@rsdoctor/sdk 0.0.2-beta.0

package/dist/esm/sdk/server/router.js

@@ -0,0 +1,92 @@
+const _Router = class _Router {
+  constructor(options) {
+    this.options = options;
+  }
+  static get(pathname) {
+    return (target, propertyKey, descriptor) => {
+      const routes = _Router.routes.get;
+      if (!routes.has(target.constructor)) {
+        routes.set(target.constructor, []);
+      }
+      routes.get(target.constructor).push([propertyKey, pathname]);
+      return descriptor;
+    };
+  }
+  static post(pathname) {
+    return (target, propertyKey, descriptor) => {
+      const routes = _Router.routes.post;
+      if (!routes.has(target.constructor)) {
+        routes.set(target.constructor, []);
+      }
+      routes.get(target.constructor).push([propertyKey, pathname]);
+      return descriptor;
+    };
+  }
+  async setup() {
+    const { apis, sdk, server } = this.options;
+    apis.forEach((API) => {
+      const obj = new API(sdk, server);
+      _Router.routes.get.forEach((v, cons) => {
+        v.forEach(([key, pathname]) => {
+          if (cons === API) {
+            server.get(pathname, this.wrapAPIFunction(obj, key));
+          }
+        });
+      });
+      _Router.routes.post.forEach((v, cons) => {
+        v.forEach(([key, pathname]) => {
+          if (cons === API) {
+            server.post(pathname, this.wrapAPIFunction(obj, key));
+          }
+        });
+      });
+    });
+  }
+  wrapAPIFunction(api, key) {
+    const { sdk, server } = this.options;
+    return async (req, res) => {
+      const ctx = {
+        req,
+        res,
+        sdk,
+        server
+      };
+      const trap = new Proxy(api, {
+        get(target, key2, receiver) {
+          switch (key2) {
+            case "ctx":
+              return ctx;
+            default:
+              return Reflect.get(target, key2, receiver);
+          }
+        },
+        set(target, key2, value, receiver) {
+          return Reflect.set(target, key2, value, receiver);
+        },
+        defineProperty(target, p, attrs) {
+          return Reflect.defineProperty(target, p, attrs);
+        }
+      });
+      const fn = api[key];
+      const result = await fn.call(trap, trap);
+      if (typeof result === "string") {
+        return Buffer.from(result, "utf-8");
+      }
+      if (result && typeof result === "object") {
+        return Buffer.from(JSON.stringify(result), "utf-8");
+      }
+      return result;
+    };
+  }
+};
+_Router.routes = {
+  /**
+   * - `key` is the constuctor of object which used to match the API class
+   */
+  get: /* @__PURE__ */ new Map(),
+  post: /* @__PURE__ */ new Map()
+};
+let Router = _Router;
+export {
+  Router
+};

package/dist/esm/sdk/server/socket/api.js

@@ -0,0 +1,25 @@
+import { Data } from "@rsdoctor/utils/common";
+class SocketAPILoader {
+  constructor(options) {
+    this.options = options;
+    this.dataLoader = new Data.APIDataLoader(this);
+  }
+  async loadManifest() {
+    return this.options.sdk.getManifestData();
+  }
+  async loadData(key) {
+    const data = this.options.sdk.getStoreData();
+    const sep = ".";
+    let res = data[key];
+    if (key.includes(sep)) {
+      res = key.split(sep).reduce((t, k) => t[k], data);
+    }
+    return res;
+  }
+  get loadAPIData() {
+    return this.dataLoader.loadAPI;
+  }
+}
+export {
+  SocketAPILoader
+};

package/dist/esm/sdk/server/socket/index.js

@@ -0,0 +1,82 @@
+import { SDK } from "@rsdoctor/types";
+import {
+  Server as SocketServer
+} from "socket.io";
+import { isDeepStrictEqual } from "util";
+import { SocketAPILoader } from "./api";
+class Socket {
+  constructor(options) {
+    this.options = options;
+    this.map = /* @__PURE__ */ new Map();
+    this.loader = new SocketAPILoader({ sdk: options.sdk });
+  }
+  bootstrap() {
+    this.io = new SocketServer(this.options.server, {
+      cors: {
+        origin: "*"
+      },
+      ...this.options.socketOptions
+    });
+    this.io.on("connection", (socket) => {
+      this.setupSocket(socket);
+    });
+  }
+  setupSocket(socket) {
+    Object.values(SDK.ServerAPI.API).forEach((api) => {
+      socket.on(api, async (body, callback) => {
+        this.saveRequestToMap(api, body);
+        callback(await this.getAPIResponse(api, body));
+      });
+    });
+  }
+  saveRequestToMap(api, body = null) {
+    if (!this.map.has(api)) {
+      this.map.set(api, []);
+    }
+    const list = this.map.get(api);
+    if (!list.some((e) => e === body || isDeepStrictEqual(e, body))) {
+      list.push(body);
+    }
+  }
+  async getAPIResponse(api, body) {
+    const data = await this.loader.loadAPIData(
+      api,
+      body
+    );
+    const response = {
+      req: {
+        api,
+        body
+      },
+      res: data
+    };
+    return response;
+  }
+  async broadcast() {
+    clearImmediate(this.timer);
+    this.timer = setImmediate(async () => {
+      const promises = [];
+      this.map.forEach((bodies, api) => {
+        bodies.forEach((body) => {
+          promises.push(
+            (async () => {
+              const res = await this.getAPIResponse(api, body);
+              this.io.emit(api, res);
+            })()
+          );
+        });
+      });
+      await Promise.all(promises);
+    });
+  }
+  sendAPIData(api, msg) {
+    this.io.sockets.emit(api, msg);
+  }
+  dispose() {
+    this.io.disconnectSockets();
+    this.io.close();
+  }
+}
+export {
+  Socket
+};

package/dist/esm/sdk/server/utils.js

@@ -0,0 +1,14 @@
+function getDataByPagination(data, pagination) {
+  const { page = 1, pageSize = 1e3 } = pagination;
+  return {
+    data: data.slice((page - 1) * pageSize, page * pageSize),
+    pagination: {
+      page,
+      pageSize,
+      hasNextPage: page <= 0 ? false : page * pageSize < data.length
+    }
+  };
+}
+export {
+  getDataByPagination
+};

package/dist/esm/sdk/utils/constant.js

@@ -0,0 +1,7 @@
+import dayjs from "dayjs";
+const CLOUD_DIR = `rsdoctor/manifests/${dayjs().format(
+  "YYYYMMDD"
+)}`;
+export {
+  CLOUD_DIR
+};

package/dist/esm/sdk/utils/index.js

@@ -0,0 +1,2 @@
+export * from "./constant";
+export * from "./upload";

package/dist/esm/sdk/utils/upload.js

@@ -0,0 +1,9 @@
+const transformDataUrls = (d) => {
+  return d.reduce((t, item) => {
+    t[item.name] = Array.isArray(item.files) ? item.files.map((e) => e.path) : item.files;
+    return t;
+  }, {});
+};
+export {
+  transformDataUrls
+};

package/dist/type/index.d.ts

@@ -0,0 +1 @@
+export * from './sdk';

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

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

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

@@ -0,0 +1,16 @@
+import { Manifest } from '@rsdoctor/types';
+import { DoctorSlaveSDK } from './slave';
+export declare class DoctorSDKController {
+  readonly slaves: DoctorSlaveSDK[];
+  root: string;
+  constructor(root?: string);
+  get master(): DoctorSlaveSDK;
+  getLastSdk(): DoctorSlaveSDK;
+  hasName(name: string): boolean;
+  getSeriesData(serverUrl?: boolean): Manifest.DoctorManifestSeriesData[];
+  createSlave({
+    name,
+    stage,
+    extraConfig
+  }: Omit<ConstructorParameters<typeof DoctorSlaveSDK>[0], 'controller'>): DoctorSlaveSDK;
+}

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

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

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

@@ -0,0 +1,7 @@
+import { DoctorServer } from '../server';
+import type { DoctorSlaveSDK } from './slave';
+export declare class DoctorSlaveServer extends DoctorServer {
+  protected sdk: DoctorSlaveSDK;
+  constructor(sdk: DoctorSlaveSDK, port?: number);
+  openClientPage(...args: unknown[]): Promise<void>;
+}

package/dist/type/sdk/multiple/slave.d.ts

@@ -0,0 +1,35 @@
+import { SDK } from '@rsdoctor/types';
+import { DoctorWebpackSDK } from '../sdk';
+import type { DoctorSDKController } from './controller';
+interface DoctorSlaveSDKOptions {
+  name: string;
+  /**
+   * use to sort for display in the client page.
+   * the smaller the front.
+   * @default 1
+   */
+  stage?: number;
+  extraConfig?: SDK.SDKOptionsType;
+  controller: DoctorSDKController;
+}
+export declare class DoctorSlaveSDK extends DoctorWebpackSDK {
+  id: number;
+  readonly stage: number;
+  private parent;
+  private uploadPieces;
+  private finishUploadPieceSwitch;
+  constructor({
+    name,
+    stage,
+    controller,
+    extraConfig
+  }: DoctorSlaveSDKOptions);
+  private clearSwitch;
+  get isMaster(): boolean;
+  protected writePieces(): Promise<void>;
+  protected writeManifest(): Promise<string>;
+  getSeriesData(serverUrl?: boolean): import("@rsdoctor/types/dist/manifest").DoctorManifestSeriesData[];
+  setName(name: string): void;
+  getManifestData(): import("@rsdoctor/types/dist/manifest").DoctorManifestWithShardingFiles;
+}
+export {};

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

@@ -0,0 +1,35 @@
+import { Common, Manifest, SDK } from '@rsdoctor/types';
+import { DoctorSDKOptions, DataWithUrl } from './types';
+export declare abstract class SDKCore<T extends DoctorSDKOptions> implements SDK.DoctorSDKInstance {
+  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.DoctorManifestWithShardingFiles;
+  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;
+  getClientRoutes(): Manifest.DoctorManifestClientRoutes[];
+  addClientRoutes(routes: Manifest.DoctorManifestClientRoutes[]): 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): Promise<DataWithUrl>;
+  abstract onDataReport(): void | Promise<void>;
+}

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

@@ -0,0 +1,2 @@
+export * from './webpack';
+export { DoctorWebpackSDK as DoctorSDK } from './webpack';

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

@@ -0,0 +1,28 @@
+/// <reference types="node" />
+import { SDK } from '@rsdoctor/types';
+export interface DataWithUrl {
+  name: string;
+  files: {
+    path: string;
+    basename: string;
+    content: Buffer;
+  }[] | string;
+}
+export interface DoctorSDKOptions {
+  name: string;
+  root: string;
+}
+/**
+ * sdk options for builder.
+ */
+export interface DoctorBuilderSDK extends DoctorSDKOptions {
+  type?: SDK.ToDataType;
+  /**
+   * port for client server
+   */
+  port?: number;
+  noServer?: boolean;
+  config?: SDK.SDKOptionsType;
+}
+export interface DoctorWebpackSDKOptions extends DoctorBuilderSDK {}
+export interface DoctorEMOSDKOptions extends DoctorSDKOptions {}

package/dist/type/sdk/sdk/webpack.d.ts

@@ -0,0 +1,47 @@
+import { Manifest, SDK } from '@rsdoctor/types';
+import { RawSourceMap, SourceMapConsumer } from 'source-map';
+import { ModuleGraph, ChunkGraph, PackageGraph } from '@rsdoctor/graph';
+import { DoctorServer } from '../server';
+import { DoctorWebpackSDKOptions } from './types';
+import { SDKCore } from './core';
+export declare class DoctorWebpackSDK<T extends DoctorWebpackSDKOptions = DoctorWebpackSDKOptions> extends SDKCore<T> implements SDK.DoctorBuilderSDKInstance {
+  server: DoctorServer;
+  extraConfig: SDK.SDKOptionsType | undefined;
+  private type;
+  private _summary;
+  private _configs;
+  private _errors;
+  private _loader;
+  private _resolver;
+  private _plugin;
+  private _moduleGraph;
+  private _chunkGraph;
+  private _rawSourceMapCache;
+  private _sourceMap;
+  private _packageGraph;
+  private _tileReportHtml;
+  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;
+  reportResolver(data: SDK.ResolverData): void;
+  reportPlugin(data: SDK.PluginData): void;
+  reportModuleGraph(data: ModuleGraph): void;
+  reportPackageGraph(data: PackageGraph): void;
+  reportChunkGraph(data: ChunkGraph): void;
+  reportSummaryData(part: Partial<SDK.SummaryData>): void;
+  reportTileHtml(tileReportHtml: string): void;
+  createPackageGraph(): void;
+  writeStore(options?: SDK.WriteStoreOptionsType): Promise<string>;
+  getStoreData(): SDK.BuilderStoreData;
+  getManifestData(): Manifest.DoctorManifestWithShardingFiles;
+  getRuleContext(_options: SDK.RuntimeContextOptions): SDK.RuntimeContext;
+  onDataReport(): void | Promise<void>;
+}

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

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

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

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

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

@@ -0,0 +1,6 @@
+import { SDK } from '@rsdoctor/types';
+import { BaseAPI } from './base';
+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/type/sdk/server/apis/data.d.ts

@@ -0,0 +1,6 @@
+import { SDK } from '@rsdoctor/types';
+import { BaseAPI } from './base';
+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/type/sdk/server/apis/fs.d.ts

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

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

@@ -0,0 +1,12 @@
+import { SDK } from '@rsdoctor/types';
+import { BaseAPI } from './base';
+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/type/sdk/server/apis/index.d.ts

@@ -0,0 +1,9 @@
+export * from './alerts';
+export * from './data';
+export * from './fs';
+export * from './loader';
+export * from './graph';
+export * from './plugin';
+export * from './project';
+export * from './renderer';
+export * from './resolver';

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

@@ -0,0 +1,16 @@
+import { SDK } from '@rsdoctor/types';
+import { BaseAPI } from './base';
+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>>;
+  getTileReportHtml(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.GetTileReportHtml>>;
+}

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

@@ -0,0 +1,6 @@
+import { SDK } from '@rsdoctor/types';
+import { BaseAPI } from './base';
+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/type/sdk/server/apis/project.d.ts

@@ -0,0 +1,8 @@
+import { SDK } from '@rsdoctor/types';
+import { BaseAPI } from './base';
+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/type/sdk/server/apis/renderer.d.ts

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

package/dist/type/sdk/server/apis/resolver.d.ts

@@ -0,0 +1,6 @@
+import { SDK } from '@rsdoctor/types';
+import { BaseAPI } from './base';
+export declare class ResolverAPI extends BaseAPI {
+  getResolverFileTree(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.GetResolverFileTree>>;
+  getResolverFileDetails(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.GetResolverFileDetails>>;
+}

package/dist/type/sdk/server/fakeServer.d.ts

@@ -0,0 +1,7 @@
+import { SDK } from '@rsdoctor/types';
+import { DoctorServer } from '.';
+export declare class DoctorFakeServer extends DoctorServer {
+  protected sdk: SDK.DoctorBuilderSDKInstance;
+  constructor(sdk: SDK.DoctorBuilderSDKInstance, port?: number);
+  openClientPage(): Promise<void>;
+}

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

@@ -0,0 +1,27 @@
+/// <reference types="connect" />
+import { Common, SDK, Thirdparty, Client } from '@rsdoctor/types';
+export * from './utils';
+export declare class DoctorServer implements SDK.DoctorServerInstance {
+  protected sdk: SDK.DoctorBuilderSDKInstance;
+  private _server;
+  port: number;
+  private _socket?;
+  private disposed;
+  private _router;
+  constructor(sdk: SDK.DoctorBuilderSDKInstance, port?: number);
+  get app(): SDK.DoctorServerInstance['app'];
+  get origin(): string;
+  get socketUrl(): string;
+  bootstrap(): Promise<void>;
+  protected wrapNextHandleFunction(method: 'GET' | 'POST', cb: (...args: Parameters<Thirdparty.connect.NextHandleFunction>) => Common.PlainObject | string): Thirdparty.connect.NextHandleFunction;
+  proxy(api: SDK.ServerAPI.API, method: 'GET' | 'POST', cb: (...args: Parameters<Thirdparty.connect.NextHandleFunction>) => Common.PlainObject | string): void;
+  get: SDK.DoctorServerInstance['get'];
+  post: SDK.DoctorServerInstance['post'];
+  getClientUrl(route: Client.DoctorClientRoutes, baselineUrl: string, currentUrl: string): string;
+  getClientUrl(route?: 'homepage'): string;
+  openClientPage(route: Client.DoctorClientRoutes, baselineUrl: string, currentUrl: string): Promise<void>;
+  openClientPage(route?: 'homepage'): Promise<void>;
+  sendAPIDataToClient<T extends SDK.ServerAPI.API | SDK.ServerAPI.APIExtends>(api: T, msg: SDK.ServerAPI.SocketResponseType<T>): void;
+  broadcast(): Promise<void>;
+  dispose: () => Promise<void>;
+}

package/dist/type/sdk/server/router.d.ts

@@ -0,0 +1,25 @@
+/// <reference types="node" />
+import type { ServerResponse } from 'http';
+import { Common, SDK, Thirdparty } from '@rsdoctor/types';
+import { BaseAPI } from './apis/base';
+interface RouterOptions {
+  apis: Common.Constructor<typeof BaseAPI>[];
+  sdk: SDK.DoctorBuilderSDKInstance;
+  server: SDK.DoctorServerInstance;
+}
+export declare class Router {
+  protected options: RouterOptions;
+  static routes: {
+    /**
+     * - `key` is the constuctor of object which used to match the API class
+     */
+    get: Map<Function, [apiKey: PropertyKey, pathname: string][]>;
+    post: Map<Function, [apiKey: PropertyKey, pathname: string][]>;
+  };
+  static get(pathname: string): MethodDecorator;
+  static post(pathname: string): MethodDecorator;
+  constructor(options: RouterOptions);
+  setup(): Promise<void>;
+  wrapAPIFunction<T extends BaseAPI>(api: T, key: PropertyKey): (req: Thirdparty.connect.IncomingMessage, res: ServerResponse) => Promise<any>;
+}
+export {};

package/dist/type/sdk/server/socket/api.d.ts

@@ -0,0 +1,15 @@
+import { Data } from '@rsdoctor/utils/common';
+import { Manifest, SDK } from '@rsdoctor/types';
+interface SocketAPILoaderOptions {
+  sdk: SDK.DoctorBuilderSDKInstance;
+}
+export declare class SocketAPILoader implements Manifest.ManifestDataLoader {
+  protected options: SocketAPILoaderOptions;
+  protected dataLoader: Data.APIDataLoader;
+  constructor(options: SocketAPILoaderOptions);
+  loadManifest(): Promise<Manifest.DoctorManifestWithShardingFiles>;
+  loadData<T extends Manifest.DoctorManifestMappingKeys>(key: T): Promise<Manifest.InferManifestDataValue<T>>;
+  loadData(key: string): Promise<void>;
+  get loadAPIData(): <T extends SDK.ServerAPI.API, B extends import("@rsdoctor/types/dist/common").Get<SDK.ServerAPI.ResquestBodyTypes, T, void> = import("@rsdoctor/types/dist/common").Get<SDK.ServerAPI.ResquestBodyTypes, T, void>, R extends import("@rsdoctor/types/dist/common").Get<SDK.ServerAPI.ResponseTypes, T, void> = import("@rsdoctor/types/dist/common").Get<SDK.ServerAPI.ResponseTypes, T, void>>(...args: B extends void ? [api: T] : [api: T, body: B]) => Promise<import("@rsdoctor/types/dist/common").Get<SDK.ServerAPI.ResponseTypes, T, void>>;
+}
+export {};

package/dist/type/sdk/server/socket/index.d.ts

@@ -0,0 +1,28 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { Common, SDK } from '@rsdoctor/types';
+import type { Server } from 'http';
+import { Server as SocketServer, ServerOptions as SocketServerOptions, Socket as SocketType } from 'socket.io';
+import { SocketAPILoader } from './api';
+interface SocketOptions {
+  sdk: SDK.DoctorBuilderSDKInstance;
+  server: Server;
+  port: number;
+  socketOptions?: SocketServerOptions;
+}
+export declare class Socket {
+  protected options: SocketOptions;
+  protected io: SocketServer;
+  protected loader: SocketAPILoader;
+  protected map: Map<SDK.ServerAPI.API, (Common.PlainObject | null)[]>;
+  constructor(options: SocketOptions);
+  bootstrap(): void;
+  protected setupSocket(socket: SocketType): void;
+  protected saveRequestToMap<T extends SDK.ServerAPI.API>(api: T, body?: SDK.ServerAPI.InferRequestBodyType<T, null> | null): void;
+  protected getAPIResponse<T extends SDK.ServerAPI.API>(api: T, body: SDK.ServerAPI.InferRequestBodyType<T>): Promise<SDK.ServerAPI.SocketResponseType<SDK.ServerAPI.API>>;
+  protected timer: NodeJS.Immediate | undefined;
+  broadcast(): Promise<void>;
+  sendAPIData<T extends SDK.ServerAPI.API | SDK.ServerAPI.APIExtends>(api: T, msg: SDK.ServerAPI.SocketResponseType<T>): void;
+  dispose(): void;
+}
+export {};