node_modules/stylelint/lib/rules/selector-descendant-combinator-no-non-space/index.js

"use strict";

const isStandardSyntaxRule = require("../../utils/isStandardSyntaxRule");
const parseSelector = require("../../utils/parseSelector");
const punctuationSets = require("../../reference/punctuationSets");
const report = require("../../utils/report");
const ruleMessages = require("../../utils/ruleMessages");
const validateOptions = require("../../utils/validateOptions");

const ruleName = "selector-descendant-combinator-no-non-space";

const messages = ruleMessages(ruleName, {
  rejected: nonSpaceCharacter => `Unexpected "${nonSpaceCharacter}"`
});

const rule = function(expectation, options, context) {
  return (root, result) => {
    const validOptions = validateOptions(result, ruleName, {
      actual: expectation
    });

    if (!validOptions) {
      return;
    }

    root.walkRules(rule => {
      if (!isStandardSyntaxRule(rule)) {
        return;
      }

      let hasFixed = false;
      const selector = rule.raws.selector
        ? rule.raws.selector.raw
        : rule.selector;

      const fixedSelector = parseSelector(
        selector,
        result,
        rule,
        fullSelector => {
          fullSelector.walkCombinators(combinatorNode => {
            if (!isActuallyCombinator(combinatorNode)) {
              return;
            }

            const value = combinatorNode.value;

            if (punctuationSets.nonSpaceCombinators.has(value)) {
              return;
            }

            if (
              value.includes("  ") ||
              value.includes("\t") ||
              value.includes("\n") ||
              value.includes("\r")
            ) {
              if (context.fix && /^\s+$/.test(value)) {
                hasFixed = true;
                combinatorNode.value = " ";

                return;
              }

              report({
                result,
                ruleName,
                message: messages.rejected(value),
                node: rule,
                index: combinatorNode.sourceIndex
              });
            }
          });
        }
      );

      if (hasFixed) {
        if (!rule.raws.selector) {
          rule.selector = fixedSelector;
        } else {
          rule.raws.selector.raw = fixedSelector;
        }
      }
    });
  };
};

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

/**
 * Check whether is actually a combinator.
 * @param {Node} combinatorNode The combinator node
 * @returns {boolean} `true` if is actually a combinator.
 */
function isActuallyCombinator(combinatorNode) {
  // `.foo  /*comment*/, .bar`
  //      ^^
  // If include comments, this spaces is a combinator, but it is not combinators.
  if (!/^\s+$/.test(combinatorNode.value)) {
    return true;
  }

  let next = combinatorNode.next();

  while (skipTest(next)) {
    next = next.next();
  }

  if (isNonTarget(next)) {
    return false;
  }

  let prev = combinatorNode.prev();

  while (skipTest(prev)) {
    prev = prev.prev();
  }

  if (isNonTarget(prev)) {
    return false;
  }

  return true;

  function skipTest(node) {
    if (!node) {
      return false;
    }

    if (node.type === "comment") {
      return true;
    }

    if (node.type === "combinator" && /^\s+$/.test(node.value)) {
      return true;
    }

    return false;
  }

  function isNonTarget(node) {
    if (!node) {
      return true;
    }

    if (node.type === "combinator" && !/^\s+$/.test(node.value)) {
      return true;
    }

    return false;
  }
}