create-docusaurus 0.0.0-4375 → 0.0.0-4379

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

@@ -0,0 +1,18 @@
+'use strict';
+
+const selectorParser = require('postcss-selector-parser');
+
+/**
+ * @param {string} selector
+ * @param {import('stylelint').PostcssResult} result
+ * @param {import('postcss').Node} node
+ * @param {Function} cb
+ */
+module.exports = function parseSelector(selector, result, node, cb) {
+	try {
+		// @ts-ignore TODO TYPES wrong postcss-selector-parser types
+		return selectorParser(cb).processSync(selector);
+	} catch {
+		result.warn('Cannot parse selector', { node, stylelintType: 'parseError' });
+	}
+};

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

@@ -0,0 +1,22 @@
+'use strict';
+
+/**
+ * If `map` already has the given `key`, returns its value. Otherwise, calls
+ * `callback`, adds the result to `map` at `key`, and then returns it.
+ *
+ * @template K
+ * @template V
+ * @param {Map<K, V>} map
+ * @param {K} key
+ * @param {() => V} callback
+ * @returns {V}
+ */
+module.exports = function (map, key, callback) {
+	if (map.has(key)) return /** @type {V} */ (map.get(key));
+
+	const value = callback();
+
+	map.set(key, value);
+
+	return value;
+};

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

@@ -0,0 +1,20 @@
+'use strict';
+
+/**
+ * Stringify PostCSS node including its raw "before" string.
+ *
+ * @param {import('postcss').Node} node
+ *
+ * @returns {string}
+ */
+module.exports = function (node) {
+	let result = '';
+
+	if (node.raws.before) {
+		result += node.raws.before;
+	}
+
+	result += node.toString();
+
+	return result;
+};

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

@@ -0,0 +1,15 @@
+'use strict';
+
+/**
+ * Remove empty lines before a node. Mutates the node.
+ *
+ * @param {import('postcss').Node} node
+ * @param {'\n' | '\r\n'} newline
+ */
+function removeEmptyLinesAfter(node, newline) {
+	node.raws.after = node.raws.after ? node.raws.after.replace(/(\r?\n\s*\r?\n)+/g, newline) : '';
+
+	return node;
+}
+
+module.exports = removeEmptyLinesAfter;

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

@@ -0,0 +1,15 @@
+'use strict';
+
+/**
+ * Remove empty lines before a node. Mutates the node.
+ *
+ * @param {import('postcss').Node} node
+ * @param {'\n' | '\r\n'} newline
+ */
+function removeEmptyLinesBefore(node, newline) {
+	node.raws.before = node.raws.before ? node.raws.before.replace(/(\r?\n\s*\r?\n)+/g, newline) : '';
+
+	return node;
+}
+
+module.exports = removeEmptyLinesBefore;

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

@@ -0,0 +1,113 @@
+'use strict';
+
+const _ = require('lodash');
+
+/** @typedef {{
+  ruleName: string,
+  result: import('stylelint').PostcssResult,
+  message: string,
+  node: import('postcss').Node & {
+    positionBy(opts: { index?: number, word?: string }): { line: number, column: number }
+  },
+  index?: number,
+  word?: string,
+  line?: number
+}} Violation */
+
+/**
+ * Report a violation.
+ *
+ * This function accounts for `disabledRanges` attached to the result.
+ * That is, if the reported violation is within a disabledRange,
+ * it is ignored. Otherwise, it is attached to the result as a
+ * postcss warning.
+ *
+ * It also accounts for the rule's severity.
+ *
+ * You *must* pass *either* a node or a line number.
+ * @param {Violation} violation
+ */
+module.exports = function (violation) {
+	const ruleName = violation.ruleName;
+	const result = violation.result;
+	const message = violation.message;
+	const line = violation.line;
+	const node = violation.node;
+	const index = violation.index;
+	const word = violation.word;
+
+	result.stylelint = result.stylelint || {
+		ruleSeverities: {},
+		customMessages: {},
+	};
+
+	// In quiet mode, mere warnings are ignored
+	if (result.stylelint.quiet && result.stylelint.ruleSeverities[ruleName] !== 'error') {
+		return;
+	}
+
+	// If a line is not passed, use the node.positionBy method to get the
+	// line number that the complaint pertains to
+	const startLine = line || node.positionBy({ index }).line;
+
+	const { ignoreDisables } = result.stylelint.config || {};
+
+	if (result.stylelint.disabledRanges) {
+		const ranges = result.stylelint.disabledRanges[ruleName] || result.stylelint.disabledRanges.all;
+
+		for (const range of ranges) {
+			if (
+				// If the violation is within a disabledRange,
+				// and that disabledRange's rules include this one,
+				// do not register a warning
+				range.start <= startLine &&
+				(range.end === undefined || range.end >= startLine) &&
+				(!range.rules || range.rules.includes(ruleName))
+			) {
+				// Collect disabled warnings
+				// Used to report `needlessDisables` in subsequent processing.
+				const disabledWarnings =
+					result.stylelint.disabledWarnings || (result.stylelint.disabledWarnings = []);
+
+				disabledWarnings.push({
+					rule: ruleName,
+					line: startLine,
+				});
+
+				if (!ignoreDisables) {
+					return;
+				}
+
+				break;
+			}
+		}
+	}
+
+	const severity = _.get(result.stylelint, ['ruleSeverities', ruleName]);
+
+	if (!result.stylelint.stylelintError && severity === 'error') {
+		result.stylelint.stylelintError = true;
+	}
+
+	/** @type {import('stylelint').StylelintWarningOptions} */
+	const warningProperties = {
+		severity,
+		rule: ruleName,
+	};
+
+	if (node) {
+		warningProperties.node = node;
+	}
+
+	if (index) {
+		warningProperties.index = index;
+	}
+
+	if (word) {
+		warningProperties.word = word;
+	}
+
+	const warningMessage = _.get(result.stylelint, ['customMessages', ruleName], message);
+
+	result.warn(warningMessage, warningProperties);
+};

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

@@ -0,0 +1,35 @@
+'use strict';
+
+/**
+ * Given an object of violation messages, return another
+ * that provides the same messages postfixed with the rule
+ * that has been violated.
+ *
+ * @param {string} ruleName
+ * @param {{[k: string]: string|Function}} messages - Object whose keys are message identifiers
+ *   and values are either message strings or functions that return message strings
+ * @return {{[k: string]: string|Function}} New message object, whose messages will be marked with the rule name
+ */
+module.exports = function (ruleName, messages) {
+	return Object.keys(messages).reduce(
+		/**
+		 * @param {{[k: string]: string|Function}} newMessages
+		 * @param {string} messageId
+		 * @return {{[k: string]: string|Function}}
+		 */
+		(newMessages, messageId) => {
+			const messageText = messages[messageId];
+
+			if (typeof messageText === 'string') {
+				newMessages[messageId] = `${messageText} (${ruleName})`;
+			} else {
+				newMessages[messageId] = (/** @type {any[]} */ ...args) => {
+					return `${messageText(...args)} (${ruleName})`;
+				};
+			}
+
+			return newMessages;
+		},
+		{},
+	);
+};

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

@@ -0,0 +1,20 @@
+'use strict';
+
+const _ = require('lodash');
+
+/** @typedef {import('postcss').AtRule} AtRule */
+
+/**
+ * @param {AtRule} atRule
+ * @param {string} params
+ * @returns {AtRule} The atRulearation that was passed in.
+ */
+module.exports = function setAtRuleParams(atRule, params) {
+	if (_.has(atRule, 'raws.params')) {
+		_.set(atRule, 'raws.params.raw', params);
+	} else {
+		atRule.params = params;
+	}
+
+	return atRule;
+};

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

@@ -0,0 +1,23 @@
+'use strict';
+
+const _ = require('lodash');
+
+/** @typedef {import('postcss').Declaration} Declaration */
+
+/**
+ * @param {Declaration} decl
+ * @param {string} value
+ * @returns {Declaration} The declaration that was passed in.
+ */
+module.exports = function setDeclarationValue(decl, value) {
+	// Lodash is necessary here because the declaration may not strictly adhere
+	// to the current version of PostCSS's Declaration interface.
+	// See also: https://github.com/stylelint/stylelint/pull/5183/files#r588047494
+	if (_.has(decl, 'raws.value')) {
+		_.set(decl, 'raws.value.raw', value);
+	} else {
+		decl.value = value;
+	}
+
+	return decl;
+};

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

@@ -0,0 +1,17 @@
+'use strict';
+
+const selectorParser = require('postcss-selector-parser');
+
+/**
+ * @param {import('stylelint').PostcssResult} result
+ * @param {import('postcss').Node} node
+ * @param {Function} cb
+ */
+module.exports = function (result, node, cb) {
+	try {
+		// @ts-ignore TODO TYPES wrong postcss-selector-parser definitions
+		return selectorParser(cb).processSync(node, { updateSelector: true });
+	} catch {
+		result.warn('Cannot parse selector', { node, stylelintType: 'parseError' });
+	}
+};

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

@@ -0,0 +1,44 @@
+'use strict';
+
+/** @typedef {import('postcss').Node} Node */
+/** @typedef {import('postcss').Node} NodeSource */
+
+/**
+ * @param {Node} node
+ * @returns {node is import('postcss').Root}
+ */
+module.exports.isRoot = function isRoot(node) {
+	return node.type === 'root';
+};
+
+/**
+ * @param {Node} node
+ * @returns {node is import('postcss').Rule}
+ */
+module.exports.isRule = function isRule(node) {
+	return node.type === 'rule';
+};
+
+/**
+ * @param {Node} node
+ * @returns {node is import('postcss').AtRule}
+ */
+module.exports.isAtRule = function isAtRule(node) {
+	return node.type === 'atrule';
+};
+
+/**
+ * @param {Node} node
+ * @returns {node is import('postcss').Comment}
+ */
+module.exports.isComment = function isComment(node) {
+	return node.type === 'comment';
+};
+
+/**
+ * @param {Node} node
+ * @returns {node is (Node & {source: NodeSource})}
+ */
+module.exports.hasSource = function hasSource(node) {
+	return Boolean(node.source);
+};

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

@@ -0,0 +1,41 @@
+'use strict';
+
+const _ = require('lodash');
+
+/**
+ * @template T
+ * @typedef {(i: T) => boolean} Validator
+ */
+
+/**
+ * Check whether the variable is an object and all it's properties are arrays of string values:
+ *
+ * ignoreProperties = {
+ *   value1: ["item11", "item12", "item13"],
+ *   value2: ["item21", "item22", "item23"],
+ *   value3: ["item31", "item32", "item33"],
+ * }
+ * @template T
+ * @param {Validator<T>|Validator<T>[]} validator
+ * @returns {(value: {[k: any]: T|T[]}) => boolean}
+ */
+module.exports = (validator) => (value) => {
+	if (!_.isPlainObject(value)) {
+		return false;
+	}
+
+	return Object.values(value).every((array) => {
+		if (!Array.isArray(array)) {
+			return false;
+		}
+
+		// Make sure the array items are strings
+		return array.every((item) => {
+			if (Array.isArray(validator)) {
+				return validator.some((v) => v(item));
+			}
+
+			return validator(item);
+		});
+	});
+};

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

@@ -0,0 +1,169 @@
+'use strict';
+
+const _ = require('lodash');
+
+const IGNORED_OPTIONS = new Set(['severity', 'message', 'reportDisables']);
+
+/** @typedef {{possible: any, actual: any, optional?: boolean}} Options */
+
+/**
+ * Validate a rule's options.
+ *
+ * See existing rules for examples.
+ *
+ * @param {import('stylelint').PostcssResult} result - postcss result
+ * @param {string} ruleName
+ * @param {...Options} optionDescriptions - Each optionDescription can
+ *   have the following properties:
+ *   - `actual` (required): the actual passed option value or object.
+ *   - `possible` (required): a schema representation of what values are
+ *      valid for those options. `possible` should be an object if the
+ *      options are an object, with corresponding keys; if the options are not an
+ *      object, `possible` isn't, either. All `possible` value representations
+ *      should be **arrays of either values or functions**. Values are === checked
+ *      against `actual`. Functions are fed `actual` as an argument and their
+ *      return value is interpreted: truthy = valid, falsy = invalid.
+ *    - `optional` (optional): If this is `true`, `actual` can be undefined.
+ * @return {boolean} Whether or not the options are valid (true = valid)
+ */
+
+module.exports = function (result, ruleName, ...optionDescriptions) {
+	let noErrors = true;
+
+	optionDescriptions.forEach((optionDescription) => {
+		validate(optionDescription, ruleName, complain);
+	});
+
+	/**
+	 * @param {string} message
+	 */
+	function complain(message) {
+		noErrors = false;
+		result.warn(message, {
+			stylelintType: 'invalidOption',
+		});
+		_.set(result, 'stylelint.stylelintError', true);
+	}
+
+	return noErrors;
+};
+
+/**
+ * @param {Options} opts
+ * @param {string} ruleName
+ * @param {(s: string) => void} complain
+ */
+function validate(opts, ruleName, complain) {
+	const possible = opts.possible;
+	const actual = opts.actual;
+	const optional = opts.optional;
+
+	if (actual === null || _.isEqual(actual, [null])) {
+		return;
+	}
+
+	const nothingPossible =
+		possible === undefined || (Array.isArray(possible) && possible.length === 0);
+
+	if (nothingPossible && actual === true) {
+		return;
+	}
+
+	if (actual === undefined) {
+		if (nothingPossible || optional) {
+			return;
+		}
+
+		complain(`Expected option value for rule "${ruleName}"`);
+
+		return;
+	}
+
+	if (nothingPossible) {
+		if (optional) {
+			complain(
+				`Incorrect configuration for rule "${ruleName}". Rule should have "possible" values for options validation`,
+			);
+
+			return;
+		}
+
+		complain(`Unexpected option value "${String(actual)}" for rule "${ruleName}"`);
+
+		return;
+	}
+
+	// If `possible` is a function ...
+	if (_.isFunction(possible)) {
+		if (!possible(actual)) {
+			complain(`Invalid option "${JSON.stringify(actual)}" for rule ${ruleName}`);
+		}
+
+		return;
+	}
+
+	// If `possible` is an array instead of an object ...
+	if (!_.isPlainObject(possible)) {
+		[].concat(actual).forEach((a) => {
+			if (isValid(possible, a)) {
+				return;
+			}
+
+			complain(`Invalid option value "${String(a)}" for rule "${ruleName}"`);
+		});
+
+		return;
+	}
+
+	// If actual is NOT an object ...
+	if (typeof actual !== 'object') {
+		complain(
+			`Invalid option value ${JSON.stringify(actual)} for rule "${ruleName}": should be an object`,
+		);
+
+		return;
+	}
+
+	Object.keys(actual).forEach((optionName) => {
+		if (IGNORED_OPTIONS.has(optionName)) {
+			return;
+		}
+
+		if (!possible[optionName]) {
+			complain(`Invalid option name "${optionName}" for rule "${ruleName}"`);
+
+			return;
+		}
+
+		const actualOptionValue = actual[optionName];
+
+		[].concat(actualOptionValue).forEach((a) => {
+			if (isValid(possible[optionName], a)) {
+				return;
+			}
+
+			complain(`Invalid value "${a}" for option "${optionName}" of rule "${ruleName}"`);
+		});
+	});
+}
+
+/**
+ * @param {any|Function} possible
+ * @param {any} actual
+ * @returns {boolean}
+ */
+function isValid(possible, actual) {
+	const possibleList = /** @type {Array<any|Function>} */ ([]).concat(possible);
+
+	for (const possibility of possibleList) {
+		if (typeof possibility === 'function' && possibility(actual)) {
+			return true;
+		}
+
+		if (actual === possibility) {
+			return true;
+		}
+	}
+
+	return false;
+}

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

@@ -0,0 +1,45 @@
+'use strict';
+
+/**
+ * Contains helpers for working with vendor prefixes.
+ *
+ * Copied from https://github.com/postcss/postcss/commit/777c55b5d2a10605313a4972888f4f32005f5ac2
+ *
+ * @namespace vendor
+ */
+module.exports = {
+	/**
+	 * Returns the vendor prefix extracted from an input string.
+	 *
+	 * @param {string} prop String with or without vendor prefix.
+	 *
+	 * @return {string} vendor prefix or empty string
+	 *
+	 * @example
+	 * vendor.prefix('-moz-tab-size') //=> '-moz-'
+	 * vendor.prefix('tab-size')      //=> ''
+	 */
+	prefix(prop) {
+		const match = prop.match(/^(-\w+-)/);
+
+		if (match) {
+			return match[0];
+		}
+
+		return '';
+	},
+
+	/**
+	 * Returns the input string stripped of its vendor prefix.
+	 *
+	 * @param {string} prop String with or without vendor prefix.
+	 *
+	 * @return {string} String name without vendor prefixes.
+	 *
+	 * @example
+	 * vendor.unprefixed('-moz-tab-size') //=> 'tab-size'
+	 */
+	unprefixed(prop) {
+		return prop.replace(/^-\w+-/, '');
+	},
+};