pasika 0.3.3 → 0.3.4

package/dist/eslint/pasika/rules/css/helpers.js

@@ -1,93 +0,0 @@
-/**
- * Shared AST walkers for the CSS rules.
- *
- * The @eslint/css language parses with css-tree in tolerant mode, so constructs
- * Tailwind v4 extends beyond the CSS grammar — `--*: initial`, arbitrary
- * properties inside `@apply`, nested `@media` inside `@theme` — survive as
- * `Raw` nodes instead of structured ones. Rules therefore walk the plain AST
- * and fall back to raw text when a construct came through unparsed.
- */
-/** Visits `node` and every descendant, in document order. */
-export function walkNodes(node, visit) {
-    visit(node);
-    if ("children" in node && node.children) {
-        for (const child of node.children)
-            walkNodes(child, visit);
-    }
-    if ("prelude" in node && node.prelude) {
-        walkNodes(node.prelude, visit);
-    }
-    if ("block" in node && node.block) {
-        walkNodes(node.block, visit);
-    }
-}
-/** Every `Atrule` node in the sheet, in document order. */
-export function atrules(node) {
-    const result = [];
-    walkNodes(node, (current) => {
-        if (current.type === "Atrule")
-            result.push(current);
-    });
-    return result;
-}
-/** Every `Atrule` with the given name. */
-export function atrulesNamed(node, name) {
-    return atrules(node).filter((candidate) => candidate.type === "Atrule" && candidate.name === name);
-}
-/** The children of a block-bearing node. */
-export function blockChildren(node) {
-    if (!node)
-        return [];
-    if (!("block" in node) || !node.block)
-        return [];
-    return node.block.children;
-}
-/**
- * The names in an at-rule prelude: `Identifier`s (the classes of an `@apply`,
- * the `inline` of `@theme inline`) and `Layer`s (the layers of `@layer base`).
- */
-export function preludeIdentifiers(node) {
-    if (!node)
-        return [];
-    if (!("prelude" in node) || !node.prelude)
-        return [];
-    const names = [];
-    walkNodes(node.prelude, (current) => {
-        if (current.type === "Identifier")
-            names.push(current.name);
-        if (current.type === "Layer")
-            names.push(current.name);
-    });
-    return names;
-}
-/** The text of a `Raw` node, or the empty string. */
-export function rawValue(node) {
-    if (!node)
-        return "";
-    if (node.type === "Raw")
-        return node.value;
-    return "";
-}
-/** Every `Rule` node in the sheet, in document order. */
-export function rules(node) {
-    const result = [];
-    walkNodes(node, (current) => {
-        if (current.type === "Rule")
-            result.push(current);
-    });
-    return result;
-}
-/** The selector names of a rule's prelude, e.g. `root` for `:root`. */
-export function selectorNames(node) {
-    if (!node)
-        return [];
-    if (!("prelude" in node) || !node.prelude)
-        return [];
-    const names = [];
-    walkNodes(node.prelude, (current) => {
-        if (current.type === "PseudoClassSelector" || current.type === "TypeSelector" || current.type === "ClassSelector") {
-            names.push(current.name);
-        }
-    });
-    return names;
-}

package/dist/eslint/pasika/rules/css/index.d.ts

@@ -1,13 +0,0 @@
-export declare const cssRules: {
-    "theme-reset": import("@eslint/css").CSSRuleDefinition;
-    "root-variables": import("@eslint/css").CSSRuleDefinition;
-    "apply-usage": import("@eslint/css").CSSRuleDefinition;
-    "base-layer-pair": import("@eslint/css").CSSRuleDefinition;
-    "stylesheet-ordering": import("@eslint/css").CSSRuleDefinition;
-    "css-variable-naming": import("@eslint/css").CSSRuleDefinition;
-    "custom-utility-apply": import("@eslint/css").CSSRuleDefinition;
-    "surface-utility": import("@eslint/css").CSSRuleDefinition;
-    "theme-variable-namespace": import("@eslint/css").CSSRuleDefinition;
-    "global-css-location": import("@eslint/css").CSSRuleDefinition;
-};
-export type CssRuleName = keyof typeof cssRules;

package/dist/eslint/pasika/rules/css/index.js

@@ -1,25 +0,0 @@
-/**
- * All CSS rules for the global stylesheet checks.
- */
-import { themeResetRule } from "./theme-reset.js";
-import { rootVariablesRule } from "./root-variables.js";
-import { applyUsageRule } from "./apply-usage.js";
-import { baseLayerPairRule } from "./base-layer-pair.js";
-import { stylesheetOrderingRule } from "./stylesheet-ordering.js";
-import { cssVariableNamingRule } from "./css-variable-naming.js";
-import { customUtilityApplyRule } from "./custom-utility-apply.js";
-import { surfaceUtilityRule } from "./surface-utility.js";
-import { themeVariableNamespaceRule } from "./theme-variable-namespace.js";
-import { globalCssLocationRule } from "./global-css-location.js";
-export const cssRules = {
-    "theme-reset": themeResetRule,
-    "root-variables": rootVariablesRule,
-    "apply-usage": applyUsageRule,
-    "base-layer-pair": baseLayerPairRule,
-    "stylesheet-ordering": stylesheetOrderingRule,
-    "css-variable-naming": cssVariableNamingRule,
-    "custom-utility-apply": customUtilityApplyRule,
-    "surface-utility": surfaceUtilityRule,
-    "theme-variable-namespace": themeVariableNamespaceRule,
-    "global-css-location": globalCssLocationRule,
-};

package/dist/eslint/pasika/rules/css/root-variables.d.ts

@@ -1,11 +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 type { CSSRuleDefinition } from "@eslint/css";
-export declare const rootVariablesRule: CSSRuleDefinition;

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;