create-docusaurus 0.0.0-4378 → 0.0.0-4379

package/templates/facebook/node_modules/stylelint/lib/rules/selector-max-pseudo-class/index.js

@@ -0,0 +1,85 @@
+// @ts-nocheck
+
+'use strict';
+
+const isContextFunctionalPseudoClass = require('../../utils/isContextFunctionalPseudoClass');
+const isNonNegativeInteger = require('../../utils/isNonNegativeInteger');
+const isStandardSyntaxRule = require('../../utils/isStandardSyntaxRule');
+const keywordSets = require('../../reference/keywordSets');
+const parseSelector = require('../../utils/parseSelector');
+const report = require('../../utils/report');
+const resolvedNestedSelector = require('postcss-resolve-nested-selector');
+const ruleMessages = require('../../utils/ruleMessages');
+const validateOptions = require('../../utils/validateOptions');
+
+const ruleName = 'selector-max-pseudo-class';
+
+const messages = ruleMessages(ruleName, {
+	expected: (selector, max) =>
+		`Expected "${selector}" to have no more than ${max} pseudo-${max === 1 ? 'class' : 'classes'}`,
+});
+
+function rule(max) {
+	return (root, result) => {
+		const validOptions = validateOptions(result, ruleName, {
+			actual: max,
+			possible: isNonNegativeInteger,
+		});
+
+		if (!validOptions) {
+			return;
+		}
+
+		function checkSelector(selectorNode, ruleNode) {
+			const count = selectorNode.reduce((total, childNode) => {
+				// Only traverse inside actual selectors and context functional pseudo-classes
+				if (childNode.type === 'selector' || isContextFunctionalPseudoClass(childNode)) {
+					checkSelector(childNode, ruleNode);
+				}
+
+				// Exclude pseudo elements from the count
+				if (
+					childNode.type === 'pseudo' &&
+					(childNode.value.includes('::') ||
+						keywordSets.levelOneAndTwoPseudoElements.has(childNode.value.toLowerCase().slice(1)))
+				) {
+					return total;
+				}
+
+				if (childNode.type === 'pseudo') {
+					return (total += 1);
+				}
+
+				return total;
+			}, 0);
+
+			if (count > max) {
+				report({
+					ruleName,
+					result,
+					node: ruleNode,
+					message: messages.expected(selectorNode, max),
+					word: selectorNode,
+				});
+			}
+		}
+
+		root.walkRules((ruleNode) => {
+			if (!isStandardSyntaxRule(ruleNode)) {
+				return;
+			}
+
+			ruleNode.selectors.forEach((selector) => {
+				resolvedNestedSelector(selector, ruleNode).forEach((resolvedSelector) => {
+					parseSelector(resolvedSelector, result, rule, (selectorTree) => {
+						checkSelector(selectorTree, ruleNode);
+					});
+				});
+			});
+		});
+	};
+}
+
+rule.ruleName = ruleName;
+rule.messages = messages;
+module.exports = rule;

package/templates/facebook/node_modules/stylelint/lib/rules/selector-max-specificity/README.md

@@ -0,0 +1,138 @@
+# selector-max-specificity
+
+Limit the specificity of selectors.
+
+<!-- prettier-ignore -->
+```css
+    .foo, #bar.baz span, #hoo { color: pink; }
+/** ↑     ↑              ↑
+ * Each of these selectors */
+```
+
+Visit the [Specificity Calculator](https://specificity.keegan.st) for visual representation of selector specificity.
+
+This rule ignores selectors with variable interpolation (`#{$var}`, `@{var}`, `$(var)`).
+
+This rule resolves nested selectors before counting the specificity of a selector. Each selector in a [selector list](https://www.w3.org/TR/selectors4/#selector-list) is evaluated separately.
+
+## Options
+
+`string`: Maximum specificity allowed.
+
+Format is `"id,class,type"`, as laid out in the [W3C selector spec](https://drafts.csswg.org/selectors/#specificity-rules).
+
+For example, with `"0,2,0"`:
+
+The following patterns are considered violations:
+
+<!-- prettier-ignore -->
+```css
+#foo {}
+```
+
+<!-- prettier-ignore -->
+```css
+.foo .baz .bar {}
+```
+
+<!-- prettier-ignore -->
+```css
+.foo .baz {
+  & .bar {}
+}
+```
+
+<!-- prettier-ignore -->
+```css
+.foo {
+  color: red;
+  @nest .baz .bar & {
+    color: blue;
+  }
+}
+```
+
+The following patterns are _not_ considered violations:
+
+<!-- prettier-ignore -->
+```css
+div {}
+```
+
+<!-- prettier-ignore -->
+```css
+.foo div {}
+```
+
+<!-- prettier-ignore -->
+```css
+.foo div {
+  & div a {}
+}
+```
+
+<!-- prettier-ignore -->
+```css
+.foo {
+  & .baz {}
+}
+```
+
+<!-- prettier-ignore -->
+```css
+.foo {
+  color: red;
+  @nest .baz & {
+    color: blue;
+  }
+}
+```
+
+## Optional secondary options
+
+### `ignoreSelectors: ["/regex/", /regex/, "string"]`
+
+Given:
+
+```
+[
+  "0,2,0",
+  {
+    ignoreSelectors: [":global", ":local", "/my-/"]
+  }
+]
+```
+
+The following patterns are _not_ considered violations:
+
+<!-- prettier-ignore -->
+```css
+:global(.foo) .bar {}
+```
+
+<!-- prettier-ignore -->
+```css
+:local(.foo.bar)
+```
+
+<!-- prettier-ignore -->
+```css
+:local(.foo, :global(.bar).baz)
+```
+
+The following patterns are considered violations:
+
+<!-- prettier-ignore -->
+```css
+:global(.foo) .bar.baz {}
+```
+
+<!-- prettier-ignore -->
+```css
+:local(.foo.bar.baz)
+```
+
+<!-- prettier-ignore -->
+```css
+:local(.foo, :global(.bar), .foo.bar.baz)
+```

package/templates/facebook/node_modules/stylelint/lib/rules/selector-max-specificity/index.js

@@ -0,0 +1,182 @@
+// @ts-nocheck
+
+'use strict';
+
+const _ = require('lodash');
+const isStandardSyntaxRule = require('../../utils/isStandardSyntaxRule');
+const isStandardSyntaxSelector = require('../../utils/isStandardSyntaxSelector');
+const keywordSets = require('../../reference/keywordSets');
+const optionsMatches = require('../../utils/optionsMatches');
+const parseSelector = require('../../utils/parseSelector');
+const report = require('../../utils/report');
+const resolvedNestedSelector = require('postcss-resolve-nested-selector');
+const ruleMessages = require('../../utils/ruleMessages');
+const specificity = require('specificity');
+const validateOptions = require('../../utils/validateOptions');
+
+const ruleName = 'selector-max-specificity';
+
+const messages = ruleMessages(ruleName, {
+	expected: (selector, max) => `Expected "${selector}" to have a specificity no more than "${max}"`,
+});
+
+// Return an array representation of zero specificity. We need a new array each time so that it can mutated
+const zeroSpecificity = () => [0, 0, 0, 0];
+
+// Calculate the sum of given array of specificity arrays
+const specificitySum = (specificities) => {
+	const sum = zeroSpecificity();
+
+	specificities.forEach((specificityArray) => {
+		specificityArray.forEach((value, i) => {
+			sum[i] += value;
+		});
+	});
+
+	return sum;
+};
+
+function rule(max, options) {
+	return (root, result) => {
+		const validOptions = validateOptions(
+			result,
+			ruleName,
+			{
+				actual: max,
+				possible: [
+					// Check that the max specificity is in the form "a,b,c"
+					(spec) => /^\d+,\d+,\d+$/.test(spec),
+				],
+			},
+			{
+				actual: options,
+				possible: {
+					ignoreSelectors: [_.isString, _.isRegExp],
+				},
+				optional: true,
+			},
+		);
+
+		if (!validOptions) {
+			return;
+		}
+
+		// Calculate the specificity of a simple selector (type, attribute, class, ID, or pseudos's own value)
+		const simpleSpecificity = (selector) => {
+			if (optionsMatches(options, 'ignoreSelectors', selector)) {
+				return zeroSpecificity();
+			}
+
+			return specificity.calculate(selector)[0].specificityArray;
+		};
+
+		// Calculate the the specificity of the most specific direct child
+		const maxChildSpecificity = (node) =>
+			node.reduce((maxSpec, child) => {
+				const childSpecificity = nodeSpecificity(child); // eslint-disable-line no-use-before-define
+
+				return specificity.compare(childSpecificity, maxSpec) === 1 ? childSpecificity : maxSpec;
+			}, zeroSpecificity());
+
+		// Calculate the specificity of a pseudo selector including own value and children
+		const pseudoSpecificity = (node) => {
+			// `node.toString()` includes children which should be processed separately,
+			// so use `node.value` instead
+			const ownValue = node.value;
+			const ownSpecificity =
+				ownValue === ':not' || ownValue === ':matches'
+					? // :not and :matches don't add specificity themselves, but their children do
+					  zeroSpecificity()
+					: simpleSpecificity(ownValue);
+
+			return specificitySum([ownSpecificity, maxChildSpecificity(node)]);
+		};
+
+		const shouldSkipPseudoClassArgument = (node) => {
+			// postcss-selector-parser includes the arguments to nth-child() functions
+			// as "tags", so we need to ignore them ourselves.
+			// The fake-tag's "parent" is actually a selector node, whose parent
+			// should be the :nth-child pseudo node.
+			const parentNode = node.parent.parent;
+
+			if (parentNode && parentNode.value) {
+				const parentNodeValue = parentNode.value;
+				const normalisedParentNode = parentNodeValue.toLowerCase().replace(/:+/, '');
+
+				return (
+					parentNode.type === 'pseudo' &&
+					(keywordSets.aNPlusBNotationPseudoClasses.has(normalisedParentNode) ||
+						keywordSets.linguisticPseudoClasses.has(normalisedParentNode))
+				);
+			}
+
+			return false;
+		};
+
+		// Calculate the specificity of a node parsed by `postcss-selector-parser`
+		const nodeSpecificity = (node) => {
+			if (shouldSkipPseudoClassArgument(node)) {
+				return zeroSpecificity();
+			}
+
+			switch (node.type) {
+				case 'attribute':
+				case 'class':
+				case 'id':
+				case 'tag':
+					return simpleSpecificity(node.toString());
+				case 'pseudo':
+					return pseudoSpecificity(node);
+				case 'selector':
+					// Calculate the sum of all the direct children
+					return specificitySum(node.map(nodeSpecificity));
+				default:
+					return zeroSpecificity();
+			}
+		};
+
+		const maxSpecificityArray = `0,${max}`.split(',').map(parseFloat);
+
+		root.walkRules((ruleNode) => {
+			if (!isStandardSyntaxRule(ruleNode)) {
+				return;
+			}
+
+			// Using `.selectors` gets us each selector in the eventuality we have a comma separated set
+			ruleNode.selectors.forEach((selector) => {
+				resolvedNestedSelector(selector, ruleNode).forEach((resolvedSelector) => {
+					try {
+						// Skip non-standard syntax selectors
+						if (!isStandardSyntaxSelector(resolvedSelector)) {
+							return;
+						}
+
+						parseSelector(resolvedSelector, result, ruleNode, (selectorTree) => {
+							// Check if the selector specificity exceeds the allowed maximum
+							if (
+								specificity.compare(maxChildSpecificity(selectorTree), maxSpecificityArray) === 1
+							) {
+								report({
+									ruleName,
+									result,
+									node: ruleNode,
+									message: messages.expected(resolvedSelector, max),
+									word: selector,
+								});
+							}
+						});
+					} catch {
+						result.warn('Cannot parse selector', {
+							node: ruleNode,
+							stylelintType: 'parseError',
+						});
+					}
+				});
+			});
+		});
+	};
+}
+
+rule.ruleName = ruleName;
+rule.messages = messages;
+module.exports = rule;

package/templates/facebook/node_modules/stylelint/lib/rules/selector-max-type/README.md

@@ -0,0 +1,179 @@
+# selector-max-type
+
+Limit the number of type selectors in a selector.
+
+<!-- prettier-ignore -->
+```css
+    a {}
+/** ↑
+ * This type of selector */
+```
+
+This rule resolves nested selectors before counting the number of type selectors. Each selector in a [selector list](https://www.w3.org/TR/selectors4/#selector-list) is evaluated separately.
+
+The `:not()` pseudo-class is also evaluated separately. The rule processes the argument as if it were an independent selector, and the result does not count toward the total for the entire selector.
+
+## Options
+
+`int`: Maximum type selectors allowed.
+
+For example, with `2`:
+
+The following patterns are considered violations:
+
+<!-- prettier-ignore -->
+```css
+div a span {}
+```
+
+<!-- prettier-ignore -->
+```css
+div a {
+  & span {}
+}
+```
+
+<!-- prettier-ignore -->
+```css
+div a {
+  & > a {}
+}
+```
+
+The following patterns are _not_ considered violations:
+
+<!-- prettier-ignore -->
+```css
+div {}
+```
+
+<!-- prettier-ignore -->
+```css
+div a {}
+```
+
+<!-- prettier-ignore -->
+```css
+.foo div a {}
+```
+
+<!-- prettier-ignore -->
+```css
+div.foo a {}
+```
+
+<!-- prettier-ignore -->
+```css
+/* each selector in a selector list is evaluated separately */
+div,
+a span {}
+```
+
+<!-- prettier-ignore -->
+```css
+/* `span` is inside `:not()`, so it is evaluated separately */
+div a .foo:not(span) {}
+```
+
+## Optional secondary options
+
+### `ignore: ["child", "compounded", "descendant", "next-sibling"]`
+
+#### `"child"`
+
+Discount child type selectors.
+
+For example, with `2`:
+
+The following patterns are _not_ considered violations:
+
+<!-- prettier-ignore -->
+```css
+div span > a {}
+```
+
+<!-- prettier-ignore -->
+```css
+#bar div span > a {}
+```
+
+#### `"compounded"`
+
+Discount compounded type selectors -- i.e. type selectors chained with other selectors.
+
+For example, with `2`:
+
+The following patterns are _not_ considered violations:
+
+<!-- prettier-ignore -->
+```css
+div span a.foo {}
+```
+
+<!-- prettier-ignore -->
+```css
+div span a#bar {}
+```
+
+#### `"descendant"`
+
+Discount descendant type selectors.
+
+For example, with `2`:
+
+The following patterns are _not_ considered violations:
+
+<!-- prettier-ignore -->
+```css
+.foo div span a {}
+```
+
+<!-- prettier-ignore -->
+```css
+#bar div span a {}
+```
+
+#### `"next-sibling"`
+
+Discount next-sibling type selectors.
+
+For example, with `2`:
+
+The following patterns are _not_ considered violations:
+
+<!-- prettier-ignore -->
+```css
+div a + span {}
+```
+
+<!-- prettier-ignore -->
+```css
+#bar + div + span + a + span {}
+```
+
+### `ignoreTypes: ["/regex/", /regex/, "string"]`
+
+Given:
+
+```
+["/^my-/", "custom"]
+```
+
+For example, with `2`.
+
+The following patterns are _not_ considered violations:
+
+<!-- prettier-ignore -->
+```css
+div a custom {}
+```
+
+<!-- prettier-ignore -->
+```css
+div a my-type {}
+```
+
+<!-- prettier-ignore -->
+```css
+div a my-other-type {}
+```