postcss 8.3.10 → 8.4.2

package/lib/no-work-result.js

@@ -0,0 +1,131 @@
+'use strict'
+
+let MapGenerator = require('./map-generator')
+let stringify = require('./stringify')
+let warnOnce = require('./warn-once')
+let parse = require('./parse')
+const Result = require('./result')
+
+class NoWorkResult {
+  constructor(processor, css, opts) {
+    this.stringified = false
+
+    this._processor = processor
+    this._css = css
+    this._opts = opts
+    this._map = undefined
+    let root
+
+    let str = stringify
+    this.result = new Result(this._processor, root, this._opts)
+    this.result.css = css
+
+    let self = this
+    Object.defineProperty(this.result, 'root', {
+      get() {
+        return self.root
+      }
+    })
+
+    let map = new MapGenerator(str, root, this._opts, css)
+    if (map.isMap()) {
+      let [generatedCSS, generatedMap] = map.generate()
+      if (generatedCSS) {
+        this.result.css = generatedCSS
+      }
+      if (generatedMap) {
+        this.result.map = generatedMap
+      }
+    }
+  }
+
+  get [Symbol.toStringTag]() {
+    return 'NoWorkResult'
+  }
+
+  get processor() {
+    return this.result.processor
+  }
+
+  get opts() {
+    return this.result.opts
+  }
+
+  get css() {
+    return this.result.css
+  }
+
+  get content() {
+    return this.result.css
+  }
+
+  get map() {
+    return this.result.map
+  }
+
+  get root() {
+    if (this._root) {
+      return this._root
+    }
+
+    let root
+    let parser = parse
+
+    try {
+      root = parser(this._css, this._opts)
+    } catch (error) {
+      this.error = error
+    }
+
+    this._root = root
+
+    return root
+  }
+
+  get messages() {
+    return []
+  }
+
+  warnings() {
+    return []
+  }
+
+  toString() {
+    return this._css
+  }
+
+  then(onFulfilled, onRejected) {
+    if (process.env.NODE_ENV !== 'production') {
+      if (!('from' in this._opts)) {
+        warnOnce(
+          'Without `from` option PostCSS could generate wrong source map ' +
+            'and will not find Browserslist config. Set it to CSS file path ' +
+            'or to `undefined` to prevent this warning.'
+        )
+      }
+    }
+
+    return this.async().then(onFulfilled, onRejected)
+  }
+
+  catch(onRejected) {
+    return this.async().catch(onRejected)
+  }
+
+  finally(onFinally) {
+    return this.async().then(onFinally, onFinally)
+  }
+
+  async() {
+    if (this.error) return Promise.reject(this.error)
+    return Promise.resolve(this.result)
+  }
+
+  sync() {
+    if (this.error) throw this.error
+    return this.result
+  }
+}
+
+module.exports = NoWorkResult
+NoWorkResult.default = NoWorkResult

package/lib/node.d.ts

@@ -38,17 +38,29 @@ export interface Position {
   line: number
 }
 
+export interface Range {
+  /**
+   * Start position, inclusive.
+   */
+  start: Position
+
+  /**
+   * End position, exclusive.
+   */
+  end: Position
+}
+
 export interface Source {
   /**
    * The file source of the node.
    */
   input: Input
   /**
-   * The starting position of the node’s source.
+   * The inclusive starting position of the node’s source.
    */
   start?: Position
   /**
-   * The ending position of the node's source.
+   * The inclusive ending position of the node's source.
    */
   end?: Position
 }
@@ -72,6 +84,11 @@ interface NodeErrorOptions {
    * of error.
    */
   index?: number
+  /**
+   * An ending index inside a node's string that should be highlighted as
+   * source of error.
+   */
+  endIndex?: number
 }
 
 /**
@@ -441,4 +458,21 @@ export default abstract class Node {
    * @return Symbol position in file.
    */
   positionInside(index: number): Position
+
+  /**
+   * Get the position for a word or an index inside the node.
+   *
+   * @param opts Options.
+   * @return Position.
+   */
+  positionBy(opts?: Pick<WarningOptions, 'word' | 'index'>): Position
+
+  /**
+   * Get the range for a word or start and end index inside the node.
+   * The start index is inclusive; the end index is exclusive.
+   *
+   * @param opts Options.
+   * @return Range.
+   */
+  rangeBy(opts?: Pick<WarningOptions, 'word' | 'index' | 'endIndex'>): Range
 }

package/lib/node.js

@@ -10,7 +10,7 @@ function cloneNode(obj, parent) {
 
   for (let i in obj) {
     if (!Object.prototype.hasOwnProperty.call(obj, i)) {
-      // istanbul ignore next
+      /* c8 ignore next 2 */
       continue
     }
     if (i === 'proxyCache') continue
@@ -56,8 +56,13 @@ class Node {
 
   error(message, opts = {}) {
     if (this.source) {
-      let pos = this.positionBy(opts)
-      return this.source.input.error(message, pos.line, pos.column, opts)
+      let { start, end } = this.rangeBy(opts)
+      return this.source.input.error(
+        message,
+        { line: start.line, column: start.column },
+        { line: end.line, column: end.column },
+        opts
+      )
     }
     return new CssSyntaxError(message)
   }
@@ -184,7 +189,7 @@ class Node {
 
     for (let name in this) {
       if (!Object.prototype.hasOwnProperty.call(this, name)) {
-        // istanbul ignore next
+        /* c8 ignore next 2 */
         continue
       }
       if (name === 'parent' || name === 'proxyCache') continue
@@ -252,6 +257,59 @@ class Node {
     return pos
   }
 
+  rangeBy(opts) {
+    let start = {
+      line: this.source.start.line,
+      column: this.source.start.column
+    }
+    let end = this.source.end
+      ? {
+          line: this.source.end.line,
+          column: this.source.end.column + 1
+        }
+      : {
+          line: start.line,
+          column: start.column + 1
+        }
+
+    if (opts.word) {
+      let index = this.toString().indexOf(opts.word)
+      if (index !== -1) {
+        start = this.positionInside(index)
+        end = this.positionInside(index + opts.word.length)
+      }
+    } else {
+      if (opts.start) {
+        start = {
+          line: opts.start.line,
+          column: opts.start.column
+        }
+      } else if (opts.index) {
+        start = this.positionInside(opts.index)
+      }
+
+      if (opts.end) {
+        end = {
+          line: opts.end.line,
+          column: opts.end.column
+        }
+      } else if (opts.endIndex) {
+        end = this.positionInside(opts.endIndex)
+      } else if (opts.index) {
+        end = this.positionInside(opts.index + 1)
+      }
+    }
+
+    if (
+      end.line < start.line ||
+      (end.line === start.line && end.column <= start.column)
+    ) {
+      end = { line: start.line, column: start.column + 1 }
+    }
+
+    return { start, end }
+  }
+
   getProxyProcessor() {
     return {
       set(node, prop, value) {
@@ -263,6 +321,7 @@ class Node {
           prop === 'name' ||
           prop === 'params' ||
           prop === 'important' ||
+          /* c8 ignore next */
           prop === 'text'
         ) {
           node.markDirty()

package/lib/parser.js

@@ -511,15 +511,27 @@ class Parser {
   // Errors
 
   unclosedBracket(bracket) {
-    throw this.input.error('Unclosed bracket', bracket[2])
+    throw this.input.error(
+      'Unclosed bracket',
+      { offset: bracket[2] },
+      { offset: bracket[2] + 1 }
+    )
   }
 
   unknownWord(tokens) {
-    throw this.input.error('Unknown word', tokens[0][2])
+    throw this.input.error(
+      'Unknown word',
+      { offset: tokens[0][2] },
+      { offset: tokens[0][2] + tokens[0][1].length }
+    )
   }
 
   unexpectedClose(token) {
-    throw this.input.error('Unexpected }', token[2])
+    throw this.input.error(
+      'Unexpected }',
+      { offset: token[2] },
+      { offset: token[2] + 1 }
+    )
   }
 
   unclosedBlock() {
@@ -528,11 +540,19 @@ class Parser {
   }
 
   doubleColon(token) {
-    throw this.input.error('Double colon', token[2])
+    throw this.input.error(
+      'Double colon',
+      { offset: token[2] },
+      { offset: token[2] + token[1].length }
+    )
   }
 
   unnamedAtrule(node, token) {
-    throw this.input.error('At-rule without name', token[2])
+    throw this.input.error(
+      'At-rule without name',
+      { offset: token[2] },
+      { offset: token[2] + token[1].length }
+    )
   }
 
   precheckMissedSemicolon(/* tokens */) {

package/lib/postcss.d.ts

@@ -10,52 +10,53 @@ import Node, {
   AnyNode
 } from './node.js'
 import Declaration, { DeclarationProps } from './declaration.js'
-import Root, { RootProps } from './root.js'
+import Container, { ContainerProps } from './container.js'
 import Document, { DocumentProps } from './document.js'
+import Warning, { WarningOptions } from './warning.js'
 import Comment, { CommentProps } from './comment.js'
 import AtRule, { AtRuleProps } from './at-rule.js'
+import Input, { FilePosition } from './input.js'
 import Result, { Message } from './result.js'
-import LazyResult from './lazy-result.js'
+import Root, { RootProps } from './root.js'
 import Rule, { RuleProps } from './rule.js'
-import Container, { ContainerProps } from './container.js'
-import Warning, { WarningOptions } from './warning.js'
-import Input, { FilePosition } from './input.js'
 import CssSyntaxError from './css-syntax-error.js'
 import list, { List } from './list.js'
+import LazyResult from './lazy-result.js'
 import Processor from './processor.js'
 
 export {
-  WarningOptions,
-  FilePosition,
-  Position,
-  Source,
-  ChildNode,
-  AnyNode,
-  Message,
   NodeErrorOptions,
-  NodeProps,
   DeclarationProps,
+  CssSyntaxError,
   ContainerProps,
+  WarningOptions,
+  DocumentProps,
+  FilePosition,
   CommentProps,
-  RuleProps,
-  ChildProps,
   AtRuleProps,
+  Declaration,
+  ChildProps,
+  LazyResult,
+  ChildNode,
+  NodeProps,
+  Processor,
+  RuleProps,
   RootProps,
-  DocumentProps,
-  Warning,
-  CssSyntaxError,
-  Node,
   Container,
-  list,
-  Declaration,
+  Position,
+  Document,
+  AnyNode,
+  Warning,
+  Message,
   Comment,
+  Source,
   AtRule,
-  Rule,
-  Root,
-  Document,
   Result,
-  LazyResult,
-  Input
+  Input,
+  Node,
+  list,
+  Rule,
+  Root
 }
 
 export type SourceMap = SourceMapGenerator & {
@@ -221,7 +222,7 @@ export type AcceptedPlugin =
     }
   | Processor
 
-export interface Parser<RootNode = Root> {
+export interface Parser<RootNode = Root | Document> {
   (
     css: string | { toString(): string },
     opts?: Pick<ProcessOptions, 'map' | 'from'>
@@ -245,7 +246,7 @@ export interface Syntax {
   /**
    * Function to generate AST by string.
    */
-  parse?: Parser<Root | Document>
+  parse?: Parser
 
   /**
    * Class to generate string by AST.
@@ -378,7 +379,7 @@ export interface Postcss {
    * root1.append(root2).toResult().css
    * ```
    */
-  parse: Parser
+  parse: Parser<Root>
 
   /**
    * Rehydrate a JSON AST (from `Node#toJSON`) back into the AST classes.
@@ -458,7 +459,7 @@ export interface Postcss {
 }
 
 export const stringify: Stringifier
-export const parse: Parser
+export const parse: Parser<Root>
 export const fromJSON: JSONHydrator
 
 export const comment: Postcss['comment']

package/lib/postcss.js

@@ -27,14 +27,17 @@ function postcss(...plugins) {
 }
 
 postcss.plugin = function plugin(name, initializer) {
+  // eslint-disable-next-line no-console
   if (console && console.warn) {
+    // eslint-disable-next-line no-console
     console.warn(
       name +
         ': postcss.plugin was deprecated. Migration guide:\n' +
         'https://evilmartians.com/chronicles/postcss-8-plugin-migration'
     )
     if (process.env.LANG && process.env.LANG.startsWith('cn')) {
-      // istanbul ignore next
+      /* c8 ignore next 7 */
+      // eslint-disable-next-line no-console
       console.warn(
         name +
           ': 里面 postcss.plugin 被弃用. 迁移指南:\n' +
@@ -79,6 +82,7 @@ postcss.document = defaults => new Document(defaults)
 postcss.CssSyntaxError = CssSyntaxError
 postcss.Declaration = Declaration
 postcss.Container = Container
+postcss.Processor = Processor
 postcss.Document = Document
 postcss.Comment = Comment
 postcss.Warning = Warning

package/lib/postcss.mjs

@@ -18,6 +18,7 @@ export const root = postcss.root
 export const CssSyntaxError = postcss.CssSyntaxError
 export const Declaration = postcss.Declaration
 export const Container = postcss.Container
+export const Processor = postcss.Processor
 export const Document = postcss.Document
 export const Comment = postcss.Comment
 export const Warning = postcss.Warning

package/lib/previous-map.js

@@ -8,7 +8,7 @@ function fromBase64(str) {
   if (Buffer) {
     return Buffer.from(str, 'base64').toString()
   } else {
-    // istanbul ignore next
+    /* c8 ignore next 2 */
     return window.atob(str)
   }
 }
@@ -48,7 +48,6 @@ class PreviousMap {
   }
 
   getAnnotationURL(sourceMapString) {
-    console.log(sourceMapString)
     return sourceMapString.replace(/^\/\*\s*# sourceMappingURL=/, '').trim()
   }
 

package/lib/processor.d.ts

@@ -8,13 +8,14 @@ import {
 import LazyResult from './lazy-result.js'
 import Result from './result.js'
 import Root from './root.js'
+import NoWorkResult from './no-work-result.js'
 
 /**
  * Contains plugins to process CSS. Create one `Processor` instance,
  * initialize its plugins, and then use that instance on numerous CSS files.
  *
  * ```js
- * const processor = postcss([autoprefixer, precss])
+ * const processor = postcss([autoprefixer, postcssNested])
  * processor.process(css1).then(result => console.log(result.css))
  * processor.process(css2).then(result => console.log(result.css))
  * ```
@@ -35,7 +36,7 @@ export default class Processor {
    * Plugins added to this processor.
    *
    * ```js
-   * const processor = postcss([autoprefixer, precss])
+   * const processor = postcss([autoprefixer, postcssNested])
    * processor.plugins.length //=> 2
    * ```
    */
@@ -67,7 +68,7 @@ export default class Processor {
    * ```js
    * const processor = postcss()
    *   .use(autoprefixer)
-   *   .use(precss)
+   *   .use(postcssNested)
    * ```
    *
    * @param plugin PostCSS plugin or `Processor` with plugins.
@@ -97,5 +98,5 @@ export default class Processor {
   process(
     css: string | { toString(): string } | Result | LazyResult | Root,
     options?: ProcessOptions
-  ): LazyResult
+  ): LazyResult | NoWorkResult
 }

package/lib/processor.js

@@ -1,12 +1,13 @@
 'use strict'
 
+let NoWorkResult = require('./no-work-result')
 let LazyResult = require('./lazy-result')
 let Document = require('./document')
 let Root = require('./root')
 
 class Processor {
   constructor(plugins = []) {
-    this.version = '8.3.10'
+    this.version = '8.4.2'
     this.plugins = this.normalize(plugins)
   }
 
@@ -20,20 +21,12 @@ class Processor {
       this.plugins.length === 0 &&
       typeof opts.parser === 'undefined' &&
       typeof opts.stringifier === 'undefined' &&
-      typeof opts.syntax === 'undefined' &&
-      !opts.hideNothingWarning
+      typeof opts.syntax === 'undefined'
     ) {
-      if (process.env.NODE_ENV !== 'production') {
-        if (typeof console !== 'undefined' && console.warn) {
-          console.warn(
-            'You did not set any plugins, parser, or stringifier. ' +
-              'Right now, PostCSS does nothing. Pick plugins for your case ' +
-              'on https://www.postcss.parts/ and use them in postcss.config.js.'
-          )
-        }
-      }
+      return new NoWorkResult(this, css, opts)
+    } else {
+      return new LazyResult(this, css, opts)
     }
-    return new LazyResult(this, css, opts)
   }
 
   normalize(plugins) {

package/lib/result.d.ts

@@ -4,6 +4,7 @@ import {
   SourceMap,
   TransformCallback,
   Root,
+  Document,
   Node,
   Warning,
   WarningOptions
@@ -94,7 +95,7 @@ export default class Result {
    * root.toResult().root === root
    * ```
    */
-  root: Root
+  root: Root | Document
 
   /**
    * Options from the `Processor#process` or `Root#toResult` call
@@ -141,7 +142,7 @@ export default class Result {
    * @param root      Root node after all transformations.
    * @param opts      Options from the `Processor#process` or `Root#toResult`.
    */
-  constructor(processor: Processor, root: Root, opts: ResultOptions)
+  constructor(processor: Processor, root: Root | Document, opts: ResultOptions)
 
   /**
    * An alias for the `Result#css` property.

package/lib/stringifier.d.ts

@@ -0,0 +1,37 @@
+import {
+  Document,
+  Root,
+  Comment,
+  Declaration,
+  Builder,
+  AnyNode,
+  Rule,
+  AtRule,
+  Container
+} from './postcss.js'
+
+export default class Stringifier {
+  builder: Builder
+  constructor(builder: Builder)
+  stringify(node: AnyNode, semicolon?: boolean): void
+  document(node: Document): void
+  root(node: Root): void
+  comment(node: Comment): void
+  decl(node: Declaration, semicolon?: boolean): void
+  rule(node: Rule): void
+  atrule(node: AtRule, semicolon?: boolean): void
+  body(node: Container): void
+  block(node: AnyNode, start: string): void
+  raw(node: AnyNode, own: string | null, detect?: string): string
+  rawSemicolon(root: Root): boolean | undefined
+  rawEmptyBody(root: Root): string | undefined
+  rawIndent(root: Root): string | undefined
+  rawBeforeComment(root: Root, node: Comment): string | undefined
+  rawBeforeDecl(root: Root, node: Declaration): string | undefined
+  rawBeforeRule(root: Root): string | undefined
+  rawBeforeClose(root: Root): string | undefined
+  rawBeforeOpen(root: Root): string | undefined
+  rawColon(root: Root): string | undefined
+  beforeAfter(node: AnyNode, detect: 'before' | 'after'): string
+  rawValue(node: AnyNode, prop: string): string
+}

package/lib/stringifier.js

@@ -25,7 +25,7 @@ class Stringifier {
   }
 
   stringify(node, semicolon) {
-    /* istanbul ignore if */
+    /* c8 ignore start */
     if (!this[node.type]) {
       throw new Error(
         'Unknown AST node type ' +
@@ -34,6 +34,7 @@ class Stringifier {
           'Maybe you need to change PostCSS stringifier.'
       )
     }
+    /* c8 ignore stop */
     this[node.type](node, semicolon)
   }
 
@@ -349,3 +350,4 @@ class Stringifier {
 }
 
 module.exports = Stringifier
+Stringifier.default = Stringifier

package/lib/warn-once.js

@@ -1,3 +1,4 @@
+/* eslint-disable no-console */
 'use strict'
 
 let printed = {}