@rsdoctor/types 1.5.9 → 1.5.10

package/dist/rule/data.d.cts

@@ -0,0 +1,217 @@
+import type { RuleMessage, RuleMessageCodeEnumerated } from './code';
+import type { SourceRange } from '../sdk';
+import type { CrossChunksPackageType, PackageBasicData, PackageInstance } from '../sdk/package';
+export interface BaseRuleStoreData extends Pick<RuleMessage, 'code' | 'category'> {
+    /**
+     * unique of error
+     */
+    id: number | string;
+    /**
+     * title of alerts
+     */
+    title: string;
+    /**
+     * description of alerts
+     */
+    description?: string;
+    /**
+     * level of error
+     */
+    level: 'warn' | 'error';
+    /**
+     * rule doc link
+     */
+    link?: string;
+}
+export interface LinkRuleStoreData extends BaseRuleStoreData {
+    type: 'link';
+}
+export interface DependencyWithPackageData {
+    /**
+     * use to group files, such as different version of duplicate packages.
+     * @example
+     * [
+     *   { group: "lodash@1.0.1", ... },
+     *   { group: "lodash@1.0.1", ... },
+     *   { group: "lodash@2.0.0", ... },
+     * ]
+     */
+    group?: string;
+    /**
+     * module dependency id
+     */
+    dependencyId: number;
+}
+export interface PackageRelationData {
+    /** Target package data */
+    target: PackageBasicData;
+    /** Target package size */
+    targetSize: {
+        sourceSize: number;
+        parsedSize: number;
+    };
+    /** package dependency chain */
+    dependencies: DependencyWithPackageData[];
+}
+/**
+ * Generally serves to view package relationship detection rules.
+ */
+export interface PackageRelationDiffRuleStoreData extends BaseRuleStoreData {
+    type: 'package-relation';
+    packages: PackageRelationData[];
+}
+export interface CrossChunksPackageRuleStoreData extends BaseRuleStoreData {
+    type: 'cross-chunks-package';
+    chunks: CrossChunksPackageType[];
+    package: Pick<PackageInstance, 'id' | 'name' | 'version'> & {
+        size: ReturnType<PackageInstance['getSize']>;
+    };
+}
+/**
+ * General service to view file relationship detection rules.
+ */
+export interface FileRelationRuleStoreData extends BaseRuleStoreData {
+    type: 'file-relation';
+    /** Target file */
+    target: string;
+    /** Dependency chain */
+    dependencies: number[];
+}
+/**
+ * the rule which code view only
+ */
+export interface CodeViewRuleStoreData extends BaseRuleStoreData {
+    type: 'code-view';
+    file: {
+        /**
+         * file path
+         */
+        path: string;
+        /**
+         * the code content
+         */
+        content: string;
+        /**
+         * fix highlight range in source
+         */
+        ranges?: SourceRange[];
+    };
+}
+/**
+ * the rule which need to change the file code.
+ */
+export interface CodeChangeRuleStoreData extends BaseRuleStoreData {
+    type: 'code-change';
+    file: {
+        /**
+         * file path
+         */
+        path: string;
+        /**
+         * the actual file content
+         */
+        actual: string;
+        /**
+         * the expected file content
+         */
+        expected: string;
+        /**
+         * fix code line in source
+         */
+        line?: number;
+        /**
+         * whether this case is fixed
+         *   - @default `false`
+         */
+        isFixed?: boolean;
+    };
+}
+export interface OverlayRuleStoreData extends BaseRuleStoreData {
+    code: RuleMessageCodeEnumerated.Overlay;
+    stack?: string;
+}
+/**
+ * Rule for detecting modules that are included in both initial and async chunks.
+ */
+export interface ModuleMixedChunksRuleStoreData extends BaseRuleStoreData {
+    type: 'module-mixed-chunks';
+    module: {
+        id: number | string;
+        path: string;
+        webpackId?: string | number;
+    };
+    initialChunks: Array<{
+        id: string;
+        name: string;
+    }>;
+    asyncChunks: Array<{
+        id: string;
+        name: string;
+    }>;
+}
+/**
+ * Rule for detecting modules that are only imported for their side effects,
+ * which may indicate unintended tree-shaking failures.
+ */
+export interface ConnectionsOnlyImportsRuleStoreData extends BaseRuleStoreData {
+    type: 'tree-shaking-side-effects-only';
+    module: {
+        id: number | string;
+        path: string;
+        webpackId?: string | number;
+    };
+    connections: Array<{
+        originModule: number;
+        dependencyType: string;
+        userRequest: string;
+    }>;
+}
+/**
+ * Rule for detecting modules imported via CJS require (bare require() call),
+ * which prevents tree-shaking of the required module.
+ */
+export interface CjsRequireRuleStoreData extends BaseRuleStoreData {
+    type: 'cjs-require';
+    /** The module that contains the require() call */
+    issuerModule: {
+        id: number | string;
+        path: string;
+        webpackId?: string | number;
+    };
+    /** The module being required */
+    requiredModule: {
+        id: number | string;
+        path: string;
+        webpackId?: string | number;
+    };
+    /** The original require string (e.g. 'lodash') */
+    request: string;
+}
+/**
+ * Rule for detecting ESM imports that were resolved to a CJS module
+ * even though the package provides an ESM entry.
+ */
+export interface EsmResolvedToCjsRuleStoreData extends BaseRuleStoreData {
+    type: 'esm-resolved-to-cjs';
+    /** Package name */
+    packageName: string;
+    /** Package version */
+    packageVersion: string;
+    /** The ESM entry path declared in the package's package.json */
+    esmEntry: string;
+    /** The actual resolved (CJS) module */
+    resolvedModule: {
+        id: number | string;
+        path: string;
+        webpackId?: string | number;
+    };
+    /** All issuer modules that imported this package via ESM import */
+    issuers: Array<{
+        id: number | string;
+        path: string;
+        /** The import request string (e.g. 'lodash') */
+        request: string;
+    }>;
+}
+export type RuleStoreDataItem = LinkRuleStoreData | FileRelationRuleStoreData | CodeChangeRuleStoreData | PackageRelationDiffRuleStoreData | CodeViewRuleStoreData | CrossChunksPackageRuleStoreData | ModuleMixedChunksRuleStoreData | ConnectionsOnlyImportsRuleStoreData | CjsRequireRuleStoreData | EsmResolvedToCjsRuleStoreData;
+export type RuleStoreData = RuleStoreDataItem[];

package/dist/rule/index.d.cts

@@ -0,0 +1,2 @@
+export * from './code';
+export * from './data';

package/dist/sdk/chunk.d.cts

@@ -0,0 +1,142 @@
+import type { NonFunctionProperties } from '../common';
+import type { ModuleInstance, ToDataType } from './module';
+export interface AssetInstance {
+    id: number;
+    path: string;
+    size: number;
+    /** File belongs to Chunk */
+    chunks: ChunkInstance[];
+    /** File resource content */
+    content: string;
+    gzipSize: number | undefined;
+    /** Generate data */
+    toData(type: ToDataType): AssetData;
+    setId(id: number): void;
+    setChunks(chunks: ChunkInstance[]): void;
+    setGzipSize(content: string): void;
+}
+export interface ChunkInstance {
+    /** Chunk Identifier */
+    id: string;
+    /** Chunk Name */
+    name: string;
+    /** Whether to load on the homepage */
+    initial: boolean;
+    size: number;
+    /** Is it an entrance */
+    entry: boolean;
+    /** Is it the entrance Chunk */
+    isEntry(): boolean;
+    /** Is the module a Chunk entrance */
+    isChunkEntryModule(module: ModuleInstance): boolean;
+    /** Does it contain modules */
+    hasModule(module: ModuleInstance): boolean;
+    /** Connection module */
+    addModule(module: ModuleInstance): void;
+    addAsset(asset: AssetInstance): void;
+    /** Add Dependency Chunk */
+    addDependency(dep: ChunkInstance): void;
+    /** Add Dependent Chunk */
+    addImported(imported: ChunkInstance): void;
+    /** Includes products */
+    getAssets(): AssetInstance[];
+    /** Contains original modules */
+    getModules(): ModuleInstance[];
+    /** Depends on Chunk */
+    getDependencies(): ChunkInstance[];
+    /** Add Dependent Chunk  */
+    getImported(): ChunkInstance[];
+    /** add parsed chunk size */
+    setParsedSize(size: number): void;
+    /** Generate data */
+    toData(): ChunkData;
+    setAssets(assets: AssetInstance[]): void;
+    setModules(modules: ModuleInstance[]): void;
+    setDependencies(dependencies: ChunkInstance[]): void;
+    setImported(imported: ChunkInstance[]): void;
+}
+export interface ChunkGraphInstance {
+    /** Obtain product data */
+    getAssets(): AssetInstance[];
+    /** Get Chunk Data */
+    getChunks(): ChunkInstance[];
+    /** Add product data */
+    addAsset(...assets: AssetInstance[]): void;
+    /** Add Chunk Data */
+    addChunk(...chunks: ChunkInstance[]): void;
+    /** Get chunk by identifier */
+    getChunkById(id: string): ChunkInstance | undefined;
+    getAssetById(id: number): AssetInstance | undefined;
+    /** Get the file according to the path */
+    getAssetByPath(path: string): AssetInstance | undefined;
+    /**
+     * get the list of entry points
+     */
+    getEntryPoints(): EntryPointInstance[];
+    /**
+     * get the entry point by id
+     */
+    getEntryPointById(id: number): EntryPointInstance | undefined;
+    /**
+     * add the entry point instance to chunk graph
+     */
+    addEntryPoint(...entrypoint: EntryPointInstance[]): void;
+    /** Output pure data */
+    toData(type: ToDataType): ChunkGraphData;
+    setChunks(chunks: ChunkInstance[]): void;
+    setAssets(assets: AssetInstance[]): void;
+    setEntrypoints(entrypoints: EntryPointInstance[]): void;
+}
+export interface AssetData extends Omit<NonFunctionProperties<AssetInstance>, 'chunks'> {
+    /** Chunk Identifier to which the file belongs */
+    chunks: string[];
+}
+export interface ChunkGraphData extends NonFunctionProperties<ChunkGraphInstance> {
+    assets: AssetData[];
+    chunks: ChunkData[];
+    entrypoints: EntryPointData[];
+}
+export interface ChunkData extends Omit<NonFunctionProperties<ChunkInstance>, 'assets' | 'modules' | 'dependencies' | 'imported'> {
+    /** Is it the entrance Chunk */
+    entry: boolean;
+    /** Contains product path */
+    assets: string[];
+    /** contains the original module identifier */
+    modules: number[];
+    /** Depends on Chunk Identifier */
+    dependencies: string[];
+    /** Dependent Chunk Identifier */
+    imported: string[];
+    /** chunk parsed size */
+    parsedSize: number;
+}
+export interface EntryPointInstance {
+    id: number;
+    name: string;
+    /**
+     * add asset which contained in this entry point
+     */
+    addAsset(asset: AssetInstance): void;
+    /**
+     * add chunk which contained in this entry point
+     */
+    addChunk(chunk: ChunkInstance): void;
+    toData(): EntryPointData;
+    setId(id: number): void;
+    setChunks(chunks: ChunkInstance[]): void;
+    setAssets(assets: AssetInstance[]): void;
+}
+export interface EntryPointData extends NonFunctionProperties<EntryPointInstance> {
+    /**
+     * id list for chunks which contained in this entry point.
+     */
+    chunks: ChunkData['id'][];
+    /**
+     * path list for assets which contained in this entry point.
+     */
+    assets: AssetData['path'][];
+    /**
+     * total size of assets
+     */
+    size: number;
+}

package/dist/sdk/config.d.cts

@@ -0,0 +1,12 @@
+import type { Configuration } from 'webpack';
+import type { Configuration as RspackConfiguration } from '@rspack/core';
+type RspackConfigurationWrapper = any extends RspackConfiguration ? never : RspackConfiguration;
+export interface WebpackConfigData {
+    name: string;
+    version: string | number;
+    bin?: string;
+    config: Configuration | RspackConfigurationWrapper;
+    root: string;
+}
+export type ConfigData = WebpackConfigData[];
+export {};

package/dist/sdk/context.d.cts

@@ -0,0 +1,23 @@
+import type { ChunkGraphInstance } from './chunk';
+import type { ModuleGraphInstance } from './module';
+import type { PackageGraphInstance, OtherReports } from './package';
+import { ConfigData } from './config';
+import { LoaderData } from './loader';
+export interface RuntimeContext {
+    /** Project root directory */
+    root: string;
+    /** Project configuration */
+    configs: ConfigData;
+    /** build error */
+    errors: Error[];
+    /** Chunk chart */
+    chunkGraph: ChunkGraphInstance;
+    /** Module diagram */
+    moduleGraph: ModuleGraphInstance;
+    /** Dependency graph */
+    packageGraph: PackageGraphInstance;
+    loader: LoaderData;
+    otherReports?: OtherReports | undefined;
+}
+export interface RuntimeContextOptions {
+}

package/dist/sdk/envinfo.d.cts

@@ -0,0 +1,19 @@
+export interface EnvInfo {
+    /**
+     * @example "macOS 11.4"
+     */
+    os: string;
+    /**
+     * @example "(12) x64 Intel(R) Core(TM) i7-9750H CPU @ 2.60GHz"
+     */
+    cpu: string;
+    /**
+     * @example "1.07 GB / 32.00 GB"
+     */
+    memory: string;
+    nodeVersion: string;
+    yarnVersion: string;
+    npmVersion: string;
+    pnpmVersion: string;
+    [key: string]: string;
+}

package/dist/sdk/hooks.d.cts

@@ -0,0 +1,14 @@
+import type { AsyncSeriesHook } from 'tapable';
+import { RsdoctorManifestWithShardingFiles } from '../manifest';
+/**
+ * sdk hooks map
+ */
+export interface Hooks {
+    afterSaveManifest: AsyncSeriesHook<[
+        {
+            manifestWithShardingFiles: RsdoctorManifestWithShardingFiles;
+            manifestDiskPath: string;
+            manifestCloudPath?: string;
+        }
+    ]>;
+}

package/dist/sdk/index.d.cts

@@ -0,0 +1,16 @@
+export * from './loader';
+export * from './resolver';
+export * from './plugin';
+export * from './module';
+export * from './chunk';
+export * from './result';
+export * from './summary';
+export * from './package';
+export * from './context';
+export * from './config';
+export * from './server';
+export * from './statement';
+export * from './treeShaking';
+export * from './envinfo';
+export * from './instance';
+export * from './hooks';

package/dist/sdk/instance.d.cts

@@ -0,0 +1,110 @@
+import type { SourceMapConsumer, RawSourceMap } from 'source-map';
+import { LoaderData, ResourceLoaderData } from './loader';
+import { ResolverData } from './resolver';
+import { PluginData } from './plugin';
+import { BuilderStoreData, EMOStoreData } from './result';
+import { ModuleGraphInstance, ToDataType } from './module';
+import { RsdoctorManifestClientRoutes, RsdoctorManifestWithShardingFiles } from '../manifest';
+import { RuntimeContext, RuntimeContextOptions } from './context';
+import { Hooks } from './hooks';
+import { ChunkGraphInstance } from './chunk';
+import { RsdoctorServerInstance } from './server';
+import { PlainObject } from '../common';
+import { BriefModeOptions } from '../config';
+import { EmoCheckData } from '../emo';
+import { SummaryData } from './summary';
+import { ConfigData } from './config';
+export type WriteStoreOptionsType = {};
+export declare enum IMode {
+    brief = "brief",
+    lite = "lite",
+    normal = "normal"
+}
+export interface RsdoctorBuilderSDKInstance extends RsdoctorSDKInstance {
+    readonly server: RsdoctorServerInstance;
+    type: ToDataType;
+    /** Report configuration information */
+    reportConfiguration(config: ConfigData[0]): void;
+    /** Report error message */
+    reportError(errors: Error[]): void;
+    /** Report error message */
+    reportLoader(data: LoaderData): void;
+    /** Report loader message before or after some builtin loader */
+    reportLoaderStartOrEnd(data: ResourceLoaderData): void;
+    /** Report path request information */
+    reportResolver(data: ResolverData): void;
+    /** Report plugin information */
+    reportPlugin(data: PluginData): void;
+    /** Report module chart data */
+    reportModuleGraph(data: ModuleGraphInstance): void;
+    reportChunkGraph(data: ChunkGraphInstance): void;
+    /** report the data of summary */
+    reportSummaryData(part: Partial<SummaryData>): void;
+    /** Report sourceMap data */
+    reportSourceMap(data: RawSourceMap): void;
+    getClientRoutes(): RsdoctorManifestClientRoutes[];
+    addClientRoutes(routes: RsdoctorManifestClientRoutes[]): void;
+    /** Application error modification */
+    applyErrorFix(id: number): Promise<void>;
+    /** Get build result data */
+    getStoreData(): BuilderStoreData;
+    /** Get build resource entry file */
+    getManifestData(): RsdoctorManifestWithShardingFiles;
+    /** Get rule context */
+    getRuleContext(options: RuntimeContextOptions): RuntimeContext;
+    /** Get SourceMap from cache */
+    getSourceMap(file: string): Promise<SourceMapConsumer | undefined>;
+    /** clear cache */
+    clearSourceMapCache(): void;
+    /** Clear all data */
+    clear(): void;
+    /** Write store data to files */
+    writeStore(options?: WriteStoreOptionsType): Promise<string>;
+}
+export interface RsdoctorEMOSDKInstance extends RsdoctorSDKInstance {
+    reportEmoData(data: EmoCheckData): void;
+    getStoreData(): EMOStoreData;
+}
+export interface RsdoctorSDKInstance {
+    readonly name: string;
+    readonly root: string;
+    readonly extraConfig: SDKOptionsType | undefined;
+    readonly hooks: Hooks;
+    /**
+     * folder of manifest
+     *   - used to save the manifest.json and sharding files.
+     * @default ".rsdoctor"
+     */
+    readonly outputDir: string;
+    /** manifest local path */
+    diskManifestPath: string;
+    /** start */
+    bootstrap(): Promise<void>;
+    dispose(): Promise<void>;
+    /** Change output path */
+    setOutputDir(outputDir: string): void;
+    /** Change build name */
+    setName(name: string): void;
+    setHash(hash: string): void;
+    getHash(): string;
+    /**
+     * write the manifest to a folder
+     *   - use this.outputDir
+     * @returns the absolute path of manifest.json.
+     */
+    saveManifest(storeData: PlainObject, options: WriteStoreOptionsType): Promise<string>;
+}
+export interface IPrintLog {
+    serverUrls: boolean;
+}
+export type SDKOptionsType = {
+    innerClientPath?: string;
+    disableClientServer?: boolean;
+    noServer?: boolean;
+    printLog?: IPrintLog;
+    mode?: keyof typeof IMode;
+    brief?: BriefModeOptions;
+    features?: {
+        treeShaking?: boolean;
+    };
+};

package/dist/sdk/loader.d.cts

@@ -0,0 +1,70 @@
+import { PlainObject } from '../common';
+import { DevToolErrorInstance } from '../error';
+import { ProcessData } from './process';
+/** Single Loader conversion data for processing files */
+export interface LoaderTransformData extends ProcessData {
+    /** loader name */
+    loader: string;
+    /**
+     * loader index
+     */
+    loaderIndex: number;
+    /** loader path */
+    path: string;
+    input: string | null | undefined;
+    /**
+     * - isPitch: true: the result of loader.pitch()
+     * - isPitch: false: the code result of loader()
+     */
+    result: string | null | undefined;
+    /** Timestamp when called */
+    startAt: number;
+    endAt: number;
+    /** loader configuration */
+    options: PlainObject;
+    /** pitching loader */
+    isPitch: boolean;
+    /**
+     * is sync
+     */
+    sync: boolean;
+    /** Error during conversion */
+    errors: DevToolErrorInstance[];
+    /** module layer */
+    layer?: string;
+}
+/** Original file data */
+export interface ResourceData {
+    /**
+     * Resource path
+     * @example '/abc/resource.js'
+     */
+    path: string;
+    /**
+     * Resource parameters
+     * @example '?rrr'
+     */
+    queryRaw: string;
+    /**
+     * Resource parameter object
+     * @example '{ abc: true }'
+     */
+    query: PlainObject;
+    /**
+     * @example 'js'
+     * @example 'txt'
+     */
+    ext: string;
+    /**
+     * Resource module layer
+     */
+    layer?: string;
+}
+/** File conversion process data */
+export interface ResourceLoaderData {
+    /** File data */
+    resource: ResourceData;
+    /** Passing loader */
+    loaders: LoaderTransformData[];
+}
+export type LoaderData = ResourceLoaderData[];