linter-bundle 5.1.0 → 6.1.0

package/stylelint/plugins/stylelint-15.11.0-stylistic/rules/no-eol-whitespace/index.cjs

@@ -0,0 +1,302 @@
+/* eslint-disable -- We want to keep as much of the original code as possible */
+// @ts-nocheck
+
+const stylelint = require('stylelint');
+const isOnlyWhitespace = require('stylelint/lib/utils/isOnlyWhitespace.cjs');
+const isStandardSyntaxComment = require('stylelint/lib/utils/isStandardSyntaxComment.cjs');
+const optionsMatches = require('stylelint/lib/utils/optionsMatches.cjs');
+const report = require('stylelint/lib/utils/report.cjs');
+const ruleMessages = require('stylelint/lib/utils/ruleMessages.cjs');
+const { isAtRule, isComment, isDeclaration, isRule } = require('stylelint/lib/utils/typeGuards.cjs');
+const validateOptions = require('stylelint/lib/utils/validateOptions.cjs');
+
+const styleSearch = require('../../style-search/index.cjs');
+
+const ruleName = 'plugin/no-eol-whitespace';
+
+const messages = ruleMessages(ruleName, {
+	rejected: 'Unexpected whitespace at end of line'
+});
+
+const meta = {
+	url: 'https://github.com/jens-duttke/linter-bundle/blob/main/stylelint/plugins/stylelint-15.11.0-stylistic/rules/no-eol-whitespace/README.md',
+	fixable: true
+};
+
+const whitespacesToReject = new Set([' ', '\t']);
+
+/**
+ * @param {string} str
+ * @param string_
+ * @returns {string}
+ */
+function fixString (string_) {
+	return string_.replace(/[\t ]+$/, '');
+}
+
+/**
+ * @param {number} lastEOLIndex
+ * @param {string} string
+ * @param {{ ignoreEmptyLines: boolean, isRootFirst: boolean }} options
+ * @returns {number}
+ */
+function findErrorStartIndex (lastEOLIndex, string, { ignoreEmptyLines, isRootFirst }) {
+	const eolWhitespaceIndex = lastEOLIndex - 1;
+
+	// If the character before newline is not whitespace, ignore
+	if (!whitespacesToReject.has(string.charAt(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;
+}
+
+/** @type {import('stylelint').Rule} */
+const rule = (primary, secondaryOptions, context) => (root, result) => {
+	const validOptions = validateOptions(
+		result,
+		ruleName,
+		{
+			actual: primary
+		},
+		{
+			optional: true,
+			actual: secondaryOptions,
+			possible: {
+				ignore: ['empty-lines']
+			}
+		}
+	);
+
+	if (!validOptions) {
+		return;
+	}
+
+	const ignoreEmptyLines = optionsMatches(secondaryOptions, 'ignore', 'empty-lines');
+
+	if (context.fix) {
+		fix(root);
+	}
+
+	const rootString = context.fix ? root.toString() : (root.source?.input.css) || '';
+
+	/**
+	 * @param {number} index
+	 */
+	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 {(index: number) => void} 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);
+				}
+			}
+		);
+	}
+
+	/**
+	 * @param {import('postcss').Root} rootNode
+	 */
+	function fix (rootNode) {
+		let isRootFirst = true;
+
+		rootNode.walk((node) => {
+			fixText(
+				node.raws.before,
+				(fixed) => {
+					node.raws.before = fixed;
+				},
+				isRootFirst
+			);
+			isRootFirst = false;
+
+			if (isAtRule(node)) {
+				fixText(node.raws.afterName, (fixed) => {
+					node.raws.afterName = fixed;
+				});
+
+				const rawsParameters = node.raws.params;
+
+				if (rawsParameters) {
+					fixText(rawsParameters.raw, (fixed) => {
+						rawsParameters.raw = fixed;
+					});
+				}
+				else {
+					fixText(node.params, (fixed) => {
+						node.params = fixed;
+					});
+				}
+			}
+
+			if (isRule(node)) {
+				const rawsSelector = node.raws.selector;
+
+				if (rawsSelector) {
+					fixText(rawsSelector.raw, (fixed) => {
+						rawsSelector.raw = fixed;
+					});
+				}
+				else {
+					fixText(node.selector, (fixed) => {
+						node.selector = fixed;
+					});
+				}
+			}
+
+			if (isAtRule(node) || isRule(node) || isDeclaration(node)) {
+				fixText(node.raws.between, (fixed) => {
+					node.raws.between = fixed;
+				});
+			}
+
+			if (isDeclaration(node)) {
+				const rawsValue = node.raws.value;
+
+				if (rawsValue) {
+					fixText(rawsValue.raw, (fixed) => {
+						rawsValue.raw = fixed;
+					});
+				}
+				else {
+					fixText(node.value, (fixed) => {
+						node.value = fixed;
+					});
+				}
+			}
+
+			if (isComment(node)) {
+				fixText(node.raws.left, (fixed) => {
+					node.raws.left = fixed;
+				});
+
+				if (!isStandardSyntaxComment(node)) {
+					node.raws.right = node.raws.right && fixString(node.raws.right);
+				}
+				else {
+					fixText(node.raws.right, (fixed) => {
+						node.raws.right = fixed;
+					});
+				}
+
+				fixText(node.text, (fixed) => {
+					node.text = fixed;
+				});
+			}
+
+			if (isAtRule(node) || isRule(node)) {
+				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));
+			}
+		}
+	}
+
+	/**
+	 * @param {string | undefined} value
+	 * @param {(text: string) => void} fixFn
+	 * @param {boolean} isRootFirst
+	 */
+	function fixText (value, fixFn, isRootFirst = false) {
+		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;
+rule.meta = meta;
+module.exports = stylelint.createPlugin(ruleName, rule);

package/stylelint/plugins/stylelint-15.11.0-stylistic/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](https://stylelint.io/user-guide/options/#fix) can automatically fix all of the problems reported by this rule.
+
+## Options
+
+### `true`
+
+The following patterns are considered problems:
+
+<!-- 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 problems:
+
+<!-- prettier-ignore -->
+```css
+@import "x.css";
+```
+
+<!-- prettier-ignore -->
+```css
+a {
+  color: pink;
+}
+```

package/stylelint/plugins/stylelint-15.11.0-stylistic/rules/no-extra-semicolons/index.cjs

@@ -0,0 +1,246 @@
+/* eslint-disable -- We want to keep as much of the original code as possible */
+// @ts-nocheck
+
+const stylelint = require('stylelint');
+const isStandardSyntaxAtRule = require('stylelint/lib/utils/isStandardSyntaxAtRule.cjs');
+const isStandardSyntaxRule = require('stylelint/lib/utils/isStandardSyntaxRule.cjs');
+const report = require('stylelint/lib/utils/report.cjs');
+const ruleMessages = require('stylelint/lib/utils/ruleMessages.cjs');
+const { isAtRule } = require('stylelint/lib/utils/typeGuards.cjs');
+const validateOptions = require('stylelint/lib/utils/validateOptions.cjs');
+
+const styleSearch = require('../../style-search/index.cjs');
+
+const ruleName = 'plugin/no-extra-semicolons';
+
+const messages = ruleMessages(ruleName, {
+	rejected: 'Unexpected extra semicolon'
+});
+
+const meta = {
+	url: 'https://github.com/jens-duttke/linter-bundle/blob/main/stylelint/plugins/stylelint-15.11.0-stylistic/rules/no-extra-semicolons/README.md',
+	fixable: true
+};
+
+/**
+ * @param {import('postcss').Node} node
+ * @returns {number}
+ */
+function getOffsetByNode (node) {
+	// @ts-expect-error -- TS2339: Property 'document' does not exist on type 'Document | Container<ChildNode>'
+	if (node.parent?.document) {
+		return 0;
+	}
+
+	const root = node.root();
+
+	if (!root.source) { throw new Error('The root node must have a source'); }
+
+	if (!node.source) { throw new Error('The node must have a source'); }
+
+	if (!node.source.start) { throw new Error('The source must have a start position'); }
+
+	const string = 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;
+}
+
+/** @type {import('stylelint').Rule} */
+const rule = (primary, _secondaryOptions, context) => (root, result) => {
+	const validOptions = validateOptions(result, ruleName, { actual: primary });
+
+	if (!validOptions) {
+		return;
+	}
+
+	if (root.raws.after && root.raws.after.trim().length > 0) {
+		const rawAfterRoot = root.raws.after;
+
+		/** @type {number[]} */
+		const fixSemiIndices = [];
+
+		styleSearch({ source: rawAfterRoot, target: ';' }, (match) => {
+			if (context.fix) {
+				fixSemiIndices.push(match.startIndex);
+
+				return;
+			}
+
+			if (!root.source) { throw new Error('The root node must have a source'); }
+
+			complain(root.source.input.css.length - rawAfterRoot.length + match.startIndex);
+		});
+
+		// fix
+		if (fixSemiIndices.length > 0) {
+			root.raws.after = removeIndices(rawAfterRoot, fixSemiIndices);
+		}
+	}
+
+	root.walk((node) => {
+		if (isAtRule(node) && !isStandardSyntaxAtRule(node)) {
+			return;
+		}
+
+		if (node.type === 'rule' && !isStandardSyntaxRule(node)) {
+			return;
+		}
+
+		if (node.raws.before && node.raws.before.trim().length > 0) {
+			const rawBeforeNode = node.raws.before;
+			const allowedSemi = 0;
+
+			const rawBeforeIndexStart = 0;
+
+			/** @type {number[]} */
+			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 > 0) {
+				node.raws.before = removeIndices(rawBeforeNode, fixSemiIndices);
+			}
+		}
+
+		if (typeof node.raws.after === 'string' && node.raws.after.trim().length > 0) {
+			const rawAfterNode = node.raws.after;
+
+			/**
+			 * 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 (
+				'last' in node &&
+					node.last &&
+					node.last.type === 'atrule' &&
+					!isStandardSyntaxAtRule(node.last)
+			) {
+				return;
+			}
+
+			/** @type {number[]} */
+			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 > 0) {
+				node.raws.after = removeIndices(rawAfterNode, fixSemiIndices);
+			}
+		}
+
+		if (typeof node.raws.ownSemicolon === 'string') {
+			const rawOwnSemicolon = node.raws.ownSemicolon;
+			const allowedSemi = 0;
+
+			/** @type {number[]} */
+			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 > 0) {
+				node.raws.ownSemicolon = removeIndices(rawOwnSemicolon, fixSemiIndices);
+			}
+		}
+	});
+
+	/**
+	 * @param {number} index
+	 */
+	function complain (index) {
+		report({
+			message: messages.rejected,
+			node: root,
+			index,
+			result,
+			ruleName
+		});
+	}
+
+	/**
+	 * @param {string} str
+	 * @param string_
+	 * @param {number[]} indices
+	 * @returns {string}
+	 */
+	function removeIndices (string_, indices) {
+		for (const index of indices.reverse()) {
+			string_ = string_.slice(0, index) + string_.slice(index + 1);
+		}
+
+		return string_;
+	}
+};
+
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;
+module.exports = stylelint.createPlugin(ruleName, rule);

package/stylelint/plugins/stylelint-15.11.0-stylistic/rules/no-missing-end-of-source-newline/README.md

@@ -0,0 +1,34 @@
+# no-missing-end-of-source-newline
+
+Disallow missing end-of-source newlines.
+
+<!-- prettier-ignore -->
+```css
+    a { color: pink; }
+    \n
+/** ↑
+ * This newline */
+```
+
+Completely empty files are not considered problems.
+
+The [`fix` option](https://stylelint.io/user-guide/options/#fix) can automatically fix all of the problems reported by this rule.
+
+## Options
+
+### `true`
+
+The following patterns are considered problems:
+
+<!-- prettier-ignore -->
+```css
+a { color: pink; }
+```
+
+The following patterns are _not_ considered problems:
+
+<!-- prettier-ignore -->
+```css
+a { color: pink; }
+\n
+```

package/stylelint/plugins/stylelint-15.11.0-stylistic/rules/no-missing-end-of-source-newline/index.cjs

@@ -0,0 +1,62 @@
+/* eslint-disable -- We want to keep as much of the original code as possible */
+// @ts-nocheck
+
+const stylelint = require('stylelint');
+const report = require('stylelint/lib/utils/report.cjs');
+const ruleMessages = require('stylelint/lib/utils/ruleMessages.cjs');
+const validateOptions = require('stylelint/lib/utils/validateOptions.cjs');
+
+const ruleName = 'plugin/no-missing-end-of-source-newline';
+
+const messages = ruleMessages(ruleName, {
+	rejected: 'Unexpected missing end-of-source newline'
+});
+
+const meta = {
+	url: 'https://github.com/jens-duttke/linter-bundle/blob/main/stylelint/plugins/stylelint-15.11.0-stylistic/rules/no-missing-end-of-source-newline/README.md',
+	fixable: true
+};
+
+/** @type {import('stylelint').Rule} */
+const rule = (primary, _secondaryOptions, context) => (root, result) => {
+	const validOptions = validateOptions(result, ruleName, { actual: primary });
+
+	if (!validOptions) {
+		return;
+	}
+
+	if (root.source == null) {
+		throw new Error('The root node must have a source property');
+	}
+
+	// @ts-expect-error -- TS2339: Property 'inline' does not exist on type 'Source'.
+	if (root.source.inline || root.source.lang === 'object-literal') {
+		return;
+	}
+
+	const rootString = context.fix ? root.toString() : root.source.input.css;
+
+	if (!rootString.trim() || rootString.endsWith('\n')) {
+		return;
+	}
+
+	// Fix
+	if (context.fix) {
+		root.raws.after = context.newline;
+
+		return;
+	}
+
+	report({
+		message: messages.rejected,
+		node: root,
+		index: rootString.length - 1,
+		result,
+		ruleName
+	});
+};
+
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;
+module.exports = stylelint.createPlugin(ruleName, rule);