@ngcompass/engine 0.1.1-beta

package/dist/index.d.cts

@@ -0,0 +1,578 @@
+import { RuleContext, RuleFailure, RuleMetadata, InfrastructureErrorCollector, RuleResult, TemplateAst, StyleAst, ProjectContext, ParserOptions, Result, AnalysisResult, ComponentFiles } from '@ngcompass/common';
+import { AnyAngularClassNode, CallExpression, AngularClassNode, DecoratedPropertyNode, NewExpression, TemplateAttributeNode, TemplateBlockNode, TemplateExpressionNode, TemplateAnalysis } from '@ngcompass/ast';
+import { Program } from 'oxc-parser';
+import ts, { TypeChecker } from 'typescript';
+import { ExecutionPlanOutput, Task } from '@ngcompass/planner';
+import { CacheContext } from '@ngcompass/cache';
+
+/**
+ * @fileoverview
+ * Facilitates the definition of analytical rules as passive observers.
+ *
+ * Rules implemented via this interface are designed for maximum performance,
+ * operating on pre-filtered node streams without performing independent
+ * AST traversals or resource allocations.
+ */
+
+type StreamType = 'AngularClass' | 'AnyAngularClass' | 'DecoratedProperty' | 'TemplateExpression' | 'TemplateAttribute' | 'TemplateBlock' | 'Template' | 'CallExpression' | 'NewExpression';
+/**
+ * Rule handler for a specific stream type.
+ *
+ * @template TNode - Node type from stream (pre-filtered, pre-analyzed)
+ */
+interface RuleHandler<TNode> {
+    readonly name: string;
+    readonly streamType: StreamType;
+    /**
+     * Evaluates a node from a pre-filtered analytical stream.
+     *
+     * Implementation must adhere to strict performance constraints, ensuring
+     * O(1) or near-constant time complexity and zero memory allocation.
+     *
+     * @param node The pre-analyzed AST node to evaluate.
+     * @param context The analytical context for the current file.
+     * @returns A rule failure, a collection of failures, or null if compliant.
+     */
+    handle(node: TNode, context: RuleContext): RuleFailure | RuleFailure[] | null;
+    readonly meta?: Partial<RuleMetadata>;
+}
+/**
+ * Helper to create component rule handlers.
+ */
+declare const createComponentRule: (name: string, handler: (node: AngularClassNode, context: RuleContext) => RuleFailure | RuleFailure[] | null, meta?: Partial<RuleMetadata>) => RuleHandler<AngularClassNode>;
+/**
+ * Helper to create rules that handle ANY Angular-decorated class:
+ * @Component, @Directive, @Pipe, @Injectable, @NgModule.
+ *
+ * Use this instead of createComponentRule when the rule applies to
+ * classes beyond just @Component and @Directive.
+ */
+declare const createAnyAngularClassRule: (name: string, handler: (node: AnyAngularClassNode, context: RuleContext) => RuleFailure | RuleFailure[] | null, meta?: Partial<RuleMetadata>) => RuleHandler<AnyAngularClassNode>;
+/**
+ * Helper to create decorated property rule handlers.
+ */
+declare const createDecoratedPropertyRule: (name: string, handler: (node: DecoratedPropertyNode, context: RuleContext) => RuleFailure | RuleFailure[] | null) => RuleHandler<DecoratedPropertyNode>;
+/**
+ * Helper to create template expression rule handlers.
+ */
+declare const createTemplateExpressionRule: (name: string, handler: (node: TemplateExpressionNode, context: RuleContext) => RuleFailure | RuleFailure[] | null, meta?: Partial<RuleMetadata>) => RuleHandler<TemplateExpressionNode>;
+/**
+ * Helper to create template attribute rule handlers.
+ */
+declare const createTemplateAttributeRule: (name: string, handler: (node: TemplateAttributeNode, context: RuleContext) => RuleFailure | RuleFailure[] | null, meta?: Partial<RuleMetadata>) => RuleHandler<TemplateAttributeNode>;
+/**
+ * Helper to create call expression rule handlers.
+ *
+ * Receives every CallExpression node in the file's AST exactly once.
+ * The handler is responsible for its own callee-shape filtering
+ * (e.g. checking for a StaticMemberExpression callee and a specific method name).
+ */
+declare const createCallExpressionRule: (name: string, handler: (node: CallExpression, context: RuleContext) => RuleFailure | RuleFailure[] | null, meta?: Partial<RuleMetadata>) => RuleHandler<CallExpression>;
+/**
+ * Helper to create new expression rule handlers.
+ */
+declare const createNewExpressionRule: (name: string, handler: (node: NewExpression, context: RuleContext) => RuleFailure | RuleFailure[] | null, meta?: Partial<RuleMetadata>) => RuleHandler<NewExpression>;
+/**
+ * Helper to create template block rule handlers.
+ */
+declare const createTemplateBlockRule: (name: string, handler: (node: TemplateBlockNode, context: RuleContext) => RuleFailure | RuleFailure[] | null, meta?: Partial<RuleMetadata>) => RuleHandler<TemplateBlockNode>;
+/**
+ * Helper to create template rules that receive the full template analysis.
+ */
+declare const createTemplateRule: (name: string, handler: (node: TemplateAnalysis, context: RuleContext) => RuleFailure | RuleFailure[] | null, meta?: Partial<RuleMetadata>) => RuleHandler<TemplateAnalysis>;
+
+/**
+ * @fileoverview
+ * Implements a high-performance visitor registry for O(1) node dispatch.
+ *
+ * This module facilitates the routing of AST nodes to their respective rule
+ * handlers by utilizing a static dispatch table, significantly optimizing the
+ * throughput of the single-pass engine.
+ */
+
+/**
+ * Compile-time exhaustiveness check.
+ * Every StreamType MUST have an entry here.
+ * Template streams use a sentinel prefix '__' — they are dispatched
+ * separately after the main AST walk and are skipped in buildVisitorMap.
+ */
+type StreamToNodeType = {
+    [K in StreamType]: string;
+};
+declare const STREAM_TO_NODE_TYPE: StreamToNodeType;
+/**
+ * A visitor entry bundles:
+ *  - the raw-node → stream-node filter function
+ *  - the rule handler
+ *  - failure collection reference
+ *  - per-rule timing reference
+ *
+ * This avoids closure allocation on the hot path by pre-binding everything
+ * at registry build time.
+ */
+interface VisitorEntry {
+    /** Rule name (for failure collection and timing) */
+    readonly ruleName: string;
+    /** Converts raw Oxc node → typed stream node (or null if not applicable) */
+    readonly filter: (rawNode: any) => unknown;
+    /** The rule handler's handle function (pre-bound) */
+    readonly handle: (streamNode: any, ctx: RuleContext) => RuleFailure | RuleFailure[] | null;
+}
+/**
+ * Maps Oxc node.type → array of VisitorEntry.
+ * Lookup is O(1) (Map.get), dispatch is O(H) where H = handlers for that type.
+ */
+type VisitorMap = ReadonlyMap<string, ReadonlyArray<VisitorEntry>>;
+/**
+ * Constructs a high-speed dispatch map from a collection of rule handlers.
+ *
+ * @param handlers A collection of rule handlers to include in the registry.
+ * @param streamFilters A mapping of stream types to their respective node filters.
+ * @returns A read-only VisitorMap optimized for O(1) lookup.
+ */
+declare function buildVisitorMap(handlers: ReadonlyArray<RuleHandler<any>>, streamFilters: Partial<Record<StreamType, (rawNode: any) => unknown>>): VisitorMap;
+
+/**
+ * @fileoverview
+ * Implements the performance-optimized single-pass analytical engine.
+ *
+ * This component is designed for maximum throughput, performing exactly one
+ * traversal of the Abstract Syntax Tree (AST) while dispatching nodes to
+ * passive observers via an O(1) visitor infrastructure.
+ *
+ * Key Performance Characteristics:
+ * - Linear Complexity: O(N) traversal in relation to the number of AST nodes.
+ * - Optimized Dispatch: Leverages a high-speed visitor map for node-type routing.
+ * - Resource Efficiency: Maintains strict execution budgets for individual rules.
+ */
+
+interface RuleTiming {
+    ruleName: string;
+    totalMs: number;
+    invocations: number;
+}
+interface PerformanceReport {
+    traversalMs: number;
+    nodesVisited: number;
+    ruleTimings: RuleTiming[];
+    cacheStats: {
+        hits: number;
+        misses: number;
+    };
+    budgetViolations: string[];
+    hasBudgetViolations: boolean;
+}
+/**
+ * Executes a comprehensive analytical pass over a provided AST program.
+ *
+ * @param rules A collection of rule handlers to evaluate during the pass.
+ * @param context The analytical context containing the program and metadata.
+ * @param options Operational configuration, including error collection.
+ * @returns A consolidated result set and performance diagnostic report.
+ */
+declare const runSinglePassAnalysis: (rules: ReadonlyArray<RuleHandler<any>>, context: RuleContext, options?: {
+    errorCollector?: InfrastructureErrorCollector;
+}) => {
+    results: RuleResult[];
+    performance: PerformanceReport;
+};
+
+/**
+ * @fileoverview
+ * Provides the RuleContextFactory for initializing rule execution contexts.
+ *
+ * This component is responsible for aggregating various analytical artifacts—including
+ * file content, AST structures, type information, and project metadata—into a
+ * unified RuleContext suitable for rule evaluation.
+ */
+
+/**
+ * Defines the operational boundaries for context construction.
+ * Encapsulates resource access requirements for both main-thread and worker-thread execution.
+ */
+interface ExecutionContext {
+    readonly rootDir: string;
+    readonly readFile: (filePath: string) => Promise<string>;
+    readonly getProgram: (filePath: string) => Promise<Program>;
+    readonly getTypeChecker?: (filePath: string) => Promise<TypeChecker | undefined>;
+    readonly getTemplate: (filePath: string) => Promise<TemplateAst | undefined>;
+    readonly getStyle: (filePath: string) => Promise<StyleAst | undefined>;
+    /**
+     * Retrieves the project-wide analytical context, if available.
+     */
+    readonly getProjectContext?: () => ProjectContext | undefined;
+    /**
+     * Retrieves the TypeScript SourceFile representation for a given path.
+     */
+    readonly getTsSourceFile?: (filePath: string) => ts.SourceFile | undefined;
+}
+/**
+ * Orschestrates the assembly of fully-resolved RuleContext objects.
+ *
+ * Decouples the rule execution logic from the underlying storage and retrieval
+ * mechanisms by utilizing the ExecutionContext abstraction.
+ */
+declare class RuleContextFactory {
+    private readonly context;
+    constructor(context: ExecutionContext);
+    /**
+     * Builds a RuleContext for the given file.
+     *
+     * @param filePath      - Absolute path to the file being analysed
+     * @param options       - Rule-specific options from the configuration
+     * @param needsTemplate - Whether the rule(s) in this batch require the template
+     * @returns A fully resolved RuleContext
+     */
+    build(filePath: string, options: Record<string, unknown>, needsTemplate: boolean): Promise<RuleContext>;
+    /**
+     * Builds a `ComponentCrossRef` for the given file path when that file is
+     * either a `.component.ts` class or its associated template.
+     *
+     * Returns `undefined` for all other file types.
+     */
+    private resolveExternalTemplatePath;
+    private buildCrossRef;
+    private getComponentSourceFile;
+}
+
+/**
+ * @fileoverview
+ * Provides the AnalysisContext abstraction for ngcompass.
+ *
+ * This module facilitates deterministic, memoized access to file system resources
+ * and abstract syntax tree (AST) artifacts, ensuring peak performance during
+ * analysis by minimizing redundant I/O and parsing operations.
+ *
+ * Implementation Strategy:
+ * - Memoization: Caches raw file content, TypeScript Programs, Template ASTs, and Style ASTs.
+ * - Resource Management: Implements an explicit eviction mechanism to control heap usage.
+ * - Determinism: Ensures the same file path always yields consistent artifacts across a run.
+ */
+
+/**
+ * Encapsulates the state and logic required for analyzing a set of source files.
+ * Provides unified access to file content and parsed metadata with internal memoization.
+ */
+interface AnalysisContext {
+    readonly rootDir: string;
+    readonly readFile: (filePath: string) => Promise<string>;
+    readonly getProgram: (filePath: string) => Promise<Program>;
+    readonly getTemplate: (filePath: string) => Promise<TemplateAst | undefined>;
+    readonly getStyle: (filePath: string) => Promise<StyleAst | undefined>;
+    /**
+     * Purges all cached artifacts associated with the specified file path.
+     *
+     * This method is critical for memory governance in large-scale repositories.
+     * It should be invoked immediately upon completion of a file's analysis tasks
+     * to release references to raw strings and AST structures, enabling garbage
+     * collection.
+     *
+     * @param filePath The path of the file to evict from internal caches.
+     */
+    readonly evict: (filePath: string) => void;
+}
+/**
+ * Instantiates an AnalysisContext provider with integrated memoization logic.
+ *
+ * @param rootDir The base directory used to resolve relative file transitions.
+ * @returns A stateful AnalysisContext instance.
+ */
+declare const createAnalysisContext: (rootDir: string) => AnalysisContext;
+
+/**
+ * @fileoverview
+ * Implements the high-level analysis orchestration pipeline.
+ *
+ * The orchestrator manages the lifecycle of an analysis run, coordinating
+ * task distribution across local threads and worker pools, while managing
+ * analytical state, result aggregation, and caching strategies.
+ */
+
+interface AnalysisFileProgress {
+    readonly filePath: string;
+    readonly taskCount: number;
+    readonly issueCount: number;
+    readonly errorCount: number;
+    readonly warningCount: number;
+    readonly duration: number;
+    readonly cached?: boolean;
+}
+
+/**
+ * Configuration parameters for the analysis orchestration process.
+ */
+interface AnalysisOptions {
+    /** Root directory for resolving file paths */
+    readonly rootDir: string;
+    /** Optional cache context for retrieving skipped task results */
+    readonly cache?: CacheContext;
+    /** Enable debug logging */
+    readonly debug?: boolean;
+    /**
+     * Maximum number of worker threads to use.
+     * Clamped to [1, os.cpus().length] (RFC §7.3 unified concurrency model).
+     * Defaults to os.cpus().length.
+     */
+    readonly maxWorkers?: number;
+    /**
+     * Number of tasks above which the worker pool is used instead of local
+     * pLimit execution.  Default: 150.
+     */
+    readonly parallelThreshold?: number;
+    /**
+     * Integrates an optional infrastructure error sink.
+     * When provided, operational errors are encapsulated and reported through
+     * this collector instead of triggering terminal exceptions.
+     */
+    readonly errorCollector?: InfrastructureErrorCollector;
+    /**
+     * All files discovered by the scanner for this run.
+     *
+     * CTX-001: Forwarded to `createTypeAwareAnalysisContext()` so the
+     * `ProjectContext` import-graph builder can restrict edges to intra-project
+     * imports and correctly populate `ProjectContext.projectFiles`.
+     *
+     * Optional for backward compatibility — when omitted the ProjectContext
+     * will still be built but `projectFiles` may be less complete (derived
+     * solely from the TypeScript Program's source-file list).
+     */
+    readonly files?: ReadonlyArray<string>;
+    /** Optional TypeScript parser settings from config. */
+    readonly parserOptions?: ParserOptions;
+    /**
+     * Maximum number of files per type-aware execution chunk.
+     *
+     * Type-aware tasks run on the main thread with a shared `ts.Program`.
+     * For large repos the Program can consume several GB.  Chunking splits
+     * the work: each chunk creates its own scoped Program, processes its
+     * tasks, then lets the Program be garbage-collected before the next chunk
+     * starts.  Smaller values reduce peak memory; larger values reduce the
+     * number of (expensive) `ts.createProgram` calls.
+     *
+     * Default: 400 files per chunk.  Set to `Infinity` to disable chunking.
+     */
+    readonly typeAwareChunkSize?: number;
+    /**
+     * When true, type-checker-dependent rules are skipped entirely.
+     * Use this as an escape valve for very large repos where even a chunked
+     * TS Program is too memory-intensive to build.
+     */
+    readonly skipTypeCheck?: boolean;
+    /**
+     * Called whenever a batch of tasks completes.
+     * @param completed - Total tasks finished so far (including cached).
+     * @param total     - Grand total tasks for this run (executed + cached).
+     */
+    readonly onProgress?: (completed: number, total: number) => void;
+    /** Called whenever all tasks for a file have completed. */
+    readonly onFileProgress?: (event: AnalysisFileProgress) => void;
+}
+/**
+ * Primary entry point for executing an analysis plan.
+ *
+ * Coordinates task execution strategies, manages result caching, and
+ * synthesizes the final analytical report.
+ *
+ * @param plan The execution plan containing tasks and cached metadata.
+ * @param options Configuration options for the orchestrator.
+ * @returns A promise resolving to an AnalysisResult encapsulation.
+ */
+declare const runAnalysis: (plan: ExecutionPlanOutput, options: AnalysisOptions) => Promise<Result<AnalysisResult>>;
+
+/**
+ * @fileoverview
+ * Facilitates the construction of the ProjectContext for ngcompass.
+ *
+ * This module performs a traversal of the TypeScript module graph to assemble
+ * a comprehensive, read-only representation of the project structure. This
+ * includes import relationships, component clusters, and Angular-specific
+ * metadata (e.g., NgModule declarations).
+ *
+ * Implementation Strategy:
+ * - Efficient Traversal: Analyzes the resolved module graph in O(F + E) time.
+ * - Structural Disambiguation: Detects barrel files and component clusters.
+ * - Angular Awareness: Integrates decorator metadata for standalone and NgModule discovery.
+ */
+
+/**
+ * Constructs a ProjectContext immutable structure from a TypeScript Program.
+ *
+ * @param program The ts.Program instance used for type-aware analysis.
+ * @param files A collection of file paths identified during the scanning phase.
+ * @param rootDir The absolute path to the project root directory.
+ * @param componentFiles An optional mapping of component-related file clusters.
+ * @returns A fully initialized ProjectContext instance.
+ */
+declare function buildProjectContext(program: ts.Program, files: ReadonlyArray<string>, rootDir: string, componentFiles?: ReadonlyMap<string, ComponentFiles>): ProjectContext;
+
+/**
+ * Enhances the baseline AnalysisContext with semantic and project-wide data.
+ */
+interface TypeAwareAnalysisContext extends AnalysisContext {
+    /**
+     * Retrieves the TypeScript TypeChecker for semantic analysis.
+     */
+    readonly getTypeChecker: (filePath: string) => Promise<ts.TypeChecker | undefined>;
+    /**
+     * Retrieves the pre-built, immutable ProjectContext for the current run.
+     */
+    readonly getProjectContext: () => ProjectContext | undefined;
+    /**
+     * Retrieves the TypeScript SourceFile representation for a given path.
+     */
+    readonly getTsSourceFile: (filePath: string) => ts.SourceFile | undefined;
+    /**
+     * Performs an explicit initialization phase for type-aware resources.
+     */
+    readonly warmup: () => Promise<void>;
+}
+/**
+ * Initializes a TypeAwareAnalysisContext for the specified root directory.
+ *
+ * @param rootDir The absolute path to the project root.
+ * @param files A collection of file paths identified during the scanning phase.
+ * @returns A fully initialized TypeAwareAnalysisContext instance.
+ */
+declare const createTypeAwareAnalysisContext: (rootDir: string, files?: ReadonlyArray<string>, parserOptions?: ParserOptions) => TypeAwareAnalysisContext;
+
+/**
+ * @fileoverview
+ * Provides the core execution runner for ngcompass.
+ *
+ * This module consolidates the rule execution logic utilized by both local
+ * sequential processes and worker-based parallel execution. It manages task
+ * batching, result mapping, and operational error handling.
+ */
+
+/**
+ * Executes a collection of analysis tasks for a specific file.
+ *
+ * Processes tasks by grouping them into optimized execution batches. Utilizes
+ * the RuleContextFactory for resource initialization and coordinates with
+ * the configured rule executor for evaluation.
+ *
+ * @param tasks A collection of tasks to execute against a single file path.
+ * @param context The operational context providing resource access.
+ * @param errorCollector An optional sink for operational error reporting.
+ * @returns A promise resolving to a collection of rule execution results.
+ */
+declare const executeBatchedTasks: (tasks: ReadonlyArray<Task>, context: ExecutionContext, errorCollector?: InfrastructureErrorCollector) => Promise<RuleResult[]>;
+
+/**
+ * @fileoverview
+ * Establishes a dependency injection boundary for rule execution.
+ *
+ * This module facilitates the decoupling of the engine's core orchestration layer
+ * from the concrete rule implementations, mitigating circular dependency risks.
+ */
+
+/**
+ * Executes multiple rules in a single AST pass and returns their results.
+ * Implemented by rules/src/engine/adapter.ts → executeBatchedNewEngineRules.
+ */
+type BatchRuleExecutorFn = (ruleNames: ReadonlyArray<string>, context: RuleContext) => ReadonlyArray<RuleResult>;
+/**
+ * Returns true if a rule with the given name is registered in the engine.
+ * Implemented by rules/src/engine/adapter.ts → isNewEngineRule.
+ */
+type RuleCheckerFn = (ruleName: string) => boolean;
+/**
+ * Configures the analytical engine with specific rule execution and validation logic.
+ *
+ * This method must be invoked during the initialization phase of the process
+ * to register the underlying rule processing capabilities.
+ *
+ * @param executor The implementation responsible for batched rule evaluation.
+ * @param checker The implementation responsible for rule presence verification.
+ */
+declare const configureRuleExecutor: (executor: BatchRuleExecutorFn, checker: RuleCheckerFn) => void;
+
+/**
+ * @fileoverview
+ * Facilitates the calculation of aggregate analytical metrics.
+ *
+ * This module provides utilities to derive summary statistics from rule execution
+ * results, including file counts, severity distributions, and execution durations.
+ */
+
+/**
+ * Computes comprehensive analytical statistics based on raw rule results.
+ *
+ * @param results A collection of rule execution results.
+ * @param startTime The high-resolution timestamp indicating the start of execution.
+ * @param cacheHitRate An optional precalculated cache hit ratio [0, 1].
+ * @returns An object encapsulating the aggregated statistical data.
+ */
+declare const calculateStats: (results: ReadonlyArray<RuleResult>, startTime: number, cacheHitRate?: number) => AnalysisResult["stats"];
+
+/**
+ * @fileoverview
+ * Defines engine-level constants and performance benchmarks for ngcompass.
+ *
+ * This module serves as the centralized source of truth for architectural
+ * thresholds, concurrency limits, and performance budgets used across the
+ * orchestration and execution layers.
+ */
+/**
+ * The minimum number of worker threads to maintain in the execution pool,
+ * ensuring availability regardless of the host system's CPU topology.
+ */
+declare const MIN_WORKER_COUNT = 2;
+/**
+ * The refresh interval for the command-line interface progress visualization.
+ */
+declare const SPINNER_FRAME_INTERVAL_MS = 80;
+/**
+ * Maximum wall-clock time a single worker thread is allowed to run before it
+ * is forcibly terminated and its results replaced with empty failures.
+ *
+ * 60 seconds is intentionally generous — the timeout is a last-resort safety
+ * net for hung workers (e.g. infinite loops or deadlocked TypeScript programs),
+ * not a performance budget.
+ */
+declare const WORKER_TIMEOUT_MS = 60000;
+/**
+ * Performance Budgets:
+ * Thresholds used to monitor and report execution efficiency.
+ */
+/**
+ * The target execution time (p95) per file for rules that do not utilize
+ * type-checking services.
+ */
+declare const BUDGET_MS_PER_FILE_WITHOUT_TYPES = 2;
+/**
+ * The target execution time (p95) per file for rules requiring full
+ * type-checking capabilities.
+ */
+declare const BUDGET_MS_PER_FILE_WITH_TYPES = 5;
+
+/**
+ * @fileoverview
+ * Provides a terminal-based progress visualization utility.
+ *
+ * Implements a high-efficiency visual indicator (spinner) for long-running
+ * command-line operations, isolated from core analytical logic.
+ */
+/**
+ * Manages the state and rendering of a terminal-based progress indicator.
+ */
+declare class Spinner {
+    private frameIndex;
+    private interval;
+    private message;
+    start(message: string): void;
+    update(message: string): void;
+    stop(finalMessage?: string): void;
+}
+
+/**
+ * @fileoverview
+ * Manages parallel analysis execution utilizing worker thread pools.
+ *
+ * Coordinates the distribution of analytical tasks across multiple workers to
+ * maximize CPU utilization. Provides a resilient fallback to local concurrent
+ * execution if worker resources are unavailable.
+ */
+declare const runAnalysisParallel: (tasks: ReadonlyArray<Task>, rootDir: string, startTime: number, maxWorkers?: number, concurrency?: number, onFileProgress?: (event: AnalysisFileProgress) => void) => Promise<Result<AnalysisResult>>;
+
+export { type AnalysisContext, type AnalysisFileProgress, type AnalysisOptions, BUDGET_MS_PER_FILE_WITHOUT_TYPES, BUDGET_MS_PER_FILE_WITH_TYPES, type BatchRuleExecutorFn, type ExecutionContext, MIN_WORKER_COUNT, type PerformanceReport, type RuleCheckerFn, RuleContextFactory, type RuleHandler, SPINNER_FRAME_INTERVAL_MS, STREAM_TO_NODE_TYPE, Spinner, type StreamType, type TypeAwareAnalysisContext, type VisitorEntry, type VisitorMap, WORKER_TIMEOUT_MS, buildProjectContext, buildVisitorMap, calculateStats, configureRuleExecutor, createAnalysisContext, createAnyAngularClassRule, createCallExpressionRule, createComponentRule, createDecoratedPropertyRule, createNewExpressionRule, createTemplateAttributeRule, createTemplateBlockRule, createTemplateExpressionRule, createTemplateRule, createTypeAwareAnalysisContext, executeBatchedTasks, runAnalysis, runAnalysisParallel, runSinglePassAnalysis };