@rsdoctor/types 1.5.9 → 1.5.11

package/dist/linter/rule.d.cts

@@ -0,0 +1,105 @@
+import type { ArrayToUnion, UnionToTuple } from '../common';
+import type { ErrorLevel as Severity } from '../error';
+import type { Hooks, RuntimeContext } from '../sdk';
+import type { ReportData, Diagnostic } from './diagnostic';
+import type { RuleMessage } from '../rule';
+/** Error level */
+export type SeverityString = keyof typeof Severity;
+/** Error level */
+export type SeverityInput = SeverityString | 'off' | 'on';
+/** Rule configuration */
+export type DefaultRuleConfig = any;
+export type DefaultRuleTitle = string;
+/** Rule check context */
+export interface RuleCheckerContext<Config = DefaultRuleConfig> extends RuntimeContext {
+    ruleConfig: Config;
+    /**
+     * Report an error
+     * @param {any} error - error data
+     * @param {any} replacer - replace the original error
+     */
+    report(error: ReportData, replacer?: any): void;
+}
+/**
+ * we shouldn't report any errors when the rule check end, so remove the report function on the context.
+ */
+export interface RuleCheckerContextForCheckEnd<Config = DefaultRuleConfig> {
+    /**
+     * data of the rule.
+     */
+    data: Omit<RuleCheckerContext<Config>, 'report'>;
+    /**
+     * the validate result for `all` rules.
+     */
+    validateResult: ValidateResult;
+    /**
+     * sdk hooks for rule context when check end.
+     *
+     * rules checking always run after builder compile done, so it must be a part of SDK.Hooks.
+     */
+    hooks: Pick<Hooks, 'afterSaveManifest'>;
+}
+export interface InternalRuleCheckerContextForCheckEnd<Config = DefaultRuleConfig> extends Omit<RuleCheckerContextForCheckEnd<Config>, 'data'> {
+    data: Omit<RuleCheckerContext<Config>, 'report' | 'ruleConfig'>;
+}
+export type CheckCallback<Config = DefaultRuleConfig> = (context: RuleCheckerContext<Config>) => void | Promise<void>;
+export type OnCheckEndCallback<Config = DefaultRuleConfig> = (context: RuleCheckerContextForCheckEnd<Config>) => void | Promise<void>;
+/** Rule Metadata */
+export interface RuleMeta<Config = DefaultRuleConfig, Title extends DefaultRuleTitle = DefaultRuleTitle> extends Pick<RuleMessage, 'code' | 'category'> {
+    title: Title;
+    severity: Severity;
+    /** Detailed document link */
+    referenceUrl?: string;
+    /** Default configuration */
+    defaultConfig?: Config;
+}
+export interface BaseRuleData<Config> {
+    check: CheckCallback<Config>;
+    /**
+     * execute when all rules check end.
+     */
+    onCheckEnd?: OnCheckEndCallback<Config>;
+}
+/** Rule Data */
+export interface RuleData<Config = DefaultRuleConfig, Title extends DefaultRuleTitle = DefaultRuleTitle> extends BaseRuleData<Config> {
+    meta: RuleMeta<Config, Title>;
+}
+/** External Rule Metadata */
+export interface ExtendRuleMeta<Config = DefaultRuleConfig, Title extends DefaultRuleTitle = DefaultRuleTitle> extends Omit<RuleMeta<Config, Title>, 'severity' | 'code'> {
+    severity: SeverityString;
+}
+/** External rule data */
+export interface ExtendRuleData<Config = DefaultRuleConfig, Title extends DefaultRuleTitle = DefaultRuleTitle> extends BaseRuleData<Config> {
+    meta: ExtendRuleMeta<Config, Title>;
+}
+/** rule constructor */
+export type RuleConstructor<Title extends DefaultRuleTitle, Config = DefaultRuleConfig> = () => RuleData<Config, Title>;
+/** External rule constructor */
+export type ExtendRuleConstructor<Title extends DefaultRuleTitle, Config = DefaultRuleConfig> = () => ExtendRuleData<Config, Title>;
+/** Rule configuration */
+export type RulesMap = Record<string, RuleConfigItem>;
+/** Single rule configuration */
+export type RuleConfigItem<T = unknown> = SeverityInput | [SeverityInput, T];
+/** Verification result */
+export interface ValidateResult {
+    errors: Diagnostic[];
+    replace: any[];
+}
+/** Verifier options */
+export interface Options<Extends extends ExtendRuleData[] = [], InternalRules extends RuleData[] = [], _Extends = UnionToTuple<ArrayToUnion<[...Extends]>>> {
+    rules?: InferRulesConfig<_Extends extends ExtendRuleData[] ? _Extends : Extends> & InferRulesConfig<InternalRules>;
+    level?: SeverityString;
+    extends?: Extends;
+}
+type InferRuleTitle<T extends ExtendRuleData | RuleData> = T['meta']['title'] extends `${infer R}` ? R : string;
+type InferRulesTitles<T extends (ExtendRuleData | RuleData)[]> = ArrayToUnion<{
+    [K in keyof T]: InferRuleTitle<T[K]>;
+}>;
+type InferRuleConfigByTitle<T extends (ExtendRuleData | RuleData)[], Title extends string> = {
+    [K in keyof T]: InferRuleTitle<T[K]> extends Title ? InferRuleConfig<T[K]> : never;
+}[number];
+export type InferRuleConfig<T> = T extends ExtendRuleData<infer P1> ? P1 : T extends RuleData<infer P2> ? P2 : any;
+export type InferRulesConfig<T extends (ExtendRuleData | RuleData)[]> = {
+    [K in InferRulesTitles<T>]?: RuleConfigItem<InferRuleConfigByTitle<T, K>>;
+} & Record<string, RuleConfigItem | undefined>;
+export {};

package/dist/logger.d.cts

@@ -0,0 +1,9 @@
+export declare enum LogLevel {
+    Silent = 0,
+    Error = 1,
+    Warning = 2,
+    Info = 3,
+    Debug = 4,
+    Verbose = 5
+}
+export type LogLevelName = keyof typeof LogLevel;

package/dist/manifest.d.cts

@@ -0,0 +1,68 @@
+import { PlainObject, ObjectPropertyNames } from './common';
+import { StoreData } from './sdk';
+export interface RsdoctorManifest {
+    client: RsdoctorManifestClient;
+    /**
+     * manifest url in tos, used by inner-rsdoctor.
+     */
+    cloudManifestUrl?: string;
+    /**
+     * manifest data shareding file urls in tos, used by inner-rsdoctor.
+     */
+    cloudData?: Record<keyof RsdoctorManifestData, string[] | string>;
+    data: RsdoctorManifestData;
+    /** current build name */
+    name?: string;
+    /**
+     * multiple build info
+     */
+    series?: RsdoctorManifestSeriesData[];
+}
+export interface RsdoctorManifestSeriesData {
+    name: string;
+    path: string;
+    stage: number;
+    origin?: string;
+}
+export interface RsdoctorManifestWithShardingFiles extends Omit<RsdoctorManifest, 'data'> {
+    data: Record<keyof RsdoctorManifestData, string[] | string>;
+    /**
+     * manifest data shareding file urls in tos, used by inner-rsdoctor.
+     */
+    cloudData?: Record<keyof RsdoctorManifestData, string[] | string>;
+    /**
+     * local server will proxy the manifest content and inject `__LOCAL__SERVER__: true`
+     */
+    __LOCAL__SERVER__?: boolean;
+    __SOCKET__PORT__?: string;
+    __SOCKET__URL__?: string;
+}
+export interface RsdoctorManifestClient {
+    enableRoutes: RsdoctorManifestClientRoutes[];
+}
+export interface RsdoctorManifestData extends StoreData {
+}
+export declare enum RsdoctorManifestClientRoutes {
+    Overall = "Overall",
+    WebpackLoaders = "Compile.WebpackLoaders",
+    ModuleResolve = "Compile.ModuleResolve",
+    WebpackPlugins = "Compile.WebpackPlugins",
+    BundleSize = "Bundle.BundleSize",
+    ModuleGraph = "Bundle.ModuleGraph",
+    TreeShaking = "Bundle.TreeShaking"
+}
+export declare enum RsdoctorManifestClientConstant {
+    WindowPropertyForManifestUrl = "__DEVTOOLS_MANIFEST_URL__"
+}
+export type RsdoctorManifestObjectKeys = NonNullable<ObjectPropertyNames<RsdoctorManifestData>>;
+export type RsdoctorManifestRootKeys = keyof RsdoctorManifestData;
+export type RsdoctorManifestMappingKeys = {
+    [K in RsdoctorManifestObjectKeys]: RsdoctorManifestData[K] extends PlainObject ? RsdoctorManifestData[K] extends Array<unknown> ? never : string extends keyof RsdoctorManifestData[K] ? never : keyof RsdoctorManifestData[K] extends string ? `${K}.${keyof RsdoctorManifestData[K]}` : never : never;
+}[RsdoctorManifestObjectKeys] | RsdoctorManifestRootKeys;
+export type InferManifestDataValue<T> = T extends `${infer Scope}.${infer Child}` ? Scope extends RsdoctorManifestObjectKeys ? Child extends keyof RsdoctorManifestData[Scope] ? RsdoctorManifestData[Scope][Child] : never : never : T extends RsdoctorManifestRootKeys ? RsdoctorManifestData[T] : never;
+export interface ManifestDataLoader {
+    loadManifest(): Promise<RsdoctorManifest | RsdoctorManifestWithShardingFiles>;
+    loadData: {
+        <T extends RsdoctorManifestMappingKeys>(key: T): Promise<void | InferManifestDataValue<T>>;
+    };
+}

package/dist/modules.d.cts

@@ -0,0 +1,7 @@
+import { StatsModule } from './plugin/baseStats';
+export type ChunkModuleMap = {
+    isAsset: boolean;
+    label: string;
+    modules: StatsModule[];
+};
+export type Modules = Record<string | number, ChunkModuleMap>;

package/dist/plugin/baseCompiler.d.cts

@@ -0,0 +1,33 @@
+import type { Compiler, Compilation, Stats, StatsError, RuleSetRule } from 'webpack';
+import type { Compiler as RspackCompiler, Compilation as RspackCompilation, Stats as RspackStats, RuleSetRule as RspackRuleSetRule, MultiCompiler } from '@rspack/core';
+type RspackCompilerWrapper = RspackCompiler & Pick<MultiCompiler, keyof Omit<MultiCompiler, 'hooks' | 'options' | 'isChild'>>;
+type RspackStatsWrapper = any extends RspackStats ? never : RspackStats;
+type RspackRuleSetRuleWrapper = any extends RspackRuleSetRule ? never : RspackRuleSetRule;
+export type BaseCompilerType<T extends 'rspack' | 'webpack' = 'webpack'> = T extends 'rspack' ? RspackCompilerWrapper : Compiler;
+export type BaseCompiler = BaseCompilerType | BaseCompilerType<'rspack'>;
+export type BaseCompilationType<T extends 'rspack' | 'webpack' = 'webpack'> = T extends 'rspack' ? Compilation : RspackCompilation;
+export type BaseCompilation = BaseCompilationType | BaseCompilationType<'rspack'>;
+export type BaseStats = Stats | RspackStatsWrapper;
+export interface JsStatsError {
+    message: string;
+    formatted?: string;
+    title?: string;
+}
+export interface JsStatsWarning extends JsRspackError {
+    message: string;
+    formatted?: string;
+}
+export interface JsRspackError {
+    name?: string;
+    message: string;
+    moduleIdentifier?: string;
+    loc?: string;
+    file?: string;
+    stack?: string;
+    hideStack?: boolean;
+}
+export type BuildError = JsStatsError | StatsError;
+export type BuildWarning = JsStatsWarning | StatsError;
+export type BuildRuleSetRules = (false | '' | 0 | RuleSetRule | '...' | null | undefined)[];
+export type BuildRuleSetRule = RuleSetRule | RspackRuleSetRuleWrapper;
+export {};

package/dist/plugin/baseLoader.d.cts

@@ -0,0 +1,78 @@
+import type { RuleSetRule as WebpackRuleSetRule, Configuration as WebpackConfiguration } from 'webpack';
+import type { Configuration as RspackConfiguration, RuleSetRule as RspackRuleSetRule } from '@rspack/core';
+export interface SourceMap {
+    version: number;
+    sources: string[];
+    mappings: string;
+    file?: string;
+    sourceRoot?: string;
+    sourcesContent?: string[];
+    names?: string[];
+}
+type RspackConfigurationWrapper = any extends RspackConfiguration ? never : RspackConfiguration;
+type RspackRuleSetRuleWrapper = any extends RspackRuleSetRule ? never : RspackRuleSetRule;
+export type RuleSetRule = RspackRuleSetRuleWrapper | WebpackRuleSetRule;
+export type Configuration = WebpackConfiguration | RspackConfigurationWrapper;
+declare interface AdditionalData {
+    [index: string]: any;
+    webpackAST: object;
+}
+export interface LoaderDefinitionFunction<OptionsType = {}, ContextAdditions = {}> {
+    (this: LoaderContext<OptionsType> & ContextAdditions, content: string, sourceMap?: string | SourceMap): string | void | Buffer | Promise<string | Buffer>;
+}
+export interface LoaderContext<OptionsType = {}> {
+    _module?: {
+        layer: string;
+    };
+    _compilation?: {
+        name: string;
+    };
+    getOptions(schema?: any): OptionsType;
+    /**
+     * Make this loader result cacheable. By default it's cacheable.
+     * A cacheable loader must have a deterministic result, when inputs and dependencies haven't changed.
+     * This means the loader shouldn't have other dependencies than specified with this.addDependency.
+     * Most loaders are deterministic and cacheable.
+     */
+    cacheable(flag?: boolean): void;
+    callback: (err?: null | Error, content?: string | Buffer, sourceMap?: string | SourceMap, additionalData?: AdditionalData) => void;
+    /**
+     * The resource path.
+     * In the example: "/abc/resource.js"
+     */
+    resourcePath: string;
+    query: string | OptionsType;
+    /**
+     * The resource query string.
+     * Example: "?query"
+     */
+    resourceQuery: string;
+    /**
+     * The resource fragment.
+     * Example: "#frag"
+     */
+    resourceFragment: string;
+    /**
+     * The resource inclusive query and fragment.
+     * Example: "/abc/resource.js?query#frag"
+     */
+    resource: string;
+    async(): (err?: Error | null, content?: string | Buffer, sourceMap?: string | SourceMap, additionalData?: AdditionalData) => void;
+    /**
+     * Target of compilation.
+     * Example: "web"
+     */
+    target: string;
+    loaderIndex: number;
+}
+export declare interface PitchLoaderDefinitionFunction<OptionsType = {}, ContextAdditions = {}> {
+    (this: LoaderContext<OptionsType> & ContextAdditions, remainingRequest: string, previousRequest: string, data: object): string | void | Buffer | Promise<string | Buffer>;
+}
+export interface RspackPitchLoaderDefinitionFunction<OptionsType = {}, ContextAdditions = {}> {
+    (this: LoaderContext<OptionsType> & ContextAdditions, remainingRequest: string, previousRequest: string, data: object): string | void | Buffer | Promise<string | Buffer>;
+}
+export type LoaderDefinition<T, R> = LoaderDefinitionFunction<T, R> & {
+    raw?: false;
+    pitch?: PitchLoaderDefinitionFunction<T> | RspackPitchLoaderDefinitionFunction<T>;
+};
+export {};

package/dist/plugin/baseStats.d.cts

@@ -0,0 +1,139 @@
+import { BaseCompilation } from './baseCompiler';
+interface StatsOptionsObj {
+    all?: boolean;
+    preset?: 'normal' | 'none' | 'verbose' | 'errors-only' | 'errors-warnings';
+    assets?: boolean;
+    chunks?: boolean;
+    modules?: boolean;
+    entrypoints?: boolean;
+    warnings?: boolean;
+    warningsCount?: boolean;
+    errors?: boolean;
+    errorsCount?: boolean;
+    colors?: boolean;
+    chunkModules?: boolean;
+    hash?: boolean;
+    ids?: boolean;
+    orphanModules?: boolean;
+    runtimeModules?: boolean;
+    cachedModules?: boolean;
+    nestedModules?: boolean;
+    optimizationBailout?: boolean;
+    /** Rspack not support below opts */
+    cachedAssets?: boolean;
+    groupAssetsByInfo?: boolean;
+    groupAssetsByPath?: boolean;
+    groupAssetsByChunk?: boolean;
+    groupAssetsByExtension?: boolean;
+    groupAssetsByEmitStatus?: boolean;
+}
+/** webpack not support boolean or string */
+type StatsOptions = StatsOptionsObj;
+interface StatsAssetInfo {
+    development?: boolean;
+}
+export interface StatsAsset {
+    type: string;
+    name: string;
+    size: number;
+    chunks?: (string | number)[];
+    chunkNames?: Array<string | number>;
+    info: StatsAssetInfo;
+}
+interface StatsError {
+    message: string;
+    formatted?: string;
+}
+type KnownStatsModuleIssuer = {
+    identifier?: string;
+    name?: string;
+    id?: string | number | null;
+    moduleId?: string | number | null;
+};
+export interface StatsModule {
+    type?: string;
+    moduleType?: string;
+    identifier?: string;
+    moduleIdentifier?: string;
+    name?: string;
+    moduleName?: string;
+    id?: string | number;
+    chunks?: Array<string | number>;
+    size?: number;
+    issuer?: string;
+    issuerName?: string;
+    assets?: Array<string | number>;
+    reasons?: Array<StatsModuleReason>;
+    source?: string | Buffer;
+    orphanModules?: Array<StatsModule>;
+    runtimeModules?: Array<StatsModule>;
+    cachedModules?: Array<StatsModule>;
+    nestedModules?: Array<StatsModule>;
+    nameForCondition?: string;
+    depth?: number | string;
+    loc?: string;
+    modules?: StatsModule[];
+    layer?: string;
+    issuerPath?: Record<string, any>[] | KnownStatsModuleIssuer[];
+    optimizationBailout?: string[];
+}
+export interface StatsModuleReason {
+    moduleIdentifier?: string;
+    moduleName?: string;
+    moduleId?: string | number;
+    type?: string;
+    userRequest?: string;
+    children?: StatsModuleReason[];
+    loc?: string;
+}
+export interface JSStatsChunkGroup {
+    name?: string;
+    assets?: {
+        name: string;
+        size?: number;
+    }[];
+    chunks?: (string | number)[];
+    assetsSize?: number;
+}
+export type StatsChunkGroup = JSStatsChunkGroup;
+export interface StatsCompilation {
+    version?: string;
+    /** rspack version */
+    rspackVersion?: string;
+    name?: string;
+    hash?: string;
+    time?: number;
+    builtAt?: number;
+    publicPath?: string;
+    assetsByChunkName?: Record<string, string[]>;
+    filteredModules?: number;
+    assets?: Array<StatsAsset>;
+    modules?: Array<StatsModule>;
+    chunks?: Array<StatsChunk>;
+    entrypoints?: Record<string, StatsChunkGroup>;
+    children?: StatsCompilation[];
+    errors?: Array<StatsError>;
+    errorsCount?: number;
+    warnings?: Array<StatsError>;
+    warningsCount?: number;
+    outputPath?: string;
+}
+interface StatsChunk {
+    type?: string;
+    files?: Array<string>;
+    id?: string | number;
+    entry: boolean;
+    initial: boolean;
+    names?: Array<string>;
+    size: number;
+    modules?: Array<StatsModule>;
+}
+export declare class Stats {
+    constructor(statsJson: any);
+    compilation: BaseCompilation;
+    hasErrors(): boolean;
+    hasWarnings(): boolean;
+    toJson(opts?: StatsOptions): StatsCompilation;
+    toString(opts?: StatsOptions): string;
+}
+export {};

package/dist/plugin/index.d.cts

@@ -0,0 +1,7 @@
+export * from './baseCompiler';
+export * from './baseStats';
+export * from './plugin';
+export * from './baseLoader';
+export * from './rspack';
+export * from './internal-rules';
+export * from './webpack';

package/dist/plugin/internal-rules.d.cts

@@ -0,0 +1,4 @@
+import { Linter } from '../index';
+export type InternalRules = Linter.RuleData[];
+export type InternalRuleId = 'E1001' | 'E1002' | 'E1003' | 'E1004' | 'E1005' | 'E1006' | 'E1007';
+export type InternalRuleName = 'duplicate-package' | 'cross-chunks-package' | 'default-import-check' | 'ecma-version-check' | 'loader-performance-optimization' | 'module-mixed-chunks' | 'tree-shaking-side-effects-only';

package/dist/plugin/plugin.d.cts

@@ -0,0 +1,159 @@
+import { Common, Config, Linter as LinterType, SDK } from '..';
+import { InternalRules } from './internal-rules';
+export interface RsdoctorWebpackPluginFeatures {
+    /**
+     * turn off it if you need not to analyze the executions of webpack loaders.
+     * @default true
+     */
+    loader?: boolean;
+    /**
+     * turn off it if you need not to analyze the executions of webpack plugins.
+     * @default true
+     */
+    plugins?: boolean;
+    /**
+     * turn off it if you need not to analyze the executions of resolver.
+     * @default false
+     */
+    resolver?: boolean;
+    /**
+     * turn off it if you need not to analyze the output bundle.
+     * @default true
+     */
+    bundle?: boolean;
+    /**
+     * turn off it if you need not to analyze the result of tree shaking.
+     * @default false
+     */
+    treeShaking?: boolean;
+    /**
+     * turn on it if you just use lite mode. This mode do not have source codes.
+     * @default false
+     */
+    lite?: boolean;
+}
+export interface RsdoctorPluginOptionsNormalized<Rules extends LinterType.ExtendRuleData[] = []> extends Common.DeepRequired<Omit<RsdoctorWebpackPluginOptions<Rules>, 'sdkInstance' | 'linter' | 'output' | 'supports' | 'port' | 'brief' | 'mode'>> {
+    features: Common.DeepRequired<RsdoctorWebpackPluginFeatures>;
+    linter: Required<LinterType.Options<Rules, InternalRules>>;
+    sdkInstance?: SDK.RsdoctorBuilderSDKInstance;
+    output: {
+        mode: keyof typeof SDK.IMode;
+        reportCodeType: SDK.ToDataType;
+        reportDir: string;
+        options: Config.BriefModeOptions | Config.NormalModeOptions;
+    };
+    port?: number;
+    supports: ISupport;
+}
+interface ISupport {
+    banner?: boolean;
+    parseBundle?: boolean;
+    generateTileGraph?: boolean;
+    gzip?: boolean;
+}
+interface OutputBaseConfig {
+    /**
+     * The directory where the report files will be output.
+     */
+    reportDir?: string;
+    /**
+     * Control the Rsdoctor reporter codes records.
+     */
+    reportCodeType?: IReportCodeType | undefined | NewReportCodeType;
+    /**
+     * @deprecated
+     * Configure whether to compress data.
+     * @default false
+     *
+     */
+    compressData?: boolean;
+}
+export type IReportCodeType = {
+    noModuleSource?: boolean;
+    noAssetsAndModuleSource?: boolean;
+    noCode?: boolean;
+};
+export type NewReportCodeType = 'noModuleSource' | 'noAssetsAndModuleSource' | 'noCode';
+export interface RsdoctorWebpackPluginOptions<Rules extends LinterType.ExtendRuleData[]> {
+    /** Checker configuration */
+    linter?: LinterType.Options<Rules, InternalRules>;
+    /**
+     * the switch for the Rsdoctor features.
+     */
+    features?: RsdoctorWebpackPluginFeatures | Array<keyof RsdoctorWebpackPluginFeatures>;
+    /**
+     * @deprecated  Use `output.mode` instead, if you're using `lite` mode, please use `output.reportCodeType: 'noCode' or 'noAssetsAndModuleSource'` instead.
+     * Rsdoctor mode option:
+     * - normal: Refers to the normal mode.
+     * - brief: Refers to the brief mode, which only displays the results of the duration analysis and build artifact analysis
+     *    and does not display any part of the code.
+     */
+    mode?: 'brief' | 'normal' | 'lite';
+    /**
+     * configuration of the interceptor for webpack loaders. TODO: delete this options.
+     * @description worked when the `features.loader === true`.
+     */
+    loaderInterceptorOptions?: {
+        /**
+         * loaders which you want to skip it (will not report the target loader data when webpack compile).
+         */
+        skipLoaders?: string[];
+    };
+    /**
+     * turn on it if you don't need to see profile in browser.
+     * @default false
+     */
+    disableClientServer?: boolean;
+    /**
+     * sdk instance of outside.
+     */
+    sdkInstance?: SDK.RsdoctorBuilderSDKInstance;
+    /**
+     * Whether to turn on some characteristic analysis capabilities, such as: the support for the BannerPlugin.
+     */
+    supports?: ISupport;
+    /**
+     * The port of the Rsdoctor server.
+     */
+    port?: number;
+    /**
+     * Options to control the log printing.
+     */
+    printLog?: SDK.IPrintLog;
+    /**
+     * @deprecated  Use `output.options.htmlOptions` instead.
+     * Please use the output.options to set the brief options, BriefModeOptions.
+     * Options to control brief mode reports.
+     */
+    brief?: Config.BriefConfig;
+    /**
+     * The name of inner rsdoctor's client package, used by inner-rsdoctor.
+     * @default false
+     */
+    innerClientPath?: string;
+    output?: Config.IOutput<'brief' | 'normal'>;
+}
+type ReportCodeTypeByMode<T extends 'brief' | 'normal'> = T extends 'brief' ? undefined | 'noCode' | {
+    noCode?: boolean;
+} : T extends 'normal' ? IReportCodeType | undefined | NewReportCodeType : IReportCodeType | undefined | NewReportCodeType;
+export interface NormalModeOptions {
+    type?: never;
+}
+interface NormalModeConfig extends Omit<OutputBaseConfig, 'reportCodeType' | 'mode'> {
+    mode?: 'normal';
+    reportCodeType?: ReportCodeTypeByMode<'normal'>;
+    options?: NormalModeOptions;
+}
+export interface BriefModeOptions {
+    /** Output type, supports HTML and JSON */
+    type?: Array<'html'>;
+    /** HTML output related configuration */
+    htmlOptions?: Config.BriefConfig;
+}
+export interface BriefModeConfig extends Omit<OutputBaseConfig, 'reportCodeType' | 'mode'> {
+    mode?: 'brief';
+    reportCodeType?: ReportCodeTypeByMode<'brief'>;
+    options?: BriefModeOptions;
+}
+export type IOutput<T extends 'brief' | 'normal' | undefined = undefined> = T extends 'brief' ? BriefModeConfig : T extends 'normal' ? NormalModeConfig : BriefModeConfig | NormalModeConfig | OutputBaseConfig;
+export {};

package/dist/plugin/rspack.d.cts

@@ -0,0 +1,37 @@
+import type { RsdoctorPluginData, NormalModuleFactory, LoaderDefinitionFunction, ModuleGraph, Dependency } from '@rspack/core';
+export type RspackNormalModuleFactory = NormalModuleFactory;
+export type RspackNativeAsset = RsdoctorPluginData.RsdoctorAsset;
+export type RspackNativeChunkGraph = RsdoctorPluginData.RsdoctorChunkGraph;
+export type RspackNativeModuleGraph = RsdoctorPluginData.RsdoctorModuleGraph;
+export type RspackNativeChunk = RsdoctorPluginData.RsdoctorChunk;
+export type RspackNativeModule = RsdoctorPluginData.RsdoctorModule;
+export type RspackNativeSideEffect = RsdoctorPluginData.RsdoctorSideEffect;
+export type RspackNativeExportInfo = RsdoctorPluginData.RsdoctorExportInfo;
+export type RspackNativeVariable = RsdoctorPluginData.RsdoctorVariable;
+export type RspackNativeDependency = RsdoctorPluginData.RsdoctorDependency;
+export type RspackNativeEntrypoint = RsdoctorPluginData.RsdoctorEntrypoint;
+export type RspackNativeStatement = RsdoctorPluginData.RsdoctorStatement;
+export type RspackNativeSourceRange = RsdoctorPluginData.RsdoctorSourceRange;
+export type RspackNativeSourcePosition = RsdoctorPluginData.RsdoctorSourcePosition;
+export type RspackNativeModuleGraphModule = RsdoctorPluginData.RsdoctorModuleGraphModule;
+export type RspackNativeAssetPatch = RsdoctorPluginData.RsdoctorAssetPatch;
+export type RspackNativeModuleIdsPatch = RsdoctorPluginData.RsdoctorModuleIdsPatch;
+export type RspackNativeChunkModules = RsdoctorPluginData.RsdoctorChunkModules;
+export type RspackNativeModuleOriginalSource = RsdoctorPluginData.RsdoctorModuleOriginalSource;
+export type RspackNativeModuleSourcePatch = RsdoctorPluginData.RsdoctorModuleSourcesPatch;
+import rspack from '@rspack/core';
+export type RspackExportsExperiments = typeof rspack.experiments;
+export type RspackSourceMapInput = Parameters<LoaderDefinitionFunction>[1];
+export type RspackEntryPoint = boolean | 'auto';
+export interface RspackExportInfo {
+    used: boolean;
+    provideInfo: boolean | null | undefined;
+    useInfo: boolean | null | undefined;
+    canMangle: boolean;
+}
+export type RspackExportsInfo = ReturnType<ModuleGraph['getExportsInfo']>;
+export interface RspackHarmonyImportSpecifierDependency extends Dependency {
+    getIds(graph: ModuleGraph): string[];
+    name: string;
+    userRequest: string;
+}

package/dist/plugin/webpack.d.cts

@@ -0,0 +1,13 @@
+import { Compiler, Compilation, LoaderDefinitionFunction, ModuleGraph, Dependency } from 'webpack';
+type GetMapValue<M extends Map<any, any>> = M extends Map<string, infer V> ? V : never;
+export type NormalModuleFactory = ReturnType<Compiler['createNormalModuleFactory']>;
+export type SourceMapInput = Parameters<LoaderDefinitionFunction>[1];
+export type EntryPoint = GetMapValue<Compilation['entrypoints']>;
+export type ExportInfo = ReturnType<ModuleGraph['getExportInfo']>;
+export type ExportsInfo = ReturnType<ModuleGraph['getExportsInfo']>;
+export interface HarmonyImportSpecifierDependency extends Dependency {
+    getIds(graph: ModuleGraph): string[];
+    name: string;
+    userRequest: string;
+}
+export {};

package/dist/rule/code/E1001.d.cts

@@ -0,0 +1,3 @@
+import { RuleMessage } from './type';
+export declare const code = "E1001";
+export declare const message: RuleMessage;