@rsdoctor/types 1.5.8 → 1.5.10

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;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,33 @@
+import { RuleMessage } from './type';
+import * as E1001 from './E1001';
+import * as E1002 from './E1002';
+import * as E1003 from './E1003';
+import * as E1004 from './E1004';
+import * as E1005 from './E1005';
+import * as E1006 from './E1006';
+import * as E1007 from './E1007';
+import * as E1008 from './E1008';
+import * as E1009 from './E1009';
+export type RuleErrorCodes = {
+    [E1001.code]: typeof E1001;
+    [E1002.code]: typeof E1002;
+    [E1003.code]: typeof E1003;
+    [E1004.code]: typeof E1004;
+    [E1005.code]: typeof E1005;
+    [E1006.code]: typeof E1006;
+    [E1007.code]: typeof E1007;
+    [E1008.code]: typeof E1008;
+    [E1009.code]: typeof E1009;
+};
+/**
+ * The format is E + "4 digits".
+ * - The first number represents the category:
+ * - 1 for Webpack build related indexes
+ * - ...
+ * - The rest of the numbers can be increased by adding zeros
+ */
+export declare const RuleErrorMap: Record<keyof RuleErrorCodes, RuleMessage>;
+export declare enum RsdoctorRuleClientConstant {
+    UrlQueryForErrorCode = "code"
+}
+export * from './type';

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

@@ -0,0 +1,27 @@
+import { RuleErrorCodes } from '.';
+/**
+ * only defined the code which can be enumerated
+ */
+export declare enum RuleMessageCodeEnumerated {
+    /**
+     * others tools / frameworks errors, such as PIA
+     */
+    Extend = "EXTEND",
+    /**
+     * errors show in the overlay at the client, such as Webpack compile errors in development
+     */
+    Overlay = "OVERLAY"
+}
+export type RuleMessageCode = keyof RuleErrorCodes | `${RuleMessageCodeEnumerated}` | RuleMessageCodeEnumerated;
+export declare enum RuleMessageCategory {
+    Compile = "compile",
+    Bundle = "bundle",
+    EMO = "emo"
+}
+export interface RuleMessage {
+    code: RuleMessageCode;
+    title: string;
+    type: 'text' | 'markdown';
+    category: `${RuleMessageCategory}` | RuleMessageCategory;
+    description: string;
+}