create-docusaurus 0.0.0-4378 → 0.0.0-4379

package/templates/facebook/node_modules/stylelint/lib/rules/no-invalid-position-at-import-rule/README.md

@@ -0,0 +1,51 @@
+# no-invalid-position-at-import-rule
+
+Disallow invalid position `@import` rules within a stylesheet.
+
+<!-- prettier-ignore -->
+```css
+a {}
+@import 'foo.css';
+/** ↑
+  * This @import */
+```
+
+Any `@import` rules must precede all other valid at-rules and style rules in a stylesheet (ignoring `@charset`), or else the `@import` rule is invalid.
+
+## Options
+
+### `true`
+
+The following patterns are considered violations:
+
+<!-- prettier-ignore -->
+```css
+a {}
+@import 'foo.css';
+```
+
+<!-- prettier-ignore -->
+```css
+@media print {}
+@import 'foo.css';
+```
+
+The following patterns are _not_ considered violations:
+
+<!-- prettier-ignore -->
+```css
+@import 'foo.css';
+a {}
+```
+
+<!-- prettier-ignore -->
+```css
+/* some comment */
+@import 'foo.css';
+```
+
+<!-- prettier-ignore -->
+```css
+@charset 'utf-8';
+@import 'foo.css';
+```

package/templates/facebook/node_modules/stylelint/lib/rules/no-invalid-position-at-import-rule/index.js

@@ -0,0 +1,58 @@
+// @ts-nocheck
+
+'use strict';
+
+const isStandardSyntaxAtRule = require('../../utils/isStandardSyntaxAtRule');
+const isStandardSyntaxRule = require('../../utils/isStandardSyntaxRule');
+const report = require('../../utils/report');
+const ruleMessages = require('../../utils/ruleMessages');
+const validateOptions = require('../../utils/validateOptions');
+
+const ruleName = 'no-invalid-position-at-import-rule';
+
+const messages = ruleMessages(ruleName, {
+	rejected: 'Unexpected invalid position @import rule',
+});
+
+function rule(actual) {
+	return (root, result) => {
+		const validOptions = validateOptions(result, ruleName, { actual });
+
+		if (!validOptions) {
+			return;
+		}
+
+		let invalidPosition = false;
+
+		root.walk((node) => {
+			const nodeName = node.name && node.name.toLowerCase();
+
+			if (
+				(node.type === 'atrule' &&
+					nodeName !== 'charset' &&
+					nodeName !== 'import' &&
+					isStandardSyntaxAtRule(node)) ||
+				(node.type === 'rule' && isStandardSyntaxRule(node))
+			) {
+				invalidPosition = true;
+
+				return;
+			}
+
+			if (node.type === 'atrule' && nodeName === 'import') {
+				if (invalidPosition) {
+					report({
+						message: messages.rejected,
+						node,
+						result,
+						ruleName,
+					});
+				}
+			}
+		});
+	};
+}
+
+rule.ruleName = ruleName;
+rule.messages = messages;
+module.exports = rule;

package/templates/facebook/node_modules/stylelint/lib/rules/no-irregular-whitespace/README.md

@@ -0,0 +1,57 @@
+# no-irregular-whitespace
+
+Disallow irregular whitespaces.
+
+<!-- prettier-ignore -->
+```css
+    .firstClass .secondClass {}
+/**            ↑
+ * Irregular whitespace. Selector would fail to match '.firstClass' */
+```
+
+## Options
+
+### `true`
+
+The following patterns are considered violations:
+
+<!-- prettier-ignore -->
+```css
+.firstClass .secondClass {}
+```
+
+The following patterns are _not_ considered violations:
+
+<!-- prettier-ignore -->
+```css
+.firstClass .secondClass { /* Writing comments with irregular whitespaces */ }
+```
+
+## Unicode reference of irregular whitespaces
+
+```
+\u000B - Line Tabulation (\v) - <VT>
+\u000C - Form Feed (\f) - <FF>
+\u00A0 - No-Break Space - <NBSP>
+\u0085 - Next Line
+\u1680 - Ogham Space Mark
+\u180E - Mongolian Vowel Separator - <MVS>
+\uFEFF - Zero Width No-Break Space - <BOM>
+\u2000 - En Quad
+\u2001 - Em Quad
+\u2002 - En Space - <ENSP>
+\u2003 - Em Space - <EMSP>
+\u2004 - Tree-Per-Em
+\u2005 - Four-Per-Em
+\u2006 - Six-Per-Em
+\u2007 - Figure Space
+\u2008 - Punctuation Space - <PUNCSP>
+\u2009 - Thin Space
+\u200A - Hair Space
+\u200B - Zero Width Space - <ZWSP>
+\u2028 - Line Separator
+\u2029 - Paragraph Separator
+\u202F - Narrow No-Break Space
+\u205F - Medium Mathematical Space
+\u3000 - Ideographic Space
+```

package/templates/facebook/node_modules/stylelint/lib/rules/no-irregular-whitespace/index.js

@@ -0,0 +1,134 @@
+// @ts-nocheck
+
+'use strict';
+
+const report = require('../../utils/report');
+const ruleMessages = require('../../utils/ruleMessages');
+const validateOptions = require('../../utils/validateOptions');
+
+const ruleName = 'no-irregular-whitespace';
+const messages = ruleMessages(ruleName, {
+	unexpected: 'Unexpected irregular whitespace',
+});
+
+const IRREGULAR_WHITESPACES = [
+	'\u000B', // Line Tabulation (\v) - <VT>
+	'\u000C', // Form Feed (\f) - <FF>
+	'\u00A0', // No-Break Space - <NBSP>
+	'\u0085', // Next Line
+	'\u1680', // Ogham Space Mark
+	'\u180E', // Mongolian Vowel Separator - <MVS>
+	'\uFEFF', // Zero Width No-Break Space - <BOM>
+	'\u2000', // En Quad
+	'\u2001', // Em Quad
+	'\u2002', // En Space - <ENSP>
+	'\u2003', // Em Space - <EMSP>
+	'\u2004', // Tree-Per-Em
+	'\u2005', // Four-Per-Em
+	'\u2006', // Six-Per-Em
+	'\u2007', // Figure Space
+	'\u2008', // Punctuation Space - <PUNCSP>
+	'\u2009', // Thin Space
+	'\u200A', // Hair Space
+	'\u200B', // Zero Width Space - <ZWSP>
+	'\u2028', // Line Separator
+	'\u2029', // Paragraph Separator
+	'\u202F', // Narrow No-Break Space
+	'\u205F', // Medium Mathematical Space
+	'\u3000', // Ideographic Space
+];
+
+const IRREGULAR_WHITESPACES_PATTERN = new RegExp(`([${IRREGULAR_WHITESPACES.join('')}])`);
+
+const generateInvalidWhitespaceValidator = () => {
+	return (str) => typeof str === 'string' && IRREGULAR_WHITESPACES_PATTERN.exec(str);
+};
+
+const declarationSchema = {
+	prop: 'string',
+	value: 'string',
+	raws: {
+		before: 'string',
+		between: 'string',
+	},
+};
+
+const atRuleSchema = {
+	name: 'string',
+	params: 'string',
+	raws: {
+		before: 'string',
+		between: 'string',
+		afterName: 'string',
+		after: 'string',
+	},
+};
+
+const ruleSchema = {
+	selector: 'string',
+	raws: {
+		before: 'string',
+		between: 'string',
+		after: 'string',
+	},
+};
+
+const generateNodeValidator = (nodeSchema, validator) => {
+	const allKeys = Object.keys(nodeSchema);
+	const validatorForKey = {};
+
+	allKeys.forEach((key) => {
+		if (typeof nodeSchema[key] === 'string') validatorForKey[key] = validator;
+
+		if (typeof nodeSchema[key] === 'object')
+			validatorForKey[key] = generateNodeValidator(nodeSchema[key], validator);
+	});
+
+	// This will be called many times, so it's optimized for performance and not readibility.
+	// Surprisingly, this seem to be slightly faster then concatenating the params and running the validator once.
+	return (node) => {
+		for (const currentKey of allKeys) {
+			if (validatorForKey[currentKey](node[currentKey])) {
+				return validatorForKey[currentKey](node[currentKey]);
+			}
+		}
+	};
+};
+
+function rule(on) {
+	return (root, result) => {
+		const validOptions = validateOptions(result, ruleName, { actual: on });
+
+		if (!validOptions) {
+			return;
+		}
+
+		const genericValidator = generateInvalidWhitespaceValidator();
+
+		const validate = (node, validator) => {
+			const issue = validator(node);
+
+			if (issue) {
+				report({
+					ruleName,
+					result,
+					message: messages.unexpected,
+					node,
+					word: issue[1],
+				});
+			}
+		};
+
+		const atRuleValidator = generateNodeValidator(atRuleSchema, genericValidator);
+		const ruleValidator = generateNodeValidator(ruleSchema, genericValidator);
+		const declValidator = generateNodeValidator(declarationSchema, genericValidator);
+
+		root.walkAtRules((atRule) => validate(atRule, atRuleValidator));
+		root.walkRules((selector) => validate(selector, ruleValidator));
+		root.walkDecls((declaration) => validate(declaration, declValidator));
+	};
+}
+
+rule.ruleName = ruleName;
+rule.messages = messages;
+module.exports = rule;

package/templates/facebook/node_modules/stylelint/lib/rules/no-missing-end-of-source-newline/README.md

@@ -0,0 +1,34 @@
+# no-missing-end-of-source-newline
+
+Disallow missing end-of-source newlines.
+
+<!-- prettier-ignore -->
+```css
+    a { color: pink; }
+    \n
+/** ↑
+ * This newline */
+```
+
+Completely empty files are not considered violations.
+
+The [`fix` option](../../../docs/user-guide/usage/options.md#fix) can automatically fix all of the problems reported by this rule.
+
+## Options
+
+### `true`
+
+The following patterns are considered violations:
+
+<!-- prettier-ignore -->
+```css
+a { color: pink; }
+```
+
+The following patterns are _not_ considered violations:
+
+<!-- prettier-ignore -->
+```css
+a { color: pink; }
+\n
+```

package/templates/facebook/node_modules/stylelint/lib/rules/no-missing-end-of-source-newline/index.js

@@ -0,0 +1,52 @@
+// @ts-nocheck
+
+'use strict';
+
+const report = require('../../utils/report');
+const ruleMessages = require('../../utils/ruleMessages');
+const validateOptions = require('../../utils/validateOptions');
+
+const ruleName = 'no-missing-end-of-source-newline';
+
+const messages = ruleMessages(ruleName, {
+	rejected: 'Unexpected missing end-of-source newline',
+});
+
+function rule(primary, _, context) {
+	return (root, result) => {
+		const validOptions = validateOptions(result, ruleName, { primary });
+
+		if (!validOptions) {
+			return;
+		}
+
+		if (root.source.inline || root.source.lang === 'object-literal') {
+			return;
+		}
+
+		const rootString = context.fix ? root.toString() : root.source.input.css;
+
+		if (!rootString.trim() || rootString.endsWith('\n')) {
+			return;
+		}
+
+		// Fix
+		if (context.fix) {
+			root.raws.after = context.newline;
+
+			return;
+		}
+
+		report({
+			message: messages.rejected,
+			node: root,
+			index: rootString.length - 1,
+			result,
+			ruleName,
+		});
+	};
+}
+
+rule.ruleName = ruleName;
+rule.messages = messages;
+module.exports = rule;

package/templates/facebook/node_modules/stylelint/lib/rules/no-unknown-animations/README.md

@@ -0,0 +1,76 @@
+# no-unknown-animations
+
+Disallow unknown animations.
+
+<!-- prettier-ignore -->
+```css
+a { animation-name: fancy-slide; }
+/**                    ↑
+ *   This animation name */
+
+a { animation: fancy-slide 2s linear; }
+/**                    ↑
+ *           And this one */
+```
+
+This rule considers the identifiers of `@keyframes` rules defined within the same source to be known.
+
+## Options
+
+### `true`
+
+The following patterns are considered violations:
+
+<!-- prettier-ignore -->
+```css
+a { animation-name: fancy-slide; }
+```
+
+<!-- prettier-ignore -->
+```css
+a { animation: fancy-slide 2s linear; }
+```
+
+<!-- prettier-ignore -->
+```css
+a { animation-name: fancccy-slide; }
+@keyframes fancy-slide {}
+```
+
+<!-- prettier-ignore -->
+```css
+a { animation: linear 100ms fancccy-slide; }
+@keyframes fancy-slide {}
+```
+
+<!-- prettier-ignore -->
+```css
+a { animation-name: jump; }
+@keyframes fancy-slide {}
+```
+
+The following patterns are _not_ considered violations:
+
+<!-- prettier-ignore -->
+```css
+a { animation-name: fancy-slide; }
+@keyframes fancy-slide {}
+```
+
+<!-- prettier-ignore -->
+```css
+@keyframes fancy-slide {}
+a { animation-name: fancy-slide; }
+```
+
+<!-- prettier-ignore -->
+```css
+@keyframes fancy-slide {}
+a { animation: fancy-slide 2s linear; }
+```
+
+<!-- prettier-ignore -->
+```css
+a { animation: 100ms steps(12, end) fancy-slide; }
+@keyframes fancy-slide {}
+```

package/templates/facebook/node_modules/stylelint/lib/rules/no-unknown-animations/index.js

@@ -0,0 +1,64 @@
+// @ts-nocheck
+
+'use strict';
+
+const declarationValueIndex = require('../../utils/declarationValueIndex');
+const findAnimationName = require('../../utils/findAnimationName');
+const keywordSets = require('../../reference/keywordSets');
+const report = require('../../utils/report');
+const ruleMessages = require('../../utils/ruleMessages');
+const validateOptions = require('../../utils/validateOptions');
+
+const ruleName = 'no-unknown-animations';
+
+const messages = ruleMessages(ruleName, {
+	rejected: (animationName) => `Unexpected unknown animation name "${animationName}"`,
+});
+
+function rule(actual) {
+	return (root, result) => {
+		const validOptions = validateOptions(result, ruleName, { actual });
+
+		if (!validOptions) {
+			return;
+		}
+
+		const declaredAnimations = new Set();
+
+		root.walkAtRules(/(-(moz|webkit)-)?keyframes/i, (atRule) => {
+			declaredAnimations.add(atRule.params);
+		});
+
+		root.walkDecls((decl) => {
+			if (decl.prop.toLowerCase() === 'animation' || decl.prop.toLowerCase() === 'animation-name') {
+				const animationNames = findAnimationName(decl.value);
+
+				if (animationNames.length === 0) {
+					return;
+				}
+
+				animationNames.forEach((animationNameNode) => {
+					if (keywordSets.animationNameKeywords.has(animationNameNode.value.toLowerCase())) {
+						return;
+					}
+
+					if (declaredAnimations.has(animationNameNode.value)) {
+						return;
+					}
+
+					report({
+						result,
+						ruleName,
+						message: messages.rejected(animationNameNode.value),
+						node: decl,
+						index: declarationValueIndex(decl) + animationNameNode.sourceIndex,
+					});
+				});
+			}
+		});
+	};
+}
+
+rule.ruleName = ruleName;
+rule.messages = messages;
+module.exports = rule;

package/templates/facebook/node_modules/stylelint/lib/rules/number-leading-zero/README.md

@@ -0,0 +1,74 @@
+# number-leading-zero
+
+Require or disallow a leading zero for fractional numbers less than 1.
+
+<!-- prettier-ignore -->
+```css
+a { line-height: 0.5; }
+/**              ↑
+ * This leading zero */
+```
+
+This rule ignores mixin parameters in Less.
+
+The [`fix` option](../../../docs/user-guide/usage/options.md#fix) can automatically fix all of the problems reported by this rule.
+
+## Options
+
+`string`: `"always"|"never"`
+
+### `"always"`
+
+There _must always_ be a leading zero.
+
+The following patterns are considered violations:
+
+<!-- prettier-ignore -->
+```css
+a { line-height: .5; }
+```
+
+<!-- prettier-ignore -->
+```css
+a { transform: translate(2px, .4px); }
+```
+
+The following patterns are _not_ considered violations:
+
+<!-- prettier-ignore -->
+```css
+a { line-height: 0.5; }
+```
+
+<!-- prettier-ignore -->
+```css
+a { transform: translate(2px, 0.4px); }
+```
+
+### `"never"`
+
+There _must never_ be a leading zero.
+
+The following patterns are considered violations:
+
+<!-- prettier-ignore -->
+```css
+a { line-height: 0.5; }
+```
+
+<!-- prettier-ignore -->
+```css
+a { transform: translate(2px, 0.4px); }
+```
+
+The following patterns are _not_ considered violations:
+
+<!-- prettier-ignore -->
+```css
+a { line-height: .5; }
+```
+
+<!-- prettier-ignore -->
+```css
+a { transform: translate(2px, .4px); }
+```