pasika 0.3.1 → 0.3.2

package/dist/eslint/pasika/ast-types.d.ts

@@ -0,0 +1,122 @@
+/**
+ * Local AST node types for the parser-specific shapes ESLint's ESTree types
+ * do not carry: JSX nodes and TypeScript type nodes.
+ *
+ * Every extra field is optional so that any `Rule.Node` is assignable to these
+ * types — the handler parameters of the rules must accept whatever the parser
+ * hands them. Narrowing happens with `type`-discriminant checks inside each
+ * rule, exactly as in `no-arbitrary-tailwind.ts`.
+ */
+import type { Rule } from "eslint";
+import type * as ESTree from "estree";
+/** JSXIdentifier — the parser-specific name node of a JSX element or attribute. */
+export interface JsxIdentifier {
+    type: "JSXIdentifier";
+    name: string;
+}
+/** JSXMemberExpression — `<Foo.Bar>`, used by element and attribute names. */
+export interface JsxMemberExpression {
+    type: "JSXMemberExpression";
+    object: JsxIdentifier | JsxMemberExpression;
+    property: JsxIdentifier;
+}
+/** JSXExpressionContainer — the `{expression}` part of a JSX attribute value. */
+export interface JsxExpressionContainer {
+    type: "JSXExpressionContainer";
+    expression: ESTree.Expression;
+}
+/** JSXAttribute — `name="value"` or `name={expression}`. */
+export type JsxAttribute = Omit<Rule.Node, "type"> & {
+    type: string;
+    name: JsxIdentifier;
+    value: ESTree.Literal | JsxExpressionContainer | null;
+    parent?: JsxOpeningElementNode;
+};
+/** JSXSpreadAttribute — `{...props}`. */
+export interface JsxSpreadAttribute {
+    type: "JSXSpreadAttribute";
+    name?: never;
+    value?: never;
+    argument: ESTree.Expression;
+}
+/** Anything that can appear inside `attributes` of a JSX opening element. */
+export type JsxAttributeLike = JsxAttribute | JsxSpreadAttribute;
+/** JSXOpeningElement — the part before the closing `>` of an element. */
+export interface JsxOpeningElement {
+    type: "JSXOpeningElement";
+    name: JsxIdentifier | JsxMemberExpression;
+    attributes: JsxAttributeLike[];
+}
+/** A node that may be a JSX element — used for parents and helper parameters. */
+export type MaybeJsxElement = Rule.Node & {
+    openingElement?: JsxOpeningElement;
+};
+/** JSXElement as received by a `JSXElement` visitor. */
+export type JsxElementNode = MaybeJsxElement & {
+    parent?: MaybeJsxElement;
+};
+/** JSXAttribute as received by a `JSXAttribute` visitor, with its parent chain. */
+export type JsxAttributeNode = Rule.Node & {
+    name?: JsxIdentifier;
+    value?: ESTree.Literal | JsxExpressionContainer | null;
+    parent?: JsxOpeningElementNode;
+};
+/** JSXOpeningElement reached through a parent chain. */
+export type JsxOpeningElementNode = Rule.Node & {
+    name?: JsxIdentifier;
+    attributes?: JsxAttributeLike[];
+    parent?: JsxElementNode;
+};
+/**
+ * FunctionDeclaration as seen by a rule visitor. ESLint's ESTree typing says
+ * `id` is always present, but an anonymous `export default function () {}`
+ * reaches the visitor with `id: null`, so the field is kept nullable.
+ */
+export type FunctionDeclarationNode = Rule.Node & {
+    id?: {
+        name?: string;
+    } | null;
+    body?: ESTree.BlockStatement;
+};
+/**
+ * TSTypeAliasDeclaration — `type X = ...`, from the typescript-eslint parser.
+ *
+ * Kept as a plain `Rule.Node` intersection so it can be passed to
+ * `context.report`, which requires an ESTree node.
+ */
+export type TsTypeAliasDeclarationNode = Rule.Node & {
+    id?: {
+        type?: string;
+        name?: string;
+    };
+    typeAnnotation?: TsTypeNode;
+};
+/**
+ * A member of a type literal (TSPropertySignature, TSIndexSignature, ...).
+ *
+ * The `type` field is widened (via Omit) so it can be compared against the
+ * parser-specific "TSPropertySignature" string that ESTree's union lacks.
+ */
+export type TsTypeElementNode = Omit<Rule.Node, "type"> & {
+    type: string;
+    key?: {
+        type?: string;
+        name?: string;
+    };
+    typeAnnotation?: TsTypeAnnotationNode;
+};
+/** TSTypeAnnotation — the `: T` wrapper around a type node. */
+export type TsTypeAnnotationNode = Omit<Rule.Node, "type"> & {
+    type: string;
+    typeAnnotation?: TsTypeNode;
+};
+/** Any TypeScript type node the rules read (TSTypeLiteral, TSUnionType, ...). */
+export type TsTypeNode = Omit<Rule.Node, "type"> & {
+    type: string;
+    members?: TsTypeElementNode[];
+    types?: TsTypeNode[];
+    literal?: {
+        type?: string;
+        value?: unknown;
+    };
+};

package/dist/eslint/pasika/ast-types.js

@@ -0,0 +1 @@
+export {};

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

@@ -6,9 +6,64 @@
  * documented requirement each rule covers is recorded in
  * `enforcement/registry.json` and verified by `pasika coverage`.
  */
-import type { Linter, Rule } from "eslint";
-/** Every rule the plugin provides, keyed by its unprefixed name. */
-export declare const pasikaRules: Record<string, Rule.RuleModule>;
+import type { Linter } from "eslint";
+import { mdRules } from "./rules/md/index.js";
+import { cssRules } from "./rules/css/index.js";
+import { jsonRules } from "./rules/json/index.js";
+export declare const pasikaRules: {
+    "component-placement": import("eslint").Rule.RuleModule;
+    "support-file-placement": import("eslint").Rule.RuleModule;
+    "application-structure": import("eslint").Rule.RuleModule;
+    "named-exports": import("eslint").Rule.RuleModule;
+    "data-testid-case": import("eslint").Rule.RuleModule;
+    "support-folder-shape": import("eslint").Rule.RuleModule;
+    "import-through-index": import("eslint").Rule.RuleModule;
+    "util-file-name": import("eslint").Rule.RuleModule;
+    "no-util-barrel": import("eslint").Rule.RuleModule;
+    "jsx-hygiene": import("eslint").Rule.RuleModule;
+    "interactive-component": import("eslint").Rule.RuleModule;
+    "ui-state": import("eslint").Rule.RuleModule;
+    "filename-case": import("eslint").Rule.RuleModule;
+    "import-boundaries": import("eslint").Rule.RuleModule;
+    "no-mixed-concerns": import("eslint").Rule.RuleModule;
+    "no-arbitrary-tailwind": import("eslint").Rule.RuleModule;
+    "enforce-cn-merge": {
+        meta: {
+            schema: never[];
+            type: "problem";
+            docs: {
+                description: string;
+            };
+        };
+        create(context: import("eslint").Rule.RuleContext): {
+            JSXAttribute(node: import("./ast-types.js").JsxAttributeNode): void;
+        };
+    };
+    "enforce-cva-variant-props": import("eslint").Rule.RuleModule;
+    "cva-appearance-props": import("eslint").Rule.RuleModule;
+    "cva-boolean-variants": import("eslint").Rule.RuleModule;
+    "enforce-barrel-exports": import("eslint").Rule.RuleModule;
+    "cross-feature-import": import("eslint").Rule.RuleModule;
+    "pure-function-extract": import("eslint").Rule.RuleModule;
+    "hook-complexity": import("eslint").Rule.RuleModule;
+    "locale-dotted-path": import("eslint").Rule.RuleModule;
+    "locales-location": import("eslint").Rule.RuleModule;
+    "hook-extraction": import("eslint").Rule.RuleModule;
+    "value-extraction": import("eslint").Rule.RuleModule;
+    "config-extraction": import("eslint").Rule.RuleModule;
+    "component-nesting": import("eslint").Rule.RuleModule;
+    "stay-flat": import("eslint").Rule.RuleModule;
+    "type-extraction": import("eslint").Rule.RuleModule;
+    "locale-placement": import("eslint").Rule.RuleModule;
+    "shared-style-dedup": import("eslint").Rule.RuleModule;
+    "no-eslint-disable": import("eslint").Rule.RuleModule;
+};
+export { mdRules, cssRules, jsonRules };
 /** Rule ids as they appear in configuration and in lint output. */
 export declare const pasikaRuleIds: string[];
+export declare const pasikaMdRuleIds: string[];
+export declare const pasikaCssRuleIds: string[];
+export declare const pasikaJsonRuleIds: string[];
+/** Every rule id, as they appear in configuration and in lint output. */
+export declare const allPasikaRuleIds: string[];
 export declare const pasikaConfig: Linter.Config;

package/dist/eslint/pasika/index.js

@@ -7,20 +7,80 @@ import { enforceCvaVariantPropsRule } from "./rules/enforce-cva-variant-props.js
 import { enforceBarrelExportsRule } from "./rules/enforce-barrel-exports.js";
 import { componentPlacementRule } from "./rules/component-placement.js";
 import { supportFilePlacementRule } from "./rules/support-file-placement.js";
-/** Every rule the plugin provides, keyed by its unprefixed name. */
+import { applicationStructureRule } from "./rules/application-structure.js";
+import { namedExportsRule } from "./rules/named-exports.js";
+import { dataTestIdCaseRule } from "./rules/data-testid-case.js";
+import { supportFolderShapeRule } from "./rules/support-folder-shape.js";
+import { importThroughIndexRule } from "./rules/import-through-index.js";
+import { utilFileNameRule } from "./rules/util-file-name.js";
+import { noUtilBarrelRule } from "./rules/no-util-barrel.js";
+import { jsxHygieneRule } from "./rules/jsx-hygiene.js";
+import { interactiveComponentRule } from "./rules/interactive-component.js";
+import { uiStateRule } from "./rules/ui-state.js";
+import { cvaAppearancePropsRule } from "./rules/cva-appearance-props.js";
+import { cvaBooleanVariantsRule } from "./rules/cva-boolean-variants.js";
+import { crossFeatureImportRule } from "./rules/cross-feature-import.js";
+import { pureFunctionExtractRule } from "./rules/pure-function-extract.js";
+import { hookComplexityRule } from "./rules/hook-complexity.js";
+import { localeDottedPathRule } from "./rules/locale-dotted-path.js";
+import { localesLocationRule } from "./rules/locales-location.js";
+import { hookExtractionRule } from "./rules/hook-extraction.js";
+import { valueExtractionRule } from "./rules/value-extraction.js";
+import { configExtractionRule } from "./rules/config-extraction.js";
+import { componentNestingRule } from "./rules/component-nesting.js";
+import { stayFlatRule } from "./rules/stay-flat.js";
+import { typeExtractionRule } from "./rules/type-extraction.js";
+import { localePlacementRule } from "./rules/locale-placement.js";
+import { sharedStyleDedupRule } from "./rules/shared-style-dedup.js";
+import { noEslintDisableRule } from "./rules/no-eslint-disable.js";
+import { mdRules } from "./rules/md/index.js";
+import { cssRules } from "./rules/css/index.js";
+import { jsonRules } from "./rules/json/index.js";
 export const pasikaRules = {
     "component-placement": componentPlacementRule,
     "support-file-placement": supportFilePlacementRule,
+    "application-structure": applicationStructureRule,
+    "named-exports": namedExportsRule,
+    "data-testid-case": dataTestIdCaseRule,
+    "support-folder-shape": supportFolderShapeRule,
+    "import-through-index": importThroughIndexRule,
+    "util-file-name": utilFileNameRule,
+    "no-util-barrel": noUtilBarrelRule,
+    "jsx-hygiene": jsxHygieneRule,
+    "interactive-component": interactiveComponentRule,
+    "ui-state": uiStateRule,
     "filename-case": filenameCaseRule,
     "import-boundaries": importBoundariesRule,
     "no-mixed-concerns": noMixedConcernsRule,
     "no-arbitrary-tailwind": noArbitraryTailwindRule,
     "enforce-cn-merge": enforceCnMergeRule,
     "enforce-cva-variant-props": enforceCvaVariantPropsRule,
+    "cva-appearance-props": cvaAppearancePropsRule,
+    "cva-boolean-variants": cvaBooleanVariantsRule,
     "enforce-barrel-exports": enforceBarrelExportsRule,
+    "cross-feature-import": crossFeatureImportRule,
+    "pure-function-extract": pureFunctionExtractRule,
+    "hook-complexity": hookComplexityRule,
+    "locale-dotted-path": localeDottedPathRule,
+    "locales-location": localesLocationRule,
+    "hook-extraction": hookExtractionRule,
+    "value-extraction": valueExtractionRule,
+    "config-extraction": configExtractionRule,
+    "component-nesting": componentNestingRule,
+    "stay-flat": stayFlatRule,
+    "type-extraction": typeExtractionRule,
+    "locale-placement": localePlacementRule,
+    "shared-style-dedup": sharedStyleDedupRule,
+    "no-eslint-disable": noEslintDisableRule,
 };
+export { mdRules, cssRules, jsonRules };
 /** Rule ids as they appear in configuration and in lint output. */
 export const pasikaRuleIds = Object.keys(pasikaRules).map((name) => `pasika/${name}`);
+export const pasikaMdRuleIds = Object.keys(mdRules).map((name) => `pasika/${name}`);
+export const pasikaCssRuleIds = Object.keys(cssRules).map((name) => `pasika/${name}`);
+export const pasikaJsonRuleIds = Object.keys(jsonRules).map((name) => `pasika/${name}`);
+/** Every rule id, as they appear in configuration and in lint output. */
+export const allPasikaRuleIds = [...pasikaRuleIds, ...pasikaMdRuleIds, ...pasikaCssRuleIds, ...pasikaJsonRuleIds];
 export const pasikaConfig = {
     files: ["src/**/*.{cjs,cts,js,jsx,mjs,mts,ts,tsx}"],
     plugins: {

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

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

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

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

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

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

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