@taiga-ui/stylelint-config 0.439.0 → 0.441.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@taiga-ui/stylelint-config",
-    "version": "0.439.0",
+    "version": "0.441.0",
     "description": "Taiga UI stylelint config",
     "keywords": [
         "stylelint",
@@ -33,7 +33,7 @@
     "peerDependencies": {
         "@stylistic/stylelint-config": "^4.0.0",
         "@stylistic/stylelint-plugin": "^5.0.1",
-        "@taiga-ui/browserslist-config": "0.439.0",
+        "@taiga-ui/browserslist-config": "0.441.0",
         "postcss": "^8.5.8",
         "postcss-less": "^6.0.0",
         "stylelint": "^17.5.0",

package/relative-less-import-extension.js

@@ -72,58 +72,56 @@ function splitQueryAndHash(value) {
 }
 
 /** @type {import('stylelint').Rule} */
-const ruleFunction = (primary) => {
-    return (root, result) => {
-        const validOptions = validateOptions(result, ruleName, {
-            actual: primary,
-            possible: [true],
-        });
-
-        if (!validOptions) {
-            return;
-        }
-
-        const expectedExtension = getExpectedExtension(root);
+const ruleFunction = (primary) => (root, result) => {
+    const validOptions = validateOptions(result, ruleName, {
+        actual: primary,
+        possible: [true],
+    });
+
+    if (!validOptions) {
+        return;
+    }
 
-        root.walkAtRules('import', (atRule) => {
-            const params = atRule.params.trim();
+    const expectedExtension = getExpectedExtension(root);
 
-            if (isUrlImport(params)) {
-                return;
-            }
+    root.walkAtRules('import', (atRule) => {
+        const params = atRule.params.trim();
 
-            const match = params.match(/^(['"])([^'"]+)\1(.*)$/);
+        if (isUrlImport(params)) {
+            return;
+        }
 
-            if (!match) {
-                return;
-            }
+        const match = params.match(/^(['"])([^'"]+)\1(.*)$/);
 
-            const [, quote, rawImportPath, tail] = match;
+        if (!match) {
+            return;
+        }
 
-            if (!isLocalImportPath(rawImportPath)) {
-                return;
-            }
+        const [, quote, rawImportPath, tail] = match;
 
-            const {pathname, suffix} = splitQueryAndHash(rawImportPath);
+        if (!isLocalImportPath(rawImportPath)) {
+            return;
+        }
 
-            if (hasKnownStyleExtension(pathname)) {
-                return;
-            }
+        const {pathname, suffix} = splitQueryAndHash(rawImportPath);
 
-            const fixedPath = `${pathname}${expectedExtension}${suffix}`;
-            const fixedParams = `${quote}${fixedPath}${quote}${tail}`;
+        if (hasKnownStyleExtension(pathname)) {
+            return;
+        }
 
-            report({
-                fix: () => {
-                    atRule.params = fixedParams;
-                },
-                message: messages.expected(rawImportPath, fixedPath),
-                node: atRule,
-                result,
-                ruleName,
-            });
+        const fixedPath = `${pathname}${expectedExtension}${suffix}`;
+        const fixedParams = `${quote}${fixedPath}${quote}${tail}`;
+
+        report({
+            fix: () => {
+                atRule.params = fixedParams;
+            },
+            message: messages.expected(rawImportPath, fixedPath),
+            node: atRule,
+            result,
+            ruleName,
         });
-    };
+    });
 };
 
 ruleFunction.ruleName = ruleName;