create-docusaurus 0.0.0-4378 → 0.0.0-4379

package/templates/facebook/node_modules/stylelint/lib/utils/checkAgainstRule.js

@@ -0,0 +1,52 @@
+'use strict';
+
+const normalizeRuleSettings = require('../normalizeRuleSettings');
+const Result = require('postcss/lib/result');
+const rules = require('../rules');
+
+/**
+ * Useful for third-party code (e.g. plugins) to run a PostCSS Root
+ * against a specific rule and do something with the warnings
+ * @template T
+ * @template {Object} O
+ * @param {{
+		ruleName: string,
+		ruleSettings: import('stylelint').StylelintConfigRuleSettings<T, O>,
+		root: import('postcss').Root,
+	}} options
+ * @param {Function} callback
+ * @returns {void}
+ */
+module.exports = function (options, callback) {
+	if (!options)
+		throw new Error(
+			"checkAgainstRule requires an options object with 'ruleName', 'ruleSettings', and 'root' properties",
+		);
+
+	if (!callback) throw new Error('checkAgainstRule requires a callback');
+
+	if (!options.ruleName) throw new Error("checkAgainstRule requires a 'ruleName' option");
+
+	if (!Object.keys(rules).includes(options.ruleName))
+		throw new Error(`Rule '${options.ruleName}' does not exist`);
+
+	if (!options.ruleSettings) throw new Error("checkAgainstRule requires a 'ruleSettings' option");
+
+	if (!options.root) throw new Error("checkAgainstRule requires a 'root' option");
+
+	const settings = normalizeRuleSettings(options.ruleSettings, options.ruleName);
+
+	if (!settings) {
+		return;
+	}
+
+	// @ts-expect-error - this error should not occur with PostCSS 8
+	const tmpPostcssResult = new Result();
+
+	rules[options.ruleName](
+		settings[0],
+		/** @type {O} */ (settings[1]),
+		{},
+	)(options.root, tmpPostcssResult);
+	tmpPostcssResult.warnings().forEach(callback);
+};

package/templates/facebook/node_modules/stylelint/lib/utils/checkInvalidCLIOptions.js

@@ -0,0 +1,92 @@
+'use strict';
+
+const _ = require('lodash');
+const chalk = require('chalk');
+const EOL = require('os').EOL;
+const levenshtein = require('fastest-levenshtein');
+
+/**
+ * @param {{ [key: string]: { alias?: string } }} allowedOptions
+ * @return {string[]}
+ */
+const buildAllowedOptions = (allowedOptions) => {
+	let options = Object.keys(allowedOptions);
+
+	options = options.reduce((opts, opt) => {
+		const alias = allowedOptions[opt].alias;
+
+		if (alias) {
+			opts.push(alias);
+		}
+
+		return opts;
+	}, options);
+	options.sort();
+
+	return options;
+};
+
+/**
+ * @param {string[]} all
+ * @param {string} invalid
+ * @return {null|string}
+ */
+const suggest = (all, invalid) => {
+	const maxThreshold = 10;
+
+	for (let threshold = 1; threshold <= maxThreshold; threshold++) {
+		const suggestion = all.find((option) => levenshtein.distance(option, invalid) <= threshold);
+
+		if (suggestion) {
+			return suggestion;
+		}
+	}
+
+	return null;
+};
+
+/**
+ * @param {string} opt
+ * @return {string}
+ */
+const cliOption = (opt) => {
+	if (opt.length === 1) {
+		return `"-${opt}"`;
+	}
+
+	return `"--${_.kebabCase(opt)}"`;
+};
+
+/**
+ * @param {string} invalid
+ * @param {string|null} suggestion
+ * @return {string}
+ */
+const buildMessageLine = (invalid, suggestion) => {
+	let line = `Invalid option ${chalk.red(cliOption(invalid))}.`;
+
+	if (suggestion) {
+		line += ` Did you mean ${chalk.cyan(cliOption(suggestion))}?`;
+	}
+
+	return line + EOL;
+};
+
+/**
+ * @param {{ [key: string]: any }} allowedOptions
+ * @param {{ [key: string]: any }} inputOptions
+ * @return {string}
+ */
+module.exports = function checkInvalidCLIOptions(allowedOptions, inputOptions) {
+	const allOptions = buildAllowedOptions(allowedOptions);
+
+	return Object.keys(inputOptions)
+		.filter((opt) => !allOptions.includes(opt))
+		.map(_.kebabCase)
+		.reduce((msg, invalid) => {
+			// NOTE: No suggestion for shortcut options because it's too difficult
+			const suggestion = invalid.length >= 2 ? suggest(allOptions, invalid) : null;
+
+			return msg + buildMessageLine(invalid, suggestion);
+		}, '');
+};

package/templates/facebook/node_modules/stylelint/lib/utils/configurationError.js

@@ -0,0 +1,15 @@
+'use strict';
+
+/**
+ * Create configurationError from text and set CLI exit code
+ * @param {string} text
+ * @returns {Object}
+ */
+module.exports = function (text) /* Object */ {
+	/** @type {Error & {code?: number}} */
+	const err = new Error(text);
+
+	err.code = 78;
+
+	return err;
+};

package/templates/facebook/node_modules/stylelint/lib/utils/containsString.js

@@ -0,0 +1,56 @@
+'use strict';
+
+const _ = require('lodash');
+
+/** @typedef {false | { match: string, pattern: string }} ReturnValue */
+
+/**
+ * Checks if a string contains a value. The comparison value can be a string or
+ * an array of strings.
+ *
+ * Any strings starting and ending with `/` are ignored. Use the
+ * matchesStringOrRegExp() util to match regexes.
+ *
+ * @param {string} input
+ * @param {string | string[]} comparison
+ *
+ * @returns {ReturnValue}
+ */
+module.exports = function containsString(input, comparison) {
+	if (!Array.isArray(comparison)) {
+		return testAgainstString(input, comparison);
+	}
+
+	for (const comparisonItem of comparison) {
+		const testResult = testAgainstString(input, comparisonItem);
+
+		if (testResult) {
+			return testResult;
+		}
+	}
+
+	return false;
+};
+
+/**
+ *
+ * @param {string} value
+ * @param {string} comparison
+ *
+ * @returns {ReturnValue}
+ */
+function testAgainstString(value, comparison) {
+	if (!comparison) return false;
+
+	if (!_.isString(comparison)) return false;
+
+	if (comparison.startsWith('/') && comparison.endsWith('/')) {
+		return false;
+	}
+
+	if (value.includes(comparison)) {
+		return { match: value, pattern: comparison };
+	}
+
+	return false;
+}

package/templates/facebook/node_modules/stylelint/lib/utils/declarationValueIndex.js

@@ -0,0 +1,26 @@
+'use strict';
+
+const _ = require('lodash');
+
+/**
+ * Get the index of a declaration's value
+ *
+ * @param {import('postcss').Declaration} decl
+ *
+ * @returns {number}
+ */
+module.exports = function (decl) {
+	return [
+		_.get(decl, 'raws.prop.prefix'),
+		_.get(decl, 'raws.prop.raw', decl.prop),
+		_.get(decl, 'raws.prop.suffix'),
+		_.get(decl, 'raws.between', ':'),
+		_.get(decl, 'raws.value.prefix'),
+	].reduce((count, str) => {
+		if (str) {
+			return count + str.length;
+		}
+
+		return count;
+	}, 0);
+};

package/templates/facebook/node_modules/stylelint/lib/utils/eachDeclarationBlock.js

@@ -0,0 +1,59 @@
+'use strict';
+
+const { isRoot, isAtRule, isRule } = require('./typeGuards');
+
+/** @typedef {import('postcss').Root} Root */
+/** @typedef {import('postcss').Root} Document */
+/** @typedef {import('postcss').Node} PostcssNode */
+/** @typedef {import('postcss').ContainerBase} PostcssContainerNode */
+
+/**
+ * @param {PostcssNode} node
+ * @returns {node is PostcssContainerNode}
+ */
+function isContainerNode(node) {
+	return isRule(node) || isAtRule(node) || isRoot(node);
+}
+
+/**
+ * In order to accommodate nested blocks (postcss-nested),
+ * we need to run a shallow loop (instead of eachDecl() or eachRule(),
+ * which loop recursively) and allow each nested block to accumulate
+ * its own list of properties -- so that a property in a nested rule
+ * does not conflict with the same property in the parent rule
+ * executes a provided function once for each declaration block.
+ *
+ * @param {Root | Document} root - root element of file.
+ * @param {function} cb - Function to execute for each declaration block
+ *
+ * @returns {void}
+ */
+module.exports = function (root, cb) {
+	/**
+	 * @param {PostcssNode} statement
+	 *
+	 * @returns {void}
+	 */
+	function each(statement) {
+		if (!isContainerNode(statement)) return;
+
+		if (statement.nodes && statement.nodes.length) {
+			/** @type {PostcssNode[]} */
+			const decls = [];
+
+			statement.nodes.forEach((node) => {
+				if (node.type === 'decl') {
+					decls.push(node);
+				}
+
+				each(node);
+			});
+
+			if (decls.length) {
+				cb(decls.forEach.bind(decls));
+			}
+		}
+	}
+
+	each(root);
+};

package/templates/facebook/node_modules/stylelint/lib/utils/filterFilePaths.js

@@ -0,0 +1,19 @@
+'use strict';
+
+const { isPathValid } = require('ignore').default;
+
+/**
+ * @param {import('ignore').Ignore} ignorer
+ * @param {string[]} filePaths
+ * @returns {string[]}
+ */
+module.exports = function filterFilePaths(ignorer, filePaths) {
+	const validForIgnore = filePaths.filter(isPathValid);
+	// Paths which starts with `..` are not valid for `ignore`, e. g. `../style.css`
+	const notValidForIgnore = new Set(filePaths.filter((p) => !validForIgnore.includes(p)));
+
+	const filteredByIgnore = new Set(ignorer.filter(validForIgnore));
+
+	// Preserving files order, while removing paths which were filtered by `ignore`
+	return filePaths.filter((p) => notValidForIgnore.has(p) || filteredByIgnore.has(p));
+};

package/templates/facebook/node_modules/stylelint/lib/utils/findAnimationName.js

@@ -0,0 +1,69 @@
+'use strict';
+
+const getUnitFromValueNode = require('./getUnitFromValueNode');
+const isStandardSyntaxValue = require('./isStandardSyntaxValue');
+const isVariable = require('./isVariable');
+const keywordSets = require('../reference/keywordSets');
+const postcssValueParser = require('postcss-value-parser');
+
+/** @typedef {import('postcss-value-parser').Node} Node */
+
+/**
+ * Get the animation name within an `animation` shorthand property value.
+ *
+ * @param {string} value
+ *
+ * @returns {Node[]}
+ */
+module.exports = function findAnimationName(value) {
+	/** @type {Node[]} */
+	const animationNames = [];
+
+	const valueNodes = postcssValueParser(value);
+
+	// Handle `inherit`, `initial` and etc
+	if (
+		valueNodes.nodes.length === 1 &&
+		keywordSets.basicKeywords.has(valueNodes.nodes[0].value.toLowerCase())
+	) {
+		return [valueNodes.nodes[0]];
+	}
+
+	valueNodes.walk((valueNode) => {
+		if (valueNode.type === 'function') {
+			return false;
+		}
+
+		if (valueNode.type !== 'word') {
+			return;
+		}
+
+		const valueLowerCase = valueNode.value.toLowerCase();
+
+		// Ignore non-standard syntax
+		if (!isStandardSyntaxValue(valueLowerCase)) {
+			return;
+		}
+
+		// Ignore variables
+		if (isVariable(valueLowerCase)) {
+			return;
+		}
+
+		// Ignore keywords for other animation parts
+		if (keywordSets.animationShorthandKeywords.has(valueLowerCase)) {
+			return;
+		}
+
+		// Ignore numbers with units
+		const unit = getUnitFromValueNode(valueNode);
+
+		if (unit || unit === '') {
+			return;
+		}
+
+		animationNames.push(valueNode);
+	});
+
+	return animationNames;
+};

package/templates/facebook/node_modules/stylelint/lib/utils/findAtRuleContext.js

@@ -0,0 +1,23 @@
+'use strict';
+
+/**
+ * Find the at-rule in which a rule is nested.
+ *
+ * Returns `null` if the rule is not nested within an at-rule.
+ *
+ * @param {import('postcss').Rule} rule
+ * @returns {null | import('postcss').AtRule}
+ */
+module.exports = function findAtRuleContext(rule) {
+	const parent = rule.parent;
+
+	if (parent.type === 'root') {
+		return null;
+	}
+
+	if (parent.type === 'atrule') {
+		return parent;
+	}
+
+	return findAtRuleContext(parent);
+};

package/templates/facebook/node_modules/stylelint/lib/utils/findFontFamily.js

@@ -0,0 +1,128 @@
+'use strict';
+
+const isNumbery = require('./isNumbery');
+const isStandardSyntaxValue = require('./isStandardSyntaxValue');
+const isValidFontSize = require('./isValidFontSize');
+const isVariable = require('./isVariable');
+const keywordSets = require('../reference/keywordSets');
+const postcssValueParser = require('postcss-value-parser');
+
+const nodeTypesToCheck = new Set(['word', 'string', 'space', 'div']);
+
+/** @typedef {import('postcss-value-parser').Node} Node */
+
+/**
+ *
+ * @param {Node} firstNode
+ * @param {Node} secondNode
+ * @param {string | null} charactersBetween
+ *
+ * @returns {Node}
+ */
+function joinValueNodes(firstNode, secondNode, charactersBetween) {
+	firstNode.value = firstNode.value + charactersBetween + secondNode.value;
+
+	return firstNode;
+}
+
+/**
+ * Get the font-families within a `font` shorthand property value.
+ *
+ * @param {string} value
+ * @return {object} Collection font-family nodes
+ */
+module.exports = function findFontFamily(value) {
+	/** @type {Node[]} */
+	const fontFamilies = [];
+
+	const valueNodes = postcssValueParser(value);
+
+	// Handle `inherit`, `initial` and etc
+	if (
+		valueNodes.nodes.length === 1 &&
+		keywordSets.basicKeywords.has(valueNodes.nodes[0].value.toLowerCase())
+	) {
+		return [valueNodes.nodes[0]];
+	}
+
+	let needMergeNodesByValue = false;
+	/** @type {string | null} */
+	let mergeCharacters = null;
+
+	valueNodes.walk((valueNode, index, nodes) => {
+		if (valueNode.type === 'function') {
+			return false;
+		}
+
+		if (!nodeTypesToCheck.has(valueNode.type)) {
+			return;
+		}
+
+		const valueLowerCase = valueNode.value.toLowerCase();
+
+		// Ignore non standard syntax
+		if (!isStandardSyntaxValue(valueLowerCase)) {
+			return;
+		}
+
+		// Ignore variables
+		if (isVariable(valueLowerCase)) {
+			return;
+		}
+
+		// Ignore keywords for other font parts
+		if (
+			keywordSets.fontShorthandKeywords.has(valueLowerCase) &&
+			!keywordSets.fontFamilyKeywords.has(valueLowerCase)
+		) {
+			return;
+		}
+
+		// Ignore font-sizes
+		if (isValidFontSize(valueNode.value)) {
+			return;
+		}
+
+		// Ignore anything come after a <font-size>/, because it's a line-height
+		if (
+			nodes[index - 1] &&
+			nodes[index - 1].value === '/' &&
+			nodes[index - 2] &&
+			isValidFontSize(nodes[index - 2].value)
+		) {
+			return;
+		}
+
+		// Ignore number values
+		if (isNumbery(valueLowerCase)) {
+			return;
+		}
+
+		// Detect when a space or comma is dividing a list of font-families, and save the joining character.
+		if (
+			(valueNode.type === 'space' || (valueNode.type === 'div' && valueNode.value !== ',')) &&
+			fontFamilies.length !== 0
+		) {
+			needMergeNodesByValue = true;
+			mergeCharacters = valueNode.value;
+
+			return;
+		}
+
+		if (valueNode.type === 'space' || valueNode.type === 'div') {
+			return;
+		}
+
+		const fontFamily = valueNode;
+
+		if (needMergeNodesByValue) {
+			joinValueNodes(fontFamilies[fontFamilies.length - 1], valueNode, mergeCharacters);
+			needMergeNodesByValue = false;
+			mergeCharacters = null;
+		} else {
+			fontFamilies.push(fontFamily);
+		}
+	});
+
+	return fontFamilies;
+};

package/templates/facebook/node_modules/stylelint/lib/utils/findListStyleType.js

@@ -0,0 +1,60 @@
+'use strict';
+
+const isStandardSyntaxValue = require('./isStandardSyntaxValue');
+const isVariable = require('./isVariable');
+const keywordSets = require('../reference/keywordSets');
+const postcssValueParser = require('postcss-value-parser');
+
+/**
+ * Get the list-style-type within a `list-style` shorthand property value.
+ *
+ * @param {string} value
+ */
+module.exports = function findListStyleType(value) {
+	/** @type {Array<import('postcss-value-parser').WordNode>} */
+	const listStyleTypes = [];
+
+	const valueNodes = postcssValueParser(value);
+
+	// Handle `inherit`, `initial` and etc
+	if (
+		valueNodes.nodes.length === 1 &&
+		keywordSets.listStyleTypeKeywords.has(valueNodes.nodes[0].value.toLowerCase())
+	) {
+		return [valueNodes.nodes[0]];
+	}
+
+	valueNodes.walk((valueNode) => {
+		if (valueNode.type === 'function') {
+			return false;
+		}
+
+		if (valueNode.type !== 'word') {
+			return;
+		}
+
+		const valueLowerCase = valueNode.value.toLowerCase();
+
+		// Ignore non standard syntax
+		if (!isStandardSyntaxValue(valueLowerCase)) {
+			return;
+		}
+
+		// Ignore variables
+		if (isVariable(valueLowerCase)) {
+			return;
+		}
+
+		// Ignore keywords for other font parts
+		if (
+			keywordSets.listStylePositionKeywords.has(valueLowerCase) ||
+			keywordSets.listStyleImageKeywords.has(valueLowerCase)
+		) {
+			return;
+		}
+
+		listStyleTypes.push(valueNode);
+	});
+
+	return listStyleTypes;
+};

package/templates/facebook/node_modules/stylelint/lib/utils/functionArgumentsSearch.js

@@ -0,0 +1,41 @@
+'use strict';
+
+const balancedMatch = require('balanced-match');
+const styleSearch = require('style-search');
+
+/**
+ * Search a CSS string for functions by name.
+ * For every match, invoke the callback, passing the function's
+ * "argument(s) string" (whatever is inside the parentheses)
+ * as an argument.
+ *
+ * Callback will be called once for every matching function found,
+ * with the function's "argument(s) string" and its starting index
+ * as the arguments.
+ *
+ * @param {string} source
+ * @param {string} functionName
+ * @param {Function} callback
+ */
+module.exports = function (source, functionName, callback) {
+	styleSearch(
+		{
+			source,
+			target: functionName,
+			functionNames: 'check',
+		},
+		(match) => {
+			if (source[match.endIndex] !== '(') {
+				return;
+			}
+
+			const parensMatch = balancedMatch('(', ')', source.substr(match.startIndex));
+
+			if (!parensMatch) {
+				throw new Error(`No parens match: "${source}"`);
+			}
+
+			callback(parensMatch.body, match.endIndex + 1);
+		},
+	);
+};

package/templates/facebook/node_modules/stylelint/lib/utils/getAtRuleParams.js

@@ -0,0 +1,11 @@
+'use strict';
+
+const _ = require('lodash');
+
+/**
+ * @param {import('postcss').AtRule} atRule
+ * @returns {string}
+ */
+module.exports = function getAtRuleParams(atRule) {
+	return _.get(atRule, 'raws.params.raw', atRule.params);
+};