@rsdoctor/types 1.5.9 → 1.5.11

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;
+    };
+}

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

@@ -0,0 +1,49 @@
+import { RsdoctorClientAssetsSummary } from '../../../client';
+import { AssetData, ChunkData, ChunkGraphData, EntryPointData } from '../../chunk';
+import { ModuleData, ModuleGraphData, SideEffectCodeData } from '../../module';
+import { API } from './index';
+export interface GraphAPIResponse {
+    [API.GetAssetsSummary]: RsdoctorClientAssetsSummary;
+    [API.GetAssetDetails]: {
+        asset: AssetData;
+    } & Pick<ModuleGraphData, 'modules'> & Pick<ChunkGraphData, 'chunks'>;
+    [API.GetChunksByModuleId]: ChunkData[];
+    [API.GetModuleDetails]: {
+        module: ModuleData;
+        sideEffectCodes?: SideEffectCodeData[];
+    } & Pick<ModuleGraphData, 'dependencies'>;
+    [API.GetModulesByModuleIds]: ModuleData[];
+    [API.GetEntryPoints]: EntryPointData[];
+}
+export interface GraphAPIRequestBody {
+    [API.GetAssetsSummary]: {
+        withFileContent?: boolean;
+    };
+    [API.GetAssetDetails]: {
+        assetPath: string;
+    };
+    [API.GetChunksByModuleId]: {
+        moduleId: number;
+    };
+    [API.GetModuleDetails]: {
+        moduleId: number;
+    };
+    [API.GetModulesByModuleIds]: {
+        moduleIds: number[];
+    };
+    [API.GetModuleCodeByModuleId]: {
+        moduleId: number;
+    };
+    [API.GetModuleCodeByModuleIds]: {
+        moduleIds: number[];
+    };
+    [API.GetAllModuleGraph]: {};
+    [API.GetAllChunkGraph]: {};
+    [API.GetSearchModules]: {
+        moduleName: string;
+    };
+    [API.GetSearchModuleInChunk]: {
+        moduleName: string;
+        chunk: string;
+    };
+}

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

@@ -0,0 +1,189 @@
+import { ServerResponse } from 'http';
+import { PlainObject, Get } from '../../../common';
+import { connect } from '../../../thirdparty';
+import { RsdoctorBuilderSDKInstance } from '../../index';
+import { RsdoctorServerInstance } from '../index';
+import { LoaderData } from '../../loader';
+import { ProjectAPIResponse, ProjectAPIRequestBody } from './project';
+import { LoaderAPIResponse, LoaderAPIRequestBody } from './loader';
+import { ResolverAPIResponse, ResolverAPIRequestBody } from './resolver';
+import { PluginAPIResponse, PluginAPIRequestBody } from './plugin';
+import { GraphAPIResponse, GraphAPIRequestBody } from './graph';
+import { AlertsAPIResponse, AlertsAPIRequestBody } from './alerts';
+import { RsdoctorManifestMappingKeys } from '../../../manifest';
+import { SDK } from '../../../index';
+import { StatsModule } from '../../../plugin';
+export * from './pagination';
+export declare enum API {
+    ApplyErrorFix = "/api/apply/error/fix",
+    Env = "/api/env",
+    EntryHtml = "/index.html",
+    Manifest = "/api/manifest.json",
+    LoadDataByKey = "/api/data/key",
+    SendAPIDataToClient = "/api/socket/send",
+    /** Project API */
+    GetProjectInfo = "/api/project/info",
+    GetClientRoutes = "/api/routes",
+    /** Loader API */
+    ReportLoader = "/api/loader/report",
+    GetLoaderNames = "/api/loader/names",
+    GetLoaderChartData = "/api/loader/chart/data",
+    GetLoaderFileTree = "/api/loader/filetree",
+    GetLoaderFileDetails = "/api/loader/file",
+    GetLoaderFolderStatistics = "/api/loader/folder/statics",
+    GetLoaderFileFirstInput = "/api/loader/input",
+    GetLoaderFileInputAndOutput = "/api/loader/inputandoutput",
+    GetDirectoriesLoaders = "/api/loader/directories",
+    /** SourceMap API */
+    ReportSourceMap = "/api/sourcemap/report",
+    /** Resolver API */
+    GetResolverFileTree = "/api/resolver/filetree",
+    GetResolverFileDetails = "/api/resolver/file",
+    /** Plugin API */
+    GetPluginSummary = "/api/plugins/summary",
+    GetPluginData = "/api/plugins/data",
+    /** Graph API */
+    GetSummaryBundles = "/api/graph/bundles/summary",
+    GetChunkGraph = "/api/graph/chunks/graph",
+    GetAssetsSummary = "/api/graph/assets/summary",
+    GetAssetDetails = "/api/graph/asset/details",
+    GetChunksByModuleId = "/api/graph/chunk/module",
+    GetModuleDetails = "/api/graph/module/details",
+    GetModulesByModuleIds = "/api/graph/modules/ids",
+    GetEntryPoints = "/api/graph/entrypoints",
+    GetModuleCodeByModuleId = "/api/graph/module/code",
+    GetModuleCodeByModuleIds = "/api/graph/module/codes",
+    GetAllModuleGraph = "/api/graph/module/all",
+    GetAllChunkGraph = "/api/graph/chunk/all",
+    GetLayers = "/api/graph/layers",
+    GetSearchModules = "/api/search/modules",
+    GetSearchModuleInChunk = "/api/search/chunk/modules",
+    GetAllModuleGraphFilter = "/api/graph/module/filter",
+    GetModuleByName = "/api/graph/module/name",
+    GetModuleIssuerPath = "/api/graph/module/issuer_path",
+    /** Package API */
+    GetPackageInfo = "/api/package/info",
+    GetPackageDependency = "/api/package/dependency",
+    /** Alerts API */
+    GetPackageRelationAlertDetails = "/api/alerts/details/package/relation",
+    GetOverlayAlerts = "/api/alerts/overlay",
+    GetBundleAlerts = "/api/alerts/bundle",
+    /** BundleDiff API */
+    BundleDiffManifest = "/api/bundle_diff/manifest.json",
+    GetBundleDiffSummary = "/api/bundle_diff/summary",
+    /** AI API */
+    GetChunkGraphAI = "/api/graph/chunks/graph/ai",
+    GetChunkByIdAI = "/api/graph/chunk/id/ai"
+}
+/**
+ * api which used outside the sdk.
+ */
+export declare enum APIExtends {
+    GetCompileProgress = "/api/progress"
+}
+export interface SocketResponseType<T extends API | APIExtends = API> {
+    /**
+     * use to match for the event listener when there are different request body.
+     */
+    req: {
+        api: T;
+        body: InferRequestBodyType<T>;
+    };
+    /**
+     * api response
+     */
+    res: InferResponseType<T>;
+}
+export interface ResponseTypes extends LoaderAPIResponse, ResolverAPIResponse, PluginAPIResponse, GraphAPIResponse, AlertsAPIResponse, ProjectAPIResponse {
+    [API.ReportLoader]: 'ok';
+    [API.EntryHtml]: string;
+    [API.Manifest]: string;
+    [API.ApplyErrorFix]: 'success';
+    [API.LoadDataByKey]: unknown;
+    [API.BundleDiffManifest]: SDK.BuilderStoreData;
+    [API.GetBundleDiffSummary]: {
+        root: string;
+        hash: string;
+        outputFilename: string;
+        errors: SDK.ErrorsData;
+        chunkGraph: SDK.ChunkGraphData;
+        moduleGraph: SDK.ModuleGraphData;
+        packageGraph: SDK.PackageGraphData;
+        moduleCodeMap: SDK.ModuleCodeData;
+        cloudManifestUrl: string;
+    };
+    [API.GetChunkGraph]: SDK.ChunkData[];
+    [API.GetAllModuleGraphFilter]: SDK.ModuleData[];
+    [API.GetModuleCodeByModuleId]: SDK.ModuleSource;
+    [API.GetModuleCodeByModuleIds]: SDK.ModuleCodeData;
+    [API.GetAllModuleGraph]: SDK.ModuleData[];
+    [API.GetSearchModules]: Record<string, string>;
+    [API.GetSearchModuleInChunk]: {
+        id: string;
+        path: string;
+        relativePath: string;
+    }[];
+    [API.GetAllChunkGraph]: SDK.ChunkData[];
+    [API.GetModuleByName]: {
+        id: number;
+        path: string;
+    }[];
+    [API.GetModuleIssuerPath]: StatsModule['issuerPath'];
+    [API.GetPackageInfo]: SDK.PackageData[];
+    [API.GetPackageDependency]: SDK.PackageDependencyData[];
+    [API.GetChunkByIdAI]: ExtendedChunkData[];
+    [API.GetChunkGraphAI]: Omit<SDK.ChunkData, 'modules'>[];
+    [API.GetSummaryBundles]: {
+        asset: SDK.AssetData;
+        modules: SDK.ModuleData[];
+    }[];
+}
+export interface RequestBodyTypes extends LoaderAPIRequestBody, ResolverAPIRequestBody, PluginAPIRequestBody, GraphAPIRequestBody, AlertsAPIRequestBody, ProjectAPIRequestBody {
+    [API.ReportLoader]: LoaderData;
+    [API.ApplyErrorFix]: {
+        id: number;
+    };
+    [API.SendAPIDataToClient]: {
+        api: API;
+        data: unknown;
+    };
+    [API.LoadDataByKey]: {
+        /**
+         * @example 'plugin'
+         * @example 'moduleGraph.modules'
+         */
+        key: RsdoctorManifestMappingKeys;
+    };
+    [API.GetModuleByName]: {
+        moduleName: string;
+    };
+    [API.GetModuleIssuerPath]: {
+        moduleId: string;
+    };
+    [API.GetPackageDependency]: {
+        packageId: string;
+    };
+    [API.GetChunkByIdAI]: {
+        chunkId: string;
+    };
+}
+export type InferResponseType<T, F = void> = Get<ResponseTypes, T, F>;
+export type InferRequestBodyType<T, F = void> = Get<RequestBodyTypes, T, F>;
+export interface APIContext {
+    server: RsdoctorServerInstance;
+    sdk: RsdoctorBuilderSDKInstance;
+    req: connect.IncomingMessage & {
+        body?: PlainObject;
+    };
+    res: ServerResponse;
+}
+export interface ExtendedChunkData extends SDK.ChunkData {
+    modulesInfo: {
+        id: number;
+        path: string;
+        size: SDK.ModuleSize;
+        chunks: string[];
+        kind: SDK.ModuleKind;
+        issuerPath: string[] | number[] | undefined;
+    }[];
+}

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

@@ -0,0 +1,53 @@
+import { API } from './index';
+import { ResourceData, LoaderTransformData } from '../../loader';
+import { Get } from '../../../common';
+export interface LoaderAPIResponse {
+    [API.GetLoaderNames]: string[];
+    [API.GetLayers]: string[];
+    [API.GetLoaderChartData]: Array<Pick<LoaderTransformData, 'loader' | 'isPitch' | 'startAt' | 'endAt' | 'pid' | 'sync'> & {
+        resource: Get<ResourceData, 'path'>;
+        layer: Get<ResourceData, 'layer'>;
+        costs: number;
+    }>;
+    [API.GetLoaderFileTree]: Array<Pick<ResourceData, 'path' | 'layer'> & {
+        loaders: Array<Pick<LoaderTransformData, 'loader' | 'path' | 'errors'> & {
+            costs: number;
+        }>;
+    }>;
+    [API.GetLoaderFileDetails]: {
+        resource: ResourceData;
+        loaders: (Omit<LoaderTransformData, 'input' | 'result'> & {
+            costs: number;
+        })[];
+    };
+    [API.GetLoaderFolderStatistics]: Array<Pick<LoaderTransformData, 'loader' | 'path'> & {
+        files: number;
+        costs: number;
+    }>;
+    [API.GetLoaderFileFirstInput]: string;
+    [API.GetLoaderFileInputAndOutput]: {
+        input: string;
+        output: string;
+    };
+    [API.GetDirectoriesLoaders]: Array<{
+        directory: string;
+        stats: Array<Pick<LoaderTransformData, 'loader' | 'path'> & {
+            files: number;
+            costs: number;
+        }>;
+    }>;
+}
+export interface LoaderAPIRequestBody {
+    [API.GetLoaderFileDetails]: Pick<ResourceData, 'path'>;
+    [API.GetLoaderFolderStatistics]: {
+        folder: string;
+    };
+    [API.GetLoaderFileFirstInput]: {
+        file: string;
+    };
+    [API.GetLoaderFileInputAndOutput]: {
+        file: string;
+        loader: string;
+        loaderIndex: number;
+    };
+}

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

@@ -0,0 +1,11 @@
+export interface PaginationRequest {
+    page?: number;
+    pageSize?: number;
+}
+export interface PaginationResponse extends Required<PaginationRequest> {
+    hasNextPage: boolean;
+}
+export interface EnhanceWithPaginationResponse<T> {
+    data: T;
+    pagination: PaginationResponse;
+}

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

@@ -0,0 +1,19 @@
+import { API } from './index';
+import { PluginHookData } from '../../plugin';
+export interface PluginAPIResponse {
+    [API.GetPluginSummary]: {
+        hooks: string[];
+        tapNames: string[];
+    };
+    [API.GetPluginData]: {
+        hook: string;
+        tapName: string;
+        data: Pick<PluginHookData, 'startAt' | 'endAt' | 'type' | 'costs'>[];
+    }[];
+}
+export interface PluginAPIRequestBody {
+    [API.GetPluginData]: {
+        hooks?: string[];
+        tapNames?: string[];
+    };
+}

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

@@ -0,0 +1,18 @@
+import { RsdoctorManifestClientRoutes, RsdoctorManifestData } from '../../../manifest';
+import { API, APIExtends } from './index';
+export interface ProjectAPIResponse {
+    [API.Env]: {
+        ip: string;
+        port: number;
+    };
+    [API.GetProjectInfo]: Pick<RsdoctorManifestData, 'hash' | 'root' | 'pid' | 'summary' | 'configs' | 'envinfo' | 'errors'> & {
+        name?: string;
+    };
+    [API.GetClientRoutes]: RsdoctorManifestClientRoutes[];
+    [APIExtends.GetCompileProgress]: {
+        percentage: number;
+        message: string;
+    };
+}
+export interface ProjectAPIRequestBody {
+}

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

@@ -0,0 +1,18 @@
+import { API } from './index';
+import { PathResolverData } from '../../resolver';
+export interface ResolverAPIResponse {
+    [API.GetResolverFileTree]: Array<Pick<PathResolverData, 'issuerPath'>>;
+    [API.GetResolverFileDetails]: {
+        filepath: string;
+        before: string;
+        after: string;
+        resolvers: (PathResolverData & {
+            costs: number;
+        })[];
+    };
+}
+export interface ResolverAPIRequestBody {
+    [API.GetResolverFileDetails]: {
+        filepath: string;
+    };
+}

package/dist/sdk/server/index.d.cts

@@ -0,0 +1,24 @@
+import { PlainObject } from '../../common';
+import { connect } from '../../thirdparty';
+import { RsdoctorClientRoutes } from '../../client';
+import { API, APIExtends } from './apis';
+export * as ServerAPI from './apis';
+interface ClientUrlFunctionWithRouteDefined<T> {
+    (route: RsdoctorClientRoutes.BundleDiff, baselineUrl: string, currentUrl: string): T;
+    (route?: 'homepage'): T;
+}
+export interface RsdoctorServerInstance {
+    readonly app: connect.Server;
+    readonly port: number;
+    readonly origin: string;
+    innerClientPath?: string;
+    get(route: string, cb: (...args: Parameters<connect.NextHandleFunction>) => string | PlainObject): connect.Server;
+    post(route: string, cb: (...args: Parameters<connect.NextHandleFunction>) => string | PlainObject): connect.Server;
+    proxy(route: string, method: 'GET' | 'POST', cb: (...args: Parameters<connect.NextHandleFunction>) => PlainObject | string): void;
+    getClientUrl: ClientUrlFunctionWithRouteDefined<string>;
+    openClientPage: ClientUrlFunctionWithRouteDefined<Promise<void>>;
+    sendAPIDataToClient(api: API | APIExtends, msg: unknown): void | never;
+    broadcast(): void;
+    bootstrap(): Promise<void>;
+    dispose(): Promise<void>;
+}

package/dist/sdk/statement.d.cts

@@ -0,0 +1,178 @@
+import type { SourceRange, ModuleInstance } from './module';
+import type { NonFunctionProperties } from '../common';
+/** Statement position */
+export interface StatementPosition {
+    /**
+     * Source code location
+     * - Because sourceMap may not exist, there may not be a value here
+     * There are many reasons why sourceMap does not exist, it may be a parsing failure, or it may be ignored during the loader conversion process
+     */
+    source?: SourceRange;
+    /** Converted code position */
+    transformed: SourceRange;
+}
+/** statement category */
+export declare enum StatementKind {
+    /**
+     * Import by default
+     * @example
+     * ```ts
+     * import defaultName from 'name';
+     * ```
+     */
+    ImportDefault = 100,
+    /**
+     * Named import
+     * @example
+     * ```ts
+     * import { name1, name as name2 } from 'name';
+     * ```
+     */
+    ImportNamed = 101,
+    /**
+     * Default and named import
+     * @example
+     * ```ts
+     * import defaultName, { name1 } from 'name';
+     * ```
+     */
+    ImportDefaultWithNamed = 102,
+    /**
+     * Default and Namespace import
+     * @example
+     * ```ts
+     * import defaultName, * as name from 'name';
+     * ```
+     */
+    ImportDefaultWithNamespace = 103,
+    /**
+     * Namespace import
+     * @example
+     * ```ts
+     * import * as namespaceName from 'name';
+     * ```
+     */
+    ImportNamespace = 104,
+    /**
+     * Side effects import
+     * @example
+     * ```ts
+     * import 'name';
+     * ```
+     */
+    ImportSideEffect = 105,
+    /**
+     * Dynamic import
+     * @example
+     * ```ts
+     * import('name');
+     * ```
+     */
+    ImportDynamic = 106,
+    /**
+     * Declare export
+     * @example
+     * ```ts
+     * export const name = '123';
+     * ```
+     */
+    ExportDeclaration = 200,
+    /**
+     * List export
+     * @example
+     * ```ts
+     * export { item1, item as item2 };
+     * ```
+     */
+    ExportList = 201,
+    /**
+     * Default export
+     * @example
+     * ```ts
+     * export default name;
+     * ```
+     */
+    ExportDefault = 202,
+    /**
+     * Re-export
+     * @example
+     * ```ts
+     * export { default as defaultName, item1, item as item2 } from 'name';
+     * ```
+     */
+    ExportAggregating = 203,
+    /**
+     * Re-export to Namespace
+     * @example
+     * ```ts
+     * export * as namespaceName from 'name';
+     * ```
+     */
+    ExportNamespace = 204,
+    /**
+     * CJS module import
+     * @example
+     * ```ts
+     * require('name');
+     * ```
+     */
+    RequireCall = 300,
+    /**
+     * CJS named import
+     * @example
+     * ```ts
+     * require('name').name
+     * ```
+     */
+    RequireName = 301,
+    /**
+     * Overall export
+     * @example
+     * ```ts
+     * module.exports = {};
+     * ```
+     */
+    RequireExports = 302,
+    /**
+     * CJS re-export
+     * @example
+     * ```ts
+     * module.exports = require('name');
+     * ```
+     */
+    RequireExportAggregating = 303,
+    /**
+     * Named export
+     * @example
+     * ```ts
+     * export.name = '123';
+     * ```
+     */
+    RequireExportName = 304,
+    /**
+     * Unknown statement
+     */
+    Unknown = 999
+}
+/** Statement class */
+export interface StatementInstance {
+    /** Current statement position */
+    readonly position: StatementPosition;
+    /** Module where the statement is located */
+    readonly module: ModuleInstance;
+    /** Is it the same statement */
+    isSame(statement: StatementInstance): boolean;
+    /**
+     * Get original location
+     * - When running for the first time and the Module contains sourceMap, it will be calculated
+     */
+    getSourcePosition(): SourceRange | undefined;
+    /** Output data */
+    toData(): StatementData;
+    getLineCode(): string | undefined;
+}
+/** statement data */
+export interface StatementData extends Omit<NonFunctionProperties<StatementInstance>, 'module'> {
+    /** Module number where the statement is located */
+    module: number;
+}

package/dist/sdk/summary.d.cts

@@ -0,0 +1,18 @@
+interface SummaryCostsData {
+    /**
+     * such as 'bootstrap' / 'compile' / 'minify' or else.
+     */
+    name: string;
+    /**
+     * the start timestamp of the data.
+     */
+    startAt: number;
+    costs: number;
+}
+export interface SummaryData {
+    /**
+     * costs of different data.
+     */
+    costs: SummaryCostsData[];
+}
+export {};