@omlet/cli/dist/node-src/analyzer.d.ts

Omlet (https://omlet.dev) is a component analytics tool that uses a CLI to scan your codebase to detect components and their usage. Get real usage insights from customizable charts to measure adoption across all projects and identify opportunities to impr

import { type Workspace } from "./apiClient";
import { type Config } from "./config";
import { CliError } from "./error";
import { type ResolutionConfigIssue, type ProjectSetup } from "./projectUtils";
interface AnalyzeOptions {
    dryRun?: boolean;
    cliVersion: string;
    verifySetup: boolean;
    quiet: boolean;
    cliParams: {
        configPath?: string;
        include?: string[];
        ignore?: string[];
        tsconfigPath?: string;
        hookScript?: string;
    };
    showSummary: boolean;
}
interface InitCmdOptions {
    cliVersion: string;
    verifySetup: boolean;
    quiet: boolean;
}
declare type AnalyzeCmdOptions = Omit<AnalyzeOptions, "showSummary">;
export interface ModuleId {
    hash: string;
    path: string;
    mtype: "package" | "local";
    package_name: string;
}
export interface SymbolWithSource {
    source: ModuleId;
    symbol: string;
}
export interface ReferenceWithSource {
    source: ModuleId;
    reference: string;
}
export interface ComponentDependencyNode extends SymbolWithSource {
    id: string;
    name: string;
}
export interface CharacterPosition {
    line: number;
    column: number;
}
export interface ComponentPropUsage {
    name: string;
    value: PropValue;
}
export interface ComponentUsage {
    start: CharacterPosition;
    end: CharacterPosition;
    props: ComponentPropUsage[];
}
export interface ComponentReference {
    usages: ComponentUsage[];
    trace: SymbolWithSource[];
}
export interface ComponentDependency {
    from: ComponentDependencyNode;
    to: ComponentDependencyNode;
    references: ComponentReference[];
}
export interface Export {
    name: string;
    module_id: ModuleId;
    is_component: unknown;
    trace_to_declaration: ReferenceWithSource[];
    inferredType?: unknown;
    resolvedType?: unknown;
}
export interface AnalysisStats {
    num_of_components: number;
    num_of_modules: number;
    num_of_exports: number;
    num_of_dependencies: number;
    num_of_commits?: number;
    num_of_deltas?: number;
    analyze_duration_msec?: number;
    parse_duration_msec?: number;
    date_extraction_msec?: number;
    mem_usages: {
        before_scan_rss: number;
        after_file_dates_rss: number;
        after_project_setup_rss: number;
        after_parse_rss: number;
        after_analyze_rss: number;
    };
}
interface Module {
    source_path: string;
    id: ModuleId;
    exports: unknown[];
    scopes: unknown[];
    body: unknown[];
}
export declare enum ObjectPropType {
    KeyValue = "KeyValue",
    Shorthand = "Shorthand",
    Spread = "Spread"
}
export declare type ObjectProp = {
    type: ObjectPropType.KeyValue;
    key: string;
    value: PropValue;
} | {
    type: ObjectPropType.Shorthand;
    key: string;
} | {
    type: ObjectPropType.Spread;
    value: PropValue;
};
export declare enum PropValueType {
    String = "String",
    Number = "Number",
    Identifier = "Identifier",
    Bool = "Bool",
    Regex = "Regex",
    Null = "Null",
    JSXElement = "JSXElement",
    Function = "Function",
    Getter = "Getter",
    Setter = "Setter",
    Array = "Array",
    Object = "Object",
    Spread = "Spread",
    Member = "Member",
    This = "This",
    Super = "Super",
    TemplateLiteral = "TemplateLiteral",
    Expression = "Expression"
}
export declare type PropValue = {
    type: PropValueType.String | PropValueType.Identifier;
    value: string;
} | {
    type: PropValueType.Number;
    value: number;
} | {
    type: PropValueType.Bool;
    value: boolean;
} | {
    type: PropValueType.Regex;
    value: string;
    flags: string;
} | {
    type: PropValueType.Array;
    values: PropValue[];
} | {
    type: PropValueType.Spread;
    value: PropValue;
} | {
    type: PropValueType.Member;
    value: PropValue;
    property: PropValue;
} | {
    type: PropValueType.Object;
    props: ObjectProp[];
} | {
    type: PropValueType.Null | PropValueType.JSXElement | PropValueType.Function | PropValueType.Getter | PropValueType.Setter | PropValueType.This | PropValueType.Super | PropValueType.TemplateLiteral | PropValueType.Expression;
};
export interface Prop {
    name: string;
    default_value?: unknown;
    span: {
        start: CharacterPosition;
        end: CharacterPosition;
    };
}
export interface Component {
    id: string;
    export_ids: string[];
    name: string;
    package_name: string;
    created_at?: Date;
    updated_at?: Date;
    source: SymbolWithSource;
    dependencies: ComponentDependency[];
    props: Prop[];
    html_elements: string[];
    metadata?: Record<string, string | number | boolean | Date>;
    span?: {
        start: CharacterPosition;
        end: CharacterPosition;
    };
}
declare class TSParseError extends CliError {
    readonly reason: string[];
    readonly file: string;
    constructor(reason: string[], file: string);
}
export declare class WorkspaceNotSetup extends CliError {
    constructor();
}
export declare class NoModuleFound extends CliError {
    readonly projectRootPath: string;
    readonly config: Config;
    constructor(data: {
        projectRootPath: string;
        config: Config;
    });
}
export declare class NoComponentFound extends CliError {
    readonly projectRootPath: string;
    readonly numberOfModules: number;
    readonly config: Config;
    constructor(data: {
        projectRootPath: string;
        config: Config;
        numberOfModules: number;
    });
}
export declare class AnalysisLimitReachedError extends CliError {
    constructor();
}
interface InvalidDependency {
    package_name: string;
    path: string;
    source_package_name: string;
}
export interface AnalyzeResult {
    components: Component[];
    exports: Export[];
    alias_map: Pick<ProjectSetup, "packages" | "root">;
    meta: AnalysisStats & {
        duration_msec: number;
        cli_version: string;
        cli_params: Record<string, unknown>;
        cli_config: Config;
        argv: string;
        node_version: string;
        device_info: {
            os: string;
            arch: string;
            version: string;
        };
        ci_vendor?: string;
    };
    parser_errors: TSParseError[];
    setup_issues: ResolutionConfigIssue[];
    invalid_dependencies: InvalidDependency[];
    repository?: {
        scope?: string;
        name?: string;
        branch?: string;
        url?: string;
        initialCommitHash: string;
    };
}
export declare function parse(projectRoot: string, config: Config): Promise<Module[]>;
export declare function getWorkspace(): Promise<Workspace>;
export declare function analyzeRepo(projectRoot: string, options: AnalyzeOptions): Promise<AnalyzeResult>;
export interface AnalyzeToJsonOptions {
    root?: string;
    include?: string[];
    ignore?: string[];
    configPath?: string;
    tsconfigPath?: string;
    verify?: boolean;
}
export declare function analyzeToJson(options: AnalyzeToJsonOptions): Promise<AnalyzeResult>;
export declare function analyze(projectRoot: string, options: AnalyzeCmdOptions): Promise<void>;
export declare function init(projectRoot: string, options: InitCmdOptions): Promise<void>;
export interface AnalyzePartialOptions {
    root?: string;
    modifiedFiles: string[];
    relatedFiles: string[];
    ignore?: string[];
    configPath?: string;
    tsconfigPath?: string;
    verify?: boolean;
}
export declare function analyzePartialToJson(options: AnalyzePartialOptions): Promise<AnalyzeResult>;
export {};