create-docusaurus 0.0.0-4378 → 0.0.0-4379

package/templates/facebook/node_modules/stylelint/lib/standalone.js

@@ -0,0 +1,334 @@
+'use strict';
+
+const _ = require('lodash');
+const createStylelint = require('./createStylelint');
+const createStylelintResult = require('./createStylelintResult');
+const debug = require('debug')('stylelint:standalone');
+const fastGlob = require('fast-glob');
+const FileCache = require('./utils/FileCache');
+const filterFilePaths = require('./utils/filterFilePaths');
+const formatters = require('./formatters');
+const fs = require('fs');
+const getFormatterOptionsText = require('./utils/getFormatterOptionsText');
+const globby = require('globby');
+const hash = require('./utils/hash');
+const NoFilesFoundError = require('./utils/noFilesFoundError');
+const path = require('path');
+const pkg = require('../package.json');
+const prepareReturnValue = require('./prepareReturnValue');
+const { default: ignore } = require('ignore');
+const DEFAULT_IGNORE_FILENAME = '.stylelintignore';
+const FILE_NOT_FOUND_ERROR_CODE = 'ENOENT';
+const ALWAYS_IGNORED_GLOBS = ['**/node_modules/**'];
+const writeFileAtomic = require('write-file-atomic');
+
+/** @typedef {import('stylelint').StylelintStandaloneOptions} StylelintStandaloneOptions */
+/** @typedef {import('stylelint').StylelintStandaloneReturnValue} StylelintStandaloneReturnValue */
+/** @typedef {import('stylelint').StylelintResult} StylelintResult */
+/** @typedef {import('stylelint').Formatter} Formatter */
+/** @typedef {import('stylelint').FormatterIdentifier} FormatterIdentifier */
+
+/**
+ * @param {StylelintStandaloneOptions} options
+ * @returns {Promise<StylelintStandaloneReturnValue>}
+ */
+module.exports = function (options) {
+	const cacheLocation = options.cacheLocation;
+	const code = options.code;
+	const codeFilename = options.codeFilename;
+	const config = options.config;
+	const configBasedir = options.configBasedir;
+	const configFile = options.configFile;
+	const configOverrides = options.configOverrides;
+	const customSyntax = options.customSyntax;
+	const globbyOptions = options.globbyOptions;
+	const files = options.files;
+	const fix = options.fix;
+	const formatter = options.formatter;
+	const ignoreDisables = options.ignoreDisables;
+	const reportNeedlessDisables = options.reportNeedlessDisables;
+	const reportInvalidScopeDisables = options.reportInvalidScopeDisables;
+	const reportDescriptionlessDisables = options.reportDescriptionlessDisables;
+	const syntax = options.syntax;
+	const allowEmptyInput = options.allowEmptyInput || false;
+	const useCache = options.cache || false;
+	/** @type {FileCache} */
+	let fileCache;
+	const startTime = Date.now();
+
+	// The ignorer will be used to filter file paths after the glob is checked,
+	// before any files are actually read
+	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);
+
+	const isValidCode = typeof code === 'string';
+
+	if ((!files && !isValidCode) || (files && (code || isValidCode))) {
+		throw new Error('You must pass stylelint a `files` glob or a `code` string, though not both');
+	}
+
+	/** @type {Formatter} */
+	let formatterFunction;
+
+	try {
+		formatterFunction = getFormatterFunction(formatter);
+	} catch (error) {
+		return Promise.reject(error);
+	}
+
+	const stylelint = createStylelint({
+		config,
+		configFile,
+		configBasedir,
+		configOverrides,
+		ignoreDisables,
+		ignorePath: ignoreFilePath,
+		reportNeedlessDisables,
+		reportInvalidScopeDisables,
+		reportDescriptionlessDisables,
+		syntax,
+		customSyntax,
+		fix,
+	});
+
+	if (!files) {
+		const absoluteCodeFilename =
+			codeFilename !== undefined && !path.isAbsolute(codeFilename)
+				? path.join(process.cwd(), codeFilename)
+				: codeFilename;
+
+		// if file is ignored, return nothing
+		if (
+			absoluteCodeFilename &&
+			!filterFilePaths(ignorer, [path.relative(process.cwd(), absoluteCodeFilename)]).length
+		) {
+			return Promise.resolve(prepareReturnValue([], options, formatterFunction));
+		}
+
+		return stylelint
+			._lintSource({
+				code,
+				codeFilename: absoluteCodeFilename,
+			})
+			.then((postcssResult) => {
+				// Check for file existence
+				return /** @type {Promise<void>} */ (new Promise((resolve, reject) => {
+					if (!absoluteCodeFilename) {
+						reject();
+
+						return;
+					}
+
+					fs.stat(absoluteCodeFilename, (err) => {
+						if (err) {
+							reject();
+						} else {
+							resolve();
+						}
+					});
+				}))
+					.then(() => {
+						return stylelint._createStylelintResult(postcssResult, absoluteCodeFilename);
+					})
+					.catch(() => {
+						return stylelint._createStylelintResult(postcssResult);
+					});
+			})
+			.catch(_.partial(handleError, stylelint))
+			.then((stylelintResult) => {
+				const postcssResult = stylelintResult._postcssResult;
+				const returnValue = prepareReturnValue([stylelintResult], options, formatterFunction);
+
+				if (options.fix && postcssResult && !postcssResult.stylelint.ignored) {
+					if (!postcssResult.stylelint.disableWritingFix) {
+						// If we're fixing, the output should be the fixed code
+						returnValue.output = postcssResult.root.toString(postcssResult.opts.syntax);
+					} else {
+						// If the writing of the fix is disabled, the input code is returned as-is
+						returnValue.output = code;
+					}
+				}
+
+				return returnValue;
+			});
+	}
+
+	let fileList = files;
+
+	if (typeof fileList === 'string') {
+		fileList = [fileList];
+	}
+
+	fileList = fileList.map((entry) => {
+		const cwd = _.get(globbyOptions, 'cwd', process.cwd());
+		const absolutePath = !path.isAbsolute(entry) ? path.join(cwd, entry) : path.normalize(entry);
+
+		if (fs.existsSync(absolutePath)) {
+			// This path points to a file. Return an escaped path to avoid globbing
+			return fastGlob.escapePath(entry);
+		}
+
+		return entry;
+	});
+
+	if (!options.disableDefaultIgnores) {
+		fileList = fileList.concat(ALWAYS_IGNORED_GLOBS.map((glob) => `!${glob}`));
+	}
+
+	if (useCache) {
+		const stylelintVersion = pkg.version;
+		const hashOfConfig = hash(`${stylelintVersion}_${JSON.stringify(config || {})}`);
+
+		fileCache = new FileCache(cacheLocation, hashOfConfig);
+	} else {
+		// No need to calculate hash here, we just want to delete cache file.
+		fileCache = new FileCache(cacheLocation);
+		// Remove cache file if cache option is disabled
+		fileCache.destroy();
+	}
+
+	return globby(fileList, globbyOptions)
+		.then((filePaths) => {
+			// The ignorer filter needs to check paths relative to cwd
+			filePaths = filterFilePaths(
+				ignorer,
+				filePaths.map((p) => path.relative(process.cwd(), p)),
+			);
+
+			if (!filePaths.length) {
+				if (!allowEmptyInput) {
+					throw new NoFilesFoundError(fileList);
+				}
+
+				return Promise.all([]);
+			}
+
+			const cwd = _.get(globbyOptions, 'cwd', process.cwd());
+			let absoluteFilePaths = filePaths.map((filePath) => {
+				const absoluteFilepath = !path.isAbsolute(filePath)
+					? path.join(cwd, filePath)
+					: path.normalize(filePath);
+
+				return absoluteFilepath;
+			});
+
+			if (useCache) {
+				absoluteFilePaths = absoluteFilePaths.filter(fileCache.hasFileChanged.bind(fileCache));
+			}
+
+			const getStylelintResults = absoluteFilePaths.map((absoluteFilepath) => {
+				debug(`Processing ${absoluteFilepath}`);
+
+				return stylelint
+					._lintSource({
+						filePath: absoluteFilepath,
+					})
+					.then((postcssResult) => {
+						if (postcssResult.stylelint.stylelintError && useCache) {
+							debug(`${absoluteFilepath} contains linting errors and will not be cached.`);
+							fileCache.removeEntry(absoluteFilepath);
+						}
+
+						/**
+						 * If we're fixing, save the file with changed code
+						 * @type {Promise<Error | void>}
+						 */
+						let fixFile = Promise.resolve();
+
+						if (
+							postcssResult.root &&
+							postcssResult.opts &&
+							!postcssResult.stylelint.ignored &&
+							options.fix &&
+							!postcssResult.stylelint.disableWritingFix
+						) {
+							// @ts-ignore TODO TYPES toString accepts 0 arguments
+							const fixedCss = postcssResult.root.toString(postcssResult.opts.syntax);
+
+							if (
+								postcssResult.root &&
+								postcssResult.root.source &&
+								// @ts-ignore TODO TYPES css is unknown property
+								postcssResult.root.source.input.css !== fixedCss
+							) {
+								fixFile = writeFileAtomic(absoluteFilepath, fixedCss);
+							}
+						}
+
+						return fixFile.then(() =>
+							stylelint._createStylelintResult(postcssResult, absoluteFilepath),
+						);
+					})
+					.catch((error) => {
+						// On any error, we should not cache the lint result
+						fileCache.removeEntry(absoluteFilepath);
+
+						return handleError(stylelint, error, absoluteFilepath);
+					});
+			});
+
+			return Promise.all(getStylelintResults);
+		})
+		.then((stylelintResults) => {
+			if (useCache) {
+				fileCache.reconcile();
+			}
+
+			const rtn = prepareReturnValue(stylelintResults, options, formatterFunction);
+
+			debug(`Linting complete in ${Date.now() - startTime}ms`);
+
+			return rtn;
+		});
+};
+
+/**
+ * @param {FormatterIdentifier | undefined} selected
+ * @returns {Formatter}
+ */
+function getFormatterFunction(selected) {
+	/** @type {Formatter} */
+	let formatterFunction;
+
+	if (typeof selected === 'string') {
+		formatterFunction = formatters[selected];
+
+		if (formatterFunction === undefined) {
+			throw new Error(
+				`You must use a valid formatter option: ${getFormatterOptionsText()} or a function`,
+			);
+		}
+	} else if (typeof selected === 'function') {
+		formatterFunction = selected;
+	} else {
+		formatterFunction = formatters.json;
+	}
+
+	return formatterFunction;
+}
+
+/**
+ * @param {import('stylelint').StylelintInternalApi} stylelint
+ * @param {any} error
+ * @param {string} [filePath]
+ * @return {Promise<StylelintResult>}
+ */
+function handleError(stylelint, error, filePath = undefined) {
+	if (error.name === 'CssSyntaxError') {
+		return createStylelintResult(stylelint, undefined, filePath, error);
+	}
+
+	throw error;
+}

package/templates/facebook/node_modules/stylelint/lib/syntaxes/index.js

@@ -0,0 +1,16 @@
+'use strict';
+
+// Use this require pattern so that syntaxes can be bundled separately
+const importLazy = require('import-lazy')(require);
+
+/** @typedef {import('../getPostcssResult').Syntax} Syntax */
+/** @type {{[k: string]: Syntax}} */
+module.exports = {
+	'css-in-js': importLazy('./syntax-css-in-js'),
+	html: importLazy('./syntax-html'),
+	less: importLazy('./syntax-less'),
+	markdown: importLazy('./syntax-markdown'),
+	sass: importLazy('./syntax-sass'),
+	scss: importLazy('./syntax-scss'),
+	sugarss: importLazy('./syntax-sugarss'),
+};

package/templates/facebook/node_modules/stylelint/lib/syntaxes/syntax-css-in-js.js

@@ -0,0 +1,3 @@
+'use strict';
+
+module.exports = require('@stylelint/postcss-css-in-js')();

package/templates/facebook/node_modules/stylelint/lib/syntaxes/syntax-html.js

@@ -0,0 +1,8 @@
+'use strict';
+
+module.exports = require('postcss-html')({
+	scss: require('postcss-scss'),
+	less: require('postcss-less'),
+	sass: require('postcss-sass'),
+	sugarss: require('sugarss'),
+});

package/templates/facebook/node_modules/stylelint/lib/syntaxes/syntax-less.js

@@ -0,0 +1,3 @@
+'use strict';
+
+module.exports = require('postcss-less');

package/templates/facebook/node_modules/stylelint/lib/syntaxes/syntax-markdown.js

@@ -0,0 +1,8 @@
+'use strict';
+
+module.exports = require('@stylelint/postcss-markdown')({
+	scss: require('postcss-scss'),
+	less: require('postcss-less'),
+	sass: require('postcss-sass'),
+	sugarss: require('sugarss'),
+});

package/templates/facebook/node_modules/stylelint/lib/syntaxes/syntax-sass.js

@@ -0,0 +1,3 @@
+'use strict';
+
+module.exports = require('postcss-sass');

package/templates/facebook/node_modules/stylelint/lib/syntaxes/syntax-scss.js

@@ -0,0 +1,3 @@
+'use strict';
+
+module.exports = require('postcss-scss');

package/templates/facebook/node_modules/stylelint/lib/syntaxes/syntax-sugarss.js

@@ -0,0 +1,3 @@
+'use strict';
+
+module.exports = require('sugarss');

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

@@ -0,0 +1,68 @@
+'use strict';
+
+const debug = require('debug')('stylelint:file-cache');
+const fileEntryCache = require('file-entry-cache');
+const getCacheFile = require('./getCacheFile');
+const path = require('path');
+
+const DEFAULT_CACHE_LOCATION = './.stylelintcache';
+const DEFAULT_HASH = '';
+
+/** @typedef {import('file-entry-cache').FileDescriptor["meta"] & { hashOfConfig?: string }} CacheMetadata */
+
+/**
+ * @param {string} [cacheLocation]
+ * @param {string} [hashOfConfig]
+ * @constructor
+ */
+class FileCache {
+	constructor(cacheLocation = DEFAULT_CACHE_LOCATION, hashOfConfig = DEFAULT_HASH) {
+		const cacheFile = path.resolve(getCacheFile(cacheLocation, process.cwd()));
+
+		debug(`Cache file is created at ${cacheFile}`);
+		this._fileCache = fileEntryCache.create(cacheFile);
+		this._hashOfConfig = hashOfConfig;
+	}
+
+	/**
+	 * @param {string} absoluteFilepath
+	 * @return {boolean}
+	 */
+	hasFileChanged(absoluteFilepath) {
+		// Get file descriptor compares current metadata against cached
+		// one and stores the result to "changed" prop.w
+		const descriptor = this._fileCache.getFileDescriptor(absoluteFilepath);
+		/** @type {CacheMetadata} */
+		const meta = descriptor.meta || {};
+		const changed = descriptor.changed || meta.hashOfConfig !== this._hashOfConfig;
+
+		if (!changed) {
+			debug(`Skip linting ${absoluteFilepath}. File hasn't changed.`);
+		}
+
+		// Mutate file descriptor object and store config hash to each file.
+		// Running lint with different config should invalidate the cache.
+		if (meta.hashOfConfig !== this._hashOfConfig) {
+			meta.hashOfConfig = this._hashOfConfig;
+		}
+
+		return changed;
+	}
+
+	reconcile() {
+		this._fileCache.reconcile();
+	}
+
+	destroy() {
+		this._fileCache.destroy();
+	}
+
+	/**
+	 * @param {string} absoluteFilepath
+	 */
+	removeEntry(absoluteFilepath) {
+		this._fileCache.removeEntry(absoluteFilepath);
+	}
+}
+
+module.exports = FileCache;

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

@@ -0,0 +1,30 @@
+'use strict';
+
+const _ = require('lodash');
+
+/** @typedef {import('postcss').ChildNode} ChildNode */
+
+/**
+ * Add an empty line after a node. Mutates the node.
+ *
+ * @param {ChildNode} node
+ * @param {'\n' | '\r\n'} newline
+ * @returns {ChildNode}
+ */
+function addEmptyLineAfter(node, newline) {
+	if (node.raws.after === undefined) {
+		return node;
+	}
+
+	const after = _.last(node.raws.after.split(';')) || '';
+
+	if (!/\r?\n/.test(after)) {
+		node.raws.after += newline.repeat(2);
+	} else {
+		node.raws.after = node.raws.after.replace(/(\r?\n)/, `${newline}$1`);
+	}
+
+	return node;
+}
+
+module.exports = addEmptyLineAfter;

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

@@ -0,0 +1,26 @@
+'use strict';
+
+/** @typedef {import('postcss').ChildNode} ChildNode */
+
+/**
+ * Add an empty line before a node. Mutates the node.
+ *
+ * @param {ChildNode} node
+ * @param {'\n' | '\r\n'} newline
+ * @returns {ChildNode}
+ */
+function addEmptyLineBefore(node, newline) {
+	if (node.raws.before === undefined) {
+		return node;
+	}
+
+	if (!/\r?\n/.test(node.raws.before)) {
+		node.raws.before = newline.repeat(2) + node.raws.before;
+	} else {
+		node.raws.before = node.raws.before.replace(/(\r?\n)/, `${newline}$1`);
+	}
+
+	return node;
+}
+
+module.exports = addEmptyLineBefore;

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

@@ -0,0 +1,16 @@
+'use strict';
+
+/**
+ * @param {import('postcss').AtRule} atRule
+ * @returns {number}
+ */
+module.exports = function (atRule) {
+	// Initial 1 is for the `@`
+	let index = 1 + atRule.name.length;
+
+	if (atRule.raws.afterName) {
+		index += atRule.raws.afterName.length;
+	}
+
+	return index;
+};

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

@@ -0,0 +1,54 @@
+'use strict';
+
+/** @typedef {import('postcss').Rule} Rule */
+/** @typedef {import('postcss').AtRule} AtRule */
+
+/**
+ * @param {Rule | AtRule} statement
+ * @param {{
+ * 	noRawBefore?: boolean
+ * }} options
+ *
+ * @returns {string}
+ */
+module.exports = function (statement, options = {}) {
+	let result = '';
+	/** @type {Rule | undefined} */
+	let rule; /*?: postcss$rule*/
+	/** @type {AtRule | undefined} */
+	let atRule; /*?: postcss$atRule*/
+
+	if (statement.type === 'rule') {
+		rule = statement;
+	}
+
+	if (statement.type === 'atrule') {
+		atRule = statement;
+	}
+
+	if (!rule && !atRule) {
+		return result;
+	}
+
+	const before = statement.raws.before || '';
+
+	if (!options.noRawBefore) {
+		result += before;
+	}
+
+	if (rule) {
+		result += rule.selector;
+	}
+
+	if (atRule) {
+		result += `@${atRule.name}${atRule.raws.afterName || ''}${atRule.params}`;
+	}
+
+	const between = statement.raws.between;
+
+	if (between !== undefined) {
+		result += between;
+	}
+
+	return result;
+};

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

@@ -0,0 +1,25 @@
+'use strict';
+
+const beforeBlockString = require('./beforeBlockString');
+const hasBlock = require('./hasBlock');
+const rawNodeString = require('./rawNodeString');
+
+/** @typedef {import('postcss').Rule} Rule */
+/** @typedef {import('postcss').AtRule} AtRule */
+
+/**
+ * Return a CSS statement's block -- the string that starts and `{` and ends with `}`.
+ *
+ * If the statement has no block (e.g. `@import url(foo.css);`),
+ * return false.
+ *
+ * @param {Rule | AtRule} statement - postcss rule or at-rule node
+ * @return {string | boolean}
+ */
+module.exports = function (statement) {
+	if (!hasBlock(statement)) {
+		return false;
+	}
+
+	return rawNodeString(statement).slice(beforeBlockString(statement).length);
+};

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

@@ -0,0 +1,10 @@
+'use strict';
+
+/**
+ * @param {string} source
+ *
+ * @returns {string}
+ */
+module.exports = function (source, blurChar = '`') {
+	return source.replace(/\/\*.*\*\//g, blurChar);
+};

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

@@ -0,0 +1,53 @@
+'use strict';
+
+const balancedMatch = require('balanced-match');
+
+/**
+ * Replace all of the characters that are arguments to a certain
+ * CSS function with some innocuous character.
+ *
+ * This is useful if you need to use a RegExp to find a string
+ * but want to ignore matches in certain functions (e.g. `url()`,
+ * which might contain all kinds of false positives).
+ *
+ * For example:
+ * blurFunctionArguments("abc url(abc) abc", "url") === "abc url(```) abc"
+ *
+ * @param {string} source
+ * @param {string} functionName
+ * @return {string} - The result string, with the function arguments "blurred"
+ */
+module.exports = function (source, functionName, blurChar = '`') {
+	const nameWithParen = `${functionName.toLowerCase()}(`;
+	const lowerCaseSource = source.toLowerCase();
+
+	if (!lowerCaseSource.includes(nameWithParen)) {
+		return source;
+	}
+
+	const functionNameLength = functionName.length;
+
+	let result = source;
+	let searchStartIndex = 0;
+
+	while (lowerCaseSource.includes(nameWithParen, searchStartIndex)) {
+		const openingParenIndex =
+			lowerCaseSource.indexOf(nameWithParen, searchStartIndex) + functionNameLength;
+		const parensMatch = balancedMatch('(', ')', lowerCaseSource.slice(openingParenIndex));
+
+		if (!parensMatch) {
+			throw new Error(`No parens match: "${source}"`);
+		}
+
+		const closingParenIndex = parensMatch.end + openingParenIndex;
+		const argumentsLength = closingParenIndex - openingParenIndex - 1;
+
+		result =
+			result.slice(0, openingParenIndex + 1) +
+			blurChar.repeat(argumentsLength) +
+			result.slice(closingParenIndex);
+		searchStartIndex = closingParenIndex;
+	}
+
+	return result;
+};

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

@@ -0,0 +1,10 @@
+'use strict';
+
+/**
+ * @param {string} source
+ *
+ * @returns {string}
+ */
+module.exports = function (source, blurChar = ' ') {
+	return source.replace(/[#@{}]+/g, blurChar);
+};