@oceanbase/ui 0.2.13 → 0.2.15

package/lib/PageContainer/index.d.ts

@@ -1,11 +1,11 @@
 import type { IconComponentProps } from '@oceanbase/icons/es/components/Icon';
 import type { PageContainerProps as AntPageContainerProps, PageHeaderProps as AntPageHeaderProps } from '@ant-design/pro-components';
 import React from 'react';
-export declare type ReloadType = boolean | IconComponentProps | React.ReactNode;
+export type ReloadType = boolean | IconComponentProps | React.ReactNode;
 export interface PageContainerLocale {
     reload?: string;
 }
-export declare type PageHeaderProps = AntPageHeaderProps & {
+export type PageHeaderProps = AntPageHeaderProps & {
     reload?: ReloadType;
 };
 export interface PageContainerProps extends AntPageContainerProps {

package/lib/PageContainer/index.js

@@ -56,7 +56,7 @@ var PageContainer = ({
   const { getPrefixCls } = (0, import_react.useContext)(import_design.ConfigProvider.ConfigContext);
   const rootPrefixCls = getPrefixCls();
   const prefixCls = getPrefixCls("pro-page-container", customizePrefixCls);
-  const { wrapSSR, hashId } = (0, import_style.default)(prefixCls);
+  const { wrapSSR } = (0, import_style.default)(prefixCls);
   const { reload, subTitle, breadcrumb } = header || {};
   const reloadProps = (0, import_lodash.isObject)(reload) && !import_react.default.isValidElement(reload) ? reload : {};
   const reloadCls = (0, import_classnames.default)(
@@ -79,8 +79,7 @@ var PageContainer = ({
     {
       [`${prefixCls}-no-page-header`]: noHasHeader
     },
-    className,
-    hashId
+    className
   );
   return wrapSSR(
     /* @__PURE__ */ import_react.default.createElement(

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

@@ -1,5 +1,9 @@
+/// <reference types="react" />
 import type { PageContainerToken } from '@ant-design/pro-layout/es/components/PageContainer/style';
-import type { GenerateStyle } from 'antd/es/theme/internal';
+import type { GenerateStyle } from '@oceanbase/design/es/theme';
 export declare const genPageContainerStyle: GenerateStyle<PageContainerToken>;
-declare const _default: (prefixCls: string) => any;
+declare const _default: (prefixCls: string) => {
+    wrapSSR: (node: import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>>) => import("react").JSX.Element;
+    hashId: string;
+};
 export default _default;

package/lib/Password/index.d.ts

@@ -1,4 +1,4 @@
-import type { PasswordProps as AntdPasswordProps } from 'antd/es/input';
+import type { PasswordProps as InputPasswordProps } from '@oceanbase/design/es/input';
 import type { LocaleWrapperProps } from '../locale/LocaleWrapper';
 import type { Validator } from './Content';
 export interface PasswordLocale {
@@ -13,7 +13,7 @@ export interface PasswordLocale {
     copyPassword: string;
     andKeepItProperly: string;
 }
-export interface PasswordProps extends LocaleWrapperProps, Omit<AntdPasswordProps, 'onChange'> {
+export interface PasswordProps extends LocaleWrapperProps, Omit<InputPasswordProps, 'onChange'> {
     value?: string;
     onChange?: (value?: string) => void;
     rules?: Validator[];

package/lib/Ranger/QuickPicker.d.ts

@@ -2,7 +2,7 @@ import React from 'react';
 import type { LocaleWrapperProps } from '../locale/LocaleWrapper';
 import type { RangeValue } from './Ranger';
 import type { RangeOption } from './typing';
-export declare type QuickType = 'select' | 'dropdown';
+export type QuickType = 'select' | 'dropdown';
 interface IProps extends LocaleWrapperProps {
     selects: RangeOption[];
     type?: QuickType;
@@ -12,6 +12,7 @@ interface IProps extends LocaleWrapperProps {
     name?: string;
     defaultName?: string;
     isMoment?: boolean;
+    size?: 'small' | 'large' | 'middle';
 }
 declare const _default: (props: IProps) => React.JSX.Element;
 export default _default;

package/lib/Ranger/Ranger.d.ts

@@ -1,9 +1,9 @@
 import type { Dayjs } from 'dayjs';
 import type { Moment } from 'moment';
 import './index.less';
-export declare type RangeName = 'customize' | string;
-export declare type RangeValue = [Moment, Moment] | [Dayjs, Dayjs];
-export declare type RangeDateValue = {
+export type RangeName = 'customize' | string;
+export type RangeValue = [Moment, Moment] | [Dayjs, Dayjs];
+export type RangeDateValue = {
     name: RangeName;
     range: RangeValue;
 };

package/lib/Ranger/index.d.ts

@@ -1,33 +1,2 @@
-import QuickPicker from './QuickPicker';
-import InternalRanger from './Ranger';
-import type { RangeOption } from './typing';
-declare type InternalRangerType = typeof InternalRanger;
-interface RangerType extends InternalRangerType {
-    NEAR_1_MINUTES: RangeOption;
-    NEAR_5_MINUTES: RangeOption;
-    NEAR_10_MINUTES: RangeOption;
-    NEAR_20_MINUTES: RangeOption;
-    NEAR_30_MINUTES: RangeOption;
-    NEAR_1_HOURS: RangeOption;
-    NEAR_2_HOURS: RangeOption;
-    NEAR_3_HOURS: RangeOption;
-    NEAR_6_HOURS: RangeOption;
-    TODAY: RangeOption;
-    YESTERDAY: RangeOption;
-    TOMORROW: RangeOption;
-    THIS_WEEK: RangeOption;
-    LAST_WEEK: RangeOption;
-    NEXT_WEEK: RangeOption;
-    THIS_MONTH: RangeOption;
-    LAST_MONTH: RangeOption;
-    NEXT_MONTH: RangeOption;
-    THIS_QUARTER: RangeOption;
-    LAST_QUARTER: RangeOption;
-    NEXT_QUARTER: RangeOption;
-    THIS_YEAR: RangeOption;
-    LAST_YEAR: RangeOption;
-    NEXT_YEAR: RangeOption;
-    QuickPicker: typeof QuickPicker;
-}
-declare const Ranger: RangerType;
+declare const Ranger: any;
 export default Ranger;

package/lib/SideTip/index.d.ts

@@ -1,10 +1,10 @@
-import type { BadgeProps } from 'antd/es/badge/index';
-import type { TooltipPropsWithTitle } from 'antd/es/tooltip/index';
+import type { BadgeProps } from '@oceanbase/design/es/badge/index';
+import type { TooltipPropsWithTitle } from '@oceanbase/design/es/tooltip/index';
 import React from 'react';
 import type { LocaleWrapperProps } from '../locale/LocaleWrapper';
 import './index.less';
-export declare type SideTipType = 'primary' | 'default';
-export declare type SideTipSize = 'small' | 'default';
+export type SideTipType = 'primary' | 'default';
+export type SideTipSize = 'small' | 'default';
 export interface Position {
     /**
      * @title 距离右侧

package/lib/TagSelect/Group.d.ts

@@ -0,0 +1,23 @@
+import React, { ReactNode } from 'react';
+export type TagSelectValueType = string | number;
+export interface TagSelectOptionType {
+    label: React.ReactNode;
+    value: TagSelectValueType;
+    style?: React.CSSProperties;
+    disabled?: boolean;
+    onChange?: (e: any) => void;
+}
+export interface TagSelectGroupProps {
+    title?: string;
+    children?: ReactNode;
+    disabled?: boolean;
+    className?: string;
+    multiple?: boolean;
+    defaultValue?: TagSelectValueType | Array<TagSelectValueType>;
+    value?: TagSelectValueType | Array<TagSelectValueType>;
+    size?: string;
+    options?: Array<TagSelectOptionType | string | number>;
+    onChange?: (value: Array<TagSelectValueType> | TagSelectValueType) => void;
+}
+declare const Group: React.FC<TagSelectGroupProps>;
+export default Group;

package/lib/TagSelect/Group.js

@@ -0,0 +1,128 @@
+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/TagSelect/Group.tsx
+var Group_exports = {};
+__export(Group_exports, {
+  default: () => Group_default
+});
+module.exports = __toCommonJS(Group_exports);
+var import_classnames = __toESM(require("classnames"));
+var import_util = require("../_util");
+var import_react = __toESM(require("react"));
+var import_TagSelectContext = __toESM(require("./TagSelectContext"));
+var import_Item = __toESM(require("./Item"));
+var import_style = __toESM(require("./style"));
+function toArray(value) {
+  let res = value;
+  if (value === void 0) {
+    res = [];
+  } else if (!Array.isArray(value)) {
+    res = [value];
+  }
+  return res;
+}
+var Group = ({
+  title,
+  multiple,
+  defaultValue,
+  size = "middle",
+  options = [],
+  children,
+  className,
+  ...restProps
+}) => {
+  const prefix = (0, import_util.getPrefix)("tag-select");
+  const { wrapSSR, hashId } = (0, import_style.default)(prefix);
+  const [value, setValue] = (0, import_react.useState)(toArray(defaultValue || restProps.value));
+  const [registeredValues, setRegisteredValues] = import_react.default.useState([]);
+  const registerValue = (val) => {
+    setRegisteredValues((prev) => [...prev, val]);
+  };
+  (0, import_react.useEffect)(() => {
+    if ("value" in restProps) {
+      setValue(toArray(restProps.value));
+    }
+  }, [restProps.value]);
+  const handleValueChange = (v) => {
+    var _a;
+    const registeredValue = value.filter((v1) => registeredValues.includes(v1));
+    const newValue = [...registeredValue];
+    const index = newValue.indexOf(v);
+    const checkedValue = index === -1 ? v : void 0;
+    if (multiple) {
+      if (index === -1) {
+        newValue.push(v);
+      } else {
+        newValue.splice(index, 1);
+      }
+    }
+    if (!("value" in restProps)) {
+      setValue(multiple ? newValue : [checkedValue]);
+    }
+    (_a = restProps.onChange) == null ? void 0 : _a.call(restProps, multiple ? newValue : checkedValue);
+  };
+  const contextValue = {
+    multiple,
+    size,
+    value,
+    disabled: restProps.disabled,
+    onChange: restProps.onChange,
+    registerValue,
+    handleValueChange
+  };
+  const memoOptions = (0, import_react.useMemo)(() => {
+    return options.map((option) => {
+      if (typeof option === "string" || typeof option === "number") {
+        return { label: option, value: option };
+      }
+      return option;
+    });
+  }, [options]);
+  const childrenNode = options.length ? memoOptions.map((option) => /* @__PURE__ */ import_react.default.createElement(
+    import_Item.default,
+    {
+      key: option.value.toString(),
+      disabled: "disabled" in option ? option.disabled : restProps.disabled,
+      value: option.value,
+      onChange: option.onChange,
+      style: option.style,
+      checked: value == null ? void 0 : value.includes(option.value)
+    },
+    option.label
+  )) : children;
+  const groupCls = (0, import_classnames.default)(
+    `${prefix}-container`,
+    hashId,
+    className
+  );
+  return wrapSSR(
+    /* @__PURE__ */ import_react.default.createElement(import_TagSelectContext.default.Provider, { value: contextValue }, /* @__PURE__ */ import_react.default.createElement("div", { className: groupCls }, /* @__PURE__ */ import_react.default.createElement("div", { className: `${prefix}-title` }, title), childrenNode))
+  );
+};
+var Group_default = Group;

package/lib/TagSelect/Item.d.ts

@@ -0,0 +1,17 @@
+import React from 'react';
+import type { TagSelectValueType } from './Group';
+export interface TagSelectItemProps {
+    children?: React.ReactNode;
+    cover?: React.ReactNode;
+    value?: string | number;
+    defaultChecked?: boolean;
+    checked?: boolean;
+    title?: string;
+    disabled?: boolean;
+    style?: React.CSSProperties;
+    multiple?: boolean;
+    handleChange?: (value: TagSelectValueType) => void;
+    onChange?: (e: any) => void;
+}
+declare const Item: React.FC<TagSelectItemProps>;
+export default Item;

package/lib/TagSelect/Item.js

@@ -0,0 +1,108 @@
+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/TagSelect/Item.tsx
+var Item_exports = {};
+__export(Item_exports, {
+  default: () => Item_default
+});
+module.exports = __toCommonJS(Item_exports);
+var import_rc_checkbox = __toESM(require("rc-checkbox"));
+var import_classnames = __toESM(require("classnames"));
+var import_lodash = require("lodash");
+var import_react = __toESM(require("react"));
+var import_style = __toESM(require("./style"));
+var import_util = require("../_util");
+var import_TagSelectContext = __toESM(require("./TagSelectContext"));
+var Item = ({
+  children,
+  handleChange,
+  onChange,
+  cover,
+  ...restProps
+}) => {
+  const [checked, setChecked] = (0, import_react.useState)(restProps.defaultChecked);
+  const coverType = typeof cover;
+  const prefixCls = (0, import_util.getPrefix)("tag-select");
+  const { wrapSSR, hashId } = (0, import_style.default)(prefixCls);
+  const tagSelectGroup = import_react.default.useContext(import_TagSelectContext.default);
+  const wrapperClassName = (0, import_classnames.default)(
+    `${prefixCls}-wrapper`,
+    {
+      [`${prefixCls}-checked`]: checked,
+      multiple: tagSelectGroup.multiple,
+      [`${prefixCls}-${tagSelectGroup.size}`]: tagSelectGroup.size,
+      [`${prefixCls}-disabled`]: tagSelectGroup.disabled || restProps.disabled,
+      [`${prefixCls}-img`]: coverType === "string",
+      [`${prefixCls}-custom`]: coverType !== "string"
+    },
+    hashId
+  );
+  (0, import_react.useEffect)(() => {
+    if ((0, import_lodash.isBoolean)(restProps.checked)) {
+      setChecked(restProps.checked);
+    }
+  }, [restProps.checked]);
+  (0, import_react.useEffect)(() => {
+    var _a;
+    return (_a = tagSelectGroup.registerValue) == null ? void 0 : _a.call(tagSelectGroup, restProps.value);
+  }, [restProps.value]);
+  (0, import_react.useEffect)(() => {
+    var _a;
+    if (((_a = tagSelectGroup.value) == null ? void 0 : _a.includes(restProps.value)) || restProps.checked || restProps.defaultChecked) {
+      setChecked(true);
+    } else {
+      setChecked(false);
+    }
+  }, [tagSelectGroup.value, restProps.value]);
+  const renderCover = () => {
+    return coverType === "string" ? /* @__PURE__ */ import_react.default.createElement("div", { className: `${prefixCls}-cover` }, /* @__PURE__ */ import_react.default.createElement("img", { src: cover, alt: "tagselect" })) : cover;
+  };
+  return wrapSSR(
+    /* @__PURE__ */ import_react.default.createElement("label", { className: wrapperClassName, style: restProps.style }, /* @__PURE__ */ import_react.default.createElement(
+      import_rc_checkbox.default,
+      {
+        ...restProps,
+        checked,
+        prefixCls,
+        onChange: (e) => {
+          if (!("checked" in restProps) && !Object.keys(tagSelectGroup).length) {
+            setChecked(e.target.checked);
+          }
+          if (onChange) {
+            onChange(e);
+          }
+          if (tagSelectGroup.handleValueChange) {
+            tagSelectGroup.handleValueChange(e.target.value);
+          }
+        }
+      }
+    ), cover ? renderCover() : /* @__PURE__ */ import_react.default.createElement("span", null, children))
+  );
+};
+var Item_default = Item;

package/lib/TagSelect/TagSelectContext.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="react" />
+import type { TagSelectValueType } from './Group';
+export type TagSelectContextProps = {
+    multiple?: boolean;
+    size?: string;
+    disabled?: boolean;
+    value?: Array<TagSelectValueType>;
+    onChange?: (value: Array<TagSelectValueType> | TagSelectValueType) => void;
+    registerValue?: (val: TagSelectValueType) => void;
+    handleValueChange?: (val: TagSelectValueType) => void;
+};
+declare const TagSelectContext: import("react").Context<TagSelectContextProps>;
+export default TagSelectContext;

package/lib/TagSelect/TagSelectContext.js

@@ -0,0 +1,27 @@
+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/TagSelect/TagSelectContext.ts
+var TagSelectContext_exports = {};
+__export(TagSelectContext_exports, {
+  default: () => TagSelectContext_default
+});
+module.exports = __toCommonJS(TagSelectContext_exports);
+var import_react = require("react");
+var TagSelectContext = (0, import_react.createContext)({});
+var TagSelectContext_default = TagSelectContext;

package/lib/TagSelect/index.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="react" />
+declare const _default: {
+    Group: import("react").FC<import("./Group").TagSelectGroupProps>;
+    Item: import("react").FC<import("./Item").TagSelectItemProps>;
+};
+export default _default;

package/lib/TagSelect/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/TagSelect/index.tsx
+var TagSelect_exports = {};
+__export(TagSelect_exports, {
+  default: () => TagSelect_default
+});
+module.exports = __toCommonJS(TagSelect_exports);
+var import_Group = __toESM(require("./Group"));
+var import_Item = __toESM(require("./Item"));
+var TagSelect_default = { Group: import_Group.default, Item: import_Item.default };

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

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