@rsdoctor/types 1.5.8 → 1.5.10

package/dist/babel.d.cts

@@ -0,0 +1,13 @@
+/** Babel Error */
+export interface Error {
+    code: string;
+    reasonCode: string;
+    message: string;
+    name: string;
+    stack: string;
+    pos?: number;
+    loc?: {
+        line: number;
+        column: number;
+    };
+}

package/dist/client.d.cts

@@ -0,0 +1,164 @@
+import type { ModuleSize } from './sdk/module';
+export declare enum RsdoctorClientUrlQuery {
+    BundleDiffFiles = "__bundle_files__",
+    ManifestFile = "manifest",
+    EnableRoutes = "enableRoutes"
+}
+export declare enum RsdoctorClientRoutes {
+    Home = "/",
+    Overall = "/overall",
+    WebpackLoaderOverall = "/webpack/loaders/overall",
+    WebpackLoaderAnalysis = "/webpack/loaders/analysis",
+    ModuleResolve = "/module/resolve",
+    WebpackPlugins = "/webpack/plugins",
+    BundleSize = "/bundle/size",
+    ModuleAnalyze = "/module/analyze",
+    TreeShaking = "/treeshaking",
+    BundleDiff = "/resources/bundle/diff",
+    RuleIndex = "/resources/rules",
+    Uploader = "/resources/uploader",
+    EmoCheck = "/emo/check"
+}
+export declare enum RsdoctorClientDiffState {
+    Equal = "-",
+    Up = "UP",
+    Down = "DOWN"
+}
+export interface RsdoctorClientAssetsDiffItem {
+    size: {
+        baseline: number;
+        current: number;
+    };
+    count: {
+        baseline: number;
+        current: number;
+    };
+    percent: number;
+    state: RsdoctorClientDiffState;
+}
+export interface RsdoctorClientAssetsDiffResult {
+    all: {
+        total: RsdoctorClientAssetsDiffItem;
+    };
+    js: {
+        total: RsdoctorClientAssetsDiffItem;
+        initial: RsdoctorClientAssetsDiffItem;
+    };
+    css: {
+        total: RsdoctorClientAssetsDiffItem;
+        initial: RsdoctorClientAssetsDiffItem;
+    };
+    imgs: {
+        total: RsdoctorClientAssetsDiffItem;
+    };
+    html: {
+        total: RsdoctorClientAssetsDiffItem;
+    };
+    media: {
+        total: RsdoctorClientAssetsDiffItem;
+    };
+    fonts: {
+        total: RsdoctorClientAssetsDiffItem;
+    };
+    /**
+     * files exclude these extensions above
+     */
+    others: {
+        total: RsdoctorClientAssetsDiffItem;
+    };
+}
+interface AssetInfo {
+    size: number;
+    count: number;
+    files: {
+        path: string;
+        size: number;
+        initial: boolean;
+        content: string | void;
+    }[];
+}
+export interface RsdoctorClientAssetsSummary {
+    all: {
+        total: AssetInfo;
+    };
+    js: {
+        total: AssetInfo;
+        initial: AssetInfo;
+    };
+    css: {
+        total: AssetInfo;
+        initial: AssetInfo;
+    };
+    imgs: {
+        total: AssetInfo;
+    };
+    html: {
+        total: AssetInfo;
+    };
+    media: {
+        total: AssetInfo;
+    };
+    fonts: {
+        total: AssetInfo;
+    };
+    /**
+     * files exclude these extensions above
+     */
+    others: {
+        total: AssetInfo;
+    };
+}
+export interface RsdoctorClientModuleDiffItem {
+    path: string;
+    size: {
+        baseline: ModuleSize;
+        current: ModuleSize;
+    };
+    /** Percent change based on parsedSize */
+    percent: number;
+    state: RsdoctorClientDiffState;
+}
+export interface RsdoctorClientModulesDiffResult {
+    added: Array<{
+        path: string;
+        size: ModuleSize;
+    }>;
+    removed: Array<{
+        path: string;
+        size: ModuleSize;
+    }>;
+    changed: RsdoctorClientModuleDiffItem[];
+}
+export interface RsdoctorClientPackageDiffItem {
+    name: string;
+    version: string;
+    root: string;
+    size: {
+        baseline: ModuleSize;
+        current: ModuleSize;
+    };
+    /** Percent change based on parsedSize */
+    percent: number;
+    state: RsdoctorClientDiffState;
+}
+export interface RsdoctorClientPackagesDiffResult {
+    added: Array<{
+        name: string;
+        version: string;
+        root: string;
+        size: ModuleSize;
+    }>;
+    removed: Array<{
+        name: string;
+        version: string;
+        root: string;
+        size: ModuleSize;
+    }>;
+    changed: RsdoctorClientPackageDiffItem[];
+}
+export interface RsdoctorClientBundleDiffResult {
+    assets: RsdoctorClientAssetsDiffResult;
+    modules: RsdoctorClientModulesDiffResult;
+    packages: RsdoctorClientPackagesDiffResult;
+}
+export {};

package/dist/common.d.cts

@@ -0,0 +1,26 @@
+export type NonFunctionPropertyNames<T> = {
+    [K in keyof T]: T[K] extends Function ? never : K;
+}[keyof T];
+export type NonFunctionProperties<T> = Pick<T, NonFunctionPropertyNames<T>>;
+export type PlainObject<T = any> = {
+    [key: string]: T;
+};
+export type PromiseReturnType<T> = T extends (...args: any[]) => Promise<infer P> ? P : T;
+export type DeepRequired<T> = T extends PlainObject ? {
+    [K in keyof T]-?: DeepRequired<T[K]>;
+} : T;
+export type OrPromise<T> = T | Promise<T>;
+export type Constructor<T> = T extends abstract new (...args: infer P1) => infer R1 ? new (...args: P1) => R1 : T extends new (...args: infer P2) => infer R2 ? new (...args: P2) => R2 : never;
+export type Function<P extends any[] = any[], R = any> = (...args: P) => R;
+export type FunctionPropertyNames<T> = {
+    [K in keyof T]: T[K] extends Function ? K : never;
+}[keyof T];
+export type Get<T, K, F = never> = K extends keyof T ? T[K] : F;
+export type ObjectPropertyNames<T> = {
+    [K in keyof T]: T[K] extends PlainObject ? K : never;
+}[keyof T];
+export type ArrayToUnion<T extends any[]> = T[number];
+export type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+export type LastOf<T> = UnionToIntersection<T extends any ? () => T : never> extends () => infer R ? R : never;
+export type Push<T extends any[], V> = [...T, V];
+export type UnionToTuple<T, L = LastOf<T>, N = [T] extends [never] ? true : false> = true extends N ? [] : Push<UnionToTuple<Exclude<T, L>>, L>;

package/dist/config.d.cts

@@ -0,0 +1,75 @@
+export interface BriefConfig {
+    reportHtmlName?: string;
+    writeDataJson: boolean;
+}
+/**
+ * @deprecated This type is deprecated and will be removed in a future version.
+ * Use {@link NewReportCodeType} instead for better type safety and consistency.
+ */
+export type IReportCodeType = {
+    noModuleSource?: boolean;
+    noAssetsAndModuleSource?: boolean;
+    noCode?: boolean;
+};
+export interface NormalModeOptions {
+    type?: never;
+}
+interface JsonSectionOptions {
+    /**
+     * @default: true
+     * */
+    moduleGraph?: boolean;
+    /**
+     * @default: true
+     * */
+    chunkGraph?: boolean;
+    /**
+     * @default: true
+     * */
+    rules?: boolean;
+}
+export interface JsonOptions {
+    fileName?: string;
+    sections?: JsonSectionOptions;
+}
+export interface BriefModeOptions {
+    /** Output type, supports HTML and JSON */
+    type?: Array<'html' | 'json'>;
+    /** HTML output related configuration */
+    htmlOptions?: BriefConfig;
+    /** JSON output related configuration */
+    jsonOptions?: JsonOptions;
+}
+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 interface BriefModeConfig extends Omit<OutputBaseConfig, 'reportCodeType' | 'mode'> {
+    mode?: 'brief';
+    reportCodeType?: ReportCodeTypeByMode<'brief'>;
+    options?: BriefModeOptions;
+}
+interface NormalModeConfig extends Omit<OutputBaseConfig, 'reportCodeType' | 'mode'> {
+    mode?: 'normal';
+    reportCodeType?: ReportCodeTypeByMode<'normal'>;
+    options?: NormalModeOptions;
+}
+type ReportCodeTypeByMode<T extends 'brief' | 'normal'> = T extends 'brief' ? undefined | 'noCode' | {
+    noCode?: boolean;
+} : T extends 'normal' ? IReportCodeType | undefined | NewReportCodeType : IReportCodeType | undefined | NewReportCodeType;
+export type IOutput<T extends 'brief' | 'normal'> = T extends 'brief' ? BriefModeConfig : T extends 'normal' ? NormalModeConfig : BriefModeConfig | NormalModeConfig | OutputBaseConfig;
+export type NewReportCodeType = 'noModuleSource' | 'noAssetsAndModuleSource' | 'noCode';
+export {};

package/dist/constants.d.cts

@@ -0,0 +1,19 @@
+export declare const JSExtension = ".js";
+export declare const BundleExtension = ".bundle";
+export declare const JSExtensions: string[];
+export declare const CSSExtension = ".css";
+export declare const HtmlExtension = ".html";
+export declare const ImgExtensions: string[];
+export declare const MediaExtensions: string[];
+export declare const FontExtensions: string[];
+export declare const MapExtensions: string[];
+export declare const RsdoctorOutputFolder = ".rsdoctor";
+export declare const RsdoctorOutputManifest = "manifest.json";
+export declare const RsdoctorOutputManifestPath: ".rsdoctor/manifest.json";
+export declare const StatsFilePath = "dist/stats.json";
+export declare const RsdoctorMonitorNodeBId = "Rsdoctor";
+export declare const RsdoctorMonitorWebBId = "Rsdoctor-Client";
+export declare const RsdoctorMonitorDocBId = "Rsdoctor-Doc";
+export declare const RsdoctorProcessEnvDebugKey = "rsdoctor";
+export declare const RsdoctorClientUrl = "";
+export declare const WINDOW_RSDOCTOR_TAG = "__RSDOCTOR__";

package/dist/emo.d.cts

@@ -0,0 +1,28 @@
+export type WorkspaceCheckDataType = {
+    message: string;
+    type: 'issues' | 'message' | 'code';
+    title: string;
+    severity?: EmoCheckSeverity;
+    result?: {
+        package: string;
+        data: Record<string, string | string[]>[];
+        tag?: string;
+    } | {
+        path: string;
+        line?: number;
+        column?: number;
+    }[] | Record<string, {
+        version: string;
+        pkgname: string;
+    }>;
+    issues?: string[];
+};
+export type EmoCheckData = {
+    projectInfo: Record<string, string | Object>;
+    workspaceRes: Record<string, WorkspaceCheckDataType[]>;
+};
+export declare enum EmoCheckSeverity {
+    Error = 0,
+    Warn = 1,
+    Info = 2
+}

package/dist/error.d.cts

@@ -0,0 +1,137 @@
+import type { NonFunctionProperties } from './common';
+import type { BaseRuleStoreData } from './rule';
+/**
+ * Position
+ *   - `line` start with `1`
+ *   - `column` start with `0`
+ */
+export interface Position {
+    line: number;
+    column: number;
+}
+/** Range of Position */
+export interface Range {
+    start: Position;
+    end: Position;
+}
+/** Offset range  */
+export interface OffsetRange {
+    start: number;
+    end: number;
+}
+/** Error Level */
+export declare enum ErrorLevel {
+    Ignore = 0,
+    Warn = 1,
+    Error = 2
+}
+/** Code prompt location */
+export interface CodeFramePosition {
+    line: number;
+    column?: number;
+}
+/** File options where the code is located */
+export interface CodeFrameFileOption {
+    filePath: string;
+}
+/** Code indication options */
+export interface CodeFrameNormalOption {
+    filePath: string;
+    fileContent: string;
+    start?: CodeFramePosition;
+    end?: CodeFramePosition;
+}
+/**
+ * Code indication options
+ *   - This type is mainly for compatibility with esbuild.
+ */
+export interface CodeFrameLineOption {
+    /** File path */
+    filePath: string;
+    /** Error line text */
+    lineText: string;
+    /** Starting point */
+    start?: CodeFramePosition;
+    /** Error character length */
+    length?: number;
+}
+export type CodeFrameOption = CodeFrameFileOption | CodeFrameNormalOption | CodeFrameLineOption;
+/** Control item */
+export interface ControllerOption {
+    /**
+     * Hide stack information
+     *   - default is `true`
+     */
+    noStack?: boolean;
+    /**
+     * Do not display colors
+     *   - default is `false`
+     */
+    noColor?: boolean;
+}
+/** repair data */
+export interface FixData {
+    /** Modify the starting position of string in the original text. */
+    start: number;
+    /** Modify the ending position of string in the original text */
+    end: number;
+    /**
+     * Replaced new text
+     *   - If empty, delete the original text.
+     */
+    newText?: string;
+    /** Has it been fixed */
+    isFixed?: boolean;
+}
+/** Error Data */
+export interface DevToolErrorData {
+    /** Error number */
+    id: number;
+    /** Error code */
+    code?: string;
+    /** Error category */
+    category?: string;
+    title: string;
+    message: string;
+    stack?: string;
+    fixData?: FixData;
+    detail?: any;
+    /** Absolute path where the error is located. */
+    path?: string;
+    /**
+     * Error level
+     *   - default is `'Error'`
+     */
+    level?: keyof typeof ErrorLevel;
+    /** Error prompt */
+    hint?: string;
+    /** Description link */
+    referenceUrl?: string;
+    codeFrame?: CodeFrameOption;
+}
+/**  Error data */
+export interface DevToolErrorInstance extends DevToolErrorData {
+    /** Output stored data */
+    toData(): BaseRuleStoreData;
+    toString(): string;
+    toJSON(): {
+        message: string;
+        name: string;
+        stack?: string;
+    };
+    /** Set control items */
+    setControllerOption(opt: ControllerOption): void;
+    /** Set code instructions */
+    setCodeFrame(opt: CodeFrameOption): void;
+    /** Is the error the same */
+    isSame<T extends DevToolErrorInstance>(error: T): boolean;
+}
+export interface DevToolErrorsData {
+    errors: DevToolErrorInstance[];
+    warnings: DevToolErrorInstance[];
+}
+/** Incorrect data input */
+export type DevToolErrorParams = Omit<NonFunctionProperties<DevToolErrorInstance>, 'message' | 'title' | 'path' | 'id'> & {
+    controller?: ControllerOption;
+    codeFrame?: CodeFrameOption;
+};

package/dist/esbuild.d.cts

@@ -0,0 +1,30 @@
+/** Esbuild Error */
+export interface Error {
+    id: string;
+    pluginName: string;
+    text: string;
+    location: Location | null;
+    notes: Note[];
+    /**
+     * Optional user-specified data that is passed through unmodified. You can
+     * use this to stash the original error, for example.
+     */
+    detail: any;
+}
+interface Note {
+    text: string;
+    location: Location | null;
+}
+interface Location {
+    file: string;
+    namespace: string;
+    /** 1-based */
+    line: number;
+    /** 0-based, in bytes */
+    column: number;
+    /** in bytes */
+    length: number;
+    lineText: string;
+    suggestion: string;
+}
+export {};

package/dist/index.d.cts

@@ -0,0 +1,15 @@
+export * as Manifest from './manifest';
+export * as Esbuild from './esbuild';
+export * as Babel from './babel';
+export * as Common from './common';
+export * as Err from './error';
+export * as Logger from './logger';
+export * as SDK from './sdk';
+export * as Modules from './modules';
+export * as Linter from './linter';
+export * as Rule from './rule';
+export * as Thirdparty from './thirdparty';
+export * as Client from './client';
+export * as Constants from './constants';
+export * as Plugin from './plugin';
+export * as Config from './config';

package/dist/linter/diagnostic.d.cts

@@ -0,0 +1,48 @@
+import { RuleMessage, BaseRuleStoreData, RuleStoreDataItem } from '../rule';
+import { ErrorLevel as Severity, Range, FixData } from '../error';
+import { SeverityString } from './rule';
+export { ErrorLevel as Severity } from '../error';
+export type { Range, OffsetRange, Position, FixData } from '../error';
+/** Diagnostic recommendations */
+export interface Suggestion {
+    description: string;
+    fixData?: FixData;
+}
+/** Error file information */
+export interface ReportDocument {
+    /** file path */
+    path: string;
+    /**  Is it a transformed code */
+    isTransformed?: boolean;
+    /** code content */
+    content: string;
+    range: Range;
+}
+/** Report erroneous data */
+export interface ReportData {
+    /** Error message */
+    message: string;
+    /** Modify severity dynamically at runtime */
+    severity?: SeverityString;
+    /** Error file information  */
+    document?: ReportDocument;
+    /** Diagnostic suggestions */
+    suggestions?: Suggestion;
+    /**
+     * Detailed information
+     *   - Mainly additional data provided to the platform.
+     */
+    detail?: any;
+}
+export type ReportDetailData<T extends BaseRuleStoreData> = Omit<T, keyof BaseRuleStoreData> & {
+    /**
+     * Error text
+     * - When this is present, Diagnostic ['message'] will be overwritten
+     */
+    description?: string;
+};
+export interface Diagnostic extends Omit<ReportData, 'severity'>, Pick<RuleMessage, 'category' | 'code'> {
+    severity: Severity;
+    title: string;
+    detail?: RuleStoreDataItem;
+}

package/dist/linter/index.d.cts

@@ -0,0 +1,2 @@
+export * from './diagnostic';
+export * from './rule';

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;