create-docusaurus 0.0.0-4483 → 0.0.0-4487

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

@@ -1,85 +0,0 @@
-// @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

@@ -1,138 +0,0 @@
-# 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

@@ -1,182 +0,0 @@
-// @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

@@ -1,179 +0,0 @@
-# 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 {}
-```