create-docusaurus 0.0.0-4378 → 0.0.0-4388

package/templates/facebook/node_modules/stylelint/lib/rules/no-eol-whitespace/index.js

@@ -0,0 +1,260 @@
+// @ts-nocheck
+
+'use strict';
+
+const isOnlyWhitespace = require('../../utils/isOnlyWhitespace');
+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 = 'no-eol-whitespace';
+
+const messages = ruleMessages(ruleName, {
+	rejected: 'Unexpected whitespace at end of line',
+});
+
+const whitespacesToReject = new Set([' ', '\t']);
+
+function fixString(str) {
+	return str.replace(/[ \t]+$/, '');
+}
+
+function findErrorStartIndex(
+	lastEOLIndex,
+	string,
+	{ ignoreEmptyLines, isRootFirst } = {
+		ignoreEmptyLines: false,
+		isRootFirst: false,
+	},
+) {
+	const eolWhitespaceIndex = lastEOLIndex - 1;
+
+	// If the character before newline is not whitespace, ignore
+	if (!whitespacesToReject.has(string[eolWhitespaceIndex])) {
+		return -1;
+	}
+
+	if (ignoreEmptyLines) {
+		// If there is only whitespace between the previous newline and
+		// this newline, ignore
+		const beforeNewlineIndex = string.lastIndexOf('\n', eolWhitespaceIndex);
+
+		if (beforeNewlineIndex >= 0 || isRootFirst) {
+			const line = string.substring(beforeNewlineIndex, eolWhitespaceIndex);
+
+			if (isOnlyWhitespace(line)) {
+				return -1;
+			}
+		}
+	}
+
+	return eolWhitespaceIndex;
+}
+
+function rule(on, options, context) {
+	return (root, result) => {
+		const validOptions = validateOptions(
+			result,
+			ruleName,
+			{
+				actual: on,
+			},
+			{
+				optional: true,
+				actual: options,
+				possible: {
+					ignore: ['empty-lines'],
+				},
+			},
+		);
+
+		if (!validOptions) {
+			return;
+		}
+
+		const ignoreEmptyLines = optionsMatches(options, 'ignore', 'empty-lines');
+
+		if (context.fix) {
+			fix(root);
+		}
+
+		const rootString = context.fix ? root.toString() : root.source.input.css;
+		const reportFromIndex = (index) => {
+			report({
+				message: messages.rejected,
+				node: root,
+				index,
+				result,
+				ruleName,
+			});
+		};
+
+		eachEolWhitespace(rootString, reportFromIndex, true);
+
+		const errorIndex = findErrorStartIndex(rootString.length, rootString, {
+			ignoreEmptyLines,
+			isRootFirst: true,
+		});
+
+		if (errorIndex > -1) {
+			reportFromIndex(errorIndex);
+		}
+
+		/**
+		 * Iterate each whitespace at the end of each line of the given string.
+		 * @param {string} string the source code string
+		 * @param {Function} callback callback the whitespace index at the end of each line.
+		 * @param {boolean} isRootFirst set `true` if the given string is the first token of the root.
+		 * @returns {void}
+		 */
+		function eachEolWhitespace(string, callback, isRootFirst) {
+			styleSearch(
+				{
+					source: string,
+					target: ['\n', '\r'],
+					comments: 'check',
+				},
+				(match) => {
+					const index = findErrorStartIndex(match.startIndex, string, {
+						ignoreEmptyLines,
+						isRootFirst,
+					});
+
+					if (index > -1) {
+						callback(index);
+					}
+				},
+			);
+		}
+
+		function fix(rootNode) {
+			let isRootFirst = true;
+
+			rootNode.walk((node) => {
+				fixText(
+					node.raws.before,
+					(fixed) => {
+						node.raws.before = fixed;
+					},
+					isRootFirst,
+				);
+				isRootFirst = false;
+
+				// AtRule
+				fixText(node.raws.afterName, (fixed) => {
+					node.raws.afterName = fixed;
+				});
+
+				if (node.raws.params) {
+					fixText(node.raws.params.raw, (fixed) => {
+						node.raws.params.raw = fixed;
+					});
+				} else {
+					fixText(node.params, (fixed) => {
+						node.params = fixed;
+					});
+				}
+
+				// Rule
+				if (node.raws.selector) {
+					fixText(node.raws.selector.raw, (fixed) => {
+						node.raws.selector.raw = fixed;
+					});
+				} else {
+					fixText(node.selector, (fixed) => {
+						node.selector = fixed;
+					});
+				}
+
+				// AtRule or Rule or Decl
+				fixText(node.raws.between, (fixed) => {
+					node.raws.between = fixed;
+				});
+
+				// Decl
+				if (node.raws.value) {
+					fixText(node.raws.value.raw, (fixed) => {
+						node.raws.value.raw = fixed;
+					});
+				} else {
+					fixText(node.value, (fixed) => {
+						node.value = fixed;
+					});
+				}
+
+				// Comment
+				fixText(node.raws.left, (fixed) => {
+					node.raws.left = fixed;
+				});
+
+				if (node.raws.inline) {
+					node.raws.right = fixString(node.raws.right);
+				} else {
+					fixText(node.raws.right, (fixed) => {
+						node.raws.right = fixed;
+					});
+				}
+
+				fixText(node.text, (fixed) => {
+					node.text = fixed;
+				});
+
+				fixText(node.raws.after, (fixed) => {
+					node.raws.after = fixed;
+				});
+			});
+
+			fixText(
+				rootNode.raws.after,
+				(fixed) => {
+					rootNode.raws.after = fixed;
+				},
+				isRootFirst,
+			);
+
+			if (typeof rootNode.raws.after === 'string') {
+				const lastEOL = Math.max(
+					rootNode.raws.after.lastIndexOf('\n'),
+					rootNode.raws.after.lastIndexOf('\r'),
+				);
+
+				if (lastEOL !== rootNode.raws.after.length - 1) {
+					rootNode.raws.after =
+						rootNode.raws.after.slice(0, lastEOL + 1) +
+						fixString(rootNode.raws.after.slice(lastEOL + 1));
+				}
+			}
+		}
+
+		function fixText(value, fixFn, isRootFirst) {
+			if (!value) {
+				return;
+			}
+
+			let fixed = '';
+			let lastIndex = 0;
+
+			eachEolWhitespace(
+				value,
+				(index) => {
+					const newlineIndex = index + 1;
+
+					fixed += fixString(value.slice(lastIndex, newlineIndex));
+					lastIndex = newlineIndex;
+				},
+				isRootFirst,
+			);
+
+			if (lastIndex) {
+				fixed += value.slice(lastIndex);
+				fixFn(fixed);
+			}
+		}
+	};
+}
+
+rule.ruleName = ruleName;
+rule.messages = messages;
+module.exports = rule;

package/templates/facebook/node_modules/stylelint/lib/rules/no-extra-semicolons/README.md

@@ -0,0 +1,78 @@
+# no-extra-semicolons
+
+Disallow extra semicolons.
+
+<!-- prettier-ignore -->
+```css
+a { color: pink;; }
+/**             ↑
+ *  This semicolons */
+```
+
+This rule ignores semicolons after Less mixins.
+
+The [`fix` option](../../../docs/user-guide/usage/options.md#fix) can automatically fix all of the problems reported by this rule.
+
+## Options
+
+### `true`
+
+The following patterns are considered violations:
+
+<!-- prettier-ignore -->
+```css
+@import "x.css";;
+```
+
+<!-- prettier-ignore -->
+```css
+@import "x.css";
+;
+```
+
+<!-- prettier-ignore -->
+```css
+a {
+  color: pink;;
+}
+```
+
+<!-- prettier-ignore -->
+```css
+a {
+  ;color: pink;
+}
+```
+
+<!-- prettier-ignore -->
+```css
+a {
+  color: pink;
+  ;
+}
+```
+
+<!-- prettier-ignore -->
+```css
+a {
+  color: red;
+}
+;
+b {
+  color: white;
+}
+```
+
+The following patterns are _not_ considered violations:
+
+<!-- prettier-ignore -->
+```css
+@import "x.css";
+```
+
+<!-- prettier-ignore -->
+```css
+a {
+  color: pink;
+}
+```

package/templates/facebook/node_modules/stylelint/lib/rules/no-extra-semicolons/index.js

@@ -0,0 +1,243 @@
+// @ts-nocheck
+
+'use strict';
+
+const isCustomPropertySet = require('../../utils/isCustomPropertySet');
+const isStandardSyntaxAtRule = require('../../utils/isStandardSyntaxAtRule');
+const isStandardSyntaxRule = require('../../utils/isStandardSyntaxRule');
+const report = require('../../utils/report');
+const ruleMessages = require('../../utils/ruleMessages');
+const styleSearch = require('style-search');
+const validateOptions = require('../../utils/validateOptions');
+
+const ruleName = 'no-extra-semicolons';
+
+const messages = ruleMessages(ruleName, {
+	rejected: 'Unexpected extra semicolon',
+});
+
+function getOffsetByNode(node) {
+	if (node.parent && node.parent.document) {
+		return 0;
+	}
+
+	const string = node.root().source.input.css;
+	const nodeColumn = node.source.start.column;
+	const nodeLine = node.source.start.line;
+	let line = 1;
+	let column = 1;
+	let index = 0;
+
+	for (let i = 0; i < string.length; i++) {
+		if (column === nodeColumn && nodeLine === line) {
+			index = i;
+			break;
+		}
+
+		if (string[i] === '\n') {
+			column = 1;
+			line += 1;
+		} else {
+			column += 1;
+		}
+	}
+
+	return index;
+}
+
+function rule(actual, options, context) {
+	return (root, result) => {
+		const validOptions = validateOptions(result, ruleName, { actual });
+
+		if (!validOptions) {
+			return;
+		}
+
+		const rawAfterRoot = root.raws.after;
+
+		if (rawAfterRoot && rawAfterRoot.trim().length !== 0) {
+			const fixSemiIndices = [];
+
+			styleSearch({ source: rawAfterRoot, target: ';' }, (match) => {
+				if (context.fix) {
+					fixSemiIndices.push(match.startIndex);
+
+					return;
+				}
+
+				complain(root.source.input.css.length - rawAfterRoot.length + match.startIndex);
+			});
+
+			// fix
+			if (fixSemiIndices.length) {
+				root.raws.after = removeIndices(rawAfterRoot, fixSemiIndices);
+			}
+		}
+
+		root.walk((node) => {
+			if (node.type === 'atrule' && !isStandardSyntaxAtRule(node)) {
+				return;
+			}
+
+			if (node.type === 'rule' && !isCustomPropertySet(node) && !isStandardSyntaxRule(node)) {
+				return;
+			}
+
+			let rawBeforeNode = node.raws.before;
+
+			if (rawBeforeNode && rawBeforeNode.trim().length !== 0) {
+				let allowedSemi = 0;
+
+				const next = node.next();
+
+				// Ignore semicolon before comment if next node is custom properties sets or comment
+				if (
+					node.type === 'comment' &&
+					next &&
+					isCustomPropertySet(next) &&
+					node.parent.index(next) > 0
+				) {
+					allowedSemi = 1;
+				}
+
+				const prev = node.prev();
+
+				let rawBeforeIndexStart = 0;
+
+				// Adding previous node string to custom properties set if previous node is comment
+				if (
+					isCustomPropertySet(node) &&
+					node.parent.index(node) > 0 &&
+					prev &&
+					prev.type === 'comment'
+				) {
+					rawBeforeNode = prev.toString() + rawBeforeNode;
+					allowedSemi = 0;
+					rawBeforeIndexStart = prev.toString().length;
+				}
+
+				const fixSemiIndices = [];
+
+				styleSearch({ source: rawBeforeNode, target: ';' }, (match, count) => {
+					if (count === allowedSemi) {
+						return;
+					}
+
+					if (context.fix) {
+						fixSemiIndices.push(match.startIndex - rawBeforeIndexStart);
+
+						return;
+					}
+
+					complain(getOffsetByNode(node) - rawBeforeNode.length + match.startIndex);
+				});
+
+				// fix
+				if (fixSemiIndices.length) {
+					node.raws.before = removeIndices(node.raws.before, fixSemiIndices);
+				}
+			}
+
+			const rawAfterNode = node.raws.after;
+
+			if (rawAfterNode && rawAfterNode.trim().length !== 0) {
+				/**
+				 * If the last child is a Less mixin followed by more than one semicolon,
+				 * node.raws.after will be populated with that semicolon.
+				 * Since we ignore Less mixins, exit here
+				 */
+				if (
+					node.last &&
+					node.last.type === 'atrule' &&
+					!isCustomPropertySet(node.last) &&
+					!isStandardSyntaxAtRule(node.last)
+				) {
+					return;
+				}
+
+				const fixSemiIndices = [];
+
+				styleSearch({ source: rawAfterNode, target: ';' }, (match) => {
+					if (context.fix) {
+						fixSemiIndices.push(match.startIndex);
+
+						return;
+					}
+
+					const index =
+						getOffsetByNode(node) +
+						node.toString().length -
+						1 -
+						rawAfterNode.length +
+						match.startIndex;
+
+					complain(index);
+				});
+
+				// fix
+				if (fixSemiIndices.length) {
+					node.raws.after = removeIndices(rawAfterNode, fixSemiIndices);
+				}
+			}
+
+			const rawOwnSemicolon = node.raws.ownSemicolon;
+
+			if (rawOwnSemicolon) {
+				let allowedSemi = 0;
+
+				if (isCustomPropertySet(node)) {
+					allowedSemi = 1;
+				}
+
+				const fixSemiIndices = [];
+
+				styleSearch({ source: rawOwnSemicolon, target: ';' }, (match, count) => {
+					if (count === allowedSemi) {
+						return;
+					}
+
+					if (context.fix) {
+						fixSemiIndices.push(match.startIndex);
+
+						return;
+					}
+
+					const index =
+						getOffsetByNode(node) +
+						node.toString().length -
+						rawOwnSemicolon.length +
+						match.startIndex;
+
+					complain(index);
+				});
+
+				// fix
+				if (fixSemiIndices.length) {
+					node.raws.ownSemicolon = removeIndices(rawOwnSemicolon, fixSemiIndices);
+				}
+			}
+		});
+
+		function complain(index) {
+			report({
+				message: messages.rejected,
+				node: root,
+				index,
+				result,
+				ruleName,
+			});
+		}
+
+		function removeIndices(str, indices) {
+			indices.reverse().forEach((index) => {
+				str = str.slice(0, index) + str.slice(index + 1);
+			});
+
+			return str;
+		}
+	};
+}
+
+rule.ruleName = ruleName;
+rule.messages = messages;
+module.exports = rule;

package/templates/facebook/node_modules/stylelint/lib/rules/no-invalid-double-slash-comments/README.md

@@ -0,0 +1,54 @@
+# no-invalid-double-slash-comments
+
+Disallow double-slash comments (`//...`) which are not supported by CSS and [could lead to unexpected results](https://stackoverflow.com/a/20192639/130652).
+
+<!-- prettier-ignore -->
+```css
+a {
+  //color: pink;
+}
+/** ↑
+ *  This comment */
+```
+
+If you are using a preprocessor that allows `//` single-line comments (e.g. Sass, Less, Stylus), this rule will not complain about those. They are compiled into standard CSS comments by your preprocessor, so stylelint will consider them valid. This rule only complains about the lesser-known method of using `//` to "comment out" a single-line of code in regular CSS. (If you didn't know this was possible, have a look at ["Single Line Comments (//) in CSS"](http://www.xanthir.com/b4U10)).
+
+## Options
+
+### `true`
+
+The following patterns are considered violations:
+
+<!-- prettier-ignore -->
+```css
+a {
+  //color: pink;
+}
+```
+
+<!-- prettier-ignore -->
+```css
+//a { color: pink; }
+```
+
+<!-- prettier-ignore -->
+```css
+// Comment {}
+a {
+  color: pink;
+}
+```
+
+The following patterns are _not_ considered violations:
+
+<!-- prettier-ignore -->
+```css
+a {
+  /* color: pink; */
+}
+```
+
+<!-- prettier-ignore -->
+```css
+/* a { color: pink;  } */
+```

package/templates/facebook/node_modules/stylelint/lib/rules/no-invalid-double-slash-comments/index.js

@@ -0,0 +1,51 @@
+// @ts-nocheck
+
+'use strict';
+
+const report = require('../../utils/report');
+const ruleMessages = require('../../utils/ruleMessages');
+const validateOptions = require('../../utils/validateOptions');
+
+const ruleName = 'no-invalid-double-slash-comments';
+
+const messages = ruleMessages(ruleName, {
+	rejected: 'Unexpected double-slash CSS comment',
+});
+
+function rule(actual) {
+	return (root, result) => {
+		const validOptions = validateOptions(result, ruleName, { actual });
+
+		if (!validOptions) {
+			return;
+		}
+
+		root.walkDecls((decl) => {
+			if (decl.prop.startsWith('//')) {
+				report({
+					message: messages.rejected,
+					node: decl,
+					result,
+					ruleName,
+				});
+			}
+		});
+
+		root.walkRules((ruleNode) => {
+			ruleNode.selectors.forEach((selector) => {
+				if (selector.startsWith('//')) {
+					report({
+						message: messages.rejected,
+						node: ruleNode,
+						result,
+						ruleName,
+					});
+				}
+			});
+		});
+	};
+}
+
+rule.ruleName = ruleName;
+rule.messages = messages;
+module.exports = rule;