pasika 0.3.2 → 0.3.4

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;

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;