@rsdoctor/components 1.2.0 → 1.2.1

package/dist/pages/TreeShaking/space.d.ts

@@ -0,0 +1 @@
+export declare function Space(): import("react/jsx-runtime").JSX.Element;

package/dist/pages/TreeShaking/table.d.ts

@@ -0,0 +1,13 @@
+import { SDK } from '@rsdoctor/types';
+import React from 'react';
+import type { TableKind, SetEditorStatus } from './types';
+interface TableProps {
+    module: SDK.ModuleInstance;
+    moduleGraph: SDK.ModuleGraphInstance;
+    setEditorData: SetEditorStatus;
+    kind: TableKind;
+}
+export declare const SideEffectTable: React.FC<TableProps>;
+export declare const ExportTable: React.FC<TableProps>;
+export declare const TreeShakingTable: React.FC<TableProps>;
+export {};

package/dist/pages/TreeShaking/types.d.ts

@@ -0,0 +1,3 @@
+import { SDK } from '@rsdoctor/types';
+export type TableKind = 'side-effect' | 'export';
+export type SetEditorStatus = (module: SDK.ModuleInstance, ranges: SDK.SourceRange[], line?: number) => void;

package/dist/pages/TreeShaking/utils.d.ts

@@ -0,0 +1,7 @@
+import { SDK } from '@rsdoctor/types';
+import type { editor } from 'monaco-editor';
+export declare function useFileStructures(modules: SDK.ModuleInstance[], moduleGraph: SDK.ModuleGraphInstance, searchInput: string, selectedModule: SDK.ModuleInstance, onItemClick: (file: string) => void, cwd: string): import("../..").DataNode[];
+export declare function getTreeFilesDefaultExpandedKeys(files: any[]): (string | number)[];
+export declare function ellipsisPath(full: string): string;
+export declare function getModulePositionString(statement: SDK.StatementInstance, module: SDK.ModuleInstance): string;
+export declare function getHoverMessageInModule(module: SDK.ModuleInstance, moduleGraph: SDK.ModuleGraphInstance): editor.IModelDecoration[];

package/dist/pages/WebpackLoaders/Analysis/constants.d.ts

@@ -0,0 +1,3 @@
+import { Client } from '@rsdoctor/types';
+export declare const name = "Loaders Analysis";
+export declare const route = Client.RsdoctorClientRoutes.WebpackLoaderAnalysis;

package/dist/pages/WebpackLoaders/Analysis/index.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+export declare const Page: React.FC;
+export * from './constants';

package/dist/pages/WebpackLoaders/Overall/constants.d.ts

@@ -0,0 +1,3 @@
+import { Client } from '@rsdoctor/types';
+export declare const name = "Loaders Timeline";
+export declare const route = Client.RsdoctorClientRoutes.WebpackLoaderOverall;

package/dist/pages/WebpackLoaders/Overall/index.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+export declare const Page: React.FC;
+export * from './constants';

package/dist/pages/WebpackLoaders/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const name = "Loaders";
+export declare const route = "/webpack/loaders";

package/dist/pages/WebpackPlugins/constants.d.ts

@@ -0,0 +1,3 @@
+import { Client } from '@rsdoctor/types';
+export declare const name = "Plugins Analysis";
+export declare const route = Client.RsdoctorClientRoutes.WebpackPlugins;

package/dist/pages/WebpackPlugins/index.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import './index.scss';
+export declare const Page: React.FC;
+export * from './constants';

package/dist/pages/index.d.ts

@@ -0,0 +1,10 @@
+export * as Overall from './Overall';
+export * as BundleSize from './BundleSize';
+export * as ModuleAnalyze from './ModuleAnalyze';
+export * as LoaderTimeline from './WebpackLoaders/Overall';
+export * as LoaderFiles from './WebpackLoaders/Analysis';
+export * as PluginsAnalyze from './WebpackPlugins';
+export * as ModuleResolve from './ModuleResolve';
+export * as RuleIndex from './Resources/RuleIndex';
+export * as TreeShaking from './TreeShaking';
+export * as BundleDiff from './Resources/BundleDiff';

package/dist/utils/data/base.d.ts

@@ -0,0 +1,24 @@
+import { Common, Manifest, SDK } from '@rsdoctor/types';
+import { Data } from '@rsdoctor/utils/common';
+export declare abstract class BaseDataLoader implements Manifest.ManifestDataLoader {
+    protected manifest: Manifest.RsdoctorManifestWithShardingFiles;
+    protected pool: Map<string, Promise<unknown>>;
+    protected loader: Data.APIDataLoader;
+    protected disposed: boolean;
+    protected shardingDataMap: Map<keyof Manifest.RsdoctorManifestData, Promise<any>>;
+    constructor(manifest: Manifest.RsdoctorManifestWithShardingFiles);
+    protected get<T extends keyof Manifest.RsdoctorManifestWithShardingFiles>(key: T): void | Manifest.RsdoctorManifestWithShardingFiles[T];
+    protected getData<T extends keyof Manifest.RsdoctorManifestData>(key: T, scope?: 'data' | 'cloudData'): void | Manifest.RsdoctorManifestWithShardingFiles['data'][T];
+    protected getKeys(key: string): string[];
+    protected joinKeys(keys: string[]): string;
+    dispose(): void;
+    limit<T>(key: string, fn: Common.Function<unknown[], Promise<T>>): Promise<T>;
+    log(...args: unknown[]): void;
+    loadManifest(): Promise<Manifest.RsdoctorManifestWithShardingFiles>;
+    abstract loadData<T extends string, P>(key: T): Promise<void | P>;
+    abstract loadData<T extends Manifest.RsdoctorManifestMappingKeys>(key: T): Promise<void | Manifest.InferManifestDataValue<T>>;
+    abstract isLocal(): boolean;
+    abstract loadAPI<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>;
+    abstract onDataUpdate<T extends SDK.ServerAPI.API | SDK.ServerAPI.APIExtends>(api: T, fn: (response: SDK.ServerAPI.SocketResponseType<T>) => void): void;
+    abstract removeOnDataUpdate<T extends SDK.ServerAPI.API | SDK.ServerAPI.APIExtends>(api: T, fn: (response: SDK.ServerAPI.SocketResponseType<T>) => void): void;
+}

package/dist/utils/data/brief.d.ts

@@ -0,0 +1,11 @@
+import { Manifest, SDK } from '@rsdoctor/types';
+import { BaseDataLoader } from './base';
+export declare class BriefDataLoader extends BaseDataLoader {
+    isLocal(): boolean;
+    loadData<T extends Manifest.RsdoctorManifestMappingKeys>(key: T): Promise<Manifest.InferManifestDataValue<T>>;
+    getData(scope: keyof Manifest.RsdoctorManifestData): any;
+    loadAPI<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>;
+    dispose(): void;
+    onDataUpdate(): void;
+    removeOnDataUpdate(): void;
+}

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

@@ -0,0 +1,5 @@
+import { Manifest } from '@rsdoctor/types';
+import { BaseDataLoader } from './base';
+export declare function useDataLoader(manifest: Manifest.RsdoctorManifestWithShardingFiles | void): {
+    loader: void | BaseDataLoader;
+};

package/dist/utils/data/local.d.ts

@@ -0,0 +1,14 @@
+import { Common, Manifest, SDK } from '@rsdoctor/types';
+import { BaseDataLoader } from './base';
+export declare class LocalServerDataLoader extends BaseDataLoader {
+    protected events: Map<SDK.ServerAPI.API | SDK.ServerAPI.APIExtends, Set<Common.Function>>;
+    isLocal(): boolean;
+    loadData<T extends keyof Manifest.RsdoctorManifestData>(key: T): Promise<void | Manifest.RsdoctorManifestData[T]>;
+    loadAPI<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>;
+    dispose(): void;
+    /**
+     * add event listener when received data from server.
+     */
+    onDataUpdate<T extends SDK.ServerAPI.API | SDK.ServerAPI.APIExtends>(api: T, fn: (response: SDK.ServerAPI.SocketResponseType<T>) => void): void;
+    removeOnDataUpdate<T extends SDK.ServerAPI.API | SDK.ServerAPI.APIExtends>(api: T, fn: (response: SDK.ServerAPI.SocketResponseType<T>) => void): void;
+}

package/dist/utils/data/remote.d.ts

@@ -0,0 +1,10 @@
+import { Manifest, SDK } from '@rsdoctor/types';
+import { BaseDataLoader } from './base';
+export declare class RemoteDataLoader extends BaseDataLoader {
+    isLocal(): boolean;
+    loadData<T extends Manifest.RsdoctorManifestMappingKeys>(key: T): Promise<Manifest.InferManifestDataValue<T>>;
+    loadAPI<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>;
+    dispose(): void;
+    onDataUpdate(): void;
+    removeOnDataUpdate(): void;
+}

package/dist/utils/file.d.ts

@@ -0,0 +1,47 @@
+import { Common, SDK } from '@rsdoctor/types';
+import { TreeNodeProps, UploadFile } from 'antd';
+import { FieldDataNode } from 'rc-tree';
+export type DataNode = FieldDataNode<{
+    key: string | number;
+    title?: React.ReactNode | ((data: DataNode) => React.ReactNode);
+}> & {
+    __BASENAME__?: any;
+    __RESOURCEPATH__?: any;
+    children?: DataNode[];
+};
+export declare const rootDirname: (file: string, sep?: string) => string | null;
+export declare function mapFileKey(arr: DataNode[], depth?: number, filter?: (node: DataNode) => boolean): DataNode['key'][];
+export declare function flattenDirectory(n: DataNode, parent: DataNode, sep: string | undefined, inlinedResourcePathKey: keyof DataNode, dirTitle?: (_dir: DataNode, defaultTitle: string) => JSX.Element | string): void;
+export declare function createFileStructures({ files, sep, inlinedResourcePathKey, fileTitle, dirTitle, page, }: {
+    files: string[];
+    cwd?: string;
+    sep?: string;
+    inlinedResourcePathKey?: keyof DataNode;
+    dirTitle?(dir: DataNode, defaultTitle: string): JSX.Element | string;
+    fileTitle?(file: string, basename: string): JSX.Element | string;
+    page?: 'bundle' | 'other';
+}): DataNode[];
+export declare function beautifyPath(path: string, cwd: string): string;
+export declare function readJSONByFileReader<T extends Common.PlainObject>(file: UploadFile): Promise<T>;
+export declare function readJSONByFileReader<T extends Common.PlainObject>(file: Blob): Promise<T>;
+/**
+ * beautify module path, will replace cwd & last 'node_modules'
+ */
+export declare function beautifyModulePath(modulePath: string, cwd: string): {
+    alias: string;
+    inNodeModules: boolean;
+};
+export declare function getFileIcon(props: TreeNodeProps, addRowIcon?: boolean): import("react/jsx-runtime").JSX.Element;
+type TreeNode = {
+    name: string;
+    value?: number;
+    children?: TreeNode[];
+    path?: string;
+    sourceSize?: number;
+    bundledSize?: number;
+    gzipSize?: number;
+    _map?: Map<string, TreeNode>;
+};
+export declare function buildTreemapData(modules: SDK.ModuleData[], rootName?: string): TreeNode;
+export declare function flattenTreemapData(modules: SDK.ModuleData[], rootName?: string): TreeNode;
+export {};

package/dist/utils/hooks.d.ts

@@ -0,0 +1,30 @@
+import { Manifest, Rule, SDK } from '@rsdoctor/types';
+import { useTranslation } from 'react-i18next';
+import './i18n';
+export declare const useI18n: typeof useTranslation;
+export declare function useRuleIndexNavigate(code: string, link?: string | undefined): () => void;
+export declare function useUrlQuery(): Record<string, string | undefined>;
+export declare function useLoading(defaultLoading?: boolean): {
+    loading: boolean;
+    setLoading: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+    withLoading(func: (...args: unknown[]) => Promise<unknown> | unknown): Promise<void>;
+};
+export declare function useProjectRootByManifest(manifest: Manifest.RsdoctorManifest): string;
+export declare function useHashByManifest(manifest: Manifest.RsdoctorManifest): string;
+export declare function useCloudManifestUrlByManifest(manifest: Manifest.RsdoctorManifest | Manifest.RsdoctorManifestWithShardingFiles | void): void;
+export declare function useChunkGraphByManifest(manifest: Manifest.RsdoctorManifest): SDK.ChunkGraphData;
+export declare function useConfigOutputFileNameByManifest(manifest: Manifest.RsdoctorManifest): string;
+export declare function useModuleGraphByManifest(manifest: Manifest.RsdoctorManifest): SDK.ModuleGraphData;
+export declare function useModuleGraph(moduleGraph: SDK.ModuleGraphData): SDK.ModuleGraphData;
+export declare function usePackageGraphByManifest(manifest: Manifest.RsdoctorManifest): SDK.PackageGraphData;
+export declare function useUniqModulesByManifest(manifest: Manifest.RsdoctorManifest): SDK.ModuleData[];
+export declare function useUniqModules(modules: SDK.ModuleData[]): SDK.ModuleData[];
+export declare function useErrorsByManifest(manifest: Manifest.RsdoctorManifest): Rule.RuleStoreData;
+export declare function useBundleAlertsByManifest(manifest: Manifest.RsdoctorManifest): Rule.RuleStoreDataItem[];
+export declare function useDuplicatePackagesByManifest(manifest: Manifest.RsdoctorManifest): Rule.PackageRelationDiffRuleStoreData[];
+export declare function useCompileAlertsByErrors(errors: Manifest.RsdoctorManifestData['errors']): Rule.RuleStoreDataItem[];
+export declare function useBundleAlertsByErrors(errors: Manifest.RsdoctorManifestData['errors']): Rule.RuleStoreDataItem[];
+export declare function useDuplicatePackagesByErrors(errors: Manifest.RsdoctorManifestData['errors']): Rule.PackageRelationDiffRuleStoreData[];
+export declare function useWebpackConfigurationByConfigs(configs?: SDK.ConfigData): SDK.WebpackConfigData | null | undefined;
+export declare function useDetectIfCloudIdeEnv(): boolean;
+export declare function useWindowWidth(): number;

package/dist/utils/i18n/cn.d.ts

@@ -0,0 +1,3 @@
+import en from './en';
+declare const cn: typeof en;
+export default cn;

package/dist/utils/i18n/en.d.ts

@@ -0,0 +1,40 @@
+declare const en: {
+    Overall: string;
+    'Compile Analysis': string;
+    'Bundle Alerts': string;
+    'Help Center': string;
+    LoadersAnalysis: string;
+    'Loaders Timeline': string;
+    'Loaders Analysis': string;
+    'Rsdoctor Introduction': string;
+    'Compilation Alerts': string;
+    'Plugins Analysis': string;
+    PluginsAnalysis: string;
+    ModuleResolve: string;
+    'Bundle Analysis': string;
+    BundleSize: string;
+    ViewBundleSize: string;
+    'Module Graph': string;
+    TreeShaking: string;
+    'Rule Index': string;
+    Resources: string;
+    'Project Overall': string;
+    'Compile Overall': string;
+    'Bundle Overall': string;
+    'Expand Omitted': string;
+    'Concatenated Tag': string;
+    'the file content not changed after transpiled by this loader': string;
+    /** Bundle Size */
+    'Output Assets List': string;
+    'filter the output assets which size is greater than the input value': string;
+    'filter the modules which size is greater than the input value': string;
+    'After Compile': string;
+    'After Bundle': string;
+    CodeModeExplain: string;
+    DuplicatePakCodeExplain: string;
+    AsyncLoaderInfo: string;
+    Details: string;
+    Expand: string;
+    Collapse: string;
+};
+export default en;

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

@@ -0,0 +1,2 @@
+import i18n from 'i18next';
+export default i18n;

package/dist/utils/index.d.ts

@@ -0,0 +1,15 @@
+export * from './data';
+export * from './file';
+export * from './hooks';
+export * from './loader';
+export * from './locale';
+export * from './manifest';
+export * from './request';
+export * from './routes';
+export * from './size';
+export * from './socket';
+export * from './storage';
+export * from './string';
+export * from './time';
+export * from './url';
+export * from './worker';

package/dist/utils/loader.d.ts

@@ -0,0 +1,7 @@
+import { Loader } from '@rsdoctor/utils/common';
+import { SDK } from '@rsdoctor/types';
+declare const findLoaderTotalTiming: typeof Loader.findLoaderTotalTiming, getLoaderCosts: typeof Loader.getLoaderCosts;
+export { findLoaderTotalTiming, getLoaderCosts };
+export declare function flattenLoaderData(loaderData: SDK.LoaderData): SDK.LoaderTransformData[];
+export declare function filterLoaders(loaderData: SDK.ResourceLoaderData, keyword: string, loaderNames: string[], layer?: string): SDK.LoaderTransformData[];
+export declare function filterLoader(resourcePath: string, loader: string, keyword: string, loaderNames: string[], resorceLayer?: string, layer?: string): boolean;

package/dist/utils/locale.d.ts

@@ -0,0 +1,4 @@
+import type { Locale } from 'antd/es/locale';
+import { Language } from '../constants';
+export declare function getLocale(locale: string): Locale;
+export declare function getLanguage(locale: string): Language;

package/dist/utils/manifest.d.ts

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

package/dist/utils/request.d.ts

@@ -0,0 +1,29 @@
+import { Manifest, SDK } from '@rsdoctor/types';
+export declare function fetchShardingFile(url: string): Promise<string>;
+export declare function loadManifestByUrl(url: string): Promise<{
+    data: Manifest.RsdoctorManifestData;
+    cloudData?: Record<keyof Manifest.RsdoctorManifestData, string[] | string>;
+    __LOCAL__SERVER__?: boolean;
+    __SOCKET__PORT__?: string;
+    __SOCKET__URL__?: string;
+    client: Manifest.RsdoctorManifestClient;
+    cloudManifestUrl?: string | undefined;
+    name?: string | undefined;
+    series?: Manifest.RsdoctorManifestSeriesData[] | undefined;
+}>;
+export declare function fetchJSONByUrl(url: string): Promise<Manifest.RsdoctorManifestWithShardingFiles>;
+export declare function fetchJSONByUrls(urls: string[]): Promise<Manifest.RsdoctorManifestWithShardingFiles[]>;
+export declare function parseManifest(json: Manifest.RsdoctorManifestWithShardingFiles): Promise<{
+    data: Manifest.RsdoctorManifestData;
+    cloudData?: Record<keyof Manifest.RsdoctorManifestData, string[] | string>;
+    __LOCAL__SERVER__?: boolean;
+    __SOCKET__PORT__?: string;
+    __SOCKET__URL__?: string;
+    client: Manifest.RsdoctorManifestClient;
+    cloudManifestUrl?: string | undefined;
+    name?: string | undefined;
+    series?: Manifest.RsdoctorManifestSeriesData[] | undefined;
+}>;
+export declare function getManifestUrl(): string;
+export declare function fetchManifest(url?: string): Promise<Manifest.RsdoctorManifestWithShardingFiles>;
+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/routes.d.ts

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

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/socket.d.ts

@@ -0,0 +1,7 @@
+import { Socket } from 'socket.io-client';
+export declare function getSocket(socketPort?: string): Socket;
+export declare function formatURL({ port, protocol, hostname, }: {
+    port?: string;
+    protocol: string;
+    hostname: string;
+}): string;

package/dist/utils/storage.d.ts

@@ -0,0 +1,15 @@
+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;
+export declare function getFirstVisitFromStorage(): string | null;
+export declare function setFirstVisitToStorage(value: '1'): void;

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/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/url.d.ts

@@ -0,0 +1,7 @@
+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;
+export declare function isDef<E = unknown>(data: E): data is NonNullable<E>;

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

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

@@ -0,0 +1,7 @@
+import { NativeWorkerMessage, UserWorkerEventHandler, WorkerMessage } from './types';
+export declare function sendMessageInClient<T>(msg: WorkerMessage<T>, worker: Worker): void;
+export declare function sendMessageInWorker<T>(receivedMsg: NativeWorkerMessage, response: T): void;
+export declare function handleMessageInWorker<T, R>({ handler, }: {
+    workerName: string;
+    handler: UserWorkerEventHandler<T, R>;
+}): void;

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

@@ -0,0 +1,13 @@
+import { UserWorkerEventCallback } from './types';
+export declare class ChildWorker {
+    protected worker: Worker;
+    private timer;
+    private callbacks;
+    constructor(worker: Worker);
+    protected setup(): void;
+    protected createEventId(): string;
+    emit<T, P = unknown>(data: P, callback: UserWorkerEventCallback<T>): {
+        abort: () => boolean;
+    };
+    dispose(): void;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rsdoctor/components",
-  "version": "1.2.0",
+  "version": "1.2.1",
   "license": "MIT",
   "types": "dist/index.d.ts",
   "repository": {
@@ -76,9 +76,9 @@
     "react-router-dom": "6.4.3",
     "socket.io-client": "4.6.1",
     "url-parse": "1.5.10",
-    "@rsdoctor/graph": "1.2.0",
-    "@rsdoctor/utils": "1.2.0",
-    "@rsdoctor/types": "1.2.0"
+    "@rsdoctor/graph": "1.2.1",
+    "@rsdoctor/types": "1.2.1",
+    "@rsdoctor/utils": "1.2.1"
   },
   "peerDependencies": {
     "react": ">=18.3.1",