create-docusaurus 0.0.0-4376 → 0.0.0-4383

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

@@ -0,0 +1,176 @@
+# color-named
+
+Require (where possible) or disallow named colors.
+
+<!-- prettier-ignore -->
+```css
+a { color: black }
+/**        ↑
+ * This named color */
+```
+
+This rule ignores `$sass` and `@less` variable syntaxes.
+
+## Options
+
+`string`: `"always-where-possible"|"never"`
+
+### `"always-where-possible"`
+
+Colors _must always_, where possible, be named.
+
+This will complain if a hex (3, 4, 6 and 8 digit), `rgb()`, `rgba()`, `hsl()`, `hsla()`, `hwb()` or `gray()` color can be represented as a named color.
+
+The following patterns are considered violations:
+
+<!-- prettier-ignore -->
+```css
+a { color: #000; }
+```
+
+<!-- prettier-ignore -->
+```css
+a { color: #f000; }
+```
+
+<!-- prettier-ignore -->
+```css
+a { color: #ff000000; }
+```
+
+<!-- prettier-ignore -->
+```css
+a { color: rgb(0, 0, 0); }
+```
+
+<!-- prettier-ignore -->
+```css
+a { color: rgb(0%, 0%, 0%); }
+```
+
+<!-- prettier-ignore -->
+```css
+a { color: rgba(0, 0, 0, 0); }
+```
+
+<!-- prettier-ignore -->
+```css
+a { color: hsl(0, 0%, 0%); }
+```
+
+<!-- prettier-ignore -->
+```css
+a { color: hwb(0, 0%, 100%); }
+```
+
+<!-- prettier-ignore -->
+```css
+a { color: gray(0); }
+```
+
+The following patterns are _not_ considered violations:
+
+<!-- prettier-ignore -->
+```css
+a { color: black; }
+```
+
+<!-- prettier-ignore -->
+```css
+a { color: rgb(10, 0, 0); }
+```
+
+<!-- prettier-ignore -->
+```css
+a { color: rgb(0, 0, 0, 0.5); }
+```
+
+### `"never"`
+
+Colors _must never_ be named.
+
+The following patterns are considered violations:
+
+<!-- prettier-ignore -->
+```css
+a { color: black; }
+```
+
+<!-- prettier-ignore -->
+```css
+a { color: white; }
+```
+
+The following patterns are _not_ considered violations:
+
+<!-- prettier-ignore -->
+```css
+a { color: #000; }
+```
+
+<!-- prettier-ignore -->
+```css
+a { color: rgb(0, 0, 0); }
+```
+
+<!-- prettier-ignore -->
+```css
+a { color: var(--white); }
+```
+
+## Optional secondary options
+
+### `ignore: ["inside-function"]`
+
+Ignore colors that are inside a function.
+
+For example, with `"never"`.
+
+The following patterns are _not_ considered violations:
+
+<!-- prettier-ignore -->
+```css
+a {
+  color: map-get($colour, blue);
+}
+```
+
+<!-- prettier-ignore -->
+```css
+a {
+  background-image: url(red);
+}
+```
+
+### `ignoreProperties: ["/regex/", /regex/, "string"]`
+
+For example with `"never"`.
+
+Given:
+
+```
+["/^my-/", "composes"]
+```
+
+The following patterns are _not_ considered violations:
+
+<!-- prettier-ignore -->
+```css
+a {
+  my-property: red;
+}
+```
+
+<!-- prettier-ignore -->
+```css
+a {
+  my-other-property: red;
+}
+```
+
+<!-- prettier-ignore -->
+```css
+a {
+  composes: red from './index.css';
+}
+```

package/templates/facebook/node_modules/stylelint/lib/rules/color-named/generateColorFuncs.js

@@ -0,0 +1,198 @@
+// @ts-nocheck
+
+'use strict';
+
+// these algorithms are sourced from https://drafts.csswg.org/css-color/#color-conversion-code
+
+function lin_sRGB(RGB) {
+	// convert an array of sRGB values in the range 0.0 - 1.0
+	// to linear light (un-companded) form.
+	// https://en.wikipedia.org/wiki/SRGB
+	return RGB.map((val) => {
+		if (val < 0.04045) {
+			return val / 12.92;
+		}
+
+		return ((val + 0.055) / 1.055) ** 2.4;
+	});
+}
+
+function matrixMultiple3d(matrix, vector) {
+	return [
+		matrix[0][0] * vector[0] + matrix[0][1] * vector[1] + matrix[0][2] * vector[2],
+		matrix[1][0] * vector[0] + matrix[1][1] * vector[1] + matrix[1][2] * vector[2],
+		matrix[2][0] * vector[0] + matrix[2][1] * vector[1] + matrix[2][2] * vector[2],
+	];
+}
+
+function srgb2xyz(srgb) {
+	return matrixMultiple3d(
+		[
+			[0.4124564, 0.3575761, 0.1804375],
+			[0.2126729, 0.7151522, 0.072175],
+			[0.0193339, 0.119192, 0.9503041],
+		],
+		srgb,
+	);
+}
+
+function chromaticAdaptationD65_D50(xyz) {
+	return matrixMultiple3d(
+		[
+			[1.0478112, 0.0228866, -0.050127],
+			[0.0295424, 0.9904844, -0.0170491],
+			[-0.0092345, 0.0150436, 0.7521316],
+		],
+		xyz,
+	);
+}
+
+function xyz2lab(xyzIn) {
+	// Assuming XYZ is relative to D50, convert to CIE Lab
+	// from CIE standard, which now defines these as a rational fraction
+	const ε = 216 / 24389; // 6^3/29^3
+	const κ = 24389 / 27; // 29^3/3^3
+	const white = [0.9642, 1.0, 0.8249]; // D50 reference white
+
+	// compute xyz, which is XYZ scaled relative to reference white
+	const xyz = xyzIn.map((value, i) => value / white[i]);
+
+	// now compute f
+	const f = xyz.map((value) => {
+		if (value > ε) {
+			return Math.cbrt(value);
+		}
+
+		return (κ * value + 16) / 116;
+	});
+
+	return [
+		116 * f[1] - 16, // L
+		500 * (f[0] - f[1]), // a
+		200 * (f[1] - f[2]), // b
+	];
+}
+
+function rgb2hsl(r, g, b) {
+	r /= 255;
+	g /= 255;
+	b /= 255;
+	let h;
+	let s;
+	let l;
+	const M = Math.max(r, g, b);
+	const m = Math.min(r, g, b);
+	const d = M - m;
+
+	if (d === 0) {
+		h = 0;
+	} else if (M === r) {
+		h = ((g - b) / d) % 6;
+	} else if (M === g) {
+		h = (b - r) / d + 2;
+	} else {
+		h = (r - g) / d + 4;
+	}
+
+	h *= 60;
+
+	if (h < 0) {
+		h += 360;
+	}
+
+	l = (M + m) / 2;
+
+	s = d === 0 ? 0 : d / (1 - Math.abs(2 * l - 1));
+
+	s *= 100;
+	l *= 100;
+
+	return [Math.round(h), Math.round(s), Math.round(l)];
+}
+
+function rgb2hwb(rgb_r, rgb_g, rgb_b) {
+	rgb_r /= 255;
+	rgb_g /= 255;
+	rgb_b /= 255;
+
+	const w = Math.min(rgb_r, rgb_g, rgb_b);
+	const v = Math.max(rgb_r, rgb_g, rgb_b);
+
+	const b = 1 - v;
+
+	if (v === w) {
+		return [0, Math.round(w * 100), Math.round(b * 100)];
+	}
+
+	const f = rgb_r === w ? rgb_g - rgb_b : rgb_g === w ? rgb_b - rgb_r : rgb_r - rgb_g;
+	const i = rgb_r === w ? 3 : rgb_g === w ? 5 : 1;
+
+	return [
+		Math.round(((i - f / (v - w)) / 6) * 360) % 360,
+		Math.round(w * 100),
+		Math.round(b * 100),
+	];
+}
+
+function perc255(value) {
+	return `${Math.round((value * 100) / 255)}%`;
+}
+
+function generateColorFuncs(hexString) {
+	if (hexString.length !== 7) {
+		throw new Error(
+			`Invalid hex string color definition (${hexString}) - expected 6 character hex string`,
+		);
+	}
+
+	const rgb = [0, 0, 0];
+
+	for (let i = 0; i < 3; i += 1) {
+		rgb[i] = Number.parseInt(hexString.substr(2 * i + 1, 2), 16);
+	}
+
+	const hsl = rgb2hsl(rgb[0], rgb[1], rgb[2]);
+	const hwb = rgb2hwb(rgb[0], rgb[1], rgb[2]);
+	const func = [];
+	const rgbStr = `${rgb[0]},${rgb[1]},${rgb[2]}`;
+	const rgbPercStr = `${perc255(rgb[0])},${perc255(rgb[1])},${perc255(rgb[2])}`;
+	const hslStr = `${hsl[0]},${hsl[1]}%,${hsl[2]}%`;
+	const hwbStr = `${hwb[0]},${hwb[1]}%,${hwb[2]}%`;
+
+	// *very* convoluted process, just to be able to establish if the color
+	// is gray -- or not.
+	const linRgb = lin_sRGB([rgb[0] / 255, rgb[1] / 255, rgb[2] / 255]);
+	const xyz_d65 = srgb2xyz(linRgb);
+	const xyz_d50 = chromaticAdaptationD65_D50(xyz_d65);
+	const lab = xyz2lab(xyz_d50);
+
+	func.push(`rgb(${rgbStr})`);
+	func.push(`rgba(${rgbStr},1)`);
+	func.push(`rgba(${rgbStr},100%)`);
+	func.push(`rgb(${rgbPercStr})`);
+	func.push(`rgba(${rgbPercStr},1)`);
+	func.push(`rgba(${rgbPercStr},100%)`);
+	func.push(`hsl(${hslStr})`);
+	func.push(`hsla(${hslStr},1)`);
+	func.push(`hsla(${hslStr},100%)`);
+	func.push(`hwb(${hwbStr})`);
+	func.push(`hwb(${hwbStr},1)`);
+	func.push(`hwb(${hwbStr},100%)`);
+
+	// technically, this should be 0 - but then #808080 wouldn't even be gray
+	if (lab[1] * lab[1] < 0.01 && lab[2] * lab[2] < 0.01) {
+		// yay! gray!
+		const grayStr = Math.round(lab[0]);
+
+		func.push(`gray(${grayStr})`);
+		func.push(`gray(${grayStr},1)`);
+		func.push(`gray(${grayStr},100%)`);
+		func.push(`gray(${grayStr}%)`);
+		func.push(`gray(${grayStr}%,1)`);
+		func.push(`gray(${grayStr}%,100%)`);
+	}
+
+	return func;
+}
+
+module.exports = generateColorFuncs;

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

@@ -0,0 +1,169 @@
+// @ts-nocheck
+
+'use strict';
+
+const _ = require('lodash');
+const declarationValueIndex = require('../../utils/declarationValueIndex');
+const isStandardSyntaxFunction = require('../../utils/isStandardSyntaxFunction');
+const isStandardSyntaxValue = require('../../utils/isStandardSyntaxValue');
+const keywordSets = require('../../reference/keywordSets');
+const namedColorDataHex = require('../../reference/namedColorData');
+const optionsMatches = require('../../utils/optionsMatches');
+const propertySets = require('../../reference/propertySets');
+const report = require('../../utils/report');
+const ruleMessages = require('../../utils/ruleMessages');
+const validateOptions = require('../../utils/validateOptions');
+const valueParser = require('postcss-value-parser');
+
+const generateColorFuncs = require('./generateColorFuncs');
+
+const ruleName = 'color-named';
+
+const messages = ruleMessages(ruleName, {
+	expected: (named, original) => `Expected "${original}" to be "${named}"`,
+	rejected: (named) => `Unexpected named color "${named}"`,
+});
+
+// Todo tested on case insensitivity
+const NODE_TYPES = new Set(['word', 'function']);
+
+function rule(expectation, options) {
+	return (root, result) => {
+		const validOptions = validateOptions(
+			result,
+			ruleName,
+			{
+				actual: expectation,
+				possible: ['never', 'always-where-possible'],
+			},
+			{
+				actual: options,
+				possible: {
+					ignoreProperties: [_.isString, _.isRegExp],
+					ignore: ['inside-function'],
+				},
+				optional: true,
+			},
+		);
+
+		if (!validOptions) {
+			return;
+		}
+
+		const namedColors = Object.keys(namedColorDataHex);
+		const namedColorData = {};
+
+		namedColors.forEach((name) => {
+			const hex = namedColorDataHex[name];
+
+			namedColorData[name] = {
+				hex,
+				func: generateColorFuncs(hex[0]),
+			};
+		});
+
+		root.walkDecls((decl) => {
+			if (propertySets.acceptCustomIdents.has(decl.prop)) {
+				return;
+			}
+
+			// Return early if the property is to be ignored
+			if (optionsMatches(options, 'ignoreProperties', decl.prop)) {
+				return;
+			}
+
+			valueParser(decl.value).walk((node) => {
+				const value = node.value;
+				const type = node.type;
+				const sourceIndex = node.sourceIndex;
+
+				if (optionsMatches(options, 'ignore', 'inside-function') && type === 'function') {
+					return false;
+				}
+
+				if (!isStandardSyntaxFunction(node)) {
+					return false;
+				}
+
+				if (!isStandardSyntaxValue(value)) {
+					return;
+				}
+
+				// Return early if neither a word nor a function
+				if (!NODE_TYPES.has(type)) {
+					return;
+				}
+
+				// Check for named colors for "never" option
+				if (
+					expectation === 'never' &&
+					type === 'word' &&
+					namedColors.includes(value.toLowerCase())
+				) {
+					complain(messages.rejected(value), decl, declarationValueIndex(decl) + sourceIndex);
+
+					return;
+				}
+
+				// Check "always-where-possible" option ...
+				if (expectation !== 'always-where-possible') {
+					return;
+				}
+
+				// First by checking for alternative color function representations ...
+				if (type === 'function' && keywordSets.colorFunctionNames.has(value.toLowerCase())) {
+					// Remove all spaces to match what's in `representations`
+					const normalizedFunctionString = valueParser.stringify(node).replace(/\s+/g, '');
+					let namedColor;
+
+					for (let i = 0, l = namedColors.length; i < l; i++) {
+						namedColor = namedColors[i];
+
+						if (namedColorData[namedColor].func.includes(normalizedFunctionString.toLowerCase())) {
+							complain(
+								messages.expected(namedColor, normalizedFunctionString),
+								decl,
+								declarationValueIndex(decl) + sourceIndex,
+							);
+
+							return; // Exit as soon as a problem is found
+						}
+					}
+
+					return;
+				}
+
+				// Then by checking for alternative hex representations
+				let namedColor;
+
+				for (let i = 0, l = namedColors.length; i < l; i++) {
+					namedColor = namedColors[i];
+
+					if (namedColorData[namedColor].hex.includes(value.toLowerCase())) {
+						complain(
+							messages.expected(namedColor, value),
+							decl,
+							declarationValueIndex(decl) + sourceIndex,
+						);
+
+						return; // Exit as soon as a problem is found
+					}
+				}
+			});
+		});
+
+		function complain(message, node, index) {
+			report({
+				result,
+				ruleName,
+				message,
+				node,
+				index,
+			});
+		}
+	};
+}
+
+rule.ruleName = ruleName;
+rule.messages = messages;
+module.exports = rule;

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

@@ -0,0 +1,60 @@
+# color-no-hex
+
+Disallow hex colors.
+
+<!-- prettier-ignore -->
+```css
+a { color: #333 }
+/**        ↑
+ * This hex color */
+```
+
+## Options
+
+### `true`
+
+The following patterns are considered violations:
+
+<!-- prettier-ignore -->
+```css
+a { color: #000; }
+```
+
+<!-- prettier-ignore -->
+```css
+a { color: #fff1aa; }
+```
+
+<!-- prettier-ignore -->
+```css
+a { color: #123456aa; }
+```
+
+Hex values that are not valid also cause violations:
+
+<!-- prettier-ignore -->
+```css
+a { color: #foobar; }
+```
+
+<!-- prettier-ignore -->
+```css
+a { color: #0000000000000000; }
+```
+
+The following patterns are _not_ considered violations:
+
+<!-- prettier-ignore -->
+```css
+a { color: black; }
+```
+
+<!-- prettier-ignore -->
+```css
+a { color: rgb(0, 0, 0); }
+```
+
+<!-- prettier-ignore -->
+```css
+a { color: rgba(0, 0, 0, 1); }
+```

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

@@ -0,0 +1,60 @@
+// @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 validateOptions = require('../../utils/validateOptions');
+
+const ruleName = 'color-no-hex';
+
+const messages = ruleMessages(ruleName, {
+	rejected: (hex) => `Unexpected hex color "${hex}"`,
+});
+
+const HEX = /^#[0-9A-Za-z]+/;
+const IGNORED_FUNCTIONS = new Set(['url']);
+
+function rule(actual) {
+	return (root, result) => {
+		const validOptions = validateOptions(result, ruleName, { actual });
+
+		if (!validOptions) {
+			return;
+		}
+
+		root.walkDecls((decl) => {
+			const parsedValue = valueParser(getDeclarationValue(decl));
+
+			parsedValue.walk((node) => {
+				if (isIgnoredFunction(node)) return false;
+
+				if (!isHexColor(node)) return;
+
+				report({
+					message: messages.rejected(node.value),
+					node: decl,
+					index: declarationValueIndex(decl) + node.sourceIndex,
+					result,
+					ruleName,
+				});
+			});
+		});
+	};
+}
+
+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-no-invalid-hex/README.md

@@ -0,0 +1,55 @@
+# color-no-invalid-hex
+
+Disallow invalid hex colors.
+
+<!-- prettier-ignore -->
+```css
+a { color: #y3 }
+/**        ↑
+ * This hex color */
+```
+
+Longhand hex colors can be either 6 or 8 (with alpha channel) hexadecimal characters. And their shorthand variants are 3 and 4 characters respectively.
+
+## Options
+
+### `true`
+
+The following patterns are considered violations:
+
+<!-- prettier-ignore -->
+```css
+a { color: #00; }
+```
+
+<!-- prettier-ignore -->
+```css
+a { color: #fff1az; }
+```
+
+<!-- prettier-ignore -->
+```css
+a { color: #12345aa; }
+```
+
+The following patterns are _not_ considered violations:
+
+<!-- prettier-ignore -->
+```css
+a { color: #000; }
+```
+
+<!-- prettier-ignore -->
+```css
+a { color: #000f; }
+```
+
+<!-- prettier-ignore -->
+```css
+a { color: #fff1a0; }
+```
+
+<!-- prettier-ignore -->
+```css
+a { color: #123450aa; }
+```