pasika 0.3.0 → 0.3.2

package/dist/eslint/pasika/rules/component-nesting.js

@@ -0,0 +1,69 @@
+/**
+ * ESLint rule: pasika/component-nesting
+ *
+ * A component MUST NOT be nested only because it has support files. Nesting is
+ * justified by exclusive child components, so a nested component folder whose
+ * only contents are the component, its index, and support folders must be
+ * flattened.
+ *
+ * @see docs/code-organization-guide/rules/folder-nesting-rule.md
+ */
+import path from "node:path";
+import { getProjectIndex } from "../project/index.js";
+import { segmentsOf } from "../project/ccf.js";
+export const componentNestingRule = {
+    meta: {
+        schema: [],
+        type: "problem",
+        docs: {
+            description: "Require a nested component to have exclusive child components, not only support files.",
+        },
+    },
+    create(context) {
+        const sourceRoot = path.resolve("src");
+        const file = path.resolve(context.filename);
+        const segments = segmentsOf(file, sourceRoot);
+        // A component file directly inside a feature subfolder:
+        // src/features/<feature>/<folder>/<file>
+        if (segments.length !== 4 || segments[0] !== "features")
+            return {};
+        const index = getProjectIndex(sourceRoot);
+        if (!index)
+            return {};
+        const module = index.modules.get(file);
+        if (!module?.exports.some((exp) => exp.kind === "component"))
+            return {};
+        const folder = segments.slice(0, 3);
+        // Another component file in the same folder is an exclusive child and makes
+        // the nesting real; an index barrel does not count.
+        const hasChildComponent = [...index.modules.values()].some((candidate) => {
+            if (candidate.file === file)
+                return false;
+            const candidateSegments = segmentsOf(candidate.file, sourceRoot);
+            if (candidateSegments.length !== 4)
+                return false;
+            if (candidateSegments[0] !== folder[0] ||
+                candidateSegments[1] !== folder[1] ||
+                candidateSegments[2] !== folder[2]) {
+                return false;
+            }
+            if (candidateSegments[3]?.startsWith("index."))
+                return false;
+            return candidate.exports.some((exp) => exp.kind === "component");
+        });
+        if (hasChildComponent)
+            return {};
+        const flatFolder = segments.slice(0, 2).join("/");
+        return {
+            Program(node) {
+                context.report({
+                    node,
+                    loc: { line: 1, column: 0 },
+                    message: `This component is nested in src/${folder.join("/")}/ but its folder has no exclusive ` +
+                        `child components — only support files. Flatten it back into src/${flatFolder}/. ` +
+                        "See docs/code-organization-guide/rules/folder-nesting-rule.md",
+                });
+            },
+        };
+    },
+};

package/dist/eslint/pasika/rules/config-extraction.d.ts

@@ -0,0 +1,14 @@
+/**
+ * ESLint rule: pasika/config-extraction
+ *
+ * A type, schema, or utility used only to implement one configuration module
+ * MUST be extracted even with one consumer. A configuration module is a
+ * src/config/<name>/ folder with index.ts as its entry point, so any type or
+ * schema still declared in a module file that is not a support file belongs in
+ * the module's types/ or schemas/ folder — or, once a consumer outside the
+ * module imports it, in the matching root support folder.
+ *
+ * @see docs/code-organization-guide/rules/configuration-rule.md
+ */
+import type { Rule } from "eslint";
+export declare const configExtractionRule: Rule.RuleModule;

package/dist/eslint/pasika/rules/config-extraction.js

@@ -0,0 +1,74 @@
+/**
+ * ESLint rule: pasika/config-extraction
+ *
+ * A type, schema, or utility used only to implement one configuration module
+ * MUST be extracted even with one consumer. A configuration module is a
+ * src/config/<name>/ folder with index.ts as its entry point, so any type or
+ * schema still declared in a module file that is not a support file belongs in
+ * the module's types/ or schemas/ folder — or, once a consumer outside the
+ * module imports it, in the matching root support folder.
+ *
+ * @see docs/code-organization-guide/rules/configuration-rule.md
+ */
+import path from "node:path";
+import { getProjectIndex, symbolKey } from "../project/index.js";
+import { describeConsumers, segmentsOf, SUPPORT_FOLDERS } from "../project/ccf.js";
+export const configExtractionRule = {
+    meta: {
+        schema: [],
+        type: "problem",
+        docs: {
+            description: "Require config-only types and schemas to be extracted into the module's support folder.",
+        },
+    },
+    create(context) {
+        const sourceRoot = path.resolve("src");
+        const file = path.resolve(context.filename);
+        const segments = segmentsOf(file, sourceRoot);
+        // A configuration module file: src/config/<name>/<file>. Support folders are
+        // already the extraction destination, so they are not candidates.
+        if (segments.length < 3 || segments[0] !== "config")
+            return {};
+        if (SUPPORT_FOLDERS.has(segments[2] ?? ""))
+            return {};
+        const index = getProjectIndex(sourceRoot);
+        if (!index)
+            return {};
+        const module = index.modules.get(file);
+        if (!module)
+            return {};
+        const suspects = module.exports.filter((exp) => exp.kind === "type" || exp.kind === "schema");
+        if (suspects.length === 0)
+            return {};
+        const findings = [];
+        for (const exp of suspects) {
+            const consumers = [...(index.symbolConsumers.get(symbolKey(file, exp.name)) ?? [])];
+            const outsideConfig = consumers.filter((consumer) => segmentsOf(consumer, sourceRoot)[0] !== "config");
+            if (outsideConfig.length > 0) {
+                findings.push({
+                    line: exp.line,
+                    message: `${exp.kind} "${exp.name}" in a configuration module is imported by ` +
+                        `${describeConsumers(outsideConfig, sourceRoot)} outside src/config/. Move it to the ` +
+                        "matching root support folder. See docs/code-organization-guide/rules/configuration-rule.md",
+                });
+            }
+            else if (consumers.length > 0) {
+                findings.push({
+                    line: exp.line,
+                    message: `${exp.kind} "${exp.name}" is used only to implement this configuration module; ` +
+                        `extract it to the module's ${exp.kind === "schema" ? "schemas/" : "types/"} folder even with one consumer. ` +
+                        "See docs/code-organization-guide/rules/configuration-rule.md",
+                });
+            }
+        }
+        if (findings.length === 0)
+            return {};
+        return {
+            Program(node) {
+                for (const finding of findings) {
+                    context.report({ node, loc: { line: finding.line, column: 0 }, message: finding.message });
+                }
+            },
+        };
+    },
+};

package/dist/eslint/pasika/rules/cross-feature-import.d.ts

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

package/dist/eslint/pasika/rules/cross-feature-import.js

@@ -0,0 +1,75 @@
+/**
+ * ESLint rule: pasika/cross-feature-import
+ *
+ * A component that imports from two or more feature folders MUST live in
+ * src/compositions/.
+ *
+ * @see docs/code-organization-guide/rules/component-placement-rule.md
+ */
+import path from "node:path";
+const FEATURES_SEGMENT = "features";
+function featureNameOf(resolvedPath, sourceRoot) {
+    const relative = path.relative(sourceRoot, resolvedPath);
+    if (relative.startsWith(".."))
+        return undefined;
+    const segments = relative.split(path.sep);
+    if (segments[0] !== FEATURES_SEGMENT || segments.length < 2)
+        return undefined;
+    return segments[1];
+}
+export const crossFeatureImportRule = {
+    meta: {
+        schema: [],
+        type: "problem",
+        docs: {
+            description: "Require non-composition files that import from two or more feature folders to live in src/compositions/.",
+        },
+    },
+    create(context) {
+        const filename = context.filename;
+        if (!filename.endsWith(".tsx") && !filename.endsWith(".jsx"))
+            return {};
+        const sourceRoot = path.resolve("src");
+        const fileRelative = path.relative(sourceRoot, filename);
+        if (fileRelative.startsWith(".."))
+            return {};
+        const fileSegments = fileRelative.split(path.sep);
+        const isInCompositions = fileSegments[0] === "compositions";
+        const isInApp = fileSegments[0] === "app";
+        const isConfig = fileSegments[0] === "config";
+        if (isInCompositions || isInApp || isConfig)
+            return {};
+        const importedFeatures = new Set();
+        let alreadyReported = false;
+        return {
+            ImportDeclaration(node) {
+                if (alreadyReported)
+                    return;
+                const source = node.source;
+                if (typeof source.value !== "string")
+                    return;
+                let resolved;
+                if (source.value.startsWith("@/")) {
+                    resolved = path.resolve(sourceRoot, source.value.slice(2));
+                }
+                else if (source.value.startsWith(".")) {
+                    resolved = path.resolve(path.dirname(filename), source.value);
+                }
+                if (!resolved)
+                    return;
+                const feature = featureNameOf(resolved, sourceRoot);
+                if (feature)
+                    importedFeatures.add(feature);
+                if (importedFeatures.size >= 2) {
+                    alreadyReported = true;
+                    const names = [...importedFeatures].sort().join(", ");
+                    context.report({
+                        node,
+                        message: `This component imports from two or more feature folders (${names}) and must live in src/compositions/. ` +
+                            "See docs/code-organization-guide/rules/component-placement-rule.md",
+                    });
+                }
+            },
+        };
+    },
+};

package/dist/eslint/pasika/rules/css/apply-usage.d.ts

@@ -0,0 +1,10 @@
+/**
+ * ESLint rule: pasika/apply-usage
+ *
+ * Style declarations added by the project inside global selectors MUST use
+ * @apply.
+ *
+ * @see docs/styling-guide/rules/global-stylesheet-rule.md
+ */
+import type { CSSRuleDefinition } from "@eslint/css";
+export declare const applyUsageRule: CSSRuleDefinition;

package/dist/eslint/pasika/rules/css/apply-usage.js

@@ -0,0 +1,45 @@
+/**
+ * ESLint rule: pasika/apply-usage
+ *
+ * Style declarations added by the project inside global selectors MUST use
+ * @apply.
+ *
+ * @see docs/styling-guide/rules/global-stylesheet-rule.md
+ */
+import { blockChildren } from "./helpers.js";
+export const applyUsageRule = {
+    meta: {
+        schema: [],
+        type: "problem",
+        docs: {
+            description: "Require @apply for project style declarations inside global selectors.",
+        },
+    },
+    create(context) {
+        return {
+            "StyleSheet:exit"(node) {
+                // Project style declarations inside global selectors are the ones in
+                // @layer base rules. Each rule's declarations must go through @apply,
+                // not raw CSS properties.
+                const layers = node.children.filter((child) => child.type === "Atrule" && child.name === "layer");
+                for (const layer of layers) {
+                    for (const child of blockChildren(layer)) {
+                        if (child.type !== "Rule")
+                            continue;
+                        for (const declaration of blockChildren(child)) {
+                            if (declaration.type !== "Declaration")
+                                continue;
+                            // @apply itself arrives as an Atrule, so a raw Declaration means
+                            // the project wrote a property by hand instead of applying a
+                            // utility.
+                            context.report({
+                                node: declaration,
+                                message: `Style declaration "${declaration.property}" inside a global selector must use @apply.`,
+                            });
+                        }
+                    }
+                }
+            },
+        };
+    },
+};

package/dist/eslint/pasika/rules/css/base-layer-pair.d.ts

@@ -0,0 +1,10 @@
+/**
+ * ESLint rule: pasika/base-layer-pair
+ *
+ * The global base layer MUST apply base-canvas and base-ink to the document
+ * body as the default page pair.
+ *
+ * @see docs/styling-guide/rules/global-stylesheet-rule.md
+ */
+import type { CSSRuleDefinition } from "@eslint/css";
+export declare const baseLayerPairRule: CSSRuleDefinition;

package/dist/eslint/pasika/rules/css/base-layer-pair.js

@@ -0,0 +1,49 @@
+/**
+ * ESLint rule: pasika/base-layer-pair
+ *
+ * The global base layer MUST apply base-canvas and base-ink to the document
+ * body as the default page pair.
+ *
+ * @see docs/styling-guide/rules/global-stylesheet-rule.md
+ */
+import { atrulesNamed, blockChildren, preludeIdentifiers, selectorNames } from "./helpers.js";
+export const baseLayerPairRule = {
+    meta: {
+        schema: [],
+        type: "problem",
+        docs: {
+            description: "Require the base layer to apply base-canvas and base-ink to the body.",
+        },
+    },
+    create(context) {
+        return {
+            "StyleSheet:exit"(node) {
+                const baseLayers = atrulesNamed(node, "layer").filter((layer) => preludeIdentifiers(layer).includes("base"));
+                if (baseLayers.length === 0)
+                    return;
+                const applied = [];
+                for (const layer of baseLayers) {
+                    for (const child of blockChildren(layer)) {
+                        if (child.type !== "Rule")
+                            continue;
+                        if (!selectorNames(child).includes("body"))
+                            continue;
+                        for (const declaration of blockChildren(child)) {
+                            if (declaration.type !== "Atrule" || declaration.name !== "apply")
+                                continue;
+                            applied.push(...preludeIdentifiers(declaration));
+                        }
+                    }
+                }
+                const hasCanvas = applied.some((name) => name.includes("canvas"));
+                const hasInk = applied.some((name) => name.includes("ink"));
+                if (!hasCanvas || !hasInk) {
+                    context.report({
+                        node,
+                        message: "The global base layer must apply a canvas and an ink utility to the document body as the default page pair.",
+                    });
+                }
+            },
+        };
+    },
+};

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

@@ -0,0 +1,10 @@
+/**
+ * ESLint rule: pasika/css-variable-naming
+ *
+ * A CSS variable intended only for a background MUST be named --<role>-canvas,
+ * and one intended only for readable text MUST be named --<role>-ink.
+ *
+ * @see docs/styling-guide/rules/theme-and-utility-definition-rule.md
+ */
+import type { CSSRuleDefinition } from "@eslint/css";
+export declare const cssVariableNamingRule: CSSRuleDefinition;

package/dist/eslint/pasika/rules/css/css-variable-naming.js

@@ -0,0 +1,39 @@
+/**
+ * ESLint rule: pasika/css-variable-naming
+ *
+ * A CSS variable intended only for a background MUST be named --<role>-canvas,
+ * and one intended only for readable text MUST be named --<role>-ink.
+ *
+ * @see docs/styling-guide/rules/theme-and-utility-definition-rule.md
+ */
+export const cssVariableNamingRule = {
+    meta: {
+        schema: [],
+        type: "problem",
+        docs: {
+            description: "Require background variables to end in -canvas and text variables to end in -ink.",
+        },
+    },
+    create(context) {
+        return {
+            Declaration(node) {
+                const property = node.property;
+                if (!property.startsWith("--"))
+                    return;
+                const lower = property.toLowerCase();
+                if ((lower.includes("bg") || lower.includes("background")) && !lower.endsWith("-canvas")) {
+                    context.report({
+                        node,
+                        message: `CSS variable "${property}" looks like a background token; name it --<role>-canvas instead.`,
+                    });
+                }
+                if (lower.includes("text") && !lower.endsWith("-ink")) {
+                    context.report({
+                        node,
+                        message: `CSS variable "${property}" looks like a text token; name it --<role>-ink instead.`,
+                    });
+                }
+            },
+        };
+    },
+};

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

@@ -0,0 +1,11 @@
+/**
+ * ESLint rule: pasika/custom-utility-apply
+ *
+ * A custom utility MUST use @apply for every styling declaration added by the
+ * project. When no named built-in utility represents a property value, it MUST
+ * apply the Tailwind custom-property or arbitrary-property utility instead.
+ *
+ * @see docs/styling-guide/rules/theme-and-utility-definition-rule.md
+ */
+import type { CSSRuleDefinition } from "@eslint/css";
+export declare const customUtilityApplyRule: CSSRuleDefinition;

package/dist/eslint/pasika/rules/css/custom-utility-apply.js

@@ -0,0 +1,52 @@
+/**
+ * ESLint rule: pasika/custom-utility-apply
+ *
+ * A custom utility MUST use @apply for every styling declaration added by the
+ * project. When no named built-in utility represents a property value, it MUST
+ * apply the Tailwind custom-property or arbitrary-property utility instead.
+ *
+ * @see docs/styling-guide/rules/theme-and-utility-definition-rule.md
+ */
+import { atrulesNamed, blockChildren } from "./helpers.js";
+/** The property name when a tolerant-mode `Raw` is actually `property: value`. */
+function rawProperty(raw) {
+    const match = /^\s*(?<property>[a-z][a-z-]*)\s*:/.exec(raw);
+    return match?.groups?.property;
+}
+export const customUtilityApplyRule = {
+    meta: {
+        schema: [],
+        type: "problem",
+        docs: {
+            description: "Require @utility blocks to style through @apply.",
+        },
+    },
+    create(context) {
+        return {
+            "StyleSheet:exit"(node) {
+                for (const utility of atrulesNamed(node, "utility")) {
+                    for (const child of blockChildren(utility)) {
+                        if (child.type === "Atrule" && child.name === "apply")
+                            continue;
+                        if (child.type === "Declaration") {
+                            context.report({
+                                node: child,
+                                message: `Custom utility must use @apply for styling declaration "${child.property}".`,
+                            });
+                            continue;
+                        }
+                        if (child.type === "Raw") {
+                            const property = rawProperty(child.value);
+                            if (property !== undefined) {
+                                context.report({
+                                    node: child,
+                                    message: `Custom utility must use @apply for styling declaration "${property}".`,
+                                });
+                            }
+                        }
+                    }
+                }
+            },
+        };
+    },
+};

package/dist/eslint/pasika/rules/css/global-css-location.d.ts

@@ -0,0 +1,10 @@
+/**
+ * ESLint rule: pasika/global-css-location
+ *
+ * The project's global CSS MUST live in the global stylesheet entry point and
+ * MUST NOT be imported from another file.
+ *
+ * @see docs/styling-guide/rules/global-stylesheet-rule.md
+ */
+import type { CSSRuleDefinition } from "@eslint/css";
+export declare const globalCssLocationRule: CSSRuleDefinition;

package/dist/eslint/pasika/rules/css/global-css-location.js

@@ -0,0 +1,42 @@
+/**
+ * ESLint rule: pasika/global-css-location
+ *
+ * The project's global CSS MUST live in the global stylesheet entry point and
+ * MUST NOT be imported from another file.
+ *
+ * @see docs/styling-guide/rules/global-stylesheet-rule.md
+ */
+export const globalCssLocationRule = {
+    meta: {
+        schema: [],
+        type: "problem",
+        docs: {
+            description: "Require project global CSS to live only in the entry point stylesheet.",
+        },
+    },
+    create(context) {
+        return {
+            "StyleSheet:exit"(node) {
+                // The entry point registers Tailwind. Any other stylesheet with
+                // project CSS — or that imports the entry point — splits global CSS
+                // out of the entry point.
+                const registersTailwind = node.children.some((child) => child.type === "Atrule" && child.name === "import" && JSON.stringify(child.prelude).includes("tailwindcss"));
+                if (registersTailwind)
+                    return;
+                const hasProjectCss = node.children.some((child) => {
+                    if (child.type === "Atrule" && child.name === "import")
+                        return false;
+                    if (child.type === "Comment")
+                        return false;
+                    return true;
+                });
+                if (!hasProjectCss)
+                    return;
+                context.report({
+                    node,
+                    message: "Global CSS must live in the global stylesheet entry point that registers Tailwind, not in this file.",
+                });
+            },
+        };
+    },
+};

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

@@ -0,0 +1,29 @@
+/**
+ * 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.
+ */
+import type { CssNodePlain } from "@eslint/css-tree";
+/** Visits `node` and every descendant, in document order. */
+export declare function walkNodes(node: CssNodePlain, visit: (current: CssNodePlain) => void): void;
+/** Every `Atrule` node in the sheet, in document order. */
+export declare function atrules(node: CssNodePlain): CssNodePlain[];
+/** Every `Atrule` with the given name. */
+export declare function atrulesNamed(node: CssNodePlain, name: string): CssNodePlain[];
+/** The children of a block-bearing node. */
+export declare function blockChildren(node: CssNodePlain | undefined): CssNodePlain[];
+/**
+ * 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 declare function preludeIdentifiers(node: CssNodePlain | undefined): string[];
+/** The text of a `Raw` node, or the empty string. */
+export declare function rawValue(node: CssNodePlain | undefined): string;
+/** Every `Rule` node in the sheet, in document order. */
+export declare function rules(node: CssNodePlain): CssNodePlain[];
+/** The selector names of a rule's prelude, e.g. `root` for `:root`. */
+export declare function selectorNames(node: CssNodePlain | undefined): string[];

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

@@ -0,0 +1,93 @@
+/**
+ * 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

@@ -0,0 +1,13 @@
+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;