@rsdoctor/types 1.5.8 → 1.5.10

package/dist/sdk/module.d.cts

@@ -0,0 +1,405 @@
+import type { Program } from 'estree';
+import type { SourceMapConsumer } from 'source-map';
+import type { NonFunctionProperties } from '../common';
+import type { ChunkInstance } from './chunk';
+import type { BriefModeOptions } from '../config';
+import type { StatementInstance, StatementData } from './statement';
+import type { PackageData } from './package';
+import type { ModuleGraphModuleInstance, ModuleGraphModuleData, ExportData, ExportInstance, SideEffectData, SideEffectInstance, VariableData, VariableInstance } from './treeShaking';
+import type { StatsModule } from '../plugin';
+export declare enum DependencyKind {
+    Unknown = 0,
+    ImportStatement = 1,
+    DynamicImport = 2,
+    RequireCall = 3,
+    AMDRequire = 4
+}
+/** Source code location */
+export interface SourcePosition {
+    line?: number;
+    column?: number;
+    index?: number;
+}
+/** Source code range */
+export interface SourceRange {
+    start: SourcePosition;
+    end?: SourcePosition;
+}
+/** Side effect location from bundler (e.g. Rspack JsRsdoctorSideEffectLocation) */
+export interface SideEffectLocationData {
+    location: string;
+    nodeType: string;
+    module: number;
+    request: string;
+}
+/** Pre-computed side-effects-only import result (from Rust analysis) */
+export interface ConnectionsOnlyImportData {
+    moduleUkey: number;
+    modulePath: string;
+    connections: Array<{
+        originModule?: number;
+        dependencyType: string;
+        userRequest: string;
+    }>;
+}
+/** Side effect code snippet data */
+export interface SideEffectCodeData {
+    /** Module ID */
+    moduleId: number;
+    /** Start line number (1-indexed) */
+    startLine: number;
+    /** Extracted source code snippet */
+    code: string;
+}
+/** Module size */
+export interface ModuleSize {
+    sourceSize: number;
+    /** Code size after transformed */
+    transformedSize: number;
+    /**
+     * Code size after compiled
+     *   - The size the module occupies in the product after packing.
+     */
+    parsedSize: number;
+    /**
+     * Gzipped size of the module source (optional)
+     */
+    gzipSize: number;
+}
+/** Module source code */
+export interface ModuleSource {
+    /** source code */
+    source: string;
+    /** transformed code */
+    transformed: string;
+    parsedSource: string;
+}
+/** Module Metadata */
+export interface ModuleBuildMeta {
+    /**
+     * Whether to include the esModule flag statement
+     * ```js
+     * Object.defineProperty(exports, "__esModule", { value: true });
+     * ```
+     *   - This statement usually appears in the object code of the tsc to cjs module.
+     */
+    hasSetEsModuleStatement: boolean;
+    /**
+     * Strict ESM module.
+     */
+    strictHarmonyModule: boolean;
+    packageData?: PackageData;
+}
+/** Module type */
+export declare enum ModuleKind {
+    /** Normal module */
+    Normal = 0,
+    /** Aggregation module */
+    Concatenation = 1
+}
+export declare enum ToDataType {
+    NoCode = 0,
+    /** Normal mode */
+    Normal = 1,
+    /** Lite mode: no source code */
+    NoSource = 2,
+    /** Lite & No Assets Code mode */
+    NoSourceAndAssets = 3,
+    /** All Data, include module transformed data. */
+    All = 4
+}
+export interface ModuleInstance {
+    /** Module identifier */
+    readonly id: number;
+    /** webpack render identifier */
+    readonly renderId?: string;
+    /** webpack identifier */
+    readonly webpackId: string;
+    /** Module path */
+    readonly path: string;
+    readonly isEntry: boolean;
+    readonly kind: ModuleKind;
+    /** Root module in aggregate module */
+    readonly rootModule?: ModuleInstance;
+    readonly layer?: string;
+    /**
+     * Preference to source location
+     *   - Indicates that the source code is not empty and there is source code location mapping data.
+     */
+    isPreferSource: boolean;
+    /** Build properties */
+    meta: ModuleBuildMeta;
+    /** Issuer paths */
+    issuerPath?: StatsModule['issuerPath'];
+    bailoutReason?: string[];
+    /** Get the Chunks instance where the module in.*/
+    getChunks(): ChunkInstance[];
+    /** Add Chunk instance */
+    addChunk(chunk: ChunkInstance): void;
+    removeChunk(chunk: ChunkInstance): void;
+    getDependencies(): DependencyInstance[];
+    getDependencyByRequest(request: string): DependencyInstance | undefined;
+    /** Get dependency data from module */
+    getDependencyByModule(module: ModuleInstance): DependencyInstance | undefined;
+    removeDependency(dependency: DependencyInstance): void;
+    /** Remove dependency data from module */
+    removeDependencyByModule(module: ModuleInstance): void;
+    removeImported(module: ModuleInstance): void;
+    getImported(): ModuleInstance[];
+    addImported(module: ModuleInstance): void;
+    addDependency(request: string, module: ModuleInstance, kind: DependencyKind, statements?: StatementInstance[]): DependencyInstance | undefined;
+    toData(contextPath?: string, isBrief?: boolean): ModuleData;
+    setSource(source: Partial<ModuleSource>): void;
+    getSource(type?: ToDataType): ModuleSource;
+    /**Set code AST after transform */
+    setProgram(program: Program): void;
+    /** Get the converted code AST */
+    getProgram(): Program | undefined;
+    /** Set module size information */
+    setSize(size: Partial<ModuleSize>): void;
+    getSize(): ModuleSize;
+    setSourceMap(sourcemap: SourceMapConsumer): void;
+    /** Get source code mapping */
+    getSourceMap(): SourceMapConsumer | undefined;
+    /**
+     * Generate statement instances
+     * @param transformed {SourceRange} The location of the transformed code.
+     */
+    getStatement(transformed: SourceRange): StatementInstance | undefined;
+    /**
+     * Generate original code location
+     * @param transformed {SourceRange} The location of the transformed code.
+     */
+    getSourceRange(transformed: SourceRange): SourceRange | undefined;
+    /** Add connected submodules */
+    addNormalModule(module: ModuleInstance): void;
+    /** If it is currently a connection module, return all connected base sub packages */
+    getNormalModules(): ModuleInstance[];
+    /** Added aggregation module */
+    addConcatenationModule(module: ModuleInstance): void;
+    /** Get all aggregated modules to which the current module belongs */
+    getConcatenationModules(): ModuleInstance[];
+    setId(id: number): void;
+    setChunks(chunks: ChunkInstance[]): void;
+    setDependencies(dependencies: DependencyInstance[]): void;
+    setImported(imported: ModuleInstance[]): void;
+    setModules(modules: ModuleInstance[]): void;
+    setConcatenationModules(modules: ModuleInstance[]): void;
+    setRenderId(renderId: string): void;
+    /** Add an issuer path */
+    addIssuerPath(issuerPath: StatsModule['issuerPath']): void;
+    /** Get issuer path */
+    getIssuerPath(): StatsModule['issuerPath'];
+    /** Add bailout reason */
+    addBailoutReason(reason: string): void;
+    /** Get bailout reason */
+    getBailoutReason(): string[];
+    /** Side effect location data (e.g. from Rspack sideEffectsLocations) */
+    sideEffectLocations?: SideEffectLocationData[];
+    /** Add a side effect location */
+    addSideEffectLocation(location: SideEffectLocationData): void;
+    /** Get side effect locations */
+    getSideEffectLocations(): SideEffectLocationData[];
+    /** Add side effect code */
+    addSideEffectCode(codeData: SideEffectCodeData): void;
+    /** Get side effect codes */
+    getSideEffectCodes(): SideEffectCodeData[];
+}
+/** Depends on Metadata */
+export interface DependencyBuildMeta {
+    /**
+     * Types of dependencies between modules
+     *   - The basis for webpack to add runtime to modules.
+     *
+     * @link https://github.com/webpack/webpack/blob/v5.75.0/lib/Module.js#L428
+     * @link https://github.com/webpack/webpack/blob/v4.46.0/lib/RuntimeTemplate.js#L215
+     */
+    exportsType: 'namespace' | 'default-only' | 'default-with-named' | 'dynamic';
+}
+export interface DependencyInstance {
+    /** Identifier */
+    readonly id: number;
+    /**
+     * Original request
+     *  - refers to the original request in the import statement
+     *  - @example `import {Instance} from'chalk'` in the statement 'chalk'
+     */
+    readonly request: string;
+    /** actual requested path */
+    readonly resolvedRequest: string;
+    /** Module */
+    readonly module: ModuleInstance;
+    /**
+     * Dependency Module
+     * - Always non-aggregated modules
+     */
+    readonly dependency: ModuleInstance;
+    /**
+     * Original dependency module
+     * - Aggregation module preferred
+     */
+    readonly originDependency: ModuleInstance;
+    /**
+     * Citation method
+     * - Numeric enumeration
+     */
+    readonly kind: DependencyKind;
+    /**
+     * Citation method
+     * - string enumeration
+     */
+    readonly kindString: keyof typeof DependencyKind;
+    /**
+     * Original dependency type string from the bundler (e.g. 'cjs require', 'cjs full require', 'esm import')
+     */
+    typeString?: string;
+    /** Whether to connect to the aggregation module */
+    readonly resolveConcatenationModule: boolean;
+    /** quote statement */
+    readonly statements: StatementInstance[];
+    /** build attribute */
+    meta: DependencyBuildMeta;
+    /** Generate data */
+    toData(): DependencyData;
+    /** Add statement */
+    addStatement(statement: StatementInstance): void;
+    /** Whether this statement is included */
+    hasStatement(statement: StatementInstance): boolean;
+    /**
+     * Is it the same dependency?
+     * - Check properties other than id and statements
+     */
+    isSameWithoutStatements(dep: DependencyInstance): boolean;
+    setBuildMeta(data: DependencyBuildMeta): void;
+    setId(id: number): void;
+}
+export type ModuleGraphToDataArgs = {
+    contextPath: string;
+    briefOptions?: BriefModeOptions;
+};
+export interface ModuleGraphInstance {
+    /** Clear data */
+    clear(): void;
+    /** How many modules are there in total */
+    size(): number;
+    /** overwrite data */
+    fromInstance(data: ModuleGraphInstance): void;
+    /** Create module connection data */
+    addModuleGraphModule(info: ModuleGraphModuleInstance): void;
+    /** Get module connection data */
+    getModuleGraphModule(module: ModuleInstance): ModuleGraphModuleInstance;
+    /** Get all module connection data */
+    getModuleGraphModules(): ModuleGraphModuleInstance[];
+    /** Get all modules */
+    getModules(): ModuleInstance[];
+    /** Get all modules */
+    getDependencies(): DependencyInstance[];
+    /** Get connection by id */
+    getDependencyById(id: number): DependencyInstance | undefined;
+    /** Get entrance module */
+    getEntryModules(): ModuleInstance[];
+    /** Get the subgraph of the current node as the entry point */
+    getSubGraphByModule(module: ModuleInstance): ModuleInstance[];
+    /** Get module by id */
+    getModuleById(id: number): ModuleInstance | undefined;
+    /** get module by webpackId */
+    getModuleByWebpackId(webpackId: string): ModuleInstance | undefined;
+    /** Get module by path */
+    getModuleByFile(file: string, layer?: string): ModuleInstance[] | [];
+    /** Add Module */
+    addModule(module: ModuleInstance): void;
+    /** Add module connection */
+    addDependency(module: DependencyInstance): void;
+    /**
+     * Remove module
+     * - The connection relationship of this module will also be removed
+     */
+    removeModule(module: ModuleInstance): void;
+    /**
+     * Remove connection
+     * - If one of the connected endpoints is an independent module, this module will also be removed from the module diagram
+     */
+    removeDependency(dependency: DependencyInstance): void;
+    /** Add export data */
+    addExportInfo(data: ExportInstance): void;
+    /** Add side effect data */
+    addSideEffect(data: SideEffectInstance): void;
+    /** Add variable data */
+    addVariable(data: VariableInstance): void;
+    /** Generate data */
+    toData(configs?: ModuleGraphToDataArgs): ModuleGraphData;
+    /** Generate tree shaking data */
+    toTreeShakingData(): TreeShakingData;
+    /** Generate data */
+    toCodeData(type?: ToDataType): ModuleCodeData;
+    setModules(modules: ModuleInstance[]): void;
+    setDependencies(dependencies: DependencyInstance[]): void;
+    setConnectionsOnlyImports(items: ConnectionsOnlyImportData[]): void;
+    getConnectionsOnlyImports(): ConnectionsOnlyImportData[];
+}
+export interface ModuleData extends Omit<NonFunctionProperties<ModuleInstance>, 'rootModule' | 'isEntry' | 'concatenationModules' | 'meta' | 'issuerPath'> {
+    /** chunk identifier */
+    chunks: string[];
+    /** Module identifier on which the module depends */
+    dependencies: number[];
+    /** Identifier of the dependent module */
+    imported: number[];
+    /** Is it an entrance module */
+    isEntry?: boolean | undefined;
+    /** Use source code location first */
+    isPreferSource: boolean;
+    /** Module size */
+    size: ModuleSize;
+    layer?: string;
+    /** Connected base subpackage */
+    modules?: number[];
+    /** root module number */
+    rootModule?: number;
+    /** Affiliated aggregation module number */
+    concatenationModules?: number[];
+    /** Module Id */
+    webpackId: string;
+    /** Build original attributes */
+    meta?: Partial<Omit<ModuleBuildMeta, 'packageData'>>;
+    /** Issuer path */
+    issuerPath?: string[] | number[];
+    /** Side effect location data (e.g. from Rspack sideEffectsLocations) */
+    sideEffectLocations?: SideEffectLocationData[];
+}
+export type ModuleCodeData = Record<number, ModuleSource>;
+/** Tree shaking analysis data */
+export interface TreeShakingData {
+    sideEffectCodes: Record<number, SideEffectCodeData[]>;
+}
+export interface DependencyData extends Omit<NonFunctionProperties<DependencyInstance>, 'module' | 'dependency' | 'statements' | 'originDependency' | 'kindString' | 'resolveConcatenationModule' | 'meta'> {
+    /** Module Identifier */
+    module: number;
+    /** Dependency Module Identifier */
+    dependency: number;
+    /** Original module identifier */
+    originDependency: number;
+    /** quote statement */
+    statements: StatementData[];
+}
+/** Module connection data from rspack module graph */
+export interface ConnectionData {
+    ukey: number;
+    dependencyId: string;
+    module: number;
+    originModule?: number;
+    resolvedModule: number;
+    dependencyType: string;
+    userRequest: string;
+    loc?: string;
+    active: boolean;
+}
+export interface ModuleGraphData {
+    dependencies: DependencyData[];
+    modules: ModuleData[];
+    moduleGraphModules: ModuleGraphModuleData[];
+    exports: ExportData[];
+    sideEffects: SideEffectData[];
+    variables: VariableData[];
+    layers?: string[];
+    connections?: ConnectionData[];
+}

package/dist/sdk/package.d.cts

@@ -0,0 +1,124 @@
+import type { ModuleInstance, DependencyInstance, ModuleSize } from './module';
+import type { NonFunctionProperties } from '../common';
+export interface PackageJSONData {
+    /** package name */
+    name: string;
+    version: string;
+    type?: string;
+}
+export interface PackageBasicData extends PackageJSONData {
+    /** Directory where the package is located */
+    root: string;
+}
+export type CrossChunksPackageType = {
+    module: {
+        id: number;
+        path: string;
+    };
+    chunks: {
+        name: string;
+    }[];
+};
+export interface PackageInstance extends PackageBasicData {
+    id: number;
+    duplicates?: CrossChunksPackageType[];
+    setDuplicates(data: CrossChunksPackageType): void;
+    /** Get all modules contained in the package */
+    getModules(): ModuleInstance[];
+    /** Get all dependencies */
+    getDependencies(): PackageDependencyInstance[];
+    /** Get the dependency chain of the current package */
+    getDependenciesChain(graph: PackageGraphInstance): PackageDependencyInstance[];
+    /** Get all dependencies */
+    getImported(): PackageInstance[];
+    addModule(module: ModuleInstance): void;
+    /** Add package dependencies */
+    addDependency(dep: PackageDependencyInstance): void;
+    /** Add dependency */
+    addImported(pkg: PackageInstance): void;
+    /** Whether this path is included */
+    contain(path: string): boolean;
+    /** Is it the same package */
+    isSame(pkg: PackageInstance): boolean;
+    /** Get package size */
+    getSize(): ModuleSize;
+    /** Get data */
+    toData(): PackageData;
+}
+export interface PackageData extends NonFunctionProperties<PackageInstance> {
+    modules?: number[];
+    size: ModuleSize;
+}
+export interface PackageDependencyInstance {
+    /** Number */
+    id: number;
+    /** Dependency package */
+    dependency: PackageInstance;
+    /**
+     * Current package
+     * - This item is local package data when using user code
+     */
+    package: PackageInstance;
+    /** Module dependency where the dependency statement is located */
+    refDependency: DependencyInstance;
+    /** Is it the same reference */
+    isSame(dep: PackageDependencyInstance): boolean;
+    /** Get data */
+    toData(): PackageDependencyData;
+}
+export interface PackageDependencyData extends Omit<NonFunctionProperties<PackageDependencyInstance>, 'dependency' | 'package' | 'refDependency'> {
+    dependency: number;
+    package: number;
+    refDependency: number;
+}
+/**
+ * Get the contents of the package.json file
+ * @param {string} Relative project root directory path
+ */
+export type GetPackageFile = (path: string) => PackageJSONData | undefined;
+export interface PackageGraphInstance {
+    /**
+     * Get all package data
+     */
+    getPackages(): PackageInstance[];
+    /**
+     * Get package data from module
+     * The new package will create new data and join the cache
+     * - If created, old data will be returned
+     */
+    getPackageByModule(module: ModuleInstance, readFile?: GetPackageFile): PackageInstance | undefined;
+    /**
+     * Get package data from file
+     * - No new data will be created
+     */
+    getPackageByFile(file: string): PackageInstance | undefined;
+    /**
+     * Get package data from data
+     * - No new data will be created
+     */
+    getPackageByData(data: PackageBasicData): PackageInstance | undefined;
+    /**
+     * Get package data from name
+     */
+    getPackagesByName(name: string): PackageInstance[];
+    /**
+     * Get dependencies from package
+     * - The input package is dependent
+     */
+    getDependenciesFromPackage(pkg: PackageInstance): PackageDependencyInstance[];
+    /** Get package dependencies imported from user code */
+    getDependenciesFromOrigin(): PackageDependencyInstance[];
+    /** Add package data */
+    addPackage(pkg: PackageInstance): void;
+    /** Add dependency data */
+    addDependency(dep: PackageDependencyInstance): void;
+    /** Get duplicate package data */
+    getDuplicatePackages(): PackageInstance[][];
+    toData(): PackageGraphData;
+}
+export interface PackageGraphData {
+    packages: PackageData[];
+    dependencies: PackageDependencyData[];
+}
+export interface OtherReports {
+}

package/dist/sdk/plugin.d.cts

@@ -0,0 +1,21 @@
+import { DevToolErrorInstance } from '../error';
+export interface PluginHookData {
+    /** hook tap name */
+    tapName: string;
+    /** hook call time-consuming */
+    costs: number;
+    startAt: number;
+    endAt: number;
+    /** hook function type */
+    type: 'sync' | 'async' | 'promise';
+    /** hook function result */
+    result: any;
+    /** hook function running error */
+    error: DevToolErrorInstance[];
+}
+/**
+ * Plugin data
+ * - Key name Hook name
+ * - Key value is the hook data array
+ */
+export type PluginData = Record<string, PluginHookData[]>;

package/dist/sdk/process.d.cts

@@ -0,0 +1,10 @@
+export interface ProcessData {
+    /**
+     * process id
+     */
+    pid: number;
+    /**
+     * parent process id
+     */
+    ppid: number | null;
+}

package/dist/sdk/resolver.d.cts

@@ -0,0 +1,52 @@
+import { ProcessData } from './process';
+export interface ResolveStackData {
+    /** Step name */
+    name: string;
+    /** trying to resolve path */
+    path: string;
+    /** Request parameters */
+    request?: string;
+    /** Request path parameter */
+    query?: string;
+    /** Request fragment connection */
+    fragment?: string;
+    /** Whether to request a module */
+    module?: boolean;
+    /** Whether to request a module */
+    file?: boolean;
+    /** Whether to request a folder */
+    directory?: boolean;
+    /** Whether to request internal module */
+    internal?: boolean;
+}
+export interface PathResolverBaseData extends ProcessData {
+    /** Is it an entry file request */
+    isEntry: boolean;
+    /**
+     * The path to send the request
+     * - When the entry file is requested, it is represented as the project root directory
+     * - When requesting a file, it is represented as a file directory
+     */
+    issuerPath: string;
+    /** Original request */
+    request: string;
+    /** Request parameters */
+    query?: string;
+    startAt: number;
+    endAt: number;
+}
+export interface PathResolverSuccessData extends PathResolverBaseData {
+    /**
+     * the resolved result.
+     */
+    result: string;
+}
+export interface PathResolverFailData extends PathResolverBaseData {
+    error: Error;
+    /**
+     * stacks of the resolve paths which try to resolve.
+     */
+    stacks: ResolveStackData[];
+}
+export type PathResolverData = PathResolverSuccessData | PathResolverFailData;
+export type ResolverData = PathResolverData[];

package/dist/sdk/result.d.cts

@@ -0,0 +1,42 @@
+import { EmoCheckData } from '../emo';
+import { LoaderData } from './loader';
+import { ModuleGraphData, ModuleCodeData, TreeShakingData } from './module';
+import { ChunkGraphData } from './chunk';
+import { ResolverData } from './resolver';
+import { PluginData } from './plugin';
+import { SummaryData } from './summary';
+import { ConfigData } from './config';
+import { RuleStoreData } from '../rule';
+import type { EnvInfo } from './envinfo';
+import { PackageGraphData, OtherReports } from './package';
+export type ErrorsData = RuleStoreData;
+interface StoreCommonData {
+    hash: string;
+    root: string;
+    pid: number;
+    envinfo: EnvInfo;
+}
+export interface BuilderStoreData extends StoreCommonData {
+    [key: string]: any;
+    errors: ErrorsData;
+    configs: ConfigData;
+    summary: SummaryData;
+    resolver: ResolverData;
+    loader: LoaderData;
+    plugin: PluginData;
+    moduleGraph: ModuleGraphData;
+    chunkGraph: ChunkGraphData;
+    packageGraph: PackageGraphData;
+    moduleCodeMap: ModuleCodeData;
+    treeShaking?: TreeShakingData;
+    otherReports?: OtherReports | undefined;
+}
+export interface EMOStoreData extends StoreCommonData {
+    emoCheck: EmoCheckData;
+}
+/**
+ * @deprecated
+ */
+export interface StoreData extends Partial<Omit<EMOStoreData, keyof StoreCommonData>>, BuilderStoreData {
+}
+export {};

package/dist/sdk/server/apis/alerts.d.cts

@@ -0,0 +1,30 @@
+import { API } from './index';
+import { OverlayRuleStoreData, RuleStoreDataItem } from '../../../rule';
+import { DependencyData, ModuleData, ModuleSource } from '../../module';
+import { PackageBasicData } from '../../package';
+export interface AlertsAPIResponse {
+    /**
+     * get the details of the alerts which type is "package-relation"
+     */
+    [API.GetPackageRelationAlertDetails]: {
+        group: string | void;
+        module: ModuleData;
+        dependency: DependencyData;
+        relativePath: string;
+        moduleCode: ModuleSource;
+    }[];
+    /**
+     * get the alerts list which use to display in overlay at the client page
+     */
+    [API.GetOverlayAlerts]: OverlayRuleStoreData[];
+    /**
+     * get the alerts list which use to display in category bundle at the client page
+     */
+    [API.GetBundleAlerts]: OverlayRuleStoreData[];
+}
+export interface AlertsAPIRequestBody {
+    [API.GetPackageRelationAlertDetails]: {
+        id: RuleStoreDataItem['id'];
+        target: PackageBasicData;
+    };
+}