pasika 0.3.2 → 0.3.4

package/dist/eslint/pasika/rules/css/root-variables.js

@@ -1,53 +0,0 @@
-/**
- * ESLint rule: pasika/root-variables
- *
- * Every value used for the project's styling MUST be defined as a CSS variable
- * in :root, and a Tailwind theme variable MUST reference that CSS variable
- * through @theme inline.
- *
- * @see docs/styling-guide/rules/global-stylesheet-rule.md
- */
-import { atrulesNamed, blockChildren, preludeIdentifiers, rules, selectorNames } from "./helpers.js";
-export const rootVariablesRule = {
-    meta: {
-        schema: [],
-        type: "problem",
-        docs: {
-            description: "Require styling values to be CSS variables in :root referenced through @theme inline.",
-        },
-    },
-    create(context) {
-        return {
-            "StyleSheet:exit"(node) {
-                const hasRootVars = rules(node).some((rule) => {
-                    if (!selectorNames(rule).includes("root"))
-                        return false;
-                    return blockChildren(rule).some((child) => child.type === "Declaration");
-                });
-                if (!hasRootVars) {
-                    context.report({
-                        node,
-                        message: "Styling values must be defined as CSS variables in a :root block.",
-                    });
-                }
-                // A Tailwind theme variable that references a CSS variable must go
-                // through @theme inline; a bare @theme block would generate values
-                // instead of referencing the :root variables.
-                const referencingThemes = atrulesNamed(node, "theme").filter((theme) => blockChildren(theme).some((child) => {
-                    if (child.type === "Raw")
-                        return child.value.includes("var(");
-                    if (child.type === "Declaration")
-                        return JSON.stringify(child.value).includes("var(");
-                    return false;
-                }));
-                const inlineThemes = atrulesNamed(node, "theme").filter((theme) => preludeIdentifiers(theme).includes("inline"));
-                if (referencingThemes.length > 0 && inlineThemes.length === 0) {
-                    context.report({
-                        node,
-                        message: "Tailwind theme variables that reference CSS variables must use @theme inline.",
-                    });
-                }
-            },
-        };
-    },
-};

package/dist/eslint/pasika/rules/css/rule-tester.d.ts

@@ -1,11 +0,0 @@
-/**
- * Shared RuleTester wiring for the CSS rule tests.
- *
- * Each `describe` title in a rule test is the exact text of the requirement the
- * case pins, which is how `pasika coverage` verifies that a requirement recorded
- * as lint-enforced has a test behind it.
- */
-import { describe } from "node:test";
-import { RuleTester } from "eslint";
-export declare const cssRuleTester: RuleTester;
-export { describe };

package/dist/eslint/pasika/rules/css/rule-tester.js

@@ -1,22 +0,0 @@
-/**
- * Shared RuleTester wiring for the CSS rule tests.
- *
- * Each `describe` title in a rule test is the exact text of the requirement the
- * case pins, which is how `pasika coverage` verifies that a requirement recorded
- * as lint-enforced has a test behind it.
- */
-import { describe, it } from "node:test";
-import { RuleTester } from "eslint";
-import css from "@eslint/css";
-import { cssRules } from "../../index.js";
-RuleTester.describe = describe;
-RuleTester.it = it;
-export const cssRuleTester = new RuleTester({
-    language: "css/css",
-    languageOptions: { tolerant: true },
-    plugins: {
-        css,
-        pasika: { rules: cssRules },
-    },
-});
-export { describe };

package/dist/eslint/pasika/rules/css/stylesheet-ordering.d.ts

@@ -1,11 +0,0 @@
-/**
- * ESLint rule: pasika/stylesheet-ordering
- *
- * The global stylesheet MUST order imports, @custom-variant definitions, :root
- * variables and the selectors that override them, @theme definitions, custom
- * utilities, base styles, and keyframes in that order.
- *
- * @see docs/styling-guide/rules/global-stylesheet-rule.md
- */
-import type { CSSRuleDefinition } from "@eslint/css";
-export declare const stylesheetOrderingRule: CSSRuleDefinition;

package/dist/eslint/pasika/rules/css/stylesheet-ordering.js

@@ -1,76 +0,0 @@
-/**
- * ESLint rule: pasika/stylesheet-ordering
- *
- * The global stylesheet MUST order imports, @custom-variant definitions, :root
- * variables and the selectors that override them, @theme definitions, custom
- * utilities, base styles, and keyframes in that order.
- *
- * @see docs/styling-guide/rules/global-stylesheet-rule.md
- */
-import { preludeIdentifiers, selectorNames } from "./helpers.js";
-const SECTION_ORDER = ["imports", "custom-variant", "root", "theme", "utility", "base styles", "keyframes"];
-export const stylesheetOrderingRule = {
-    meta: {
-        schema: [],
-        type: "problem",
-        docs: {
-            description: "Require the global stylesheet sections in the documented order.",
-        },
-    },
-    create(context) {
-        return {
-            "StyleSheet:exit"(node) {
-                // Map each top-level child to its section name.
-                const sections = [];
-                let index = 0;
-                for (const child of node.children) {
-                    if (child.type === "Atrule" && child.name === "import") {
-                        sections.push({ name: "imports", at: index });
-                    }
-                    else if (child.type === "Atrule" && child.name === "custom-variant") {
-                        sections.push({ name: "custom-variant", at: index });
-                    }
-                    else if (child.type === "Atrule" && child.name === "theme") {
-                        sections.push({ name: "theme", at: index });
-                    }
-                    else if (child.type === "Atrule" && child.name === "utility") {
-                        sections.push({ name: "utility", at: index });
-                    }
-                    else if (child.type === "Atrule" && child.name === "keyframes") {
-                        sections.push({ name: "keyframes", at: index });
-                    }
-                    else if (child.type === "Atrule" && child.name === "layer") {
-                        if (preludeIdentifiers(child).includes("base")) {
-                            sections.push({ name: "base styles", at: index });
-                        }
-                    }
-                    else if (child.type === "Rule" && selectorNames(child).includes("root")) {
-                        sections.push({ name: "root", at: index });
-                    }
-                    index += 1;
-                }
-                // The first occurrence of each section must not appear after a later
-                // section has already started.
-                const firstAt = new Map();
-                for (const section of sections) {
-                    if (!firstAt.has(section.name))
-                        firstAt.set(section.name, section.at ?? 0);
-                }
-                let lastSeen = -1;
-                for (const name of SECTION_ORDER) {
-                    const at = firstAt.get(name);
-                    if (at === undefined)
-                        continue;
-                    if (at < lastSeen) {
-                        context.report({
-                            node,
-                            message: `Global stylesheet sections must be ordered: imports, @custom-variant, :root, @theme, custom utilities, base styles, keyframes. Found "${name}" before an earlier section.`,
-                        });
-                        return;
-                    }
-                    lastSeen = at;
-                }
-            },
-        };
-    },
-};

package/dist/eslint/pasika/rules/css/surface-utility.d.ts

@@ -1,10 +0,0 @@
-/**
- * ESLint rule: pasika/surface-utility
- *
- * A repeated combination of canvas, ink, and related styles MUST become a
- * *-surface custom Tailwind utility that owns the combination.
- *
- * @see docs/styling-guide/rules/theme-and-utility-definition-rule.md
- */
-import type { CSSRuleDefinition } from "@eslint/css";
-export declare const surfaceUtilityRule: CSSRuleDefinition;

package/dist/eslint/pasika/rules/css/surface-utility.js

@@ -1,41 +0,0 @@
-/**
- * ESLint rule: pasika/surface-utility
- *
- * A repeated combination of canvas, ink, and related styles MUST become a
- * *-surface custom Tailwind utility that owns the combination.
- *
- * @see docs/styling-guide/rules/theme-and-utility-definition-rule.md
- */
-import { atrulesNamed, preludeIdentifiers } from "./helpers.js";
-export const surfaceUtilityRule = {
-    meta: {
-        schema: [],
-        type: "problem",
-        docs: {
-            description: "Require repeated canvas+ink combinations to become a *-surface utility.",
-        },
-    },
-    create(context) {
-        return {
-            "StyleSheet:exit"(node) {
-                const combinations = new Map();
-                for (const apply of atrulesNamed(node, "apply")) {
-                    const classes = preludeIdentifiers(apply);
-                    if (!classes.some((name) => name.includes("canvas")) || !classes.some((name) => name.includes("ink"))) {
-                        continue;
-                    }
-                    const key = [...classes].sort().join(" ");
-                    combinations.set(key, (combinations.get(key) ?? 0) + 1);
-                }
-                for (const [combo, count] of combinations) {
-                    if (count < 2)
-                        continue;
-                    context.report({
-                        node,
-                        message: `Combination "${combo}" appears ${String(count)} times. Create a *-surface custom Tailwind utility for it.`,
-                    });
-                }
-            },
-        };
-    },
-};

package/dist/eslint/pasika/rules/css/theme-reset.d.ts

@@ -1,9 +0,0 @@
-/**
- * ESLint rule: pasika/theme-reset
- *
- * The global stylesheet MUST reset Tailwind's default theme with `--*: initial`.
- *
- * @see docs/styling-guide/rules/global-stylesheet-rule.md
- */
-import type { CSSRuleDefinition } from "@eslint/css";
-export declare const themeResetRule: CSSRuleDefinition;

package/dist/eslint/pasika/rules/css/theme-reset.js

@@ -1,36 +0,0 @@
-/**
- * ESLint rule: pasika/theme-reset
- *
- * The global stylesheet MUST reset Tailwind's default theme with `--*: initial`.
- *
- * @see docs/styling-guide/rules/global-stylesheet-rule.md
- */
-import { atrulesNamed, blockChildren } from "./helpers.js";
-export const themeResetRule = {
-    meta: {
-        schema: [],
-        type: "problem",
-        docs: {
-            description: "Require Tailwind's default theme reset --*: initial.",
-        },
-    },
-    create(context) {
-        return {
-            "StyleSheet:exit"(node) {
-                const resetFound = atrulesNamed(node, "theme").some((theme) => blockChildren(theme).some((child) => {
-                    if (child.type === "Declaration")
-                        return child.property.startsWith("--*");
-                    if (child.type === "Raw")
-                        return child.value.includes("--*: initial");
-                    return false;
-                }));
-                if (!resetFound) {
-                    context.report({
-                        node,
-                        message: "The global stylesheet must reset Tailwind's default theme with --*: initial inside an @theme block.",
-                    });
-                }
-            },
-        };
-    },
-};

package/dist/eslint/pasika/rules/css/theme-variable-namespace.d.ts

@@ -1,11 +0,0 @@
-/**
- * ESLint rule: pasika/theme-variable-namespace
- *
- * A value that needs at least two utility classes from the same Tailwind
- * theme-variable namespace MUST use that namespace and have the same name in
- * :root.
- *
- * @see docs/styling-guide/rules/theme-and-utility-definition-rule.md
- */
-import type { CSSRuleDefinition } from "@eslint/css";
-export declare const themeVariableNamespaceRule: CSSRuleDefinition;

package/dist/eslint/pasika/rules/css/theme-variable-namespace.js

@@ -1,53 +0,0 @@
-/**
- * ESLint rule: pasika/theme-variable-namespace
- *
- * A value that needs at least two utility classes from the same Tailwind
- * theme-variable namespace MUST use that namespace and have the same name in
- * :root.
- *
- * @see docs/styling-guide/rules/theme-and-utility-definition-rule.md
- */
-import { atrulesNamed, blockChildren, preludeIdentifiers } from "./helpers.js";
-export const themeVariableNamespaceRule = {
-    meta: {
-        schema: [],
-        type: "problem",
-        docs: {
-            description: "Require utility classes from the same theme namespace to share a prefix.",
-        },
-    },
-    create(context) {
-        return {
-            "StyleSheet:exit"(node) {
-                // Namespaces are the first segment of each theme variable name, e.g.
-                // --color-* defines the `color` namespace.
-                const namespaces = new Set();
-                for (const theme of atrulesNamed(node, "theme")) {
-                    for (const child of blockChildren(theme)) {
-                        if (child.type !== "Declaration")
-                            continue;
-                        const segments = child.property.replace(/^--/, "").split("-");
-                        if (segments[0])
-                            namespaces.add(segments[0]);
-                    }
-                }
-                for (const apply of atrulesNamed(node, "apply")) {
-                    const classes = preludeIdentifiers(apply);
-                    for (const ns of namespaces) {
-                        const matching = classes.filter((name) => name.startsWith(`${ns}-`) || name === ns);
-                        if (matching.length < 2)
-                            continue;
-                        // All classes from one namespace must share a deeper prefix.
-                        const prefixes = matching.map((name) => name.split("-").slice(0, 2).join("-"));
-                        if (new Set(prefixes).size > 1) {
-                            context.report({
-                                node: apply,
-                                message: `Utility classes ${matching.join(", ")} use namespace "${ns}" but lack a shared prefix; use the theme-variable namespace prefix.`,
-                            });
-                        }
-                    }
-                }
-            },
-        };
-    },
-};

package/dist/eslint/pasika/rules/cva-appearance-props.d.ts

@@ -1,10 +0,0 @@
-/**
- * ESLint rule: pasika/cva-appearance-props
- *
- * Enforces that components exposing visual option props (size, variant, etc.)
- * define them via a cva() call rather than raw union types.
- *
- * @see docs/styling-guide/rules/component-variant-rule.md
- */
-import type { Rule } from "eslint";
-export declare const cvaAppearancePropsRule: Rule.RuleModule;

package/dist/eslint/pasika/rules/cva-appearance-props.js

@@ -1,77 +0,0 @@
-/**
- * ESLint rule: pasika/cva-appearance-props
- *
- * Enforces that components exposing visual option props (size, variant, etc.)
- * define them via a cva() call rather than raw union types.
- *
- * @see docs/styling-guide/rules/component-variant-rule.md
- */
-const VISUAL_OPTION_NAMES = new Set([
-    "size",
-    "variant",
-    "tone",
-    "color",
-    "appearance",
-    "intent",
-    "style",
-    "scheme",
-    "theme",
-]);
-function hasCvaCall(body) {
-    for (const stmt of body) {
-        if (stmt.type !== "VariableDeclaration")
-            continue;
-        for (const decl of stmt.declarations) {
-            const init = decl.init;
-            if (init?.type === "CallExpression" && init.callee.type === "Identifier" && init.callee.name === "cva") {
-                return true;
-            }
-        }
-    }
-    return false;
-}
-export const cvaAppearancePropsRule = {
-    meta: {
-        schema: [],
-        type: "problem",
-        docs: {
-            description: "Components with visual option props must define them using cva.",
-        },
-    },
-    create(context) {
-        const program = context.sourceCode.ast;
-        const hasCva = hasCvaCall(program.body);
-        // If cva is used anywhere in the file, all visual option props are assumed
-        // to be handled by that definition. This avoids false positives when the
-        // cva call and the component are in different scopes.
-        if (hasCva)
-            return {};
-        return {
-            TSTypeAliasDeclaration(node) {
-                if (node.id?.type !== "Identifier" || !node.id.name?.endsWith("Props"))
-                    return;
-                if (node.typeAnnotation?.type !== "TSTypeLiteral")
-                    return;
-                for (const member of node.typeAnnotation.members ?? []) {
-                    if (member.type !== "TSPropertySignature")
-                        continue;
-                    const keyName = member.key?.type === "Identifier" ? member.key.name : undefined;
-                    if (!keyName || !VISUAL_OPTION_NAMES.has(keyName))
-                        continue;
-                    // Only flag union types (string literal unions like "sm" | "lg")
-                    const typeAnnotation = member.typeAnnotation?.typeAnnotation ?? member.typeAnnotation;
-                    if (!typeAnnotation)
-                        continue;
-                    // Accept both TSUnionType and TSTypeLiteral
-                    if (typeAnnotation.type === "TSUnionType" || typeAnnotation.type === "TSTypeLiteral") {
-                        context.report({
-                            node,
-                            message: `Visual option prop "${keyName}" must be defined through a cva() call ` +
-                                "rather than a manual union type. See docs/styling-guide/rules/component-variant-rule.md",
-                        });
-                    }
-                }
-            },
-        };
-    },
-};

package/dist/eslint/pasika/rules/cva-boolean-variants.d.ts

@@ -1,11 +0,0 @@
-/**
- * ESLint rule: pasika/cva-boolean-variants
- *
- * Enforces correct placement of boolean appearance props:
- * - If a boolean variant appears in both CVA and cn(), report it —
- *   it belongs in exactly one place.
- *
- * @see docs/styling-guide/rules/component-variant-rule.md
- */
-import type { Rule } from "eslint";
-export declare const cvaBooleanVariantsRule: Rule.RuleModule;

package/dist/eslint/pasika/rules/cva-boolean-variants.js

@@ -1,97 +0,0 @@
-/**
- * ESLint rule: pasika/cva-boolean-variants
- *
- * Enforces correct placement of boolean appearance props:
- * - If a boolean variant appears in both CVA and cn(), report it —
- *   it belongs in exactly one place.
- *
- * @see docs/styling-guide/rules/component-variant-rule.md
- */
-function extractCvaInfo(node) {
-    if (node.callee.type !== "Identifier" || node.callee.name !== "cva") {
-        return undefined;
-    }
-    const variantNames = new Set();
-    const compoundVariants = new Set();
-    const options = node.arguments[1];
-    if (options?.type !== "ObjectExpression")
-        return { variantNames, compoundVariants };
-    for (const prop of options.properties) {
-        if (prop.type !== "Property")
-            continue;
-        const keyName = prop.key.type === "Identifier" ? prop.key.name : undefined;
-        if (keyName === "variants" && prop.value.type === "ObjectExpression") {
-            for (const vProp of prop.value.properties) {
-                if (vProp.type !== "Property")
-                    continue;
-                const vName = vProp.key.type === "Identifier" ? vProp.key.name : undefined;
-                if (vName)
-                    variantNames.add(vName);
-            }
-        }
-        if (keyName === "compoundVariants" && prop.value.type === "ArrayExpression") {
-            for (const entry of prop.value.elements) {
-                if (entry?.type !== "ObjectExpression")
-                    continue;
-                for (const cvProp of entry.properties) {
-                    if (cvProp.type !== "Property")
-                        continue;
-                    const cvName = cvProp.key.type === "Identifier" ? cvProp.key.name : undefined;
-                    if (cvName && variantNames.has(cvName)) {
-                        compoundVariants.add(cvName);
-                    }
-                }
-            }
-        }
-    }
-    return { variantNames, compoundVariants };
-}
-export const cvaBooleanVariantsRule = {
-    meta: {
-        schema: [],
-        type: "problem",
-        docs: {
-            description: "Enforce correct boolean variant placement between CVA and cn().",
-        },
-    },
-    create(context) {
-        const cvaInfos = [];
-        return {
-            // Collect all cva() calls in the file
-            CallExpression(node) {
-                const info = extractCvaInfo(node);
-                if (info)
-                    cvaInfos.push(info);
-            },
-            // Detect boolean && "class" patterns anywhere inside a className attribute
-            "JSXAttribute[name.name='className'] LogicalExpression[operator='&&']"(node) {
-                if (cvaInfos.length === 0)
-                    return;
-                if (node.type !== "LogicalExpression")
-                    return;
-                const left = node.left;
-                const right = node.right;
-                // Right side should be a string literal (class name)
-                if (right.type !== "Literal" || typeof right.value !== "string") {
-                    return;
-                }
-                // Left side should be an identifier (boolean prop)
-                if (left.type !== "Identifier")
-                    return;
-                const propName = left.name;
-                // Check if this prop is also a CVA variant
-                for (const info of cvaInfos) {
-                    if (info.variantNames.has(propName)) {
-                        context.report({
-                            node,
-                            message: `Boolean prop "${propName}" is used as a standalone conditional in cn() ` +
-                                "but is also defined as a CVA variant. Move it to one place: " +
-                                "either CVA (with both true/false treatments) or cn() (standalone). " +
-                                "See docs/styling-guide/rules/component-variant-rule.md",
-                        });
-                    }
-                }
-            },
-        };
-    },
-};

package/dist/eslint/pasika/rules/data-testid-case.d.ts

@@ -1,2 +0,0 @@
-import type { Rule } from "eslint";
-export declare const dataTestIdCaseRule: Rule.RuleModule;

package/dist/eslint/pasika/rules/data-testid-case.js

@@ -1,76 +0,0 @@
-/**
- * ESLint rule: pasika/data-testid-case
- *
- * Enforces data-testid casing for components whose rendered result has one
- * statically identifiable intrinsic root. Components with multiple or dynamic
- * roots are intentionally left alone, matching the documented exemption.
- *
- * @see docs/code-organization-guide/rules/smart-vs-dumb-component-rule.md
- */
-import path from "node:path";
-import { findSimpleRoot, getTestId, parseComponentInfo } from "./component-conventions.js";
-const NEXT_ROUTING_FILES = new Set([
-    "page",
-    "layout",
-    "loading",
-    "error",
-    "not-found",
-    "route",
-    "template",
-    "default",
-    "middleware",
-    "instrumentation",
-]);
-const isPascalCase = (value) => /^[A-Z][A-Za-z0-9]*$/.test(value);
-const isKebabCase = (value) => /^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/.test(value);
-export const dataTestIdCaseRule = {
-    meta: {
-        schema: [],
-        type: "problem",
-        docs: {
-            description: "Enforce data-testid casing for smart and dumb components with a single intrinsic root.",
-        },
-    },
-    create(context) {
-        const filename = path.resolve(context.filename);
-        if (!filename.endsWith(".tsx"))
-            return {};
-        const base = path.basename(filename, path.extname(filename));
-        if (NEXT_ROUTING_FILES.has(base))
-            return {};
-        const text = context.sourceCode.text;
-        const components = parseComponentInfo(text, filename);
-        return {
-            Program(node) {
-                for (const component of components) {
-                    const root = findSimpleRoot(component, text, filename);
-                    if (!root)
-                        continue;
-                    const { value } = getTestId(root);
-                    const expected = component.smart ? component.name : toKebabCase(component.name);
-                    if (component.smart && value === undefined) {
-                        context.report({
-                            node,
-                            message: `Smart component "${component.name}" with one outer DOM element must set data-testid="${expected}".`,
-                        });
-                        continue;
-                    }
-                    if (value === undefined || value === expected)
-                        continue;
-                    if (component.smart ? !isPascalCase(value) || value !== expected : !isKebabCase(value)) {
-                        context.report({
-                            node,
-                            message: `data-testid for ${component.smart ? "smart" : "dumb"} component "${component.name}" must be ${component.smart ? "PascalCase" : "kebab-case"}: expected "${expected}".`,
-                        });
-                    }
-                }
-            },
-        };
-    },
-};
-function toKebabCase(value) {
-    return value
-        .replace(/(?<lower>[a-z0-9])(?<upper>[A-Z])/g, "$<lower>-$<upper>")
-        .replace(/(?<first>[A-Z])(?<rest>[A-Z][a-z])/g, "$<first>-$<rest>")
-        .toLowerCase();
-}

package/dist/eslint/pasika/rules/enforce-barrel-exports.d.ts

@@ -1,9 +0,0 @@
-/**
- * ESLint rule: pasika/enforce-barrel-exports
- *
- * Enforces the "Folder Nesting Rule" — index.ts only re-exports parent component.
- *
- * @see docs/code-organization-guide/rules/folder-nesting-rule.md
- */
-import type { Rule } from "eslint";
-export declare const enforceBarrelExportsRule: Rule.RuleModule;