linter-bundle 5.1.0 → 6.1.0

package/stylelint/plugins/stylelint-15.11.0-stylistic/rules/number-leading-zero/README.md

@@ -0,0 +1,74 @@
+# number-leading-zero
+
+Require or disallow a leading zero for fractional numbers less than 1.
+
+<!-- prettier-ignore -->
+```css
+a { line-height: 0.5; }
+/**              ↑
+ * This leading zero */
+```
+
+This rule ignores mixin parameters in Less.
+
+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 leading zero.
+
+The following patterns are considered problems:
+
+<!-- prettier-ignore -->
+```css
+a { line-height: .5; }
+```
+
+<!-- prettier-ignore -->
+```css
+a { transform: translate(2px, .4px); }
+```
+
+The following patterns are _not_ considered problems:
+
+<!-- prettier-ignore -->
+```css
+a { line-height: 0.5; }
+```
+
+<!-- prettier-ignore -->
+```css
+a { transform: translate(2px, 0.4px); }
+```
+
+### `"never"`
+
+There _must never_ be a leading zero.
+
+The following patterns are considered problems:
+
+<!-- prettier-ignore -->
+```css
+a { line-height: 0.5; }
+```
+
+<!-- prettier-ignore -->
+```css
+a { transform: translate(2px, 0.4px); }
+```
+
+The following patterns are _not_ considered problems:
+
+<!-- prettier-ignore -->
+```css
+a { line-height: .5; }
+```
+
+<!-- prettier-ignore -->
+```css
+a { transform: translate(2px, .4px); }
+```

package/stylelint/plugins/stylelint-15.11.0-stylistic/rules/number-leading-zero/index.cjs

@@ -0,0 +1,197 @@
+/* eslint-disable -- We want to keep as much of the original code as possible */
+// @ts-nocheck
+
+const valueParser = require('postcss-value-parser');
+const stylelint = require('stylelint');
+const atRuleParamIndex = require('stylelint/lib/utils/atRuleParamIndex.cjs');
+const declarationValueIndex = require('stylelint/lib/utils/declarationValueIndex.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/number-leading-zero';
+
+const messages = ruleMessages(ruleName, {
+	expected: 'Expected a leading zero',
+	rejected: 'Unexpected leading zero'
+});
+
+const meta = {
+	url: 'https://github.com/jens-duttke/linter-bundle/blob/main/stylelint/plugins/stylelint-15.11.0-stylistic/rules/number-leading-zero/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']
+	});
+
+	if (!validOptions) {
+		return;
+	}
+
+	root.walkAtRules((atRule) => {
+		if (atRule.name.toLowerCase() === 'import') {
+			return;
+		}
+
+		check(atRule, atRule.params);
+	});
+
+	root.walkDecls((decl) => check(decl, decl.value));
+
+	/**
+	 * @param {import('postcss').AtRule | import('postcss').Declaration} node
+	 * @param {string} value
+	 */
+	function check (node, value) {
+		/** @type {Array<{ startIndex: number, endIndex: number }>} */
+		const neverFixPositions = [];
+		/** @type {Array<{ index: number }>} */
+		const alwaysFixPositions = [];
+
+		// Get out quickly if there are no periods
+		if (!value.includes('.')) {
+			return;
+		}
+
+		valueParser(value).walk((valueNode) => {
+			// Ignore `url` function
+			if (valueNode.type === 'function' && valueNode.value.toLowerCase() === 'url') {
+				return false;
+			}
+
+			// Ignore strings, comments, etc
+			if (valueNode.type !== 'word') {
+				return;
+			}
+
+			// Check leading zero
+			if (primary === 'always') {
+				const match = (/(?:\D|^)(\.\d+)/).exec(valueNode.value);
+
+				if (match?.[0] == null || match[1] == null) {
+					return;
+				}
+
+				// The regexp above consists of 2 capturing groups (or capturing parentheses).
+				// We need the index of the second group. This makes sanse when we have "-.5" as an input
+				// for regex. And we need the index of ".5".
+				const capturingGroupIndex = match[0].length - match[1].length;
+
+				const index = valueNode.sourceIndex + match.index + capturingGroupIndex;
+
+				if (context.fix) {
+					alwaysFixPositions.unshift({
+						index
+					});
+
+					return;
+				}
+
+				const baseIndex = isAtRule(node) ? atRuleParamIndex(node) : declarationValueIndex(node);
+
+				complain(messages.expected, node, baseIndex + index);
+			}
+
+			if (primary === 'never') {
+				const match = (/(?:\D|^)(0+)(\.\d+)/).exec(valueNode.value);
+
+				if (match?.[0] == null || match[1] == null || match[2] == null) {
+					return;
+				}
+
+				// The regexp above consists of 3 capturing groups (or capturing parentheses).
+				// We need the index of the second group. This makes sanse when we have "-00.5"
+				// as an input for regex. And we need the index of "00".
+				const capturingGroupIndex = match[0].length - (match[1].length + match[2].length);
+
+				const index = valueNode.sourceIndex + match.index + capturingGroupIndex;
+
+				if (context.fix) {
+					neverFixPositions.unshift({
+						startIndex: index,
+						// match[1].length is the length of our matched zero(s)
+						endIndex: index + match[1].length
+					});
+
+					return;
+				}
+
+				const baseIndex = isAtRule(node) ? atRuleParamIndex(node) : declarationValueIndex(node);
+
+				complain(messages.rejected, node, baseIndex + index);
+			}
+		});
+
+		if (alwaysFixPositions.length > 0) {
+			for (const fixPosition of alwaysFixPositions) {
+				const index = fixPosition.index;
+
+				if (isAtRule(node)) {
+					node.params = addLeadingZero(node.params, index);
+				}
+				else {
+					node.value = addLeadingZero(node.value, index);
+				}
+			}
+		}
+
+		if (neverFixPositions.length > 0) {
+			for (const fixPosition of neverFixPositions) {
+				const startIndex = fixPosition.startIndex;
+				const endIndex = fixPosition.endIndex;
+
+				if (isAtRule(node)) {
+					node.params = removeLeadingZeros(node.params, startIndex, endIndex);
+				}
+				else {
+					node.value = removeLeadingZeros(node.value, startIndex, endIndex);
+				}
+			}
+		}
+	}
+
+	/**
+	 * @param {string} message
+	 * @param {import('postcss').Node} node
+	 * @param {number} index
+	 */
+	function complain (message, node, index) {
+		report({
+			result,
+			ruleName,
+			message,
+			node,
+			index
+		});
+	}
+};
+
+/**
+ * @param {string} input
+ * @param {number} index
+ * @returns {string}
+ */
+function addLeadingZero (input, index) {
+	 
+	return input.slice(0, index) + '0' + input.slice(index);
+}
+
+/**
+ * @param {string} input
+ * @param {number} startIndex
+ * @param {number} endIndex
+ * @returns {string}
+ */
+function removeLeadingZeros (input, startIndex, endIndex) {
+	return input.slice(0, startIndex) + input.slice(endIndex);
+}
+
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;
+module.exports = stylelint.createPlugin(ruleName, rule);

package/stylelint/plugins/stylelint-15.11.0-stylistic/rules/number-no-trailing-zeros/README.md

@@ -0,0 +1,40 @@
+# number-no-trailing-zeros
+
+Disallow trailing zeros in numbers.
+
+<!-- prettier-ignore -->
+```css
+a { top: 0.5000px; bottom: 1.0px; }
+/**         ↑                ↑
+ *        These trailing zeros */
+```
+
+The [`fix` option](https://stylelint.io/user-guide/options/#fix) can automatically fix some of the problems reported by this rule.
+
+## Options
+
+### `true`
+
+The following patterns are considered problems:
+
+<!-- prettier-ignore -->
+```css
+a { top: 1.0px }
+```
+
+<!-- prettier-ignore -->
+```css
+a { top: 1.01000px }
+```
+
+The following patterns are _not_ considered problems:
+
+<!-- prettier-ignore -->
+```css
+a { top: 1px }
+```
+
+<!-- prettier-ignore -->
+```css
+a { top: 1.01px }
+```

package/stylelint/plugins/stylelint-15.11.0-stylistic/rules/number-no-trailing-zeros/index.cjs

@@ -0,0 +1,139 @@
+/* eslint-disable -- We want to keep as much of the original code as possible */
+// @ts-nocheck
+
+const valueParser = require('postcss-value-parser');
+const stylelint = require('stylelint');
+const atRuleParamIndex = require('stylelint/lib/utils/atRuleParamIndex.cjs');
+const declarationValueIndex = require('stylelint/lib/utils/declarationValueIndex.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/number-no-trailing-zeros';
+
+const messages = ruleMessages(ruleName, {
+	rejected: 'Unexpected trailing zero(s)'
+});
+
+const meta = {
+	url: 'https://github.com/jens-duttke/linter-bundle/blob/main/stylelint/plugins/stylelint-15.11.0-stylistic/rules/number-no-trailing-zeros/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;
+	}
+
+	root.walkAtRules((atRule) => {
+		if (atRule.name.toLowerCase() === 'import') {
+			return;
+		}
+
+		check(atRule, atRule.params);
+	});
+
+	root.walkDecls((decl) => check(decl, decl.value));
+
+	/**
+	 * @param {import('postcss').AtRule | import('postcss').Declaration} node
+	 * @param {string} value
+	 */
+	function check (node, value) {
+		/** @type {Array<{ startIndex: number, endIndex: number }>} */
+		const fixPositions = [];
+
+		// Get out quickly if there are no periods
+		if (!value.includes('.')) {
+			return;
+		}
+
+		valueParser(value).walk((valueNode) => {
+			// Ignore `url` function
+			if (valueNode.type === 'function' && valueNode.value.toLowerCase() === 'url') {
+				return false;
+			}
+
+			// Ignore strings, comments, etc
+			if (valueNode.type !== 'word') {
+				return;
+			}
+
+			const match = (/\.(\d{0,100}?)(0+)(?:\D|$)/).exec(valueNode.value);
+
+			// match[1] is any numbers between the decimal and our trailing zero, could be empty
+			// match[2] is our trailing zero(s)
+			if (match?.[1] == null || match[2] == null) {
+				return;
+			}
+
+			// our index is:
+			//  the index of our valueNode +
+			//  the index of our match +
+			//  1 for our decimal +
+			//  the length of our potential non-zero number match (match[1])
+			const index = valueNode.sourceIndex + match.index + 1 + match[1].length;
+
+			// our startIndex is identical to our index except when we have only
+			// trailing zeros after our decimal. in that case we don't need the decimal
+			// either so we move our index back by 1.
+			const startIndex = match[1].length > 0 ? index : index - 1;
+
+			// our end index is our original index + the length of our trailing zeros
+			const endIndex = index + match[2].length;
+
+			if (context.fix) {
+				fixPositions.unshift({
+					startIndex,
+					endIndex
+				});
+
+				return;
+			}
+
+			const baseIndex = isAtRule(node) ? atRuleParamIndex(node) : declarationValueIndex(node);
+
+			report({
+				message: messages.rejected,
+				node,
+				// this is the index of the _first_ trailing zero
+				index: baseIndex + index,
+				result,
+				ruleName
+			});
+		});
+
+		if (fixPositions.length > 0) {
+			for (const fixPosition of fixPositions) {
+				const startIndex = fixPosition.startIndex;
+				const endIndex = fixPosition.endIndex;
+
+				if (isAtRule(node)) {
+					node.params = removeTrailingZeros(node.params, startIndex, endIndex);
+				}
+				else {
+					node.value = removeTrailingZeros(node.value, startIndex, endIndex);
+				}
+			}
+		}
+	}
+};
+
+/**
+ * @param {string} input
+ * @param {number} startIndex
+ * @param {number} endIndex
+ * @returns {string}
+ */
+function removeTrailingZeros (input, startIndex, endIndex) {
+	return input.slice(0, startIndex) + input.slice(endIndex);
+}
+
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;
+module.exports = stylelint.createPlugin(ruleName, rule);

package/stylelint/plugins/stylelint-15.11.0-stylistic/rules/property-case/README.md

@@ -0,0 +1,192 @@
+# property-case
+
+Specify lowercase or uppercase for properties.
+
+<!-- prettier-ignore -->
+```css
+    a { width: 1px; }
+/**     ↑
+ * This property */
+```
+
+The [`fix` option](https://stylelint.io/user-guide/options/#fix) can automatically fix all of the problems reported by this rule.
+
+## Options
+
+`string`: `"lower"|"upper"`
+
+### `"lower"`
+
+The following patterns are considered problems:
+
+<!-- prettier-ignore -->
+```css
+a {
+  Width: 1px
+}
+```
+
+<!-- prettier-ignore -->
+```css
+a {
+  WIDTH: 1px
+}
+```
+
+<!-- prettier-ignore -->
+```css
+a {
+  widtH: 1px
+}
+```
+
+<!-- prettier-ignore -->
+```css
+a {
+  border-Radius: 5px;
+}
+```
+
+<!-- prettier-ignore -->
+```css
+a {
+  -WEBKIT-animation-duration: 3s;
+}
+```
+
+<!-- prettier-ignore -->
+```css
+@media screen and (orientation: landscape) {
+  WiDtH: 500px;
+}
+```
+
+The following patterns are _not_ considered problems:
+
+<!-- prettier-ignore -->
+```css
+a {
+  width: 1px
+}
+```
+
+<!-- prettier-ignore -->
+```css
+a {
+  border-radius: 5px;
+}
+```
+
+<!-- prettier-ignore -->
+```css
+a {
+  -webkit-animation-duration: 3s;
+}
+```
+
+<!-- prettier-ignore -->
+```css
+@media screen and (orientation: landscape) {
+  width: 500px;
+}
+```
+
+### `"upper"`
+
+The following patterns are considered problems:
+
+<!-- prettier-ignore -->
+```css
+a {
+  Width: 1px
+}
+```
+
+<!-- prettier-ignore -->
+```css
+a {
+  width: 1px
+}
+```
+
+<!-- prettier-ignore -->
+```css
+a {
+  widtH: 1px
+}
+```
+
+<!-- prettier-ignore -->
+```css
+a {
+  border-Radius: 5px;
+}
+```
+
+<!-- prettier-ignore -->
+```css
+a {
+  -WEBKIT-animation-duration: 3s;
+}
+```
+
+<!-- prettier-ignore -->
+```css
+@media screen and (orientation: landscape) {
+  WiDtH: 500px;
+}
+```
+
+The following patterns are _not_ considered problems:
+
+<!-- prettier-ignore -->
+```css
+a {
+  WIDTH: 1px
+}
+```
+
+<!-- prettier-ignore -->
+```css
+a {
+  BORDER-RADIUS: 5px;
+}
+```
+
+<!-- prettier-ignore -->
+```css
+a {
+  -WEBKIT-ANIMATION-DURATION: 3s;
+}
+```
+
+<!-- prettier-ignore -->
+```css
+@media screen and (orientation: landscape) {
+  WIDTH: 500px;
+}
+```
+
+## Optional secondary options
+
+### `ignoreSelectors: ["/regex/", /regex/, "string"]`
+
+Given:
+
+```json
+[
+  "lower",
+  {
+    "ignoreSelectors": [":export"]
+  }
+]
+```
+
+The following patterns are _not_ considered problems:
+
+<!-- prettier-ignore -->
+```css
+:export {
+  camelCase: value;
+}
+```