@oceanbase/design 0.1.0

package/lib/Action/Item.d.ts

@@ -0,0 +1,31 @@
+import React from 'react';
+export interface BaseProps {
+    /** 是否显示 */
+    visible?: boolean;
+    disabled?: boolean;
+    onClick?: () => Promise<void> | void;
+    children?: React.ReactElement | string;
+    type?: 'default' | 'primary';
+    className?: string;
+    enableLoading?: boolean;
+    tooltip?: string;
+    loading?: boolean;
+    danger?: boolean;
+    /** 不会被隐藏 */
+    fixed?: boolean;
+}
+export declare class ActionButton extends React.PureComponent<BaseProps> {
+    static __DISPLAY_NAME: string;
+    state: {
+        loading: boolean;
+    };
+    render(): React.JSX.Element;
+}
+export declare class ActionLink extends React.PureComponent<BaseProps> {
+    static __DISPLAY_NAME: string;
+    state: {
+        loading: boolean;
+        disabled: boolean;
+    };
+    render(): React.JSX.Element;
+}

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_react = __toESM(require("react"));
+var import_antd = require("antd");
+var import_icons = require("@ant-design/icons");
+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_antd.Tooltip, { placement: "top", title: tooltip }, /* @__PURE__ */ import_react.default.createElement(
+      import_antd.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_antd.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_antd.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,39 @@
+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 };
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {});

package/lib/Alert/index.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="react" />
+import type { AlertProps as AntAlertProps } from 'antd/es/alert';
+export interface AlertProps extends AntAlertProps {
+    ghost?: boolean;
+    colored?: boolean;
+}
+declare const Alert: {
+    ({ ghost, colored, prefixCls: customizePrefixCls, className, ...restProps }: AlertProps): JSX.Element;
+    ErrorBoundary: typeof import("antd/es/alert/ErrorBoundary").default;
+    displayName: string;
+};
+export default Alert;

package/lib/Alert/index.js

@@ -0,0 +1,65 @@
+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/Alert/index.tsx
+var Alert_exports = {};
+__export(Alert_exports, {
+  default: () => Alert_default
+});
+module.exports = __toCommonJS(Alert_exports);
+var import_react = __toESM(require("react"));
+var import_antd = require("antd");
+var import_classnames = __toESM(require("classnames"));
+var import_style = __toESM(require("./style"));
+var Alert = ({
+  ghost,
+  colored,
+  prefixCls: customizePrefixCls,
+  className,
+  ...restProps
+}) => {
+  const { getPrefixCls } = (0, import_react.useContext)(import_antd.ConfigProvider.ConfigContext);
+  const prefixCls = getPrefixCls("alert", customizePrefixCls);
+  const { wrapSSR, hashId } = (0, import_style.default)(prefixCls);
+  const alertCls = (0, import_classnames.default)(
+    {
+      [`${prefixCls}-ghost`]: ghost,
+      [`${prefixCls}-colored`]: colored
+    },
+    className,
+    hashId
+  );
+  return wrapSSR(/* @__PURE__ */ import_react.default.createElement(import_antd.Alert, { prefixCls: customizePrefixCls, className: alertCls, ...restProps }));
+};
+Alert.ErrorBoundary = import_antd.Alert.ErrorBoundary;
+if (process.env.NODE_ENV !== "production") {
+  Alert.displayName = import_antd.Alert.displayName;
+}
+var Alert_default = Alert;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {});

package/lib/Alert/style/index.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="react" />
+import type { FullToken, GenerateStyle } from 'antd/es/theme/internal';
+export declare type AlertToken = FullToken<'Alert'>;
+export declare const genAlertStyle: GenerateStyle<AlertToken>;
+declare const _default: (prefixCls: string) => {
+    wrapSSR: (node: import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>>) => JSX.Element;
+    hashId: string;
+};
+export default _default;

package/lib/Alert/style/index.js

@@ -0,0 +1,120 @@
+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/Alert/style/index.ts
+var style_exports = {};
+__export(style_exports, {
+  default: () => style_default,
+  genAlertStyle: () => genAlertStyle
+});
+module.exports = __toCommonJS(style_exports);
+var import_genComponentStyleHook = require("../../_util/genComponentStyleHook");
+var genTypeStyle = (color, token) => {
+  const borderWidth = 8;
+  return {
+    content: '""',
+    width: borderWidth,
+    // 绕 Y 轴旋转 60deg 是为了让圆角有一定的视觉拉伸，以与原先的边框贴合更加紧密
+    transform: "rotateY(60deg)",
+    backgroundColor: color,
+    position: "absolute",
+    height: `calc(100% - ${token.lineWidth}px)`,
+    left: -token.lineWidth - borderWidth / 2 / 2,
+    top: token.lineWidth / 2,
+    borderTopLeftRadius: token.borderRadiusLG,
+    borderBottomLeftRadius: token.borderRadiusLG
+  };
+};
+var genColoredStyle = (color, colorHover, token) => {
+  const { componentCls, iconCls } = token;
+  return {
+    [`${componentCls}-message`]: {
+      color
+    },
+    [`${componentCls}-description`]: {
+      color
+    },
+    [`${componentCls}-close-icon`]: {
+      [`${iconCls}`]: {
+        color,
+        "&:hover": {
+          color: colorHover
+        }
+      },
+      [`${componentCls}-close-text`]: {
+        color,
+        "&:hover": {
+          color: colorHover
+        }
+      }
+    }
+  };
+};
+var genAlertStyle = (token) => {
+  const {
+    componentCls,
+    colorSuccess,
+    colorSuccessHover,
+    colorInfo,
+    colorInfoHover,
+    colorWarning,
+    colorWarningHover,
+    colorError,
+    colorErrorHover
+  } = token;
+  return {
+    [`${componentCls}${componentCls}-with-description`]: {
+      paddingBlock: token.padding,
+      [`${componentCls}-message`]: {
+        marginBottom: token.marginXXS
+      },
+      [`${componentCls}-icon`]: {
+        fontSize: token.fontSizeHeading4,
+        height: token.fontSizeHeading3
+      }
+    },
+    [`${componentCls}:not(${componentCls}-banner):not(${componentCls}-ghost)`]: {
+      [`&${componentCls}-success::before`]: genTypeStyle(colorSuccess, token),
+      [`&${componentCls}-info::before`]: genTypeStyle(colorInfo, token),
+      [`&${componentCls}-warning::before`]: genTypeStyle(colorWarning, token),
+      [`&${componentCls}-error::before`]: genTypeStyle(colorError, token)
+    },
+    [`${componentCls}${componentCls}-ghost`]: {
+      backgroundColor: "transparent",
+      border: "none",
+      padding: 0,
+      borderRadius: 0
+    },
+    [`${componentCls}-colored`]: {
+      [`&${componentCls}-success`]: genColoredStyle(colorSuccess, colorSuccessHover, token),
+      [`&${componentCls}-info`]: genColoredStyle(colorInfo, colorInfoHover, token),
+      [`&${componentCls}-warning`]: genColoredStyle(colorWarning, colorWarningHover, token),
+      [`&${componentCls}-error`]: genColoredStyle(colorError, colorErrorHover, token)
+    }
+  };
+};
+var style_default = (prefixCls) => {
+  const useStyle = (0, import_genComponentStyleHook.genComponentStyleHook)("Alert", (token) => {
+    return [genAlertStyle(token)];
+  });
+  return useStyle(prefixCls);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  genAlertStyle
+});

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_constants = require("./constants");
+var import_react = __toESM(require("react"));
+var import_ahooks = require("ahooks");
+var import_antd = require("antd");
+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_antd.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.d.ts

@@ -0,0 +1,6 @@
+export declare const REFRESH_FREQUENCY: {
+    LOW: number;
+    MEDIUM: number;
+    HIGH: number;
+    EXTREMELY: number;
+};

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 @@
+import React from 'react';
+import type { NotificationInstance, GlobalConfigProps } 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: React.ForwardRefExoticComponent<IProps & React.RefAttributes<BackgroundTaskManagerRef>>;
+export default _default;