linter-bundle 5.0.1 → 6.0.0

package/stylelint/plugins/stylelint-15.11.0-stylistic/rules/declaration-block-semicolon-space-before/README.md

@@ -0,0 +1,130 @@
+# declaration-block-semicolon-space-before
+
+Require a single space or disallow whitespace before the semicolons of declaration blocks.
+
+<!-- prettier-ignore -->
+```css
+a { color: pink; }
+/**            ↑
+ * The space before this semicolon */
+```
+
+This rule ignores semicolons that are preceded by Less mixins.
+
+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 semicolons.
+
+The following patterns are considered problems:
+
+<!-- prettier-ignore -->
+```css
+a { color: pink; }
+```
+
+<!-- prettier-ignore -->
+```css
+a { color: pink; top: 0; }
+```
+
+The following patterns are _not_ considered problems:
+
+<!-- prettier-ignore -->
+```css
+a { color: pink ; }
+```
+
+<!-- prettier-ignore -->
+```css
+a { color: pink ; top: 0 ; }
+```
+
+### `"never"`
+
+There _must never_ be whitespace before the semicolons.
+
+The following patterns are considered problems:
+
+<!-- prettier-ignore -->
+```css
+a { color: pink ; }
+```
+
+<!-- prettier-ignore -->
+```css
+a { color: pink ; top: 0 ; }
+```
+
+The following patterns are _not_ considered problems:
+
+<!-- prettier-ignore -->
+```css
+a { color: pink; }
+```
+
+<!-- prettier-ignore -->
+```css
+a { color: pink; top: 0; }
+```
+
+### `"always-single-line"`
+
+There _must always_ be a single space before the semicolons in single-line declaration blocks.
+
+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 ; }
+```
+
+<!-- prettier-ignore -->
+```css
+a { color: pink; top: 0; }
+```
+
+<!-- prettier-ignore -->
+```css
+a { color: pink ; top: 0 ; }
+```
+
+### `"never-single-line"`
+
+There _must never_ be whitespace before the semicolons in single-line declaration blocks.
+
+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; }
+```
+
+<!-- prettier-ignore -->
+```css
+a { color: pink; top: 0; }
+```
+
+<!-- prettier-ignore -->
+```css
+a { color: pink ; top: 0 ; }
+```

package/stylelint/plugins/stylelint-15.11.0-stylistic/rules/declaration-block-semicolon-space-before/index.cjs

@@ -0,0 +1,106 @@
+/* eslint-disable -- We want to keep as much of the original code as possible */
+// @ts-nocheck
+
+const stylelint = require('stylelint');
+const blockString = require('stylelint/lib/utils/blockString.cjs');
+const getDeclarationValue = require('stylelint/lib/utils/getDeclarationValue.cjs');
+const report = require('stylelint/lib/utils/report.cjs');
+const ruleMessages = require('stylelint/lib/utils/ruleMessages.cjs');
+const setDeclarationValue = require('stylelint/lib/utils/setDeclarationValue.cjs');
+const { isAtRule, isRule } = require('stylelint/lib/utils/typeGuards.cjs');
+const validateOptions = require('stylelint/lib/utils/validateOptions.cjs');
+
+const whitespaceChecker = require('../../utils/whitespaceChecker.cjs');
+
+const ruleName = 'plugin/declaration-block-semicolon-space-before';
+
+const messages = ruleMessages(ruleName, {
+	expectedBefore: () => 'Expected single space before ";"',
+	rejectedBefore: () => 'Unexpected whitespace before ";"',
+	expectedBeforeSingleLine: () => 'Expected single space before ";" in a single-line declaration block',
+	rejectedBeforeSingleLine: () => 'Unexpected whitespace before ";" in a single-line declaration block'
+});
+
+const meta = {
+	url: 'https://github.com/jens-duttke/linter-bundle/blob/main/stylelint/plugins/stylelint-15.11.0-stylistic/rules/declaration-block-semicolon-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;
+		}
+
+		root.walkDecls((decl) => {
+			// Ignore last declaration if there's no trailing semicolon
+			const parentRule = decl.parent;
+
+			if (!parentRule) { throw new Error('A parent node must be present'); }
+
+			if (!isAtRule(parentRule) && !isRule(parentRule)) {
+				return;
+			}
+
+			if (!parentRule.raws.semicolon && parentRule.last === decl) {
+				return;
+			}
+
+			const declString = decl.toString();
+
+			checker.before({
+				source: declString,
+				index: declString.length,
+				lineCheckStr: blockString(parentRule),
+				err: (m) => {
+					if (context.fix) {
+						const value = getDeclarationValue(decl);
+
+						if (primary.startsWith('always')) {
+							if (decl.important) {
+								decl.raws.important = ' !important ';
+							}
+							else {
+								setDeclarationValue(decl, value.replace(/\s*$/, ' '));
+							}
+
+							return;
+						}
+
+						if (primary.startsWith('never')) {
+							if (decl.raws.important) {
+								decl.raws.important = decl.raws.important.replace(/\s*$/, '');
+							}
+							else {
+								setDeclarationValue(decl, value.replace(/\s*$/, ''));
+							}
+
+							return;
+						}
+					}
+
+					report({
+						message: m,
+						node: decl,
+						index: decl.toString().length - 1,
+						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/declaration-block-trailing-semicolon/README.md

@@ -0,0 +1,108 @@
+# declaration-block-trailing-semicolon
+
+Require or disallow a trailing semicolon within declaration blocks.
+
+<!-- prettier-ignore -->
+```css
+a { background: orange; color: pink; }
+/**                                ↑
+ *                    This semicolon */
+```
+
+The trailing semicolon is the _last_ semicolon in a declaration block and it is optional.
+
+This rule ignores:
+
+- Less mixins
+- trailing `//` comments
+- declaration blocks containing nested (at-)rules
+
+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"`
+
+There _must always_ be a trailing semicolon.
+
+The following patterns are considered problems:
+
+<!-- prettier-ignore -->
+```css
+a { color: pink }
+```
+
+<!-- prettier-ignore -->
+```css
+a { background: orange; color: pink }
+```
+
+<!-- prettier-ignore -->
+```css
+a { @include foo }
+```
+
+The following patterns are _not_ considered problems:
+
+<!-- prettier-ignore -->
+```css
+a { color: pink; }
+```
+
+<!-- prettier-ignore -->
+```css
+a { background: orange; color: pink; }
+```
+
+<!-- prettier-ignore -->
+```css
+a { @include foo; }
+```
+
+### `"never"`
+
+There _must never_ be a trailing semicolon.
+
+The following patterns are considered problems:
+
+<!-- prettier-ignore -->
+```css
+a { color: pink; }
+```
+
+<!-- prettier-ignore -->
+```css
+a { background: orange; color: pink; }
+```
+
+The following patterns are _not_ considered problems:
+
+<!-- prettier-ignore -->
+```css
+a { color: pink }
+```
+
+<!-- prettier-ignore -->
+```css
+a { background: orange; color: pink }
+```
+
+## Optional secondary options
+
+### `ignore: ["single-declaration"]`
+
+Ignore declaration blocks that contain a single declaration.
+
+The following patterns are _not_ considered problems:
+
+<!-- prettier-ignore -->
+```css
+a { color: pink }
+```
+
+<!-- prettier-ignore -->
+```css
+a { color: pink; }
+```

package/stylelint/plugins/stylelint-15.11.0-stylistic/rules/declaration-block-trailing-semicolon/index.cjs

@@ -0,0 +1,147 @@
+/* eslint-disable -- We want to keep as much of the original code as possible */
+// @ts-nocheck
+
+const stylelint = require('stylelint');
+const hasBlock = require('stylelint/lib/utils/hasBlock.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 } = require('stylelint/lib/utils/typeGuards.cjs');
+const validateOptions = require('stylelint/lib/utils/validateOptions.cjs');
+
+const ruleName = 'plugin/declaration-block-trailing-semicolon';
+
+const messages = ruleMessages(ruleName, {
+	expected: 'Expected a trailing semicolon',
+	rejected: 'Unexpected trailing semicolon'
+});
+
+const meta = {
+	url: 'https://github.com/jens-duttke/linter-bundle/blob/main/stylelint/plugins/stylelint-15.11.0-stylistic/rules/declaration-block-trailing-semicolon/README.md',
+	fixable: true
+};
+
+/** @type {import('stylelint').Rule} */
+const rule = (primary, secondaryOptions, context) => (root, result) => {
+	const validOptions = validateOptions(
+		result,
+		ruleName,
+		{
+			actual: primary,
+			possible: ['always', 'never']
+		},
+		{
+			actual: secondaryOptions,
+			possible: {
+				ignore: ['single-declaration']
+			},
+			optional: true
+		}
+	);
+
+	if (!validOptions) {
+		return;
+	}
+
+	root.walkAtRules((atRule) => {
+		if (!atRule.parent) { throw new Error('A parent node must be present'); }
+
+		if (atRule.parent === root) {
+			return;
+		}
+
+		if (atRule !== atRule.parent.last) {
+			return;
+		}
+
+		if (hasBlock(atRule)) {
+			return;
+		}
+
+		checkLastNode(atRule);
+	});
+
+	root.walkDecls((decl) => {
+		if (!decl.parent) { throw new Error('A parent node must be present'); }
+
+		if (decl.parent.type === 'object') {
+			return;
+		}
+
+		if (decl !== decl.parent.last) {
+			return;
+		}
+
+		checkLastNode(decl);
+	});
+
+	/**
+	 * @param {import('postcss').Node} node
+	 */
+	function checkLastNode (node) {
+		if (!node.parent) { throw new Error('A parent node must be present'); }
+
+		const hasSemicolon = node.parent.raws.semicolon;
+		const ignoreSingleDeclaration = optionsMatches(
+			secondaryOptions,
+			'ignore',
+			'single-declaration'
+		);
+
+		if (ignoreSingleDeclaration && node.parent.first === node) {
+			return;
+		}
+
+		let message;
+
+		if (primary === 'always') {
+			if (hasSemicolon) {
+				return;
+			}
+
+			// auto-fix
+			if (context.fix) {
+				node.parent.raws.semicolon = true;
+
+				if (isAtRule(node)) {
+					node.raws.between = '';
+					node.parent.raws.after = ' ';
+				}
+
+				return;
+			}
+
+			message = messages.expected;
+		}
+		else if (primary === 'never') {
+			if (!hasSemicolon) {
+				return;
+			}
+
+			// auto-fix
+			if (context.fix) {
+				node.parent.raws.semicolon = false;
+
+				return;
+			}
+
+			message = messages.rejected;
+		}
+		else {
+			throw new Error(`Unexpected primary option: "${primary}"`);
+		}
+
+		report({
+			message,
+			node,
+			index: node.toString().trim().length - 1,
+			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/declaration-colon-newline-after/README.md

@@ -0,0 +1,78 @@
+# declaration-colon-newline-after
+
+Require a newline or disallow whitespace after the colon of declarations.
+
+<!-- prettier-ignore -->
+```css
+a {
+  box-shadow:
+    0 0 0 1px #5b9dd9,
+    0 0 2px 1px rgba(30, 140, 190, 0.8);
+}        /* ↑ */
+/**         ↑
+ * The newline after this colon */
+```
+
+The [`fix` option](https://stylelint.io/user-guide/options/#fix) can automatically fix all of the problems reported by this rule.
+
+## Options
+
+`string`: `"always"|"always-multi-line"`
+
+### `"always"`
+
+There _must always_ be a newline after the colon.
+
+The following patterns are considered problems:
+
+<!-- prettier-ignore -->
+```css
+a { color:pink; }
+```
+
+<!-- prettier-ignore -->
+```css
+a { color: pink; }
+```
+
+The following patterns are _not_ considered problems:
+
+<!-- prettier-ignore -->
+```css
+a {
+  color:
+    pink;
+}
+```
+
+### `"always-multi-line"`
+
+There _must always_ be a newline after the colon _if the declaration's value is multi-line_.
+
+The following patterns are considered problems:
+
+<!-- prettier-ignore -->
+```css
+a {
+  box-shadow: 0 0 0 1px #5b9dd9,
+    0 0 2px 1px rgba(30, 140, 190, 0.8);
+}
+```
+
+The following patterns are _not_ considered problems:
+
+<!-- prettier-ignore -->
+```css
+a {
+  box-shadow:
+    0 0 0 1px #5b9dd9,
+    0 0 2px 1px rgba(30, 140, 190, 0.8);
+}
+```
+
+<!-- prettier-ignore -->
+```css
+a {
+  color: pink;
+}
+```

package/stylelint/plugins/stylelint-15.11.0-stylistic/rules/declaration-colon-newline-after/index.cjs

@@ -0,0 +1,99 @@
+/* eslint-disable -- We want to keep as much of the original code as possible */
+// @ts-nocheck
+
+const stylelint = require('stylelint');
+const declarationValueIndex = require('stylelint/lib/utils/declarationValueIndex.cjs');
+const isStandardSyntaxDeclaration = require('stylelint/lib/utils/isStandardSyntaxDeclaration.cjs');
+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 whitespaceChecker = require('../../utils/whitespaceChecker.cjs');
+
+const ruleName = 'plugin/declaration-colon-newline-after';
+
+const messages = ruleMessages(ruleName, {
+	expectedAfter: () => 'Expected newline after ":"',
+	expectedAfterMultiLine: () => 'Expected newline after ":" with a multi-line declaration'
+});
+
+const meta = {
+	url: 'https://github.com/jens-duttke/linter-bundle/blob/main/stylelint/plugins/stylelint-15.11.0-stylistic/rules/declaration-colon-newline-after/README.md',
+	fixable: true
+};
+
+/** @type {import('stylelint').Rule} */
+const rule = (primary, _secondaryOptions, context) => {
+	const checker = whitespaceChecker('newline', primary, messages);
+
+	return (root, result) => {
+		const validOptions = validateOptions(result, ruleName, {
+			actual: primary,
+			possible: ['always', 'always-multi-line']
+		});
+
+		if (!validOptions) {
+			return;
+		}
+
+		root.walkDecls((decl) => {
+			if (!isStandardSyntaxDeclaration(decl)) {
+				return;
+			}
+
+			// Get the raw prop, and only the prop
+			const endOfPropertyIndex = declarationValueIndex(decl) + (decl.raws.between || '').length - 1;
+
+			// The extra characters tacked onto the end ensure that there is a character to check
+			// after the colon. Otherwise, with `background:pink` the character after the
+			const propertyPlusColon = `${decl.toString().slice(0, endOfPropertyIndex)}xxx`;
+
+			for (let i = 0, l = propertyPlusColon.length; i < l; i++) {
+				if (propertyPlusColon[i] !== ':') {
+					continue;
+				}
+
+				const indexToCheck = (/^[^\S\n\r]*\/\*/).test(propertyPlusColon.slice(i + 1)) ?
+					propertyPlusColon.indexOf('*/', i) + 1
+					: i;
+
+				checker.afterOneOnly({
+					source: propertyPlusColon,
+					index: indexToCheck,
+					lineCheckStr: decl.value,
+					err: (m) => {
+						if (context.fix) {
+							const between = decl.raws.between;
+
+							if (between == null) { throw new Error('`between` must be present'); }
+
+							const betweenStart = declarationValueIndex(decl) - between.length;
+							const sliceIndex = indexToCheck - betweenStart + 1;
+							const betweenBefore = between.slice(0, sliceIndex);
+							const betweenAfter = between.slice(sliceIndex);
+
+							decl.raws.between = (/^\s*\n/).test(betweenAfter) ?
+								betweenBefore + betweenAfter.replace(/^[^\S\n\r]*/, '')
+								: betweenBefore + context.newline + betweenAfter;
+
+							return;
+						}
+
+						report({
+							message: m,
+							node: decl,
+							index: indexToCheck,
+							result,
+							ruleName
+						});
+					}
+				});
+			}
+		});
+	};
+};
+
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;
+module.exports = stylelint.createPlugin(ruleName, rule);