@rsdoctor/components 0.0.2-beta.0

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,107 @@
+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 __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+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 = (_a) => {
+  var _b = _a, {
+    duplicatePackages = [],
+    cwd,
+    children
+  } = _b, props = __objRest(_b, [
+    "duplicatePackages",
+    "cwd",
+    "children"
+  ]);
+  if (!duplicatePackages.length) {
+    return /* @__PURE__ */ jsx(Space, { style: __spreadValues({ fontSize: "inherit" }, props.buttonStyle), children: /* @__PURE__ */ jsx(Typography.Text, { style: __spreadValues({ fontSize: "inherit" }, props.textStyle), children: "0" }) });
+  }
+  return /* @__PURE__ */ jsx(
+    TextDrawer,
+    __spreadProps(__spreadValues({}, props), {
+      buttonStyle: __spreadValues({ fontSize: "inherit" }, props.buttonStyle),
+      buttonProps: __spreadValues({ 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: __spreadValues({ fontSize: "inherit", color: "inherit" }, props.textStyle), children: duplicatePackages.length }),
+        /* @__PURE__ */ jsx(ExceptionOutlined, {})
+      ] }) }),
+      drawerProps: __spreadValues({ 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 = (_c) => {
+  var _d = _c, { moduleGraph } = _d, props = __objRest(_d, ["moduleGraph"]);
+  return /* @__PURE__ */ jsx(DuplicatePackageDrawerContent, __spreadProps(__spreadValues({}, 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, __spreadProps(__spreadValues({}, 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,55 @@
+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 { 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,
+      __spreadProps(__spreadValues({
+        type: "link"
+      }, props.buttonProps), {
+        onClick: () => setVisible(!visible),
+        style: __spreadValues({ padding: 0 }, props.buttonStyle),
+        children: props.text
+      })
+    ),
+    /* @__PURE__ */ jsx(
+      Drawer,
+      __spreadProps(__spreadValues({
+        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,8 @@
+export * from './Alert';
+export * from './Alerts';
+export * from './Badge';
+export * from './Card';
+export * from './CodeViewer';
+export * from './Layout';
+export * from './Overall';
+export { TimelineCom } from './Charts/TimelineCharts';

package/dist/components/index.js

@@ -0,0 +1,11 @@
+export * from "./Alert";
+export * from "./Alerts";
+export * from "./Badge";
+export * from "./Card";
+export * from "./CodeViewer";
+export * from "./Layout";
+export * from "./Overall";
+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,61 @@
+const import_meta = {};
+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.ts", 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 @@
+import { parser } from "@rsdoctor/utils/ruleUtils";
+import { handleMessageInWorker } from "../../../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,39 @@
+const import_meta = {};
+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.ts", 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,52 @@
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+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 { minify as terserMinify } from "terser";
+import { handleMessageInWorker } from "../../../utils/worker";
+var require_worker = __commonJS({
+  "src/components/worker/jsequal/worker.ts"(exports) {
+    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: (_0) => __async(exports, [_0], function* ({ input = "", output = "" }) {
+        const key = input + output;
+        if (cache.has(key))
+          return cache.get(key);
+        const [inputMinified, outputMinified] = yield Promise.all([minify(input), minify(output)]);
+        const isEqual = inputMinified === outputMinified;
+        cache.set(key, isEqual);
+        return isEqual;
+      })
+    });
+  }
+});
+export default require_worker();

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.DoctorManifest;
+  setTheme(theme: Config['theme']): void;
+  setManifest(json: Manifest.DoctorManifest): 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>;

package/dist/config.js

@@ -0,0 +1,39 @@
+var __defProp = Object.defineProperty;
+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;
+};
+import { createContext } from "react";
+import { getLocaleFromStorage, getThemeFromStorage, getViewModeFromStorage } from "./utils/storage";
+import { PageState } from "./constants";
+const defaultConfig = {
+  locale: getLocaleFromStorage(),
+  theme: getThemeFromStorage(),
+  pageState: PageState.Pending,
+  viewMode: getViewModeFromStorage(),
+  json: {},
+  setTheme() {
+  },
+  setManifest() {
+  },
+  setPageState(_state) {
+  },
+  setViewMode() {
+  }
+};
+const ConfigContext = createContext(__spreadValues({}, defaultConfig));
+export {
+  ConfigContext,
+  defaultConfig
+};

package/dist/constants.d.ts

@@ -0,0 +1,48 @@
+export declare enum Theme {
+  Light = "light",
+  Dark = "dark",
+}
+export declare enum PageState {
+  Success = 0,
+  Pending = 1,
+  Fail = 2,
+}
+export declare enum ComponentState {
+  Success = 0,
+  Pending = 1,
+  Updating = 2,
+  Fail = 3,
+}
+export declare enum ViewMode {
+  List = "list",
+  Group = "group",
+}
+export declare enum Language {
+  Cn = "cn",
+  En = "en",
+}
+export declare enum APILoaderMode4Dev {
+  Local = "local",
+  Remote = "remote",
+  Default = "default",
+}
+export declare enum Size {
+  BasePadding = 24,
+  BaseBorderRadius = 8,
+  NavBarHeight = 54,
+}
+export declare enum Color {
+  Red = "rgb(207, 19, 34)",
+  Green = "#52c41a",
+  Yellow = "#faad14",
+  Blue = "#1677ff",
+}
+export declare const drawerWidth: number;
+export declare const TAG_PALLETE: {
+  COLOR_A: string;
+  COLOR_B: string;
+  COLOR_C: string;
+  COLOR_D: string;
+  COLOR_E: string;
+  DARK_BLUE: string;
+};