source: frontend/node_modules/postcss/lib/lazy-result.js

Last change on this file was 9af201e, checked in by MBK <marija.karapandzova@…>, 12 days ago

Fix frontend appearance
  • Property mode set to 100644
File size: 13.5 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 rootSource = this.result.root.source
382 if (
383 opts.map === undefined &&
384 !(rootSource && rootSource.input && rootSource.input.map)
385 ) {
386 let result = ''
387 str(this.result.root, i => {
388 result += i
389 })
390 this.result.css = result
391 return this.result
392 }
393
394 let map = new MapGenerator(str, this.result.root, this.result.opts)
395 let data = map.generate()
396 this.result.css = data[0]
397 this.result.map = data[1]
398
399 return this.result
400 }
401
402 sync() {
403 if (this.error) throw this.error
404 if (this.processed) return this.result
405 this.processed = true
406
407 if (this.processing) {
408 throw this.getAsyncError()
409 }
410
411 for (let plugin of this.plugins) {
412 let promise = this.runOnRoot(plugin)
413 if (isPromise(promise)) {
414 throw this.getAsyncError()
415 }
416 }
417
418 this.prepareVisitors()
419 if (this.hasListener) {
420 let root = this.result.root
421 while (!root[isClean]) {
422 root[isClean] = true
423 this.walkSync(root)
424 }
425 if (this.listeners.OnceExit) {
426 if (root.type === 'document') {
427 for (let subRoot of root.nodes) {
428 this.visitSync(this.listeners.OnceExit, subRoot)
429 }
430 } else {
431 this.visitSync(this.listeners.OnceExit, root)
432 }
433 }
434 }
435
436 return this.result
437 }
438
439 then(onFulfilled, onRejected) {
440 if (process.env.NODE_ENV !== 'production') {
441 if (!('from' in this.opts)) {
442 warnOnce(
443 'Without `from` option PostCSS could generate wrong source map ' +
444 'and will not find Browserslist config. Set it to CSS file path ' +
445 'or to `undefined` to prevent this warning.'
446 )
447 }
448 }
449 return this.async().then(onFulfilled, onRejected)
450 }
451
452 toString() {
453 return this.css
454 }
455
456 visitSync(visitors, node) {
457 for (let [plugin, visitor] of visitors) {
458 this.result.lastPlugin = plugin
459 let promise
460 try {
461 promise = visitor(node, this.helpers)
462 } catch (e) {
463 throw this.handleError(e, node.proxyOf)
464 }
465 if (node.type !== 'root' && node.type !== 'document' && !node.parent) {
466 return true
467 }
468 if (isPromise(promise)) {
469 throw this.getAsyncError()
470 }
471 }
472 }
473
474 visitTick(stack) {
475 let visit = stack[stack.length - 1]
476 let { node, visitors } = visit
477
478 if (node.type !== 'root' && node.type !== 'document' && !node.parent) {
479 stack.pop()
480 return
481 }
482
483 if (visitors.length > 0 && visit.visitorIndex < visitors.length) {
484 let [plugin, visitor] = visitors[visit.visitorIndex]
485 visit.visitorIndex += 1
486 if (visit.visitorIndex === visitors.length) {
487 visit.visitors = []
488 visit.visitorIndex = 0
489 }
490 this.result.lastPlugin = plugin
491 try {
492 return visitor(node.toProxy(), this.helpers)
493 } catch (e) {
494 throw this.handleError(e, node)
495 }
496 }
497
498 if (visit.iterator !== 0) {
499 let iterator = visit.iterator
500 let child
501 while ((child = node.nodes[node.indexes[iterator]])) {
502 node.indexes[iterator] += 1
503 if (!child[isClean]) {
504 child[isClean] = true
505 stack.push(toStack(child))
506 return
507 }
508 }
509 visit.iterator = 0
510 delete node.indexes[iterator]
511 }
512
513 let events = visit.events
514 while (visit.eventIndex < events.length) {
515 let event = events[visit.eventIndex]
516 visit.eventIndex += 1
517 if (event === CHILDREN) {
518 if (node.nodes && node.nodes.length) {
519 node[isClean] = true
520 visit.iterator = node.getIterator()
521 }
522 return
523 } else if (this.listeners[event]) {
524 visit.visitors = this.listeners[event]
525 return
526 }
527 }
528 stack.pop()
529 }
530
531 walkSync(node) {
532 node[isClean] = true
533 let events = getEvents(node)
534 for (let event of events) {
535 if (event === CHILDREN) {
536 if (node.nodes) {
537 node.each(child => {
538 if (!child[isClean]) this.walkSync(child)
539 })
540 }
541 } else {
542 let visitors = this.listeners[event]
543 if (visitors) {
544 if (this.visitSync(visitors, node.toProxy())) return
545 }
546 }
547 }
548 }
549
550 warnings() {
551 return this.sync().warnings()
552 }
553}
554
555LazyResult.registerPostcss = dependant => {
556 postcss = dependant
557}
558
559module.exports = LazyResult
560LazyResult.default = LazyResult
561
562Root.registerLazyResult(LazyResult)
563Document.registerLazyResult(LazyResult)
Note: See TracBrowser for help on using the repository browser.