@rsdoctor/core 2.0.0-alpha.0 → 2.0.0-alpha.2

package/dist/rule-utils/parser/parser.d.ts

@@ -0,0 +1,118 @@
+import { Parser as AcornParser, Options, Position } from 'acorn';
+import * as walk from 'acorn-walk';
+import * as utils from './utils.js';
+import type { Node } from './types.js';
+export type { Options as ParseOptions } from 'acorn';
+export interface ParseError extends Error {
+    loc?: Position;
+    pos: number;
+    raisedAt: number;
+}
+export declare const parser: {
+    /** AST iterator */
+    walk: typeof walk;
+    /**
+     * Compile code
+     * - Output root node is `Node.Program`
+     */
+    parse: (input: string, options: Options) => Node.Program;
+    /**
+     * Compile the next first expression
+     * - The output root node is `Node.ExpressionStatement`
+     */
+    parseExpressionAt: (input: string, pos: number, options: Options) => Node.ExpressionStatement;
+    /**
+     * add plugins for acorn
+     */
+    extend(...args: Parameters<typeof AcornParser.extend>): typeof AcornParser;
+    /** Set of assertions */
+    asserts: {
+        readonly isProgram: (node: unknown) => node is Node.Program;
+        readonly isEmptyStatement: (node: unknown) => node is Node.EmptyStatement;
+        readonly isBlockStatement: (node: unknown) => node is Node.BlockStatement;
+        readonly isStaticBlock: (node: unknown) => node is Node.StaticBlock;
+        readonly isExpressionStatement: (node: unknown) => node is Node.ExpressionStatement;
+        readonly isIfStatement: (node: unknown) => node is Node.IfStatement;
+        readonly isLabeledStatement: (node: unknown) => node is Node.LabeledStatement;
+        readonly isBreakStatement: (node: unknown) => node is Node.BreakStatement;
+        readonly isContinueStatement: (node: unknown) => node is Node.ContinueStatement;
+        readonly isWithStatement: (node: unknown) => node is Node.WithStatement;
+        readonly isSwitchStatement: (node: unknown) => node is Node.SwitchStatement;
+        readonly isReturnStatement: (node: unknown) => node is Node.ReturnStatement;
+        readonly isThrowStatement: (node: unknown) => node is Node.ThrowStatement;
+        readonly isTryStatement: (node: unknown) => node is Node.TryStatement;
+        readonly isWhileStatement: (node: unknown) => node is Node.WhileStatement;
+        readonly isDoWhileStatement: (node: unknown) => node is Node.DoWhileStatement;
+        readonly isForStatement: (node: unknown) => node is Node.ForStatement;
+        readonly isForInStatement: (node: unknown) => node is Node.ForInStatement;
+        readonly isForOfStatement: (node: unknown) => node is Node.ForOfStatement;
+        readonly isDebuggerStatement: (node: unknown) => node is Node.DebuggerStatement;
+        readonly isFunctionDeclaration: (node: unknown) => node is Node.FunctionDeclaration;
+        readonly isVariableDeclaration: (node: unknown) => node is Node.VariableDeclaration;
+        readonly isVariableDeclarator: (node: unknown) => node is Node.VariableDeclarator;
+        readonly isChainExpression: (node: unknown) => node is Node.ChainExpression;
+        readonly isThisExpression: (node: unknown) => node is Node.ThisExpression;
+        readonly isArrayExpression: (node: unknown) => node is Node.ArrayExpression;
+        readonly isObjectExpression: (node: unknown) => node is Node.ObjectExpression;
+        readonly isPrivateIdentifier: (node: unknown) => node is Node.PrivateIdentifier;
+        readonly isProperty: (node: unknown) => node is Node.Property;
+        readonly isPropertyDefinition: (node: unknown) => node is Node.PropertyDefinition;
+        readonly isFunctionExpression: (node: unknown) => node is Node.FunctionExpression;
+        readonly isSequenceExpression: (node: unknown) => node is Node.SequenceExpression;
+        readonly isUnaryExpression: (node: unknown) => node is Node.UnaryExpression;
+        readonly isBinaryExpression: (node: unknown) => node is Node.BinaryExpression;
+        readonly isAssignmentExpression: (node: unknown) => node is Node.AssignmentExpression;
+        readonly isUpdateExpression: (node: unknown) => node is Node.UpdateExpression;
+        readonly isLogicalExpression: (node: unknown) => node is Node.LogicalExpression;
+        readonly isConditionalExpression: (node: unknown) => node is Node.ConditionalExpression;
+        readonly isNewExpression: (node: unknown) => node is Node.NewExpression;
+        readonly isSwitchCase: (node: unknown) => node is Node.SwitchCase;
+        readonly isCatchClause: (node: unknown) => node is Node.CatchClause;
+        readonly isIdentifier: (node: unknown) => node is Node.Identifier;
+        readonly isLiteral: (node: unknown) => node is Node.Literal;
+        readonly isSuper: (node: unknown) => node is Node.Super;
+        readonly isSpreadElement: (node: unknown) => node is Node.SpreadElement;
+        readonly isArrowFunctionExpression: (node: unknown) => node is Node.ArrowFunctionExpression;
+        readonly isYieldExpression: (node: unknown) => node is Node.YieldExpression;
+        readonly isTemplateLiteral: (node: unknown) => node is Node.TemplateLiteral;
+        readonly isTaggedTemplateExpression: (node: unknown) => node is Node.TaggedTemplateExpression;
+        readonly isTemplateElement: (node: unknown) => node is Node.TemplateElement;
+        readonly isObjectPattern: (node: unknown) => node is Node.ObjectPattern;
+        readonly isArrayPattern: (node: unknown) => node is Node.ArrayPattern;
+        readonly isRestElement: (node: unknown) => node is Node.RestElement;
+        readonly isAssignmentPattern: (node: unknown) => node is Node.AssignmentPattern;
+        readonly isClassBody: (node: unknown) => node is Node.ClassBody;
+        readonly isClassDeclaration: (node: unknown) => node is Node.ClassDeclaration;
+        readonly isClassExpression: (node: unknown) => node is Node.ClassExpression;
+        readonly isMetaProperty: (node: unknown) => node is Node.MetaProperty;
+        readonly isImportDeclaration: (node: unknown) => node is Node.ImportDeclaration;
+        readonly isImportSpecifier: (node: unknown) => node is Node.ImportSpecifier;
+        readonly isImportExpression: (node: unknown) => node is Node.ImportExpression;
+        readonly isImportDefaultSpecifier: (node: unknown) => node is Node.ImportDefaultSpecifier;
+        readonly isImportNamespaceSpecifier: (node: unknown) => node is Node.ImportNamespaceSpecifier;
+        readonly isExportNamedDeclaration: (node: unknown) => node is Node.ExportNamedDeclaration;
+        readonly isExportSpecifier: (node: unknown) => node is Node.ExportSpecifier;
+        readonly isExportDefaultDeclaration: (node: unknown) => node is Node.ExportDefaultDeclaration;
+        readonly isExportAllDeclaration: (node: unknown) => node is Node.ExportAllDeclaration;
+        readonly isAwaitExpression: (node: unknown) => node is Node.AwaitExpression;
+        readonly isMethodDefinition: (node: unknown) => node is Node.MethodDefinition;
+        readonly isMemberExpression: (node: unknown) => node is Node.MemberExpression;
+        readonly isComment: (node: unknown) => node is Node.Comment;
+        readonly isDirective: (node: unknown) => node is Node.Directive;
+        readonly isSimpleCallExpression: (node: unknown) => node is Node.SimpleCallExpression;
+        readonly isAssignmentProperty: (node: unknown) => node is Node.AssignmentProperty;
+        readonly isSimpleLiteral: (node: unknown) => node is Node.SimpleLiteral;
+        readonly isRegExpLiteral: (node: unknown) => node is Node.RegExpLiteral;
+        readonly isBigIntLiteral: (node: unknown) => node is Node.BigIntLiteral;
+        readonly isExportStatement: (node: unknown) => node is Node.ExportStatement;
+    };
+    utils: typeof utils;
+    /**
+     * @internal
+     * parser for internal packages
+     */
+    internal: {
+        parse: (input: string, options: Options) => Node.Program;
+        parseExpressionAt: (input: string, pos: number, options: Options) => Node.ExpressionStatement;
+    };
+};

package/dist/rule-utils/parser/types.d.ts

@@ -0,0 +1,30 @@
+import type * as Node from 'estree';
+export type { Node };
+export declare enum ECMAVersion {
+    ES5 = "ES5",
+    ES6 = "ES6",
+    ES7P = "ES7+"
+}
+/**
+ * estree supplement type
+ * Mainly to match the node type of acorn
+ * The main reason for not using the type of acorn directly is that the node type described by acorn itself is too simple
+ */
+declare module 'estree' {
+    interface BaseNode {
+        start: number;
+        end: number;
+        loc?: SourceLocation | undefined;
+    }
+    interface Position {
+        offset: number;
+    }
+    /** all syntax nodes */
+    type SyntaxNode = Node.Comment | Node.Program | Node.Directive | Node.EmptyStatement | Node.BlockStatement | Node.StaticBlock | Node.ExpressionStatement | Node.IfStatement | Node.LabeledStatement | Node.BreakStatement | Node.ContinueStatement | Node.WithStatement | Node.SwitchStatement | Node.ReturnStatement | Node.ThrowStatement | Node.TryStatement | Node.WhileStatement | Node.DoWhileStatement | Node.ForStatement | Node.ForInStatement | Node.DebuggerStatement | Node.FunctionDeclaration | Node.VariableDeclaration | Node.VariableDeclarator | Node.ChainExpression | Node.ThisExpression | Node.ArrayExpression | Node.ObjectExpression | Node.PrivateIdentifier | Node.Property | Node.PropertyDefinition | Node.FunctionExpression | Node.SequenceExpression | Node.UnaryExpression | Node.BinaryExpression | Node.AssignmentExpression | Node.UpdateExpression | Node.LogicalExpression | Node.ConditionalExpression | Node.SimpleCallExpression | Node.NewExpression | Node.MemberExpression | Node.SwitchCase | Node.CatchClause | Node.Identifier | Node.SimpleLiteral | Node.RegExpLiteral | Node.BigIntLiteral | Node.ForOfStatement | Node.Super | Node.SpreadElement | Node.ArrowFunctionExpression | Node.YieldExpression | Node.TemplateLiteral | Node.TaggedTemplateExpression | Node.TemplateElement | Node.AssignmentProperty | Node.ObjectPattern | Node.ArrayPattern | Node.RestElement | Node.AssignmentPattern | Node.ClassBody | Node.MethodDefinition | Node.ClassDeclaration | Node.ClassExpression | Node.MetaProperty | Node.ImportDeclaration | Node.ImportSpecifier | Node.ImportExpression | Node.ImportDefaultSpecifier | Node.ImportNamespaceSpecifier | Node.ExportNamedDeclaration | Node.ExportSpecifier | Node.ExportDefaultDeclaration | Node.ExportAllDeclaration | Node.AwaitExpression;
+    /** all operators */
+    type SyntaxOperator = Node.UnaryOperator | Node.BinaryOperator | Node.LogicalOperator | Node.AssignmentOperator | Node.UpdateOperator;
+    /** Block-scoped statement */
+    type BlockScopeStatement = Node.StaticBlock | Node.BlockStatement | Node.ForInStatement | Node.ForOfStatement | Node.ForStatement | Node.CatchClause | Node.SwitchStatement;
+    /** Export statement */
+    type ExportStatement = Node.ExportAllDeclaration | Node.ExportDefaultDeclaration | Node.ExportNamedDeclaration;
+}

package/dist/rule-utils/parser/utils.d.ts

@@ -0,0 +1,30 @@
+import { ecmaVersion } from 'acorn';
+import { Node, ECMAVersion } from './types.js';
+/**
+ * Is the node semantics the same?
+ * @deprecated
+ * - Recursively compare whether the content of the node itself is the same
+ * - Ignore comments, positions, string symbols (single and double quotation marks)
+ * - String templates and string addition will be considered different
+ */
+export declare function isSameSemantics(node1: Node.SyntaxNode, node2: Node.SyntaxNode): boolean;
+/**
+ * Get all default reference statements
+ */
+export declare function getDefaultImports(node: Node.Program): Node.ImportDeclaration[];
+/** Get the literal in the text. */
+export declare function getIdentifierInPattern(name: string, node: Node.Pattern): Node.Identifier | undefined;
+/** Get the variable declaration statement identifier. */
+export declare function getIdentifierInDeclaration(name: string, node: Node.SyntaxNode): Node.Identifier | undefined;
+/** Get the reference declaration statement identifier. */
+export declare function getIdentifierInImport(name: string, node: Node.SyntaxNode): Node.Identifier | undefined;
+/** Get the export statement identifier. */
+export declare function getIdentifierInExport(name: string, node: Node.SyntaxNode): Node.Identifier | undefined;
+/** Determine that it can be resolved using the specified ECMA version */
+export declare function canParse(code: string, ecmaVersion: ecmaVersion): boolean;
+/** Determine whether it is all ES5 version code. */
+export declare function isES5(code: string): boolean;
+/** Determine whether it is all ES6 version code. */
+export declare function isES6(code: string): boolean;
+/** Detect ECMA version. */
+export declare function detectECMAVersion(code: string): ECMAVersion;

package/dist/rules/linter.d.ts

@@ -1,4 +1,4 @@
-import { Linter as LinterType, SDK } from '@rsdoctor/types';
+import { Linter as LinterType, SDK } from '@rsdoctor/shared/types';
 export { LinterType };
 export declare class Linter<Rules extends LinterType.ExtendRuleData[]> {
     private rules;

package/dist/rules/rule.d.ts

@@ -1,4 +1,4 @@
-import { Linter, SDK, Rule as RuleTypes } from '@rsdoctor/types';
+import { Linter, SDK, Rule as RuleTypes } from '@rsdoctor/shared/types';
 import { LinterType } from './linter.js';
 type DefaultRuleConfig = Linter.DefaultRuleConfig;
 export declare class Rule<Config = DefaultRuleConfig> implements Linter.RuleMeta<Config> {
@@ -16,7 +16,7 @@ export declare class Rule<Config = DefaultRuleConfig> implements Linter.RuleMeta
     get title(): string;
     get severity(): Linter.Severity;
     get config(): Config | undefined;
-    get category(): "compile" | "bundle" | RuleTypes.RuleMessageCategory | "emo";
+    get category(): "bundle" | "compile" | "emo" | RuleTypes.RuleMessageCategory;
     setOption(opt: Linter.RuleConfigItem): void;
     match(level: Linter.Severity): boolean;
     validate(context: SDK.RuntimeContext): Promise<Linter.ValidateResult>;

package/dist/rules/rules/cjs-require/index.d.ts

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

package/dist/rules/rules/cross-chunks-package/index.d.ts

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

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

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

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

@@ -1,5 +1,5 @@
-import { Node, Range } from '@rsdoctor/utils/ruleUtils';
-import type { SDK, Linter } from '@rsdoctor/types';
+import { Node, Range } from '../../../rule-utils/index.js';
+import type { SDK, Linter } from '@rsdoctor/shared/types';
 export declare function getDefaultImportByRequest(node: Node.Program, request: string): Node.ImportDeclaration | undefined;
 /**
  * Determine that it contains the same left value assignment expression in the enumeration.

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

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

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

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

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

@@ -0,0 +1,3 @@
+export declare class Parser {
+    constructor();
+}

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

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

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

@@ -1,3 +1,13 @@
-import type { PluginCheckSyntaxOptions } from '@rsbuild/plugin-check-syntax';
-export interface Config extends PluginCheckSyntaxOptions {
-}
+import type { ecmaVersion as EcmaVersion } from 'acorn';
+type Condition = string | RegExp | ((filepath: string) => boolean);
+type CheckSyntaxExclude = Condition | Condition[];
+type SyntaxErrorKey = 'source' | 'output' | 'reason' | 'code';
+export type Config = {
+    targets?: string[];
+    exclude?: CheckSyntaxExclude;
+    excludeOutput?: CheckSyntaxExclude;
+    excludeErrorMessage?: RegExp | RegExp[];
+    excludeErrorLogs?: SyntaxErrorKey[];
+    ecmaVersion?: EcmaVersion;
+};
+export {};

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

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

package/dist/rules/rules/esm-resolved-to-cjs/index.d.ts

@@ -1,4 +1,4 @@
-import { Linter } from '@rsdoctor/types';
+import { Linter } from '@rsdoctor/shared/types';
 import type { Config } from './types.js';
 export type { Config } from './types.js';
 export declare const rule: Linter.RuleData<Config, "esm-resolved-to-cjs">;

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

@@ -1,2 +1,2 @@
-import type { Linter } from '@rsdoctor/types';
+import type { Linter } from '@rsdoctor/shared/types';
 export declare const rules: Linter.RuleData[];

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

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

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

@@ -1,4 +1,4 @@
-import type { SDK } from '@rsdoctor/types';
+import type { SDK } from '@rsdoctor/shared/types';
 export interface Config {
     /**
      * loaders which should be ignore.

package/dist/rules/rules/module-mixed-chunks/index.d.ts

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

package/dist/rules/rules/side-effects-only-imports/index.d.ts

@@ -1,4 +1,4 @@
-import { Linter } from '@rsdoctor/types';
+import { Linter } from '@rsdoctor/shared/types';
 import type { Config } from './types.js';
 export type { Config } from './types.js';
 export declare const rule: Linter.RuleData<Config, "tree-shaking-side-effects-only">;

package/dist/rules/utils.d.ts

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

package/dist/sdk/index.d.ts

@@ -0,0 +1,2 @@
+export * from './sdk/index.js';
+export * from './multiple/index.js';

package/dist/sdk/multiple/controller.d.ts

@@ -0,0 +1,12 @@
+import { Manifest } from '@rsdoctor/shared/types';
+import { RsdoctorPrimarySDK } from './primary.js';
+export declare class RsdoctorSDKController {
+    readonly slaves: RsdoctorPrimarySDK[];
+    root: string;
+    constructor(root?: string);
+    get master(): RsdoctorPrimarySDK;
+    getLastSdk(): RsdoctorPrimarySDK;
+    hasName(name: string): boolean;
+    getSeriesData(serverUrl?: boolean): Manifest.RsdoctorManifestSeriesData[];
+    createSlave({ name, stage, extraConfig, type, }: Omit<ConstructorParameters<typeof RsdoctorPrimarySDK>[0], 'controller'>): RsdoctorPrimarySDK;
+}

package/dist/sdk/multiple/index.d.ts

@@ -0,0 +1,2 @@
+export * from './controller.js';
+export * from './primary.js';

package/dist/sdk/multiple/primary.d.ts

@@ -0,0 +1,32 @@
+import { Manifest, SDK } from '@rsdoctor/shared/types';
+import { RsdoctorSDK } from '../sdk/index.js';
+import type { RsdoctorSDKController } from './controller.js';
+interface RsdoctorSlaveSDKOptions {
+    name: string;
+    /**
+     * use to sort for display in the client page.
+     * the smaller the front.
+     * @default 1
+     */
+    stage?: number;
+    extraConfig?: SDK.SDKOptionsType;
+    controller: RsdoctorSDKController;
+    type: SDK.ToDataType;
+}
+export declare class RsdoctorPrimarySDK extends RsdoctorSDK implements SDK.RsdoctorBuilderSDKInstance {
+    id: number;
+    parent: RsdoctorSDKController;
+    readonly stage: number;
+    dependencies: Array<string> | undefined;
+    private uploadPieces;
+    private finishUploadPieceSwitch;
+    constructor({ name, stage, controller, extraConfig, type, }: RsdoctorSlaveSDKOptions);
+    private clearSwitch;
+    get isMaster(): boolean;
+    protected writePieces(): Promise<void>;
+    protected writeManifest(): Promise<string>;
+    getSeriesData(serverUrl?: boolean): Manifest.RsdoctorManifestSeriesData[];
+    setName(name: string): void;
+    getManifestData(): Manifest.RsdoctorManifestWithShardingFiles;
+}
+export {};

package/dist/sdk/multiple/server.d.ts

@@ -0,0 +1,7 @@
+import { RsdoctorServer, type RsdoctorServerOptions } from '../server/index.js';
+import type { RsdoctorPrimarySDK } from './primary.js';
+export declare class RsdoctorSlaveServer extends RsdoctorServer {
+    protected sdk: RsdoctorPrimarySDK;
+    constructor(sdk: RsdoctorPrimarySDK, port?: number, config?: RsdoctorServerOptions);
+    openClientPage(...args: unknown[]): Promise<void>;
+}

package/dist/sdk/sdk/core.d.ts

@@ -0,0 +1,33 @@
+import { Common, Manifest, SDK } from '@rsdoctor/shared/types';
+import { RsdoctorSDKOptions, DataWithUrl } from './types.js';
+export declare abstract class SDKCore<T extends RsdoctorSDKOptions> implements SDK.RsdoctorSDKInstance {
+    protected _name: string;
+    protected hash: string;
+    extraConfig: SDK.SDKOptionsType | undefined;
+    readonly root: string;
+    readonly pid: number;
+    readonly hooks: SDK.Hooks;
+    protected _envinfo: SDK.EnvInfo;
+    private _clientRoutes;
+    private _outputDir;
+    diskManifestPath: string;
+    cloudData?: Manifest.RsdoctorManifestWithShardingFiles;
+    constructor({ name, root }: T);
+    get outputDir(): string;
+    get name(): string;
+    bootstrap(): Promise<void>;
+    dispose(): Promise<void>;
+    setOutputDir(outputDir: string): void;
+    setName(name: string): void;
+    setHash(hash: string): void;
+    getHash(): string;
+    getClientRoutes(): Manifest.RsdoctorManifestClientRoutes[];
+    addClientRoutes(routes: Manifest.RsdoctorManifestClientRoutes[]): void;
+    /** Upload analysis data pieces */
+    protected writePieces(storeData: Common.PlainObject, _options?: SDK.WriteStoreOptionsType): Promise<void>;
+    /** Upload manifest file */
+    protected writeManifest(): Promise<string>;
+    saveManifest(data: Common.PlainObject, options: SDK.WriteStoreOptionsType): Promise<string>;
+    protected writeToFolder(jsonStr: string, dir: string, key: string, index?: number): Promise<DataWithUrl>;
+    abstract onDataReport(): void | Promise<void>;
+}

package/dist/sdk/sdk/index.d.ts

@@ -0,0 +1,52 @@
+import { Manifest, SDK } from '@rsdoctor/shared/types';
+import { RawSourceMap, SourceMapConsumer } from 'source-map';
+import { RsdoctorServer } from '../server/index.js';
+import { RsdoctorRspackSDKOptions } from './types.js';
+import { SDKCore } from './core.js';
+export * from '../utils/openBrowser.js';
+export * from '../utils/base.js';
+export { resolveClientDiffHtmlPath } from '../server/client.js';
+export declare class RsdoctorSDK<T extends RsdoctorRspackSDKOptions = RsdoctorRspackSDKOptions> extends SDKCore<T> implements SDK.RsdoctorBuilderSDKInstance {
+    server: RsdoctorServer;
+    extraConfig: SDK.SDKOptionsType | undefined;
+    type: SDK.ToDataType;
+    root: string;
+    private _summary;
+    private _configs;
+    private _errors;
+    private _loader;
+    private _loaderStart;
+    private _resolver;
+    private _plugin;
+    private _moduleGraph;
+    private _chunkGraph;
+    private _rawSourceMapCache;
+    private _sourceMap;
+    private _packageGraph;
+    constructor(options: T);
+    bootstrap(): Promise<void>;
+    dispose(): Promise<void>;
+    applyErrorFix(id: number): Promise<void>;
+    clear(): void;
+    clearSourceMapCache(): void;
+    getSourceMap(file: string): Promise<SourceMapConsumer | undefined>;
+    reportSourceMap(data: RawSourceMap): void;
+    reportConfiguration(config: SDK.ConfigData[0]): void;
+    reportError(errors: Error[]): void;
+    reportLoader(data: SDK.LoaderData): void;
+    reportLoaderStartOrEnd(data: SDK.ResourceLoaderData): void;
+    reportResolver(data: SDK.ResolverData): void;
+    reportPlugin(data: SDK.PluginData): void;
+    reportModuleGraph(data: SDK.ModuleGraphInstance): void;
+    reportPackageGraph(data: SDK.PackageGraphInstance): void;
+    reportChunkGraph(data: SDK.ChunkGraphInstance): void;
+    reportSummaryData(part: Partial<SDK.SummaryData>): void;
+    createPackageGraph(): void;
+    writeStore(options?: SDK.WriteStoreOptionsType): Promise<string>;
+    getStoreData(): SDK.BuilderStoreData;
+    getManifestData(): Manifest.RsdoctorManifestWithShardingFiles;
+    getRuleContext(_options: SDK.RuntimeContextOptions): SDK.RuntimeContext;
+    onDataReport(): void | Promise<void>;
+    addRsdoctorDataToHTML(storeData: SDK.BuilderStoreData, htmlContent: string): string;
+    inlineScriptsAndStyles(htmlFilePath: string): string;
+}

package/dist/sdk/sdk/types.d.ts

@@ -0,0 +1,26 @@
+import { SDK } from '@rsdoctor/shared/types';
+export interface DataWithUrl {
+    name: string;
+    files: {
+        path: string;
+        basename: string;
+        content: Buffer;
+    }[] | string;
+}
+export interface RsdoctorSDKOptions {
+    name: string;
+    root: string;
+}
+/**
+ * sdk options for builder.
+ */
+export interface RsdoctorBuilderSDK extends RsdoctorSDKOptions {
+    type?: SDK.ToDataType;
+    /**
+     * port for client server
+     */
+    port?: number;
+    config?: SDK.SDKOptionsType;
+}
+export type RsdoctorRspackSDKOptions = RsdoctorBuilderSDK;
+export type RsdoctorEMOSDKOptions = RsdoctorSDKOptions;

package/dist/sdk/server/apis/alerts.d.ts

@@ -0,0 +1,5 @@
+import { SDK } from '@rsdoctor/shared/types';
+import { BaseAPI } from './base.js';
+export declare class AlertsAPI extends BaseAPI {
+    getPackageRelationAlertDetails(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.GetPackageRelationAlertDetails>>;
+}

package/dist/sdk/server/apis/base.d.ts

@@ -0,0 +1,11 @@
+import { Data } from '@rsdoctor/shared/common-browser';
+import { Manifest, SDK } from '@rsdoctor/shared/types';
+export declare class BaseAPI implements Manifest.ManifestDataLoader {
+    [key: string | symbol]: any;
+    readonly ctx: SDK.ServerAPI.APIContext;
+    protected dataLoader: Data.APIDataLoader;
+    constructor(sdk: SDK.RsdoctorSDKInstance, server: SDK.RsdoctorServerInstance);
+    loadManifest(): Promise<Manifest.RsdoctorManifestWithShardingFiles>;
+    loadData<T extends Manifest.RsdoctorManifestMappingKeys>(key: T): Promise<Manifest.InferManifestDataValue<T>>;
+    loadData(key: string): Promise<void>;
+}

package/dist/sdk/server/apis/bundle-diff.d.ts

@@ -0,0 +1,6 @@
+import { SDK } from '@rsdoctor/shared/types';
+import { BaseAPI } from './base.js';
+export declare class BundleDiffAPI extends BaseAPI {
+    getBundleDiffSummary(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.GetBundleDiffSummary>>;
+    bundleDiffManifest(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.BundleDiffManifest>>;
+}

package/dist/sdk/server/apis/data.d.ts

@@ -0,0 +1,6 @@
+import { SDK } from '@rsdoctor/shared/types';
+import { BaseAPI } from './base.js';
+export declare class DataAPI extends BaseAPI {
+    loadDataByKey(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.LoadDataByKey>>;
+    sendMessageToClient(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.SendAPIDataToClient>>;
+}

package/dist/sdk/server/apis/fs.d.ts

@@ -0,0 +1,5 @@
+import { SDK } from '@rsdoctor/shared/types';
+import { BaseAPI } from './base.js';
+export declare class FileSystemAPI extends BaseAPI {
+    applyErrorFix(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.ApplyErrorFix>>;
+}

package/dist/sdk/server/apis/graph.d.ts

@@ -0,0 +1,12 @@
+import { SDK } from '@rsdoctor/shared/types';
+import { BaseAPI } from './base.js';
+export declare class GraphAPI extends BaseAPI {
+    getAssetsSummary(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.GetAssetsSummary>>;
+    getModuleGraphForAsset(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.GetAssetDetails>>;
+    getChunksByModuleId(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.GetChunksByModuleId>>;
+    getModuleDetails(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.GetModuleDetails>>;
+    getDependencyByResolvedRequest(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.GetModulesByModuleIds>>;
+    getModuleCodeByModuleId(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.GetModuleCodeByModuleId>>;
+    getModuleCodeByModuleIds(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.GetModuleCodeByModuleIds>>;
+    getEntryModulesSummary(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.GetEntryPoints>>;
+}

package/dist/sdk/server/apis/index.d.ts

@@ -0,0 +1,10 @@
+export * from './alerts.js';
+export * from './bundle-diff.js';
+export { DataAPI } from './data.js';
+export * from './fs.js';
+export * from './loader.js';
+export * from './graph.js';
+export * from './plugin.js';
+export * from './project.js';
+export * from './renderer.js';
+export * from './resolver.js';

package/dist/sdk/server/apis/loader.d.ts

@@ -0,0 +1,15 @@
+import { SDK } from '@rsdoctor/shared/types';
+import { BaseAPI } from './base.js';
+export declare class LoaderAPI extends BaseAPI {
+    /** report loader data api */
+    reportLoader(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.ReportLoader>>;
+    /** report sourcemap data api */
+    reportSourceMap(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.ReportLoader>>;
+    getLoaderNames(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.GetLoaderNames>>;
+    getLoaderChartData(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.GetLoaderChartData>>;
+    getLoaderFileTree(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.GetLoaderFileTree>>;
+    getLoaderFileDetails(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.GetLoaderFileDetails>>;
+    getLoaderFolderStatistics(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.GetLoaderFolderStatistics>>;
+    getLoaderFileFirstInput(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.GetLoaderFileFirstInput>>;
+    getLoaderFileInputAndOutput(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.GetLoaderFileInputAndOutput>>;
+}

package/dist/sdk/server/apis/plugin.d.ts

@@ -0,0 +1,6 @@
+import { SDK } from '@rsdoctor/shared/types';
+import { BaseAPI } from './base.js';
+export declare class PluginAPI extends BaseAPI {
+    getPluginSummary(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.GetPluginSummary>>;
+    getPluginData(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.GetPluginData>>;
+}

package/dist/sdk/server/apis/project.d.ts

@@ -0,0 +1,8 @@
+import { SDK } from '@rsdoctor/shared/types';
+import { BaseAPI } from './base.js';
+export declare class ProjectAPI extends BaseAPI {
+    env(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.Env>>;
+    manifest(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.Manifest>>;
+    getProjectInfo(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.GetProjectInfo>>;
+    getClientRoutes(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.GetClientRoutes>>;
+}

package/dist/sdk/server/apis/renderer.d.ts

@@ -0,0 +1,6 @@
+import { SDK } from '@rsdoctor/shared/types';
+import { BaseAPI } from './base.js';
+export declare class RendererAPI extends BaseAPI {
+    /** sdk manifest api */
+    entryHtml(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.EntryHtml>>;
+}