@rsdoctor/types 0.0.2-beta.0

package/dist/linter/rule.d.ts

@@ -0,0 +1,107 @@
+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>>;
+} & {
+    [key: string]: RuleConfigItem;
+};
+export {};

package/dist/linter/rule.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/logger.d.ts

@@ -0,0 +1,34 @@
+export declare enum LogLevel {
+    Silent = 0,
+    Error = 1,
+    Warning = 2,
+    Info = 3,
+    Debug = 4,
+    Verbose = 5
+}
+export type LogLevelName = keyof typeof LogLevel;
+export interface LoggerOptions {
+    /**
+     * Default is `info`.
+     */
+    level?: LogLevelName;
+    /**
+     * Default is `false`.
+     */
+    timestamp?: boolean;
+    /**
+     * Default is empty string
+     */
+    prefix?: string;
+}
+type Label = string;
+export declare abstract class LoggerInstance {
+    abstract timesLog: Map<Label, number>;
+    abstract info(...msg: string[]): void;
+    abstract warn(...msg: string[]): void;
+    abstract error(...msg: string[]): void;
+    abstract debug(...msg: string[]): void;
+    abstract time(label: Label): void;
+    abstract timeEnd(label: Label): void;
+}
+export {};

package/dist/logger.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoggerInstance = exports.LogLevel = void 0;
+var LogLevel;
+(function (LogLevel) {
+    LogLevel[LogLevel["Silent"] = 0] = "Silent";
+    LogLevel[LogLevel["Error"] = 1] = "Error";
+    LogLevel[LogLevel["Warning"] = 2] = "Warning";
+    LogLevel[LogLevel["Info"] = 3] = "Info";
+    LogLevel[LogLevel["Debug"] = 4] = "Debug";
+    LogLevel[LogLevel["Verbose"] = 5] = "Verbose";
+})(LogLevel || (exports.LogLevel = LogLevel = {}));
+class LoggerInstance {
+}
+exports.LoggerInstance = LoggerInstance;

package/dist/manifest.d.ts

@@ -0,0 +1,55 @@
+import { PlainObject, ObjectPropertyNames } from './common';
+import { StoreData } from './sdk';
+export interface DoctorManifest {
+    client: DoctorManifestClient;
+    data: DoctorManifestData;
+    /** current build name */
+    name?: string;
+    /**
+     * multiple build info
+     */
+    series?: DoctorManifestSeriesData[];
+}
+export interface DoctorManifestSeriesData {
+    name: string;
+    path: string;
+    stage: number;
+    origin?: string;
+}
+export interface DoctorManifestWithShardingFiles extends Omit<DoctorManifest, 'data'> {
+    data: Record<keyof DoctorManifestData, string[] | string>;
+    /**
+     * local server will proxy the manifest content and inject `__LOCAL__SERVER__: true`
+     */
+    __LOCAL__SERVER__?: boolean;
+    __SOCKET__URL__?: string;
+}
+export interface DoctorManifestClient {
+    enableRoutes: DoctorManifestClientRoutes[];
+}
+export interface DoctorManifestData extends StoreData {
+}
+export declare enum DoctorManifestClientRoutes {
+    Overall = "Overall",
+    WebpackLoaders = "Compile.WebpackLoaders",
+    ModuleResolve = "Compile.ModuleResolve",
+    WebpackPlugins = "Compile.WebpackPlugins",
+    BundleSize = "Bundle.BundleSize",
+    ModuleGraph = "Bundle.ModuleGraph",
+    TreeShaking = "Bundle.TreeShaking"
+}
+export declare enum DoctorManifestClientConstant {
+    WindowPropertyForManifestUrl = "__DEVTOOLS_MANIFEST_URL__"
+}
+export type DoctorManifestObjectKeys = NonNullable<ObjectPropertyNames<DoctorManifestData>>;
+export type DoctorManifestRootKeys = keyof DoctorManifestData;
+export type DoctorManifestMappingKeys = {
+    [K in DoctorManifestObjectKeys]: DoctorManifestData[K] extends PlainObject ? DoctorManifestData[K] extends Array<unknown> ? never : string extends keyof DoctorManifestData[K] ? never : keyof DoctorManifestData[K] extends string ? `${K}.${keyof DoctorManifestData[K]}` : never : never;
+}[DoctorManifestObjectKeys] | DoctorManifestRootKeys;
+export type InferManifestDataValue<T> = T extends `${infer Scope}.${infer Child}` ? Scope extends DoctorManifestObjectKeys ? Child extends keyof DoctorManifestData[Scope] ? DoctorManifestData[Scope][Child] : never : never : T extends DoctorManifestRootKeys ? DoctorManifestData[T] : never;
+export interface ManifestDataLoader {
+    loadManifest(): Promise<DoctorManifest | DoctorManifestWithShardingFiles>;
+    loadData: {
+        <T extends DoctorManifestMappingKeys>(key: T): Promise<void | InferManifestDataValue<T>>;
+    };
+}

package/dist/manifest.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DoctorManifestClientConstant = exports.DoctorManifestClientRoutes = void 0;
+var DoctorManifestClientRoutes;
+(function (DoctorManifestClientRoutes) {
+    DoctorManifestClientRoutes["Overall"] = "Overall";
+    DoctorManifestClientRoutes["WebpackLoaders"] = "Compile.WebpackLoaders";
+    DoctorManifestClientRoutes["ModuleResolve"] = "Compile.ModuleResolve";
+    DoctorManifestClientRoutes["WebpackPlugins"] = "Compile.WebpackPlugins";
+    DoctorManifestClientRoutes["BundleSize"] = "Bundle.BundleSize";
+    DoctorManifestClientRoutes["ModuleGraph"] = "Bundle.ModuleGraph";
+    DoctorManifestClientRoutes["TreeShaking"] = "Bundle.TreeShaking";
+})(DoctorManifestClientRoutes || (exports.DoctorManifestClientRoutes = DoctorManifestClientRoutes = {}));
+var DoctorManifestClientConstant;
+(function (DoctorManifestClientConstant) {
+    DoctorManifestClientConstant["WindowPropertyForManifestUrl"] = "__DEVTOOLS_MANIFEST_URL__";
+})(DoctorManifestClientConstant || (exports.DoctorManifestClientConstant = DoctorManifestClientConstant = {}));

package/dist/modules.d.ts

@@ -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/modules.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/plugin/baseCompiler.d.ts

@@ -0,0 +1,20 @@
+import type { Compiler, Compilation, Stats, StatsError, RuleSetRule } from 'webpack';
+import type { Compiler as RspackCompiler, Compilation as RspackCompilation, Stats as RspackStats, RuleSetRule as RspackRuleSetRule, RuleSetRules } from '@rspack/core';
+export type BaseCompiler = (Compiler | RspackCompiler) & {
+    webpack: any;
+};
+export type BaseCompilation = RspackCompilation | Compilation;
+export type BaseStats = Stats | RspackStats;
+export interface JsStatsError {
+    message: string;
+    formatted: string;
+    title: string;
+}
+export interface JsStatsWarning {
+    message: string;
+    formatted: string;
+}
+export type BuildError = JsStatsError | StatsError;
+export type BuildWarning = JsStatsWarning | StatsError;
+export type BuildRuleSetRules = (RuleSetRule | '...')[] | RuleSetRules;
+export type BuildRuleSetRule = RuleSetRule | RspackRuleSetRule;

package/dist/plugin/baseCompiler.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/plugin/baseLoader.d.ts

@@ -0,0 +1,71 @@
+/// <reference types="node" />
+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[];
+}
+export type RuleSetRule = RspackRuleSetRule | WebpackRuleSetRule;
+export type Configuration = WebpackConfiguration | RspackConfiguration;
+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 = {}> {
+    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/baseLoader.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/plugin/baseStats.d.ts

@@ -0,0 +1,114 @@
+/// <reference types="node" />
+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;
+    /** 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;
+}
+export interface StatsModule {
+    type?: string;
+    moduleType?: string;
+    identifier?: string;
+    name?: string;
+    id?: string | number;
+    chunks?: Array<string | number>;
+    size?: number;
+    issuer?: string;
+    issuerName?: string;
+    assets?: Array<string | number>;
+    reasons?: Array<StatsModuleReason>;
+    source?: string | Buffer;
+    nameForCondition?: string;
+    depth?: number | string;
+    loc?: string;
+    modules?: StatsModule[];
+}
+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 */
+    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);
+    hasErrors(): boolean;
+    hasWarnings(): boolean;
+    toJson(opts?: StatsOptions): StatsCompilation;
+    toString(opts?: StatsOptions): string;
+}
+export {};

package/dist/plugin/baseStats.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/plugin/index.d.ts

@@ -0,0 +1,4 @@
+export * from './baseCompiler';
+export * from './baseStats';
+export * from './plugin';
+export * from './baseLoader';

package/dist/plugin/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./baseCompiler"), exports);
+__exportStar(require("./baseStats"), exports);
+__exportStar(require("./plugin"), exports);
+__exportStar(require("./baseLoader"), exports);

package/dist/plugin/plugin.d.ts

@@ -0,0 +1,32 @@
+export interface DoctorWebpackPluginFeatures {
+    /**
+     * 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;
+}

package/dist/plugin/plugin.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

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

package/dist/rule/code/E1001.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.message = exports.code = void 0;
+exports.code = 'E1001';
+exports.message = {
+    code: exports.code,
+    title: 'Duplicate Packages',
+    type: 'markdown',
+    category: 'bundle',
+    description: `
+#### Description
+
+there is a same name package which bundled more than one version in your application.
+
+it is not good to the bundle size of your application.
+
+#### General Solution
+
+add an entry in \`resolve.alias\` which will configure Webpack to route any package references to a single specified path.
+
+For example, if \`lodash\` is duplicated in your bundle, the following configuration would render all Lodash imports to always refer to the \`lodash\` instance found at \`./node_modules/lodash\`:
+
+\`\`\`js
+{
+  alias: {
+    lodash: path.resolve(__dirname, 'node_modules/lodash')
+  }
+}
+\`\`\`
+`,
+};

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

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

package/dist/rule/code/E1002.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.message = exports.code = void 0;
+exports.code = 'E1002';
+exports.message = {
+    code: exports.code,
+    title: 'Default Import Check',
+    type: 'markdown',
+    category: 'compile',
+    description: `
+#### Description
+
+Usually webpack will automatically compatible different modules that has different types, but in a special case, the operation of compatibility will fail.
+That is, when you use \`Default Import\` to import a cjs module, and this cjs module do not have the compatible statement, such as \`exports.default = \`.
+
+#### General Solution
+
+1. for cjs module, write a \`exports.default = \` statement for default export.
+2. use \`Namespace Import\` for import the cjs module.
+
+For example, for the package \`htmlparser2@7.2.0\`:
+
+\`\`\`ts
+// you should use this
+import * as Parser from 'htmlparser2';
+
+// can not use this
+import Parser from 'htmlparser2';
+\`\`\`
+`,
+};

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

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

package/dist/rule/code/E1003.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.message = exports.code = void 0;
+exports.code = 'E1003';
+exports.message = {
+    code: exports.code,
+    title: 'Loader Performance Optimization',
+    type: 'markdown',
+    category: 'compile',
+    description: `
+#### Description
+
+Usually the slow compile of most projects is due to the slow execution of the loaders.
+
+And the loaders always pre-process many unnecessary files, such as \`node_modules files\` and \`already compiled files\`.
+
+#### General Solution
+
+Set \`exclude\` to the \`module.rules\` of webpack configuration for target loader.
+
+For example, if \`node_modules/lodash\` is processed by the \`babel-loader\` that make the compile slowly:
+
+\`\`\`
+{
+  module: {
+    rules: [
+      {
+        test: /\\.js$/,
+        use: 'babel-loader',
+        exclude: [
+          /node_modules\\/lodash/
+        ]
+      }
+    ]
+  }
+}
+\`\`\`
+`,
+};

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

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