@rsdoctor/core 0.1.0 → 0.1.2

package/dist/inner-plugins/plugins/ensureModulesChunkGraph.js

@@ -31,11 +31,13 @@ __export(ensureModulesChunkGraph_exports, {
   ensureModulesChunksGraphFn: () => ensureModulesChunksGraphFn
 });
 module.exports = __toCommonJS(ensureModulesChunkGraph_exports);
-var import_logger = require("@rsdoctor/utils/logger");
+var import_path = __toESM(require("path"));
+var import_types2 = require("@rsdoctor/types");
 var import_build = require("@rsdoctor/utils/build");
+var import_logger = require("@rsdoctor/utils/logger");
+var import_fs_extra = __toESM(require("fs-extra"));
 var import_build2 = require("../../build-utils/build");
 var import_common = require("../../build-utils/common");
-var import_fs_extra = __toESM(require("fs-extra"));
 var import_constants = require("../constants");
 const ensureModulesChunksGraphFn = (compiler, _this) => {
   if (_this._modulesGraphApplied)
@@ -64,18 +66,17 @@ const ensureModulesChunksGraphFn = (compiler, _this) => {
         context
       );
       (0, import_logger.debug)(import_build.Process.getMemoryUsageMessage, "[After Generate ModuleGraph]");
-      await getModulesInfosByStats(
-        compiler,
-        statsJson,
-        _this.modulesGraph
-      );
+      await getModulesInfosByStats(compiler, statsJson, _this.modulesGraph);
       (0, import_logger.debug)(import_build.Process.getMemoryUsageMessage, "[After Transform ModuleGraph]");
       _this.modulesGraph && await _this.sdk.reportModuleGraph(_this.modulesGraph);
       await _this.sdk.reportChunkGraph(_this.chunkGraph);
       const reportFilePath = await import_build2.Chunks.generateTileGraph(
         statsJson,
         {
-          reportFilename: import_build2.Chunks.TileGraphReportName,
+          reportFilename: import_path.default.join(
+            import_types2.Constants.RsdoctorOutputFolder,
+            import_build2.Chunks.TileGraphReportName
+          ),
           reportTitle: "bundle-analyzer"
         },
         compiler.outputPath

package/dist/inner-plugins/plugins/errors.d.ts

@@ -2,10 +2,10 @@ import { Rule, Err, Plugin } from '@rsdoctor/types';
 import { InternalBasePlugin } from './base';
 import { DevToolError } from '@rsdoctor/utils/error';
 export declare class InternalErrorReporterPlugin<T extends Plugin.BaseCompiler> extends InternalBasePlugin<T> {
-  readonly name = "error-reporter";
-  apply(compiler: T): void;
-  done: (stats: Plugin.BaseStats) => Promise<void>;
-  handleWebpackError(err: Plugin.BuildError, category: Rule.RuleMessageCategory, level: keyof typeof Err.ErrorLevel): DevToolError;
-  reportWarnings(warnings: Plugin.BuildError[]): Promise<void>;
-  reportErrors(errors: Plugin.BuildWarning[]): Promise<void>;
-}
+    readonly name = "error-reporter";
+    apply(compiler: T): void;
+    done: (stats: Plugin.BaseStats) => Promise<void>;
+    handleWebpackError(err: Plugin.BuildError, category: Rule.RuleMessageCategory, level: keyof typeof Err.ErrorLevel): DevToolError;
+    reportWarnings(warnings: Plugin.BuildError[]): Promise<void>;
+    reportErrors(errors: Plugin.BuildWarning[]): Promise<void>;
+}

package/dist/inner-plugins/plugins/index.d.ts

@@ -6,4 +6,4 @@ export * from './summary';
 export * from './base';
 export * from './bundle';
 export * from './ensureModulesChunkGraph';
-export * from './rules';
+export * from './rules';

package/dist/inner-plugins/plugins/loader.d.ts

@@ -2,10 +2,10 @@ import { Plugin } from '@rsdoctor/types';
 import { RuleSetRule } from 'webpack';
 import { InternalBasePlugin } from './base';
 export declare class InternalLoaderPlugin<T extends Plugin.BaseCompiler> extends InternalBasePlugin<T> {
-  readonly name = "loader";
-  readonly internalLoaderPath: string;
-  apply(compiler: T): void;
-  afterPlugins: (compiler: Plugin.BaseCompiler) => void;
-  compilation(compiler: Plugin.BaseCompiler, compilation: Plugin.BaseCompilation): void;
-  getInterceptRules(compiler: Plugin.BaseCompiler, rules: RuleSetRule[]): RuleSetRule[];
-}
+    readonly name = "loader";
+    readonly internalLoaderPath: string;
+    apply(compiler: T): void;
+    afterPlugins: (compiler: Plugin.BaseCompiler) => void;
+    compilation(compiler: Plugin.BaseCompiler, compilation: Plugin.BaseCompilation): void;
+    getInterceptRules(compiler: Plugin.BaseCompiler, rules: RuleSetRule[]): RuleSetRule[];
+}

package/dist/inner-plugins/plugins/plugins.d.ts

@@ -1,8 +1,8 @@
 import { Plugin } from '@rsdoctor/types';
 import { InternalBasePlugin } from './base';
 export declare class InternalPluginsPlugin<T extends Plugin.BaseCompiler> extends InternalBasePlugin<T> {
-  readonly name = "plugins";
-  apply(compiler: T): void;
-  afterPlugins: (compiler: Plugin.BaseCompiler) => void;
-  compilation: (compilation: Plugin.BaseCompilation) => void;
-}
+    readonly name = "plugins";
+    apply(compiler: T): void;
+    afterPlugins: (compiler: Plugin.BaseCompiler) => void;
+    compilation: (compilation: Plugin.BaseCompilation) => void;
+}

package/dist/inner-plugins/plugins/progress.d.ts

@@ -2,7 +2,7 @@ import { SDK } from '@rsdoctor/types';
 import type { Plugin } from '@rsdoctor/types';
 import { InternalBasePlugin } from './base';
 export declare class InternalProgressPlugin<T extends Plugin.BaseCompiler> extends InternalBasePlugin<T> {
-  readonly name = "progress";
-  protected currentProgress: SDK.ServerAPI.InferResponseType<SDK.ServerAPI.APIExtends.GetCompileProgess>;
-  apply(compiler: T): void;
-}
+    readonly name = "progress";
+    protected currentProgress: SDK.ServerAPI.InferResponseType<SDK.ServerAPI.APIExtends.GetCompileProgess>;
+    apply(compiler: T): void;
+}

package/dist/inner-plugins/plugins/rules.d.ts

@@ -1,8 +1,8 @@
 import { InternalBasePlugin } from '../plugins';
 import { Plugin } from '@rsdoctor/types';
 export declare class InternalRulesPlugin extends InternalBasePlugin<Plugin.BaseCompiler> {
-  readonly name = "rules";
-  apply(compiler: Plugin.BaseCompiler): void;
-  done: (stats: Plugin.BaseStats) => Promise<void>;
-  protected lint(compilation: Plugin.BaseCompilation): Promise<void>;
-}
+    readonly name = "rules";
+    apply(compiler: Plugin.BaseCompiler): void;
+    done: (stats: Plugin.BaseStats) => Promise<void>;
+    protected lint(compilation: Plugin.BaseCompilation): Promise<void>;
+}

package/dist/inner-plugins/plugins/summary.d.ts

@@ -1,14 +1,14 @@
 import type { Plugin } from '@rsdoctor/types';
 import { InternalBasePlugin } from './base';
 export declare class InternalSummaryPlugin<T extends Plugin.BaseCompiler> extends InternalBasePlugin<T> {
-  readonly name = "summary";
-  private times;
-  private preTimes;
-  private postTimes;
-  apply(compiler: T): void;
-  private mark;
-  beforeCompile: () => Promise<void>;
-  afterCompile: (compilation: Plugin.BaseCompilation) => Promise<void>;
-  done: (compiler: T) => Promise<void>;
-  private report;
-}
+    readonly name = "summary";
+    private times;
+    private preTimes;
+    private postTimes;
+    apply(compiler: T): void;
+    private mark;
+    beforeCompile: () => Promise<void>;
+    afterCompile: (compilation: Plugin.BaseCompilation) => Promise<void>;
+    done: (compiler: T) => Promise<void>;
+    private report;
+}

package/dist/inner-plugins/utils/circleDetect.d.ts

@@ -1,4 +1,4 @@
 export declare const checkCirclePath: (obj: any, record: {
-  prop: string;
-  ref: unknown;
-}[], res: string[][], level: number, maxLevel?: number) => void;
+    prop: string;
+    ref: unknown;
+}[], res: string[][], level: number, maxLevel?: number) => void;

package/dist/inner-plugins/utils/config.d.ts

@@ -1,7 +1,7 @@
 import { Linter, Plugin } from '@rsdoctor/types';
 import { RuleSetCondition as RspackRuleSetCondition } from '@rspack/core';
 import { RuleSetCondition, RuleSetConditionAbsolute, RuleSetRule } from 'webpack';
-import { RsdoctorWebpackPluginOptions, RsdoctorPluginOptionsNormalized } from "../../types";
+import { RsdoctorWebpackPluginOptions, RsdoctorPluginOptionsNormalized } from '../../types';
 export declare function normalizeUserConfig<Rules extends Linter.ExtendRuleData[]>(config?: RsdoctorWebpackPluginOptions<Rules>): RsdoctorPluginOptionsNormalized<Rules>;
 export declare function makeRuleSetSerializable(item: RuleSetConditionAbsolute | RuleSetCondition | RspackRuleSetCondition | void): void;
-export declare function makeRulesSerializable(rules: Plugin.RuleSetRule[] | RuleSetRule['oneOf']): void;
+export declare function makeRulesSerializable(rules: Plugin.RuleSetRule[] | RuleSetRule['oneOf']): void;

package/dist/inner-plugins/utils/index.d.ts

@@ -2,4 +2,4 @@ export * from './loader';
 export * from './plugin';
 export * from './sdk';
 export * from './config';
-export * from './circleDetect';
+export * from './circleDetect';

package/dist/inner-plugins/utils/loader.d.ts

@@ -1,11 +1,11 @@
 /// <reference types="lodash" />
 /// <reference types="node" />
 import { SDK, Plugin } from '@rsdoctor/types';
-import { ProxyLoaderInternalOptions, ProxyLoaderOptions } from "../../types";
-import { Utils as BuildUtils, Types } from "../../build-utils/build";
+import { ProxyLoaderInternalOptions, ProxyLoaderOptions } from '../../types';
+import { Utils as BuildUtils, Types } from '../../build-utils/build';
 export declare function getInternalLoaderOptions(loaderContext: Plugin.LoaderContext<ProxyLoaderOptions>): ProxyLoaderInternalOptions;
 export declare function getLoaderOptionsWithoutInternalKeys(loaderContext: Plugin.LoaderContext<ProxyLoaderOptions>): import("lodash").Omit<ProxyLoaderOptions, "__l__">;
 export declare function getOriginLoaderModule(loaderContext: Plugin.LoaderContext<ProxyLoaderOptions>): ReturnType<typeof BuildUtils.loadLoaderModule>;
 export declare function shouldSkipLoader(loaderContext: Plugin.LoaderContext<ProxyLoaderOptions>): boolean;
 export declare function interceptLoader<T extends Plugin.BuildRuleSetRule>(rules: T[], loaderPath: string, options: Omit<ProxyLoaderInternalOptions, 'loader' | 'hasOptions'>, cwd?: string, resolveLoader?: Plugin.Configuration['resolve']): T[];
-export declare function reportLoader(ctx: Plugin.LoaderContext<ProxyLoaderOptions>, start: number, startHRTime: [number, number], isPitch: boolean, sync: boolean, code: string, err: Error | null | undefined, res: string | Buffer | null, sourceMap?: Types.SourceMapInput): Promise<SDK.LoaderData>;
+export declare function reportLoader(ctx: Plugin.LoaderContext<ProxyLoaderOptions>, start: number, startHRTime: [number, number], isPitch: boolean, sync: boolean, code: string, err: Error | null | undefined, res: string | Buffer | null, sourceMap?: Types.SourceMapInput): Promise<SDK.LoaderData>;

package/dist/inner-plugins/utils/plugin.d.ts

@@ -2,4 +2,4 @@ import type { Hook } from 'tapable';
 import type { SDK } from '@rsdoctor/types';
 import type { RsdoctorWebpackSDK } from '@rsdoctor/sdk';
 export declare function reportPluginData(sdk: RsdoctorWebpackSDK, hook: string, tapName: string, start: number, type: SDK.PluginHookData['type'], _res: unknown, err?: Error): void;
-export declare function interceptPluginHook(sdk: RsdoctorWebpackSDK, name: string, hook: Hook<any, any>): void;
+export declare function interceptPluginHook(sdk: RsdoctorWebpackSDK, name: string, hook: Hook<any, any>): void;

package/dist/inner-plugins/utils/sdk.d.ts

@@ -1,3 +1,3 @@
 import { RsdoctorWebpackSDK } from '@rsdoctor/sdk';
 export declare function setSDK(t: RsdoctorWebpackSDK): void;
-export declare function getSDK(): RsdoctorWebpackSDK;
+export declare function getSDK(): RsdoctorWebpackSDK;

package/dist/rules/index.d.ts

@@ -1,3 +1,3 @@
 export * from './linter';
 export * from './rule';
-export { rules } from './rules';
+export { rules } from './rules';

package/dist/rules/linter.d.ts

@@ -1,13 +1,9 @@
 import { Linter as LinterType, SDK } from '@rsdoctor/types';
 export { LinterType };
 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>;
-}
+    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>;
+}

package/dist/rules/rule.d.ts

@@ -2,30 +2,26 @@ import { Linter, SDK, Rule as RuleTypes } from '@rsdoctor/types';
 import { LinterType } from './linter';
 type DefaultRuleConfig = Linter.DefaultRuleConfig;
 export declare class Rule<Config = DefaultRuleConfig> implements Linter.RuleMeta<Config> {
-  static from<C>(data: Linter.ExtendRuleData<C>): Rule<C>;
-  readonly meta: Linter.RuleMeta<Config>;
-  private check;
-  /**
-   * execute when check end
-   */
-  private onCheckEnd;
-  private _severity;
-  private _config?;
-  constructor(data: Linter.RuleData<Config>);
-  get code(): RuleTypes.RuleMessageCode;
-  get title(): string;
-  get severity(): Linter.Severity;
-  get config(): Config | undefined;
-  get category(): "bundle" | RuleTypes.RuleMessageCategory | "compile" | "emo";
-  setOption(opt: Linter.RuleConfigItem): void;
-  match(level: Linter.Severity): boolean;
-  validate(context: SDK.RuntimeContext): Promise<Linter.ValidateResult>;
-  afterValidate({
-    hooks,
-    validateResult,
-    data
-  }: LinterType.InternalRuleCheckerContextForCheckEnd<Config>): Promise<void>;
+    static from<C>(data: Linter.ExtendRuleData<C>): Rule<C>;
+    readonly meta: Linter.RuleMeta<Config>;
+    private check;
+    /**
+     * execute when check end
+     */
+    private onCheckEnd;
+    private _severity;
+    private _config?;
+    constructor(data: Linter.RuleData<Config>);
+    get code(): RuleTypes.RuleMessageCode;
+    get title(): string;
+    get severity(): Linter.Severity;
+    get config(): Config | undefined;
+    get category(): "bundle" | RuleTypes.RuleMessageCategory | "compile" | "emo";
+    setOption(opt: Linter.RuleConfigItem): void;
+    match(level: Linter.Severity): boolean;
+    validate(context: SDK.RuntimeContext): Promise<Linter.ValidateResult>;
+    afterValidate({ hooks, validateResult, data, }: LinterType.InternalRuleCheckerContextForCheckEnd<Config>): Promise<void>;
 }
 export declare function defineRule<Title extends Linter.DefaultRuleTitle, T = Linter.DefaultRuleConfig>(ruleCreator: Linter.ExtendRuleConstructor<Title, T>): Linter.ExtendRuleData<T, Title>;
 export declare function defineRule<Title extends Linter.DefaultRuleTitle, T = Linter.DefaultRuleConfig>(ruleCreator: Linter.RuleConstructor<Title, T>): Linter.RuleData<T, Title>;
-export {};
+export {};

package/dist/rules/rules/default-import-check/index.d.ts

@@ -1,4 +1,4 @@
 import { Linter } from '@rsdoctor/types';
 import type { Config } from './types';
 export type { Config } from './types';
-export declare const rule: Linter.RuleData<Config, "default-import-check">;
+export declare const rule: Linter.RuleData<Config, "default-import-check">;

package/dist/rules/rules/default-import-check/types.d.ts

@@ -1,4 +1,4 @@
 export interface Config {
-  /** Packages that need to be ignored */
-  ignore: string[];
-}
+    /** Packages that need to be ignored */
+    ignore: string[];
+}

package/dist/rules/rules/default-import-check/utils.d.ts

@@ -7,4 +7,4 @@ export declare function getDefaultImportByRequest(node: Node.Program, request: s
 export declare function hasSameLeftInAssignStatement(node: Node.Program, compare: Node.SyntaxNode[]): Node.Pattern | undefined;
 export declare function importDeclarationToString(node: Node.ImportDeclaration): string;
 export declare function getFixData(module: SDK.ModuleInstance, node: Node.ImportDeclaration, originalRange: Range): Linter.FixData;
-export declare function getSourceRangeFromTransformedOffset(module: SDK.ModuleInstance, node: Node.SyntaxNode): Linter.ReportDocument | undefined;
+export declare function getSourceRangeFromTransformedOffset(module: SDK.ModuleInstance, node: Node.SyntaxNode): Linter.ReportDocument | undefined;

package/dist/rules/rules/duplicate-package/index.d.ts

@@ -1,4 +1,4 @@
 import { Linter } from '@rsdoctor/types';
 import { Config } from './types';
 export type { Config, CheckVersion } from './types';
-export declare const rule: Linter.RuleData<Config, "duplicate-package">;
+export declare const rule: Linter.RuleData<Config, "duplicate-package">;

package/dist/rules/rules/duplicate-package/types.d.ts

@@ -1,24 +1,24 @@
 export declare enum CheckVersion {
-  null = 0,
-  prerelease = 1,
-  prepatch = 16,
-  patch = 256,
-  preminor = 4096,
-  minor = 65536,
-  premajor = 1048576,
-  major = 16777216,
+    null = 0,
+    prerelease = 1,
+    prepatch = 16,
+    patch = 256,
+    preminor = 4096,
+    minor = 65536,
+    premajor = 1048576,
+    major = 16777216
 }
 export declare enum CheckVersionMap {
-  null = 0,
-  prerelease = 1,
-  prepatch = 17,
-  patch = 273,
-  preminor = 4369,
-  minor = 69905,
-  premajor = 1118481,
-  major = 17895697,
+    null = 0,
+    prerelease = 1,
+    prepatch = 17,
+    patch = 273,
+    preminor = 4369,
+    minor = 69905,
+    premajor = 1118481,
+    major = 17895697
 }
 export interface Config {
-  checkVersion: keyof typeof CheckVersion;
-  ignore: string[];
-}
+    checkVersion: keyof typeof CheckVersion;
+    ignore: string[];
+}

package/dist/rules/rules/duplicate-package/utils.d.ts

@@ -1,3 +1,3 @@
 import type { SDK, Rule } from '@rsdoctor/types';
 export declare function getErrorMsg(packages: SDK.PackageInstance[], root: string): string;
-export declare function getErrorDetail(pkg: SDK.PackageInstance, pkgGraph: SDK.PackageGraphInstance): Rule.PackageRelationData;
+export declare function getErrorDetail(pkg: SDK.PackageInstance, pkgGraph: SDK.PackageGraphInstance): Rule.PackageRelationData;

package/dist/rules/rules/ecma-version-check/index.d.ts

@@ -1,4 +1,4 @@
 import { Config } from './types';
 import { Linter } from '@rsdoctor/types';
 export type { Config } from './types';
-export declare const rule: Linter.RuleData<Config, "ecma-version-check">;
+export declare const rule: Linter.RuleData<Config, "ecma-version-check">;

package/dist/rules/rules/ecma-version-check/types.d.ts

@@ -1,7 +1,7 @@
 import type { ECMAVersion } from '@rsdoctor/utils/ruleUtils';
 export interface Config {
-  /** Check the ecma version */
-  highestVersion: ECMAVersion;
-  /** Js files that need to be ignored */
-  ignore: string[];
-}
+    /** Check the ecma version */
+    highestVersion: ECMAVersion;
+    /** Js files that need to be ignored */
+    ignore: string[];
+}

package/dist/rules/rules/ecma-version-check/utils.d.ts

@@ -1,2 +1,2 @@
 import type { ECMAVersion } from '@rsdoctor/utils/ruleUtils';
-export declare function getVersionNumber(ECMAString: ECMAVersion): number | undefined;
+export declare function getVersionNumber(ECMAString: ECMAVersion): number | undefined;

package/dist/rules/rules/index.d.ts

@@ -1 +1 @@
-export declare const rules: (import("@rsdoctor/types/dist/linter").RuleData<import("./duplicate-package").Config, "duplicate-package"> | import("@rsdoctor/types/dist/linter").RuleData<import("./default-import-check").Config, "default-import-check"> | import("@rsdoctor/types/dist/linter").RuleData<import("./loader-performance-optimization").Config, "loader-performance-optimization"> | import("@rsdoctor/types/dist/linter").RuleData<import("./ecma-version-check").Config, "ecma-version-check">)[];
+export declare const rules: (import("@rsdoctor/types/dist/linter").RuleData<import("./duplicate-package").Config, "duplicate-package"> | import("@rsdoctor/types/dist/linter").RuleData<import("./default-import-check").Config, "default-import-check"> | import("@rsdoctor/types/dist/linter").RuleData<import("./loader-performance-optimization").Config, "loader-performance-optimization"> | import("@rsdoctor/types/dist/linter").RuleData<import("./ecma-version-check").Config, "ecma-version-check">)[];

package/dist/rules/rules/loader-performance-optimization/index.d.ts

@@ -1,4 +1,4 @@
 import { Linter } from '@rsdoctor/types';
 import { Config } from './types';
 export type { Config } from './types';
-export declare const rule: Linter.RuleData<Config, "loader-performance-optimization">;
+export declare const rule: Linter.RuleData<Config, "loader-performance-optimization">;

package/dist/rules/rules/loader-performance-optimization/types.d.ts

@@ -1,22 +1,22 @@
 import type { SDK } from '@rsdoctor/types';
 export interface Config {
-  /**
-   * loaders which should be ignore.
-   */
-  ignore: (string | RegExp)[];
-  /**
-   * threshold which the loader total costs.
-   * @unit millisecond
-   * @default 5000
-   */
-  threshold: number;
-  /**
-   * the file extensions which will be match in rule check.
-   * @default ["js", "css", "jpg", "jpeg", "png", "gif", "webp", "svg"]
-   */
-  extensions: (string | RegExp)[];
+    /**
+     * loaders which should be ignore.
+     */
+    ignore: (string | RegExp)[];
+    /**
+     * threshold which the loader total costs.
+     * @unit millisecond
+     * @default 5000
+     */
+    threshold: number;
+    /**
+     * the file extensions which will be match in rule check.
+     * @default ["js", "css", "jpg", "jpeg", "png", "gif", "webp", "svg"]
+     */
+    extensions: (string | RegExp)[];
 }
 export interface LoaderMapValue extends SDK.LoaderTransformData {
-  __resource__: SDK.ResourceData;
-  __costs__: number;
-}
+    __resource__: SDK.ResourceData;
+    __costs__: number;
+}

package/dist/rules/rules/loader-performance-optimization/utils.d.ts

@@ -1 +1 @@
-export declare function match(str: string, partterns: (string | RegExp)[]): boolean;
+export declare function match(str: string, partterns: (string | RegExp)[]): boolean;

package/dist/rules/utils.d.ts

@@ -1,3 +1,3 @@
 import { Linter } from '@rsdoctor/types';
 export declare function toSeverity(input: Linter.SeverityInput, defaultLevel: Linter.Severity): Linter.Severity;
-export declare function noop(): void;
+export declare function noop(): void;

package/dist/types/chunks.d.ts

@@ -1,11 +1,11 @@
 import { Plugin } from '@rsdoctor/types';
 export type AssetsModules = {
-  label?: string;
-  isAsset?: boolean;
-  modules?: Plugin.StatsModule[];
+    label?: string;
+    isAsset?: boolean;
+    modules?: Plugin.StatsModule[];
 };
 export type ParseBundle = (assetFile: string, modules: Plugin.StatsModule[]) => {
-  modules?: Record<string, any>;
-  src?: string;
-  runtimeSrc?: string;
-};
+    modules?: Record<string, any>;
+    src?: string;
+    runtimeSrc?: string;
+};

package/dist/types/index.d.ts

@@ -2,4 +2,4 @@ export * from './chunks';
 export * from './rules';
 export * from './webpack';
 export * from './loader';
-export * from './plugin';
+export * from './plugin';

package/dist/types/loader.d.ts

@@ -1,19 +1,19 @@
 import { Loader } from '@rsdoctor/utils/common';
 export interface ProxyLoaderInternalOptions {
-  cwd: string;
-  /**
-   * the url host of http server(which used to collect data).
-   */
-  host: string;
-  /**
-   * correct loader path.
-   */
-  loader: string;
-  /** include the loader option */
-  hasOptions: boolean;
-  skipLoaders: string[];
+    cwd: string;
+    /**
+     * the url host of http server(which used to collect data).
+     */
+    host: string;
+    /**
+     * correct loader path.
+     */
+    loader: string;
+    /** include the loader option */
+    hasOptions: boolean;
+    skipLoaders: string[];
 }
 export interface ProxyLoaderOptions {
-  [key: string]: any;
-  [Loader.LoaderInternalPropertyName]: ProxyLoaderInternalOptions;
-}
+    [key: string]: any;
+    [Loader.LoaderInternalPropertyName]: ProxyLoaderInternalOptions;
+}