@rsdoctor/core 2.0.0-rc.0 → 2.0.0-rc.2

package/dist/e.js.LICENSE.txt

@@ -3,5 +3,5 @@
  *
  * @copyright 2026 Jason Mulligan <jason.mulligan@avoidwork.com>
  * @license BSD-3-Clause
- * @version 11.0.23
+ * @version 11.0.24
  */

package/dist/index.d.ts

@@ -1,7 +1,458 @@
-export { logger } from './logger.js';
-export { migrateRsdoctorOptions } from './compat.js';
-export type { CompatibleRsdoctorOptions } from './compat.js';
-export { RsdoctorRspackPlugin } from './rspack-plugin/index.js';
-export { Linter, LinterType, Rule as LinterRule, defineRule, rules, } from './rules/index.js';
-export { RsdoctorSDK, resolveClientDiffHtmlPath } from './sdk/index.js';
-export type { RsdoctorRspackPluginOptions } from './types/index.js';
+import { Client } from '@rsdoctor/shared/types';
+import { Common } from '@rsdoctor/shared/types';
+import type { Config } from '@rsdoctor/shared/types';
+import { Linter as LinterType } from '@rsdoctor/shared/types';
+import { Manifest } from '@rsdoctor/shared/types';
+import { Plugin as Plugin_2 } from '@rsdoctor/shared/types';
+import { RawSourceMap } from 'source-map';
+import { Rule } from '@rsdoctor/shared/types';
+import { SDK } from '@rsdoctor/shared/types';
+import { SourceMapConsumer } from 'source-map';
+import { Thirdparty } from '@rsdoctor/shared/types';
+
+declare interface BasePluginInstance<T extends Plugin_2.BaseCompiler> {
+    apply: (compiler: T) => void;
+    [k: string]: any;
+}
+
+/** Options accepted by framework integrations migrating from Rsdoctor 1.x. */
+export declare type CompatibleRsdoctorOptions<Rules extends LinterType.ExtendRuleData[] = []> = Omit<Plugin_2.RsdoctorRspackPluginOptions<Rules>, 'output' | 'supports'> & {
+    mode?: 'normal' | 'brief' | 'lite';
+    port?: number;
+    brief?: LegacyBriefConfig;
+    experiments?: {
+        enableNativePlugin?: boolean | {
+            moduleGraph?: boolean;
+            chunkGraph?: boolean;
+        };
+    };
+    supports?: Plugin_2.RsdoctorRspackPluginOptions<Rules>['supports'] & {
+        generateTileGraph?: boolean;
+    };
+    output?: {
+        mode?: 'normal' | 'brief';
+        reportDir?: string;
+        reportCodeType?: Config.NewReportCodeType | Partial<Record<Config.NewReportCodeType, boolean>>;
+        compressData?: boolean;
+        options?: Omit<Config.BriefModeOptions, 'htmlOptions'> & {
+            htmlOptions?: LegacyBriefConfig;
+        };
+    };
+};
+
+declare interface DataWithUrl {
+    name: string;
+    files: {
+        path: string;
+        basename: string;
+        content?: Buffer;
+    }[] | string;
+}
+
+declare type DefaultRuleConfig = LinterType.DefaultRuleConfig;
+
+export declare function defineRule<Title extends LinterType.DefaultRuleTitle, T = LinterType.DefaultRuleConfig>(ruleCreator: LinterType.ExtendRuleConstructor<Title, T>): LinterType.ExtendRuleData<T, Title>;
+
+export declare function defineRule<Title extends LinterType.DefaultRuleTitle, T = LinterType.DefaultRuleConfig>(ruleCreator: LinterType.RuleConstructor<Title, T>): LinterType.RuleData<T, Title>;
+
+declare type ISocketType = {
+    port: number;
+    socketUrl: string;
+    token: string;
+};
+
+declare type LegacyBriefConfig = Config.BriefConfig & {
+    writeDataJson?: boolean;
+};
+
+export declare class Linter<Rules extends LinterType.ExtendRuleData[]> {
+    private rules;
+    constructor({ rules, extends: extendRules, level, }?: LinterType.Options<Rules>);
+    private getRules;
+    validate(context: SDK.RuntimeContext): Promise<LinterType.ValidateResult>;
+    afterValidate(context: LinterType.InternalRuleCheckerContextForCheckEnd): Promise<void>;
+}
+
+export declare class LinterRule<Config = DefaultRuleConfig> implements LinterType.RuleMeta<Config> {
+    static from<C>(data: LinterType.ExtendRuleData<C>): LinterRule<C>;
+    readonly meta: LinterType.RuleMeta<Config>;
+    private check;
+    /**
+     * execute when check end
+     */
+    private onCheckEnd;
+    private _severity;
+    private _config?;
+    constructor(data: LinterType.RuleData<Config>);
+    get code(): Rule.RuleMessageCode;
+    get title(): string;
+    get severity(): LinterType.Severity;
+    get config(): Config | undefined;
+    get category(): "bundle" | "compile" | "emo" | Rule.RuleMessageCategory;
+    setOption(opt: LinterType.RuleConfigItem): void;
+    match(level: LinterType.Severity): boolean;
+    validate(context: SDK.RuntimeContext): Promise<LinterType.ValidateResult>;
+    afterValidate({ hooks, validateResult, data, }: LinterType.InternalRuleCheckerContextForCheckEnd<Config>): Promise<void>;
+}
+
+export { LinterType }
+
+declare const LOG_TYPES: {
+    error: {
+        readonly label: string;
+        level: "error";
+    };
+    warn: {
+        readonly label: string;
+        level: "warn";
+    };
+    info: {
+        readonly label: string;
+        level: "info";
+    };
+    start: {
+        readonly label: string;
+        level: "info";
+    };
+    ready: {
+        readonly label: string;
+        level: "info";
+    };
+    success: {
+        readonly label: string;
+        level: "info";
+    };
+    log: {
+        level: "info";
+    };
+    debug: {
+        readonly label: string;
+        level: "verbose";
+    };
+};
+
+declare type LogFunction = (message?: LogMessage, ...args: unknown[]) => void;
+
+declare type Logger = Record<LogMethods, LogFunction> & {
+    greet: (message: string) => void;
+    level: LogLevel;
+    readonly options: Options;
+    override: (customLogger: Partial<Record<LogMethods, LogFunction>>) => void;
+};
+
+export declare const logger: Logger;
+
+declare type LogLevel = 'silent' | 'error' | 'warn' | 'info' | 'log' | 'verbose';
+
+declare type LogMessage = unknown;
+
+declare type LogMethods = keyof typeof LOG_TYPES;
+
+/**
+ * Translate legacy options before constructing the plugin. Explicit current
+ * options take precedence. The input is never mutated; only legacy fields log.
+ */
+export declare function migrateRsdoctorOptions<Rules extends LinterType.ExtendRuleData[] = []>(config?: CompatibleRsdoctorOptions<Rules>): Plugin_2.RsdoctorRspackPluginOptions<Rules>;
+
+declare interface Options {
+    /**
+     * Controls which log levels are emitted.
+     * @default 'info'
+     */
+    level?: LogLevel;
+    /**
+     * Prepends a fixed prefix to every log message.
+     * @default undefined
+     */
+    prefix?: string;
+    /**
+     * Overrides the console used by this logger instance.
+     * @default globalThis.console
+     */
+    console?: Pick<Console, 'log' | 'warn' | 'error'>;
+    /**
+     * Aligns continuation lines of multi-line messages to the first line's
+     * content column (label + prefix). Error object stacks keep their original
+     * top-aligned formatting.
+     * @default false
+     */
+    alignMultiline?: boolean;
+}
+
+export declare const resolveClientDiffHtmlPath: (innerClientPath?: string) => string;
+
+/**
+ * sdk options for builder.
+ */
+declare interface RsdoctorBuilderSDK extends RsdoctorSDKOptions {
+    type?: SDK.ToDataType;
+    /**
+     * port for client server
+     */
+    port?: number;
+    config?: SDK.SDKOptionsType;
+}
+
+declare class RsdoctorCompilerContext implements RsdoctorRspackPluginInstance<LinterType.ExtendRuleData[]> {
+    readonly sdk: SDK.RsdoctorBuilderSDKInstance;
+    readonly options: RsdoctorRspackPluginOptionsNormalized<LinterType.ExtendRuleData[]>;
+    readonly name = "RsdoctorRspackPlugin";
+    readonly isRsdoctorPlugin = true;
+    readonly modulesGraph: SDK.ModuleGraphInstance;
+    bootstrapTask?: Promise<void>;
+    applied: boolean;
+    hasOpenedClientAutomatically: boolean;
+    constructor(sdk: SDK.RsdoctorBuilderSDKInstance, options: RsdoctorRspackPluginOptionsNormalized<LinterType.ExtendRuleData[]>);
+    apply(): void;
+    ensureModulesChunksGraphApplied(compiler: Plugin_2.BaseCompilerType<'rspack'>): void;
+}
+
+export declare interface RsdoctorPluginInstance<T extends Plugin_2.BaseCompiler, Rules extends LinterType.ExtendRuleData[] = []> extends BasePluginInstance<T> {
+    readonly name: string;
+    readonly options: Plugin_2.RsdoctorPluginOptionsNormalized<Rules>;
+    readonly sdk: SDK.RsdoctorBuilderSDKInstance;
+    readonly isRsdoctorPlugin: boolean;
+    _modulesGraphApplied?: boolean;
+    chunkGraph?: SDK.ChunkGraphInstance;
+    modulesGraph: SDK.ModuleGraphInstance;
+    ensureModulesChunksGraphApplied(compiler: T): void;
+}
+
+declare class RsdoctorPrimarySDK extends RsdoctorSDK implements SDK.RsdoctorBuilderSDKInstance {
+    id: number;
+    parent: RsdoctorSDKController;
+    readonly stage: number;
+    displayName: string;
+    readonly compilerPath: string;
+    readonly parentCompilerPath?: string;
+    readonly isChild: boolean;
+    dependencies: Array<string> | undefined;
+    reportFileName: string;
+    constructor({ name, displayName, compilerPath, parentCompilerPath, isChild, stage, controller, extraConfig, type, }: RsdoctorSlaveSDKOptions);
+    get isMaster(): boolean;
+    protected writeBriefJson(data: Manifest.RsdoctorBriefData): void;
+    protected writePieces(_storeData: Common.PlainObject, options?: SDK.WriteStoreOptionsType): Promise<void>;
+    protected writeManifest(): Promise<string>;
+    refreshManifestSeries(): Promise<void>;
+    getSeriesData(serverUrl?: boolean): Manifest.RsdoctorManifestSeriesData[];
+    setName(name: string): void;
+    getManifestData(): Manifest.RsdoctorManifestWithShardingFiles;
+    addRsdoctorDataToHTML(storeData: SDK.BuilderStoreData, htmlContent: string): string;
+}
+
+export declare class RsdoctorRspackPlugin<Rules extends LinterType.ExtendRuleData[]> implements RsdoctorRspackPluginInstance<Rules> {
+    readonly name = "RsdoctorRspackPlugin";
+    readonly isRsdoctorPlugin = true;
+    readonly options: RsdoctorRspackPluginOptionsNormalized<Rules>;
+    readonly outsideInstance: boolean;
+    private readonly childOptions;
+    private readonly defaultName;
+    private readonly controller?;
+    private readonly sessionLease?;
+    private readonly primaryContext;
+    private readonly compilerContexts;
+    private readonly childPlugins;
+    private appliedCompilerCount;
+    constructor(options?: RsdoctorRspackPluginOptions<Rules>);
+    get sdk(): SDK.RsdoctorBuilderSDKInstance;
+    get modulesGraph(): SDK.ModuleGraphInstance;
+    get _bootstrapTask(): Promise<void>;
+    getCompilerSDK(name: string): SDK.RsdoctorBuilderSDKInstance | RsdoctorPrimarySDK | undefined;
+    apply(compiler: unknown): unknown;
+    ensureModulesChunksGraphApplied(compiler: Plugin_2.BaseCompilerType<'rspack'>): void;
+    afterPlugins: (compiler: Plugin_2.BaseCompilerType<'rspack'>, context?: RsdoctorCompilerContext) => void;
+    done: (compiler: Plugin_2.BaseCompilerType<'rspack'>, context?: RsdoctorCompilerContext) => Promise<void>;
+    getRspackConfig(compiler: Plugin_2.BaseCompilerType<'rspack'>, context?: RsdoctorCompilerContext): void;
+    private createCompilerContext;
+    private getCompilerContext;
+    private ensureBootstrap;
+    private awaitBootstrap;
+    private clearBootstrapTask;
+    private disposeSDK;
+    private getOutputDir;
+    private getBriefReportFileName;
+    private applyChildCompilerSupport;
+    private registerChildCompiler;
+    private removeInheritedRsdoctorTaps;
+    private childDone;
+    private shouldDisposeSDK;
+    private releasePendingSessionOnRun;
+}
+
+declare type RsdoctorRspackPluginInstance<Rules extends LinterType.ExtendRuleData[] = []> = RsdoctorPluginInstance<Plugin_2.BaseCompilerType<'rspack'>, Rules>;
+
+export declare type RsdoctorRspackPluginOptions<Rules extends LinterType.ExtendRuleData[]> = Plugin_2.RsdoctorRspackPluginOptions<Rules>;
+
+declare type RsdoctorRspackPluginOptionsNormalized<Rules extends LinterType.ExtendRuleData[]> = Plugin_2.RsdoctorPluginOptionsNormalized<Rules>;
+
+declare type RsdoctorRspackSDKOptions = RsdoctorBuilderSDK;
+
+export declare class RsdoctorSDK<T extends RsdoctorRspackSDKOptions = RsdoctorRspackSDKOptions> extends SDKCore<T> implements SDK.RsdoctorBuilderSDKInstance {
+    server: RsdoctorServer;
+    extraConfig: SDK.SDKOptionsType | undefined;
+    type: SDK.ToDataType;
+    root: string;
+    private _summary;
+    private _configs;
+    private _errors;
+    private _loader;
+    private _loaderStart;
+    private _resolver;
+    private _plugin;
+    private _moduleGraph;
+    private _chunkGraph;
+    private _rawSourceMapCache;
+    private _sourceMap;
+    private _packageGraph;
+    constructor(options: T);
+    bootstrap(): Promise<void>;
+    dispose(): Promise<void>;
+    applyErrorFix(id: number): Promise<void>;
+    clear(): void;
+    clearSourceMapCache(): void;
+    getSourceMap(file: string): Promise<SourceMapConsumer | undefined>;
+    reportSourceMap(data: RawSourceMap): void;
+    reportConfiguration(config: SDK.ConfigData[0]): void;
+    reportError(errors: Error[]): void;
+    reportLoader(data: SDK.LoaderData): void;
+    reportLoaderStartOrEnd(data: SDK.ResourceLoaderData): void;
+    reportResolver(data: SDK.ResolverData): void;
+    reportPlugin(data: SDK.PluginData): void;
+    reportModuleGraph(data: SDK.ModuleGraphInstance): void;
+    reportPackageGraph(data: SDK.PackageGraphInstance): void;
+    reportChunkGraph(data: SDK.ChunkGraphInstance): void;
+    reportSummaryData(part: Partial<SDK.SummaryData>): void;
+    createPackageGraph(): void;
+    getBriefJsonPath(outputDir?: string): string | undefined;
+    protected writeBriefJson(data: Manifest.RsdoctorBriefData): void;
+    writeStore(options?: SDK.WriteStoreOptionsType): Promise<string>;
+    getStoreData(): SDK.BuilderStoreData;
+    getManifestData(): Manifest.RsdoctorManifestWithShardingFiles;
+    getRuleContext(_options: SDK.RuntimeContextOptions): SDK.RuntimeContext;
+    onDataReport(): void | Promise<void>;
+    addRsdoctorDataToHTML(storeData: SDK.BuilderStoreData, htmlContent: string): string;
+    inlineScriptsAndStyles(htmlFilePath: string): string;
+}
+
+declare class RsdoctorSDKController {
+    readonly slaves: RsdoctorPrimarySDK[];
+    private readonly activeSlaves;
+    private outputDir;
+    private outputOwner?;
+    private refreshManifestTask;
+    private readonly compilerDirectories;
+    private readonly briefReports;
+    root: string;
+    constructor(root?: string);
+    get master(): RsdoctorPrimarySDK;
+    get isMultiple(): boolean;
+    getLastSdk(): RsdoctorPrimarySDK;
+    hasName(name: string, exclude?: RsdoctorPrimarySDK): boolean;
+    registerSlave(slave: RsdoctorPrimarySDK): void;
+    setOutputDir(slave: RsdoctorPrimarySDK, outputDir: string): void;
+    getCompilerOutputDir(slave: RsdoctorPrimarySDK): string;
+    writeBriefJson(current: RsdoctorPrimarySDK, data: Manifest.RsdoctorBriefData): void;
+    getSeriesData(serverUrl?: boolean): Manifest.RsdoctorManifestSeriesData[];
+    getBriefSeriesData(current: RsdoctorPrimarySDK): Manifest.RsdoctorManifestSeriesData[];
+    createSlave({ name, displayName, compilerPath, parentCompilerPath, isChild, stage, extraConfig, type, }: Omit<ConstructorParameters<typeof RsdoctorPrimarySDK>[0], 'controller'>): RsdoctorPrimarySDK;
+    refreshManifestSeries(): Promise<void>;
+    private getActiveSlaves;
+}
+
+declare interface RsdoctorSDKOptions {
+    name: string;
+    root: string;
+}
+
+declare class RsdoctorServer implements SDK.RsdoctorServerInstance {
+    protected sdk: SDK.RsdoctorBuilderSDKInstance;
+    private _server;
+    port: number;
+    private _socket?;
+    private disposed;
+    private _router;
+    private _innerClientPath;
+    private _printServerUrl;
+    private _cors;
+    private _socketToken;
+    constructor(sdk: SDK.RsdoctorBuilderSDKInstance, port?: number, config?: RsdoctorServerOptions);
+    get app(): SDK.RsdoctorServerInstance['app'];
+    get host(): string;
+    get origin(): string;
+    get socketUrl(): ISocketType;
+    get innerClientPath(): string;
+    private createInnerServer;
+    private resolveCorsOptions;
+    bootstrap(): Promise<void>;
+    protected wrapNextHandleFunction(method: 'GET' | 'POST', cb: (...args: Parameters<Thirdparty.connect.NextHandleFunction>) => Common.PlainObject | string): Thirdparty.connect.NextHandleFunction;
+    proxy(api: SDK.ServerAPI.API, method: 'GET' | 'POST', cb: (...args: Parameters<Thirdparty.connect.NextHandleFunction>) => Common.PlainObject | string): void;
+    get: SDK.RsdoctorServerInstance['get'];
+    post: SDK.RsdoctorServerInstance['post'];
+    getClientUrl(route: Client.RsdoctorClientRoutes, baselineUrl: string, currentUrl: string): string;
+    getClientUrl(route?: 'homepage'): string;
+    openClientPage(route: Client.RsdoctorClientRoutes, baselineUrl: string, currentUrl: string): Promise<void>;
+    openClientPage(route?: 'homepage'): Promise<void>;
+    sendAPIDataToClient<T extends SDK.ServerAPI.API | SDK.ServerAPI.APIExtends>(api: T, msg: SDK.ServerAPI.SocketResponseType<T>): void;
+    broadcast(): Promise<void>;
+    dispose: (exitCode?: number) => Promise<void>;
+}
+
+declare type RsdoctorServerOptions = {
+    innerClientPath?: string;
+    printServerUrl?: boolean;
+    cors?: SDK.RsdoctorServerConfig['cors'];
+};
+
+declare interface RsdoctorSlaveSDKOptions {
+    name: string;
+    displayName?: string;
+    compilerPath?: string;
+    parentCompilerPath?: string;
+    isChild?: boolean;
+    /**
+     * use to sort for display in the client page.
+     * the smaller the front.
+     * @default 1
+     */
+    stage?: number;
+    extraConfig?: SDK.SDKOptionsType;
+    controller: RsdoctorSDKController;
+    type: SDK.ToDataType;
+}
+
+export declare const rules: LinterType.RuleData[];
+
+declare abstract class SDKCore<T extends RsdoctorSDKOptions> implements SDK.RsdoctorSDKInstance {
+    protected _name: string;
+    protected hash: string;
+    extraConfig: SDK.SDKOptionsType | undefined;
+    readonly root: string;
+    readonly pid: number;
+    readonly hooks: SDK.Hooks;
+    protected _envinfo: SDK.EnvInfo;
+    private _clientRoutes;
+    private _outputDir;
+    diskManifestPath: string;
+    cloudData?: Manifest.RsdoctorManifestWithShardingFiles;
+    constructor({ name, root }: T);
+    get outputDir(): string;
+    get name(): string;
+    bootstrap(): Promise<void>;
+    dispose(): Promise<void>;
+    setOutputDir(outputDir: string): void;
+    setName(name: string): void;
+    setHash(hash: string): void;
+    getHash(): string;
+    getClientRoutes(): Manifest.RsdoctorManifestClientRoutes[];
+    addClientRoutes(routes: Manifest.RsdoctorManifestClientRoutes[]): void;
+    /** Upload analysis data pieces */
+    protected writePieces(storeData: Common.PlainObject, options?: SDK.WriteStoreOptionsType): Promise<void>;
+    /** Upload manifest file */
+    protected writeManifest(): Promise<string>;
+    saveManifest(data: Common.PlainObject, options: SDK.WriteStoreOptionsType): Promise<string>;
+    protected writeToFolder(jsonStr: string, dir: string, key: string, index?: number, compressionLevel?: number): Promise<DataWithUrl>;
+    protected writeJsonFragmentsToFolder(jsonFragments: string[], dir: string, key: string, index?: number, compressionLevel?: number): Promise<DataWithUrl>;
+    abstract onDataReport(): void | Promise<void>;
+}
+
+export { }