pasika 0.3.3 → 0.3.4

package/dist/eslint/pasika/project/index.js

@@ -1,139 +0,0 @@
-import { readdirSync, statSync } from "node:fs";
-import path from "node:path";
-import { parseModule } from "./parse-module.js";
-const MODULE_EXTENSIONS = [".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs"];
-const INDEX_BASENAMES = ["index.ts", "index.tsx", "index.mts", "index.cts", "index.js", "index.jsx"];
-/**
- * How long a built index is trusted before its inputs are re-checked. A long
- * lived ESLint server keeps this module in memory across edits, so the index has
- * to notice a changed tree without re-reading it on every single file.
- */
-const REVALIDATE_AFTER_MS = 2000;
-export const symbolKey = (file, name) => `${file}\u0000${name}`;
-function listSourceFiles(dir) {
-    let entries;
-    try {
-        entries = readdirSync(dir);
-    }
-    catch {
-        return [];
-    }
-    return entries.flatMap((entry) => {
-        if (entry.startsWith(".") || entry === "node_modules")
-            return [];
-        const entryPath = path.join(dir, entry);
-        let stats;
-        try {
-            stats = statSync(entryPath);
-        }
-        catch {
-            return [];
-        }
-        if (stats.isDirectory())
-            return listSourceFiles(entryPath);
-        return MODULE_EXTENSIONS.includes(path.extname(entry)) ? [entryPath] : [];
-    });
-}
-/** Cheap fingerprint of the tree, so an unchanged tree is never re-parsed. */
-function fingerprint(files) {
-    let total = 0;
-    for (const file of files) {
-        try {
-            total += statSync(file).mtimeMs;
-        }
-        catch {
-            /* A file removed between listing and stat just drops out of the fingerprint. */
-        }
-    }
-    return `${String(files.length)}:${String(total)}`;
-}
-/** Resolves an import specifier to a file inside the source tree, if it points at one. */
-export function resolveSpecifier(fromFile, specifier, sourceRoot) {
-    let base;
-    if (specifier.startsWith("@/")) {
-        base = path.resolve(sourceRoot, specifier.slice(2));
-    }
-    else if (specifier.startsWith(".")) {
-        base = path.resolve(path.dirname(fromFile), specifier);
-    }
-    else {
-        return undefined;
-    }
-    const candidates = [
-        base,
-        ...MODULE_EXTENSIONS.map((extension) => `${base}${extension}`),
-        ...INDEX_BASENAMES.map((name) => path.join(base, name)),
-    ];
-    for (const candidate of candidates) {
-        try {
-            if (statSync(candidate).isFile())
-                return candidate;
-        }
-        catch {
-            /* Try the next candidate. */
-        }
-    }
-    return undefined;
-}
-function build(sourceRoot, files) {
-    const modules = new Map();
-    const consumers = new Map();
-    const symbolConsumers = new Map();
-    for (const file of files) {
-        try {
-            modules.set(file, parseModule(file));
-        }
-        catch {
-            /* A file that cannot be read or parsed contributes nothing to the graph. */
-        }
-    }
-    for (const [file, module] of modules) {
-        for (const moduleImport of module.imports) {
-            const target = resolveSpecifier(file, moduleImport.specifier, sourceRoot);
-            if (!target || !modules.has(target))
-                continue;
-            const fileConsumers = consumers.get(target) ?? new Set();
-            fileConsumers.add(file);
-            consumers.set(target, fileConsumers);
-            for (const name of moduleImport.names) {
-                const key = symbolKey(target, name);
-                const nameConsumers = symbolConsumers.get(key) ?? new Set();
-                nameConsumers.add(file);
-                symbolConsumers.set(key, nameConsumers);
-            }
-        }
-    }
-    return { sourceRoot, modules, consumers, symbolConsumers };
-}
-let cache;
-/**
- * The project index for a source tree, rebuilt only when the tree changed.
- * Returns undefined when the tree does not exist, which is how a repository
- * without a `src/` folder opts out of every cross-file rule.
- */
-export function getProjectIndex(sourceRoot) {
-    const now = Date.now();
-    if (cache?.index.sourceRoot === sourceRoot && now - cache.checkedAt < REVALIDATE_AFTER_MS) {
-        return cache.index;
-    }
-    try {
-        if (!statSync(sourceRoot).isDirectory())
-            return undefined;
-    }
-    catch {
-        return undefined;
-    }
-    const files = listSourceFiles(sourceRoot).sort((left, right) => left.localeCompare(right));
-    const currentFingerprint = fingerprint(files);
-    if (cache?.index.sourceRoot === sourceRoot && cache.fingerprint === currentFingerprint) {
-        cache.checkedAt = now;
-        return cache.index;
-    }
-    const index = build(sourceRoot, files);
-    cache = { index, checkedAt: now, fingerprint: currentFingerprint };
-    return index;
-}
-/** Drops the memoized index. Used by tests that write a fresh tree per case. */
-export function clearProjectIndex() {
-    cache = undefined;
-}

package/dist/eslint/pasika/project/parse-module.d.ts

@@ -1,27 +0,0 @@
-/** What an exported name is, as far as the placement rules need to care. */
-export type ExportKind = "component" | "hook" | "type" | "schema" | "constant" | "function" | "other";
-export interface ModuleExport {
-    name: string;
-    kind: ExportKind;
-    line: number;
-}
-export interface ModuleImport {
-    /** The specifier exactly as written. */
-    specifier: string;
-    /** Names taken from the module; empty for a side-effect or namespace import. */
-    names: string[];
-    line: number;
-}
-export interface ParsedModule {
-    file: string;
-    imports: ModuleImport[];
-    exports: ModuleExport[];
-}
-/**
- * Parses one module for the names it exports and the modules it imports.
- *
- * Uses the TypeScript parser without a program or typechecker: the placement
- * rules only need the shape of the import and export statements, and parsing a
- * file in isolation keeps this fast enough to run over a whole tree.
- */
-export declare function parseModule(file: string): ParsedModule;

package/dist/eslint/pasika/project/parse-module.js

@@ -1,128 +0,0 @@
-import path from "node:path";
-import { readFileSync } from "node:fs";
-import ts from "typescript";
-const isPascalCase = (name) => /^[A-Z][A-Za-z0-9]*$/.test(name);
-const isHookName = (name) => /^use[A-Z]/.test(name);
-const isSchemaName = (name) => /[Ss]chema$/.test(name);
-function lineOf(sourceFile, node) {
-    return sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile)).line + 1;
-}
-function returnsJsx(node) {
-    let found = false;
-    const visit = (child) => {
-        if (found)
-            return;
-        if (ts.isJsxElement(child) ||
-            ts.isJsxSelfClosingElement(child) ||
-            ts.isJsxFragment(child) ||
-            ts.isJsxOpeningFragment(child)) {
-            found = true;
-            return;
-        }
-        ts.forEachChild(child, visit);
-    };
-    ts.forEachChild(node, visit);
-    return found;
-}
-function classifyFunction(name, isTsx, hasJsx) {
-    if (isHookName(name))
-        return "hook";
-    if (isTsx && isPascalCase(name) && hasJsx)
-        return "component";
-    return "function";
-}
-function classifyValue(name, initializer, isTsx) {
-    const isFunctionLike = initializer !== undefined &&
-        (ts.isArrowFunction(initializer) || ts.isFunctionExpression(initializer) || ts.isFunctionDeclaration(initializer));
-    if (isHookName(name))
-        return "hook";
-    if (isSchemaName(name))
-        return "schema";
-    if (isTsx && isPascalCase(name) && (initializer === undefined || returnsJsx(initializer) || isFunctionLike)) {
-        return "component";
-    }
-    if (isFunctionLike)
-        return "function";
-    return "constant";
-}
-/**
- * Parses one module for the names it exports and the modules it imports.
- *
- * Uses the TypeScript parser without a program or typechecker: the placement
- * rules only need the shape of the import and export statements, and parsing a
- * file in isolation keeps this fast enough to run over a whole tree.
- */
-export function parseModule(file) {
-    const text = readFileSync(file, "utf8");
-    const isTsx = file.endsWith(".tsx") || file.endsWith(".jsx");
-    const sourceFile = ts.createSourceFile(file, text, ts.ScriptTarget.Latest, true, ts.ScriptKind.TSX);
-    const imports = [];
-    const exports = [];
-    const addImport = (specifierNode, names, node) => {
-        if (!ts.isStringLiteral(specifierNode))
-            return;
-        imports.push({ specifier: specifierNode.text, names, line: lineOf(sourceFile, node) });
-    };
-    for (const statement of sourceFile.statements) {
-        if (ts.isImportDeclaration(statement)) {
-            const names = [];
-            const bindings = statement.importClause?.namedBindings;
-            if (statement.importClause?.name)
-                names.push(statement.importClause.name.text);
-            if (bindings && ts.isNamedImports(bindings)) {
-                for (const element of bindings.elements)
-                    names.push(element.propertyName?.text ?? element.name.text);
-            }
-            addImport(statement.moduleSpecifier, names, statement);
-            continue;
-        }
-        if (ts.isExportDeclaration(statement)) {
-            // `export { x } from "./y"` both imports and re-exports.
-            if (statement.moduleSpecifier) {
-                const names = [];
-                if (statement.exportClause && ts.isNamedExports(statement.exportClause)) {
-                    for (const element of statement.exportClause.elements) {
-                        names.push(element.propertyName?.text ?? element.name.text);
-                    }
-                }
-                addImport(statement.moduleSpecifier, names, statement);
-            }
-            if (statement.exportClause && ts.isNamedExports(statement.exportClause)) {
-                for (const element of statement.exportClause.elements) {
-                    exports.push({ name: element.name.text, kind: "other", line: lineOf(sourceFile, element) });
-                }
-            }
-            continue;
-        }
-        const isExported = ts.canHaveModifiers(statement)
-            ? (ts.getModifiers(statement) ?? []).some((modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword)
-            : false;
-        if (!isExported)
-            continue;
-        if (ts.isFunctionDeclaration(statement) && statement.name) {
-            const name = statement.name.text;
-            exports.push({
-                name,
-                kind: classifyFunction(name, isTsx, returnsJsx(statement)),
-                line: lineOf(sourceFile, statement),
-            });
-            continue;
-        }
-        if (ts.isVariableStatement(statement)) {
-            for (const declaration of statement.declarationList.declarations) {
-                if (!ts.isIdentifier(declaration.name))
-                    continue;
-                exports.push({
-                    name: declaration.name.text,
-                    kind: classifyValue(declaration.name.text, declaration.initializer, isTsx),
-                    line: lineOf(sourceFile, declaration),
-                });
-            }
-            continue;
-        }
-        if (ts.isTypeAliasDeclaration(statement) || ts.isInterfaceDeclaration(statement)) {
-            exports.push({ name: statement.name.text, kind: "type", line: lineOf(sourceFile, statement) });
-        }
-    }
-    return { file: path.resolve(file), imports, exports };
-}

package/dist/eslint/pasika/rules/application-structure.d.ts

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

package/dist/eslint/pasika/rules/application-structure.js

@@ -1,152 +0,0 @@
-/**
- * ESLint rule: pasika/application-structure
- *
- * Enforces the path-based parts of the Application Structure, Configuration,
- * and Component Placement rules. Questions about ownership or extraction stay
- * with the cross-file rules because they need the project graph.
- *
- * @see docs/code-organization-guide/rules/application-structure-rule.md
- * @see docs/code-organization-guide/rules/configuration-rule.md
- * @see docs/code-organization-guide/rules/component-placement-rule.md
- */
-import fs from "node:fs";
-import path from "node:path";
-import { parseModule } from "../project/parse-module.js";
-import { segmentsOf, SUPPORT_FOLDERS } from "../project/ccf.js";
-const MODULE_EXTENSIONS = new Set([".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs"]);
-const ROUTING_FILES = new Set([
-    "default",
-    "error",
-    "instrumentation",
-    "layout",
-    "loading",
-    "middleware",
-    "not-found",
-    "page",
-    "route",
-    "template",
-]);
-const EXPECTED_SUPPORT_FOLDER = {
-    hook: "hooks",
-    type: "types",
-    schema: "schemas",
-    constant: "constants",
-    function: "utils",
-};
-function report(context, message) {
-    return {
-        Program(node) {
-            context.report({ node, loc: { line: 1, column: 0 }, message });
-        },
-    };
-}
-function isCodeFile(filename) {
-    return MODULE_EXTENSIONS.has(path.extname(filename));
-}
-function isRootSupportFolder(folder) {
-    return SUPPORT_FOLDERS.has(folder);
-}
-function exportedKinds(filename) {
-    try {
-        return new Set(parseModule(filename).exports.map((moduleExport) => moduleExport.kind));
-    }
-    catch {
-        return new Set();
-    }
-}
-function expectedSupportFolder(kinds) {
-    for (const kind of ["component", "hook", "type", "schema", "constant", "function"]) {
-        if (kinds.has(kind))
-            return EXPECTED_SUPPORT_FOLDER[kind];
-    }
-    return undefined;
-}
-function configModuleRoot(filename, sourceRoot) {
-    const segments = segmentsOf(filename, sourceRoot);
-    if (segments[0] !== "config" || segments.length < 3)
-        return undefined;
-    return path.join(sourceRoot, "config", segments[1] ?? "");
-}
-export const applicationStructureRule = {
-    meta: {
-        schema: [],
-        type: "problem",
-        docs: {
-            description: "Enforce the repository's application, configuration, and support-folder structure.",
-        },
-    },
-    create(context) {
-        const filename = path.resolve(context.filename);
-        const sourceRoot = path.resolve("src");
-        const segments = segmentsOf(filename, sourceRoot);
-        if (segments.length === 0)
-            return {};
-        const [topLevel, secondLevel] = segments;
-        if (topLevel === undefined)
-            return {};
-        if (segments.length > 1 &&
-            topLevel !== "app" &&
-            topLevel !== "compositions" &&
-            topLevel !== "features" &&
-            topLevel !== "shared" &&
-            topLevel !== "config" &&
-            topLevel !== "locales" &&
-            !isRootSupportFolder(topLevel)) {
-            return report(context, `Move this source file under an allowed src/ folder; "src/${topLevel}/" is not part of the application structure.`);
-        }
-        if (topLevel === "features" && segments.length >= 2 && secondLevel !== undefined) {
-            if (SUPPORT_FOLDERS.has(secondLevel)) {
-                return report(context, `Move this support folder inside a feature folder; "src/features/${secondLevel}/" does not belong to a feature.`);
-            }
-            if (segments.length === 2) {
-                return report(context, "src/features/ must contain only feature folders, not source files.");
-            }
-        }
-        if (topLevel === "config") {
-            if (segments.length === 2) {
-                return report(context, "A configuration module must be a src/config/<config-name>/ folder with index.ts as its entry point.");
-            }
-            const moduleRoot = configModuleRoot(filename, sourceRoot);
-            if (moduleRoot && !fs.existsSync(path.join(moduleRoot, "index.ts"))) {
-                return report(context, `Add src/config/${path.basename(moduleRoot)}/index.ts as the configuration module entry point.`);
-            }
-            if (moduleRoot && segments.length === 3 && path.basename(filename) !== "index.ts") {
-                const kinds = exportedKinds(filename);
-                const expected = expectedSupportFolder(kinds);
-                if (expected !== undefined) {
-                    return report(context, `Move this configuration support file into src/config/${path.basename(moduleRoot)}/${expected}/.`);
-                }
-            }
-        }
-        if (topLevel === "app" && isCodeFile(filename)) {
-            const basename = path.basename(filename, path.extname(filename));
-            const currentFolder = path.basename(path.dirname(filename));
-            if (SUPPORT_FOLDERS.has(currentFolder)) {
-                return report(context, "src/app/ may contain routing files and framework assets, but ordinary components and support files must live outside src/app/.");
-            }
-            if (!ROUTING_FILES.has(basename) && path.extname(filename) !== ".css") {
-                return report(context, "src/app/ may contain routing files and framework assets, but ordinary components and support files must live outside src/app/.");
-            }
-        }
-        const currentFolder = path.basename(path.dirname(filename));
-        const kinds = exportedKinds(filename);
-        const isConfigModuleRoot = topLevel === "config" && segments.length === 3 && path.basename(filename) === "index.ts";
-        if (isConfigModuleRoot)
-            return {};
-        if (!SUPPORT_FOLDERS.has(currentFolder)) {
-            const expected = expectedSupportFolder(kinds);
-            if (expected !== undefined && segments.length > 2) {
-                return report(context, `Move this file to a ${expected}/ folder; ${currentFolder}/ is not a recognized support folder.`);
-            }
-            return {};
-        }
-        if (kinds.has("component")) {
-            return report(context, `A support folder must not contain a component; move ${path.basename(filename)} beside ${currentFolder}/.`);
-        }
-        const expected = expectedSupportFolder(kinds);
-        if (expected !== undefined && expected !== currentFolder) {
-            return report(context, `Move this file to a ${expected}/ folder; ${currentFolder}/ is reserved for ${expected === "utils" ? "utilities" : expected}.`);
-        }
-        return {};
-    },
-};

package/dist/eslint/pasika/rules/component-conventions.d.ts

@@ -1,16 +0,0 @@
-import ts from "typescript";
-export interface ComponentInfo {
-    name: string;
-    declaration: ts.FunctionDeclaration | ts.VariableDeclaration;
-    smart: boolean;
-}
-export declare function parseComponentInfo(text: string, filename: string): ComponentInfo[];
-export interface SimpleRoot {
-    tagName: string;
-    attributes: ts.JsxAttributeLike[];
-}
-export declare function findSimpleRoot(component: ComponentInfo, _text: string, _filename: string): SimpleRoot | undefined;
-export declare function getTestId(root: SimpleRoot): {
-    value?: string;
-    attribute?: ts.JsxAttribute;
-};

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

@@ -1,145 +0,0 @@
-import path from "node:path";
-import ts from "typescript";
-const isPascalCase = (name) => /^[A-Z][A-Za-z0-9]*$/.test(name);
-const isHookCallName = (name) => /^use[A-Z]/.test(name);
-function isExported(node) {
-    if (!ts.canHaveModifiers(node))
-        return false;
-    return (ts.getModifiers(node) ?? []).some((modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword);
-}
-function containsJsx(node) {
-    let found = false;
-    const visit = (child) => {
-        if (found)
-            return;
-        if (ts.isJsxElement(child) || ts.isJsxSelfClosingElement(child) || ts.isJsxFragment(child)) {
-            found = true;
-            return;
-        }
-        ts.forEachChild(child, visit);
-    };
-    ts.forEachChild(node, visit);
-    return found;
-}
-function containsSmartCall(node) {
-    let found = false;
-    const visit = (child) => {
-        if (found)
-            return;
-        if (ts.isCallExpression(child)) {
-            const expression = child.expression;
-            let name = "";
-            if (ts.isIdentifier(expression)) {
-                name = expression.text;
-            }
-            else if (ts.isPropertyAccessExpression(expression)) {
-                name = expression.name.text;
-            }
-            if (isHookCallName(name)) {
-                found = true;
-                return;
-            }
-        }
-        ts.forEachChild(child, visit);
-    };
-    ts.forEachChild(node, visit);
-    return found;
-}
-function componentFromFunction(node) {
-    const name = node.name?.text;
-    if (!name || !isPascalCase(name) || !containsJsx(node))
-        return undefined;
-    return { name, declaration: node, smart: containsSmartCall(node) };
-}
-function componentFromVariable(node) {
-    if (!ts.isIdentifier(node.name) || !isPascalCase(node.name.text))
-        return undefined;
-    const initializer = node.initializer;
-    if (!initializer || (!ts.isArrowFunction(initializer) && !ts.isFunctionExpression(initializer)))
-        return undefined;
-    if (!containsJsx(initializer))
-        return undefined;
-    return {
-        name: node.name.text,
-        declaration: node,
-        smart: containsSmartCall(initializer),
-    };
-}
-export function parseComponentInfo(text, filename) {
-    const sourceFile = ts.createSourceFile(path.resolve(filename), text, ts.ScriptTarget.Latest, true, ts.ScriptKind.TSX);
-    const components = [];
-    for (const statement of sourceFile.statements) {
-        if (!isExported(statement))
-            continue;
-        if (ts.isFunctionDeclaration(statement)) {
-            const component = componentFromFunction(statement);
-            if (component)
-                components.push(component);
-            continue;
-        }
-        if (ts.isVariableStatement(statement)) {
-            for (const declaration of statement.declarationList.declarations) {
-                const component = componentFromVariable(declaration);
-                if (component)
-                    components.push(component);
-            }
-        }
-    }
-    return components;
-}
-function jsxTagName(element) {
-    const tagName = ts.isJsxElement(element) ? element.openingElement.tagName : element.tagName;
-    return ts.isIdentifier(tagName) ? tagName.text : undefined;
-}
-function rootFromExpression(expression) {
-    if (ts.isJsxSelfClosingElement(expression)) {
-        const tagName = jsxTagName(expression);
-        if (!tagName?.startsWith(tagName[0]?.toLowerCase() ?? ""))
-            return undefined;
-        return { tagName, attributes: [...expression.attributes.properties] };
-    }
-    if (ts.isJsxElement(expression)) {
-        const tagName = jsxTagName(expression);
-        if (!tagName?.startsWith(tagName[0]?.toLowerCase() ?? ""))
-            return undefined;
-        return { tagName, attributes: [...expression.openingElement.attributes.properties] };
-    }
-    return undefined;
-}
-export function findSimpleRoot(component, _text, _filename) {
-    const declaration = component.declaration;
-    let body;
-    if (ts.isFunctionDeclaration(declaration))
-        body = declaration.body;
-    else if (declaration.initializer && ts.isArrowFunction(declaration.initializer))
-        body = declaration.initializer.body;
-    else if (declaration.initializer && ts.isFunctionExpression(declaration.initializer)) {
-        body = declaration.initializer.body;
-    }
-    if (!body)
-        return undefined;
-    if (!ts.isBlock(body))
-        return rootFromExpression(body);
-    const returns = [];
-    const visit = (node) => {
-        if (node !== body && (ts.isFunctionLike(node) || ts.isClassLike(node)))
-            return;
-        if (ts.isReturnStatement(node))
-            returns.push(node);
-        ts.forEachChild(node, visit);
-    };
-    visit(body);
-    if (returns.length !== 1)
-        return undefined;
-    const expression = returns[0]?.expression;
-    return expression && ts.isExpression(expression) ? rootFromExpression(expression) : undefined;
-}
-export function getTestId(root) {
-    const attribute = root.attributes.find((candidate) => ts.isJsxAttribute(candidate) && ts.isIdentifier(candidate.name) && candidate.name.text === "data-testid");
-    if (!attribute)
-        return {};
-    const value = attribute.initializer;
-    if (!value || !ts.isStringLiteral(value))
-        return { attribute };
-    return { value: value.text, attribute };
-}

package/dist/eslint/pasika/rules/component-nesting.d.ts

@@ -1,12 +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 type { Rule } from "eslint";
-export declare const componentNestingRule: Rule.RuleModule;