create-docusaurus 0.0.0-4378 → 0.0.0-4379

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

@@ -0,0 +1,88 @@
+'use strict';
+
+const _ = require('lodash');
+const augmentConfig = require('./augmentConfig');
+const createStylelintResult = require('./createStylelintResult');
+const getConfigForFile = require('./getConfigForFile');
+const getPostcssResult = require('./getPostcssResult');
+const isPathIgnored = require('./isPathIgnored');
+const lintSource = require('./lintSource');
+const path = require('path');
+const { cosmiconfig } = require('cosmiconfig');
+
+const IS_TEST = process.env.NODE_ENV === 'test';
+const STOP_DIR = IS_TEST ? path.resolve(__dirname, '..') : undefined;
+
+/** @typedef {import('stylelint').StylelintInternalApi} StylelintInternalApi */
+
+/**
+ * The stylelint "internal API" is passed among functions
+ * so that methods on a stylelint instance can invoke
+ * each other while sharing options and caches
+ * @param {import('stylelint').StylelintStandaloneOptions} options
+ * @returns {StylelintInternalApi}
+ */
+module.exports = function (options = {}) {
+	/** @type {Partial<StylelintInternalApi>} */
+	const stylelint = { _options: options };
+
+	options.configOverrides = options.configOverrides || {};
+
+	if (options.ignoreDisables) {
+		options.configOverrides.ignoreDisables = options.ignoreDisables;
+	}
+
+	if (options.reportNeedlessDisables) {
+		options.configOverrides.reportNeedlessDisables = options.reportNeedlessDisables;
+	}
+
+	if (options.reportInvalidScopeDisables) {
+		options.configOverrides.reportInvalidScopeDisables = options.reportInvalidScopeDisables;
+	}
+
+	if (options.reportDescriptionlessDisables) {
+		options.configOverrides.reportDescriptionlessDisables = options.reportDescriptionlessDisables;
+	}
+
+	// Two separate explorers so they can each have their own transform
+	// function whose results are cached by cosmiconfig
+	stylelint._fullExplorer = cosmiconfig('stylelint', {
+		// @ts-ignore TODO TYPES found out which cosmiconfig types are valid
+		transform: _.partial(
+			augmentConfig.augmentConfigFull,
+			/** @type{StylelintInternalApi} */ (stylelint),
+		),
+		stopDir: STOP_DIR,
+	});
+	// @ts-ignore TODO TYPES found out which cosmiconfig types are valid
+	stylelint._extendExplorer = cosmiconfig(null, {
+		transform: _.partial(
+			augmentConfig.augmentConfigExtended,
+			/** @type{StylelintInternalApi} */ (stylelint),
+		),
+		stopDir: STOP_DIR,
+	});
+
+	stylelint._specifiedConfigCache = new Map();
+	stylelint._postcssResultCache = new Map();
+	stylelint._createStylelintResult = _.partial(
+		createStylelintResult,
+		/** @type{StylelintInternalApi} */ (stylelint),
+	);
+	stylelint._getPostcssResult = _.partial(
+		getPostcssResult,
+		/** @type{StylelintInternalApi} */ (stylelint),
+	);
+	stylelint._lintSource = _.partial(lintSource, /** @type{StylelintInternalApi} */ (stylelint));
+
+	stylelint.getConfigForFile = _.partial(
+		getConfigForFile,
+		/** @type{StylelintInternalApi} */ (stylelint),
+	);
+	stylelint.isPathIgnored = _.partial(
+		isPathIgnored,
+		/** @type{StylelintInternalApi} */ (stylelint),
+	);
+
+	return /** @type{StylelintInternalApi} */ (stylelint);
+};

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

@@ -0,0 +1,39 @@
+'use strict';
+
+const createPartialStylelintResult = require('./createPartialStylelintResult');
+
+/** @typedef {import('stylelint').PostcssResult} PostcssResult */
+/** @typedef {import('postcss').NodeSource} NodeSource */
+/** @typedef {import('stylelint').StylelintResult} StylelintResult */
+
+/**
+ * @param {import('stylelint').StylelintInternalApi} stylelint
+ * @param {PostcssResult} [postcssResult]
+ * @param {string} [filePath]
+ * @param {import('stylelint').StylelintCssSyntaxError} [cssSyntaxError]
+ * @return {Promise<StylelintResult>}
+ */
+module.exports = function (stylelint, postcssResult, filePath, cssSyntaxError) {
+	let stylelintResult = createPartialStylelintResult(postcssResult, cssSyntaxError);
+
+	return stylelint.getConfigForFile(filePath).then((configForFile) => {
+		// TODO TYPES handle possible null here
+		const config = /** @type {{ config: import('stylelint').StylelintConfig, filepath: string }} */ (configForFile)
+			.config;
+		const file = stylelintResult.source || (cssSyntaxError && cssSyntaxError.file);
+
+		if (config.resultProcessors) {
+			config.resultProcessors.forEach((resultProcessor) => {
+				// Result processors might just mutate the result object,
+				// or might return a new one
+				const returned = resultProcessor(stylelintResult, file);
+
+				if (returned) {
+					stylelintResult = returned;
+				}
+			});
+		}
+
+		return stylelintResult;
+	});
+};

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

@@ -0,0 +1,62 @@
+'use strict';
+
+const optionsMatches = require('./utils/optionsMatches');
+const validateDisableSettings = require('./validateDisableSettings');
+
+/** @typedef {import('postcss/lib/comment')} PostcssComment */
+/** @typedef {import('stylelint').RangeType} RangeType */
+/** @typedef {import('stylelint').DisableReportRange} DisableReportRange */
+/** @typedef {import('stylelint').StylelintDisableOptionsReport} StylelintDisableOptionsReport */
+
+/**
+ * @param {import('stylelint').StylelintResult[]} results
+ */
+module.exports = function (results) {
+	results.forEach((result) => {
+		const settings = validateDisableSettings(
+			result._postcssResult,
+			'reportDescriptionlessDisables',
+		);
+
+		if (!settings) return;
+
+		const [enabled, options, stylelintResult] = settings;
+
+		const rangeData = stylelintResult.disabledRanges;
+
+		/** @type {Set<PostcssComment>} */
+		const alreadyReported = new Set();
+
+		Object.keys(rangeData).forEach((rule) => {
+			rangeData[rule].forEach((range) => {
+				if (range.description) return;
+
+				if (alreadyReported.has(range.comment)) return;
+
+				if (enabled === optionsMatches(options, 'except', rule)) {
+					// An 'all' rule will get copied for each individual rule. If the
+					// configuration is `[false, {except: ['specific-rule']}]`, we
+					// don't want to report the copies that match except, so we record
+					// the comment as already reported.
+					if (!enabled && rule === 'all') alreadyReported.add(range.comment);
+
+					return;
+				}
+
+				alreadyReported.add(range.comment);
+
+				// 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: `Disable for "${rule}" is missing a description`,
+					rule: '--report-descriptionless-disables',
+					line: range.comment.source.start.line,
+					column: range.comment.source.start.column,
+					severity: options.severity,
+				});
+			});
+		});
+	});
+};

package/templates/facebook/node_modules/stylelint/lib/formatters/compactFormatter.js

@@ -0,0 +1,20 @@
+'use strict';
+
+const _ = require('lodash');
+
+/**
+ * @type {import('stylelint').Formatter}
+ */
+const formatter = (results) =>
+	_.flatMap(results, (result) =>
+		result.warnings.map(
+			(warning) =>
+				`${result.source}: ` +
+				`line ${warning.line}, ` +
+				`col ${warning.column}, ` +
+				`${warning.severity} - ` +
+				`${warning.text}`,
+		),
+	).join('\n');
+
+module.exports = formatter;

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

@@ -0,0 +1,12 @@
+'use strict';
+
+const importLazy = require('import-lazy');
+
+module.exports = {
+	compact: importLazy(() => require('./compactFormatter'))('compactFormatter'),
+	json: importLazy(() => require('./jsonFormatter'))('jsonFormatter'),
+	string: importLazy(() => require('./stringFormatter'))('stringFormatter'),
+	tap: importLazy(() => require('./tapFormatter'))('tapFormatter'),
+	unix: importLazy(() => require('./unixFormatter'))('unixFormatter'),
+	verbose: importLazy(() => require('./verboseFormatter'))('verboseFormatter'),
+};

package/templates/facebook/node_modules/stylelint/lib/formatters/jsonFormatter.js

@@ -0,0 +1,20 @@
+'use strict';
+
+/**
+ * Omit any properties starting with `_`, which are fake-private
+ *
+ * @type {import('stylelint').Formatter}
+ */
+module.exports = function jsonFormatter(results) {
+	const cleanedResults = results.map((result) =>
+		Object.entries(result)
+			.filter(([key]) => !key.startsWith('_'))
+			.reduce((/** @type {{ [key: string]: any }} */ obj, [key, value]) => {
+				obj[key] = value;
+
+				return obj;
+			}, {}),
+	);
+
+	return JSON.stringify(cleanedResults);
+};

package/templates/facebook/node_modules/stylelint/lib/formatters/stringFormatter.js

@@ -0,0 +1,225 @@
+'use strict';
+
+const _ = require('lodash');
+const chalk = require('chalk');
+const path = require('path');
+const stringWidth = require('string-width');
+const symbols = require('log-symbols');
+const table = require('table');
+
+const MARGIN_WIDTHS = 9;
+
+const levelColors = {
+	info: 'blue',
+	warning: 'yellow',
+	error: 'red',
+	success: undefined,
+};
+
+/**
+ * @param {import('stylelint').StylelintResult[]} results
+ * @returns {string}
+ */
+function deprecationsFormatter(results) {
+	const allDeprecationWarnings = _.flatMap(results, 'deprecations');
+	const uniqueDeprecationWarnings = _.uniqBy(allDeprecationWarnings, 'text');
+
+	if (!uniqueDeprecationWarnings || !uniqueDeprecationWarnings.length) {
+		return '';
+	}
+
+	return uniqueDeprecationWarnings.reduce((output, warning) => {
+		output += chalk.yellow('Deprecation Warning: ');
+		output += warning.text;
+
+		if (warning.reference) {
+			output += chalk.dim(' See: ');
+			output += chalk.dim.underline(warning.reference);
+		}
+
+		return `${output}\n`;
+	}, '\n');
+}
+
+/**
+ * @param {import('stylelint').StylelintResult[]} results
+ * @return {string}
+ */
+function invalidOptionsFormatter(results) {
+	const allInvalidOptionWarnings = _.flatMap(results, (r) =>
+		r.invalidOptionWarnings.map((w) => w.text),
+	);
+	const uniqueInvalidOptionWarnings = [...new Set(allInvalidOptionWarnings)];
+
+	return uniqueInvalidOptionWarnings.reduce((output, warning) => {
+		output += chalk.red('Invalid Option: ');
+		output += warning;
+
+		return `${output}\n`;
+	}, '\n');
+}
+
+/**
+ * @param {string} fromValue
+ * @return {string}
+ */
+function logFrom(fromValue) {
+	if (fromValue.startsWith('<')) return fromValue;
+
+	return path.relative(process.cwd(), fromValue).split(path.sep).join('/');
+}
+
+/**
+ * @param {{[k: number]: number}} columnWidths
+ * @return {number}
+ */
+function getMessageWidth(columnWidths) {
+	if (!process.stdout.isTTY) {
+		return columnWidths[3];
+	}
+
+	const availableWidth = process.stdout.columns < 80 ? 80 : process.stdout.columns;
+	const fullWidth = Object.values(columnWidths).reduce((a, b) => a + b);
+
+	// If there is no reason to wrap the text, we won't align the last column to the right
+	if (availableWidth > fullWidth + MARGIN_WIDTHS) {
+		return columnWidths[3];
+	}
+
+	return availableWidth - (fullWidth - columnWidths[3] + MARGIN_WIDTHS);
+}
+
+/**
+ * @param {import('stylelint').StylelintWarning[]} messages
+ * @param {string} source
+ * @return {string}
+ */
+function formatter(messages, source) {
+	if (!messages.length) return '';
+
+	const orderedMessages = _.sortBy(
+		messages,
+		// eslint-disable-next-line no-confusing-arrow
+		(m) => (m.line ? 2 : 1), // positionless first
+		(m) => m.line,
+		(m) => m.column,
+	);
+
+	/**
+	 * Create a list of column widths, needed to calculate
+	 * the size of the message column and if needed wrap it.
+	 * @type {{[k: string]: number}}
+	 */
+	const columnWidths = { 0: 1, 1: 1, 2: 1, 3: 1, 4: 1 };
+
+	/**
+	 * @param {[string, string, string, string, string]} columns
+	 * @return {[string, string, string, string, string]}
+	 */
+	function calculateWidths(columns) {
+		for (const [key, value] of Object.entries(columns)) {
+			const normalisedValue = value ? value.toString() : value;
+
+			columnWidths[key] = Math.max(columnWidths[key], stringWidth(normalisedValue));
+		}
+
+		return columns;
+	}
+
+	let output = '\n';
+
+	if (source) {
+		output += `${chalk.underline(logFrom(source))}\n`;
+	}
+
+	const cleanedMessages = orderedMessages.map((message) => {
+		const { line, column } = message;
+		const severity = /** @type {keyof import('log-symbols')} */ (message.severity);
+		/**
+		 * @type {[string, string, string, string, string]}
+		 */
+		const row = [
+			line ? line.toString() : '',
+			column ? column.toString() : '',
+			symbols[severity]
+				? chalk[/** @type {'blue' | 'red' | 'yellow'} */ (levelColors[severity])](symbols[severity])
+				: severity,
+			message.text
+				// Remove all control characters (newline, tab and etc)
+				.replace(/[\u0001-\u001A]+/g, ' ') // eslint-disable-line no-control-regex
+				.replace(/\.$/, '')
+				// eslint-disable-next-line prefer-template
+				.replace(new RegExp(_.escapeRegExp('(' + message.rule + ')') + '$'), ''),
+			chalk.dim(message.rule || ''),
+		];
+
+		calculateWidths(row);
+
+		return row;
+	});
+
+	output += table
+		.table(cleanedMessages, {
+			border: table.getBorderCharacters('void'),
+			columns: {
+				0: { alignment: 'right', width: columnWidths[0], paddingRight: 0 },
+				1: { alignment: 'left', width: columnWidths[1] },
+				2: { alignment: 'center', width: columnWidths[2] },
+				3: {
+					alignment: 'left',
+					width: getMessageWidth(columnWidths),
+					wrapWord: getMessageWidth(columnWidths) > 1,
+				},
+				4: { alignment: 'left', width: columnWidths[4], paddingRight: 0 },
+			},
+			drawHorizontalLine: () => false,
+		})
+		.split('\n')
+		.map(
+			/**
+			 * @param {string} el
+			 * @returns {string}
+			 */
+			(el) => el.replace(/(\d+)\s+(\d+)/, (m, p1, p2) => chalk.dim(`${p1}:${p2}`)),
+		)
+		.join('\n');
+
+	return output;
+}
+
+/**
+ * @type {import('stylelint').Formatter}
+ */
+module.exports = function (results) {
+	let output = invalidOptionsFormatter(results);
+
+	output += deprecationsFormatter(results);
+
+	output = results.reduce((accum, result) => {
+		// Treat parseErrors as warnings
+		if (result.parseErrors) {
+			result.parseErrors.forEach((error) =>
+				result.warnings.push({
+					line: error.line,
+					column: error.column,
+					rule: error.stylelintType,
+					severity: 'error',
+					text: `${error.text} (${error.stylelintType})`,
+				}),
+			);
+		}
+
+		accum += formatter(result.warnings, result.source || '');
+
+		return accum;
+	}, output);
+
+	// Ensure consistent padding
+	output = output.trim();
+
+	if (output !== '') {
+		output = `\n${output}\n\n`;
+	}
+
+	return output;
+};

package/templates/facebook/node_modules/stylelint/lib/formatters/tapFormatter.js

@@ -0,0 +1,39 @@
+'use strict';
+
+/**
+ * @type {import('stylelint').Formatter}
+ */
+const tapFormatter = (results) => {
+	let lines = [`TAP version 13\n1..${results.length}`];
+
+	results.forEach((result, index) => {
+		lines.push(
+			`${result.errored ? 'not ok' : 'ok'} ${index + 1} - ${result.ignored ? 'ignored ' : ''}${
+				result.source
+			}`,
+		);
+
+		if (result.warnings.length > 0) {
+			lines.push('---', 'messages:');
+
+			result.warnings.forEach((warning) => {
+				lines.push(
+					` - message: "${warning.text}"`,
+					`   severity: ${warning.severity}`,
+					`   data:`,
+					`     line: ${warning.line}`,
+					`     column: ${warning.column}`,
+					`     ruleId: ${warning.rule}`,
+				);
+			});
+
+			lines.push('---');
+		}
+	});
+
+	lines.push('');
+
+	return lines.join('\n');
+};
+
+module.exports = tapFormatter;

package/templates/facebook/node_modules/stylelint/lib/formatters/unixFormatter.js

@@ -0,0 +1,26 @@
+'use strict';
+
+const _ = require('lodash');
+
+/**
+ * @type {import('stylelint').Formatter}
+ */
+const unixFormatter = (results) => {
+	const lines = _.flatMap(results, (result) =>
+		result.warnings.map(
+			(warning) =>
+				`${result.source}:${warning.line}:${warning.column}: ` +
+				`${warning.text} [${warning.severity}]\n`,
+		),
+	);
+	const total = lines.length;
+	let output = lines.join('');
+
+	if (total > 0) {
+		output += `\n${total} problem${total !== 1 ? 's' : ''}\n`;
+	}
+
+	return output;
+};
+
+module.exports = unixFormatter;

package/templates/facebook/node_modules/stylelint/lib/formatters/verboseFormatter.js

@@ -0,0 +1,61 @@
+'use strict';
+
+const _ = require('lodash');
+const chalk = require('chalk');
+const stringFormatter = require('./stringFormatter');
+
+/**
+ * @type {import('stylelint').Formatter}
+ */
+module.exports = function (results) {
+	let output = stringFormatter(results);
+
+	if (output === '') {
+		output = '\n';
+	}
+
+	const sourceWord = results.length > 1 ? 'sources' : 'source';
+	const ignoredCount = results.filter((result) => result.ignored).length;
+	const checkedDisplay = ignoredCount
+		? `${results.length - ignoredCount} of ${results.length}`
+		: results.length;
+
+	output += chalk.underline(`${checkedDisplay} ${sourceWord} checked\n`);
+	results.forEach((result) => {
+		let formatting = 'green';
+
+		if (result.errored) {
+			formatting = 'red';
+		} else if (result.warnings.length) {
+			formatting = 'yellow';
+		} else if (result.ignored) {
+			formatting = 'dim';
+		}
+
+		let sourceText = `${result.source}`;
+
+		if (result.ignored) {
+			sourceText += ' (ignored)';
+		}
+
+		output += _.get(chalk, formatting)(` ${sourceText}\n`);
+	});
+
+	const warnings = _.flatten(results.map((r) => r.warnings));
+	const warningsBySeverity = _.groupBy(warnings, 'severity');
+	const problemWord = warnings.length === 1 ? 'problem' : 'problems';
+
+	output += chalk.underline(`\n${warnings.length} ${problemWord} found\n`);
+
+	for (const [severityLevel, warningList] of Object.entries(warningsBySeverity)) {
+		const warningsByRule = _.groupBy(warningList, 'rule');
+
+		output += ` severity level "${severityLevel}": ${warningList.length}\n`;
+
+		for (const [rule, list] of Object.entries(warningsByRule)) {
+			output += chalk.dim(`  ${rule}: ${list.length}\n`);
+		}
+	}
+
+	return `${output}\n`;
+};

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

@@ -0,0 +1,61 @@
+'use strict';
+
+const augmentConfigFull = require('./augmentConfig').augmentConfigFull;
+const configurationError = require('./utils/configurationError');
+const path = require('path');
+
+/** @typedef {import('stylelint').StylelintConfig} StylelintConfig */
+/** @typedef {import('stylelint').CosmiconfigResult} CosmiconfigResult */
+/** @typedef {Promise<CosmiconfigResult | null>} ConfigPromise  */
+
+/**
+ * @param {import('stylelint').StylelintInternalApi} stylelint
+ * @param {string} [searchPath]
+ * @returns {ConfigPromise}
+ */
+module.exports = function (stylelint, searchPath = process.cwd()) {
+	const optionsConfig = stylelint._options.config;
+
+	if (optionsConfig !== undefined) {
+		const cached = /** @type {ConfigPromise} */ (stylelint._specifiedConfigCache.get(
+			optionsConfig,
+		));
+
+		if (cached) return cached;
+
+		// stylelint._fullExplorer (cosmiconfig) is already configured to
+		// run augmentConfigFull; but since we're making up the result here,
+		// we need to manually run the transform
+		const augmentedResult = augmentConfigFull(stylelint, {
+			config: optionsConfig,
+			// Add the extra path part so that we can get the directory without being
+			// confused
+			filepath: path.join(process.cwd(), 'argument-config'),
+		});
+
+		stylelint._specifiedConfigCache.set(optionsConfig, augmentedResult);
+
+		return augmentedResult;
+	}
+
+	const searchForConfig = stylelint._options.configFile
+		? stylelint._fullExplorer.load(stylelint._options.configFile)
+		: stylelint._fullExplorer.search(searchPath);
+
+	return /** @type {ConfigPromise} */ (searchForConfig
+		.then((config) => {
+			// If no config was found, try looking from process.cwd
+			if (!config) return stylelint._fullExplorer.search(process.cwd());
+
+			return config;
+		})
+		.then((config) => {
+			if (!config) {
+				const ending = searchPath ? ` for ${searchPath}` : '';
+
+				throw configurationError(`No configuration provided${ending}`);
+			}
+
+			return config;
+		}));
+};