@rsdoctor/components 0.0.0-next-20240620044732

package/dist/components/Resolver/analysis.js

@@ -0,0 +1,144 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+import React, { useMemo, useState } from "react";
+import { get, map } from "lodash-es";
+import { Button, Card, Col, Row, Space, Table, Typography } from "antd";
+import { CloseCircleOutlined, FileSearchOutlined, MenuFoldOutlined, MenuUnfoldOutlined } from "@ant-design/icons";
+import { Resolver } from "@rsdoctor/utils/common";
+import { SDK } from "@rsdoctor/types";
+import { Size } from "../../constants";
+import { createFileStructures, formatCosts, mapFileKey } from "../../utils";
+import { FileTree } from "../FileTree";
+import { KeywordInput } from "../Form/keyword";
+import { DiffViewer } from "../CodeViewer";
+import { ServerAPIProvider, withServerAPI } from "../Manifest";
+const height = 735;
+const ResolverDetailsPanel = ({
+  filepath,
+  before,
+  after,
+  resolvers
+}) => {
+  const [collapsed, setCollapsed] = useState(false);
+  return /* @__PURE__ */ jsxs(React.Fragment, { children: [
+    /* @__PURE__ */ jsx(Col, { flex: 1, children: /* @__PURE__ */ jsx(Card, { title: "Resolve Diff Viewer", children: /* @__PURE__ */ jsx(DiffViewer, { filepath, before, after, editorProps: { height } }) }) }),
+    /* @__PURE__ */ jsx(Col, { span: collapsed ? 2 : 7, children: /* @__PURE__ */ jsx(
+      Card,
+      {
+        title: collapsed ? "..." : "Resolve Details",
+        extra: /* @__PURE__ */ jsx(
+          Button,
+          {
+            onClick: () => setCollapsed(!collapsed),
+            size: "small",
+            icon: collapsed ? /* @__PURE__ */ jsx(MenuFoldOutlined, {}) : /* @__PURE__ */ jsx(MenuUnfoldOutlined, {})
+          }
+        ),
+        style: collapsed ? { width: 80 } : void 0,
+        children: collapsed ? null : /* @__PURE__ */ jsx(
+          Table,
+          {
+            style: { width: "100%", height, overflowY: "scroll", wordBreak: "break-all" },
+            size: "small",
+            pagination: false,
+            bordered: true,
+            rowKey: (e) => e.request,
+            columns: [
+              {
+                title: "Source Code",
+                width: 200,
+                render: (_v, r) => /* @__PURE__ */ jsx(Typography.Text, { copyable: true, children: /* @__PURE__ */ jsx(Typography.Text, { code: true, strong: true, children: r.request }) })
+              },
+              {
+                title: "Duration",
+                width: 80,
+                render: (_v, r) => /* @__PURE__ */ jsx(Typography.Text, { strong: true, children: formatCosts(r.costs) }),
+                sorter: (a, b) => a.costs - b.costs,
+                sortDirections: ["descend", "ascend"]
+              },
+              {
+                title: "Resolve Result",
+                render: (_v, r) => {
+                  if (Resolver.isResolveSuccessData(r))
+                    return /* @__PURE__ */ jsx(Typography.Text, { copyable: true, children: r.result });
+                  return /* @__PURE__ */ jsx(CloseCircleOutlined, { style: { color: "#f50" } });
+                }
+              }
+            ],
+            dataSource: resolvers
+          }
+        )
+      }
+    ) })
+  ] });
+};
+const ResolverFiles = (props) => {
+  const { resolver, cwd } = props;
+  const [filepath, setFilepath] = useState("");
+  const inlinedResourcePathKey = "__RESOURCEPATH__";
+  const n = "/node_modules/";
+  const paths = useMemo(() => {
+    return map(resolver, (e) => e.issuerPath).filter(Boolean);
+  }, [resolver]);
+  const filterPaths = useMemo(() => {
+    return paths.filter((e) => props.filename ? e.indexOf(props.filename) > -1 : true);
+  }, [props.filename, paths]);
+  const allNodeModules = filterPaths.length && filterPaths.every((e) => e.indexOf(n) > -1);
+  const files = useMemo(() => {
+    return createFileStructures({
+      files: filterPaths.length ? filterPaths : paths,
+      cwd,
+      fileTitle(file, basename) {
+        return /* @__PURE__ */ jsx("div", { onClick: () => setFilepath(file), children: basename });
+      }
+    });
+  }, [props.filename]);
+  return /* @__PURE__ */ jsxs(Row, { justify: "start", align: "top", wrap: false, gutter: Size.BasePadding, children: [
+    /* @__PURE__ */ jsx(Col, { span: 7, children: /* @__PURE__ */ jsx(Card, { title: "Files", children: /* @__PURE__ */ jsx(
+      FileTree,
+      {
+        style: { width: "100%", height, overflow: "scroll" },
+        treeData: files,
+        defaultExpandedKeys: mapFileKey(
+          files,
+          allNodeModules ? 1 : 4,
+          allNodeModules ? void 0 : (node) => {
+            const resourcePath = get(node, inlinedResourcePathKey);
+            const isNodeModules = resourcePath.indexOf(n) > -1;
+            if (filterPaths.length && filterPaths.every((e) => e.indexOf(n) > -1)) {
+              return true;
+            }
+            return !isNodeModules;
+          }
+        )
+      },
+      `tree_${props.filename}`
+    ) }) }),
+    filepath && /* @__PURE__ */ jsx(ServerAPIProvider, { api: SDK.ServerAPI.API.GetResolverFileDetails, body: { filepath }, children: (resolvers) => /* @__PURE__ */ jsx(ResolverDetailsPanel, { ...resolvers }) })
+  ] });
+};
+const ResolverAnalysisBase = ({ project }) => {
+  const { root: cwd } = project;
+  const [filename, setFilename] = useState("");
+  return /* @__PURE__ */ jsxs("div", { style: { width: "100%" }, children: [
+    /* @__PURE__ */ jsx(Space, { style: { marginTop: Size.BasePadding, marginBottom: Size.BasePadding }, children: /* @__PURE__ */ jsx(
+      KeywordInput,
+      {
+        icon: /* @__PURE__ */ jsx(FileSearchOutlined, {}),
+        label: "Filename",
+        placeholder: "search filename by keyword",
+        onChange: (e) => setFilename(e)
+      }
+    ) }),
+    /* @__PURE__ */ jsx(ServerAPIProvider, { api: SDK.ServerAPI.API.GetResolverFileTree, children: (resolver) => /* @__PURE__ */ jsx(ResolverFiles, { filename, resolver, cwd }) })
+  ] });
+};
+const ResolverAnalysis = withServerAPI({
+  api: SDK.ServerAPI.API.GetProjectInfo,
+  responsePropName: "project",
+  Component: ResolverAnalysisBase
+});
+export {
+  ResolverAnalysis,
+  ResolverAnalysisBase,
+  ResolverFiles
+};

package/dist/components/Select/index.d.ts

@@ -0,0 +1,15 @@
+import React from 'react';
+interface LoaderNamesSelectProps {
+    style?: React.CSSProperties;
+    onChange: (loaders: string[]) => void;
+    loaderNames: string[];
+}
+export declare const LoaderNamesSelect: React.FC<LoaderNamesSelectProps>;
+export declare const LoaderCommonSelect: React.FC<{
+    onChange(value: {
+        loaders: string[];
+        filename: string;
+    }): void;
+    loaderNames: string[];
+}>;
+export {};

package/dist/components/Select/index.js

@@ -0,0 +1,68 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+import { useEffect, useState } from "react";
+import { Button, Input, Select, Space, Typography } from "antd";
+import { FileSearchOutlined, SelectOutlined } from "@ant-design/icons";
+import { KeywordInput } from "../Form/keyword";
+import { Size } from "../../constants";
+const LoaderNamesSelect = ({ style, onChange, loaderNames }) => {
+  const [selectLoaders, setSelectLoaders] = useState([]);
+  const labelStyle = { width: 120 };
+  return /* @__PURE__ */ jsxs(Input.Group, { compact: true, style, children: [
+    /* @__PURE__ */ jsxs(Button, { style: labelStyle, children: [
+      /* @__PURE__ */ jsx(SelectOutlined, {}),
+      /* @__PURE__ */ jsx(Typography.Text, { children: "Loaders" })
+    ] }),
+    /* @__PURE__ */ jsx(
+      Select,
+      {
+        mode: "multiple",
+        allowClear: true,
+        defaultValue: selectLoaders,
+        style: { width: 350 },
+        dropdownMatchSelectWidth: true,
+        placeholder: "select loaders",
+        onChange: (e) => {
+          setSelectLoaders(e);
+          onChange(e);
+        },
+        children: loaderNames.map((e) => {
+          return /* @__PURE__ */ jsx(Select.Option, { label: e, value: e, children: e }, e);
+        })
+      }
+    )
+  ] });
+};
+const LoaderCommonSelect = ({ onChange, loaderNames }) => {
+  const [selectLoaders, setSelectLoaders] = useState([]);
+  const [filename, setFilename] = useState("");
+  useEffect(() => {
+    onChange({ loaders: selectLoaders, filename });
+  }, [selectLoaders, filename]);
+  return /* @__PURE__ */ jsxs(Space, { style: { marginBottom: Size.BasePadding }, children: [
+    /* @__PURE__ */ jsx(
+      LoaderNamesSelect,
+      {
+        loaderNames,
+        style: { marginRight: Size.BasePadding - 8 },
+        onChange: (e) => {
+          setSelectLoaders(e);
+        }
+      }
+    ),
+    /* @__PURE__ */ jsx(
+      KeywordInput,
+      {
+        icon: /* @__PURE__ */ jsx(FileSearchOutlined, {}),
+        label: "Filename",
+        placeholder: "search filename by keyword",
+        onChange: (e) => {
+          setFilename(e);
+        }
+      }
+    )
+  ] });
+};
+export {
+  LoaderCommonSelect,
+  LoaderNamesSelect
+};

package/dist/components/Status/failed.d.ts

@@ -0,0 +1,9 @@
+import { Common } from '@rsdoctor/types';
+import React from 'react';
+interface FailedStatusProps {
+    title?: string;
+    buttonText?: string;
+    retry: Common.Function;
+}
+export declare const FailedStatus: React.NamedExoticComponent<FailedStatusProps>;
+export {};

package/dist/components/Status/failed.js

@@ -0,0 +1,33 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+import { Button, Empty, Space, Typography } from "antd";
+import React from "react";
+const defaultTitle = "Load data failed, please try again";
+const defaultBottonText = "retry";
+const FailedStatusComponent = ({
+  title = defaultTitle,
+  buttonText = defaultBottonText,
+  retry
+}) => {
+  return /* @__PURE__ */ jsx(
+    Empty,
+    {
+      description: /* @__PURE__ */ jsxs(Space, { direction: "vertical", children: [
+        /* @__PURE__ */ jsx(Typography.Text, { children: title }),
+        /* @__PURE__ */ jsx(
+          Button,
+          {
+            type: "primary",
+            onClick: () => {
+              retry();
+            },
+            children: buttonText
+          }
+        )
+      ] })
+    }
+  );
+};
+const FailedStatus = React.memo(FailedStatusComponent);
+export {
+  FailedStatus
+};

package/dist/components/Status/index.d.ts

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

package/dist/components/Status/index.js

@@ -0,0 +1 @@
+export * from "./failed";

package/dist/components/TextDrawer/duplicate.d.ts

@@ -0,0 +1,17 @@
+import React from 'react';
+import { Rule, SDK } from '@rsdoctor/types';
+import { TextDrawerProps } from './index';
+import { PackageRelationAlertProps } from '../Alert/types';
+interface DuplicatePackageDrawerContentProps extends Omit<TextDrawerProps, 'text'> {
+    duplicatePackages: Rule.PackageRelationDiffRuleStoreData[];
+    cwd: string;
+    textStyle?: React.CSSProperties;
+    children: PackageRelationAlertProps['getPackageRelationContentComponent'];
+}
+interface DuplicatePackageDrawerProps extends Omit<DuplicatePackageDrawerContentProps, 'children'> {
+    moduleGraph: Pick<SDK.ModuleGraphData, 'dependencies' | 'modules'>;
+    moduleCodeMap: SDK.ModuleCodeData;
+}
+export declare const DuplicatePackageDrawer: React.FC<DuplicatePackageDrawerProps>;
+export declare const DuplicatePackageDrawerWithServer: React.FC<Omit<DuplicatePackageDrawerContentProps, 'children'>>;
+export {};

package/dist/components/TextDrawer/duplicate.js

@@ -0,0 +1,69 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+import { Col, Row, Space, Tooltip, Typography } from "antd";
+import { SDK } from "@rsdoctor/types";
+import { ExceptionOutlined } from "@ant-design/icons";
+import { Alerts } from "@rsdoctor/utils/common";
+import { Size } from "../../constants";
+import { TextDrawer } from "./index";
+import {
+  PackageRelationAlert,
+  PackageRelationReasons,
+  PackageRelationReasonsWithServer
+} from "../Alert/package-relation";
+import { ServerAPIProvider } from "../Manifest";
+const DuplicatePackageDrawerContent = ({
+  duplicatePackages = [],
+  cwd,
+  children,
+  ...props
+}) => {
+  return /* @__PURE__ */ jsx(
+    TextDrawer,
+    {
+      ...props,
+      buttonStyle: { fontSize: "inherit", ...props.buttonStyle },
+      buttonProps: { type: "text", ...props.buttonProps },
+      text: /* @__PURE__ */ jsx(Tooltip, { title: "Click to show the details of duplicate packages", children: /* @__PURE__ */ jsxs(Space, { style: { fontSize: "inherit" }, children: [
+        /* @__PURE__ */ jsx(Typography.Text, { strong: true, style: { fontSize: "inherit", color: "inherit", ...props.textStyle }, children: duplicatePackages.length }),
+        /* @__PURE__ */ jsx(ExceptionOutlined, {})
+      ] }) }),
+      drawerProps: { title: "Duplicate Packages Viewer", ...props.drawerProps },
+      children: /* @__PURE__ */ jsx(Row, { gutter: [Size.BasePadding, Size.BasePadding], children: duplicatePackages.map((err, i) => {
+        return /* @__PURE__ */ jsx(Col, { span: 24, children: /* @__PURE__ */ jsx(PackageRelationAlert, { data: err, cwd, getPackageRelationContentComponent: children }) }, i);
+      }) })
+    }
+  );
+};
+const DuplicatePackageDrawer = ({ moduleGraph, ...props }) => {
+  return /* @__PURE__ */ jsx(DuplicatePackageDrawerContent, { ...props, children: (res) => {
+    return /* @__PURE__ */ jsx(
+      ServerAPIProvider,
+      {
+        api: SDK.ServerAPI.API.GetModuleCodeByModuleIds,
+        body: { moduleIds: moduleGraph.modules.map((mod) => mod.id) },
+        children: (moduleCodes) => /* @__PURE__ */ jsx(
+          PackageRelationReasons,
+          {
+            data: Alerts.getPackageRelationAlertDetails(
+              moduleGraph.modules,
+              moduleGraph.dependencies,
+              props.cwd,
+              res.package.dependencies,
+              moduleCodes
+            ),
+            cwd: props.cwd
+          }
+        )
+      }
+    );
+  } });
+};
+const DuplicatePackageDrawerWithServer = (props) => {
+  return /* @__PURE__ */ jsx(DuplicatePackageDrawerContent, { ...props, children: (res) => {
+    return /* @__PURE__ */ jsx(PackageRelationReasonsWithServer, { body: { id: res.data.id, target: res.package.target }, cwd: props.cwd });
+  } });
+};
+export {
+  DuplicatePackageDrawer,
+  DuplicatePackageDrawerWithServer
+};

package/dist/components/TextDrawer/index.d.ts

@@ -0,0 +1,11 @@
+import { ButtonProps, DrawerProps } from 'antd';
+import React, { CSSProperties, PropsWithChildren } from 'react';
+export interface TextDrawerProps {
+    text?: string | React.ReactNode;
+    button?: React.ReactNode;
+    buttonProps?: ButtonProps;
+    buttonStyle?: CSSProperties;
+    drawerProps?: DrawerProps;
+}
+export declare const TextDrawer: (props: PropsWithChildren<TextDrawerProps>) => JSX.Element;
+export * from './duplicate';

package/dist/components/TextDrawer/index.js

@@ -0,0 +1,36 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+import { Button, Drawer } from "antd";
+import React, { useState } from "react";
+import { drawerWidth } from "../../constants";
+const TextDrawer = (props) => {
+  const [visible, setVisible] = useState(false);
+  return /* @__PURE__ */ jsxs(React.Fragment, { children: [
+    props.button ? /* @__PURE__ */ jsx("div", { onClick: () => setVisible(!visible), children: props.button }) : /* @__PURE__ */ jsx(
+      Button,
+      {
+        type: "link",
+        ...props.buttonProps,
+        onClick: () => setVisible(!visible),
+        style: { padding: 0, ...props.buttonStyle },
+        children: props.text
+      }
+    ),
+    /* @__PURE__ */ jsx(
+      Drawer,
+      {
+        maskClosable: true,
+        width: drawerWidth,
+        zIndex: 999,
+        ...props.drawerProps,
+        open: visible,
+        onClose: () => setVisible(false),
+        destroyOnClose: true,
+        children: props.children
+      }
+    )
+  ] });
+};
+export * from "./duplicate";
+export {
+  TextDrawer
+};

package/dist/components/Title/index.d.ts

@@ -0,0 +1,15 @@
+import React, { PropsWithChildren } from 'react';
+interface TitleProps {
+    /**
+     * @default true
+     */
+    upperFisrt?: boolean;
+    /**
+     * @default 16
+     */
+    fontSize?: number;
+    text: string | React.ReactNode;
+    hash?: string;
+}
+export declare const Title: React.FC<PropsWithChildren<TitleProps>>;
+export {};

package/dist/components/Title/index.js

@@ -0,0 +1,10 @@
+import { jsx } from "react/jsx-runtime";
+import { Typography } from "antd";
+import { upperFirst as upf } from "lodash-es";
+const Title = ({ upperFisrt = true, fontSize = 16, text, hash }) => {
+  const t = typeof text === "string" ? upperFisrt ? upf(text) : text : text;
+  return /* @__PURE__ */ jsx(Typography.Text, { style: { fontSize }, strong: true, children: hash ? /* @__PURE__ */ jsx("a", { href: hash, id: hash.replace(/^#/, ""), style: { color: "inherit" }, children: t }) : t });
+};
+export {
+  Title
+};

package/dist/components/index.d.ts

@@ -0,0 +1,12 @@
+export * from './Alert';
+export * from './Alerts';
+export * from './Badge';
+export * from './Card';
+export * from './CodeViewer';
+export * from './Layout';
+export * from './Overall';
+export * from './Manifest';
+export * from './Form/keyword';
+export * from './TextDrawer';
+export * from './BundleDiff';
+export { TimelineCom } from './Charts/TimelineCharts';

package/dist/components/index.js

@@ -0,0 +1,15 @@
+export * from "./Alert";
+export * from "./Alerts";
+export * from "./Badge";
+export * from "./Card";
+export * from "./CodeViewer";
+export * from "./Layout";
+export * from "./Overall";
+export * from "./Manifest";
+export * from "./Form/keyword";
+export * from "./TextDrawer";
+export * from "./BundleDiff";
+import { TimelineCom } from "./Charts/TimelineCharts";
+export {
+  TimelineCom
+};

package/dist/components/worker/ecmaversion/client.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+import { ECMAVersion } from '@rsdoctor/utils/ruleUtils';
+export declare function useECMAVersionDetectWorker(props: {
+    code: string;
+}): {
+    version: ECMAVersion | undefined;
+};
+export declare const ECMAVersionDetectTag: React.FC<{
+    code: string;
+}>;

package/dist/components/worker/ecmaversion/client.js

@@ -0,0 +1,60 @@
+import { jsx } from "react/jsx-runtime";
+import { useEffect, useState } from "react";
+import { BadgeColorMap, BadgeType } from "../../Badge";
+import { ECMAVersion } from "@rsdoctor/utils/ruleUtils";
+import { master } from "../../../utils/worker";
+const getECMAVersionDetectWorker = () => new Worker(new URL("./worker.js", import.meta.url));
+function useECMAVersionDetectWorker(props) {
+  const { code } = props;
+  const [version, setVersion] = useState();
+  useEffect(() => {
+    if (!code)
+      return;
+    const worker = master.detectWorker(getECMAVersionDetectWorker);
+    const { abort } = worker.emit(code, (data) => {
+      setVersion(data);
+    });
+    return () => {
+      abort();
+    };
+  }, [code]);
+  return {
+    version
+  };
+}
+const TagColor = {
+  [ECMAVersion.ES5]: BadgeColorMap[BadgeType.Success],
+  [ECMAVersion.ES6]: BadgeColorMap[BadgeType.Error],
+  [ECMAVersion.ES7P]: BadgeColorMap[BadgeType.Error]
+};
+const ECMAVersionDetectTag = ({ code }) => {
+  if (!code)
+    return null;
+  const height = 19.5;
+  const { version } = useECMAVersionDetectWorker({ code });
+  if (!version) {
+    return null;
+  }
+  return /* @__PURE__ */ jsx(
+    "div",
+    {
+      style: {
+        display: "inline-block",
+        height,
+        padding: `0px 4px`,
+        width: 40,
+        fontSize: 10,
+        lineHeight: `${height}px`,
+        textAlign: "center",
+        color: "#fff",
+        background: TagColor[version] || BadgeColorMap[BadgeType.Default],
+        borderRadius: 4
+      },
+      children: version
+    }
+  );
+};
+export {
+  ECMAVersionDetectTag,
+  useECMAVersionDetectWorker
+};

package/dist/components/worker/ecmaversion/worker.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/components/worker/ecmaversion/worker.js

@@ -0,0 +1,13 @@
+const { parser, ECMAVersion } = require("@rsdoctor/utils/ruleUtils");
+const { handleMessageInWorker } = require("../../../utils/worker");
+const cache = /* @__PURE__ */ new Map();
+handleMessageInWorker({
+  workerName: "ecmaversion",
+  handler: (code) => {
+    if (cache.has(code))
+      return cache.get(code) || "";
+    const version = parser.utils.detectECMAVersion(code);
+    cache.set(code, version);
+    return version;
+  }
+});

package/dist/components/worker/jsequal/client.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+export declare function useJSEqualWorker(props: {
+    input: string;
+    output: string;
+}): {
+    isEqual: boolean;
+};
+export declare const JSIsEqualTag: React.FC<{
+    input: string;
+    output: string;
+}>;

package/dist/components/worker/jsequal/client.js

@@ -0,0 +1,38 @@
+import { jsx } from "react/jsx-runtime";
+import { useEffect, useState } from "react";
+import { Tag } from "antd";
+import { master } from "../../../utils/worker";
+import { useI18n } from "../../../utils";
+const getJSEqualWorker = () => new Worker(new URL("./worker.js", import.meta.url));
+function useJSEqualWorker(props) {
+  const { input, output } = props;
+  const [isEqual, setIsEqual] = useState(false);
+  useEffect(() => {
+    if (!input || !output)
+      return;
+    const worker = master.detectWorker(getJSEqualWorker);
+    const { abort } = worker.emit({ input, output }, (data) => {
+      setIsEqual(data);
+    });
+    return () => {
+      abort();
+    };
+  }, [input, output]);
+  return {
+    isEqual
+  };
+}
+const JSIsEqualTag = ({ input, output }) => {
+  if (!input || !output)
+    return null;
+  const { isEqual } = useJSEqualWorker({ input, output });
+  const { t } = useI18n();
+  if (!isEqual) {
+    return null;
+  }
+  return /* @__PURE__ */ jsx(Tag, { color: "warning", children: t("the file content not changed after transpiled by this loader") });
+};
+export {
+  JSIsEqualTag,
+  useJSEqualWorker
+};

package/dist/components/worker/jsequal/worker.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/components/worker/jsequal/worker.js

@@ -0,0 +1,23 @@
+const { minify: terserMinify } = require("terser");
+const { handleMessageInWorker } = require("../../../utils/worker");
+const cache = /* @__PURE__ */ new Map();
+function minify(code) {
+  return terserMinify(code, {
+    module: true,
+    compress: false,
+    mangle: false,
+    sourceMap: false
+  }).then((res) => res.code);
+}
+handleMessageInWorker({
+  workerName: "jsequal",
+  handler: async ({ input = "", output = "" }) => {
+    const key = input + output;
+    if (cache.has(key))
+      return cache.get(key) || "";
+    const [inputMinified, outputMinified] = await Promise.all([minify(input), minify(output)]);
+    const isEqual = inputMinified === outputMinified;
+    cache.set(key, isEqual);
+    return isEqual;
+  }
+});

package/dist/config.d.ts

@@ -0,0 +1,19 @@
+/// <reference types="react" />
+import { Manifest } from '@rsdoctor/types';
+import { PageState, ViewMode, Language, Theme } from './constants';
+export interface Config {
+    locale: Language;
+    theme: Theme;
+    pageState: PageState;
+    viewMode: {
+        bundleAlerts: ViewMode;
+        compileAlerts: ViewMode;
+    };
+    json: Manifest.RsdoctorManifest;
+    setTheme(theme: Config['theme']): void;
+    setManifest(json: Manifest.RsdoctorManifest): void;
+    setPageState(state: PageState): void;
+    setViewMode(mode: Partial<Config['viewMode']>, saveStorage?: boolean): void;
+}
+export declare const defaultConfig: Config;
+export declare const ConfigContext: import("react").Context<Config>;