create-docusaurus 0.0.0-4378 → 0.0.0-4379

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

@@ -0,0 +1,182 @@
+'use strict';
+
+const fs = require('fs');
+const LazyResult = require('postcss/lib/lazy-result');
+const postcss = require('postcss');
+const syntaxes = require('./syntaxes');
+
+/** @typedef {import('postcss').Result} Result */
+/** @typedef {import('postcss').Syntax} Syntax */
+/** @typedef {import('stylelint').CustomSyntax} CustomSyntax */
+/** @typedef {import('stylelint').GetPostcssOptions} GetPostcssOptions */
+/** @typedef {import('stylelint').StylelintInternalApi} StylelintInternalApi */
+
+const postcssProcessor = postcss();
+
+/**
+ * @param {StylelintInternalApi} stylelint
+ * @param {GetPostcssOptions} options
+ *
+ * @returns {Promise<Result>}
+ */
+module.exports = function (stylelint, options = {}) {
+	const cached = options.filePath ? stylelint._postcssResultCache.get(options.filePath) : undefined;
+
+	if (cached) return Promise.resolve(cached);
+
+	/** @type {Promise<string> | undefined} */
+	let getCode;
+
+	if (options.code !== undefined) {
+		getCode = Promise.resolve(options.code);
+	} else if (options.filePath) {
+		getCode = readFile(options.filePath);
+	}
+
+	if (!getCode) {
+		throw new Error('code or filePath required');
+	}
+
+	return getCode
+		.then((code) => {
+			/** @type {Syntax | null} */
+			let syntax = null;
+
+			if (stylelint._options.customSyntax) {
+				syntax = getCustomSyntax(stylelint._options.customSyntax);
+			} else if (stylelint._options.syntax) {
+				if (stylelint._options.syntax === 'css') {
+					syntax = cssSyntax(stylelint);
+				} else {
+					const keys = Object.keys(syntaxes);
+
+					if (!keys.includes(stylelint._options.syntax)) {
+						throw new Error(
+							`You must use a valid syntax option, either: css, ${keys
+								.slice(0, -1)
+								.join(', ')} or ${keys.slice(-1)}`,
+						);
+					}
+
+					syntax = syntaxes[stylelint._options.syntax];
+				}
+			} else if (!(options.codeProcessors && options.codeProcessors.length)) {
+				const autoSyntax = require('postcss-syntax');
+
+				// TODO: investigate why lazy import HTML syntax causes
+				// JS files with the word "html" to throw TypeError
+				// https://github.com/stylelint/stylelint/issues/4793
+				const { html, ...rest } = syntaxes;
+
+				syntax = autoSyntax({
+					css: cssSyntax(stylelint),
+					jsx: syntaxes['css-in-js'],
+					...rest,
+				});
+			}
+
+			const postcssOptions = {
+				from: options.filePath,
+				syntax,
+			};
+
+			const source = options.code ? options.codeFilename : options.filePath;
+			let preProcessedCode = code;
+
+			if (options.codeProcessors && options.codeProcessors.length) {
+				if (stylelint._options.fix) {
+					console.warn(
+						'Autofix is incompatible with processors and will be disabled. Are you sure you need a processor?',
+					);
+					stylelint._options.fix = false;
+				}
+
+				options.codeProcessors.forEach((codeProcessor) => {
+					preProcessedCode = codeProcessor(preProcessedCode, source);
+				});
+			}
+
+			const result = new LazyResult(postcssProcessor, preProcessedCode, postcssOptions);
+
+			return result;
+		})
+		.then((postcssResult) => {
+			if (options.filePath) {
+				stylelint._postcssResultCache.set(options.filePath, postcssResult);
+			}
+
+			return postcssResult;
+		});
+};
+
+/**
+ * @param {CustomSyntax} customSyntax
+ * @returns {Syntax}
+ */
+function getCustomSyntax(customSyntax) {
+	let resolved;
+
+	if (typeof customSyntax === 'string') {
+		try {
+			resolved = require(customSyntax);
+		} catch {
+			throw new Error(
+				`Cannot resolve custom syntax module ${customSyntax}. Check that module ${customSyntax} is available and spelled correctly.`,
+			);
+		}
+
+		/*
+		 * PostCSS allows for syntaxes that only contain a parser, however,
+		 * it then expects the syntax to be set as the `parse` option.
+		 */
+		if (!resolved.parse) {
+			resolved = {
+				parse: resolved,
+				stringify: postcss.stringify,
+			};
+		}
+
+		return resolved;
+	}
+
+	if (typeof customSyntax === 'object') {
+		if (typeof customSyntax.parse === 'function') {
+			resolved = { ...customSyntax };
+		} else {
+			throw new TypeError(
+				`An object provided to the "customSyntax" option must have a "parse" property. Ensure the "parse" property exists and its value is a function.`,
+			);
+		}
+
+		return resolved;
+	}
+
+	throw new Error(`Custom syntax must be a string or a Syntax object`);
+}
+
+/**
+ * @param {string} filePath
+ * @returns {Promise<string>}
+ */
+function readFile(filePath) {
+	return new Promise((resolve, reject) => {
+		fs.readFile(filePath, 'utf8', (err, content) => {
+			if (err) {
+				return reject(err);
+			}
+
+			resolve(content);
+		});
+	});
+}
+
+/**
+ * @param {StylelintInternalApi} stylelint
+ * @returns {Syntax}
+ */
+function cssSyntax(stylelint) {
+	return {
+		parse: stylelint._options.fix ? require('postcss-safe-parser') : postcss.parse,
+		stringify: postcss.stringify,
+	};
+}

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

@@ -0,0 +1,33 @@
+'use strict';
+
+const checkAgainstRule = require('./utils/checkAgainstRule');
+const createPlugin = require('./createPlugin');
+const createStylelint = require('./createStylelint');
+const formatters = require('./formatters');
+const postcssPlugin = require('./postcssPlugin');
+const report = require('./utils/report');
+const ruleMessages = require('./utils/ruleMessages');
+const rules = require('./rules');
+const standalone = require('./standalone');
+const validateOptions = require('./utils/validateOptions');
+
+/**
+ * TODO TYPES change any to appropriated options
+ * @type {import('postcss').Plugin<any> & Partial<import('stylelint').StylelintPublicAPI>}
+ */
+const api = postcssPlugin;
+
+api.utils = {
+	report,
+	ruleMessages,
+	validateOptions,
+	checkAgainstRule,
+};
+
+api.lint = standalone;
+api.rules = rules;
+api.formatters = formatters;
+api.createPlugin = createPlugin;
+api.createLinter = createStylelint;
+
+module.exports = api;

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

@@ -0,0 +1,50 @@
+'use strict';
+
+const optionsMatches = require('./utils/optionsMatches');
+const validateDisableSettings = require('./validateDisableSettings');
+
+/** @typedef {import('stylelint').RangeType} RangeType */
+
+/**
+ * @param {import('stylelint').StylelintResult[]} results
+ */
+module.exports = function (results) {
+	results.forEach((result) => {
+		const settings = validateDisableSettings(result._postcssResult, 'reportInvalidScopeDisables');
+
+		if (!settings) return;
+
+		const [enabled, options, stylelintResult] = settings;
+
+		const configRules = (stylelintResult.config || {}).rules || {};
+
+		const usedRules = new Set(Object.keys(configRules));
+
+		usedRules.add('all');
+
+		const rangeData = stylelintResult.disabledRanges;
+		const disabledRules = Object.keys(rangeData);
+
+		disabledRules.forEach((rule) => {
+			if (usedRules.has(rule)) return;
+
+			if (enabled === optionsMatches(options, 'except', rule)) return;
+
+			rangeData[rule].forEach((range) => {
+				if (!range.strictStart && !range.strictEnd) return;
+
+				// If the comment doesn't have a location, we can't report a useful error.
+				// In practice we expect all comments to have locations, though.
+				if (!range.comment.source || !range.comment.source.start) return;
+
+				result.warnings.push({
+					text: `Rule "${rule}" isn't enabled`,
+					rule: '--report-invalid-scope-disables',
+					line: range.comment.source.start.line,
+					column: range.comment.source.start.column,
+					severity: options.severity,
+				});
+			});
+		});
+	});
+};

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

@@ -0,0 +1,48 @@
+'use strict';
+
+const filterFilePaths = require('./utils/filterFilePaths');
+const getFileIgnorer = require('./utils/getFileIgnorer');
+const micromatch = require('micromatch');
+const path = require('path');
+const slash = require('slash');
+
+/**
+ * To find out if a path is ignored, we need to load the config,
+ * which may have an ignoreFiles property. We then check the path
+ * against these.
+ * @param {import('stylelint').StylelintInternalApi} stylelint
+ * @param {string} [filePath]
+ * @return {Promise<boolean>}
+ */
+module.exports = function (stylelint, filePath) {
+	if (!filePath) {
+		return Promise.resolve(false);
+	}
+
+	const cwd = process.cwd();
+	const ignorer = getFileIgnorer(stylelint._options);
+
+	return stylelint.getConfigForFile(filePath).then((result) => {
+		if (!result) {
+			return true;
+		}
+
+		// Glob patterns for micromatch should be in POSIX-style
+		const ignoreFiles = /** @type {Array<string>} */ (result.config.ignoreFiles || []).map(slash);
+
+		const absoluteFilePath = path.isAbsolute(filePath)
+			? filePath
+			: path.resolve(process.cwd(), filePath);
+
+		if (micromatch([absoluteFilePath], ignoreFiles).length) {
+			return true;
+		}
+
+		// Check filePath with .stylelintignore file
+		if (filterFilePaths(ignorer, [path.relative(cwd, absoluteFilePath)]).length === 0) {
+			return true;
+		}
+
+		return false;
+	});
+};

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

@@ -0,0 +1,134 @@
+'use strict';
+
+const assignDisabledRanges = require('./assignDisabledRanges');
+const get = require('lodash/get');
+const getOsEol = require('./utils/getOsEol');
+const reportUnknownRuleNames = require('./reportUnknownRuleNames');
+const rulesOrder = require('./rules');
+
+/** @typedef {import('stylelint').StylelintStandaloneOptions} StylelintStandaloneOptions */
+/** @typedef {import('stylelint').PostcssResult} PostcssResult */
+/** @typedef {import('stylelint').StylelintConfig} StylelintConfig */
+
+/**
+ * @param {StylelintStandaloneOptions} stylelintOptions
+ * @param {PostcssResult} postcssResult
+ * @param {StylelintConfig} config
+ * @returns {Promise<any>}
+ */
+function lintPostcssResult(stylelintOptions, postcssResult, config) {
+	postcssResult.stylelint.ruleSeverities = {};
+	postcssResult.stylelint.customMessages = {};
+	postcssResult.stylelint.stylelintError = false;
+	postcssResult.stylelint.quiet = config.quiet;
+	postcssResult.stylelint.config = config;
+
+	/** @type {string} */
+	let newline;
+	const postcssDoc = postcssResult.root;
+
+	if (postcssDoc) {
+		if (!('type' in postcssDoc)) {
+			throw new Error('Unexpected Postcss root object!');
+		}
+
+		// @ts-ignore TODO TYPES property css does not exists
+		const newlineMatch = postcssDoc.source && postcssDoc.source.input.css.match(/\r?\n/);
+
+		newline = newlineMatch ? newlineMatch[0] : getOsEol();
+
+		assignDisabledRanges(postcssDoc, postcssResult);
+	}
+
+	const isFileFixCompatible = isFixCompatible(postcssResult);
+
+	if (!isFileFixCompatible) {
+		postcssResult.stylelint.disableWritingFix = true;
+	}
+
+	const postcssRoots = /** @type {import('postcss').Root[]} */ (postcssDoc &&
+	postcssDoc.constructor.name === 'Document'
+		? postcssDoc.nodes
+		: [postcssDoc]);
+
+	// Promises for the rules. Although the rule code runs synchronously now,
+	// the use of Promises makes it compatible with the possibility of async
+	// rules down the line.
+	/** @type {Array<Promise<any>>} */
+	const performRules = [];
+
+	const rules = config.rules
+		? Object.keys(config.rules).sort(
+				(a, b) => Object.keys(rulesOrder).indexOf(a) - Object.keys(rulesOrder).indexOf(b),
+		  )
+		: [];
+
+	rules.forEach((ruleName) => {
+		const ruleFunction = rulesOrder[ruleName] || get(config, ['pluginFunctions', ruleName]);
+
+		if (ruleFunction === undefined) {
+			performRules.push(
+				Promise.all(
+					postcssRoots.map((postcssRoot) =>
+						reportUnknownRuleNames(ruleName, postcssRoot, postcssResult),
+					),
+				),
+			);
+
+			return;
+		}
+
+		const ruleSettings = get(config, ['rules', ruleName]);
+
+		if (ruleSettings === null || ruleSettings[0] === null) {
+			return;
+		}
+
+		const primaryOption = ruleSettings[0];
+		const secondaryOptions = ruleSettings[1];
+
+		// Log the rule's severity in the PostCSS result
+		const defaultSeverity = config.defaultSeverity || 'error';
+
+		postcssResult.stylelint.ruleSeverities[ruleName] = get(
+			secondaryOptions,
+			'severity',
+			defaultSeverity,
+		);
+		postcssResult.stylelint.customMessages[ruleName] = get(secondaryOptions, 'message');
+
+		performRules.push(
+			Promise.all(
+				postcssRoots.map((postcssRoot) =>
+					ruleFunction(primaryOption, secondaryOptions, {
+						fix:
+							stylelintOptions.fix &&
+							// Next two conditionals are temporary measures until #2643 is resolved
+							isFileFixCompatible &&
+							!postcssResult.stylelint.disabledRanges[ruleName],
+						newline,
+					})(postcssRoot, postcssResult),
+				),
+			),
+		);
+	});
+
+	return Promise.all(performRules);
+}
+
+/**
+ * There are currently some bugs in the autofixer of Stylelint.
+ * The autofixer does not yet adhere to stylelint-disable comments, so if there are disabled
+ * ranges we can not autofix this document. More info in issue #2643.
+ *
+ * @param {PostcssResult} postcssResult
+ * @returns {boolean}
+ */
+function isFixCompatible({ stylelint }) {
+	// Check for issue #2643
+	if (stylelint.disabledRanges.all.length) return false;
+
+	return true;
+}
+
+module.exports = lintPostcssResult;

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

@@ -0,0 +1,133 @@
+'use strict';
+
+const lintPostcssResult = require('./lintPostcssResult');
+const path = require('path');
+
+/** @typedef {import('stylelint').StylelintInternalApi} StylelintInternalApi */
+/** @typedef {import('stylelint').GetLintSourceOptions} Options */
+/** @typedef {import('postcss').Result} Result */
+/** @typedef {import('stylelint').PostcssResult} PostcssResult */
+/** @typedef {import('stylelint').StylelintPostcssResult} StylelintPostcssResult */
+
+/**
+ * Run stylelint on a PostCSS Result, either one that is provided
+ * or one that we create
+ * @param {StylelintInternalApi} stylelint
+ * @param {Options} options
+ * @returns {Promise<PostcssResult>}
+ */
+module.exports = function lintSource(stylelint, options = {}) {
+	if (!options.filePath && options.code === undefined && !options.existingPostcssResult) {
+		return Promise.reject(new Error('You must provide filePath, code, or existingPostcssResult'));
+	}
+
+	const isCodeNotFile = options.code !== undefined;
+
+	const inputFilePath = isCodeNotFile ? options.codeFilename : options.filePath;
+
+	if (inputFilePath !== undefined && !path.isAbsolute(inputFilePath)) {
+		if (isCodeNotFile) {
+			return Promise.reject(new Error('codeFilename must be an absolute path'));
+		}
+
+		return Promise.reject(new Error('filePath must be an absolute path'));
+	}
+
+	const getIsIgnored = stylelint.isPathIgnored(inputFilePath).catch((err) => {
+		if (isCodeNotFile && err.code === 'ENOENT') return false;
+
+		throw err;
+	});
+
+	return getIsIgnored.then((isIgnored) => {
+		if (isIgnored) {
+			/** @type {PostcssResult} */
+
+			return options.existingPostcssResult
+				? Object.assign(options.existingPostcssResult, {
+						stylelint: createEmptyStylelintPostcssResult(),
+				  })
+				: createEmptyPostcssResult(inputFilePath);
+		}
+
+		const configSearchPath = stylelint._options.configFile || inputFilePath;
+
+		const getConfig = stylelint.getConfigForFile(configSearchPath).catch((err) => {
+			if (isCodeNotFile && err.code === 'ENOENT') return stylelint.getConfigForFile(process.cwd());
+
+			throw err;
+		});
+
+		return getConfig.then((result) => {
+			if (!result) {
+				throw new Error('Config file not found');
+			}
+
+			const config = result.config;
+			const existingPostcssResult = options.existingPostcssResult;
+			const stylelintResult = {
+				ruleSeverities: {},
+				customMessages: {},
+				disabledRanges: {},
+			};
+
+			if (existingPostcssResult) {
+				const stylelintPostcssResult = Object.assign(existingPostcssResult, {
+					stylelint: stylelintResult,
+				});
+
+				return lintPostcssResult(stylelint._options, stylelintPostcssResult, config).then(
+					() => stylelintPostcssResult,
+				);
+			}
+
+			return stylelint
+				._getPostcssResult({
+					code: options.code,
+					codeFilename: options.codeFilename,
+					filePath: inputFilePath,
+					codeProcessors: config.codeProcessors,
+				})
+				.then((postcssResult) => {
+					const stylelintPostcssResult = Object.assign(postcssResult, {
+						stylelint: stylelintResult,
+					});
+
+					return lintPostcssResult(stylelint._options, stylelintPostcssResult, config).then(
+						() => stylelintPostcssResult,
+					);
+				});
+		});
+	});
+};
+
+/**
+ * @returns {StylelintPostcssResult}
+ */
+function createEmptyStylelintPostcssResult() {
+	return {
+		ruleSeverities: {},
+		customMessages: {},
+		disabledRanges: {},
+		ignored: true,
+		stylelintError: false,
+	};
+}
+
+/**
+ * @param {string} [filePath]
+ * @returns {PostcssResult}
+ */
+function createEmptyPostcssResult(filePath) {
+	return {
+		root: {
+			source: {
+				input: { file: filePath },
+			},
+		},
+		messages: [],
+		opts: undefined,
+		stylelint: createEmptyStylelintPostcssResult(),
+		warn: () => {},
+	};
+}

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

@@ -0,0 +1,110 @@
+'use strict';
+
+const _ = require('lodash');
+const optionsMatches = require('./utils/optionsMatches');
+const putIfAbsent = require('./utils/putIfAbsent');
+const validateDisableSettings = require('./validateDisableSettings');
+
+/** @typedef {import('postcss/lib/comment')} PostcssComment */
+/** @typedef {import('stylelint').DisabledRange} DisabledRange */
+/** @typedef {import('stylelint').RangeType} RangeType */
+/** @typedef {import('stylelint').DisableReportRange} DisableReportRange */
+
+/**
+ * @param {import('stylelint').StylelintResult[]} results
+ */
+module.exports = function (results) {
+	results.forEach((result) => {
+		const settings = validateDisableSettings(result._postcssResult, 'reportNeedlessDisables');
+
+		if (!settings) return;
+
+		const [enabled, options, stylelintResult] = settings;
+
+		/** @type {{[ruleName: string]: Array<DisabledRange>}} */
+		const rangeData = _.cloneDeep(stylelintResult.disabledRanges);
+
+		if (!rangeData) return;
+
+		const disabledWarnings = stylelintResult.disabledWarnings || [];
+
+		// A map from `stylelint-disable` comments to the set of rules that
+		// are usefully disabled by each comment. We track this
+		// comment-by-comment rather than range-by-range because ranges that
+		// disable *all* rules are duplicated for each rule they apply to in
+		// practice.
+		/** @type {Map<PostcssComment, Set<string>>}} */
+		const usefulDisables = new Map();
+
+		for (const warning of disabledWarnings) {
+			const rule = warning.rule;
+			const ruleRanges = rangeData[rule];
+
+			if (ruleRanges) {
+				for (const range of ruleRanges) {
+					if (isWarningInRange(warning, range)) {
+						putIfAbsent(usefulDisables, range.comment, () => new Set()).add(rule);
+					}
+				}
+			}
+
+			for (const range of rangeData.all) {
+				if (isWarningInRange(warning, range)) {
+					putIfAbsent(usefulDisables, range.comment, () => new Set()).add(rule);
+				}
+			}
+		}
+
+		const rangeEntries = Object.entries(rangeData);
+
+		// Get rid of the duplicated ranges for each `all` rule. We only care
+		// if the entire `all` rule is useful as a whole or not.
+		for (const range of rangeData.all) {
+			for (const [rule, ranges] of rangeEntries) {
+				if (rule === 'all') continue;
+
+				_.remove(ranges, (otherRange) => range.comment === otherRange.comment);
+			}
+		}
+
+		for (const [rule, ranges] of rangeEntries) {
+			for (const range of ranges) {
+				if (enabled === optionsMatches(options, 'except', rule)) continue;
+
+				const useful = usefulDisables.get(range.comment) || new Set();
+
+				// Only emit a warning if this range's comment isn't useful for this rule.
+				// For the special rule "all", only emit a warning if it's not useful for
+				// *any* rules, because it covers all of them.
+				if (rule === 'all' ? useful.size !== 0 : useful.has(rule)) continue;
+
+				// If the comment doesn't have a location, we can't report a useful error.
+				// In practice we expect all comments to have locations, though.
+				if (!range.comment.source || !range.comment.source.start) continue;
+
+				result.warnings.push({
+					text: `Needless disable for "${rule}"`,
+					rule: '--report-needless-disables',
+					line: range.comment.source.start.line,
+					column: range.comment.source.start.column,
+					severity: options.severity,
+				});
+			}
+		}
+	});
+};
+
+/**
+ * @param {import('stylelint').DisabledWarning} warning
+ * @param {RangeType} range
+ * @return {boolean}
+ */
+function isWarningInRange(warning, range) {
+	const line = warning.line;
+
+	// Need to check if range.end exist, because line number type cannot be compared to undefined
+	return (
+		range.start <= line &&
+		((range.end !== undefined && range.end >= line) || range.end === undefined)
+	);
+}