@rsdoctor/graph 1.5.9 → 1.5.11

package/dist/graph/chunk-graph/asset.d.cts

@@ -0,0 +1,15 @@
+import { SDK } from '@rsdoctor/types';
+export declare class Asset implements SDK.AssetInstance {
+    static init(): void;
+    id: number;
+    path: string;
+    size: number;
+    content: string;
+    chunks: SDK.ChunkInstance[];
+    gzipSize: number | undefined;
+    constructor(path: string, size: number, chunks: SDK.ChunkInstance[], content: string);
+    toData(types: SDK.ToDataType): SDK.AssetData;
+    setChunks(chunks: SDK.ChunkInstance[]): void;
+    setId(id: number): void;
+    setGzipSize(content: string): void;
+}

package/dist/graph/chunk-graph/chunk.d.cts

@@ -0,0 +1,32 @@
+import { SDK } from '@rsdoctor/types';
+export declare class Chunk implements SDK.ChunkInstance {
+    readonly id: string;
+    readonly name: string;
+    readonly size: number;
+    readonly initial: boolean;
+    readonly entry: boolean;
+    private _assets;
+    private _modules;
+    private _dependencies;
+    private _imported;
+    private _parsedSize;
+    constructor(id: string, name: string, size: number, initial: boolean, entry: boolean);
+    isEntry(): boolean;
+    isChunkEntryModule(module: SDK.ModuleInstance): boolean;
+    hasModule(module: SDK.ModuleInstance): boolean;
+    addModule(module: SDK.ModuleInstance): void;
+    addAsset(asset: SDK.AssetInstance): void;
+    addModules(modules: SDK.ModuleInstance[]): void;
+    addDependency(dep: SDK.ChunkInstance): void;
+    addImported(imported: SDK.ChunkInstance): void;
+    getAssets(): SDK.AssetInstance[];
+    getModules(): SDK.ModuleInstance[];
+    getDependencies(): SDK.ChunkInstance[];
+    getImported(): SDK.ChunkInstance[];
+    setParsedSize(parsedSize: number): void;
+    toData(): SDK.ChunkData;
+    setDependencies(dependencies: SDK.ChunkInstance[]): void;
+    setImported(imported: SDK.ChunkInstance[]): void;
+    setModules(modules: SDK.ModuleInstance[]): void;
+    setAssets(assets: SDK.AssetInstance[]): void;
+}

package/dist/graph/chunk-graph/entrypoint.d.cts

@@ -0,0 +1,15 @@
+import { SDK } from '@rsdoctor/types';
+export declare class EntryPoint implements SDK.EntryPointInstance {
+    readonly name: string;
+    static init(): void;
+    constructor(name: string);
+    id: number;
+    private _chunks;
+    private _assets;
+    addChunk(chunk: SDK.ChunkInstance): void;
+    addAsset(asset: SDK.AssetInstance): void;
+    toData(): SDK.EntryPointData;
+    setChunks(chunks: SDK.ChunkInstance[]): void;
+    setAssets(assets: SDK.AssetInstance[]): void;
+    setId(id: number): void;
+}

package/dist/graph/chunk-graph/graph.d.cts

@@ -0,0 +1,22 @@
+import { SDK } from '@rsdoctor/types';
+export declare class ChunkGraph implements SDK.ChunkGraphInstance {
+    private _assetMap;
+    private _assetPathMap;
+    private _chunkMap;
+    private _entrypointMap;
+    getAssets(): SDK.AssetInstance[];
+    getChunks(): SDK.ChunkInstance[];
+    addAsset(...assets: SDK.AssetInstance[]): void;
+    addChunk(...chunks: SDK.ChunkInstance[]): void;
+    getChunkById(id: string): SDK.ChunkInstance | undefined;
+    getAssetByPath(path: string): SDK.AssetInstance | undefined;
+    getAssetById(id: number): SDK.AssetInstance | undefined;
+    getEntryPoints(): SDK.EntryPointInstance[];
+    getEntryPointById(id: number): SDK.EntryPointInstance | undefined;
+    addEntryPoint(...entrypoints: SDK.EntryPointInstance[]): void;
+    /** output the chunk graph data */
+    toData(type: SDK.ToDataType): SDK.ChunkGraphData;
+    setChunks(chunks: SDK.ChunkInstance[]): void;
+    setEntrypoints(entrypoints: SDK.EntryPointInstance[]): void;
+    setAssets(assets: SDK.AssetInstance[]): void;
+}

package/dist/graph/chunk-graph/index.d.cts

@@ -0,0 +1,4 @@
+export * from './chunk';
+export * from './graph';
+export * from './asset';
+export * from './entrypoint';

package/dist/graph/index.d.cts

@@ -0,0 +1,3 @@
+export * from './chunk-graph';
+export * from './module-graph';
+export * from './package-graph';

package/dist/graph/module-graph/dependency.d.cts

@@ -0,0 +1,25 @@
+import { SDK } from '@rsdoctor/types';
+export declare class Dependency implements SDK.DependencyInstance {
+    static kind: typeof SDK.DependencyKind;
+    static init(): void;
+    id: number;
+    readonly request: string;
+    readonly module: SDK.ModuleInstance;
+    readonly kind: SDK.DependencyKind;
+    typeString?: string;
+    readonly statements: SDK.StatementInstance[];
+    private _originDependency;
+    meta: SDK.DependencyBuildMeta;
+    constructor(request: string, module: SDK.ModuleInstance, dependency: SDK.ModuleInstance, kind: SDK.DependencyKind, statements?: SDK.StatementInstance[]);
+    get resolvedRequest(): string;
+    get dependency(): SDK.ModuleInstance;
+    get originDependency(): SDK.ModuleInstance;
+    get kindString(): keyof typeof SDK.DependencyKind;
+    get resolveConcatenationModule(): boolean;
+    isSameWithoutStatements(dep: Dependency): boolean;
+    addStatement(statement: SDK.StatementInstance): void;
+    hasStatement(statement: SDK.StatementInstance): boolean;
+    setBuildMeta(data: SDK.DependencyBuildMeta): void;
+    toData(): SDK.DependencyData;
+    setId(id: number): void;
+}

package/dist/graph/module-graph/graph.d.cts

@@ -0,0 +1,44 @@
+import { SDK } from '@rsdoctor/types';
+export declare class ModuleGraph implements SDK.ModuleGraphInstance {
+    static init(): void;
+    static fromData(data: Partial<SDK.ModuleGraphData>): ModuleGraph;
+    private _dependenciesIdMap;
+    private _connectionsOnlyImports;
+    private _moduleWebpackIdMap;
+    private _moduleIdMap;
+    private _moduleGraphModules;
+    private _exportIdMap;
+    private _sideEffectIdMap;
+    private _varIdMap;
+    private _layers;
+    clear(): void;
+    size(): number;
+    fromInstance(data: SDK.ModuleGraphInstance): void;
+    getSubGraphByModule(module: SDK.ModuleInstance): SDK.ModuleInstance[];
+    getModules(): SDK.ModuleInstance[];
+    getDependencies(): SDK.DependencyInstance[];
+    getEntryModules(): SDK.ModuleInstance[];
+    getModuleById(id: number): SDK.ModuleInstance | undefined;
+    getDependencyById(id: number): SDK.DependencyInstance | undefined;
+    getModuleByWebpackId(id: string): SDK.ModuleInstance | undefined;
+    getModuleByFile(file: string, layer?: string): SDK.ModuleInstance[];
+    addModule(...modules: SDK.ModuleInstance[]): void;
+    addDependency(...deps: SDK.DependencyInstance[]): void;
+    removeModule(module: SDK.ModuleInstance): void;
+    removeDependency(dep: SDK.DependencyInstance): void;
+    addModuleGraphModule(mgm: SDK.ModuleGraphModuleInstance): void;
+    getModuleGraphModule(module: SDK.ModuleInstance): SDK.ModuleGraphModuleInstance;
+    getModuleGraphModules(): SDK.ModuleGraphModuleInstance[];
+    addExportInfo(data: SDK.ExportInstance): void;
+    addSideEffect(data: SDK.SideEffectInstance): void;
+    addVariable(data: SDK.VariableInstance): void;
+    addLayer(layer: string): void;
+    getLayers(): Map<string, number>;
+    toData(configs?: SDK.ModuleGraphToDataArgs): SDK.ModuleGraphData;
+    toTreeShakingData(): SDK.TreeShakingData;
+    toCodeData(type?: SDK.ToDataType): SDK.ModuleCodeData;
+    setModules(modules: SDK.ModuleInstance[]): void;
+    setDependencies(dependencies: SDK.DependencyInstance[]): void;
+    setConnectionsOnlyImports(items: SDK.ConnectionsOnlyImportData[]): void;
+    getConnectionsOnlyImports(): SDK.ConnectionsOnlyImportData[];
+}

package/dist/graph/module-graph/index.d.cts

@@ -0,0 +1,7 @@
+export * from './dependency';
+export * from './module';
+export * from './graph';
+export * from './statement';
+export * from './tree-shaking';
+export * from './types';
+export * from './utils';

package/dist/graph/module-graph/module.d.cts

@@ -0,0 +1,87 @@
+import { SDK, Plugin } from '@rsdoctor/types';
+import type { SourceMapConsumer } from 'source-map';
+import type { Program } from 'estree';
+import { Dependency } from './dependency';
+import { Statement } from './statement';
+export declare class Module implements SDK.ModuleInstance {
+    static kind: typeof SDK.ModuleKind;
+    issuerPath: SDK.ModuleInstance['issuerPath'];
+    static init(): void;
+    id: number;
+    renderId: string | undefined;
+    bailoutReason: string[];
+    /** Side effect location data from the bundler */
+    sideEffectLocations: SDK.SideEffectLocationData[];
+    /** Side effect code snippets */
+    private sideEffectCodes;
+    readonly webpackId: string;
+    readonly path: string;
+    readonly isEntry: boolean;
+    readonly kind: SDK.ModuleKind;
+    readonly layer?: string;
+    private source;
+    private size;
+    private sourceMap;
+    private program;
+    private chunks;
+    private dependencies;
+    private imported;
+    private modules;
+    private concatenationModules;
+    private _isPreferSource?;
+    meta: SDK.ModuleBuildMeta;
+    constructor(webpackId: string, path: string, isEntry?: boolean, kind?: SDK.ModuleKind, renderId?: string | undefined, layer?: string);
+    get rootModule(): SDK.ModuleInstance | undefined;
+    get isPreferSource(): boolean;
+    addBailoutReason(reason: string): void;
+    getBailoutReason(): string[];
+    addSideEffectLocation(location: SDK.SideEffectLocationData): void;
+    getSideEffectLocations(): SDK.SideEffectLocationData[];
+    addSideEffectCode(codeData: SDK.SideEffectCodeData): void;
+    getSideEffectCodes(): SDK.SideEffectCodeData[];
+    getChunks(): SDK.ChunkInstance[];
+    addChunk(chunk: SDK.ChunkInstance): void;
+    removeChunk(chunk: SDK.ChunkInstance): void;
+    getDependencies(): SDK.DependencyInstance[];
+    getDependencyByRequest(request: string): SDK.DependencyInstance | undefined;
+    getDependencyByModule(module: SDK.ModuleInstance): SDK.DependencyInstance | undefined;
+    addDependency(request: string, module: SDK.ModuleInstance, kind: SDK.DependencyKind, statements?: SDK.StatementInstance[]): Dependency | undefined;
+    removeDependency(dep: SDK.DependencyInstance): void;
+    removeDependencyByModule(module: SDK.ModuleInstance): void;
+    getImported(): SDK.ModuleInstance[];
+    addImported(module: SDK.ModuleInstance): void;
+    removeImported(module: SDK.ModuleInstance): void;
+    setProgram(program: Program): void;
+    getProgram(): Program | undefined;
+    setSource(input: Partial<SDK.ModuleSource>): void;
+    getSource(type?: SDK.ToDataType): {
+        source: string;
+        transformed: string;
+        parsedSource: string;
+    };
+    setSourceMap(sourceMap: SourceMapConsumer): void;
+    getSourceMap(): SourceMapConsumer | undefined;
+    setSize(input: Partial<SDK.ModuleSize>): void;
+    getSize(): {
+        sourceSize: number;
+        transformedSize: number;
+        parsedSize: number;
+        gzipSize: number;
+    };
+    getStatement(transformed: SDK.SourceRange): Statement;
+    getSourceRange(transformed: SDK.SourceRange): SDK.SourceRange | undefined;
+    addNormalModule(module: SDK.ModuleInstance): void;
+    getNormalModules(): SDK.ModuleInstance[];
+    addConcatenationModule(module: SDK.ModuleInstance): void;
+    addIssuerPath(issuerPath: Plugin.StatsModule['issuerPath']): void;
+    getIssuerPath(): Plugin.StatsModule['issuerPath'];
+    getConcatenationModules(): SDK.ModuleInstance[];
+    toData(contextPath?: string, isBrief?: boolean): SDK.ModuleData;
+    setId(id: number): void;
+    setRenderId(renderId: string): void;
+    setChunks(chunks: SDK.ChunkInstance[]): void;
+    setDependencies(dependencies: SDK.DependencyInstance[]): void;
+    setImported(imported: SDK.ModuleInstance[]): void;
+    setModules(modules: SDK.ModuleInstance[]): void;
+    setConcatenationModules(modules: SDK.ModuleInstance[]): void;
+}

package/dist/graph/module-graph/statement.d.cts

@@ -0,0 +1,11 @@
+import { SDK } from '@rsdoctor/types';
+export declare class Statement implements SDK.StatementInstance {
+    static getDefaultStatement(module: SDK.ModuleInstance): Statement;
+    readonly position: SDK.StatementPosition;
+    readonly module: SDK.ModuleInstance;
+    constructor(module: SDK.ModuleInstance, position: SDK.StatementPosition);
+    isSame(statement: SDK.StatementInstance): boolean;
+    getSourcePosition(): SDK.SourceRange | undefined;
+    getLineCode(): string | undefined;
+    toData(): SDK.StatementData;
+}

package/dist/graph/module-graph/tree-shaking/export.d.cts

@@ -0,0 +1,19 @@
+import { SDK } from '@rsdoctor/types';
+export declare class ExportInfo implements SDK.ExportInstance {
+    static init(): void;
+    id: number;
+    name: string;
+    identifier?: SDK.StatementInstance;
+    private from?;
+    private _variable?;
+    private _sideEffects;
+    constructor(name: string, identifier?: SDK.StatementInstance, variable?: SDK.VariableInstance);
+    get isReExport(): boolean;
+    set variable(data: SDK.VariableInstance | undefined);
+    get variable(): SDK.VariableInstance | undefined;
+    addSideEffect(info: SDK.SideEffectInstance): void;
+    getSideEffects(): SDK.SideEffectInstance[];
+    setFromExport(from: SDK.ExportInstance): void;
+    getRecursiveExport(depth?: number): ExportInfo;
+    toData(): SDK.ExportData;
+}

package/dist/graph/module-graph/tree-shaking/index.d.cts

@@ -0,0 +1,5 @@
+export * from './module';
+export * from './export';
+export * from './variable';
+export * from './sideEffect';
+export * from './types';

package/dist/graph/module-graph/tree-shaking/module.d.cts

@@ -0,0 +1,23 @@
+import { SDK } from '@rsdoctor/types';
+export declare class ModuleGraphModule implements SDK.ModuleGraphModuleInstance {
+    static init(): void;
+    readonly module: SDK.ModuleInstance;
+    private exports;
+    private sideEffects;
+    private variables;
+    private _dynamic?;
+    private _graph;
+    constructor(module: SDK.ModuleInstance, graph: SDK.ModuleGraphInstance, dynamic?: boolean);
+    get dynamic(): boolean;
+    addExportInfo(data: SDK.ExportInstance): void;
+    addSideEffect(data: SDK.SideEffectInstance): void;
+    addVariable(data: SDK.VariableInstance): void;
+    getExports(): SDK.ExportInstance[];
+    getSideEffects(name?: string): SDK.SideEffectInstance[];
+    getOwnExports(): SDK.ExportInstance[];
+    getExport(name: string): SDK.ExportInstance | undefined;
+    getReExports(): SDK.ExportInstance[];
+    getOwnExport(name: string): SDK.ExportInstance | undefined;
+    getReExport(name: string): SDK.ExportInstance | undefined;
+    toData(): SDK.ModuleGraphModuleData;
+}

package/dist/graph/module-graph/tree-shaking/sideEffect.d.cts

@@ -0,0 +1,21 @@
+import { SDK } from '@rsdoctor/types';
+export declare class SideEffect implements SDK.SideEffectInstance {
+    static init(): void;
+    /** Name import tags */
+    static NamespaceSymbol: symbol;
+    readonly id: number;
+    readonly name: string;
+    readonly originName?: string;
+    readonly module: SDK.ModuleInstance;
+    readonly identifier: SDK.StatementInstance;
+    readonly isNameSpace: boolean;
+    readonly fromDependency?: SDK.DependencyInstance;
+    private _exports;
+    private _variable?;
+    constructor(name: string, module: SDK.ModuleInstance, identifier: SDK.StatementInstance, fromRequest?: string, originName?: string | symbol);
+    get variable(): SDK.VariableInstance | undefined;
+    get exports(): SDK.ExportInstance[];
+    setModuleExport(mgm: SDK.ModuleGraphModuleInstance): void;
+    setExportInfo(info: SDK.ExportInstance): void;
+    toData(): SDK.SideEffectData;
+}

package/dist/graph/module-graph/tree-shaking/types.d.cts

@@ -0,0 +1,5 @@
+import type { SDK } from '@rsdoctor/types';
+export type ExportData = SDK.ExportData;
+export type ModuleGraphModuleData = SDK.ModuleGraphModuleData;
+export type SideEffectData = SDK.SideEffectData;
+export type VariableData = SDK.VariableData;

package/dist/graph/module-graph/tree-shaking/variable.d.cts

@@ -0,0 +1,15 @@
+import { SDK } from '@rsdoctor/types';
+export declare class Variable implements SDK.VariableInstance {
+    static init(): void;
+    readonly id: number;
+    readonly name: string;
+    readonly module: SDK.ModuleInstance;
+    readonly usedInfo: string;
+    readonly identifier: SDK.StatementInstance;
+    private _exported?;
+    constructor(name: string, module: SDK.ModuleInstance, usedInfo: string, identifier: SDK.StatementInstance);
+    get isUsed(): boolean;
+    setExportInfo(info: SDK.ExportInstance): void;
+    getExportInfo(): SDK.ExportInstance | undefined;
+    toData(): SDK.VariableData;
+}

package/dist/graph/module-graph/types.d.cts

@@ -0,0 +1,12 @@
+import type { SDK } from '@rsdoctor/types';
+export type ModuleBuildMeta = SDK.ModuleBuildMeta;
+export type ModuleSize = SDK.ModuleSize;
+export type ModuleSource = SDK.ModuleSource;
+export type DependencyBuildMeta = SDK.DependencyBuildMeta;
+export type SourcePosition = SDK.SourcePosition;
+export type SourceRange = SDK.SourceRange;
+export type StatementPosition = SDK.StatementPosition;
+export type ModuleData = SDK.ModuleData;
+export type DependencyData = SDK.DependencyData;
+export type StatementData = SDK.StatementData;
+export type ModuleGraphData = SDK.ModuleGraphData;

package/dist/graph/module-graph/utils.d.cts

@@ -0,0 +1,26 @@
+import type { SDK } from '@rsdoctor/types';
+export declare function isSamePosition(po1: SDK.SourcePosition, po2: SDK.SourcePosition): boolean;
+export declare function isSameRange(po1: SDK.SourceRange, po2: SDK.SourceRange): boolean;
+export declare function getModuleName(name?: string): string;
+/**
+ * Parse location string from Rspack side effect location
+ * Supports formats:
+ * - "line:column" -> { startLine, startColumn }
+ * - "startLine:startColumn-endLine:endColumn" -> full range (e.g. 3:1-7:2)
+ * - "line:startColumn-endColumn" -> single-line range (e.g. 11:72-285)
+ * - "startLine-endLine:endColumn" -> start column omitted (e.g. 1-7:2)
+ * - "startLine-endLine" -> line range only
+ */
+export declare function parseLocation(location: string): {
+    startLine: number;
+    startColumn: number;
+    endLine?: number;
+    endColumn?: number;
+} | null;
+/**
+ * Extract code snippet from source based on location
+ * @param source The source code string
+ * @param location Parsed location object
+ * @returns Extracted code snippet
+ */
+export declare function extractCodeFromLocation(source: string, location: ReturnType<typeof parseLocation>): string;

package/dist/graph/package-graph/dependency.d.cts

@@ -0,0 +1,13 @@
+import type { SDK } from '@rsdoctor/types';
+export declare class PackageDependency implements SDK.PackageDependencyInstance {
+    id: number;
+    dependency: SDK.PackageInstance;
+    package: SDK.PackageInstance;
+    refDependency: SDK.DependencyInstance;
+    constructor(pack: SDK.PackageInstance, dep: SDK.PackageInstance, refDependency: SDK.DependencyInstance);
+    get name(): string;
+    get version(): string;
+    get root(): string;
+    isSame(dep: SDK.PackageDependencyInstance): boolean;
+    toData(): SDK.PackageDependencyData;
+}

package/dist/graph/package-graph/graph.d.cts

@@ -0,0 +1,25 @@
+import { SDK } from '@rsdoctor/types';
+import { Package } from './package';
+export { readPackageJson } from './utils';
+export declare class PackageGraph implements SDK.PackageGraphInstance {
+    static fromModuleGraph(graph: SDK.ModuleGraphInstance, root: string, getPackageFile?: SDK.GetPackageFile): PackageGraph;
+    private _root;
+    private _dependencies;
+    private _packages;
+    private _pkgNameMap;
+    private _pkgFileMap;
+    constructor(root: string);
+    getPackages(): SDK.PackageInstance[];
+    getPackageByModule(module: SDK.ModuleInstance, readFile?: SDK.GetPackageFile): SDK.PackageInstance | Package | undefined;
+    getPackageByFile(file: string): SDK.PackageInstance | undefined;
+    getPackageContainFile(file: string): SDK.PackageInstance | undefined;
+    getPackagesByName(name: string): SDK.PackageInstance[];
+    getPackageByData(data: SDK.PackageBasicData): SDK.PackageInstance | undefined;
+    addPackage(pkg: SDK.PackageInstance): void;
+    setDuplicates(module: SDK.ModuleInstance, pkg: SDK.PackageInstance): void;
+    getDependenciesFromPackage(pkg: SDK.PackageInstance): SDK.PackageDependencyInstance[];
+    addDependency(dep: SDK.PackageDependencyInstance): void;
+    getDependenciesFromOrigin(): SDK.PackageDependencyInstance[];
+    getDuplicatePackages(): SDK.PackageInstance[][];
+    toData(): SDK.PackageGraphData;
+}

package/dist/graph/package-graph/index.d.cts

@@ -0,0 +1,4 @@
+export * from './dependency';
+export * from './graph';
+export * from './package';
+export * from './types';

package/dist/graph/package-graph/package.d.cts

@@ -0,0 +1,24 @@
+import type { SDK } from '@rsdoctor/types';
+export declare class Package implements SDK.PackageInstance {
+    id: number;
+    root: string;
+    name: string;
+    version: string;
+    duplicates: SDK.CrossChunksPackageType[];
+    private _modules;
+    private _dependencies;
+    private _imported;
+    constructor(name: string, root: string, version: string);
+    setDuplicates(data: SDK.CrossChunksPackageType): void;
+    getModules(): SDK.ModuleInstance[];
+    getDependencies(): SDK.PackageDependencyInstance[];
+    getImported(): SDK.PackageInstance[];
+    addModule(module: SDK.ModuleInstance): void;
+    addDependency(dep: SDK.PackageDependencyInstance): void;
+    getDependenciesChain(graph: SDK.PackageGraphInstance): SDK.PackageDependencyInstance[];
+    addImported(pkg: SDK.PackageInstance): void;
+    contain(file: string): boolean;
+    isSame(pkg: SDK.PackageInstance): boolean;
+    getSize(): SDK.ModuleSize;
+    toData(): SDK.PackageData;
+}

package/dist/graph/package-graph/types.d.cts

@@ -0,0 +1,6 @@
+import type { SDK } from '@rsdoctor/types';
+export type PackageData = SDK.PackageData;
+export type PackageJSONData = SDK.PackageJSONData;
+export type PackageBasicData = SDK.PackageBasicData;
+export type PackageDependencyData = SDK.PackageDependencyData;
+export type GetPackageFile = SDK.GetPackageFile;

package/dist/graph/package-graph/utils.d.cts

@@ -0,0 +1,3 @@
+import { SDK } from '@rsdoctor/types';
+export declare function isPackagePath(path: string): boolean;
+export declare const readPackageJson: (file: string, readFile?: SDK.GetPackageFile) => SDK.PackageBasicData | undefined;

package/dist/index.cjs

@@ -20,31 +20,31 @@ __webpack_require__.n = (module)=>{
 };
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__), __webpack_require__.d(__webpack_exports__, {
-    isSamePosition: ()=>isSamePosition,
-    Dependency: ()=>Dependency,
-    ModuleGraphTrans: ()=>transform_module_graph_namespaceObject,
     Asset: ()=>Asset,
-    isSameRange: ()=>isSameRange,
+    Chunk: ()=>Chunk,
+    ChunkGraph: ()=>ChunkGraph,
+    Chunks: ()=>chunks_namespaceObject,
+    Dependency: ()=>Dependency,
+    EntryPoint: ()=>EntryPoint,
     ExportInfo: ()=>ExportInfo,
+    Module: ()=>Module,
+    ModuleGraph: ()=>ModuleGraph,
     ModuleGraphModule: ()=>ModuleGraphModule,
-    getModuleName: ()=>getModuleName,
-    readPackageJson: ()=>readPackageJson,
+    ModuleGraphTrans: ()=>transform_module_graph_namespaceObject,
+    Package: ()=>Package,
     PackageDependency: ()=>PackageDependency,
-    Statement: ()=>Statement,
-    EntryPoint: ()=>EntryPoint,
-    ChunkGraph: ()=>ChunkGraph,
+    PackageGraph: ()=>PackageGraph,
     SideEffect: ()=>SideEffect,
-    Module: ()=>Module,
-    Package: ()=>Package,
+    Statement: ()=>Statement,
     TransUtils: ()=>trans_utils_namespaceObject,
+    Variable: ()=>Variable,
     Webpack: ()=>webpack_compatible_namespaceObject,
-    Chunks: ()=>chunks_namespaceObject,
-    parseLocation: ()=>parseLocation,
     extractCodeFromLocation: ()=>extractCodeFromLocation,
-    Variable: ()=>Variable,
-    PackageGraph: ()=>PackageGraph,
-    Chunk: ()=>Chunk,
-    ModuleGraph: ()=>ModuleGraph
+    getModuleName: ()=>getModuleName,
+    isSamePosition: ()=>isSamePosition,
+    isSameRange: ()=>isSameRange,
+    parseLocation: ()=>parseLocation,
+    readPackageJson: ()=>readPackageJson
 });
 var chunks_namespaceObject = {};
 __webpack_require__.r(chunks_namespaceObject), __webpack_require__.d(chunks_namespaceObject, {

package/dist/index.d.cts

@@ -0,0 +1,3 @@
+export * from './graph';
+export * from './transform';
+export * from './types';

package/dist/transform/chunks/assetsContent.d.cts

@@ -0,0 +1,4 @@
+import { SDK, Plugin } from '@rsdoctor/types';
+export declare function assetsContents(assetMap: Map<string, {
+    content: string;
+}>, chunkGraph: SDK.ChunkGraphInstance, supports: Plugin.RsdoctorPluginOptionsNormalized['supports']): void;

package/dist/transform/chunks/assetsModules.d.cts

@@ -0,0 +1,22 @@
+import { SDK } from '@rsdoctor/types';
+import { ParseBundle } from '../../types/transform';
+export type ParsedModuleSizeData = {
+    [x: string]: {
+        size: number;
+        sizeConvert: string;
+        content: string;
+    };
+};
+/**
+ * The following code is modified based on
+ * https://github.com/webpack-contrib/webpack-bundle-analyzer/blob/8a3d3f0f40010f2b41ccd28519eda5a44e13da3e/src/analyzer.js#L20
+ *
+ * MIT Licensed
+ * Author th0r
+ * Copyright JS Foundation and other contributors.
+ * https://github.com/webpack-contrib/webpack-bundle-analyzer/blob/44bd8d0f9aa3b098e271af220096ea70cc44bc9e/LICENSE
+ */
+export declare function getAssetsModulesData(moduleGraph: SDK.ModuleGraphInstance, chunkGraph: SDK.ChunkGraphInstance, bundleDir: string, opts: {
+    parseBundle?: ParseBundle;
+}, sourceMapSets?: Map<string, string>, assetsWithoutSourceMap?: Set<string>): Promise<void>;
+export declare function transformAssetsModulesData(parsedModulesData: ParsedModuleSizeData, moduleGraph: SDK.ModuleGraphInstance): void;

package/dist/transform/chunks/chunkTransform.d.cts

@@ -0,0 +1,5 @@
+import { ChunkGraph } from '../../graph';
+import { Plugin } from '@rsdoctor/types';
+export declare function chunkTransform(assetMap: Map<string, {
+    content: string;
+}>, bundleStats: Plugin.StatsCompilation): ChunkGraph;

package/dist/transform/chunks/index.d.cts

@@ -0,0 +1,3 @@
+export * from './assetsModules';
+export * from './chunkTransform';
+export * from './assetsContent';

package/dist/transform/index.d.cts

@@ -0,0 +1,4 @@
+export * as Chunks from './chunks';
+export * as ModuleGraphTrans from './module-graph';
+export * as TransUtils from './trans-utils';
+export * as Webpack from './webpack/compatible';

package/dist/transform/module-graph/compatible.d.cts

@@ -0,0 +1,8 @@
+import { Plugin, SDK } from '@rsdoctor/types';
+/**
+ * Reverse decode the location (loc) information.
+ * // TODO:
+ * @link https://github.com/webpack/webpack/blob/main/lib/formatLocation.js#L30-L66
+ */
+export declare function getPositionByStatsLocation(loc: string): SDK.SourceRange | undefined;
+export declare function isWebpack5orRspack(compilation: Plugin.BaseCompilation): Boolean;

package/dist/transform/module-graph/index.d.cts

@@ -0,0 +1,3 @@
+export * from './transform';
+export * from './compatible';
+export * from './utils';

package/dist/transform/module-graph/transform.d.cts

@@ -0,0 +1,7 @@
+import { SDK, Plugin } from '@rsdoctor/types';
+import { ModuleGraph } from '../../graph';
+export declare function getModulesFromArray(modules: Plugin.StatsModule[], collectedModules: Plugin.StatsModule[]): void;
+/**
+ * this function can run in browser & node.
+ */
+export declare function getModuleGraphByStats({ modules, chunks }: Plugin.StatsCompilation, root: string, chunkGraph: SDK.ChunkGraphInstance): ModuleGraph;

package/dist/transform/module-graph/utils.d.cts

@@ -0,0 +1,13 @@
+import { SDK } from '@rsdoctor/types';
+interface DependencyData {
+    type?: string;
+}
+/** Determine whether it is the import statement itself */
+export declare function isImportDependency({ type }: DependencyData): boolean;
+export declare function getImportKind(dep: DependencyData): SDK.DependencyKind;
+/**
+ * Remove the css module without connection
+ *   - This will happen when the user uses the mini-css plug-in.
+ */
+export declare function removeNoImportStyle(graph: SDK.ModuleGraphInstance): void;
+export {};

package/dist/transform/trans-utils/index.d.cts

@@ -0,0 +1 @@
+export * from './transStats';

package/dist/transform/trans-utils/transStats.d.cts

@@ -0,0 +1,10 @@
+import { Plugin, SDK } from '@rsdoctor/types';
+/**
+ * @description Convert stats to chunkGraph and moduleGraph, online tools for rsdoctor's website.
+ * @param json
+ * @returns
+ */
+export declare function transStats(json: Plugin.StatsCompilation): Promise<{
+    chunkGraph: SDK.ChunkGraphInstance;
+    moduleGraph: import("../..").ModuleGraph;
+}>;

package/dist/transform/webpack/compatible.d.cts

@@ -0,0 +1,16 @@
+import { Compilation, Dependency, ExternalModule, Module, ModuleGraph, NormalModule } from 'webpack';
+import { SDK, Plugin } from '@rsdoctor/types';
+export declare function isNormalModule(mod: Module): mod is NormalModule;
+export declare function getWebpackModuleId(mod: Module): string;
+export declare function getWebpackModulePath(mod: NormalModule): string;
+export declare function getWebpackDependencyRequest(dep: Dependency, module?: NormalModule): string;
+export declare function getResolveRequest(dep: Dependency, graph: ModuleGraph): string;
+export declare function isExternalModule(mod: Module): mod is ExternalModule;
+export declare function getModuleSource(mod: NormalModule): string;
+export declare function getEntryModule(entryMap: Map<string, Plugin.EntryPoint>): NormalModule[];
+export declare function getDependencyPosition(dep: Dependency, module: SDK.ModuleInstance, getSource?: boolean): SDK.StatementInstance | undefined;
+export declare function getExportDependency(info: Plugin.ExportInfo, module: NormalModule): Dependency | undefined;
+export declare function getSdkDependencyByWebpackDependency(dep: Dependency, module: NormalModule, graph: SDK.ModuleGraphInstance): SDK.DependencyInstance | undefined;
+export declare function getExportStatement(info: Plugin.ExportInfo, normalModule: NormalModule, graph: SDK.ModuleGraphInstance): SDK.StatementInstance | undefined;
+export declare function getLastExportInfo(info: Plugin.ExportInfo, webpackGraph: ModuleGraph): Plugin.ExportInfo | undefined;
+export declare function getAllModules(compilation: Compilation): NormalModule[];

package/dist/types/index.d.cts

@@ -0,0 +1 @@
+export * from './transform';

package/dist/types/transform.d.cts

@@ -0,0 +1,6 @@
+import { SDK } from '@rsdoctor/types';
+export type ParseBundle = (assetFile: string, modules: Pick<SDK.ModuleInstance, 'renderId' | 'webpackId'>[]) => {
+    modules?: Record<string, any>;
+    src?: string;
+    runtimeSrc?: string;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rsdoctor/graph",
-  "version": "1.5.9",
+  "version": "1.5.11",
   "repository": {
     "type": "git",
     "url": "https://github.com/web-infra-dev/rsdoctor",
@@ -15,9 +15,14 @@
   ],
   "exports": {
     ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.js",
-      "default": "./dist/index.cjs"
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
     }
   },
   "type": "module",
@@ -25,8 +30,8 @@
     "es-toolkit": "^1.45.1",
     "path-browserify": "1.0.1",
     "source-map": "^0.7.6",
-    "@rsdoctor/types": "1.5.9",
-    "@rsdoctor/utils": "1.5.9"
+    "@rsdoctor/types": "1.5.11",
+    "@rsdoctor/utils": "1.5.11"
   },
   "devDependencies": {
     "@types/body-parser": "1.19.6",