source: node_modules/postcss/lib/lazy-result.js@ 2058e5c

Last change on this file since 2058e5c was 2058e5c, checked in by istevanoska <ilinastevanoska@…>, 6 months ago

Working / before login
  • Property mode set to 100644
File size: 13.2 KB
Line 
1'use strict'
2
3let Container = require('./container')
4let Document = require('./document')
5let MapGenerator = require('./map-generator')
6let parse = require('./parse')
7let Result = require('./result')
8let Root = require('./root')
9let stringify = require('./stringify')
10let { isClean, my } = require('./symbols')
11let warnOnce = require('./warn-once')
12
13const TYPE_TO_CLASS_NAME = {
14 atrule: 'AtRule',
15 comment: 'Comment',
16 decl: 'Declaration',
17 document: 'Document',
18 root: 'Root',
19 rule: 'Rule'
20}
21
22const PLUGIN_PROPS = {
23 AtRule: true,
24 AtRuleExit: true,
25 Comment: true,
26 CommentExit: true,
27 Declaration: true,
28 DeclarationExit: true,
29 Document: true,
30 DocumentExit: true,
31 Once: true,
32 OnceExit: true,
33 postcssPlugin: true,
34 prepare: true,
35 Root: true,
36 RootExit: true,
37 Rule: true,
38 RuleExit: true
39}
40
41const NOT_VISITORS = {
42 Once: true,
43 postcssPlugin: true,
44 prepare: true
45}
46
47const CHILDREN = 0
48
49function isPromise(obj) {
50 return typeof obj === 'object' && typeof obj.then === 'function'
51}
52
53function getEvents(node) {
54 let key = false
55 let type = TYPE_TO_CLASS_NAME[node.type]
56 if (node.type === 'decl') {
57 key = node.prop.toLowerCase()
58 } else if (node.type === 'atrule') {
59 key = node.name.toLowerCase()
60 }
61
62 if (key && node.append) {
63 return [
64 type,
65 type + '-' + key,
66 CHILDREN,
67 type + 'Exit',
68 type + 'Exit-' + key
69 ]
70 } else if (key) {
71 return [type, type + '-' + key, type + 'Exit', type + 'Exit-' + key]
72 } else if (node.append) {
73 return [type, CHILDREN, type + 'Exit']
74 } else {
75 return [type, type + 'Exit']
76 }
77}
78
79function toStack(node) {
80 let events
81 if (node.type === 'document') {
82 events = ['Document', CHILDREN, 'DocumentExit']
83 } else if (node.type === 'root') {
84 events = ['Root', CHILDREN, 'RootExit']
85 } else {
86 events = getEvents(node)
87 }
88
89 return {
90 eventIndex: 0,
91 events,
92 iterator: 0,
93 node,
94 visitorIndex: 0,
95 visitors: []
96 }
97}
98
99function cleanMarks(node) {
100 node[isClean] = false
101 if (node.nodes) node.nodes.forEach(i => cleanMarks(i))
102 return node
103}
104
105let postcss = {}
106
107class LazyResult {
108 get content() {
109 return this.stringify().content
110 }
111
112 get css() {
113 return this.stringify().css
114 }
115
116 get map() {
117 return this.stringify().map
118 }
119
120 get messages() {
121 return this.sync().messages
122 }
123
124 get opts() {
125 return this.result.opts
126 }
127
128 get processor() {
129 return this.result.processor
130 }
131
132 get root() {
133 return this.sync().root
134 }
135
136 get [Symbol.toStringTag]() {
137 return 'LazyResult'
138 }
139
140 constructor(processor, css, opts) {
141 this.stringified = false
142 this.processed = false
143
144 let root
145 if (
146 typeof css === 'object' &&
147 css !== null &&
148 (css.type === 'root' || css.type === 'document')
149 ) {
150 root = cleanMarks(css)
151 } else if (css instanceof LazyResult || css instanceof Result) {
152 root = cleanMarks(css.root)
153 if (css.map) {
154 if (typeof opts.map === 'undefined') opts.map = {}
155 if (!opts.map.inline) opts.map.inline = false
156 opts.map.prev = css.map
157 }
158 } else {
159 let parser = parse
160 if (opts.syntax) parser = opts.syntax.parse
161 if (opts.parser) parser = opts.parser
162 if (parser.parse) parser = parser.parse
163
164 try {
165 root = parser(css, opts)
166 } catch (error) {
167 this.processed = true
168 this.error = error
169 }
170
171 if (root && !root[my]) {
172 /* c8 ignore next 2 */
173 Container.rebuild(root)
174 }
175 }
176
177 this.result = new Result(processor, root, opts)
178 this.helpers = { ...postcss, postcss, result: this.result }
179 this.plugins = this.processor.plugins.map(plugin => {
180 if (typeof plugin === 'object' && plugin.prepare) {
181 return { ...plugin, ...plugin.prepare(this.result) }
182 } else {
183 return plugin
184 }
185 })
186 }
187
188 async() {
189 if (this.error) return Promise.reject(this.error)
190 if (this.processed) return Promise.resolve(this.result)
191 if (!this.processing) {
192 this.processing = this.runAsync()
193 }
194 return this.processing
195 }
196
197 catch(onRejected) {
198 return this.async().catch(onRejected)
199 }
200
201 finally(onFinally) {
202 return this.async().then(onFinally, onFinally)
203 }
204
205 getAsyncError() {
206 throw new Error('Use process(css).then(cb) to work with async plugins')
207 }
208
209 handleError(error, node) {
210 let plugin = this.result.lastPlugin
211 try {
212 if (node) node.addToError(error)
213 this.error = error
214 if (error.name === 'CssSyntaxError' && !error.plugin) {
215 error.plugin = plugin.postcssPlugin
216 error.setMessage()
217 } else if (plugin.postcssVersion) {
218 if (process.env.NODE_ENV !== 'production') {
219 let pluginName = plugin.postcssPlugin
220 let pluginVer = plugin.postcssVersion
221 let runtimeVer = this.result.processor.version
222 let a = pluginVer.split('.')
223 let b = runtimeVer.split('.')
224
225 if (a[0] !== b[0] || parseInt(a[1]) > parseInt(b[1])) {
226 // eslint-disable-next-line no-console
227 console.error(
228 'Unknown error from PostCSS plugin. Your current PostCSS ' +
229 'version is ' +
230 runtimeVer +
231 ', but ' +
232 pluginName +
233 ' uses ' +
234 pluginVer +
235 '. Perhaps this is the source of the error below.'
236 )
237 }
238 }
239 }
240 } catch (err) {
241 /* c8 ignore next 3 */
242 // eslint-disable-next-line no-console
243 if (console && console.error) console.error(err)
244 }
245 return error
246 }
247
248 prepareVisitors() {
249 this.listeners = {}
250 let add = (plugin, type, cb) => {
251 if (!this.listeners[type]) this.listeners[type] = []
252 this.listeners[type].push([plugin, cb])
253 }
254 for (let plugin of this.plugins) {
255 if (typeof plugin === 'object') {
256 for (let event in plugin) {
257 if (!PLUGIN_PROPS[event] && /^[A-Z]/.test(event)) {
258 throw new Error(
259 `Unknown event ${event} in ${plugin.postcssPlugin}. ` +
260 `Try to update PostCSS (${this.processor.version} now).`
261 )
262 }
263 if (!NOT_VISITORS[event]) {
264 if (typeof plugin[event] === 'object') {
265 for (let filter in plugin[event]) {
266 if (filter === '*') {
267 add(plugin, event, plugin[event][filter])
268 } else {
269 add(
270 plugin,
271 event + '-' + filter.toLowerCase(),
272 plugin[event][filter]
273 )
274 }
275 }
276 } else if (typeof plugin[event] === 'function') {
277 add(plugin, event, plugin[event])
278 }
279 }
280 }
281 }
282 }
283 this.hasListener = Object.keys(this.listeners).length > 0
284 }
285
286 async runAsync() {
287 this.plugin = 0
288 for (let i = 0; i < this.plugins.length; i++) {
289 let plugin = this.plugins[i]
290 let promise = this.runOnRoot(plugin)
291 if (isPromise(promise)) {
292 try {
293 await promise
294 } catch (error) {
295 throw this.handleError(error)
296 }
297 }
298 }
299
300 this.prepareVisitors()
301 if (this.hasListener) {
302 let root = this.result.root
303 while (!root[isClean]) {
304 root[isClean] = true
305 let stack = [toStack(root)]
306 while (stack.length > 0) {
307 let promise = this.visitTick(stack)
308 if (isPromise(promise)) {
309 try {
310 await promise
311 } catch (e) {
312 let node = stack[stack.length - 1].node
313 throw this.handleError(e, node)
314 }
315 }
316 }
317 }
318
319 if (this.listeners.OnceExit) {
320 for (let [plugin, visitor] of this.listeners.OnceExit) {
321 this.result.lastPlugin = plugin
322 try {
323 if (root.type === 'document') {
324 let roots = root.nodes.map(subRoot =>
325 visitor(subRoot, this.helpers)
326 )
327
328 await Promise.all(roots)
329 } else {
330 await visitor(root, this.helpers)
331 }
332 } catch (e) {
333 throw this.handleError(e)
334 }
335 }
336 }
337 }
338
339 this.processed = true
340 return this.stringify()
341 }
342
343 runOnRoot(plugin) {
344 this.result.lastPlugin = plugin
345 try {
346 if (typeof plugin === 'object' && plugin.Once) {
347 if (this.result.root.type === 'document') {
348 let roots = this.result.root.nodes.map(root =>
349 plugin.Once(root, this.helpers)
350 )
351
352 if (isPromise(roots[0])) {
353 return Promise.all(roots)
354 }
355
356 return roots
357 }
358
359 return plugin.Once(this.result.root, this.helpers)
360 } else if (typeof plugin === 'function') {
361 return plugin(this.result.root, this.result)
362 }
363 } catch (error) {
364 throw this.handleError(error)
365 }
366 }
367
368 stringify() {
369 if (this.error) throw this.error
370 if (this.stringified) return this.result
371 this.stringified = true
372
373 this.sync()
374
375 let opts = this.result.opts
376 let str = stringify
377 if (opts.syntax) str = opts.syntax.stringify
378 if (opts.stringifier) str = opts.stringifier
379 if (str.stringify) str = str.stringify
380
381 let map = new MapGenerator(str, this.result.root, this.result.opts)
382 let data = map.generate()
383 this.result.css = data[0]
384 this.result.map = data[1]
385
386 return this.result
387 }
388
389 sync() {
390 if (this.error) throw this.error
391 if (this.processed) return this.result
392 this.processed = true
393
394 if (this.processing) {
395 throw this.getAsyncError()
396 }
397
398 for (let plugin of this.plugins) {
399 let promise = this.runOnRoot(plugin)
400 if (isPromise(promise)) {
401 throw this.getAsyncError()
402 }
403 }
404
405 this.prepareVisitors()
406 if (this.hasListener) {
407 let root = this.result.root
408 while (!root[isClean]) {
409 root[isClean] = true
410 this.walkSync(root)
411 }
412 if (this.listeners.OnceExit) {
413 if (root.type === 'document') {
414 for (let subRoot of root.nodes) {
415 this.visitSync(this.listeners.OnceExit, subRoot)
416 }
417 } else {
418 this.visitSync(this.listeners.OnceExit, root)
419 }
420 }
421 }
422
423 return this.result
424 }
425
426 then(onFulfilled, onRejected) {
427 if (process.env.NODE_ENV !== 'production') {
428 if (!('from' in this.opts)) {
429 warnOnce(
430 'Without `from` option PostCSS could generate wrong source map ' +
431 'and will not find Browserslist config. Set it to CSS file path ' +
432 'or to `undefined` to prevent this warning.'
433 )
434 }
435 }
436 return this.async().then(onFulfilled, onRejected)
437 }
438
439 toString() {
440 return this.css
441 }
442
443 visitSync(visitors, node) {
444 for (let [plugin, visitor] of visitors) {
445 this.result.lastPlugin = plugin
446 let promise
447 try {
448 promise = visitor(node, this.helpers)
449 } catch (e) {
450 throw this.handleError(e, node.proxyOf)
451 }
452 if (node.type !== 'root' && node.type !== 'document' && !node.parent) {
453 return true
454 }
455 if (isPromise(promise)) {
456 throw this.getAsyncError()
457 }
458 }
459 }
460
461 visitTick(stack) {
462 let visit = stack[stack.length - 1]
463 let { node, visitors } = visit
464
465 if (node.type !== 'root' && node.type !== 'document' && !node.parent) {
466 stack.pop()
467 return
468 }
469
470 if (visitors.length > 0 && visit.visitorIndex < visitors.length) {
471 let [plugin, visitor] = visitors[visit.visitorIndex]
472 visit.visitorIndex += 1
473 if (visit.visitorIndex === visitors.length) {
474 visit.visitors = []
475 visit.visitorIndex = 0
476 }
477 this.result.lastPlugin = plugin
478 try {
479 return visitor(node.toProxy(), this.helpers)
480 } catch (e) {
481 throw this.handleError(e, node)
482 }
483 }
484
485 if (visit.iterator !== 0) {
486 let iterator = visit.iterator
487 let child
488 while ((child = node.nodes[node.indexes[iterator]])) {
489 node.indexes[iterator] += 1
490 if (!child[isClean]) {
491 child[isClean] = true
492 stack.push(toStack(child))
493 return
494 }
495 }
496 visit.iterator = 0
497 delete node.indexes[iterator]
498 }
499
500 let events = visit.events
501 while (visit.eventIndex < events.length) {
502 let event = events[visit.eventIndex]
503 visit.eventIndex += 1
504 if (event === CHILDREN) {
505 if (node.nodes && node.nodes.length) {
506 node[isClean] = true
507 visit.iterator = node.getIterator()
508 }
509 return
510 } else if (this.listeners[event]) {
511 visit.visitors = this.listeners[event]
512 return
513 }
514 }
515 stack.pop()
516 }
517
518 walkSync(node) {
519 node[isClean] = true
520 let events = getEvents(node)
521 for (let event of events) {
522 if (event === CHILDREN) {
523 if (node.nodes) {
524 node.each(child => {
525 if (!child[isClean]) this.walkSync(child)
526 })
527 }
528 } else {
529 let visitors = this.listeners[event]
530 if (visitors) {
531 if (this.visitSync(visitors, node.toProxy())) return
532 }
533 }
534 }
535 }
536
537 warnings() {
538 return this.sync().warnings()
539 }
540}
541
542LazyResult.registerPostcss = dependant => {
543 postcss = dependant
544}
545
546module.exports = LazyResult
547LazyResult.default = LazyResult
548
549Root.registerLazyResult(LazyResult)
550Document.registerLazyResult(LazyResult)
Note: See TracBrowser for help on using the repository browser.