create-docusaurus 0.0.0-4376 → 0.0.0-4383

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

@@ -0,0 +1,52 @@
+'use strict';
+
+const fs = require('fs');
+const hash = require('./hash');
+const path = require('path');
+
+/**
+ * Return the cacheFile to be used by stylelint, based on whether the provided parameter is
+ * a directory or looks like a directory (ends in `path.sep`), in which case the file
+ * name will be `cacheFile/.cache_hashOfCWD`.
+ *
+ * If cacheFile points to a file or looks like a file, then it will just use that file.
+ *
+ * @param {string} cacheFile - The name of file to be used to store the cache
+ * @param {string} cwd - Current working directory. Used for tests
+ * @returns {string} Resolved path to the cache file
+ */
+module.exports = function getCacheFile(cacheFile, cwd) {
+	/*
+	 * Make sure path separators are normalized for environment/os.
+	 * Also, keep trailing path separator if present.
+	 */
+	cacheFile = path.normalize(cacheFile);
+
+	const resolvedCacheFile = path.resolve(cwd, cacheFile);
+	// If the last character passed is a path separator, we assume is a directory.
+	const looksLikeADirectory = cacheFile[cacheFile.length - 1] === path.sep;
+
+	/**
+	 * Return the default cache file name when provided parameter is a directory.
+	 * @returns {string} - Resolved path to the cacheFile
+	 */
+	function getCacheFileForDirectory() {
+		return path.join(resolvedCacheFile, `.stylelintcache_${hash(cwd)}`);
+	}
+
+	let fileStats;
+
+	try {
+		fileStats = fs.lstatSync(resolvedCacheFile);
+	} catch {
+		fileStats = null;
+	}
+
+	if (looksLikeADirectory || (fileStats && fileStats.isDirectory())) {
+		// Return path to provided directory with generated file name.
+		return getCacheFileForDirectory();
+	}
+
+	// Return normalized path to cache file.
+	return resolvedCacheFile;
+};

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

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

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

@@ -0,0 +1,34 @@
+'use strict';
+// Try to get file ignorer from '.stylelintignore'
+
+const fs = require('fs');
+const path = require('path');
+const { default: ignore } = require('ignore');
+
+const DEFAULT_IGNORE_FILENAME = '.stylelintignore';
+const FILE_NOT_FOUND_ERROR_CODE = 'ENOENT';
+
+/** @typedef {import('stylelint').StylelintStandaloneOptions} StylelintOptions */
+
+/**
+ * @param {StylelintOptions} options
+ * @return {import('ignore').Ignore}
+ */
+module.exports = function (options) {
+	const ignoreFilePath = options.ignorePath || DEFAULT_IGNORE_FILENAME;
+	const absoluteIgnoreFilePath = path.isAbsolute(ignoreFilePath)
+		? ignoreFilePath
+		: path.resolve(process.cwd(), ignoreFilePath);
+	let ignoreText = '';
+
+	try {
+		ignoreText = fs.readFileSync(absoluteIgnoreFilePath, 'utf8');
+	} catch (readError) {
+		if (readError.code !== FILE_NOT_FOUND_ERROR_CODE) throw readError;
+	}
+
+	const ignorePattern = options.ignorePattern || [];
+	const ignorer = ignore().add(ignoreText).add(ignorePattern);
+
+	return ignorer;
+};

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

@@ -0,0 +1,19 @@
+'use strict';
+
+const formatters = require('../formatters');
+
+/**
+ * @param {{ useOr?: boolean }} [options={}]
+ * @returns {string}
+ */
+module.exports = function getFormatterOptionsText(options = {}) {
+	let output = Object.keys(formatters)
+		.map((name) => `"${name}"`)
+		.join(', ');
+
+	if (options.useOr) {
+		output = output.replace(/, ([a-z"]+)$/u, ' or $1');
+	}
+
+	return output;
+};

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

@@ -0,0 +1,31 @@
+'use strict';
+
+const configurationError = require('./configurationError');
+const globalModules = require('global-modules');
+const resolveFrom = require('resolve-from');
+
+/**
+ * @param {string} basedir
+ * @param {string} lookup
+ * @return {string}
+ */
+module.exports = function getModulePath(basedir, lookup) {
+	// 1. Try to resolve from the provided directory
+	// 2. Try to resolve from `process.cwd`
+	// 3. Try to resolve from global `node_modules` directory
+	let path = resolveFrom.silent(basedir, lookup);
+
+	if (!path) {
+		path = resolveFrom.silent(process.cwd(), lookup);
+	}
+
+	if (!path) {
+		path = resolveFrom.silent(globalModules, lookup);
+	}
+
+	if (!path) {
+		throw configurationError(`Could not find "${lookup}". Do you need a \`configBasedir\`?`);
+	}
+
+	return path;
+};

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

@@ -0,0 +1,38 @@
+'use strict';
+
+const _ = require('lodash');
+
+/** @typedef {import('postcss').Node} Node */
+
+/**
+ * @param {Node | void} node
+ */
+function getNodeLine(node) {
+	return _.get(node, 'source.start.line');
+}
+
+/**
+ * @param {Node | void} node
+ * @returns {Node | void}
+ */
+module.exports = function getNextNonSharedLineCommentNode(node) {
+	if (node === undefined) {
+		return undefined;
+	}
+
+	/** @type {Node | void} */
+	const nextNode = node.next();
+
+	if (_.get(nextNode, 'type') !== 'comment') {
+		return nextNode;
+	}
+
+	if (
+		getNodeLine(node) === getNodeLine(nextNode) ||
+		(nextNode !== undefined && getNodeLine(nextNode) === getNodeLine(nextNode.next()))
+	) {
+		return getNextNonSharedLineCommentNode(nextNode);
+	}
+
+	return nextNode;
+};

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

@@ -0,0 +1,11 @@
+'use strict';
+
+const os = require('os');
+
+// This function simply provides roundabout way of getting os.EOL
+// so we can mock this for Jest tests
+function getOsEl() {
+	return os.EOL;
+}
+
+module.exports = getOsEl;

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

@@ -0,0 +1,40 @@
+'use strict';
+
+const _ = require('lodash');
+
+/** @typedef {import('postcss').Node} Node */
+
+/**
+ * @param {Node} node
+ */
+function getNodeLine(node) {
+	return _.get(node, 'source.start.line');
+}
+
+/**
+ * @param {import('postcss').Node | void} node
+ * @returns {Node | void}
+ */
+module.exports = function getPreviousNonSharedLineCommentNode(node) {
+	if (node === undefined) {
+		return undefined;
+	}
+
+	const previousNode = node.prev();
+
+	if (!previousNode || _.get(previousNode, 'type') !== 'comment') {
+		return previousNode;
+	}
+
+	if (getNodeLine(node) === getNodeLine(previousNode)) {
+		return getPreviousNonSharedLineCommentNode(previousNode);
+	}
+
+	const previousNode2 = previousNode.prev();
+
+	if (previousNode2 && getNodeLine(previousNode) === getNodeLine(previousNode2)) {
+		return getPreviousNonSharedLineCommentNode(previousNode);
+	}
+
+	return previousNode;
+};

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

@@ -0,0 +1,13 @@
+'use strict';
+
+const _ = require('lodash');
+
+/**
+ * @param {import('postcss').Rule} ruleNode
+ * @returns {string}
+ */
+function getRuleSelector(ruleNode) {
+	return _.get(ruleNode, 'raws.selector.raw', ruleNode.selector);
+}
+
+module.exports = getRuleSelector;

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

@@ -0,0 +1,39 @@
+'use strict';
+
+const { URL } = require('url');
+
+/**
+ * Get unit from value node
+ *
+ * Returns `null` if the unit is not found.
+ *
+ * @param {string} urlString
+ */
+module.exports = function (urlString) {
+	let protocol = null;
+
+	try {
+		protocol = new URL(urlString).protocol;
+	} catch {
+		return null;
+	}
+
+	if (protocol === null || typeof protocol === 'undefined') {
+		return null;
+	}
+
+	const scheme = protocol.slice(0, -1); // strip trailing `:`
+
+	// The URL spec does not require a scheme to be followed by `//`, but checking
+	// for it allows this rule to differentiate <scheme>:<hostname> urls from
+	// <hostname>:<port> urls. `data:` scheme urls are an exception to this rule.
+	const slashIndex = protocol.length;
+	const expectedSlashes = urlString.slice(slashIndex, slashIndex + 2);
+	const isSchemeLessUrl = expectedSlashes !== '//' && scheme !== 'data';
+
+	if (isSchemeLessUrl) {
+		return null;
+	}
+
+	return scheme;
+};

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

@@ -0,0 +1,49 @@
+'use strict';
+
+const blurInterpolation = require('./blurInterpolation');
+const isStandardSyntaxValue = require('./isStandardSyntaxValue');
+const valueParser = require('postcss-value-parser');
+
+/**
+ * Get unit from value node
+ *
+ * Returns `null` if the unit is not found.
+ *
+ * @param {import('postcss-value-parser').Node} node
+ *
+ * @returns {string | null}
+ */
+module.exports = function (node) {
+	if (!node || !node.value) {
+		return null;
+	}
+
+	// Ignore non-word nodes
+	if (node.type !== 'word') {
+		return null;
+	}
+
+	// Ignore non standard syntax
+	if (!isStandardSyntaxValue(node.value)) {
+		return null;
+	}
+
+	// Ignore HEX
+	if (node.value.startsWith('#')) {
+		return null;
+	}
+
+	// Remove non standard stuff
+	const value = blurInterpolation(node.value, '')
+		// ignore hack unit
+		.replace('\\0', '')
+		.replace('\\9', '');
+
+	const parsedUnit = valueParser.unit(value);
+
+	if (!parsedUnit) {
+		return null;
+	}
+
+	return parsedUnit.unit;
+};

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

@@ -0,0 +1,11 @@
+'use strict';
+
+/**
+ * Check if a statement has an block (empty or otherwise).
+ *
+ * @param {import('postcss').Rule | import('postcss').AtRule} statement - postcss rule or at-rule node
+ * @return {boolean} True if `statement` has a block (empty or otherwise)
+ */
+module.exports = function (statement) {
+	return statement.nodes !== undefined;
+};

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

@@ -0,0 +1,13 @@
+'use strict';
+
+/**
+ * Check if a statement has an empty block.
+ *
+ * @param {import('postcss').Rule | import('postcss').AtRule} statement - postcss rule or at-rule node
+ * @return {boolean} True if the statement has a block and it is empty
+ */
+module.exports = function (statement) {
+	return (
+		statement.nodes !== undefined && statement.nodes.length === 0 // has block
+	); // and is empty
+};

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

@@ -0,0 +1,14 @@
+'use strict';
+
+/**
+ * Check if a string contains at least one empty line
+ *
+ * @param {string} string
+ *
+ * @returns {boolean}
+ */
+module.exports = function (string) {
+	if (string === '' || string === undefined) return false;
+
+	return /\n[\r\t ]*\n/.test(string);
+};

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

@@ -0,0 +1,26 @@
+'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 string has interpolation
+ *
+ * @param {string} string
+ * @return {boolean} If `true`, a string has interpolation
+ */
+module.exports = function (string) {
+	// SCSS or Less interpolation
+	if (
+		hasLessInterpolation(string) ||
+		hasScssInterpolation(string) ||
+		hasTplInterpolation(string) ||
+		hasPsvInterpolation(string)
+	) {
+		return true;
+	}
+
+	return false;
+};

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

@@ -0,0 +1,11 @@
+'use strict';
+
+/**
+ * Check whether a string has less interpolation
+ *
+ * @param {string} string
+ * @return {boolean} If `true`, a string has less interpolation
+ */
+module.exports = function (string) {
+	return /@{.+?}/.test(string);
+};

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

@@ -0,0 +1,10 @@
+'use strict';
+
+/**
+ * Check whether a string has postcss-simple-vars interpolation
+ *
+ * @param {string} string
+ */
+module.exports = function (string) {
+	return /\$\(.+?\)/.test(string);
+};

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

@@ -0,0 +1,10 @@
+'use strict';
+
+/**
+ * Check whether a string has scss interpolation
+ *
+ * @param {string} string
+ */
+module.exports = function (string) {
+	return /#{.+?}/.test(string);
+};

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

@@ -0,0 +1,11 @@
+'use strict';
+
+/**
+ * Check whether a string has JS template literal interpolation or HTML-like template
+ *
+ * @param {string} string
+ * @return {boolean} If `true`, a string has template literal interpolation
+ */
+module.exports = function (string) {
+	return /{.+?}/.test(string);
+};

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

@@ -0,0 +1,12 @@
+'use strict';
+
+const murmur = require('imurmurhash');
+
+/**
+ * hash the given string
+ * @param  {string} str the string to hash
+ * @returns {string} the hash
+ */
+module.exports = function hash(str) {
+	return murmur(str).result().toString(36);
+};

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

@@ -0,0 +1,16 @@
+'use strict';
+
+const isSharedLineComment = require('./isSharedLineComment');
+
+/**
+ * @param {import('postcss').Node} node
+ */
+module.exports = function (node) {
+	const previousNode = node.prev();
+
+	if (!previousNode || previousNode.type !== 'comment') {
+		return false;
+	}
+
+	return !isSharedLineComment(previousNode);
+};

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

@@ -0,0 +1,22 @@
+'use strict';
+
+const isSharedLineComment = require('./isSharedLineComment');
+
+/**
+ * @param {import('postcss').Node} node
+ */
+function isAfterSingleLineComment(node) {
+	const prevNode = node.prev();
+
+	return (
+		prevNode !== undefined &&
+		prevNode.type === 'comment' &&
+		!isSharedLineComment(prevNode) &&
+		prevNode.source &&
+		prevNode.source.start &&
+		prevNode.source.end &&
+		prevNode.source.start.line === prevNode.source.end.line
+	);
+}
+
+module.exports = isAfterSingleLineComment;

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

@@ -0,0 +1,20 @@
+'use strict';
+
+const _ = require('lodash');
+const getPreviousNonSharedLineCommentNode = require('./getPreviousNonSharedLineCommentNode');
+const isCustomProperty = require('./isCustomProperty');
+const isStandardSyntaxDeclaration = require('./isStandardSyntaxDeclaration');
+
+/**
+ * @param {import('postcss').Node} node
+ */
+module.exports = function (node) {
+	const prevNode = getPreviousNonSharedLineCommentNode(node);
+
+	return (
+		prevNode !== undefined &&
+		prevNode.type === 'decl' &&
+		isStandardSyntaxDeclaration(prevNode) &&
+		!isCustomProperty(_.get(prevNode, 'prop', ''))
+	);
+};

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

@@ -0,0 +1,86 @@
+'use strict';
+
+const autoprefixer = require('autoprefixer');
+const Browsers = require('autoprefixer/lib/browsers');
+const Prefixes = require('autoprefixer/lib/prefixes');
+
+/**
+ * Use Autoprefixer's secret powers to determine whether or
+ * not a certain CSS identifier contains a vendor prefix that
+ * Autoprefixer, given the standardized identifier, could add itself.
+ *
+ * Used by `*-no-vendor-prefix-*` rules to find superfluous
+ * vendor prefixes.
+ */
+
+const prefixes = new Prefixes(
+	autoprefixer.data.prefixes,
+	new Browsers(autoprefixer.data.browsers, []),
+);
+
+/**
+ * Most identifier types have to be looked up in a unique way,
+ * so we're exposing special functions for each.
+ */
+module.exports = {
+	/**
+	 * @param {string} identifier
+	 * @returns {boolean}
+	 */
+	atRuleName(identifier) {
+		return Boolean(prefixes.remove[`@${identifier.toLowerCase()}`]);
+	},
+
+	/**
+	 * @param {string} identifier
+	 * @returns {boolean}
+	 */
+	selector(identifier) {
+		return prefixes.remove.selectors.some((/** @type {{ prefixed: string}} */ selectorObj) => {
+			return identifier.toLowerCase() === selectorObj.prefixed;
+		});
+	},
+
+	/**
+	 * @param {string} identifier
+	 * @returns {boolean}
+	 */
+	mediaFeatureName(identifier) {
+		return identifier.toLowerCase().includes('device-pixel-ratio');
+	},
+
+	/**
+	 * @param {string} identifier
+	 * @returns {boolean}
+	 */
+	property(identifier) {
+		return Boolean(autoprefixer.data.prefixes[prefixes.unprefixed(identifier.toLowerCase())]);
+	},
+
+	/**
+	 *
+	 * @param {string} prop
+	 * @param {string} value
+	 * @returns {boolean}
+	 */
+	propertyValue(prop, value) {
+		const possiblePrefixableValues =
+			(prefixes.remove[prop.toLowerCase()] && prefixes.remove[prop.toLowerCase()].values) || false;
+
+		return (
+			possiblePrefixableValues &&
+			possiblePrefixableValues.some((/** @type {{ prefixed: string}} */ valueObj) => {
+				return value.toLowerCase() === valueObj.prefixed;
+			})
+		);
+	},
+
+	/**
+	 *
+	 * @param {string} value
+	 * @returns {string}
+	 */
+	unprefix(value) {
+		return value.replace(/-\w+-/, '');
+	},
+};

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

@@ -0,0 +1,22 @@
+'use strict';
+
+const getPreviousNonSharedLineCommentNode = require('./getPreviousNonSharedLineCommentNode');
+const hasBlock = require('./hasBlock');
+
+/**
+ * @param {import('postcss').AtRule} atRule
+ * @returns {boolean}
+ */
+module.exports = function (atRule) {
+	if (atRule.type !== 'atrule') {
+		return false;
+	}
+
+	const previousNode = getPreviousNonSharedLineCommentNode(atRule);
+
+	if (previousNode === undefined) {
+		return false;
+	}
+
+	return previousNode.type === 'atrule' && !hasBlock(previousNode) && !hasBlock(atRule);
+};

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

@@ -0,0 +1,19 @@
+'use strict';
+
+const _ = require('lodash');
+const getPreviousNonSharedLineCommentNode = require('./getPreviousNonSharedLineCommentNode');
+const isBlocklessAtRuleAfterBlocklessAtRule = require('./isBlocklessAtRuleAfterBlocklessAtRule');
+
+/**
+ * @param {import('postcss').AtRule} atRule
+ * @returns {boolean}
+ */
+module.exports = function (atRule) {
+	if (!isBlocklessAtRuleAfterBlocklessAtRule(atRule)) {
+		return false;
+	}
+
+	const previousNode = getPreviousNonSharedLineCommentNode(atRule);
+
+	return _.get(previousNode, 'name') === atRule.name;
+};