create-docusaurus 0.0.0-4470 → 0.0.0-4485

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

@@ -1,176 +0,0 @@
-// @ts-nocheck
-
-'use strict';
-
-const _ = require('lodash');
-const isContextFunctionalPseudoClass = require('../../utils/isContextFunctionalPseudoClass');
-const isKeyframeSelector = require('../../utils/isKeyframeSelector');
-const isNonNegativeInteger = require('../../utils/isNonNegativeInteger');
-const isOnlyWhitespace = require('../../utils/isOnlyWhitespace');
-const isStandardSyntaxRule = require('../../utils/isStandardSyntaxRule');
-const isStandardSyntaxSelector = require('../../utils/isStandardSyntaxSelector');
-const isStandardSyntaxTypeSelector = require('../../utils/isStandardSyntaxTypeSelector');
-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 validateOptions = require('../../utils/validateOptions');
-
-const ruleName = 'selector-max-type';
-
-const messages = ruleMessages(ruleName, {
-	expected: (selector, max) =>
-		`Expected "${selector}" to have no more than ${max} type ${
-			max === 1 ? 'selector' : 'selectors'
-		}`,
-});
-
-function rule(max, options) {
-	return (root, result) => {
-		const validOptions = validateOptions(
-			result,
-			ruleName,
-			{
-				actual: max,
-				possible: isNonNegativeInteger,
-			},
-			{
-				actual: options,
-				possible: {
-					ignore: ['descendant', 'child', 'compounded', 'next-sibling'],
-					ignoreTypes: [_.isString, _.isRegExp],
-				},
-				optional: true,
-			},
-		);
-
-		if (!validOptions) {
-			return;
-		}
-
-		const ignoreDescendant = optionsMatches(options, 'ignore', 'descendant');
-		const ignoreChild = optionsMatches(options, 'ignore', 'child');
-		const ignoreCompounded = optionsMatches(options, 'ignore', 'compounded');
-		const ignoreNextSibling = optionsMatches(options, 'ignore', 'next-sibling');
-
-		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);
-				}
-
-				if (optionsMatches(options, 'ignoreTypes', childNode.value)) {
-					return total;
-				}
-
-				if (ignoreDescendant && hasDescendantCombinatorBefore(childNode)) {
-					return total;
-				}
-
-				if (ignoreChild && hasChildCombinatorBefore(childNode)) {
-					return total;
-				}
-
-				if (ignoreCompounded && hasCompoundSelector(childNode)) {
-					return total;
-				}
-
-				if (ignoreNextSibling && hasNextSiblingCombinator(childNode)) {
-					return total;
-				}
-
-				if (childNode.type === 'tag' && !isStandardSyntaxTypeSelector(childNode)) {
-					return total;
-				}
-
-				return total + (childNode.type === 'tag');
-			}, 0);
-
-			if (selectorNode.type !== 'root' && selectorNode.type !== 'pseudo' && count > max) {
-				report({
-					ruleName,
-					result,
-					node: ruleNode,
-					message: messages.expected(selectorNode, max),
-					word: selectorNode,
-				});
-			}
-		}
-
-		root.walkRules((ruleNode) => {
-			const selectors = ruleNode.selectors;
-
-			if (!isStandardSyntaxRule(ruleNode)) {
-				return;
-			}
-
-			if (selectors.some((s) => isKeyframeSelector(s))) {
-				return;
-			}
-
-			ruleNode.selectors.forEach((selector) => {
-				resolvedNestedSelector(selector, ruleNode).forEach((resolvedSelector) => {
-					if (!isStandardSyntaxSelector(resolvedSelector)) {
-						return;
-					}
-
-					parseSelector(resolvedSelector, result, ruleNode, (container) =>
-						checkSelector(container, ruleNode),
-					);
-				});
-			});
-		});
-	};
-}
-
-function hasDescendantCombinatorBefore(node) {
-	const nodeIndex = node.parent.nodes.indexOf(node);
-
-	return node.parent.nodes.slice(0, nodeIndex).some(isDescendantCombinator);
-}
-
-function hasChildCombinatorBefore(node) {
-	const nodeIndex = node.parent.nodes.indexOf(node);
-
-	return node.parent.nodes.slice(0, nodeIndex).some(isChildCombinator);
-}
-
-function hasCompoundSelector(node) {
-	if (node.prev() && !isCombinator(node.prev())) {
-		return true;
-	}
-
-	return node.next() && !isCombinator(node.next());
-}
-
-function hasNextSiblingCombinator(node) {
-	return node.prev() && isNextSiblingCombinator(node.prev());
-}
-
-function isCombinator(node) {
-	if (!node) return false;
-
-	return _.get(node, 'type') === 'combinator';
-}
-
-function isDescendantCombinator(node) {
-	if (!node) return false;
-
-	return isCombinator(node) && isOnlyWhitespace(node.value);
-}
-
-function isChildCombinator(node) {
-	if (!node) return false;
-
-	return isCombinator(node) && node.value === '>';
-}
-
-function isNextSiblingCombinator(node) {
-	return isCombinator(node) && node.value === '+';
-}
-
-rule.ruleName = ruleName;
-rule.messages = messages;
-module.exports = rule;

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

@@ -1,76 +0,0 @@
-# selector-max-universal
-
-Limit the number of universal selectors in a selector.
-
-<!-- prettier-ignore -->
-```css
-    * {}
-/** ↑
- * This universal selector */
-```
-
-This rule resolves nested selectors before counting the number of universal selectors. Each selector in a [selector list](https://www.w3.org/TR/selectors4/#selector-list) is evaluated separately.
-
-The logical combinations pseudo-class (e.g. `:not`, `:has`) 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 universal selectors allowed.
-
-For example, with `2`:
-
-The following patterns are considered violations:
-
-<!-- prettier-ignore -->
-```css
-* * * {}
-```
-
-<!-- prettier-ignore -->
-```css
-* * {
-  & * {}
-}
-```
-
-<!-- prettier-ignore -->
-```css
-* * {
-  & > * {}
-}
-```
-
-The following patterns are _not_ considered violations:
-
-<!-- prettier-ignore -->
-```css
-* {}
-```
-
-<!-- prettier-ignore -->
-```css
-* * {}
-```
-
-<!-- prettier-ignore -->
-```css
-.foo * {}
-```
-
-<!-- prettier-ignore -->
-```css
-*.foo * {}
-```
-
-<!-- prettier-ignore -->
-```css
-/* each selector in a selector list is evaluated separately */
-*.foo,
-*.bar * {}
-```
-
-<!-- prettier-ignore -->
-```css
-/* `*` is inside `:not()`, so it is evaluated separately */
-* > * .foo:not(*) {}
-```

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

@@ -1,84 +0,0 @@
-// @ts-nocheck
-
-'use strict';
-
-const isNonNegativeInteger = require('../../utils/isNonNegativeInteger');
-const isStandardSyntaxRule = require('../../utils/isStandardSyntaxRule');
-const parseSelector = require('../../utils/parseSelector');
-const report = require('../../utils/report');
-const resolvedNestedSelector = require('postcss-resolve-nested-selector');
-const ruleMessages = require('../../utils/ruleMessages');
-const selectorParser = require('postcss-selector-parser');
-const validateOptions = require('../../utils/validateOptions');
-
-const ruleName = 'selector-max-universal';
-
-const messages = ruleMessages(ruleName, {
-	expected: (selector, max) =>
-		`Expected "${selector}" to have no more than ${max} universal ${
-			max === 1 ? 'selector' : 'selectors'
-		}`,
-});
-
-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
-				// All logical combinations will be resolved as nested selector in `postcss-resolve-nested-selector`
-				if (childNode.type === 'selector') {
-					checkSelector(childNode, ruleNode);
-				}
-
-				return (total += childNode.type === 'universal' ? 1 : 0);
-			}, 0);
-
-			if (selectorNode.type !== 'root' && selectorNode.type !== 'pseudo' && count > max) {
-				report({
-					ruleName,
-					result,
-					node: ruleNode,
-					message: messages.expected(selectorNode, max),
-					word: selectorNode,
-				});
-			}
-		}
-
-		root.walkRules((ruleNode) => {
-			if (!isStandardSyntaxRule(ruleNode)) {
-				return;
-			}
-
-			const selectors = [];
-
-			selectorParser()
-				.astSync(ruleNode.selector)
-				.walk((node) => {
-					if (node.type === 'selector') {
-						selectors.push(String(node).trim());
-					}
-				});
-
-			selectors.forEach((selector) => {
-				resolvedNestedSelector(selector, ruleNode).forEach((resolvedSelector) => {
-					parseSelector(resolvedSelector, result, ruleNode, (container) =>
-						checkSelector(container, ruleNode),
-					);
-				});
-			});
-		});
-	};
-}
-
-rule.ruleName = ruleName;
-rule.messages = messages;
-module.exports = rule;

package/templates/facebook/node_modules/stylelint/lib/rules/selector-nested-pattern/README.md

@@ -1,77 +0,0 @@
-# selector-nested-pattern
-
-Specify a pattern for the selectors of rules nested within rules.
-
-<!-- prettier-ignore -->
-```css
-    a {
-      color: orange;
-      &:hover { color: pink; }
-    } ↑
-/**   ↑
- * This nested selector */
-```
-
-Non-standard selectors (e.g. selectors with Sass or Less interpolation) and selectors of rules nested within at-rules are ignored.
-
-## Options
-
-`regex|string`
-
-A string will be translated into a RegExp like so `new RegExp(yourString)` — so be sure to escape properly.
-
-The selector value will be checked in its entirety. If you'd like to allow for combinators and commas, you must incorporate them into your pattern.
-
-Given the string:
-
-```
-"^&:(?:hover|focus)$"
-```
-
-The following patterns are considered violations:
-
-<!-- prettier-ignore -->
-```css
-a {
-  .bar {}
-}
-```
-
-<!-- prettier-ignore -->
-```css
-a {
-  .bar:hover {}
-}
-```
-
-<!-- prettier-ignore -->
-```css
-a {
-  &:hover,
-  &:focus {}
-}
-```
-
-The following patterns are _not_ considered violations:
-
-<!-- prettier-ignore -->
-```css
-a {
-  &:hover {}
-}
-```
-
-<!-- prettier-ignore -->
-```css
-a {
-  &:focus {}
-}
-```
-
-<!-- prettier-ignore -->
-```css
-a {
-  &:hover {}
-  &:focus {}
-}
-```

package/templates/facebook/node_modules/stylelint/lib/rules/selector-nested-pattern/index.js

@@ -1,58 +0,0 @@
-// @ts-nocheck
-
-'use strict';
-
-const _ = require('lodash');
-const isStandardSyntaxRule = require('../../utils/isStandardSyntaxRule');
-const report = require('../../utils/report');
-const ruleMessages = require('../../utils/ruleMessages');
-const validateOptions = require('../../utils/validateOptions');
-
-const ruleName = 'selector-nested-pattern';
-
-const messages = ruleMessages(ruleName, {
-	expected: (selector, pattern) =>
-		`Expected nested selector "${selector}" to match pattern "${pattern}"`,
-});
-
-function rule(pattern) {
-	return (root, result) => {
-		const validOptions = validateOptions(result, ruleName, {
-			actual: pattern,
-			possible: [_.isRegExp, _.isString],
-		});
-
-		if (!validOptions) {
-			return;
-		}
-
-		const normalizedPattern = _.isString(pattern) ? new RegExp(pattern) : pattern;
-
-		root.walkRules((ruleNode) => {
-			if (ruleNode.parent.type !== 'rule') {
-				return;
-			}
-
-			if (!isStandardSyntaxRule(ruleNode)) {
-				return;
-			}
-
-			const selector = ruleNode.selector;
-
-			if (normalizedPattern.test(selector)) {
-				return;
-			}
-
-			report({
-				result,
-				ruleName,
-				message: messages.expected(selector, pattern),
-				node: ruleNode,
-			});
-		});
-	};
-}
-
-rule.ruleName = ruleName;
-rule.messages = messages;
-module.exports = rule;

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

@@ -1,105 +0,0 @@
-# selector-no-qualifying-type
-
-Disallow qualifying a selector by type.
-
-<!-- prettier-ignore -->
-```css
-    a.foo {}
-/** ↑
- * This type selector is qualifying the class */
-```
-
-A type selector is "qualifying" when it is compounded with (chained to) another selector (e.g. `a.foo`, `a#foo`). This rule does not regulate type selectors that are combined with other selectors via a combinator (e.g. `a > .foo`, `a #foo`).
-
-## Options
-
-### `true`
-
-The following patterns are considered violations:
-
-<!-- prettier-ignore -->
-```css
-a.foo {
-  margin: 0
-}
-```
-
-<!-- prettier-ignore -->
-```css
-a#foo {
-  margin: 0
-}
-```
-
-<!-- prettier-ignore -->
-```css
-input[type='button'] {
-  margin: 0
-}
-```
-
-The following patterns are _not_ considered violations:
-
-<!-- prettier-ignore -->
-```css
-.foo {
-  margin: 0
-}
-```
-
-<!-- prettier-ignore -->
-```css
-#foo {
-  margin: 0
-}
-```
-
-<!-- prettier-ignore -->
-```css
-input {
-  margin: 0
-}
-```
-
-## Optional secondary options
-
-### `ignore: ["attribute", "class", "id"]`
-
-#### `"attribute"`
-
-Allow attribute selectors qualified by type.
-
-The following patterns are _not_ considered violations:
-
-<!-- prettier-ignore -->
-```css
-input[type='button'] {
-  margin: 0
-}
-```
-
-#### `"class"`
-
-Allow class selectors qualified by type.
-
-The following patterns are _not_ considered violations:
-
-<!-- prettier-ignore -->
-```css
-a.foo {
-  margin: 0
-}
-```
-
-#### `"id"`
-
-Allow ID selectors qualified by type.
-
-The following patterns are _not_ considered violations:
-
-<!-- prettier-ignore -->
-```css
-a#foo {
-  margin: 0
-}
-```

package/templates/facebook/node_modules/stylelint/lib/rules/selector-no-qualifying-type/index.js

@@ -1,134 +0,0 @@
-// @ts-nocheck
-
-'use strict';
-
-const isKeyframeRule = require('../../utils/isKeyframeRule');
-const isStandardSyntaxRule = require('../../utils/isStandardSyntaxRule');
-const isStandardSyntaxSelector = require('../../utils/isStandardSyntaxSelector');
-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 validateOptions = require('../../utils/validateOptions');
-
-const ruleName = 'selector-no-qualifying-type';
-
-const messages = ruleMessages(ruleName, {
-	rejected: 'Unexpected qualifying type selector',
-});
-
-const selectorCharacters = ['#', '.', '['];
-
-function isSelectorCharacters(value) {
-	return selectorCharacters.some((char) => value.includes(char));
-}
-
-function getRightNodes(node) {
-	const result = [];
-	let rightNode = node;
-
-	while ((rightNode = rightNode.next())) {
-		if (rightNode.type === 'combinator') {
-			break;
-		}
-
-		if (rightNode.type !== 'id' && rightNode.type !== 'class' && rightNode.type !== 'attribute') {
-			continue;
-		}
-
-		result.push(rightNode);
-	}
-
-	return result;
-}
-
-function rule(enabled, options) {
-	return (root, result) => {
-		const validOptions = validateOptions(
-			result,
-			ruleName,
-			{
-				actual: enabled,
-				possible: [true, false],
-			},
-			{
-				actual: options,
-				possible: {
-					ignore: ['attribute', 'class', 'id'],
-				},
-				optional: true,
-			},
-		);
-
-		if (!validOptions) {
-			return;
-		}
-
-		root.walkRules((ruleNode) => {
-			if (!isStandardSyntaxRule(ruleNode)) {
-				return;
-			}
-
-			if (isKeyframeRule(ruleNode)) {
-				return;
-			}
-
-			if (!isSelectorCharacters(ruleNode.selector)) {
-				return;
-			}
-
-			function checkSelector(selectorAST) {
-				selectorAST.walkTags((selector) => {
-					const selectorParent = selector.parent;
-
-					if (selectorParent.nodes.length === 1) {
-						return;
-					}
-
-					const selectorNodes = getRightNodes(selector);
-					const index = selector.sourceIndex;
-
-					selectorNodes.forEach((selectorNode) => {
-						if (selectorNode.type === 'id' && !optionsMatches(options, 'ignore', 'id')) {
-							complain(index);
-						}
-
-						if (selectorNode.type === 'class' && !optionsMatches(options, 'ignore', 'class')) {
-							complain(index);
-						}
-
-						if (
-							selectorNode.type === 'attribute' &&
-							!optionsMatches(options, 'ignore', 'attribute')
-						) {
-							complain(index);
-						}
-					});
-				});
-			}
-
-			resolvedNestedSelector(ruleNode.selector, ruleNode).forEach((resolvedSelector) => {
-				if (!isStandardSyntaxSelector(resolvedSelector)) {
-					return;
-				}
-
-				parseSelector(resolvedSelector, result, ruleNode, checkSelector);
-			});
-
-			function complain(index) {
-				report({
-					ruleName,
-					result,
-					node: ruleNode,
-					message: messages.rejected,
-					index,
-				});
-			}
-		});
-	};
-}
-
-rule.ruleName = ruleName;
-rule.messages = messages;
-module.exports = rule;