create-docusaurus 0.0.0-4483 → 0.0.0-4487

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

@@ -1,334 +0,0 @@
-'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

@@ -1,16 +0,0 @@
-'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

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

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

@@ -1,8 +0,0 @@
-'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

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

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

@@ -1,8 +0,0 @@
-'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

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

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

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

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

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

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

@@ -1,68 +0,0 @@
-'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

@@ -1,30 +0,0 @@
-'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

@@ -1,26 +0,0 @@
-'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

@@ -1,16 +0,0 @@
-'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

@@ -1,54 +0,0 @@
-'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

@@ -1,25 +0,0 @@
-'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

@@ -1,10 +0,0 @@
-'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

@@ -1,53 +0,0 @@
-'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;
-};