pasika 0.3.3 → 0.3.4

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

@@ -1,69 +0,0 @@
-/**
- * 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/component-placement.d.ts

@@ -1,11 +0,0 @@
-/**
- * ESLint rule: pasika/component-placement
- *
- * Enforces the placement requirements from the "Component Placement Rule" by
- * reading the whole source tree, because where a component belongs depends on
- * which files import it — something a single-file pass cannot see.
- *
- * @see docs/code-organization-guide/rules/component-placement-rule.md
- */
-import type { Rule } from "eslint";
-export declare const componentPlacementRule: Rule.RuleModule;

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

@@ -1,75 +0,0 @@
-/**
- * ESLint rule: pasika/component-placement
- *
- * Enforces the placement requirements from the "Component Placement Rule" by
- * reading the whole source tree, because where a component belongs depends on
- * which files import it — something a single-file pass cannot see.
- *
- * @see docs/code-organization-guide/rules/component-placement-rule.md
- */
-import path from "node:path";
-import { getProjectIndex } from "../project/index.js";
-import { describeConsumers, folderSegmentsOf, formatFolder, isConfigModule, isUnderApp, resolveComponentPlacement, segmentsOf, } from "../project/ccf.js";
-const REASON_TEXT = {
-    ccf: "that is the closest folder its consumers share",
-    "across-features": "its consumers span more than one feature, and no feature may import from another",
-    "across-layers": "its consumers span more than one layer, so no feature can own it",
-};
-const sameFolder = (left, right) => left.length === right.length && left.every((segment, depth) => segment === right[depth]);
-export const componentPlacementRule = {
-    meta: {
-        schema: [],
-        type: "problem",
-        docs: {
-            description: "Enforce that a component lives in the folder its consumers imply.",
-        },
-    },
-    create(context) {
-        const filename = context.filename;
-        if (!filename.endsWith(".tsx") && !filename.endsWith(".jsx"))
-            return {};
-        const sourceRoot = path.resolve("src");
-        const index = getProjectIndex(sourceRoot);
-        if (!index)
-            return {};
-        const componentFile = path.resolve(filename);
-        const segments = segmentsOf(componentFile, sourceRoot);
-        if (segments.length === 0)
-            return {};
-        // Routing files and configuration modules are not placed by their consumers.
-        if (isUnderApp(segments) || isConfigModule(segments))
-            return {};
-        const module = index.modules.get(componentFile);
-        if (!module?.exports.some((moduleExport) => moduleExport.kind === "component"))
-            return {};
-        const currentFolder = folderSegmentsOf(componentFile, sourceRoot);
-        const placement = resolveComponentPlacement(componentFile, index);
-        return {
-            Program(node) {
-                if (!placement) {
-                    // No consumer counts, so the component belongs to the feature it represents.
-                    if (segments[0] !== "features" || segments.length < 3) {
-                        context.report({
-                            node,
-                            loc: { line: 1, column: 0 },
-                            message: `This component has no consumer outside src/app/ or a configuration module, ` +
-                                `so it belongs in the feature folder it represents, not in ${formatFolder(currentFolder)}. ` +
-                                "See docs/code-organization-guide/rules/component-placement-rule.md",
-                        });
-                    }
-                    return;
-                }
-                if (sameFolder(currentFolder, placement.expectedFolder))
-                    return;
-                const explanation = REASON_TEXT[placement.reason] ?? "that is where its consumers place it";
-                context.report({
-                    node,
-                    loc: { line: 1, column: 0 },
-                    message: `Move this component to ${formatFolder(placement.expectedFolder)} — ${explanation}. ` +
-                        `Imported by ${describeConsumers(placement.countedConsumers, sourceRoot)}. ` +
-                        "See docs/code-organization-guide/rules/component-placement-rule.md",
-                });
-            },
-        };
-    },
-};

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,29 +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.
- */
-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[];