create-docusaurus 0.0.0-4377 → 0.0.0-4384

package/templates/facebook/node_modules/stylelint/lib/rules/length-zero-no-unit/index.js

@@ -0,0 +1,163 @@
+// @ts-nocheck
+
+'use strict';
+
+const valueParser = require('postcss-value-parser');
+
+const atRuleParamIndex = require('../../utils/atRuleParamIndex');
+const declarationValueIndex = require('../../utils/declarationValueIndex');
+const getAtRuleParams = require('../../utils/getAtRuleParams');
+const getDeclarationValue = require('../../utils/getDeclarationValue');
+const isCustomProperty = require('../../utils/isCustomProperty');
+const isMathFunction = require('../../utils/isMathFunction');
+const isStandardSyntaxAtRule = require('../../utils/isStandardSyntaxAtRule');
+const keywordSets = require('../../reference/keywordSets');
+const optionsMatches = require('../../utils/optionsMatches');
+const report = require('../../utils/report');
+const ruleMessages = require('../../utils/ruleMessages');
+const setAtRuleParams = require('../../utils/setAtRuleParams');
+const setDeclarationValue = require('../../utils/setDeclarationValue');
+const validateOptions = require('../../utils/validateOptions');
+
+const ruleName = 'length-zero-no-unit';
+
+const messages = ruleMessages(ruleName, {
+	rejected: 'Unexpected unit',
+});
+
+function rule(primary, secondary, context) {
+	return (root, result) => {
+		const validOptions = validateOptions(
+			result,
+			ruleName,
+			{
+				actual: primary,
+			},
+			{
+				actual: secondary,
+				possible: {
+					ignore: ['custom-properties'],
+				},
+				optional: true,
+			},
+		);
+
+		if (!validOptions) return;
+
+		let needsFix;
+
+		function check(node, nodeIndex, valueNode) {
+			const { value, sourceIndex } = valueNode;
+
+			if (isMathFunction(valueNode)) return false;
+
+			if (!isWord(valueNode)) return;
+
+			const numberUnit = valueParser.unit(value);
+
+			if (numberUnit === false) return;
+
+			const { number, unit } = numberUnit;
+
+			if (unit === '') return;
+
+			if (!isLength(unit)) return;
+
+			if (isFraction(unit)) return;
+
+			if (!isZero(number)) return;
+
+			if (context.fix) {
+				valueNode.value = number;
+				needsFix = true;
+
+				return;
+			}
+
+			report({
+				index: nodeIndex + sourceIndex + number.length,
+				message: messages.rejected,
+				node,
+				result,
+				ruleName,
+			});
+		}
+
+		function checkAtRule(node) {
+			if (!isStandardSyntaxAtRule(node)) return;
+
+			needsFix = false;
+
+			const index = atRuleParamIndex(node);
+			const parsedValue = valueParser(getAtRuleParams(node));
+
+			parsedValue.walk((valueNode) => {
+				return check(node, index, valueNode);
+			});
+
+			if (needsFix) {
+				setAtRuleParams(node, parsedValue.toString());
+			}
+		}
+
+		function checkDecl(node) {
+			needsFix = false;
+
+			const { prop } = node;
+
+			if (isLineHeight(prop)) return;
+
+			if (optionsMatches(secondary, 'ignore', 'custom-properties') && isCustomProperty(prop))
+				return;
+
+			const index = declarationValueIndex(node);
+			const parsedValue = valueParser(getDeclarationValue(node));
+
+			parsedValue.walk((valueNode, valueNodeIndex, valueNodes) => {
+				if (isLineHeightValue(node, valueNodes, valueNodeIndex)) return;
+
+				return check(node, index, valueNode);
+			});
+
+			if (needsFix) {
+				setDeclarationValue(node, parsedValue.toString());
+			}
+		}
+
+		root.walkAtRules(checkAtRule);
+		root.walkDecls(checkDecl);
+	};
+}
+
+function isLineHeightValue({ prop }, nodes, index) {
+	return (
+		prop.toLowerCase() === 'font' &&
+		index > 0 &&
+		nodes[index - 1].type === 'div' &&
+		nodes[index - 1].value === '/'
+	);
+}
+
+function isLineHeight(prop) {
+	return prop.toLowerCase() === 'line-height';
+}
+
+function isWord({ type }) {
+	return type === 'word';
+}
+
+function isLength(unit) {
+	return keywordSets.lengthUnits.has(unit.toLowerCase());
+}
+
+function isFraction(unit) {
+	return unit.toLowerCase() === 'fr';
+}
+
+function isZero(number) {
+	return Number.parseFloat(number) === 0;
+}
+
+rule.ruleName = ruleName;
+rule.messages = messages;
+module.exports = rule;

package/templates/facebook/node_modules/stylelint/lib/rules/linebreaks/README.md

@@ -0,0 +1,21 @@
+# linebreaks
+
+Specify unix or windows linebreaks.
+
+The [`fix` option](../../../docs/user-guide/usage/options.md#fix) can automatically fix all of the problems reported by this rule.
+
+## Options
+
+`string`: `"unix"|"windows"`
+
+### `"unix"`
+
+Linebreaks _must always_ be LF (`\n`).
+
+Lines with CRLF linebreaks are considered violations.
+
+### `"windows"`
+
+Linebreaks _must always_ be CRLF (`\r\n`).
+
+Lines with LF linebreaks are considered violations.

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

@@ -0,0 +1,102 @@
+// @ts-nocheck
+
+'use strict';
+
+const _ = require('lodash');
+const postcss = require('postcss');
+const report = require('../../utils/report');
+const ruleMessages = require('../../utils/ruleMessages');
+const validateOptions = require('../../utils/validateOptions');
+
+const ruleName = 'linebreaks';
+
+const messages = ruleMessages(ruleName, {
+	expected: (linebreak) => `Expected linebreak to be ${linebreak}`,
+});
+
+function rule(actual, secondary, context) {
+	return (root, result) => {
+		const validOptions = validateOptions(result, ruleName, {
+			actual,
+			possible: ['unix', 'windows'],
+		});
+
+		if (!validOptions) {
+			return;
+		}
+
+		const shouldHaveCR = actual === 'windows';
+
+		if (context.fix) {
+			const propertiesToUpdate = ['selector', 'raws.before', 'raws.after', 'value', 'text'];
+
+			root.walk((node) => {
+				propertiesToUpdate.forEach((property) => {
+					const fixedData = fixData(_.get(node, property));
+
+					_.set(node, property, fixedData);
+				});
+			});
+
+			root.raws.after = fixData(root.raws.after);
+		} else {
+			const lines = root.source.input.css.split('\n');
+
+			for (let i = 0; i < lines.length; i++) {
+				let line = lines[i];
+
+				if (i < lines.length - 1 && !line.includes('\r')) {
+					line += '\n';
+				}
+
+				if (hasError(line)) {
+					const lineNum = i + 1;
+					const colNum = line.length;
+
+					reportNewlineError(lineNum, colNum);
+				}
+			}
+		}
+
+		function hasError(dataToCheck) {
+			const hasNewlineToVerify = /[\r\n]/.test(dataToCheck);
+			const hasCR = hasNewlineToVerify ? /\r/.test(dataToCheck) : false;
+
+			return hasNewlineToVerify && hasCR !== shouldHaveCR;
+		}
+
+		function fixData(data) {
+			if (data) {
+				let res = data.replace(/\r/g, '');
+
+				if (shouldHaveCR) {
+					res = res.replace(/\n/g, '\r\n');
+				}
+
+				return res;
+			}
+
+			return data;
+		}
+
+		function reportNewlineError(line, column) {
+			// Creating a node manually helps us to point to empty lines.
+			const node = postcss.rule({
+				source: {
+					start: { line, column },
+				},
+			});
+
+			report({
+				message: messages.expected(actual),
+				node,
+				result,
+				ruleName,
+			});
+		}
+	};
+}
+
+rule.ruleName = ruleName;
+rule.messages = messages;
+module.exports = rule;

package/templates/facebook/node_modules/stylelint/lib/rules/max-empty-lines/README.md

@@ -0,0 +1,116 @@
+# max-empty-lines
+
+Limit the number of adjacent empty lines.
+
+<!-- prettier-ignore -->
+```css
+a {}
+     /* ← */
+     /* ← */
+a {} /* ↑ */
+/**     ↑
+ * These lines */
+```
+
+The [`fix` option](../../../docs/user-guide/usage/options.md#fix) can automatically fix all of the problems reported by this rule.
+
+## Options
+
+`int`: Maximum number of adjacent empty lines allowed.
+
+For example, with `2`:
+
+The following patterns are considered violations:
+
+<!-- prettier-ignore -->
+```css
+a {}
+
+
+
+b {}
+```
+
+Comment strings are also checked -- so the following is a violation:
+
+<!-- prettier-ignore -->
+```css
+/*
+ Call me Ishmael.
+
+
+
+ Some years ago--never mind how long precisely-—...
+ */
+```
+
+The following patterns are _not_ considered violations:
+
+<!-- prettier-ignore -->
+```css
+a {}
+b {}
+```
+
+<!-- prettier-ignore -->
+```css
+a {}
+
+b {}
+```
+
+<!-- prettier-ignore -->
+```css
+a {}
+
+
+b {}
+```
+
+## Optional secondary options
+
+### `ignore: ["comments"]`
+
+Only enforce the adjacent empty lines limit for lines that are not comments.
+
+For example, with `2` adjacent empty lines:
+
+The following patterns are considered violations:
+
+<!-- prettier-ignore -->
+```css
+/* horse */
+a {}
+
+
+
+b {}
+```
+
+The following patterns are _not_ considered violations:
+
+<!-- prettier-ignore -->
+```css
+/*
+ Call me Ishmael.
+
+
+
+ Some years ago -- never mind how long precisely -- ...
+ */
+```
+
+<!-- prettier-ignore -->
+```css
+a {
+    /*
+     Comment
+
+
+
+
+     inside the declaration with a lot of empty lines...
+    */
+     color: pink;
+}
+```

package/templates/facebook/node_modules/stylelint/lib/rules/max-empty-lines/index.js

@@ -0,0 +1,209 @@
+// @ts-nocheck
+
+'use strict';
+
+const _ = require('lodash');
+const optionsMatches = require('../../utils/optionsMatches');
+const report = require('../../utils/report');
+const ruleMessages = require('../../utils/ruleMessages');
+const styleSearch = require('style-search');
+const validateOptions = require('../../utils/validateOptions');
+
+const ruleName = 'max-empty-lines';
+
+const messages = ruleMessages(ruleName, {
+	expected: (max) => `Expected no more than ${max} empty ${max === 1 ? 'line' : 'lines'}`,
+});
+
+function rule(max, options, context) {
+	let emptyLines = 0;
+	let lastIndex = -1;
+
+	return (root, result) => {
+		const validOptions = validateOptions(
+			result,
+			ruleName,
+			{
+				actual: max,
+				possible: _.isNumber,
+			},
+			{
+				actual: options,
+				possible: {
+					ignore: ['comments'],
+				},
+				optional: true,
+			},
+		);
+
+		if (!validOptions) {
+			return;
+		}
+
+		const ignoreComments = optionsMatches(options, 'ignore', 'comments');
+		const getChars = _.partial(replaceEmptyLines, max);
+
+		/**
+		 * 1. walk nodes & replace enterchar
+		 * 2. deal with special case.
+		 */
+		if (context.fix) {
+			root.walk((node) => {
+				if (node.type === 'comment') {
+					// for inline comments
+					if (node.raws.inline) {
+						node.raws.before = getChars(node.raws.before);
+					}
+
+					if (!ignoreComments) {
+						node.raws.left = getChars(node.raws.left);
+						node.raws.right = getChars(node.raws.right);
+					}
+				} else {
+					if (node.raws.before) {
+						node.raws.before = getChars(node.raws.before);
+					}
+
+					if (node.raws.after) {
+						node.raws.after = getChars(node.raws.after);
+					}
+				}
+			});
+
+			// first node
+			const firstNodeRawsBefore = _.get(root, 'first.raws.before');
+			// root raws
+			const rootRawsAfter = _.get(root, 'raws.after');
+
+			// not document node
+			if (_.get(root, 'document.constructor.name') !== 'Document') {
+				if (firstNodeRawsBefore) {
+					_.set(root, 'first.raws.before', getChars(firstNodeRawsBefore, true));
+				}
+
+				if (rootRawsAfter) {
+					// when max setted 0, should be treated as 1 in this situation.
+					_.set(root, 'raws.after', replaceEmptyLines(max === 0 ? 1 : max, rootRawsAfter, true));
+				}
+			} else if (rootRawsAfter) {
+				// `css in js` or `html`
+				_.set(root, 'raws.after', replaceEmptyLines(max === 0 ? 1 : max, rootRawsAfter));
+			}
+
+			return;
+		}
+
+		emptyLines = 0;
+		lastIndex = -1;
+		const rootString = root.toString();
+
+		styleSearch(
+			{
+				source: rootString,
+				target: /\r\n/.test(rootString) ? '\r\n' : '\n',
+				comments: ignoreComments ? 'skip' : 'check',
+			},
+			(match) => {
+				checkMatch(rootString, match.startIndex, match.endIndex, root);
+			},
+		);
+
+		function checkMatch(source, matchStartIndex, matchEndIndex, node) {
+			const eof = matchEndIndex === source.length;
+			let violation = false;
+
+			// Additional check for beginning of file
+			if (!matchStartIndex || lastIndex === matchStartIndex) {
+				emptyLines++;
+			} else {
+				emptyLines = 0;
+			}
+
+			lastIndex = matchEndIndex;
+
+			if (emptyLines > max) violation = true;
+
+			if (!eof && !violation) return;
+
+			if (violation) {
+				report({
+					message: messages.expected(max),
+					node,
+					index: matchStartIndex,
+					result,
+					ruleName,
+				});
+			}
+
+			// Additional check for end of file
+			if (eof && max) {
+				emptyLines++;
+
+				if (emptyLines > max && isEofNode(result.root, node)) {
+					report({
+						message: messages.expected(max),
+						node,
+						index: matchEndIndex,
+						result,
+						ruleName,
+					});
+				}
+			}
+		}
+
+		function replaceEmptyLines(maxLines, str, isSpecialCase = false) {
+			const repeatTimes = isSpecialCase ? maxLines : maxLines + 1;
+
+			if (repeatTimes === 0 || typeof str !== 'string') {
+				return '';
+			}
+
+			const emptyLFLines = '\n'.repeat(repeatTimes);
+			const emptyCRLFLines = '\r\n'.repeat(repeatTimes);
+
+			return /(\r\n)+/g.test(str)
+				? str.replace(/(\r\n)+/g, ($1) => {
+						if ($1.length / 2 > repeatTimes) {
+							return emptyCRLFLines;
+						}
+
+						return $1;
+				  })
+				: str.replace(/(\n)+/g, ($1) => {
+						if ($1.length > repeatTimes) {
+							return emptyLFLines;
+						}
+
+						return $1;
+				  });
+		}
+	};
+}
+
+/**
+ * Checks whether the given node is the last node of file.
+ * @param {Document|null} document the document node with `postcss-html` and `postcss-jsx`.
+ * @param {Root} root the root node of css
+ */
+function isEofNode(document, root) {
+	if (!document || document.constructor.name !== 'Document') {
+		return true;
+	}
+
+	// In the `postcss-html` and `postcss-jsx` syntax, checks that there is text after the given node.
+	let after;
+
+	if (root === document.last) {
+		after = _.get(document, 'raws.afterEnd');
+	} else {
+		const rootIndex = document.index(root);
+
+		after = _.get(document.nodes[rootIndex + 1], 'raws.beforeStart');
+	}
+
+	return !String(after).trim();
+}
+
+rule.ruleName = ruleName;
+rule.messages = messages;
+module.exports = rule;