create-docusaurus 0.0.0-4377 → 0.0.0-4384

package/templates/facebook/node_modules/stylelint/lib/rules/color-function-notation/README.md

@@ -0,0 +1,116 @@
+# color-function-notation
+
+Specify modern or legacy notation for applicable color-functions.
+
+<!-- prettier-ignore -->
+```css
+    a { color: rgb(0 0 0 / 0.2) }
+/**            ↑
+ *             This notation */
+```
+
+Modern color-functions use a comma-free syntax because functions in CSS are used to group/name a syntax chunk. They should work by the same rules that CSS grammar does in general: values are optional and re-orderable when possible, space-separated, and commas are used to separate repetitions only.
+
+For legacy reasons, `rgb()` and `hsl()` also supports an alternate syntax that separates all of its arguments with commas. Also for legacy reasons, the `rgba()` and `hsla()` functions exist using the same comma-based syntax.
+
+The [`fix` option](../../../docs/user-guide/usage/options.md#fix) can automatically fix some of the problems reported by this rule when the primary option is `"modern"`.
+
+## Options
+
+`string`: `"modern"|"legacy"`
+
+### `"modern"`
+
+Applicable color-functions _must always_ use modern notation.
+
+The following patterns are considered violations:
+
+<!-- prettier-ignore -->
+```css
+a { color: rgb(0, 0, 0) }
+```
+
+<!-- prettier-ignore -->
+```css
+a { color: rgba(12, 122, 231, 0.2) }
+```
+
+<!-- prettier-ignore -->
+```css
+a { color: hsla(270, 60%, 50%, 15%) }
+```
+
+<!-- prettier-ignore -->
+```css
+a { color: hsl(.75turn, 60%, 70%) }
+```
+
+The following patterns are _not_ considered violations:
+
+<!-- prettier-ignore -->
+```css
+a { color: rgb(0 0 0) }
+```
+
+<!-- prettier-ignore -->
+```css
+a { color: rgb(12 122 231 / 0.2) }
+```
+
+<!-- prettier-ignore -->
+```css
+a { color: hsl(270 60% 50% / 15%) }
+```
+
+<!-- prettier-ignore -->
+```css
+a { color: hsl(.75turn 60% 70%) }
+```
+
+### `"legacy"`
+
+Applicable color-functions _must always_ use the legacy notation.
+
+The following patterns are considered violations:
+
+<!-- prettier-ignore -->
+```css
+a { color: rgb(0 0 0) }
+```
+
+<!-- prettier-ignore -->
+```css
+a { color: rgb(12 122 231 / 0.2) }
+```
+
+<!-- prettier-ignore -->
+```css
+a { color: hsl(270 60% 50% / 15%) }
+```
+
+<!-- prettier-ignore -->
+```css
+a { color: hsl(.75turn 60% 70%) }
+```
+
+The following patterns are _not_ considered violations:
+
+<!-- prettier-ignore -->
+```css
+a { color: rgb(0, 0, 0) }
+```
+
+<!-- prettier-ignore -->
+```css
+a { color: rgba(12, 122, 231, 0.2) }
+```
+
+<!-- prettier-ignore -->
+```css
+a { color: hsla(270, 60%, 50%, 15%) }
+```
+
+<!-- prettier-ignore -->
+```css
+a { color: hsl(.75turn, 60%, 70%) }
+```

package/templates/facebook/node_modules/stylelint/lib/rules/color-function-notation/index.js

@@ -0,0 +1,108 @@
+// @ts-nocheck
+
+'use strict';
+
+const valueParser = require('postcss-value-parser');
+
+const declarationValueIndex = require('../../utils/declarationValueIndex');
+const getDeclarationValue = require('../../utils/getDeclarationValue');
+const report = require('../../utils/report');
+const ruleMessages = require('../../utils/ruleMessages');
+const setDeclarationValue = require('../../utils/setDeclarationValue');
+const validateOptions = require('../../utils/validateOptions');
+
+const ruleName = 'color-function-notation';
+
+const messages = ruleMessages(ruleName, {
+	expected: (primary) => `Expected ${primary} color-function notation`,
+});
+
+const LEGACY_FUNCS = new Set(['rgba', 'hsla']);
+const LEGACY_NOTATION_FUNCS = new Set(['rgb', 'rgba', 'hsl', 'hsla']);
+
+function rule(primary, secondary, context) {
+	return (root, result) => {
+		const validOptions = validateOptions(result, ruleName, {
+			actual: primary,
+			possible: ['modern', 'legacy'],
+		});
+
+		if (!validOptions) return;
+
+		root.walkDecls((decl) => {
+			let needsFix = false;
+			const parsedValue = valueParser(getDeclarationValue(decl));
+
+			parsedValue.walk((node) => {
+				const { value, type, sourceIndex, nodes } = node;
+
+				if (type !== 'function') return;
+
+				if (!LEGACY_NOTATION_FUNCS.has(value.toLowerCase())) return;
+
+				if (primary === 'modern' && !hasCommas(node)) return;
+
+				if (primary === 'legacy' && hasCommas(node)) return;
+
+				if (context.fix && primary === 'modern') {
+					let commaCount = 0;
+
+					// Convert punctuation
+					node.nodes = nodes.map((childNode) => {
+						if (isComma(childNode)) {
+							// Non-alpha commas to space and alpha commas to slashes
+							if (commaCount < 2) {
+								childNode.type = 'space';
+								childNode.value = atLeastOneSpace(childNode.after);
+								commaCount++;
+							} else {
+								childNode.value = '/';
+								childNode.before = atLeastOneSpace(childNode.before);
+								childNode.after = atLeastOneSpace(childNode.after);
+							}
+						}
+
+						return childNode;
+					});
+
+					// Remove trailing 'a' from legacy function name
+					if (LEGACY_FUNCS.has(node.value.toLowerCase())) {
+						node.value = node.value.slice(0, -1);
+					}
+
+					needsFix = true;
+
+					return;
+				}
+
+				report({
+					message: messages.expected(primary),
+					node: decl,
+					index: declarationValueIndex(decl) + sourceIndex,
+					result,
+					ruleName,
+				});
+			});
+
+			if (needsFix) {
+				setDeclarationValue(decl, parsedValue.toString());
+			}
+		});
+	};
+}
+
+function atLeastOneSpace(whitespace) {
+	return whitespace !== '' ? whitespace : ' ';
+}
+
+function isComma(node) {
+	return node.type === 'div' && node.value === ',';
+}
+
+function hasCommas(node) {
+	return node.nodes && node.nodes.some((childNode) => isComma(childNode));
+}
+
+rule.ruleName = ruleName;
+rule.messages = messages;
+module.exports = rule;

package/templates/facebook/node_modules/stylelint/lib/rules/color-hex-case/README.md

@@ -0,0 +1,58 @@
+# color-hex-case
+
+Specify lowercase or uppercase for hex colors.
+
+<!-- prettier-ignore -->
+```css
+a { color: #fff }
+/**        ↑
+ * This hex color */
+```
+
+The [`fix` option](../../../docs/user-guide/usage/options.md#fix) can automatically fix all of the problems reported by this rule.
+
+## Options
+
+`string`: `"lower"|"upper"`
+
+### `"lower"`
+
+The following patterns are considered violations:
+
+<!-- prettier-ignore -->
+```css
+a { color: #FFF; }
+```
+
+The following patterns are _not_ considered violations:
+
+<!-- prettier-ignore -->
+```css
+a { color: #000; }
+```
+
+<!-- prettier-ignore -->
+```css
+a { color: #fff; }
+```
+
+### `"upper"`
+
+The following patterns are considered violations:
+
+<!-- prettier-ignore -->
+```css
+a { color: #fff; }
+```
+
+The following patterns are _not_ considered violations:
+
+<!-- prettier-ignore -->
+```css
+a { color: #000; }
+```
+
+<!-- prettier-ignore -->
+```css
+a { color: #FFF; }
+```

package/templates/facebook/node_modules/stylelint/lib/rules/color-hex-case/index.js

@@ -0,0 +1,82 @@
+// @ts-nocheck
+
+'use strict';
+
+const valueParser = require('postcss-value-parser');
+
+const declarationValueIndex = require('../../utils/declarationValueIndex');
+const getDeclarationValue = require('../../utils/getDeclarationValue');
+const report = require('../../utils/report');
+const ruleMessages = require('../../utils/ruleMessages');
+const setDeclarationValue = require('../../utils/setDeclarationValue');
+const validateOptions = require('../../utils/validateOptions');
+
+const ruleName = 'color-hex-case';
+
+const messages = ruleMessages(ruleName, {
+	expected: (actual, expected) => `Expected "${actual}" to be "${expected}"`,
+});
+
+const HEX = /^#[0-9A-Za-z]+/;
+const IGNORED_FUNCTIONS = new Set(['url']);
+
+function rule(expectation, options, context) {
+	return (root, result) => {
+		const validOptions = validateOptions(result, ruleName, {
+			actual: expectation,
+			possible: ['lower', 'upper'],
+		});
+
+		if (!validOptions) {
+			return;
+		}
+
+		root.walkDecls((decl) => {
+			const parsedValue = valueParser(getDeclarationValue(decl));
+			let needsFix = false;
+
+			parsedValue.walk((node) => {
+				const { value } = node;
+
+				if (isIgnoredFunction(node)) return false;
+
+				if (!isHexColor(node)) return;
+
+				const expected = expectation === 'lower' ? value.toLowerCase() : value.toUpperCase();
+
+				if (value === expected) return;
+
+				if (context.fix) {
+					node.value = expected;
+					needsFix = true;
+
+					return;
+				}
+
+				report({
+					message: messages.expected(value, expected),
+					node: decl,
+					index: declarationValueIndex(decl) + node.sourceIndex,
+					result,
+					ruleName,
+				});
+			});
+
+			if (needsFix) {
+				setDeclarationValue(decl, parsedValue.toString());
+			}
+		});
+	};
+}
+
+function isIgnoredFunction({ type, value }) {
+	return type === 'function' && IGNORED_FUNCTIONS.has(value.toLowerCase());
+}
+
+function isHexColor({ type, value }) {
+	return type === 'word' && HEX.test(value);
+}
+
+rule.ruleName = ruleName;
+rule.messages = messages;
+module.exports = rule;

package/templates/facebook/node_modules/stylelint/lib/rules/color-hex-length/README.md

@@ -0,0 +1,73 @@
+# color-hex-length
+
+Specify short or long notation for hex colors.
+
+<!-- prettier-ignore -->
+```css
+a { color: #fff }
+/**        ↑
+ * This hex color */
+```
+
+The [`fix` option](../../../docs/user-guide/usage/options.md#fix) can automatically fix all of the problems reported by this rule.
+
+## Options
+
+`string`: `"short"|"long"`
+
+### `"short"`
+
+The following patterns are considered violations:
+
+<!-- prettier-ignore -->
+```css
+a { color: #ffffff; }
+```
+
+<!-- prettier-ignore -->
+```css
+a { color: #ffffffaa; }
+```
+
+The following patterns are _not_ considered violations:
+
+<!-- prettier-ignore -->
+```css
+a { color: #fff; }
+```
+
+<!-- prettier-ignore -->
+```css
+a { color: #fffa; }
+```
+
+<!-- prettier-ignore -->
+```css
+a { color: #a4a4a4; }
+```
+
+### `"long"`
+
+The following patterns are considered violations:
+
+<!-- prettier-ignore -->
+```css
+a { color: #fff; }
+```
+
+<!-- prettier-ignore -->
+```css
+a { color: #fffa; }
+```
+
+The following patterns are _not_ considered violations:
+
+<!-- prettier-ignore -->
+```css
+a { color: #ffffff; }
+```
+
+<!-- prettier-ignore -->
+```css
+a { color: #ffffffaa; }
+```

package/templates/facebook/node_modules/stylelint/lib/rules/color-hex-length/index.js

@@ -0,0 +1,120 @@
+// @ts-nocheck
+
+'use strict';
+
+const valueParser = require('postcss-value-parser');
+
+const declarationValueIndex = require('../../utils/declarationValueIndex');
+const getDeclarationValue = require('../../utils/getDeclarationValue');
+const report = require('../../utils/report');
+const ruleMessages = require('../../utils/ruleMessages');
+const setDeclarationValue = require('../../utils/setDeclarationValue');
+const validateOptions = require('../../utils/validateOptions');
+
+const ruleName = 'color-hex-length';
+
+const messages = ruleMessages(ruleName, {
+	expected: (actual, expected) => `Expected "${actual}" to be "${expected}"`,
+});
+
+const HEX = /^#[0-9A-Za-z]+/;
+const IGNORED_FUNCTIONS = new Set(['url']);
+
+function rule(expectation, _, context) {
+	return (root, result) => {
+		const validOptions = validateOptions(result, ruleName, {
+			actual: expectation,
+			possible: ['short', 'long'],
+		});
+
+		if (!validOptions) {
+			return;
+		}
+
+		root.walkDecls((decl) => {
+			const parsedValue = valueParser(getDeclarationValue(decl));
+			let needsFix = false;
+
+			parsedValue.walk((node) => {
+				const { value: hexValue } = node;
+
+				if (isIgnoredFunction(node)) return false;
+
+				if (!isHexColor(node)) return;
+
+				if (expectation === 'long' && hexValue.length !== 4 && hexValue.length !== 5) {
+					return;
+				}
+
+				if (expectation === 'short' && (hexValue.length < 6 || !canShrink(hexValue))) {
+					return;
+				}
+
+				const variant = expectation === 'long' ? longer : shorter;
+				const expectedHex = variant(hexValue);
+
+				if (context.fix) {
+					node.value = expectedHex;
+					needsFix = true;
+
+					return;
+				}
+
+				report({
+					message: messages.expected(hexValue, expectedHex),
+					node: decl,
+					index: declarationValueIndex(decl) + node.sourceIndex,
+					result,
+					ruleName,
+				});
+			});
+
+			if (needsFix) {
+				setDeclarationValue(decl, parsedValue.toString());
+			}
+		});
+	};
+}
+
+function canShrink(hex) {
+	hex = hex.toLowerCase();
+
+	return (
+		hex[1] === hex[2] &&
+		hex[3] === hex[4] &&
+		hex[5] === hex[6] &&
+		(hex.length === 7 || (hex.length === 9 && hex[7] === hex[8]))
+	);
+}
+
+function shorter(hex) {
+	let hexVariant = '#';
+
+	for (let i = 1; i < hex.length; i += 2) {
+		hexVariant += hex[i];
+	}
+
+	return hexVariant;
+}
+
+function longer(hex) {
+	let hexVariant = '#';
+
+	for (let i = 1; i < hex.length; i++) {
+		hexVariant += hex[i] + hex[i];
+	}
+
+	return hexVariant;
+}
+
+function isIgnoredFunction({ type, value }) {
+	return type === 'function' && IGNORED_FUNCTIONS.has(value.toLowerCase());
+}
+
+function isHexColor({ type, value }) {
+	return type === 'word' && HEX.test(value);
+}
+
+rule.ruleName = ruleName;
+rule.messages = messages;
+module.exports = rule;