zemdomu 1.3.2 → 1.3.4

package/out/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/out/cli.js

@@ -0,0 +1,88 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const glob_1 = __importDefault(require("glob"));
+const path_1 = __importDefault(require("path"));
+const project_linter_1 = require("./project-linter");
+function parsePatterns(inputs) {
+    const result = [];
+    for (const input of inputs) {
+        const splits = input
+            .split(/\r?\n/)
+            .flatMap((p) => p.split(/[ ,]+/))
+            .filter(Boolean);
+        result.push(...splits);
+    }
+    return result;
+}
+async function run() {
+    var _a;
+    const args = process.argv.slice(2);
+    const rawPatterns = [];
+    const customRules = [];
+    let cross = false;
+    let depth;
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === '--custom' || arg === '-c') {
+            const file = args[++i];
+            if (!file)
+                throw new Error('Missing file for --custom');
+            const resolved = path_1.default.resolve(file);
+            const customDir = path_1.default.resolve('custom-rules');
+            const relative = path_1.default.relative(customDir, resolved);
+            if (relative.startsWith('..') || path_1.default.isAbsolute(relative)) {
+                throw new Error('Custom rule file must be inside ./custom-rules');
+            }
+            const mod = require(resolved);
+            const rules = (_a = mod.default) !== null && _a !== void 0 ? _a : mod;
+            if (Array.isArray(rules))
+                customRules.push(...rules);
+            else
+                customRules.push(rules);
+        }
+        else if (arg === '--cross') {
+            cross = true;
+        }
+        else if (arg === '--cross-depth') {
+            const val = args[++i];
+            if (!val)
+                throw new Error('Missing value for --cross-depth');
+            depth = parseInt(val, 10);
+            if (isNaN(depth))
+                throw new Error('Invalid number for --cross-depth');
+            cross = true;
+        }
+        else {
+            rawPatterns.push(arg);
+        }
+    }
+    const patterns = parsePatterns(rawPatterns);
+    if (patterns.length === 0) {
+        patterns.push('**/*.{html,jsx,tsx}');
+    }
+    const files = new Set();
+    for (const pattern of patterns) {
+        const matches = glob_1.default.sync(pattern, { nodir: true });
+        for (const m of matches)
+            files.add(m);
+    }
+    const linter = new project_linter_1.ProjectLinter({ customRules, crossComponentAnalysis: cross, crossComponentDepth: depth });
+    const results = await linter.lintFiles(Array.from(files));
+    let hasIssues = false;
+    for (const [file, issues] of results.entries()) {
+        for (const issue of issues) {
+            console.error(`${file}:${issue.line + 1}:${issue.column + 1} ${issue.rule}: ${issue.message}`);
+            hasIssues = true;
+        }
+    }
+    if (hasIssues)
+        process.exit(1);
+}
+run().catch((e) => {
+    console.error(e);
+    process.exit(1);
+});

package/out/component-analyzer.d.ts

@@ -0,0 +1,89 @@
+import { LintResult, LinterOptions } from './linter';
+interface PerformanceRecorder {
+    record(filePath: string, timings: Record<string, number>): void;
+}
+interface ComponentReference {
+    name: string;
+    path: string | null;
+    rawImportPath: string | null;
+    sourceLocation: {
+        line: number;
+        column: number;
+    };
+    usageLocations: Array<{
+        line: number;
+        column: number;
+    }>;
+}
+interface HeadingInfo {
+    level: number;
+    line: number;
+    column: number;
+    filePath: string;
+}
+interface IdInfo {
+    id: string;
+    line: number;
+    column: number;
+    filePath: string;
+}
+interface NavInfo {
+    filePath: string;
+    line: number;
+    column: number;
+    hasLocalLink: boolean;
+    childComponents: ComponentReference[];
+}
+interface ComponentDefinition {
+    name: string;
+    filePath: string;
+    issues: Map<string, LintResult[]>;
+    usesComponents: ComponentReference[];
+    headings: HeadingInfo[];
+    ids: IdInfo[];
+    navs: NavInfo[];
+    hasLocalAnchor: boolean;
+}
+export declare class ComponentAnalyzer {
+    private componentRegistry;
+    private importToComponentMap;
+    private options;
+    private processingComponentStack;
+    private perf?;
+    private resolver;
+    private maxDepth;
+    constructor(options: LinterOptions & {
+        crossComponentAnalysis?: boolean;
+        crossComponentDepth?: number;
+    }, perf?: PerformanceRecorder);
+    analyzeFile(filePath: string): Promise<ComponentDefinition | null>;
+    private extractComponentInfo;
+    private resolveComponentPath;
+    registerComponent(component: ComponentDefinition, issues: LintResult[]): void;
+    private getRuleType;
+    analyzeComponentTree(): LintResult[];
+    private findCrossComponentH1Issues;
+    private findReferenceForComp;
+    /**
+     * Improved implementation to find heading order issues across components
+     */
+    private findCrossComponentHeadingOrderIssues;
+    /**
+     * Collects all headings from a component and its children in document order
+     * and checks for heading level issues
+     */
+    private analyzeHeadingHierarchy;
+    /**
+     * Collects all headings from a component and its children in document order
+     */
+    private collectHeadingsInDocumentOrder;
+    private findCrossComponentDuplicateIds;
+    private collectIds;
+    private findCrossComponentNavLinks;
+    private checkNavs;
+    private navHasLink;
+    private componentHasAnchor;
+    private findEntryPoints;
+    private findComponentsWithRule;
+}
+export {};