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

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';

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(()=>({

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) {

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

package/dist/sdk/sdk/core.js

@@ -0,0 +1,163 @@
+import "node:module";
+import { Constants, Manifest } from "@rsdoctor/shared/types";
+import { EnvInfo, File, Json } from "../../build-utils/index.js";
+import node_fs from "node:fs";
+import node_path from "node:path";
+import { createHash, randomUUID } from "node:crypto";
+import node_process from "node:process";
+import { AsyncSeriesHook } from "tapable";
+import { Algorithm, decycle } from "../../common/index.js";
+import { logger } from "../../logger.js";
+import { transformDataUrls } from "../utils/index.js";
+class SDKCore {
+    get outputDir() {
+        return this._outputDir;
+    }
+    get name() {
+        return this._name;
+    }
+    async bootstrap() {
+        const [cpu, memory, nodeVersion, yarnVersion, npmVersion, pnpmVersion] = await Promise.all([
+            EnvInfo.getCPUInfo(),
+            EnvInfo.getMemoryInfo(),
+            EnvInfo.getNodeVersion(),
+            EnvInfo.getYarnVersion(),
+            EnvInfo.getNpmVersion(),
+            EnvInfo.getPnpmVersion()
+        ]);
+        this._envinfo = {
+            ...this._envinfo,
+            cpu,
+            memory,
+            nodeVersion,
+            yarnVersion,
+            npmVersion,
+            pnpmVersion
+        };
+        const hash = createHash('md5').update([
+            this.name,
+            this.root,
+            JSON.stringify(this._envinfo),
+            Date.now()
+        ].join('_')).digest('hex');
+        this.setHash(hash);
+    }
+    async dispose() {}
+    setOutputDir(outputDir) {
+        this._outputDir = outputDir;
+    }
+    setName(name) {
+        this._name = name;
+    }
+    setHash(hash) {
+        this.hash = hash;
+    }
+    getHash() {
+        return this.hash;
+    }
+    getClientRoutes() {
+        return [
+            ...this._clientRoutes
+        ];
+    }
+    addClientRoutes(routes) {
+        routes.forEach((route)=>{
+            this._clientRoutes.add(route);
+        });
+        this.onDataReport();
+    }
+    async writePieces(storeData, _options) {
+        const { outputDir } = this;
+        const manifest = node_path.resolve(outputDir, Constants.RsdoctorOutputManifest);
+        this.diskManifestPath = manifest;
+        await File.fse.ensureDir(outputDir);
+        const urlsPromiseList = [];
+        for (const key of Object.keys(storeData)){
+            const data = storeData[key];
+            if ('object' != typeof data) {
+                urlsPromiseList.push({
+                    name: key,
+                    files: data
+                });
+                continue;
+            }
+            const jsonStr = await (async ()=>{
+                try {
+                    if ('configs' === key) return JSON.stringify(decycle(data));
+                    return JSON.stringify(data);
+                } catch  {
+                    return Json.stringify(data);
+                }
+            })();
+            if (Array.isArray(jsonStr)) {
+                let fileOffset = 0;
+                for (const str of jsonStr){
+                    const result = await this.writeToFolder(str, outputDir, key, fileOffset);
+                    fileOffset += result.files.length;
+                    urlsPromiseList.push(result);
+                }
+            } else urlsPromiseList.push(this.writeToFolder(jsonStr, outputDir, key));
+        }
+        const dataUrls = await Promise.all(urlsPromiseList);
+        logger.debug(`SDKCore.writePieces extraConfig: ${JSON.stringify(this.extraConfig)}`, '[SDKCore.writePieces]');
+        this.cloudData = {
+            client: {
+                enableRoutes: this.getClientRoutes()
+            },
+            data: transformDataUrls(dataUrls)
+        };
+    }
+    async writeManifest() {
+        const { cloudData: data, diskManifestPath } = this;
+        const dataStr = JSON.stringify(data, null, 2);
+        logger.debug(`SDKCore.writeManifest extraConfig: ${this.extraConfig}`, '[SDKCore.writeManifest]');
+        const dir = node_path.dirname(diskManifestPath);
+        const base = node_path.basename(diskManifestPath);
+        const tmpPath = node_path.join(dir, `${base}.${Date.now()}.${randomUUID()}.tmp`);
+        await File.fse.outputFile(tmpPath, dataStr);
+        node_fs.renameSync(tmpPath, diskManifestPath);
+        return diskManifestPath;
+    }
+    async saveManifest(data, options) {
+        await this.writePieces(data, options);
+        const manifestDiskPath = await this.writeManifest();
+        await this.hooks.afterSaveManifest.promise({
+            manifestWithShardingFiles: this.cloudData,
+            manifestDiskPath
+        });
+        return manifestDiskPath;
+    }
+    writeToFolder(jsonStr, dir, key, index) {
+        const sharding = new File.FileSharding(Algorithm.compressText(jsonStr));
+        const folder = node_path.resolve(dir, key);
+        const writer = sharding.writeStringToFolder(folder, '', index);
+        return writer.then((item)=>{
+            const res = {
+                name: key,
+                files: item.map((el)=>({
+                        path: node_path.resolve(folder, el.filename),
+                        basename: el.filename,
+                        content: el.content
+                    }))
+            };
+            return res;
+        });
+    }
+    constructor({ name, root }){
+        this.hooks = {
+            afterSaveManifest: new AsyncSeriesHook([
+                'result'
+            ])
+        };
+        this._envinfo = {};
+        this._clientRoutes = new Set([
+            Manifest.RsdoctorManifestClientRoutes.Overall
+        ]);
+        this.diskManifestPath = '';
+        this._name = name;
+        this.root = root;
+        this.pid = node_process.pid;
+        this._outputDir = node_path.join(this.outputDir || this.root, Constants.RsdoctorOutputFolder);
+    }
+}
+export { SDKCore };

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