create-docusaurus 0.0.0-4378 → 0.0.0-4388

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

@@ -0,0 +1,21 @@
+'use strict';
+
+/**
+ * Check whether a math function is standard
+ *
+ * @param {string} mathFunction
+ * @returns {boolean}
+ */
+module.exports = function isStandardSyntaxMathFunction(mathFunction) {
+	// SCSS variable
+	if (mathFunction.includes('$')) {
+		return false;
+	}
+
+	// Less variable
+	if (mathFunction.includes('@')) {
+		return false;
+	}
+
+	return true;
+};

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

@@ -0,0 +1,26 @@
+'use strict';
+
+const hasInterpolation = require('../utils/hasInterpolation');
+
+/**
+ * Check whether a media feature is standard
+ *
+ * @param {string} mediaFeature
+ * @returns {boolean}
+ */
+module.exports = function (mediaFeature) {
+	// Remove outside parens
+	mediaFeature = mediaFeature.slice(1, -1);
+
+	// Parentheticals used for non-standard operations e.g. ($var - 10)
+	if (mediaFeature.includes('(')) {
+		return false;
+	}
+
+	// SCSS or Less interpolation
+	if (hasInterpolation(mediaFeature)) {
+		return false;
+	}
+
+	return true;
+};

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

@@ -0,0 +1,16 @@
+'use strict';
+
+/**
+ * Check whether a media feature name is standard
+ *
+ * @param {string} mediaFeatureName
+ * @returns {boolean}
+ */
+module.exports = function (mediaFeatureName) {
+	// SCSS interpolation
+	if (/#{.+?}|\$.+?/.test(mediaFeatureName)) {
+		return false;
+	}
+
+	return true;
+};

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

@@ -0,0 +1,34 @@
+'use strict';
+
+const hasInterpolation = require('../utils/hasInterpolation');
+const isScssVariable = require('./isScssVariable');
+
+/**
+ * Check whether a property is standard
+ *
+ * @param {string} property
+ * @returns {boolean}
+ */
+module.exports = function (property) {
+	// SCSS var
+	if (isScssVariable(property)) {
+		return false;
+	}
+
+	// Less var (e.g. @var: x)
+	if (property.startsWith('@')) {
+		return false;
+	}
+
+	// Less append property value with space (e.g. transform+_: scale(2))
+	if (property.endsWith('+') || property.endsWith('+_')) {
+		return false;
+	}
+
+	// SCSS or Less interpolation
+	if (hasInterpolation(property)) {
+		return false;
+	}
+
+	return true;
+};

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

@@ -0,0 +1,69 @@
+'use strict';
+
+const _ = require('lodash');
+const isCustomPropertySet = require('../utils/isCustomPropertySet');
+const isStandardSyntaxSelector = require('../utils/isStandardSyntaxSelector');
+
+/**
+ * Check whether a Node is a standard rule
+ *
+ * @param {import('postcss').Rule | import('postcss-less').Rule} rule
+ * @returns {boolean}
+ */
+module.exports = function (rule) {
+	if (rule.type !== 'rule') {
+		return false;
+	}
+
+	// Get full selector
+	const selector = _.get(rule, 'raws.selector.raw', rule.selector);
+
+	if (!isStandardSyntaxSelector(rule.selector)) {
+		return false;
+	}
+
+	// Custom property set (e.g. --custom-property-set: {})
+	if (isCustomPropertySet(rule)) {
+		return false;
+	}
+
+	// Called Less mixin (e.g. a { .mixin() })
+	// @ts-ignore TODO TYPES support LESS and SASS types somehow
+	if (rule.mixin) {
+		return false;
+	}
+
+	// Less detached rulesets
+	if (selector.startsWith('@') && selector.endsWith(':')) {
+		return false;
+	}
+
+	// Ignore Less &:extend rule
+	if ('extend' in rule && rule.extend) {
+		return false;
+	}
+
+	// Ignore mixin or &:extend rule
+	// https://github.com/shellscape/postcss-less/blob/master/lib/less-parser.js#L52
+	// @ts-ignore TODO TYPES support LESS and SASS types somehow
+	if (rule.params && rule.params[0]) {
+		return false;
+	}
+
+	// Non-outputting Less mixin definition (e.g. .mixin() {})
+	if (selector.endsWith(')') && !selector.includes(':')) {
+		return false;
+	}
+
+	// Less guards
+	if (/when\s+(not\s+)*\(/.test(selector)) {
+		return false;
+	}
+
+	// Ignore Scss nested properties
+	if (selector.endsWith(':')) {
+		return false;
+	}
+
+	return true;
+};

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

@@ -0,0 +1,38 @@
+'use strict';
+
+const hasInterpolation = require('../utils/hasInterpolation');
+
+/**
+ * Check whether a selector is standard
+ *
+ * @param {string} selector
+ * @returns {boolean}
+ */
+module.exports = function (selector) {
+	// SCSS or Less interpolation
+	if (hasInterpolation(selector)) {
+		return false;
+	}
+
+	// SCSS placeholder selectors
+	if (selector.startsWith('%')) {
+		return false;
+	}
+
+	// Less :extend()
+	if (/:extend(\(.*?\))?/.test(selector)) {
+		return false;
+	}
+
+	// Less mixin with resolved nested selectors (e.g. .foo().bar or .foo(@a, @b)[bar])
+	if (/\.[\w-]+\(.*\).+/i.test(selector)) {
+		return false;
+	}
+
+	// ERB template tags
+	if (selector.includes('<%') || selector.includes('%>')) {
+		return false;
+	}
+
+	return true;
+};

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

@@ -0,0 +1,53 @@
+'use strict';
+
+const keywordSets = require('../reference/keywordSets');
+
+/**
+ * Check whether a type selector is standard
+ *
+ * @param {import('postcss-selector-parser').Tag} node postcss-selector-parser node (of type tag)
+ * @return {boolean} If `true`, the type selector is standard
+ */
+module.exports = function (node) {
+	// postcss-selector-parser includes the arguments to nth-child() functions
+	// as "tags", so we need to ignore them ourselves.
+	// The fake-tag's "parent" is actually a selector node, whose parent
+	// should be the :nth-child pseudo node.
+	if (!node.parent || !node.parent.parent) {
+		return false;
+	}
+
+	const _node$parent$parent = node.parent.parent;
+	const parentType = _node$parent$parent.type;
+	const parentValue = _node$parent$parent.value;
+
+	if (parentValue) {
+		const normalisedParentName = parentValue.toLowerCase().replace(/:+/, '');
+
+		if (
+			parentType === 'pseudo' &&
+			(keywordSets.aNPlusBNotationPseudoClasses.has(normalisedParentName) ||
+				keywordSets.aNPlusBOfSNotationPseudoClasses.has(normalisedParentName) ||
+				keywordSets.linguisticPseudoClasses.has(normalisedParentName) ||
+				keywordSets.shadowTreePseudoElements.has(normalisedParentName))
+		) {
+			return false;
+		}
+	}
+
+	// &-bar is a nesting selector combined with a suffix
+	if (node.prev() && node.prev().type === 'nesting') {
+		return false;
+	}
+
+	if (node.value.startsWith('%')) {
+		return false;
+	}
+
+	// Reference combinators like `/deep/`
+	if (node.value.startsWith('/') && node.value.endsWith('/')) {
+		return false;
+	}
+
+	return true;
+};

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

@@ -0,0 +1,48 @@
+'use strict';
+
+const hasLessInterpolation = require('../utils/hasLessInterpolation');
+const hasPsvInterpolation = require('../utils/hasPsvInterpolation');
+const hasScssInterpolation = require('../utils/hasScssInterpolation');
+const hasTplInterpolation = require('../utils/hasTplInterpolation');
+
+/**
+ * Check whether a URL is standard
+ *
+ * @param {string} url
+ * @returns {boolean}
+ */
+module.exports = function (url) {
+	if (url.length === 0) {
+		return true;
+	}
+
+	// Sass interpolation works anywhere
+	if (hasScssInterpolation(url) || hasTplInterpolation(url) || hasPsvInterpolation(url)) {
+		return false;
+	}
+
+	// Inside `'` and `"` work only LESS interpolation
+	if ((url.startsWith(`'`) && url.endsWith(`'`)) || (url.startsWith(`"`) && url.endsWith(`"`))) {
+		if (hasLessInterpolation(url)) {
+			return false;
+		}
+
+		return true;
+	}
+
+	// Less variable works only at the beginning
+	// Check is less variable, allow use '@url/some/path'
+	// https://github.com/less/less.js/blob/3.x/lib/less/parser/parser.js#L547
+	if (url.startsWith('@') && /^@@?[\w-]+$/.test(url)) {
+		return false;
+	}
+
+	// In url without quotes scss variable can be everywhere
+	// But in this case it is allowed to use only specific characters
+	// Also forbidden "/" at the end of url
+	if (url.includes('$') && /^[$\s\w+-/*'"/]+$/.test(url) && !url.endsWith('/')) {
+		return false;
+	}
+
+	return true;
+};

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

@@ -0,0 +1,47 @@
+'use strict';
+
+const hasInterpolation = require('../utils/hasInterpolation');
+
+/**
+ * Check whether a value is standard
+ *
+ * @param {string} value
+ * @returns {boolean}
+ */
+module.exports = function (value) {
+	let normalizedValue = value;
+
+	// Ignore operators before variables (example -$variable)
+	if (/^[-+*/]/.test(value[0])) {
+		normalizedValue = normalizedValue.slice(1);
+	}
+
+	// SCSS variable (example $variable)
+	if (normalizedValue.startsWith('$')) {
+		return false;
+	}
+
+	// SCSS namespace (example namespace.$variable)
+	if (/^.+\.\$/.test(value)) {
+		return false;
+	}
+
+	// Less variable
+	if (normalizedValue.startsWith('@')) {
+		return false;
+	}
+
+	// SCSS or Less interpolation
+	if (hasInterpolation(normalizedValue)) {
+		return false;
+	}
+
+	// WebExtension replacement keyword used by Chrome/Firefox
+	// more information: https://developer.chrome.com/extensions/i18n
+	// and https://github.com/stylelint/stylelint/issues/4707
+	if (/__MSG_\S+__/.test(value)) {
+		return false;
+	}
+
+	return true;
+};

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

@@ -0,0 +1,38 @@
+'use strict';
+
+const keywordSets = require('../reference/keywordSets');
+const valueParser = require('postcss-value-parser');
+
+/**
+ * Check if a word is a font-size value.
+ *
+ * @param {string} word
+ * @returns {boolean}
+ */
+module.exports = function (word) {
+	if (!word) {
+		return false;
+	}
+
+	if (keywordSets.fontSizeKeywords.has(word)) {
+		return true;
+	}
+
+	const numberUnit = valueParser.unit(word);
+
+	if (!numberUnit) {
+		return false;
+	}
+
+	const unit = numberUnit.unit;
+
+	if (unit === '%') {
+		return true;
+	}
+
+	if (keywordSets.lengthUnits.has(unit.toLowerCase())) {
+		return true;
+	}
+
+	return false;
+};

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

@@ -0,0 +1,11 @@
+'use strict';
+
+/**
+ * Check if a value is a valid 3, 4, 6 or 8 digit hex
+ *
+ * @param {string} value
+ * @returns {boolean}
+ */
+module.exports = function (value) {
+	return /^#(?:[0-9a-fA-F]{3,4}|[0-9a-fA-F]{6}|[0-9a-fA-F]{8})$/.test(value);
+};

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

@@ -0,0 +1,11 @@
+'use strict';
+
+/**
+ * Check whether a word is a variable i.e var(--custom-property).
+ *
+ * @param {string} word
+ * @returns {boolean}
+ */
+module.exports = function (word) {
+	return word.toLowerCase().startsWith('var(');
+};

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

@@ -0,0 +1,11 @@
+'use strict';
+
+/**
+ * Check if a character is whitespace.
+ *
+ * @param {string} char
+ * @returns {boolean}
+ */
+module.exports = function (char) {
+	return [' ', '\n', '\t', '\r', '\f'].includes(char);
+};

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

@@ -0,0 +1,85 @@
+'use strict';
+
+/**
+ * Compares a string to a second value that, if it fits a certain convention,
+ * is converted to a regular expression before the comparison.
+ * If it doesn't fit the convention, then two strings are compared.
+ *
+ * Any strings starting and ending with `/` are interpreted
+ * as regular expressions.
+ *
+ * @param {string} input
+ * @param {string | RegExp | Array<string | RegExp>} comparison
+ *
+ * @returns {false | {match: string, pattern: (string | RegExp) }}
+ */
+module.exports = function matchesStringOrRegExp(input, comparison) {
+	if (!Array.isArray(input)) {
+		return testAgainstStringOrRegExpOrArray(input, comparison);
+	}
+
+	for (const inputItem of input) {
+		const testResult = testAgainstStringOrRegExpOrArray(inputItem, comparison);
+
+		if (testResult) {
+			return testResult;
+		}
+	}
+
+	return false;
+};
+
+/**
+ * @param {string} value
+ * @param {string | RegExp | Array<string | RegExp>} comparison
+ */
+function testAgainstStringOrRegExpOrArray(value, comparison) {
+	if (!Array.isArray(comparison)) {
+		return testAgainstStringOrRegExp(value, comparison);
+	}
+
+	for (const comparisonItem of comparison) {
+		const testResult = testAgainstStringOrRegExp(value, comparisonItem);
+
+		if (testResult) {
+			return testResult;
+		}
+	}
+
+	return false;
+}
+
+/**
+ * @param {string} value
+ * @param {string | RegExp} comparison
+ */
+function testAgainstStringOrRegExp(value, comparison) {
+	// If it's a RegExp, test directly
+	if (comparison instanceof RegExp) {
+		return comparison.test(value) ? { match: value, pattern: comparison } : false;
+	}
+
+	// Check if it's RegExp in a string
+	const firstComparisonChar = comparison[0];
+	const lastComparisonChar = comparison[comparison.length - 1];
+	const secondToLastComparisonChar = comparison[comparison.length - 2];
+
+	const comparisonIsRegex =
+		firstComparisonChar === '/' &&
+		(lastComparisonChar === '/' ||
+			(secondToLastComparisonChar === '/' && lastComparisonChar === 'i'));
+
+	const hasCaseInsensitiveFlag = comparisonIsRegex && lastComparisonChar === 'i';
+
+	// If so, create a new RegExp from it
+	if (comparisonIsRegex) {
+		const valueMatches = hasCaseInsensitiveFlag
+			? new RegExp(comparison.slice(1, -2), 'i').test(value)
+			: new RegExp(comparison.slice(1, -1)).test(value);
+
+		return valueMatches ? { match: value, pattern: comparison } : false;
+	}
+
+	// Otherwise, it's a string. Do a strict comparison
+	return value === comparison ? { match: value, pattern: comparison } : false;
+}

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

@@ -0,0 +1,20 @@
+'use strict';
+
+/** @typedef {import('postcss').Node} PostcssNode */
+
+/**
+ * Get the next non-comment node in a PostCSS AST
+ * at or after a given node.
+ *
+ * @param {PostcssNode | void} startNode
+ * @returns {PostcssNode | null}
+ */
+module.exports = function nextNonCommentNode(startNode) {
+	if (!startNode || !startNode.next) return null;
+
+	if (startNode.type === 'comment') {
+		return nextNonCommentNode(startNode.next());
+	}
+
+	return startNode;
+};

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

@@ -0,0 +1,20 @@
+'use strict';
+
+class NoFilesFoundError extends Error {
+	/**
+	 * @param {string|string[]} fileList
+	 */
+	constructor(fileList) {
+		super();
+
+		if (typeof fileList === 'string') {
+			fileList = [fileList];
+		}
+
+		const pattern = fileList.filter((i) => !i.startsWith('!')).join(', ');
+
+		this.message = `No files matching the pattern "${pattern}" were found.`;
+	}
+}
+
+module.exports = NoFilesFoundError;

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

@@ -0,0 +1,43 @@
+'use strict';
+
+/**
+ * Create a collection of Maps that serve to contextualize a given node.
+ * This is useful to ensure that you only compare nodes that share a certain
+ * context.
+ *
+ * All nodes are initially contextualized by their input source.
+ * From there, you can contextualize them however you want.
+ *
+ * For a usage example, see `selector-no-descending-specificity`.
+ */
+module.exports = function () {
+	const contextMap = new Map();
+
+	return {
+		/**
+		 * @param {import('postcss').Node} node
+		 */
+		getContext(node, /** @type {any[]} */ ...subContexts) {
+			// TODO TYPES node.source possible undefined
+			const nodeSource = /** @type {import('postcss').NodeSource} */ (node.source).input.from;
+			const baseContext = creativeGetMap(contextMap, nodeSource);
+
+			return subContexts.reduce((result, context) => {
+				return creativeGetMap(result, context);
+			}, baseContext);
+		},
+	};
+};
+
+/**
+ * TODO TYPES
+ * @param {Map<any, any>} someMap
+ * @param {any} someThing
+ */
+function creativeGetMap(someMap, someThing) {
+	if (!someMap.has(someThing)) {
+		someMap.set(someThing, new Map());
+	}
+
+	return someMap.get(someThing);
+}

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

@@ -0,0 +1,22 @@
+'use strict';
+
+const matchesStringOrRegExp = require('./matchesStringOrRegExp');
+
+/**
+ * Check if an options object's propertyName contains a user-defined string or
+ * regex that matches the passed in input.
+ *
+ * @param {{ [x: string]: any; }} options
+ * @param {string} propertyName
+ * @param {string} input
+ *
+ * @returns {boolean}
+ */
+module.exports = function optionsMatches(options, propertyName, input) {
+	return Boolean(
+		options &&
+			options[propertyName] &&
+			typeof input === 'string' &&
+			matchesStringOrRegExp(input, options[propertyName]),
+	);
+};

package/templates/facebook/node_modules/stylelint/lib/utils/parseCalcExpression/index.js

@@ -0,0 +1,15 @@
+'use strict';
+
+// To generate parser.js run the following command in the current directory:
+//
+// npx jison-gho parser.jison -o parser.js
+
+const parse = require('./parser').parse;
+
+/**
+ * @param {string} exp
+ * @returns {object}
+ */
+module.exports = function parseCalcExpression(exp) {
+	return parse(exp);
+};