@rsdoctor/components 0.0.2-beta.0

package/dist/utils/manifest.d.ts

@@ -0,0 +1,27 @@
+import { ModuleGraph } from '@rsdoctor/graph';
+import { Manifest, SDK } from '@rsdoctor/types';
+import { Theme, ViewMode } from '../constants';
+export declare function useManifestJson(): Manifest.DoctorManifest;
+export declare function useLocale(): import("../constants").Language;
+export declare function useTheme(): {
+  theme: Theme;
+  setTheme: (theme: Theme) => void;
+  isDark: boolean;
+  isLight: boolean;
+};
+export declare function useViewMode(): {
+  viewMode: {
+    bundleAlerts: ViewMode;
+    compileAlerts: ViewMode;
+  };
+  setViewMode: (mode: Partial<{
+    bundleAlerts: ViewMode;
+    compileAlerts: ViewMode;
+  }>, saveStorage?: boolean | undefined) => void;
+  setCompileAlertsViewMode(mode: ViewMode): void;
+  setBundleAlertsViewMode(mode: ViewMode): void;
+  isCompileList: boolean;
+  isBundleList: boolean;
+};
+export declare function useManifest(url: string): Manifest.DoctorManifestWithShardingFiles | undefined;
+export declare function useModuleGraphInstanceByModuleGraph(moduleGraph: SDK.ModuleGraphData): ModuleGraph;

package/dist/utils/manifest.js

@@ -0,0 +1,54 @@
+import { useContext, useEffect, useMemo, useState } from "react";
+import { ModuleGraph } from "@rsdoctor/graph";
+import { ConfigContext } from "../config";
+import { Theme, ViewMode } from "../constants";
+import { fetchManifest } from "./request";
+function useManifestJson() {
+  const { json } = useContext(ConfigContext);
+  return json;
+}
+function useLocale() {
+  const ctx = useContext(ConfigContext);
+  return ctx.locale;
+}
+function useTheme() {
+  const { theme, setTheme } = useContext(ConfigContext);
+  const isDark = theme === Theme.Dark;
+  return { theme, setTheme, isDark, isLight: !isDark };
+}
+function useViewMode() {
+  const { viewMode, setViewMode } = useContext(ConfigContext);
+  const { bundleAlerts, compileAlerts } = viewMode;
+  return {
+    viewMode,
+    setViewMode,
+    setCompileAlertsViewMode(mode) {
+      setViewMode({ compileAlerts: mode });
+    },
+    setBundleAlertsViewMode(mode) {
+      setViewMode({ bundleAlerts: mode });
+    },
+    isCompileList: compileAlerts === ViewMode.List,
+    isBundleList: bundleAlerts === ViewMode.List
+  };
+}
+function useManifest(url) {
+  const [manifest, setManifest] = useState();
+  useEffect(() => {
+    fetchManifest(url).then((res) => {
+      setManifest(res);
+    });
+  }, []);
+  return manifest;
+}
+function useModuleGraphInstanceByModuleGraph(moduleGraph) {
+  return useMemo(() => ModuleGraph.fromData(moduleGraph), [moduleGraph]);
+}
+export {
+  useLocale,
+  useManifest,
+  useManifestJson,
+  useModuleGraphInstanceByModuleGraph,
+  useTheme,
+  useViewMode
+};

package/dist/utils/monaco.d.ts

@@ -0,0 +1,9 @@
+import type { SDK } from '@rsdoctor/types';
+import type { Range as RangeClass } from 'monaco-editor';
+export declare function getOriginalLanguage(filepath: string): string;
+export declare function getModifiedLanguage(filepath: string): string;
+export declare function getRevealPositionForViewer(startLineNumber: number, startColumn: number): {
+  lineNumber: number;
+  column: number;
+};
+export declare function getSelectionRange(source: SDK.SourceRange, Range: typeof RangeClass): RangeClass;

package/dist/utils/monaco.js

@@ -0,0 +1,48 @@
+import { extname } from "path";
+import { isJsDataUrl } from "./url";
+function getOriginalLanguage(filepath) {
+  if (isJsDataUrl(filepath)) {
+    return "javascript";
+  }
+  const ext = extname(filepath).slice(1);
+  switch (ext) {
+    case "js":
+    case "jsx":
+      return "javascript";
+    case "ts":
+    case "tsx":
+      return "typescript";
+    default:
+      return ext;
+  }
+}
+function getModifiedLanguage(filepath) {
+  const ext = extname(filepath).slice(1);
+  switch (ext) {
+    case "js":
+    case "jsx":
+    case "ts":
+    case "tsx":
+      return "javascript";
+    default:
+      return ext;
+  }
+}
+function getRevealPositionForViewer(startLineNumber, startColumn) {
+  return {
+    lineNumber: Math.floor(startLineNumber / 1.2) || 1,
+    column: Math.floor(startColumn / 1.5) || 1
+  };
+}
+function getSelectionRange(source, Range) {
+  var _a, _b;
+  const { start, end } = source;
+  const { line = 1, column = 0 } = start;
+  return new Range(line, column + 1, (_a = end == null ? void 0 : end.line) != null ? _a : line, ((_b = end == null ? void 0 : end.column) != null ? _b : 9999) + 1);
+}
+export {
+  getModifiedLanguage,
+  getOriginalLanguage,
+  getRevealPositionForViewer,
+  getSelectionRange
+};

package/dist/utils/request.d.ts

@@ -0,0 +1,23 @@
+import { Manifest, SDK } from '@rsdoctor/types';
+export declare function fetchShardingFile(url: string): Promise<string>;
+export declare function loadManifestByUrl(url: string): Promise<{
+  data: Manifest.DoctorManifestData;
+  __LOCAL__SERVER__?: boolean | undefined;
+  __SOCKET__URL__?: string | undefined;
+  client: Manifest.DoctorManifestClient;
+  name?: string | undefined;
+  series?: Manifest.DoctorManifestSeriesData[] | undefined;
+}>;
+export declare function fetchJSONByUrl(url: string): Promise<Manifest.DoctorManifestWithShardingFiles>;
+export declare function fetchJSONByUrls(urls: string[]): Promise<Manifest.DoctorManifestWithShardingFiles[]>;
+export declare function parseManifest(json: Manifest.DoctorManifestWithShardingFiles): Promise<{
+  data: Manifest.DoctorManifestData;
+  __LOCAL__SERVER__?: boolean | undefined;
+  __SOCKET__URL__?: string | undefined;
+  client: Manifest.DoctorManifestClient;
+  name?: string | undefined;
+  series?: Manifest.DoctorManifestSeriesData[] | undefined;
+}>;
+export declare function getManifestUrl(): string;
+export declare function fetchManifest(url?: string): Promise<Manifest.DoctorManifestWithShardingFiles>;
+export declare function postServerAPI<T extends SDK.ServerAPI.API, B extends SDK.ServerAPI.InferRequestBodyType<T> = SDK.ServerAPI.InferRequestBodyType<T>, R extends SDK.ServerAPI.InferResponseType<T> = SDK.ServerAPI.InferResponseType<T>>(...args: B extends void ? [api: T] : [api: T, body: B]): Promise<R>;

package/dist/utils/request.js

@@ -0,0 +1,162 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+import axios from "axios";
+import { Manifest, SDK } from "@rsdoctor/types";
+import { Manifest as ManifestMethod, Url } from "@rsdoctor/utils/common";
+import { APILoaderMode4Dev } from "../constants";
+import { getManifestUrlFromUrlQuery } from "./url";
+import { getAPILoaderModeFromStorage } from "./storage";
+function random() {
+  return `${Date.now()}${Math.floor(Math.random() * 1e4)}`;
+}
+function fetchShardingFile(url) {
+  return __async(this, null, function* () {
+    if (Url.isUrl(url)) {
+      return axios.get(url, { timeout: 999999, responseType: "text" }).then((e) => e.data);
+    }
+    return url;
+  });
+}
+function loadManifestByUrl(url) {
+  return __async(this, null, function* () {
+    const json = yield fetchJSONByUrl(url);
+    const res = yield parseManifest(json);
+    return res;
+  });
+}
+function fetchJSONByUrl(url) {
+  return __async(this, null, function* () {
+    let json = yield axios.get(url, { timeout: 3e4 }).then((e) => e.data);
+    if (typeof json === "string") {
+      json = JSON.parse(json);
+    }
+    console.log("[json] ", url, json);
+    return json;
+  });
+}
+function fetchJSONByUrls(urls) {
+  return Promise.all(urls.map((url) => fetchJSONByUrl(url)));
+}
+function parseManifest(json) {
+  return __async(this, null, function* () {
+    let transformedData;
+    if (json.data) {
+      try {
+        transformedData = yield ManifestMethod.fetchShardingFiles(json.data, fetchShardingFile);
+      } catch (error) {
+        console.log("cloudData load error: ", error);
+      }
+    } else {
+      throw new Error("fallback to load json.data");
+    }
+    return __spreadProps(__spreadValues({}, json), {
+      data: transformedData
+    });
+  });
+}
+const manifestUrlForDev = "/manifest.json";
+function getManifestUrl() {
+  let file;
+  if (window[Manifest.DoctorManifestClientConstant.WindowPropertyForManifestUrl]) {
+    file = window[Manifest.DoctorManifestClientConstant.WindowPropertyForManifestUrl];
+  } else {
+    file = getManifestUrlFromUrlQuery();
+  }
+  if (!file) {
+    if (process.env.NODE_ENV === "development") {
+      file = manifestUrlForDev;
+    } else {
+      file = SDK.ServerAPI.API.Manifest;
+    }
+  }
+  return file;
+}
+const pool = /* @__PURE__ */ new Map();
+function fetchManifest() {
+  return __async(this, arguments, function* (url = getManifestUrl()) {
+    if (!pool.has(url)) {
+      pool.set(
+        url,
+        fetchJSONByUrl(url).catch((err) => {
+          pool.delete(url);
+          throw err;
+        })
+      );
+    }
+    const res = yield pool.get(url);
+    return res;
+  });
+}
+if (process.env.NODE_ENV === "development") {
+  if (getAPILoaderModeFromStorage() === APILoaderMode4Dev.Local) {
+    axios.interceptors.request.use((c) => {
+      c.withCredentials = false;
+      if (c.url && c.url.startsWith("/")) {
+        if (c.url === manifestUrlForDev) {
+          c.url = SDK.ServerAPI.API.Manifest;
+        }
+        const url = new URL(location.href);
+        url.port = String(process.env.LOCAL_CLI_PORT);
+        return __spreadProps(__spreadValues({}, c), {
+          url: `${url.origin}${c.url}`
+        });
+      }
+      return c;
+    });
+  }
+}
+function postServerAPI(...args) {
+  return __async(this, null, function* () {
+    const [api, body] = args;
+    const timeout = process.env.NODE_ENV === "development" ? 1e4 : 6e4;
+    const { data } = yield axios.post(`${api}?_t=${random()}`, body, { timeout });
+    return data;
+  });
+}
+export {
+  fetchJSONByUrl,
+  fetchJSONByUrls,
+  fetchManifest,
+  fetchShardingFile,
+  getManifestUrl,
+  loadManifestByUrl,
+  parseManifest,
+  postServerAPI
+};

package/dist/utils/routes.d.ts

@@ -0,0 +1,3 @@
+import { Manifest } from '@rsdoctor/types';
+export declare function hasCompile(routes: Manifest.DoctorManifestClientRoutes[]): boolean;
+export declare function hasBundle(routes: Manifest.DoctorManifestClientRoutes[]): boolean;

package/dist/utils/routes.js

@@ -0,0 +1,14 @@
+import { includes } from "lodash-es";
+import { Manifest } from "@rsdoctor/types";
+function hasCompile(routes) {
+  const hasCompile2 = includes(routes, Manifest.DoctorManifestClientRoutes.WebpackLoaders) || includes(routes, Manifest.DoctorManifestClientRoutes.ModuleResolve) || includes(routes, Manifest.DoctorManifestClientRoutes.WebpackPlugins);
+  return hasCompile2;
+}
+function hasBundle(routes) {
+  const hasBundle2 = includes(routes, Manifest.DoctorManifestClientRoutes.BundleSize) || includes(routes, Manifest.DoctorManifestClientRoutes.ModuleGraph) || includes(routes, Manifest.DoctorManifestClientRoutes.TreeShaking);
+  return hasBundle2;
+}
+export {
+  hasBundle,
+  hasCompile
+};

package/dist/utils/size.d.ts

@@ -0,0 +1,2 @@
+export declare function formatSize(bytes: number): string;
+export declare function formatPercent(percent: number): string;

package/dist/utils/size.js

@@ -0,0 +1,24 @@
+function formatSize(bytes) {
+  let res;
+  if (bytes >= 1073741824) {
+    res = `${(bytes / 1073741824).toFixed(2)} GB`;
+  } else if (bytes >= 1048576) {
+    res = `${(bytes / 1048576).toFixed(2)} MB`;
+  } else if (bytes >= 1024) {
+    res = `${(bytes / 1024).toFixed(2)} KB`;
+  } else if (bytes > 1) {
+    res = `${bytes} bytes`;
+  } else if (bytes === 1) {
+    res = `${bytes} byte`;
+  } else {
+    res = "0 bytes";
+  }
+  return res;
+}
+function formatPercent(percent) {
+  return `${+percent.toFixed(2)}%`;
+}
+export {
+  formatPercent,
+  formatSize
+};

package/dist/utils/socket.d.ts

@@ -0,0 +1,2 @@
+import { Socket } from 'socket.io-client';
+export declare function getSocket(socketUrl?: string): Socket;

package/dist/utils/socket.js

@@ -0,0 +1,20 @@
+import { io } from "socket.io-client";
+const map = /* @__PURE__ */ new Map();
+const defaultSocketUrl = process.env.NODE_ENV === "development" ? `ws://${location.hostname}:${process.env.LOCAL_CLI_PORT}` : `ws://${location.host}`;
+function ensureSocket(socketUrl = defaultSocketUrl) {
+  if (!map.has(socketUrl)) {
+    const socket = io(socketUrl, {});
+    socket.on("connect", () => {
+      console.log(`Scoket Connect ${socketUrl}`);
+    });
+    map.set(socketUrl, socket);
+  }
+  return map.get(socketUrl);
+}
+function getSocket(socketUrl = defaultSocketUrl) {
+  const socket = ensureSocket(socketUrl);
+  return socket;
+}
+export {
+  getSocket
+};

package/dist/utils/storage.d.ts

@@ -0,0 +1,13 @@
+import type { Config } from '../config';
+import { APILoaderMode4Dev } from '../constants';
+export declare function getStorage(key: string): string | null;
+export declare function setStorage(key: string, value: string): boolean;
+export declare function getThemeFromStorage(): Config['theme'];
+export declare function setThemeToStorage(theme: Config['theme']): void;
+export declare function getLocaleFromStorage(): Config['locale'];
+export declare function setLocaleToStorage(locale: Config['locale']): void;
+export declare function getViewModeFromStorage(): Config['viewMode'];
+export declare function setViewModeToStorage(viewMode: Config['viewMode']): void;
+export declare function hasViewModeFromStorage(): boolean;
+export declare function setAPILoaderModeToStorage(mode: APILoaderMode4Dev): void;
+export declare function getAPILoaderModeFromStorage(): string;

package/dist/utils/storage.js

@@ -0,0 +1,70 @@
+import { APILoaderMode4Dev, Language, Theme, ViewMode } from "../constants";
+var Keys = /* @__PURE__ */ ((Keys2) => {
+  Keys2["Namespace"] = "__WEBDOCTOR__STORAGE__";
+  Keys2["Theme"] = "THEME";
+  Keys2["Locale"] = "LOCALE";
+  Keys2["ViewMode"] = "VIEWMODE";
+  Keys2["APILoaderMode4Dev"] = "APILOADERMODE_DEV";
+  return Keys2;
+})(Keys || {});
+function getStorage(key) {
+  return window.localStorage.getItem(`${"__WEBDOCTOR__STORAGE__" /* Namespace */}${key}`);
+}
+function setStorage(key, value) {
+  try {
+    window.localStorage.setItem(`${"__WEBDOCTOR__STORAGE__" /* Namespace */}${key}`, value);
+    return true;
+  } catch (error) {
+    console.error(error);
+    return false;
+  }
+}
+function getThemeFromStorage() {
+  return getStorage("THEME" /* Theme */) || Theme.Light;
+}
+function setThemeToStorage(theme) {
+  setStorage("THEME" /* Theme */, theme);
+}
+function getLocaleFromStorage() {
+  return getStorage("LOCALE" /* Locale */) || Language.En;
+}
+function setLocaleToStorage(locale) {
+  setStorage("LOCALE" /* Locale */, locale);
+}
+function getViewModeFromStorage() {
+  const fallback = { bundleAlerts: ViewMode.List, compileAlerts: ViewMode.List };
+  try {
+    const str = getStorage("VIEWMODE" /* ViewMode */);
+    if (str) {
+      return JSON.parse(str) || fallback;
+    }
+    return fallback;
+  } catch (error) {
+    return fallback;
+  }
+}
+function setViewModeToStorage(viewMode) {
+  setStorage("VIEWMODE" /* ViewMode */, JSON.stringify(viewMode));
+}
+function hasViewModeFromStorage() {
+  return !!getStorage("VIEWMODE" /* ViewMode */);
+}
+function setAPILoaderModeToStorage(mode) {
+  setStorage("APILOADERMODE_DEV" /* APILoaderMode4Dev */, mode);
+}
+function getAPILoaderModeFromStorage() {
+  return getStorage("APILOADERMODE_DEV" /* APILoaderMode4Dev */) || APILoaderMode4Dev.Default;
+}
+export {
+  getAPILoaderModeFromStorage,
+  getLocaleFromStorage,
+  getStorage,
+  getThemeFromStorage,
+  getViewModeFromStorage,
+  hasViewModeFromStorage,
+  setAPILoaderModeToStorage,
+  setLocaleToStorage,
+  setStorage,
+  setThemeToStorage,
+  setViewModeToStorage
+};

package/dist/utils/string.d.ts

@@ -0,0 +1,2 @@
+export declare function ensurePrefix(str: string, prefix: string): string;
+export declare function removePrefix(str: string, prefix: string): string;

package/dist/utils/string.js

@@ -0,0 +1,14 @@
+function ensurePrefix(str, prefix) {
+  return str.slice(0, prefix.length) === prefix ? str : `${str}${prefix}`;
+}
+function removePrefix(str, prefix) {
+  let res = str;
+  while (res.slice(0, prefix.length) === prefix) {
+    res = res.slice(prefix.length);
+  }
+  return res;
+}
+export {
+  ensurePrefix,
+  removePrefix
+};

package/dist/utils/time.d.ts

@@ -0,0 +1,3 @@
+import { Time } from '@rsdoctor/utils/common';
+declare const toFixedDigits: typeof Time.toFixedDigits, getUnit: typeof Time.getUnit, formatCosts: typeof Time.formatCosts;
+export { toFixedDigits as toFixed, getUnit, formatCosts };

package/dist/utils/time.js

@@ -0,0 +1,7 @@
+import { Time } from "@rsdoctor/utils/common";
+const { toFixedDigits, getUnit, formatCosts } = Time;
+export {
+  formatCosts,
+  getUnit,
+  toFixedDigits as toFixed
+};

package/dist/utils/url.d.ts

@@ -0,0 +1,6 @@
+export declare function isJsDataUrl(path: string): boolean;
+export declare function getManifestUrlFromUrlQuery(): string | void;
+export declare function changeOrigin(origin: string): string;
+export declare function getSharingUrl(manifestCloudUrl: string): string;
+export declare function getDemoUrl(): string | null;
+export declare const getShortPath: (path: string) => string;

package/dist/utils/url.js

@@ -0,0 +1,89 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+import parse from "url-parse";
+import { Constants, Client } from "@rsdoctor/types";
+import { endsWith } from "lodash-es";
+function setDefaultUrl(url) {
+  if (process.env.NODE_ENV !== "development") {
+    const uri = parse(Constants.RsdoctorClientUrl, true);
+    url.set("origin", uri.origin);
+    url.set("protocol", uri.protocol);
+    url.set("host", uri.host);
+    url.set("pathname", uri.pathname);
+  }
+}
+function setUploaderHash(url) {
+  if (endsWith(url.hash, Client.DoctorClientRoutes.Uploader)) {
+    url.set("hash", Client.DoctorClientRoutes.Overall);
+  }
+}
+function isJsDataUrl(path) {
+  return path.startsWith("data:text/javascript;");
+}
+function getManifestUrlFromUrlQuery() {
+  const { query } = parse(location.href, true);
+  const url = query[Client.DoctorClientUrlQuery.ManifestFile];
+  if (url) {
+    return decodeURIComponent(url);
+  }
+}
+function changeOrigin(origin) {
+  const url = parse(location.href, true);
+  const newUrl = parse(origin, true);
+  setUploaderHash(url);
+  url.set("origin", origin);
+  url.set("protocol", newUrl.protocol);
+  url.set("host", newUrl.host);
+  url.set("port", newUrl.port);
+  return url.toString();
+}
+function getSharingUrl(manifestCloudUrl) {
+  const url = parse(location.href, true);
+  setDefaultUrl(url);
+  setUploaderHash(url);
+  url.set("query", __spreadProps(__spreadValues({}, url.query), {
+    [Client.DoctorClientUrlQuery.ManifestFile]: manifestCloudUrl
+  }));
+  return url.toString();
+}
+function getDemoUrl() {
+  if (process.env.OFFICAL_DEMO_MANIFEST_PATH) {
+    return getSharingUrl(process.env.OFFICAL_DEMO_MANIFEST_PATH);
+  }
+  return null;
+}
+const getShortPath = (path) => {
+  if ((path == null ? void 0 : path.indexOf("node_modules")) >= 0) {
+    const pathArr = path.split("node_modules");
+    return `node_modules${pathArr[pathArr.length - 1]}`;
+  }
+  if (path == null ? void 0 : path.length) {
+    return `${path == null ? void 0 : path.split("/").slice(-4).join("/")}`;
+  }
+  return path;
+};
+export {
+  changeOrigin,
+  getDemoUrl,
+  getManifestUrlFromUrlQuery,
+  getSharingUrl,
+  getShortPath,
+  isJsDataUrl
+};

package/dist/utils/worker/index.d.ts

@@ -0,0 +1,4 @@
+export * from './utils';
+export * from './types';
+export * from './master';
+export * from './worker';

package/dist/utils/worker/index.js

@@ -0,0 +1,4 @@
+export * from "./utils";
+export * from "./types";
+export * from "./master";
+export * from "./worker";

package/dist/utils/worker/master.d.ts

@@ -0,0 +1,8 @@
+import { CreateWorker } from './types';
+import { ChildWorker } from './worker';
+declare class Master {
+  private _workerMap;
+  detectWorker(create: CreateWorker): ChildWorker;
+}
+export declare const master: Master;
+export {};

package/dist/utils/worker/master.js

@@ -0,0 +1,18 @@
+import { ChildWorker } from "./worker";
+class Master {
+  constructor() {
+    this._workerMap = /* @__PURE__ */ new WeakMap();
+  }
+  detectWorker(create) {
+    if (this._workerMap.has(create))
+      return this._workerMap.get(create);
+    const worker = create();
+    const child = new ChildWorker(worker);
+    this._workerMap.set(create, child);
+    return child;
+  }
+}
+const master = new Master();
+export {
+  master
+};

package/dist/utils/worker/types.d.ts

@@ -0,0 +1,9 @@
+export type CreateWorker = () => Worker;
+export type NativeWorkerMessage<T = unknown> = MessageEvent<WorkerMessage<T>>;
+export type WorkerMessage<T = unknown> = {
+  id: number | string;
+  data: T;
+};
+export type InternalWorkerEventCallback<T> = (message: WorkerMessage<T>) => unknown;
+export type UserWorkerEventCallback<T = unknown> = (data: T) => unknown;
+export type UserWorkerEventHandler<T = unknown, R = unknown> = (data: T) => R | Promise<R>;