@oceanbase/ui 0.2.0

package/lib/Action/Item.js

@@ -0,0 +1,126 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/Action/Item.tsx
+var Item_exports = {};
+__export(Item_exports, {
+  ActionButton: () => ActionButton,
+  ActionLink: () => ActionLink
+});
+module.exports = __toCommonJS(Item_exports);
+var import_icons = require("@ant-design/icons");
+var import_design = require("@oceanbase/design");
+var import_react = __toESM(require("react"));
+var ActionButton = class extends import_react.default.PureComponent {
+  constructor() {
+    super(...arguments);
+    this.state = {
+      loading: false
+    };
+  }
+  render() {
+    const {
+      type,
+      disabled,
+      children,
+      onClick,
+      enableLoading = true,
+      className,
+      tooltip,
+      loading,
+      danger
+    } = this.props;
+    return /* @__PURE__ */ import_react.default.createElement(import_design.Tooltip, { placement: "top", title: tooltip }, /* @__PURE__ */ import_react.default.createElement(
+      import_design.Button,
+      {
+        className,
+        loading: enableLoading && (loading || this.state.loading),
+        type,
+        danger,
+        disabled,
+        onClick: (_) => {
+          if (enableLoading) {
+            this.setState({ loading: true });
+            const handle = onClick == null ? void 0 : onClick();
+            if (handle.then) {
+              handle.then(() => {
+                this.setState({ loading: false });
+              });
+            }
+          }
+        }
+      },
+      children
+    ));
+  }
+};
+ActionButton.__DISPLAY_NAME = "button";
+var ActionLink = class extends import_react.default.PureComponent {
+  constructor() {
+    super(...arguments);
+    this.state = {
+      loading: false,
+      disabled: false
+    };
+  }
+  render() {
+    const {
+      disabled,
+      onClick,
+      children,
+      className,
+      enableLoading = true,
+      tooltip,
+      loading
+    } = this.props;
+    return /* @__PURE__ */ import_react.default.createElement(
+      import_design.Typography.Link,
+      {
+        className,
+        style: { padding: 0 },
+        disabled: loading || disabled || this.state.disabled,
+        onClick: (_) => {
+          const handle = onClick == null ? void 0 : onClick();
+          if (enableLoading && (handle == null ? void 0 : handle.then)) {
+            this.setState({ loading: true, disabled: true });
+            handle.then(() => {
+              this.setState({ loading: false, disabled: false });
+            });
+          }
+        }
+      },
+      /* @__PURE__ */ import_react.default.createElement(import_design.Tooltip, { placement: "top", title: tooltip }, loading || this.state.disabled ? /* @__PURE__ */ import_react.default.createElement(import_icons.LoadingOutlined, null) : "", " ", children)
+    );
+  }
+};
+ActionLink.__DISPLAY_NAME = "link";
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ActionButton,
+  ActionLink
+});

package/lib/Action/index.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="react" />
+import { ActionButton, ActionLink } from './Item';
+declare const _default: {
+    Group: ({ size, children, dropDownPlacement, shouldVisible, shouldDisabled, enableLoading, moreText, }: import("./Group").GroupProps) => import("react").JSX.Element;
+    Button: typeof ActionButton;
+    Link: typeof ActionLink;
+};
+export default _default;

package/lib/Action/index.js

@@ -0,0 +1,37 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/Action/index.tsx
+var Action_exports = {};
+__export(Action_exports, {
+  default: () => Action_default
+});
+module.exports = __toCommonJS(Action_exports);
+var import_Group = __toESM(require("./Group"));
+var import_Item = require("./Item");
+var Action_default = { Group: import_Group.default, Button: import_Item.ActionButton, Link: import_Item.ActionLink };

package/lib/BackgroundTaskManager/RefreshMan.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+interface IProps {
+    run: () => void;
+    children?: React.ReactNode;
+    rollingFrequency?: number;
+    refreshImmediate?: boolean;
+    timeout?: number;
+    spinning?: boolean;
+}
+export declare const RefreshMan: React.ForwardRefExoticComponent<IProps & React.RefAttributes<any>>;
+export {};

package/lib/BackgroundTaskManager/RefreshMan.js

@@ -0,0 +1,86 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/BackgroundTaskManager/RefreshMan.tsx
+var RefreshMan_exports = {};
+__export(RefreshMan_exports, {
+  RefreshMan: () => RefreshMan
+});
+module.exports = __toCommonJS(RefreshMan_exports);
+var import_ahooks = require("ahooks");
+var import_design = require("@oceanbase/design");
+var import_react = __toESM(require("react"));
+var import_constants = require("./constants");
+var RefreshMan = (0, import_react.forwardRef)((props, ref) => {
+  const {
+    run,
+    timeout = null,
+    refreshImmediate = true,
+    rollingFrequency = import_constants.REFRESH_FREQUENCY.LOW,
+    children,
+    spinning = false
+  } = props;
+  const [interval, setInterval] = (0, import_react.useState)(null);
+  const [refreshManLoading, setRefreshManLoading] = (0, import_react.useState)(false);
+  (0, import_react.useEffect)(() => {
+    return () => setRefreshManLoading(true);
+  }, []);
+  (0, import_ahooks.useInterval)(
+    () => {
+      run();
+    },
+    interval,
+    { immediate: refreshImmediate }
+  );
+  const startLoop = (0, import_react.useCallback)(() => {
+    setInterval(rollingFrequency);
+  }, [setInterval, rollingFrequency]);
+  const stopLoop = (0, import_react.useCallback)(() => {
+    setInterval(null);
+  }, [setInterval]);
+  (0, import_react.useImperativeHandle)(ref, () => ({
+    startLoop,
+    stopLoop
+  }));
+  (0, import_ahooks.useTimeout)(() => {
+    stopLoop();
+  }, timeout);
+  (0, import_react.useEffect)(() => {
+    if (timeout !== 0) {
+      startLoop();
+    }
+    return () => {
+      stopLoop();
+    };
+  }, [startLoop, stopLoop, timeout]);
+  return /* @__PURE__ */ import_react.default.createElement(import_design.Spin, { spinning: spinning && refreshManLoading }, /* @__PURE__ */ import_react.default.createElement(import_react.default.Fragment, null, children));
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RefreshMan
+});

package/lib/BackgroundTaskManager/constants.js

@@ -0,0 +1,38 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/BackgroundTaskManager/constants.ts
+var constants_exports = {};
+__export(constants_exports, {
+  REFRESH_FREQUENCY: () => REFRESH_FREQUENCY
+});
+module.exports = __toCommonJS(constants_exports);
+var REFRESH_FREQUENCY = {
+  // 3分钟
+  LOW: 3 * 60 * 1e3,
+  // 1分钟
+  MEDIUM: 1 * 60 * 1e3,
+  // 30秒
+  HIGH: 0.5 * 60 * 1e3,
+  // 3秒
+  EXTREMELY: 3 * 1e3
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  REFRESH_FREQUENCY
+});

package/lib/BackgroundTaskManager/index.d.ts

@@ -0,0 +1,49 @@
+/// <reference types="react" />
+import type { GlobalConfigProps, NotificationInstance } from 'antd/es/notification/interface';
+export declare enum NotificationApi {
+    success = "success",
+    error = "error",
+    info = "info",
+    warning = "warning",
+    open = "open"
+}
+export declare const BackgroundTaskManagerConstants: {
+    REFRESH_FREQUENCY: {
+        LOW: number;
+        MEDIUM: number;
+        HIGH: number;
+        EXTREMELY: number;
+    };
+    NotificationApi: typeof NotificationApi;
+};
+declare type Namespace = string;
+export declare type TaskMgrID = string | number;
+export declare type ITaskMgrQueue = Record<TaskMgrID, Namespace>;
+interface NotificationAction {
+    api: (params: any) => Promise<any>;
+    successCb: (response: any, id: TaskMgrID) => {
+        type: keyof NotificationInstance;
+        config: GlobalConfigProps;
+    } | null;
+    failedCb?: (response: any, id: TaskMgrID) => {
+        type: keyof NotificationInstance;
+        config: GlobalConfigProps;
+    } | null;
+}
+export declare type ITaskMgrPreset = Record<Namespace, NotificationAction>;
+export interface BackgroundTaskManagerRef {
+    pushQueue: (queue: ITaskMgrQueue) => void;
+    popQueue: (id: TaskMgrID) => void;
+    setQueue: (queue: ITaskMgrQueue) => void;
+    pushPreset: (preset: ITaskMgrPreset) => void;
+    setPreset: (preset: ITaskMgrPreset) => void;
+    fetchPreset: () => ITaskMgrPreset;
+    fetchQueue: () => ITaskMgrQueue;
+    fetchQueueNsById: (id: TaskMgrID) => Namespace;
+}
+interface IProps {
+    rollingFrequency?: number;
+    prefix: Namespace;
+}
+declare const _default: import("react").ForwardRefExoticComponent<IProps & import("react").RefAttributes<BackgroundTaskManagerRef>>;
+export default _default;

package/lib/BackgroundTaskManager/index.js

@@ -0,0 +1,161 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/BackgroundTaskManager/index.tsx
+var BackgroundTaskManager_exports = {};
+__export(BackgroundTaskManager_exports, {
+  BackgroundTaskManagerConstants: () => BackgroundTaskManagerConstants,
+  NotificationApi: () => NotificationApi,
+  default: () => BackgroundTaskManager_default
+});
+module.exports = __toCommonJS(BackgroundTaskManager_exports);
+var import_design = require("@oceanbase/design");
+var import_react = require("react");
+var import_constants = require("./constants");
+var import_RefreshMan = require("./RefreshMan");
+var NotificationApi = /* @__PURE__ */ ((NotificationApi2) => {
+  NotificationApi2["success"] = "success";
+  NotificationApi2["error"] = "error";
+  NotificationApi2["info"] = "info";
+  NotificationApi2["warning"] = "warning";
+  NotificationApi2["open"] = "open";
+  return NotificationApi2;
+})(NotificationApi || {});
+var BackgroundTaskManagerConstants = {
+  REFRESH_FREQUENCY: import_constants.REFRESH_FREQUENCY,
+  NotificationApi
+};
+var BackgroundTaskManager_default = (0, import_react.forwardRef)((props, ref) => {
+  const { rollingFrequency = import_constants.REFRESH_FREQUENCY.EXTREMELY, prefix } = props;
+  const [queue, setQueue] = (0, import_react.useState)({});
+  const [preset, setPreset] = (0, import_react.useState)({});
+  const pushQueue = (0, import_react.useCallback)(
+    (q) => {
+      setQueue({
+        ...queue,
+        ...q
+      });
+    },
+    [queue, setQueue]
+  );
+  const popQueue = (0, import_react.useCallback)(
+    (id) => {
+      delete queue[id];
+      setQueue({ ...queue });
+    },
+    [queue, setQueue]
+  );
+  const taskQueue = (0, import_react.useMemo)(() => {
+    return Object.entries(queue);
+  }, [queue]);
+  const run = (0, import_react.useCallback)(
+    (newPreset) => {
+      if (!!taskQueue.length) {
+        taskQueue == null ? void 0 : taskQueue.forEach(([id, ns]) => {
+          const realPreset = newPreset ?? preset;
+          if (!realPreset[ns]) {
+            console.warn("cannot find preset of namespace: ", ns);
+            return;
+          }
+          const { api, successCb, failedCb } = realPreset[ns];
+          api == null ? void 0 : api({ id }).then((res) => {
+            const { type, config } = successCb(res, id) || {
+              type: null,
+              config: null
+            };
+            if (type) {
+              import_design.notification[type](config);
+            }
+          }).catch((err) => {
+            if (failedCb) {
+              const { type, config } = failedCb(err, id) || {
+                type: null,
+                config: null
+              };
+              if (type) {
+                import_design.notification[type](config);
+              }
+            }
+          });
+        });
+      }
+    },
+    [taskQueue, preset]
+  );
+  const pushPreset = (0, import_react.useCallback)(
+    (p) => {
+      const newPreset = {
+        ...preset,
+        ...p
+      };
+      if (Object.keys(newPreset).length === Object.keys(preset).length)
+        return;
+      setPreset(newPreset);
+      run(newPreset);
+    },
+    [preset, setPreset, run]
+  );
+  const fetchPreset = (0, import_react.useCallback)(() => {
+    return preset;
+  }, [preset]);
+  const fetchQueue = (0, import_react.useCallback)(() => {
+    return queue;
+  }, [queue]);
+  const fetchQueueNsById = (0, import_react.useCallback)(
+    (id) => {
+      return queue[id];
+    },
+    [queue]
+  );
+  (0, import_react.useImperativeHandle)(ref, () => ({
+    pushQueue,
+    popQueue,
+    setQueue,
+    pushPreset,
+    setPreset,
+    fetchPreset,
+    fetchQueue,
+    fetchQueueNsById
+  }));
+  const getLocalStorageIds = (0, import_react.useCallback)(() => {
+    const storedIdsStr = window.localStorage.getItem(prefix) || "[]";
+    const storedQueue = JSON.parse(storedIdsStr);
+    return storedQueue;
+  }, []);
+  (0, import_react.useEffect)(() => {
+    const storedQueue = getLocalStorageIds();
+    if (!!Object.keys(storedQueue).length)
+      setQueue(storedQueue);
+  }, [setQueue, getLocalStorageIds]);
+  (0, import_react.useEffect)(() => {
+    const onUnload = () => {
+      window.localStorage.setItem(prefix, JSON.stringify(queue));
+    };
+    window.addEventListener("beforeunload", onUnload);
+    return () => {
+      window.localStorage.setItem(prefix, JSON.stringify(queue));
+      window.removeEventListener("beforeunload", onUnload);
+    };
+  }, [queue, preset]);
+  return /* @__PURE__ */ React.createElement(React.Fragment, null, !!taskQueue.length && /* @__PURE__ */ React.createElement(import_RefreshMan.RefreshMan, { run, rollingFrequency }));
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BackgroundTaskManagerConstants,
+  NotificationApi
+});

package/lib/BasicLayout/Header.d.ts

@@ -0,0 +1,45 @@
+import React from 'react';
+import type { Locale } from '../interface';
+import type { LocaleWrapperProps } from '../locale/LocaleWrapper';
+import './Header.less';
+export declare type OverlayFunc = () => React.ReactElement;
+export interface HeaderLocale {
+    help: string;
+    welcome: string;
+    viewDocs: string;
+    downloadDocs?: string;
+    about: string;
+    version: string;
+    releaseTime: string;
+    company: string;
+    right: string;
+}
+export interface AppData {
+    shortName?: string;
+    version: string;
+    releaseTime: string;
+}
+export interface HeaderProps extends LocaleWrapperProps {
+    showLabel?: boolean;
+    style?: React.CSSProperties;
+    className?: string;
+    title?: React.ReactNode;
+    extra?: React.ReactNode;
+    pathname?: string;
+    welcomePath?: string;
+    docsPath?: string;
+    pdfPath?: string;
+    iconUrl?: string;
+    logoUrl?: string;
+    simpleLogoUrl?: string;
+    username?: string;
+    userMenu?: React.ReactElement | OverlayFunc;
+    appData?: AppData;
+    locale?: HeaderLocale;
+    showHelp?: boolean;
+    showLocale?: boolean;
+    locales?: Locale[];
+    langs?: Locale[];
+}
+declare const _default: any;
+export default _default;