@alexlit/lint-kit 183.4.0 → 183.6.0

package/packages/config-stylelint/node_modules/stylelint/lib/utils/isInDocument.mjs

@@ -0,0 +1,32 @@
+import { Node } from 'postcss';
+
+import { isDocument } from './typeGuards.mjs';
+
+/**
+ * @param {Node} node
+ * @param {{ inline: boolean }} [options]
+ * @returns {boolean}
+ */
+export default function isInDocument(node, options) {
+	const { inline = false } = options || {};
+	let current = node;
+
+	while (current) {
+		if (isDocument(current)) return true;
+
+		// Check for unofficial 'document' property from parsers like postcss-html
+		if ('document' in current && current.document instanceof Node && isDocument(current.document)) {
+			if (inline && current.source && 'inline' in current.source) {
+				return Boolean(current.source.inline);
+			}
+
+			return true;
+		}
+
+		if (!current.parent) break;
+
+		current = current.parent;
+	}
+
+	return false;
+}

package/packages/config-stylelint/node_modules/stylelint/lib/utils/isKeyframeRule.mjs

@@ -0,0 +1,17 @@
+import { isAtRule } from './typeGuards.mjs';
+
+/**
+ * Check if a rule is a keyframe one
+ *
+ * @param {import('postcss').Rule} rule
+ * @returns {boolean}
+ */
+export default function isKeyframeRule(rule) {
+	const parent = rule.parent;
+
+	if (!parent) {
+		return false;
+	}
+
+	return isAtRule(parent) && parent.name.toLowerCase() === 'keyframes';
+}

package/packages/config-stylelint/node_modules/stylelint/lib/utils/isKeyframeSelector.mjs

@@ -0,0 +1,29 @@
+import { keyframeSelectorKeywords, namedTimelineRangeKeywords } from '../reference/keywords.mjs';
+
+const HAS_TIMELINE_RANGE = new RegExp(
+	`^(?:${[...namedTimelineRangeKeywords.values()].join('|')})\\s+(?:\\d+|\\d*\\.\\d+)%$`,
+	'i',
+);
+
+/**
+ * Check whether a string is a keyframe selector.
+ *
+ * @param {string} selector
+ * @returns {boolean}
+ */
+export default function isKeyframeSelector(selector) {
+	if (keyframeSelectorKeywords.has(selector)) {
+		return true;
+	}
+
+	// Percentages
+	if (/^(?:\d+|\d*\.\d+)%$/.test(selector)) {
+		return true;
+	}
+
+	if (HAS_TIMELINE_RANGE.test(selector)) {
+		return true;
+	}
+
+	return false;
+}

package/packages/config-stylelint/node_modules/stylelint/lib/utils/isMathFunction.mjs

@@ -0,0 +1,11 @@
+import { mathFunctions } from '../reference/functions.mjs';
+
+/**
+ * Check whether a node is math function
+ *
+ * @param {import('postcss-value-parser').Node} node postcss-value-parser node
+ * @returns {boolean} If `true`, the node is math function
+ */
+export default function isMathFunction(node) {
+	return node.type === 'function' && mathFunctions.has(node.value.toLowerCase());
+}

package/packages/config-stylelint/node_modules/stylelint/lib/utils/isNonNegativeInteger.mjs

@@ -0,0 +1,6 @@
+/**
+ * @param {unknown} value
+ */
+export default function isNonNegativeInteger(value) {
+	return Number.isInteger(value) && typeof value === 'number' && value >= 0;
+}

package/packages/config-stylelint/node_modules/stylelint/lib/utils/isNumbery.mjs

@@ -0,0 +1,9 @@
+/**
+ * Check whether it's a number or a number-like string:
+ * i.e. when coerced to a number it == itself.
+ *
+ * @param {string | number} value
+ */
+export default function isNumbery(value) {
+	return value.toString().trim().length !== 0 && Number(value) == value; // eslint-disable-line eqeqeq
+}

package/packages/config-stylelint/node_modules/stylelint/lib/utils/isOnlyWhitespace.mjs

@@ -0,0 +1,17 @@
+import isWhitespace from './isWhitespace.mjs';
+
+/**
+ * Returns a Boolean indicating whether the input string is only whitespace.
+ *
+ * @param {string} input
+ * @returns {boolean}
+ */
+export default function isOnlyWhitespace(input) {
+	for (const element of input) {
+		if (!isWhitespace(element)) {
+			return false;
+		}
+	}
+
+	return true;
+}

package/packages/config-stylelint/node_modules/stylelint/lib/utils/isPathNotFoundError.mjs

@@ -0,0 +1,9 @@
+import { types } from 'node:util';
+
+/**
+ * @param {unknown} error
+ * @returns {error is NodeJS.ErrnoException}
+ */
+export default function isPathNotFoundError(error) {
+	return types.isNativeError(error) && 'code' in error && error.code === 'ENOENT';
+}

package/packages/config-stylelint/node_modules/stylelint/lib/utils/isScssVariable.mjs

@@ -0,0 +1,19 @@
+/**
+ * Check whether a property is SCSS variable
+ *
+ * @param {string} property
+ * @returns {boolean}
+ */
+export default function isScssVariable(property) {
+	// SCSS var (e.g. $var: x), list (e.g. $list: (x)) or map (e.g. $map: (key:value))
+	if (property.startsWith('$')) {
+		return true;
+	}
+
+	// SCSS var within a namespace (e.g. namespace.$var: x)
+	if (property.includes('.$')) {
+		return true;
+	}
+
+	return false;
+}

package/packages/config-stylelint/node_modules/stylelint/lib/utils/isSharedLineComment.mjs

@@ -0,0 +1,53 @@
+import { isComment, isRoot } from './typeGuards.mjs';
+import getNextNonSharedLineCommentNode from './getNextNonSharedLineCommentNode.mjs';
+import getPreviousNonSharedLineCommentNode from './getPreviousNonSharedLineCommentNode.mjs';
+
+/** @typedef {import('postcss').Node} PostcssNode */
+
+/**
+ * @param {PostcssNode | void} a
+ * @param {PostcssNode | void} b
+ */
+function nodesShareLines(a, b) {
+	const endLine = a && a.source && a.source.end && a.source.end.line;
+	const startLine = b && b.source && b.source.start && b.source.start.line;
+
+	return endLine === startLine;
+}
+
+/**
+ * @param {PostcssNode} node
+ * @returns {boolean}
+ */
+export default function isSharedLineComment(node) {
+	if (!isComment(node)) {
+		return false;
+	}
+
+	const previousNonSharedLineCommentNode = getPreviousNonSharedLineCommentNode(node);
+
+	if (nodesShareLines(previousNonSharedLineCommentNode, node)) {
+		return true;
+	}
+
+	const nextNonSharedLineCommentNode = getNextNonSharedLineCommentNode(node);
+
+	if (nextNonSharedLineCommentNode && nodesShareLines(node, nextNonSharedLineCommentNode)) {
+		return true;
+	}
+
+	const parentNode = node.parent;
+
+	// It's a first child and located on the same line as block start
+	if (
+		parentNode !== undefined &&
+		!isRoot(parentNode) &&
+		parentNode.index(node) === 0 &&
+		node.raws.before !== undefined &&
+		!node.raws.before.includes('\n')
+	) {
+		return true;
+	}
+
+	return false;
+}

package/packages/config-stylelint/node_modules/stylelint/lib/utils/isSingleLineString.mjs

@@ -0,0 +1,10 @@
+/**
+ * Check if a string is a single line (i.e. does not contain
+ * any newline characters).
+ *
+ * @param {string} input
+ * @returns {boolean}
+ */
+export default function isSingleLineString(input) {
+	return !/[\n\r]/.test(input);
+}

package/packages/config-stylelint/node_modules/stylelint/lib/utils/isStandardSyntaxAtRule.mjs

@@ -0,0 +1,32 @@
+/**
+ * Check whether a at-rule is standard
+ *
+ * @param {import('postcss').AtRule | import('postcss-less').AtRule} atRule postcss at-rule node
+ * @returns {boolean} If `true`, the declaration is standard
+ */
+export default function isStandardSyntaxAtRule(atRule) {
+	// Ignore `@charset` css rule (is parsed as at-rule)
+	if (atRule.name.toLowerCase() === 'charset') {
+		return false;
+	}
+
+	// Ignore scss `@content` inside mixins
+	if (!atRule.nodes && atRule.params === '') {
+		return false;
+	}
+
+	// Ignore Less mixins
+	if ('mixin' in atRule && atRule.mixin) {
+		return false;
+	}
+
+	// Ignore Less detached ruleset `@detached-ruleset: { background: red; }; .top { @detached-ruleset(); }`
+	if (
+		('variable' in atRule && atRule.variable) ||
+		(!atRule.nodes && atRule.raws.afterName === '' && atRule.params[0] === '(')
+	) {
+		return false;
+	}
+
+	return true;
+}

package/packages/config-stylelint/node_modules/stylelint/lib/utils/isStandardSyntaxColorFunction.mjs

@@ -0,0 +1,24 @@
+import isStandardSyntaxFunction from './isStandardSyntaxFunction.mjs';
+
+/**
+ * Check whether a function is standard syntax color function
+ *
+ * @param {import('postcss-value-parser').FunctionNode} node
+ * @returns {boolean}
+ */
+export default function isStandardSyntaxColorFunction(node) {
+	if (!isStandardSyntaxFunction(node)) return false;
+
+	// scss can accept a #hex, or $var variables and we need to check all nested fn nodes
+	for (const fnNode of node.nodes) {
+		if (fnNode.type === 'function') return isStandardSyntaxColorFunction(fnNode);
+
+		if (
+			fnNode.type === 'word' &&
+			(fnNode.value.startsWith('#') || fnNode.value.startsWith('$') || fnNode.value.includes('.$'))
+		)
+			return false;
+	}
+
+	return true;
+}

package/packages/config-stylelint/node_modules/stylelint/lib/utils/isStandardSyntaxCombinator.mjs

@@ -0,0 +1,32 @@
+/**
+ * Check whether a combinator is standard
+ *
+ * @param {import('postcss-selector-parser').Combinator} node postcss-selector-parser node (of type combinator)
+ * @returns {boolean} If `true`, the combinator is standard
+ */
+export default function isStandardSyntaxCombinator(node) {
+	// if it's not a combinator, then it's not a standard combinator
+	if (node.type !== 'combinator') {
+		return false;
+	}
+
+	// Ignore reference combinators like `/deep/`
+	if (node.value.startsWith('/') || node.value.endsWith('/')) {
+		return false;
+	}
+
+	// ignore the combinators that are the first or last node in their container
+	if (node.parent !== undefined && node.parent !== null) {
+		const parent = node.parent;
+
+		if (node === parent.first) {
+			return false;
+		}
+
+		if (node === parent.last) {
+			return false;
+		}
+	}
+
+	return true;
+}

package/packages/config-stylelint/node_modules/stylelint/lib/utils/isStandardSyntaxComment.mjs

@@ -0,0 +1,13 @@
+/**
+ * @param {import('postcss').Comment} comment
+ * @returns {boolean}
+ */
+export default function isStandardSyntaxComment(comment) {
+	// We check both here because the Sass parser uses `raws.inline` to indicate
+	// inline comments, while the Less parser uses `inline`.
+	if ('inline' in comment) return false;
+
+	if ('inline' in comment.raws) return false;
+
+	return true;
+}

package/packages/config-stylelint/node_modules/stylelint/lib/utils/isStandardSyntaxDeclaration.mjs

@@ -0,0 +1,57 @@
+import { isRule } from './typeGuards.mjs';
+import isScssVariable from './isScssVariable.mjs';
+
+/**
+ * Check whether a declaration is standard
+ *
+ * @param {import('postcss').Declaration | import('postcss-less').Declaration} decl
+ * @returns {boolean}
+ */
+export default function isStandardSyntaxDeclaration(decl) {
+	const prop = decl.prop;
+	const parent = decl.parent;
+
+	// SCSS var; covers map and list declarations
+	if (isScssVariable(prop)) {
+		return false;
+	}
+
+	// Less var (e.g. @var: x), but exclude variable interpolation (e.g. @{var})
+	if (prop[0] === '@' && prop[1] !== '{') {
+		return false;
+	}
+
+	// Less map declaration
+	if (parent && parent.type === 'atrule' && parent.raws.afterName === ':') {
+		return false;
+	}
+
+	// Less map (e.g. #my-map() { myprop: red; })
+	if (
+		parent &&
+		isRule(parent) &&
+		parent.selector &&
+		parent.selector.startsWith('#') &&
+		parent.selector.endsWith('()')
+	) {
+		return false;
+	}
+
+	// Sass nested properties (e.g. border: { style: solid; color: red; })
+	if (
+		parent &&
+		isRule(parent) &&
+		parent.selector &&
+		parent.selector[parent.selector.length - 1] === ':' &&
+		parent.selector.substring(0, 2) !== '--'
+	) {
+		return false;
+	}
+
+	// Less &:extend
+	if ('extend' in decl && decl.extend) {
+		return false;
+	}
+
+	return true;
+}

package/packages/config-stylelint/node_modules/stylelint/lib/utils/isStandardSyntaxFunction.mjs

@@ -0,0 +1,28 @@
+/**
+ * Check whether a function is standard
+ *
+ * @param {import('postcss-value-parser').Node} node
+ * @returns {boolean}
+ */
+export default function isStandardSyntaxFunction(node) {
+	// Function nodes without names are things in parentheses like Sass lists
+	if (!node.value) {
+		return false;
+	}
+
+	if (node.value.startsWith('#{')) {
+		return false;
+	}
+
+	// CSS-in-JS interpolation
+	if (node.value.startsWith('${')) {
+		return false;
+	}
+
+	// CSS-in-JS syntax
+	if (node.value.startsWith('`')) {
+		return false;
+	}
+
+	return true;
+}

package/packages/config-stylelint/node_modules/stylelint/lib/utils/isStandardSyntaxHexColor.mjs

@@ -0,0 +1,14 @@
+/**
+ * Check whether a hex color is standard
+ *
+ * @param {string} hex
+ * @returns {boolean}
+ */
+export default function isStandardSyntaxHexColor(hex) {
+	// Less map usage (e.g. .myclass { color: #colors[somecolor]; })
+	if (hex.includes('[')) {
+		return false;
+	}
+
+	return true;
+}

package/packages/config-stylelint/node_modules/stylelint/lib/utils/isStandardSyntaxKeyframesName.mjs

@@ -0,0 +1,15 @@
+import hasInterpolation from './hasInterpolation.mjs';
+
+/**
+ * Check whether a keyframes name is standard
+ *
+ * @param {string} keyframesName
+ * @returns {boolean}
+ */
+export default function isStandardSyntaxKeyframesName(keyframesName) {
+	if (hasInterpolation(keyframesName)) {
+		return false;
+	}
+
+	return true;
+}

package/packages/config-stylelint/node_modules/stylelint/lib/utils/isStandardSyntaxProperty.mjs

@@ -0,0 +1,32 @@
+import hasInterpolation from './hasInterpolation.mjs';
+import isScssVariable from './isScssVariable.mjs';
+
+/**
+ * Check whether a property is standard
+ *
+ * @param {string} property
+ * @returns {boolean}
+ */
+export default function isStandardSyntaxProperty(property) {
+	// SCSS var
+	if (isScssVariable(property)) {
+		return false;
+	}
+
+	// Less var (e.g. @var: x)
+	if (property.startsWith('@')) {
+		return false;
+	}
+
+	// Less append property value with space (e.g. transform+_: scale(2))
+	if (property.endsWith('+') || property.endsWith('+_')) {
+		return false;
+	}
+
+	// SCSS or Less interpolation
+	if (hasInterpolation(property)) {
+		return false;
+	}
+
+	return true;
+}

package/packages/config-stylelint/node_modules/stylelint/lib/utils/isStandardSyntaxRule.mjs

@@ -0,0 +1,24 @@
+import isStandardSyntaxSelector from './isStandardSyntaxSelector.mjs';
+
+/**
+ * Check whether a Node is a standard rule
+ *
+ * @param {import('postcss').Rule | import('postcss-less').Rule} rule
+ * @returns {boolean}
+ */
+export default function isStandardSyntaxRule(rule) {
+	if (rule.type !== 'rule') {
+		return false;
+	}
+
+	// Ignore Less &:extend rule
+	if ('extend' in rule && rule.extend) {
+		return false;
+	}
+
+	if (!isStandardSyntaxSelector(rule.selector)) {
+		return false;
+	}
+
+	return true;
+}

package/packages/config-stylelint/node_modules/stylelint/lib/utils/isStandardSyntaxSelector.mjs

@@ -0,0 +1,56 @@
+import hasInterpolation from './hasInterpolation.mjs';
+
+/**
+ * Check whether a selector is standard
+ *
+ * @param {string} selector
+ * @returns {boolean}
+ */
+export default function isStandardSyntaxSelector(selector) {
+	// SCSS or Less interpolation
+	if (hasInterpolation(selector)) {
+		return false;
+	}
+
+	// SCSS placeholder selectors
+	if (selector.startsWith('%')) {
+		return false;
+	}
+
+	// SCSS nested properties
+	if (selector.endsWith(':')) {
+		return false;
+	}
+
+	// Less :extend()
+	if (/:extend(?:\(.*?\))?/.test(selector)) {
+		return false;
+	}
+
+	// Less mixin with resolved nested selectors (e.g. .foo().bar or .foo(@a, @b)[bar])
+	if (/\.[\w-]+\(.*\).+/.test(selector)) {
+		return false;
+	}
+
+	// Less non-outputting mixin definition (e.g. .mixin() {})
+	if (selector.endsWith(')') && !selector.includes(':')) {
+		return false;
+	}
+
+	// Less Parametric mixins (e.g. .mixin(@variable: x) {})
+	if (/\(@.*\)$/.test(selector)) {
+		return false;
+	}
+
+	// ERB template tags
+	if (selector.includes('<%') || selector.includes('%>')) {
+		return false;
+	}
+
+	//  SCSS and Less comments
+	if (selector.includes('//')) {
+		return false;
+	}
+
+	return true;
+}

package/packages/config-stylelint/node_modules/stylelint/lib/utils/isStandardSyntaxTypeSelector.mjs

@@ -0,0 +1,56 @@
+import {
+	aNPlusBNotationPseudoClasses,
+	aNPlusBOfSNotationPseudoClasses,
+	linguisticPseudoClasses,
+	shadowTreePseudoElements,
+} from '../reference/selectors.mjs';
+
+/**
+ * Check whether a type selector is standard
+ *
+ * @param {import('postcss-selector-parser').Tag} node postcss-selector-parser node (of type tag)
+ * @returns {boolean} If `true`, the type selector is standard
+ */
+export default function isStandardSyntaxTypeSelector(node) {
+	// postcss-selector-parser includes the arguments to nth-child() functions
+	// as "tags", so we need to ignore them ourselves.
+	// The fake-tag's "parent" is actually a selector node, whose parent
+	// should be the :nth-child pseudo node.
+	if (!node.parent || !node.parent.parent) {
+		return false;
+	}
+
+	const _node$parent$parent = node.parent.parent;
+	const parentType = _node$parent$parent.type;
+	const parentValue = _node$parent$parent.value;
+
+	if (parentValue) {
+		const normalisedParentName = parentValue.toLowerCase().replace(/:+/, '');
+
+		if (
+			parentType === 'pseudo' &&
+			(aNPlusBNotationPseudoClasses.has(normalisedParentName) ||
+				aNPlusBOfSNotationPseudoClasses.has(normalisedParentName) ||
+				linguisticPseudoClasses.has(normalisedParentName) ||
+				shadowTreePseudoElements.has(normalisedParentName))
+		) {
+			return false;
+		}
+	}
+
+	// &-bar is a nesting selector combined with a suffix
+	if (node.prev()?.type === 'nesting') {
+		return false;
+	}
+
+	if (node.value.startsWith('%')) {
+		return false;
+	}
+
+	// Reference combinators like `/deep/`
+	if (node.value.startsWith('/') && node.value.endsWith('/')) {
+		return false;
+	}
+
+	return true;
+}

package/packages/config-stylelint/node_modules/stylelint/lib/utils/isStandardSyntaxUrl.mjs

@@ -0,0 +1,49 @@
+import hasLessInterpolation from './hasLessInterpolation.mjs';
+import hasPsvInterpolation from './hasPsvInterpolation.mjs';
+import hasScssInterpolation from './hasScssInterpolation.mjs';
+import hasTplInterpolation from './hasTplInterpolation.mjs';
+
+const IS_LESS_VARIABLE_IN_URL = /^@@?[\w-]+$/;
+const IS_SCSS_VARIABLE_IN_URL = /^[$\s\w+\-,./*'"@#?]+$/;
+
+/**
+ * Check whether a URL is standard
+ *
+ * @param {string} url
+ * @returns {boolean}
+ */
+export default function isStandardSyntaxUrl(url) {
+	if (url.length === 0) {
+		return true;
+	}
+
+	// Sass interpolation works anywhere
+	if (hasScssInterpolation(url) || hasTplInterpolation(url) || hasPsvInterpolation(url)) {
+		return false;
+	}
+
+	// Inside `'` and `"` work only LESS interpolation
+	if ((url.startsWith(`'`) && url.endsWith(`'`)) || (url.startsWith(`"`) && url.endsWith(`"`))) {
+		if (hasLessInterpolation(url)) {
+			return false;
+		}
+
+		return true;
+	}
+
+	// Less variable works only at the beginning
+	// Check is less variable, allow use '@url/some/path'
+	// https://github.com/less/less.js/blob/3.x/lib/less/parser/parser.js#L547
+	if (url.startsWith('@') && IS_LESS_VARIABLE_IN_URL.test(url)) {
+		return false;
+	}
+
+	// In url without quotes scss variable can be everywhere
+	// But in this case it is allowed to use only specific characters
+	// Also forbidden "/" at the end of url
+	if (url.includes('$') && IS_SCSS_VARIABLE_IN_URL.test(url) && !url.endsWith('/')) {
+		return false;
+	}
+
+	return true;
+}