Initial commit

node_modules/stylelint/lib/rules/declaration-block-no-duplicate-properties/index.js

@@ -0,0 +1,135 @@
+"use strict"
+
+const _ = require("lodash")
+const isCustomProperty = require("../../utils/isCustomProperty")
+const isStandardSyntaxProperty = require("../../utils/isStandardSyntaxProperty")
+const optionsMatches = require("../../utils/optionsMatches")
+const report = require("../../utils/report")
+const ruleMessages = require("../../utils/ruleMessages")
+const validateOptions = require("../../utils/validateOptions")
+
+const ruleName = "declaration-block-no-duplicate-properties"
+
+const messages = ruleMessages(ruleName, {
+  rejected: property => `Unexpected duplicate "${property}"`,
+})
+
+const rule = function (on, options) {
+  return (root, result) => {
+    const validOptions = validateOptions(result, ruleName, { actual: on }, {
+      actual: options,
+      possible: {
+        ignore: [
+          "consecutive-duplicates",
+          "consecutive-duplicates-with-different-values",
+        ],
+        ignoreProperties: [_.isString],
+      },
+      optional: true,
+    })
+    if (!validOptions) {
+      return
+    }
+
+    // In order to accommodate nested blocks (postcss-nested),
+    // we need to run a shallow loop (instead of eachDecl() or eachRule(),
+    // which loop recursively) and allow each nested block to accumulate
+    // its own list of properties -- so that a property in a nested rule
+    // does not conflict with the same property in the parent rule
+    root.each(node => {
+      if (
+        node.type === "rule"
+        || node.type === "atrule"
+      ) {
+        checkRulesInNode(node)
+      }
+    })
+
+    function checkRulesInNode(node) {
+      const decls = []
+      const values = []
+
+      node.each(child => {
+        if (
+          child.nodes
+          && child.nodes.length
+        ) {
+          checkRulesInNode(child)
+        }
+
+        if (child.type !== "decl") {
+          return
+        }
+
+        const prop = child.prop
+        const value = child.value
+
+        if (!isStandardSyntaxProperty(prop)) {
+          return
+        }
+        if (isCustomProperty(prop)) {
+          return
+        }
+
+        // Return early if the property is to be ignored
+        if (optionsMatches(options, "ignoreProperties", prop)) {
+          return
+        }
+
+        // Ignore the src property as commonly duplicated in at-fontface
+        if (prop.toLowerCase() === "src") {
+          return
+        }
+
+        const indexDuplicate = decls.indexOf(prop.toLowerCase())
+
+        if (indexDuplicate !== -1) {
+          if (optionsMatches(options, "ignore", "consecutive-duplicates-with-different-values")) {
+            // if duplicates are not consecutive
+            if (indexDuplicate !== decls.length - 1) {
+              report({
+                message: messages.rejected(prop),
+                node: child,
+                result,
+                ruleName,
+              })
+              return
+            }
+            // if values of consecutive duplicates are equal
+            if (value === values[indexDuplicate]) {
+              report({
+                message: messages.rejected(value),
+                node: child,
+                result,
+                ruleName,
+              })
+              return
+            }
+            return
+          }
+
+          if (
+            optionsMatches(options, "ignore", "consecutive-duplicates")
+            && indexDuplicate === decls.length - 1
+          ) {
+            return
+          }
+
+          report({
+            message: messages.rejected(prop),
+            node: child,
+            result,
+            ruleName,
+          })
+        }
+
+        decls.push(prop.toLowerCase())
+        values.push(value.toLowerCase())
+      })
+    }
+  }
+}
+
+rule.ruleName = ruleName
+rule.messages = messages
+module.exports = rule