@rsdoctor/core 1.6.1 → 2.0.0-alpha.1

package/dist/rules/linter.js

@@ -1,5 +1,5 @@
 import "node:module";
-import { Linter } from "@rsdoctor/types";
+import { Linter } from "@rsdoctor/shared/types";
 import { Rule } from "./rule.js";
 import { rules as index_js_rules } from "./rules/index.js";
 import { toSeverity } from "./utils.js";

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/rule.js

@@ -1,6 +1,6 @@
 import "node:module";
-import { Linter, Rule } from "@rsdoctor/types";
-import { Lodash } from "@rsdoctor/utils/common";
+import { Linter, Rule } from "@rsdoctor/shared/types";
+import { Lodash } from "../common/index.js";
 import { noop, toSeverity } from "./utils.js";
 class rule_Rule {
     static from(data) {

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/cjs-require/index.js

@@ -1,5 +1,5 @@
 import "node:module";
-import { Linter } from "@rsdoctor/types";
+import { Linter } from "@rsdoctor/shared/types";
 import { defineRule } from "../../rule.js";
 const title = 'cjs-require';
 const CJS_REQUIRE_TYPE = 'cjs require';
@@ -30,12 +30,12 @@ const rule = defineRule(()=>({
                     issuerModule: {
                         id: dep.module.id,
                         path: dep.module.path,
-                        webpackId: dep.module.webpackId
+                        identifier: dep.module.identifier
                     },
                     requiredModule: {
                         id: requiredModule.id,
                         path: requiredModule.path,
-                        webpackId: requiredModule.webpackId
+                        identifier: requiredModule.identifier
                     },
                     request: dep.request
                 };

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/cross-chunks-package/index.js

@@ -1,8 +1,8 @@
 import "node:module";
-import { Linter } from "@rsdoctor/types";
+import { Linter } from "@rsdoctor/shared/types";
 import { defineRule } from "../../rule.js";
 import { getErrorMsgForDupPckChunks } from "./utils.js";
-import { uniq } from "es-toolkit/compat";
+import { uniq } from "../../../collection.js";
 const title = 'cross-chunks-package';
 const rule = defineRule(()=>({
         meta: {

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/index.js

@@ -1,7 +1,7 @@
 import "node:module";
 import { builtinModules } from "module";
-import { Linter } from "@rsdoctor/types";
-import { getDocument, parser } from "@rsdoctor/utils/ruleUtils";
+import { Linter } from "@rsdoctor/shared/types";
+import { getDocument, parser } from "../../../rule-utils/index.js";
 import { getDefaultImportByRequest, getFixData, getSourceRangeFromTransformedOffset, hasSameLeftInAssignStatement } from "./utils.js";
 import { defineRule } from "../../rule.js";
 const title = '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/default-import-check/utils.js

@@ -1,6 +1,6 @@
 import "node:module";
-import { getDocument, parser } from "@rsdoctor/utils/ruleUtils";
-import { Lodash } from "@rsdoctor/utils/common";
+import { getDocument, parser } from "../../../rule-utils/index.js";
+import { Lodash } from "../../../common/index.js";
 function getDefaultImportByRequest(node, request) {
     return parser.utils.getDefaultImports(node).find((decl)=>decl.source.value === request);
 }

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/index.js

@@ -1,11 +1,11 @@
 import "node:module";
-import { Linter } from "@rsdoctor/types";
+import { Linter } from "@rsdoctor/shared/types";
 import { diff, gt } from "semver";
 import { getErrorDetail, getErrorMsg } from "./utils.js";
 import { defineRule } from "../../rule.js";
-import * as __rspack_external__types_js_7eec16d2 from "./types.js";
+import * as __rspack_external__types_js_b06c0ce5 from "./types.js";
 const title = 'duplicate-package';
-const { CheckVersionMap: CheckVersionMap } = __rspack_external__types_js_7eec16d2;
+const { CheckVersionMap: CheckVersionMap } = __rspack_external__types_js_b06c0ce5;
 const rule = defineRule(()=>({
         meta: {
             code: 'E1001',

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/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/index.js

@@ -3,7 +3,7 @@ import path from "path";
 import { CheckSyntax } from "@rsbuild/plugin-check-syntax";
 import { loadConfig } from "browserslist-load-config";
 import { defineRule } from "../../rule.js";
-import { Linter } from "@rsdoctor/types";
+import { Linter } from "@rsdoctor/shared/types";
 const title = 'ecma-version-check';
 const rule = defineRule(()=>({
         meta: {

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

@@ -1,3 +1,2 @@
 import type { PluginCheckSyntaxOptions } from '@rsbuild/plugin-check-syntax';
-export interface Config extends PluginCheckSyntaxOptions {
-}
+export type Config = PluginCheckSyntaxOptions;

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/esm-resolved-to-cjs/index.js

@@ -1,7 +1,7 @@
 import "node:module";
 import fs from "fs";
 import path from "path";
-import { Linter, SDK } from "@rsdoctor/types";
+import { Linter, SDK } from "@rsdoctor/shared/types";
 import { defineRule } from "../../rule.js";
 const title = 'esm-resolved-to-cjs';
 function normalizePathForCompare(filePath) {
@@ -64,27 +64,12 @@ function matchPatternExportKey(patternKey, exportKey) {
     if (!exportKey.startsWith(prefix) || !exportKey.endsWith(suffix)) return null;
     return exportKey.slice(prefix.length, exportKey.length - suffix.length);
 }
-function isPatternExportKey(key) {
-    return key.indexOf('*') === key.lastIndexOf('*') && key.includes('*');
-}
-function patternKeyCompare(keyA, keyB) {
-    const baseLengthA = keyA.includes('*') ? keyA.indexOf('*') + 1 : keyA.length;
-    const baseLengthB = keyB.includes('*') ? keyB.indexOf('*') + 1 : keyB.length;
-    if (baseLengthA > baseLengthB) return -1;
-    if (baseLengthB > baseLengthA) return 1;
-    if (!keyA.includes('*')) return 1;
-    if (!keyB.includes('*')) return -1;
-    if (keyA.length > keyB.length) return -1;
-    if (keyB.length > keyA.length) return 1;
-    return 0;
-}
 function resolveExportEntry(exports, exportKey) {
     if (Object.prototype.hasOwnProperty.call(exports, exportKey)) return {
         value: exports[exportKey],
         wildcard: ''
     };
-    const patternEntries = Object.entries(exports).filter(([key])=>isPatternExportKey(key)).sort(([keyA], [keyB])=>patternKeyCompare(keyA, keyB));
-    for (const [key, value] of patternEntries){
+    for (const [key, value] of Object.entries(exports)){
         const wildcard = matchPatternExportKey(key, exportKey);
         if (null !== wildcard) return {
             value,
@@ -181,7 +166,7 @@ const rule = defineRule(()=>({
                     resolvedModule: {
                         id: dep.dependency.id,
                         path: dep.dependency.path,
-                        webpackId: dep.dependency.webpackId
+                        identifier: dep.dependency.identifier
                     },
                     issuers: [
                         issuer

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/index.js

@@ -1,6 +1,6 @@
 import "node:module";
-import { Linter } from "@rsdoctor/types";
-import { Loader, Time } from "@rsdoctor/utils/common";
+import { Linter } from "@rsdoctor/shared/types";
+import { Loader, Time } from "../../../common/index.js";
 import { defineRule } from "../../rule.js";
 import { match } from "./utils.js";
 const title = 'loader-performance-optimization';
@@ -29,7 +29,7 @@ const rule = defineRule(()=>({
             const { extensions, ignore = [], threshold = 5000 } = ruleConfig;
             if (!extensions || extensions?.length === 0) return;
             if (0 === loader.length) return;
-            const { config } = configs.find((e)=>'webpack' === e.name) || {
+            const { config } = configs.find((e)=>'rspack' === e.name) || {
                 config: void 0
             };
             if (!config) return;

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/module-mixed-chunks/index.js

@@ -1,5 +1,5 @@
 import "node:module";
-import { Linter } from "@rsdoctor/types";
+import { Linter } from "@rsdoctor/shared/types";
 import { defineRule } from "../../rule.js";
 const title = 'module-mixed-chunks';
 const rule = defineRule(()=>({
@@ -28,7 +28,7 @@ const rule = defineRule(()=>({
                         module: {
                             id: module.id,
                             path: module.path,
-                            webpackId: module.webpackId
+                            identifier: module.identifier
                         },
                         initialChunks: initialChunks.map((chunk)=>({
                                 id: chunk.id,

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/rules/side-effects-only-imports/index.js

@@ -1,5 +1,5 @@
 import "node:module";
-import { Linter } from "@rsdoctor/types";
+import { Linter } from "@rsdoctor/shared/types";
 import { defineRule } from "../../rule.js";
 const title = 'tree-shaking-side-effects-only';
 function isSideEffectDependencyType(dependencyType) {
@@ -61,7 +61,7 @@ const rule = defineRule(()=>({
                     module: {
                         id: module.id,
                         path: module.path,
-                        webpackId: module.webpackId
+                        identifier: module.identifier
                     },
                     connections: sideEffectConnections.map((c)=>({
                             originModule: c.originModule ?? module.id,

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/rules/utils.js

@@ -1,5 +1,5 @@
 import "node:module";
-import { Linter } from "@rsdoctor/types";
+import { Linter } from "@rsdoctor/shared/types";
 function toSeverity(input, defaultLevel) {
     if ('off' === input) return Linter.Severity.Ignore;
     if ('on' === input) return defaultLevel;

package/dist/sdk/index.d.ts

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

package/dist/sdk/index.js

@@ -0,0 +1,3 @@
+import "node:module";
+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/controller.js

@@ -0,0 +1,42 @@
+import "node:module";
+import { RsdoctorPrimarySDK } from "./primary.js";
+class RsdoctorSDKController {
+    get master() {
+        return this.slaves[0];
+    }
+    getLastSdk() {
+        return this.slaves[this.slaves.length - 1];
+    }
+    hasName(name) {
+        return Boolean(this.slaves.find((item)=>item.name === name));
+    }
+    getSeriesData(serverUrl = false) {
+        return this.slaves.map((item)=>{
+            const data = {
+                name: item.name,
+                path: item.diskManifestPath,
+                stage: item.stage
+            };
+            if (serverUrl) data.origin = item.server.origin;
+            return data;
+        });
+    }
+    createSlave({ name, stage, extraConfig, type }) {
+        const slave = new RsdoctorPrimarySDK({
+            name,
+            stage,
+            controller: this,
+            extraConfig,
+            type
+        });
+        this.slaves.push(slave);
+        this.slaves.sort((a, b)=>a.stage - b.stage);
+        return slave;
+    }
+    constructor(root = process.cwd()){
+        this.slaves = [];
+        this.root = '';
+        this.root = root;
+    }
+}
+export { RsdoctorSDKController };

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

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

package/dist/sdk/multiple/index.js

@@ -0,0 +1,3 @@
+import "node:module";
+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/primary.js

@@ -0,0 +1,64 @@
+import "node:module";
+import path from "path";
+import { RsdoctorSDK } from "../sdk/index.js";
+import { RsdoctorSlaveServer } from "./server.js";
+let id = 1;
+class RsdoctorPrimarySDK extends RsdoctorSDK {
+    clearSwitch() {
+        this.uploadPieces = new Promise((resolve)=>{
+            this.finishUploadPieceSwitch = resolve;
+        });
+    }
+    get isMaster() {
+        return this.parent.master === this;
+    }
+    async writePieces() {
+        const { name, parent, isMaster, outputDir, finishUploadPieceSwitch } = this;
+        this.setOutputDir(isMaster ? outputDir : path.join(parent.master.outputDir, '.slaves', name.replace(/\s+/g, '-')));
+        await super.writePieces(this.getStoreData());
+        finishUploadPieceSwitch?.();
+    }
+    async writeManifest() {
+        const { parent, cloudData, dependencies } = this;
+        if (!dependencies?.length) await Promise.all(this.parent.slaves.filter((item)=>!item.dependencies?.length).map((item)=>item.uploadPieces));
+        if (cloudData) {
+            cloudData.name = this.name;
+            cloudData.series = parent.getSeriesData();
+        }
+        const result = await super.writeManifest();
+        this.clearSwitch();
+        return result;
+    }
+    getSeriesData(serverUrl = false) {
+        return this.parent.getSeriesData(serverUrl);
+    }
+    setName(name) {
+        this._name = this.parent.hasName(name) ? `${name}-${id}` : name;
+    }
+    getManifestData() {
+        const data = super.getManifestData();
+        data.name = this.name;
+        data.series = this.getSeriesData(true);
+        return data;
+    }
+    constructor({ name, stage, controller, extraConfig, type }){
+        super({
+            name,
+            root: controller.root,
+            config: extraConfig
+        });
+        const lastSdk = controller.getLastSdk();
+        const port = lastSdk ? lastSdk.server.port + 1 : extraConfig?.server?.port ?? this.server.port;
+        this.id = id++;
+        this.stage = 'number' == typeof stage ? stage : 1;
+        this.extraConfig = extraConfig;
+        this.parent = controller;
+        this.server = new RsdoctorSlaveServer(this, port, {
+            cors: extraConfig?.server?.cors
+        });
+        this.type = type;
+        this.setName(name);
+        this.clearSwitch();
+    }
+}
+export { RsdoctorPrimarySDK };

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/multiple/server.js

@@ -0,0 +1,14 @@
+import "node:module";
+import { Server } from "../../build-utils/index.js";
+import { RsdoctorServer } from "../server/index.js";
+class RsdoctorSlaveServer extends RsdoctorServer {
+    async openClientPage(...args) {
+        if (this.sdk.isMaster) return super.openClientPage(...args);
+        return Promise.resolve();
+    }
+    constructor(sdk, port = Server.defaultPort, config){
+        super(sdk, port, config);
+        this.sdk = sdk;
+    }
+}
+export { RsdoctorSlaveServer };

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>;
+}