pasika 0.2.0 → 0.3.0

package/dist/eslint/pasika/rules/no-arbitrary-tailwind.js

@@ -16,6 +16,7 @@
  * the lookahead exclusion.
  */
 const ARBITRARY_VALUE_RE = /(?:^|(?<=\s))(?:[a-z]+(?:-[a-z]+)*)-\[[^\]]+\](?![-\w]*:)/g;
+const CLASS_HELPERS = new Set(["cn", "clsx", "twMerge", "twJoin"]);
 export const noArbitraryTailwindRule = {
     meta: {
         schema: [],
@@ -25,83 +26,72 @@ export const noArbitraryTailwindRule = {
         },
     },
     create(context) {
-        function checkQuasis(node, quasis) {
-            for (const quasi of quasis) {
-                ARBITRARY_VALUE_RE.lastIndex = 0;
-                const match = ARBITRARY_VALUE_RE.exec(quasi.value.raw);
-                if (match) {
-                    context.report({
-                        node,
-                        message: `Tailwind arbitrary-value class "${match[0]}" is not allowed. ` +
-                            "Use a named token or custom utility. " +
-                            "See docs/styling-guide/rules/arbitrary-value-rule.md",
-                    });
+        function reportClassString(node, value) {
+            ARBITRARY_VALUE_RE.lastIndex = 0;
+            const match = ARBITRARY_VALUE_RE.exec(value);
+            if (!match)
+                return;
+            context.report({
+                node,
+                message: `Tailwind arbitrary-value class "${match[0]}" is not allowed. ` +
+                    "Use a named token or custom utility. " +
+                    "See docs/styling-guide/rules/arbitrary-value-rule.md",
+            });
+        }
+        /** Walks every expression a class name can hide in: conditionals, arrays, and object keys. */
+        function checkExpression(node, expression) {
+            if (!expression)
+                return;
+            if (expression.type === "Literal") {
+                if (typeof expression.value === "string")
+                    reportClassString(node, expression.value);
+                return;
+            }
+            if (expression.type === "TemplateLiteral") {
+                for (const quasi of expression.quasis)
+                    reportClassString(node, quasi.value.raw);
+                return;
+            }
+            if (expression.type === "LogicalExpression") {
+                checkExpression(node, expression.left);
+                checkExpression(node, expression.right);
+                return;
+            }
+            if (expression.type === "ConditionalExpression") {
+                checkExpression(node, expression.consequent);
+                checkExpression(node, expression.alternate);
+                return;
+            }
+            if (expression.type === "ArrayExpression") {
+                for (const element of expression.elements)
+                    checkExpression(node, element);
+                return;
+            }
+            if (expression.type === "ObjectExpression") {
+                // clsx and cn accept `{ "px-[3px]": isActive }`, so the keys carry classes.
+                for (const property of expression.properties) {
+                    if (property.type === "Property")
+                        checkExpression(node, property.key);
                 }
             }
         }
         return {
             JSXAttribute(node) {
-                if (node.name.name !== "className" && node.name.name !== "class")
+                const attributeName = node.name?.name;
+                if (attributeName !== "className" && attributeName !== "class")
                     return;
-                const valueNode = node.value;
-                if (!valueNode)
+                const value = node.value;
+                if (!value)
                     return;
-                if (valueNode.type === "Literal" && typeof valueNode.value === "string") {
-                    ARBITRARY_VALUE_RE.lastIndex = 0;
-                    const match = ARBITRARY_VALUE_RE.exec(valueNode.value);
-                    if (match) {
-                        context.report({
-                            node,
-                            message: `Tailwind arbitrary-value class "${match[0]}" is not allowed. ` +
-                                "Use a named token or custom utility. " +
-                                "See docs/styling-guide/rules/arbitrary-value-rule.md",
-                        });
-                    }
-                }
-                else if (valueNode.type === "JSXExpressionContainer" && valueNode.expression) {
-                    const expr = valueNode.expression;
-                    if (expr.type === "Literal" && typeof expr.value === "string") {
-                        ARBITRARY_VALUE_RE.lastIndex = 0;
-                        const match = ARBITRARY_VALUE_RE.exec(expr.value);
-                        if (match) {
-                            context.report({
-                                node,
-                                message: `Tailwind arbitrary-value class "${match[0]}" is not allowed. ` +
-                                    "Use a named token or custom utility. " +
-                                    "See docs/styling-guide/rules/arbitrary-value-rule.md",
-                            });
-                        }
-                    }
-                    else if (expr.type === "TemplateLiteral") {
-                        checkQuasis(node, expr.quasis);
-                    }
-                }
+                checkExpression(node, value.type === "JSXExpressionContainer" ? value.expression : value);
             },
             CallExpression(node) {
-                if (node.callee.type !== "Identifier")
-                    return;
-                const calleeName = node.callee.name;
-                if (calleeName !== "cn" && calleeName !== "clsx" && calleeName !== "twMerge" && calleeName !== "twJoin")
+                if (node.callee.type !== "Identifier" || !CLASS_HELPERS.has(node.callee.name))
                     return;
-                for (const arg of node.arguments) {
-                    if (arg.type === "Literal" && typeof arg.value === "string") {
-                        ARBITRARY_VALUE_RE.lastIndex = 0;
-                        const match = ARBITRARY_VALUE_RE.exec(arg.value);
-                        if (match) {
-                            context.report({
-                                node,
-                                message: `Tailwind arbitrary-value class "${match[0]}" is not allowed. ` +
-                                    "Use a named token or custom utility. " +
-                                    "See docs/styling-guide/rules/arbitrary-value-rule.md",
-                            });
-                        }
-                    }
-                    else if (arg.type === "TemplateLiteral") {
-                        checkQuasis(node, arg.quasis);
-                    }
+                for (const argument of node.arguments) {
+                    checkExpression(node, argument);
                 }
             },
         };
     },
 };
-/* eslint-enable  -- re-enable rules disabled for AST access @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-argument */

package/dist/eslint/pasika/rules/support-file-placement.d.ts

@@ -0,0 +1,15 @@
+/**
+ * ESLint rule: pasika/support-file-placement
+ *
+ * Enforces where a hook, type, schema, constant, or utility lives, which depends
+ * on the files that import it and so cannot be decided from one file.
+ *
+ * @see docs/code-organization-guide/rules/types-and-schemas-rule.md
+ * @see docs/code-organization-guide/rules/constants-rule.md
+ * @see docs/code-organization-guide/rules/utilities-rule.md
+ * @see docs/code-organization-guide/rules/hook-extraction-rule.md
+ * @see docs/code-organization-guide/rules/configuration-rule.md
+ * @see docs/code-organization-guide/rules/folder-nesting-rule.md
+ */
+import type { Rule } from "eslint";
+export declare const supportFilePlacementRule: Rule.RuleModule;

package/dist/eslint/pasika/rules/support-file-placement.js

@@ -0,0 +1,70 @@
+/**
+ * ESLint rule: pasika/support-file-placement
+ *
+ * Enforces where a hook, type, schema, constant, or utility lives, which depends
+ * on the files that import it and so cannot be decided from one file.
+ *
+ * @see docs/code-organization-guide/rules/types-and-schemas-rule.md
+ * @see docs/code-organization-guide/rules/constants-rule.md
+ * @see docs/code-organization-guide/rules/utilities-rule.md
+ * @see docs/code-organization-guide/rules/hook-extraction-rule.md
+ * @see docs/code-organization-guide/rules/configuration-rule.md
+ * @see docs/code-organization-guide/rules/folder-nesting-rule.md
+ */
+import path from "node:path";
+import { getProjectIndex } from "../project/index.js";
+import { describeConsumers, folderSegmentsOf, formatFolder, isConfigModule, resolveSupportPlacement, segmentsOf, SUPPORT_FOLDERS, } from "../project/ccf.js";
+/**
+ * Support folders a configuration module keeps regardless of who imports them: a
+ * constant or type whose meaning is derived from the configuration stays beside
+ * it even when consumers exist outside the module.
+ */
+const CONFIG_OWNED_FOLDERS = new Set(["types", "constants"]);
+const REASON_TEXT = {
+    "app-consumer": "a file under src/app/ imports it, so it belongs to the app-wide support folder",
+    "config-module": "every file that imports it belongs to that configuration module",
+    ccf: "that is the closest folder its consumers share",
+    "across-features": "its consumers span more than one feature, so no feature can own it",
+    "across-layers": "its consumers span more than one layer, so no layer can own it",
+};
+const sameFolder = (left, right) => left.length === right.length && left.every((segment, depth) => segment === right[depth]);
+export const supportFilePlacementRule = {
+    meta: {
+        schema: [],
+        type: "problem",
+        docs: {
+            description: "Enforce that a support file lives in the folder its consumers imply.",
+        },
+    },
+    create(context) {
+        const sourceRoot = path.resolve("src");
+        const supportFile = path.resolve(context.filename);
+        const currentFolder = folderSegmentsOf(supportFile, sourceRoot);
+        const supportFolder = currentFolder[currentFolder.length - 1];
+        // Only a file already inside a support folder is placed by this rule; a
+        // declaration still sitting beside its consumer is an extraction question.
+        if (supportFolder === undefined || !SUPPORT_FOLDERS.has(supportFolder))
+            return {};
+        // A type or constant whose meaning comes from a configuration may stay with
+        // it however widely it is used, so its consumers cannot place it.
+        if (isConfigModule(segmentsOf(supportFile, sourceRoot)) && CONFIG_OWNED_FOLDERS.has(supportFolder))
+            return {};
+        const index = getProjectIndex(sourceRoot);
+        if (!index)
+            return {};
+        const placement = resolveSupportPlacement(supportFile, supportFolder, index);
+        if (!placement || sameFolder(currentFolder, placement.expectedFolder))
+            return {};
+        return {
+            Program(node) {
+                context.report({
+                    node,
+                    loc: { line: 1, column: 0 },
+                    message: `Move this file to ${formatFolder(placement.expectedFolder)} — ` +
+                        `${REASON_TEXT[placement.reason] ?? "that is where its consumers place it"}. ` +
+                        `Imported by ${describeConsumers(placement.countedConsumers, sourceRoot)}.`,
+                });
+            },
+        };
+    },
+};