linter-bundle 5.1.0 → 6.1.0

package/stylelint/plugins/stylelint-15.11.0-stylistic/rules/media-query-list-comma-space-before/README.md

@@ -0,0 +1,136 @@
+# media-query-list-comma-space-before
+
+Require a single space or disallow whitespace before the commas of media query lists.
+
+<!-- prettier-ignore -->
+```css
+@media screen and (color) ,projection and (color) {}
+/**                       ↑
+ * The space before this comma */
+```
+
+The [`fix` option](https://stylelint.io/user-guide/options/#fix) can automatically fix all of the problems reported by this rule.
+
+## Options
+
+`string`: `"always"|"never"|"always-single-line"|"never-single-line"`
+
+### `"always"`
+
+There _must always_ be a single space before the commas.
+
+The following patterns are considered problems:
+
+<!-- prettier-ignore -->
+```css
+@media screen and (color),projection and (color) {}
+```
+
+<!-- prettier-ignore -->
+```css
+@media screen and (color)
+,projection and (color) {}
+```
+
+The following patterns are _not_ considered problems:
+
+<!-- prettier-ignore -->
+```css
+@media screen and (color) ,projection and (color) {}
+```
+
+<!-- prettier-ignore -->
+```css
+@media screen and (color) ,
+projection and (color) {}
+```
+
+### `"never"`
+
+There _must never_ be whitespace before the commas.
+
+The following patterns are considered problems:
+
+<!-- prettier-ignore -->
+```css
+@media screen and (color) ,projection and (color) {}
+```
+
+<!-- prettier-ignore -->
+```css
+@media screen and (color)
+, projection and (color) {}
+```
+
+The following patterns are _not_ considered problems:
+
+<!-- prettier-ignore -->
+```css
+@media screen and (color),projection and (color) {}
+```
+
+<!-- prettier-ignore -->
+```css
+@media screen and (color),
+projection and (color) {}
+```
+
+### `"always-single-line"`
+
+There _must always_ be a single space before the commas in single-line media query lists.
+
+The following patterns are considered problems:
+
+<!-- prettier-ignore -->
+```css
+@media screen and (color),projection and (color) {}
+```
+
+The following patterns are _not_ considered problems:
+
+<!-- prettier-ignore -->
+```css
+@media screen and (color) ,projection and (color) {}
+```
+
+<!-- prettier-ignore -->
+```css
+@media screen and (color)
+, projection and (color) {}
+```
+
+<!-- prettier-ignore -->
+```css
+@media screen and (color)
+,projection and (color) {}
+```
+
+### `"never-single-line"`
+
+There _must never_ be whitespace before the commas in single-line media query lists.
+
+The following patterns are considered problems:
+
+<!-- prettier-ignore -->
+```css
+@media screen and (color) , projection and (color) {}
+```
+
+The following patterns are _not_ considered problems:
+
+<!-- prettier-ignore -->
+```css
+@media screen and (color),projection and (color) {}
+```
+
+<!-- prettier-ignore -->
+```css
+@media screen and (color)
+,projection and (color) {}
+```
+
+<!-- prettier-ignore -->
+```css
+@media screen and (color)
+, projection and (color) {}
+```

package/stylelint/plugins/stylelint-15.11.0-stylistic/rules/media-query-list-comma-space-before/index.cjs

@@ -0,0 +1,93 @@
+/* eslint-disable -- We want to keep as much of the original code as possible */
+// @ts-nocheck
+
+const stylelint = require('stylelint');
+const atRuleParamIndex = require('stylelint/lib/utils/atRuleParamIndex.cjs');
+const ruleMessages = require('stylelint/lib/utils/ruleMessages.cjs');
+const validateOptions = require('stylelint/lib/utils/validateOptions.cjs');
+
+const whitespaceChecker = require('../../utils/whitespaceChecker.cjs');
+const mediaQueryListCommaWhitespaceChecker = require('../mediaQueryListCommaWhitespaceChecker.cjs');
+
+const ruleName = 'plugin/media-query-list-comma-space-before';
+
+const messages = ruleMessages(ruleName, {
+	expectedBefore: () => 'Expected single space before ","',
+	rejectedBefore: () => 'Unexpected whitespace before ","',
+	expectedBeforeSingleLine: () => 'Expected single space before "," in a single-line list',
+	rejectedBeforeSingleLine: () => 'Unexpected whitespace before "," in a single-line list'
+});
+
+const meta = {
+	url: 'https://github.com/jens-duttke/linter-bundle/blob/main/stylelint/plugins/stylelint-15.11.0-stylistic/rules/media-query-list-comma-space-before/README.md',
+	fixable: true
+};
+
+/** @type {import('stylelint').Rule} */
+const rule = (primary, _secondaryOptions, context) => {
+	const checker = whitespaceChecker('space', primary, messages);
+
+	return (root, result) => {
+		const validOptions = validateOptions(result, ruleName, {
+			actual: primary,
+			possible: ['always', 'never', 'always-single-line', 'never-single-line']
+		});
+
+		if (!validOptions) {
+			return;
+		}
+
+		/** @type {Map<import('postcss').AtRule, number[]> | undefined} */
+		let fixData;
+
+		mediaQueryListCommaWhitespaceChecker({
+			root,
+			result,
+			locationChecker: checker.before,
+			checkedRuleName: ruleName,
+			fix: context.fix ?
+				(atRule, index) => {
+					const parameterCommaIndex = index - atRuleParamIndex(atRule);
+
+					fixData ||= new Map();
+					const commaIndices = fixData.get(atRule) || [];
+
+					commaIndices.push(parameterCommaIndex);
+					fixData.set(atRule, commaIndices);
+
+					return true;
+				  }
+				: null
+		});
+
+		if (fixData) {
+			for (const [atRule, commaIndices] of fixData.entries()) {
+				let parameters = atRule.raws.params ? atRule.raws.params.raw : atRule.params;
+
+				for (const index of commaIndices.sort((a, b) => b - a)) {
+					const beforeComma = parameters.slice(0, index);
+					const afterComma = parameters.slice(index);
+
+					if (primary.startsWith('always')) {
+						parameters = beforeComma.replace(/\s*$/, ' ') + afterComma;
+					}
+					else if (primary.startsWith('never')) {
+						parameters = beforeComma.replace(/\s*$/, '') + afterComma;
+					}
+				}
+
+				if (atRule.raws.params) {
+					atRule.raws.params.raw = parameters;
+				}
+				else {
+					atRule.params = parameters;
+				}
+			}
+		}
+	};
+};
+
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;
+module.exports = stylelint.createPlugin(ruleName, rule);

package/stylelint/plugins/stylelint-15.11.0-stylistic/rules/mediaFeatureColonSpaceChecker.cjs

@@ -0,0 +1,54 @@
+/* eslint-disable -- We want to keep as much of the original code as possible */
+// @ts-nocheck
+
+const atRuleParamIndex = require('stylelint/lib/utils/atRuleParamIndex.cjs');
+const report = require('stylelint/lib/utils/report.cjs');
+
+const styleSearch = require('../style-search/index.cjs');
+
+/**
+ * @param {{
+ *   root: import('postcss').Root,
+ *   locationChecker: (args: { source: string, index: number, err: (message: string) => void }) => void,
+ *   fix: ((node: import('postcss').AtRule, index: number) => boolean) | null,
+ *   result: import('stylelint').PostcssResult,
+ *   checkedRuleName: string,
+ * }} opts
+ * @param options
+ */
+module.exports = function mediaFeatureColonSpaceChecker (options) {
+	options.root.walkAtRules(/^media$/i, (atRule) => {
+		const parameters = atRule.raws.params ? atRule.raws.params.raw : atRule.params;
+
+		styleSearch({ source: parameters, target: ':' }, (match) => {
+			checkColon(parameters, match.startIndex, atRule);
+		});
+	});
+
+	/**
+	 * @param {string} source
+	 * @param {number} index
+	 * @param {import('postcss').AtRule} node
+	 */
+	function checkColon (source, index, node) {
+		options.locationChecker({
+			source,
+			index,
+			err: (message) => {
+				const colonIndex = index + atRuleParamIndex(node);
+
+				if (options.fix?.(node, colonIndex)) {
+					return;
+				}
+
+				report({
+					message,
+					node,
+					index: colonIndex,
+					result: options.result,
+					ruleName: options.checkedRuleName
+				});
+			}
+		});
+	}
+};

package/stylelint/plugins/stylelint-15.11.0-stylistic/rules/mediaQueryListCommaWhitespaceChecker.cjs

@@ -0,0 +1,73 @@
+/* eslint-disable -- We want to keep as much of the original code as possible */
+// @ts-nocheck
+
+const atRuleParamIndex = require('stylelint/lib/utils/atRuleParamIndex.cjs');
+const report = require('stylelint/lib/utils/report.cjs');
+const { assertString } = require('stylelint/lib/utils/validateTypes.cjs');
+
+const styleSearch = require('../style-search/index.cjs');
+
+/**
+ * @param {{
+ *   root: import('postcss').Root,
+ *   result: import('stylelint').PostcssResult,
+ *   locationChecker: (args: { source: string, index: number, err: (message: string) => void }) => void,
+ *   checkedRuleName: string,
+ *   fix?: ((atRule: import('postcss').AtRule, index: number) => boolean) | null | undefined,
+ *   allowTrailingComments?: boolean,
+ * }} opts
+ * @param options
+ */
+module.exports = function mediaQueryListCommaWhitespaceChecker (options) {
+	options.root.walkAtRules(/^media$/i, (atRule) => {
+		const parameters = atRule.raws.params ? atRule.raws.params.raw : atRule.params;
+
+		styleSearch({ source: parameters, target: ',' }, (match) => {
+			let index = match.startIndex;
+
+			if (options.allowTrailingComments) {
+				// if there is a comment on the same line at after the comma, check the space after the comment.
+				let execResult;
+
+				while ((execResult = (/^[^\S\n\r]*\/\*([\S\s]*?)\*\//).exec(parameters.slice(index + 1)))) {
+					assertString(execResult[0]);
+					index += execResult[0].length;
+				}
+
+				if ((execResult = (/^([^\S\n\r]*\/\/[\S\s]*?)\r?\n/).exec(parameters.slice(index + 1)))) {
+					assertString(execResult[1]);
+					index += execResult[1].length;
+				}
+			}
+
+			checkComma(parameters, index, atRule);
+		});
+	});
+
+	/**
+	 * @param {string} source
+	 * @param {number} index
+	 * @param {import('postcss').AtRule} node
+	 */
+	function checkComma (source, index, node) {
+		options.locationChecker({
+			source,
+			index,
+			err: (message) => {
+				const commaIndex = index + atRuleParamIndex(node);
+
+				if (options.fix?.(node, commaIndex)) {
+					return;
+				}
+
+				report({
+					message,
+					node,
+					index: commaIndex,
+					result: options.result,
+					ruleName: options.checkedRuleName
+				});
+			}
+		});
+	}
+};

package/stylelint/plugins/stylelint-15.11.0-stylistic/rules/no-empty-first-line/README.md

@@ -0,0 +1,34 @@
+# no-empty-first-line
+
+Disallow empty first lines.
+
+<!-- prettier-ignore -->
+```css
+    \n
+    /** ↑
+     * This newline */
+    a { color: pink; }
+```
+
+This rule ignores empty sources. Use the [`no-empty-source`](../no-empty-source/README.md) rule to disallow these.
+
+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
+\n
+a { color: pink; }
+```
+
+The following patterns are _not_ considered problems:
+
+<!-- prettier-ignore -->
+```css
+a { color: pink; }
+```

package/stylelint/plugins/stylelint-15.11.0-stylistic/rules/no-empty-first-line/index.cjs

@@ -0,0 +1,63 @@
+/* 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-empty-first-line';
+const noEmptyFirstLineTest = /^\s*[\n\r]/;
+
+const messages = ruleMessages(ruleName, {
+	rejected: 'Unexpected empty line'
+});
+
+const meta = {
+	url: 'https://github.com/jens-duttke/linter-bundle/blob/main/stylelint/plugins/stylelint-15.11.0-stylistic/rules/no-empty-first-line/README.md',
+	fixable: true
+};
+
+/** @type {import('stylelint').Rule} */
+const rule = (primary, _secondaryOptions, context) => (root, result) => {
+	const validOptions = validateOptions(result, ruleName, { actual: primary });
+
+	// @ts-expect-error -- TS2339: Property 'inline' does not exist on type 'Source'. Property 'lang' does not exist on type 'Source'.
+	if (!validOptions || root.source.inline || root.source.lang === 'object-literal') {
+		return;
+	}
+
+	const rootString = context.fix ? root.toString() : (root.source?.input.css) || '';
+
+	if (!rootString.trim()) {
+		return;
+	}
+
+	if (noEmptyFirstLineTest.test(rootString)) {
+		if (context.fix) {
+			if (root.first == null) {
+				throw new Error('The root node must have the first node.');
+			}
+
+			if (root.first.raws.before == null) {
+				throw new Error('The first node must have spaces before.');
+			}
+
+			root.first.raws.before = root.first.raws.before.trimStart();
+
+			return;
+		}
+
+		report({
+			message: messages.rejected,
+			node: root,
+			result,
+			ruleName
+		});
+	}
+};
+
+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-eol-whitespace/README.md

@@ -0,0 +1,79 @@
+# no-eol-whitespace
+
+Disallow end-of-line whitespace.
+
+<!-- prettier-ignore -->
+```css
+a { color: pink; }···
+/**               ↑
+ *  This whitespace */
+```
+
+The [`fix` option](https://stylelint.io/user-guide/options/#fix) can automatically fix most of the problems reported by this rule.
+
+## Options
+
+### `true`
+
+The following patterns are considered problems:
+
+<!-- prettier-ignore -->
+```css
+a { color: pink; }·
+```
+
+<!-- prettier-ignore -->
+```css
+a { color: pink; }····
+```
+
+Comment strings are also checked -- so the following is a problem:
+
+<!-- prettier-ignore -->
+```css
+/* something····
+ * something else */
+```
+
+The following patterns are _not_ considered problems:
+
+<!-- prettier-ignore -->
+```css
+a { color: pink; }
+```
+
+<!-- prettier-ignore -->
+```css
+/* something
+ * something else */
+```
+
+## Optional secondary options
+
+### `ignore: ["empty-lines"]`
+
+#### `"empty-lines"`
+
+Allow end-of-line whitespace for lines that are only whitespace, "empty" lines.
+
+The following patterns are _not_ considered problems:
+
+<!-- prettier-ignore -->
+```css
+a {
+  color: pink;
+··
+  background: orange;
+}
+```
+
+<!-- prettier-ignore -->
+```css
+····
+```
+
+<!-- prettier-ignore -->
+```css
+a { color: pink; }
+····
+```