@arcblock/ux 2.10.64 → 2.10.66

package/lib/ActionButton/index.d.ts

@@ -1,4 +1,4 @@
-declare const _default: (props: any) => import("react/jsx-runtime").JSX.Element;
+declare const _default: (props: ActionButtonProps) => import("react/jsx-runtime").JSX.Element;
 export default _default;
 /**
  * Action button component

package/lib/Alert/index.d.ts

@@ -1,4 +1,4 @@
-declare const _default: (props: any) => import("react/jsx-runtime").JSX.Element;
+declare const _default: (props: AlertProps) => import("react/jsx-runtime").JSX.Element;
 export default _default;
 /**
  * Alert notification component

package/lib/AnimationWaiter/index.d.ts

@@ -1,27 +1,39 @@
 /**
  * 用于长时间等待的用的动画组件
  * 动画会随着时间的变化而逐步加快播放速度，好适应用户的等待心理
- * @param {Object} animationData lottie json 动画数据
- * @param {Number} size 动画的尺寸，单位px
- * @param {String｜Array} message 动画下方的文字；数组情况下会在一定时间切换文案
- * @param {Number} messageDuration 动画下方的文字为数组时，每个文案的持续时间；默认5000ms
- * @param {Number} messageLoop 动画下方的文字为数组时，文案是否循环播放
- * @param {Array} tips 底部的提示元素
- * @param {Number} tipsDuration 底部提示的切换时间，单位毫秒，默认3000ms
- * @param {Number} speed 动画默认的播放速度
- * @param {Number} maybeDuration 整个动画大概的持续时间，单位毫秒，用于计算增量下的动画速度，默认两分钟(120000ms)
- * @param {Number} increaseSpeed 在 maybeDuration 时间下增加的速度，默认为0（不增加速度）
- * @returns element
+ * @param {object} props - 组件属性
+ * @param {object} [props.animationData] - lottie json 动画数据
+ * @param {number|string} [props.size] - 动画的尺寸，单位px
+ * @param {string|React.ReactNode[]} [props.message] - 动画下方的文字；数组情况下会在一定时间切换文案
+ * @param {number} [props.messageDuration=5000] - 动画下方的文字为数组时，每个文案的持续时间（毫秒）
+ * @param {boolean} [props.messageLoop=true] - 动画下方的文字为数组时，文案是否循环播放
+ * @param {React.ReactNode[]} [props.tips=[]] - 底部的提示元素
+ * @param {number} [props.tipsDuration=5000] - 底部提示的切换时间（毫秒）
+ * @param {number} [props.speed=1] - 动画默认的播放速度
+ * @param {number} [props.maybeDuration=120000] - 整个动画大概的持续时间（毫秒），用于计算增量下的动画速度
+ * @param {number} [props.increaseSpeed=0] - 在 maybeDuration 时间下增加的速度
+ * @returns {JSX.Element}
  */
-declare function AnimationWaiter({ animationData, size, message, messageDuration, messageLoop, tips, tipsDuration, maybeDuration, speed, increaseSpeed, ...rest }: Object): import("react/jsx-runtime").JSX.Element;
+declare function AnimationWaiter({ animationData, size, message, messageDuration, messageLoop, tips, tipsDuration, maybeDuration, speed, increaseSpeed, ...rest }: {
+    animationData?: object | undefined;
+    size?: string | number | undefined;
+    message?: string | import("react").ReactNode[] | undefined;
+    messageDuration?: number | undefined;
+    messageLoop?: boolean | undefined;
+    tips?: import("react").ReactNode[] | undefined;
+    tipsDuration?: number | undefined;
+    speed?: number | undefined;
+    maybeDuration?: number | undefined;
+    increaseSpeed?: number | undefined;
+}): JSX.Element;
 declare namespace AnimationWaiter {
     namespace propTypes {
-        let animationData: PropTypes.Requireable<any>;
+        let animationData: PropTypes.Requireable<object>;
         let size: PropTypes.Requireable<NonNullable<string | number | null | undefined>>;
-        let message: PropTypes.Requireable<any>;
+        let message: PropTypes.Requireable<NonNullable<string | PropTypes.ReactNodeLike[] | null | undefined>>;
         let messageDuration: PropTypes.Requireable<number>;
         let messageLoop: PropTypes.Requireable<boolean>;
-        let tips: PropTypes.Requireable<any[]>;
+        let tips: PropTypes.Requireable<PropTypes.ReactNodeLike[]>;
         let tipsDuration: PropTypes.Requireable<number>;
         let speed: PropTypes.Requireable<number>;
         let maybeDuration: PropTypes.Requireable<number>;

package/lib/AnimationWaiter/index.js

@@ -9,17 +9,18 @@ import { styled } from '../Theme';
 /**
  * 用于长时间等待的用的动画组件
  * 动画会随着时间的变化而逐步加快播放速度，好适应用户的等待心理
- * @param {Object} animationData lottie json 动画数据
- * @param {Number} size 动画的尺寸，单位px
- * @param {String｜Array} message 动画下方的文字；数组情况下会在一定时间切换文案
- * @param {Number} messageDuration 动画下方的文字为数组时，每个文案的持续时间；默认5000ms
- * @param {Number} messageLoop 动画下方的文字为数组时，文案是否循环播放
- * @param {Array} tips 底部的提示元素
- * @param {Number} tipsDuration 底部提示的切换时间，单位毫秒，默认3000ms
- * @param {Number} speed 动画默认的播放速度
- * @param {Number} maybeDuration 整个动画大概的持续时间，单位毫秒，用于计算增量下的动画速度，默认两分钟(120000ms)
- * @param {Number} increaseSpeed 在 maybeDuration 时间下增加的速度，默认为0（不增加速度）
- * @returns element
+ * @param {object} props - 组件属性
+ * @param {object} [props.animationData] - lottie json 动画数据
+ * @param {number|string} [props.size] - 动画的尺寸，单位px
+ * @param {string|React.ReactNode[]} [props.message] - 动画下方的文字；数组情况下会在一定时间切换文案
+ * @param {number} [props.messageDuration=5000] - 动画下方的文字为数组时，每个文案的持续时间（毫秒）
+ * @param {boolean} [props.messageLoop=true] - 动画下方的文字为数组时，文案是否循环播放
+ * @param {React.ReactNode[]} [props.tips=[]] - 底部的提示元素
+ * @param {number} [props.tipsDuration=5000] - 底部提示的切换时间（毫秒）
+ * @param {number} [props.speed=1] - 动画默认的播放速度
+ * @param {number} [props.maybeDuration=120000] - 整个动画大概的持续时间（毫秒），用于计算增量下的动画速度
+ * @param {number} [props.increaseSpeed=0] - 在 maybeDuration 时间下增加的速度
+ * @returns {JSX.Element}
  */
 export default function AnimationWaiter({
   animationData,
@@ -144,12 +145,12 @@ export default function AnimationWaiter({
   });
 }
 AnimationWaiter.propTypes = {
-  animationData: PropTypes.any,
+  animationData: PropTypes.oneOfType([PropTypes.object, PropTypes.oneOf([null])]),
   size: PropTypes.oneOfType([PropTypes.number, PropTypes.string]),
-  message: PropTypes.any,
+  message: PropTypes.oneOfType([PropTypes.string, PropTypes.arrayOf(PropTypes.node)]),
   messageDuration: PropTypes.number,
   messageLoop: PropTypes.bool,
-  tips: PropTypes.array,
+  tips: PropTypes.arrayOf(PropTypes.node),
   tipsDuration: PropTypes.number,
   speed: PropTypes.number,
   maybeDuration: PropTypes.number,

package/lib/Async/index.d.ts

@@ -1,30 +1,63 @@
-export default function LoadAsyncComponent(importComponent: any, key?: string, showProgress?: boolean): {
-    new (props: any): {
-        state: {
-            Component: null;
-            error: null;
-        };
+import * as React from 'react';
+export default function LoadAsyncComponent<T extends React.ComponentType<any>>(importComponent: () => Promise<Record<string, T>>, key?: string, showProgress?: boolean): {
+    new (props: React.ComponentProps<T>): {
         componentDidMount(): void;
-        render(): import("react/jsx-runtime").JSX.Element | null;
+        render(): string | import("react/jsx-runtime").JSX.Element | null;
         context: unknown;
-        setState<K extends string | number | symbol>(state: any, callback?: (() => void) | undefined): void;
+        setState<K extends keyof {
+            Component: React.ComponentType<any> | null;
+            error: string | null;
+        }>(state: {
+            Component: React.ComponentType<any> | null;
+            error: string | null;
+        } | ((prevState: Readonly<{
+            Component: React.ComponentType<any> | null;
+            error: string | null;
+        }>, props: Readonly<React.ComponentProps<T>>) => {
+            Component: React.ComponentType<any> | null;
+            error: string | null;
+        } | Pick<{
+            Component: React.ComponentType<any> | null;
+            error: string | null;
+        }, K> | null) | Pick<{
+            Component: React.ComponentType<any> | null;
+            error: string | null;
+        }, K> | null, callback?: (() => void) | undefined): void;
         forceUpdate(callback?: (() => void) | undefined): void;
-        readonly props: Readonly<any>;
+        readonly props: Readonly<React.ComponentProps<T>>;
+        state: Readonly<{
+            Component: React.ComponentType<any> | null;
+            error: string | null;
+        }>;
         refs: {
             [key: string]: React.ReactInstance;
         };
-        shouldComponentUpdate?(nextProps: Readonly<any>, nextState: Readonly<any>, nextContext: any): boolean;
+        shouldComponentUpdate?(nextProps: Readonly<React.ComponentProps<T>>, nextState: Readonly<{
+            Component: React.ComponentType<any> | null;
+            error: string | null;
+        }>, nextContext: any): boolean;
         componentWillUnmount?(): void;
         componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
-        getSnapshotBeforeUpdate?(prevProps: Readonly<any>, prevState: Readonly<any>): any;
-        componentDidUpdate?(prevProps: Readonly<any>, prevState: Readonly<any>, snapshot?: any): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<React.ComponentProps<T>>, prevState: Readonly<{
+            Component: React.ComponentType<any> | null;
+            error: string | null;
+        }>): any;
+        componentDidUpdate?(prevProps: Readonly<React.ComponentProps<T>>, prevState: Readonly<{
+            Component: React.ComponentType<any> | null;
+            error: string | null;
+        }>, snapshot?: any): void;
         componentWillMount?(): void;
         UNSAFE_componentWillMount?(): void;
-        componentWillReceiveProps?(nextProps: Readonly<any>, nextContext: any): void;
-        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<any>, nextContext: any): void;
-        componentWillUpdate?(nextProps: Readonly<any>, nextState: Readonly<any>, nextContext: any): void;
-        UNSAFE_componentWillUpdate?(nextProps: Readonly<any>, nextState: Readonly<any>, nextContext: any): void;
+        componentWillReceiveProps?(nextProps: Readonly<React.ComponentProps<T>>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<React.ComponentProps<T>>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<React.ComponentProps<T>>, nextState: Readonly<{
+            Component: React.ComponentType<any> | null;
+            error: string | null;
+        }>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<React.ComponentProps<T>>, nextState: Readonly<{
+            Component: React.ComponentType<any> | null;
+            error: string | null;
+        }>, nextContext: any): void;
     };
     contextType?: React.Context<any> | undefined;
 };
-import * as React from 'react';

package/lib/Badge/index.d.ts

@@ -1,4 +1,4 @@
-declare const _default: (props: any) => import("react/jsx-runtime").JSX.Element;
+declare const _default: (props: Omit<BadgeProps, "ref"> & import("react").RefAttributes<HTMLSpanElement>) => import("react/jsx-runtime").JSX.Element;
 export default _default;
 /**
  * Badge component to display notification badge

package/lib/Badge/index.js

@@ -79,7 +79,13 @@ Badge.defaultProps = {
   className: '',
   style: '{}'
 };
-export default withDeprecated(/*#__PURE__*/forwardRef((props, ref) => /*#__PURE__*/_jsx(Badge, {
+export default withDeprecated(/*#__PURE__*/forwardRef(
+/**
+ * @param {BadgeProps} props - Badge组件的属性
+ * @param {React.Ref<HTMLSpanElement>} ref - 转发的ref
+ * @returns {JSX.Element}
+ */
+(props, ref) => /*#__PURE__*/_jsx(Badge, {
   ...props,
   forwardedRef: ref
 })), {

package/lib/BlockletContext/index.d.ts

@@ -1,31 +1,15 @@
-export const BlockletContext: import("react").Context<any>;
-/**
- *
- * @param {object} props
- * @param {string} props.baseUrl baseUrl 为 blocklet origin + blocklet prefix
- * @param {any} props.children
- * @returns
- */
-export function BlockletProvider({ children, baseUrl, loading }: {
+import type { Blocklet } from '../type';
+declare const BlockletContext: import("react").Context<Blocklet | null>;
+declare const Consumer: import("react").Consumer<Blocklet | null>;
+declare function BlockletProvider({ children, baseUrl, loading, }: {
+    children: React.ReactNode;
+    /**
+     * baseUrl 为 blocklet origin + blocklet prefix
+     */
     baseUrl: string;
-    children: any;
+    loading: React.ReactNode;
 }): import("react/jsx-runtime").JSX.Element;
-export namespace BlockletProvider {
-    namespace propTypes {
-        let baseUrl: PropTypes.Requireable<string>;
-        let children: PropTypes.Validator<any>;
-        let loading: PropTypes.Requireable<any>;
-    }
-    namespace defaultProps {
-        let baseUrl_1: string;
-        export { baseUrl_1 as baseUrl };
-        let loading_1: null;
-        export { loading_1 as loading };
-    }
-}
-declare const Consumer: import("react").Consumer<any>;
-export function useBlockletContext(): {
-    blocklet: any;
+declare function useBlockletContext(): {
+    blocklet: Blocklet | null;
 };
-import PropTypes from 'prop-types';
-export { Consumer as BlockletConsumer };
+export { BlockletContext, BlockletProvider, Consumer as BlockletConsumer, useBlockletContext };

package/lib/BlockletContext/index.js

@@ -1,24 +1,15 @@
 import { jsx as _jsx } from "react/jsx-runtime";
-import PropTypes from 'prop-types';
 import { useMemoizedFn, useAsyncEffect } from 'ahooks';
 import { createContext, useContext, useState } from 'react';
-const BlockletContext = /*#__PURE__*/createContext();
+const BlockletContext = /*#__PURE__*/createContext(null);
 const {
   Provider,
   Consumer
 } = BlockletContext;
-
-/**
- *
- * @param {object} props
- * @param {string} props.baseUrl baseUrl 为 blocklet origin + blocklet prefix
- * @param {any} props.children
- * @returns
- */
 function BlockletProvider({
   children,
-  baseUrl,
-  loading
+  baseUrl = '',
+  loading = null
 }) {
   const [blockletData, setBlockletData] = useState(null);
   const getBlockleData = useMemoizedFn(async () => {
@@ -53,13 +44,4 @@ function useBlockletContext() {
     blocklet
   };
 }
-BlockletProvider.propTypes = {
-  baseUrl: PropTypes.string,
-  children: PropTypes.any.isRequired,
-  loading: PropTypes.any
-};
-BlockletProvider.defaultProps = {
-  baseUrl: '',
-  loading: null
-};
 export { BlockletContext, BlockletProvider, Consumer as BlockletConsumer, useBlockletContext };

package/lib/Button/wrap.d.ts

@@ -5,7 +5,8 @@
  *  loading?: boolean,
  *  forwardedRef?: import('react').ForwardedRef<any>,
  *  color?: MuiButtonProps['color'] | 'reverse' | 'did'
- * } & Omit<MuiButtonProps, 'color'>} ButtonProps
+ * }} CustomButtonProps
+ * @typedef { CustomButtonProps & Omit<MuiButtonProps, 'color'> } ButtonProps
  */
 /**
  * @typedef {React.ForwardRefExoticComponent<React.PropsWithoutRef<ButtonProps> & React.RefAttributes<HTMLButtonElement>>} ButtonComponent
@@ -18,10 +19,11 @@
  */
 export default function _default(BaseComponent: import("@mui/material").ExtendButtonBase<import("@mui/material").ButtonTypeMap<{}, "button">>): ButtonComponent;
 export type MuiButtonProps = import("@mui/material").ButtonProps;
-export type ButtonProps = {
+export type CustomButtonProps = {
     rounded?: boolean;
     loading?: boolean;
     forwardedRef?: import("react").ForwardedRef<any>;
     color?: MuiButtonProps["color"] | "reverse" | "did";
-} & Omit<MuiButtonProps, "color">;
+};
+export type ButtonProps = CustomButtonProps & Omit<MuiButtonProps, "color">;
 export type ButtonComponent = React.ForwardRefExoticComponent<React.PropsWithoutRef<ButtonProps> & React.RefAttributes<HTMLButtonElement>>;

package/lib/Button/wrap.js

@@ -36,7 +36,8 @@ const extendedColors = {
  *  loading?: boolean,
  *  forwardedRef?: import('react').ForwardedRef<any>,
  *  color?: MuiButtonProps['color'] | 'reverse' | 'did'
- * } & Omit<MuiButtonProps, 'color'>} ButtonProps
+ * }} CustomButtonProps
+ * @typedef { CustomButtonProps & Omit<MuiButtonProps, 'color'> } ButtonProps
  */
 
 /**

package/lib/ButtonGroup/index.d.ts

@@ -1,2 +1,12 @@
-declare const _default: import("../Button/wrap").ButtonComponent;
-export default _default;
+export default ButtonGroupComponent;
+export type MuiButtonGroupProps = import("@mui/material").ButtonGroupProps;
+export type ButtonGroupProps = import("../Button/wrap").CustomButtonProps & Omit<MuiButtonGroupProps, "color">;
+/**
+ * @typedef {import('@mui/material').ButtonGroupProps} MuiButtonGroupProps
+ * @typedef {import('../Button/wrap').CustomButtonProps & Omit<MuiButtonGroupProps, 'color'>} ButtonGroupProps
+ */
+/**
+ * @deprecated 建议直接使用 @mui/material/ButtonGroup
+ * @type {React.ForwardRefExoticComponent<React.PropsWithoutRef<ButtonGroupProps> & React.RefAttributes<HTMLButtonElement>>}
+ */
+declare const ButtonGroupComponent: React.ForwardRefExoticComponent<React.PropsWithoutRef<ButtonGroupProps> & React.RefAttributes<HTMLButtonElement>>;

package/lib/ButtonGroup/index.js

@@ -1,6 +1,16 @@
 import ButtonGroup from '@mui/material/ButtonGroup';
 import wrap from '../Button/wrap';
 
-// deprecated, ux ButtonGroup 组件废弃, 建议直接使用 @mui/material/ButtonGroup
-// (该定制组件原本目的是调整 ButtonGroup 的圆角, 但最新设计规范已经不再使用较大的圆角, 改为使用 mui button 默认的圆角)
-export default wrap(ButtonGroup);
+/**
+ * @typedef {import('@mui/material').ButtonGroupProps} MuiButtonGroupProps
+ * @typedef {import('../Button/wrap').CustomButtonProps & Omit<MuiButtonGroupProps, 'color'>} ButtonGroupProps
+ */
+
+/**
+ * @deprecated 建议直接使用 @mui/material/ButtonGroup
+ * @type {React.ForwardRefExoticComponent<React.PropsWithoutRef<ButtonGroupProps> & React.RefAttributes<HTMLButtonElement>>}
+ */
+const ButtonGroupComponent = wrap(ButtonGroup);
+
+// 该定制组件原本目的是调整 ButtonGroup 的圆角, 但最新设计规范已经不再使用较大的圆角, 改为使用 mui button 默认的圆角
+export default ButtonGroupComponent;

package/lib/CardSelector/index.d.ts

@@ -1,34 +1,12 @@
-declare function CardSelector({ list, width, height, cardSpace, onSelect, defaultIndex }: {
-    list: any;
-    width: any;
-    height: any;
-    cardSpace: any;
-    onSelect: any;
-    defaultIndex: any;
-}): import("react/jsx-runtime").JSX.Element;
-declare namespace CardSelector {
-    namespace propTypes {
-        let list: PropTypes.Requireable<any[]>;
-        let width: PropTypes.Requireable<number>;
-        let height: PropTypes.Requireable<number>;
-        let cardSpace: PropTypes.Requireable<number>;
-        let onSelect: PropTypes.Requireable<(...args: any[]) => any>;
-        let defaultIndex: PropTypes.Requireable<number>;
-    }
-    namespace defaultProps {
-        let list_1: string;
-        export { list_1 as list };
-        let width_1: number;
-        export { width_1 as width };
-        let height_1: number;
-        export { height_1 as height };
-        let cardSpace_1: number;
-        export { cardSpace_1 as cardSpace };
-        export { noop as onSelect };
-        let defaultIndex_1: number;
-        export { defaultIndex_1 as defaultIndex };
-    }
+export interface CardSelectorProps {
+    list?: Array<{
+        src: string;
+        name: string;
+    }> | Array<(i: number) => React.ReactNode>;
+    width?: number;
+    height?: number;
+    cardSpace?: number;
+    onSelect?: (index: number) => void;
+    defaultIndex?: number;
 }
-export default CardSelector;
-import PropTypes from 'prop-types';
-import noop from 'lodash/noop';
+export default function CardSelector({ list, width, height, cardSpace, onSelect, defaultIndex, }: CardSelectorProps): import("react/jsx-runtime").JSX.Element;

package/lib/CardSelector/index.js

@@ -1,15 +1,15 @@
 import { jsx as _jsx } from "react/jsx-runtime";
+/* eslint-disable no-unused-vars */
 import { useState, useEffect, useRef } from 'react';
 import styled from '@emotion/styled';
-import PropTypes from 'prop-types';
 import noop from 'lodash/noop';
 export default function CardSelector({
-  list,
-  width,
-  height,
-  cardSpace,
-  onSelect,
-  defaultIndex
+  list = [],
+  width = 300,
+  height = 400,
+  cardSpace = 40,
+  onSelect = noop,
+  defaultIndex = 0
 }) {
   const [selectedId, setSelectedId] = useState(0);
   const [translateX, setTranslateX] = useState(0);
@@ -21,16 +21,16 @@ export default function CardSelector({
       return;
     }
     setSelectedId(i);
-
-    // 外部容器大小
-    const outerWidth = outterCon.current.clientWidth;
-    setTranslateX(i * (width + cardSpace) - (outerWidth - width) / 2 + cardSpace * 0.5);
+    if (outterCon.current) {
+      // 外部容器大小
+      const outerWidth = outterCon.current.clientWidth;
+      setTranslateX(i * (width + cardSpace) - (outerWidth - width) / 2 + cardSpace * 0.5);
+    }
     onSelect(i);
   };
   useEffect(() => {
     selectedItem(defaultIndex);
-    const func = e => e.preventDefault();
-    outterCon.current.addEventListener('touchmove', func, {
+    outterCon.current?.addEventListener('touchmove', e => e.preventDefault(), {
       passive: false
     });
     // eslint-disable-next-line react-hooks/exhaustive-deps
@@ -51,7 +51,7 @@ export default function CardSelector({
       }
     }
   };
-  return /*#__PURE__*/_jsx(Contianer, {
+  return /*#__PURE__*/_jsx(Container, {
     ref: outterCon,
     onTouchStart: touchstart,
     onTouchEnd: touchend,
@@ -96,7 +96,7 @@ export default function CardSelector({
     })
   });
 }
-const Contianer = styled.div`
+const Container = styled.div`
   overflow: hidden;
   mask-image: linear-gradient(to left, transparent, black 3%, black 97%, transparent);
   overflow: hidden;
@@ -130,20 +130,4 @@ const Contianer = styled.div`
       }
     }
   }
-`;
-CardSelector.propTypes = {
-  list: PropTypes.array,
-  width: PropTypes.number,
-  height: PropTypes.number,
-  cardSpace: PropTypes.number,
-  onSelect: PropTypes.func,
-  defaultIndex: PropTypes.number
-};
-CardSelector.defaultProps = {
-  list: '',
-  width: 300,
-  height: 400,
-  cardSpace: 40,
-  onSelect: noop,
-  defaultIndex: 0
-};
+`;

package/lib/Center/index.d.ts

@@ -1,22 +1,7 @@
-/**
- * @param {Object} props 属性
- * @param {*} props.children 子元素
- * @param {'screen'|'parent'} [props.relative='screen'] 容器相对尺寸，默认相对屏幕(screen)，可设置为父容器(parent)
- * @returns react component element
- */
-declare function Center({ children, relative }: {
-    children: any;
-    relative?: "screen" | "parent" | undefined;
+export default function Center({ children, relative, }: {
+    children: React.ReactNode;
+    /**
+     * 容器相对尺寸，默认相对屏幕(screen)，可设置为父容器(parent)
+     */
+    relative?: 'screen' | 'parent';
 }): import("react/jsx-runtime").JSX.Element;
-declare namespace Center {
-    namespace propTypes {
-        let children: PropTypes.Validator<any>;
-        let relative: PropTypes.Requireable<string>;
-    }
-    namespace defaultProps {
-        let relative_1: string;
-        export { relative_1 as relative };
-    }
-}
-export default Center;
-import PropTypes from 'prop-types';

package/lib/Center/index.js

@@ -1,16 +1,8 @@
 import { jsx as _jsx } from "react/jsx-runtime";
-import PropTypes from 'prop-types';
 import { styled } from '../Theme';
-
-/**
- * @param {Object} props 属性
- * @param {*} props.children 子元素
- * @param {'screen'|'parent'} [props.relative='screen'] 容器相对尺寸，默认相对屏幕(screen)，可设置为父容器(parent)
- * @returns react component element
- */
 export default function Center({
   children,
-  relative
+  relative = 'screen'
 }) {
   let style = {};
   if (relative === 'parent') {
@@ -32,11 +24,4 @@ const Div = styled('div')`
   display: flex;
   justify-content: center;
   align-items: center;
-`;
-Center.propTypes = {
-  children: PropTypes.any.isRequired,
-  relative: PropTypes.string
-};
-Center.defaultProps = {
-  relative: 'screen'
-};
+`;

package/lib/ClickToCopy/copy-button.d.ts

@@ -1,27 +1,10 @@
-declare function CopyButton({ content, locale, render, showTooltip, ...rest }: {
-    [x: string]: any;
-    content: any;
-    locale: any;
-    render: any;
-    showTooltip: any;
-}): any;
-declare namespace CopyButton {
-    namespace propTypes {
-        let content: PropTypes.Requireable<string>;
-        let locale: PropTypes.Requireable<string>;
-        let render: PropTypes.Requireable<(...args: any[]) => any>;
-        let showTooltip: PropTypes.Requireable<boolean>;
-    }
-    namespace defaultProps {
-        let content_1: string;
-        export { content_1 as content };
-        let locale_1: string;
-        export { locale_1 as locale };
-        let render_1: undefined;
-        export { render_1 as render };
-        let showTooltip_1: boolean;
-        export { showTooltip_1 as showTooltip };
-    }
+export interface CopyButtonProps extends React.HTMLAttributes<HTMLSpanElement> {
+    content?: string;
+    locale?: 'en' | 'zh';
+    render?: (props: {
+        copyButton: React.ReactNode;
+        containerRef: React.RefObject<HTMLElement>;
+    }) => React.ReactNode;
+    showTooltip?: boolean;
 }
-export default CopyButton;
-import PropTypes from 'prop-types';
+export default function CopyButton({ content, locale, render, showTooltip, ...rest }: CopyButtonProps): string | number | boolean | Iterable<import("react").ReactNode> | import("react/jsx-runtime").JSX.Element | null | undefined;

package/lib/ClickToCopy/copy-button.js

@@ -1,15 +1,15 @@
 import { jsx as _jsx } from "react/jsx-runtime";
-import PropTypes from 'prop-types';
+/* eslint-disable no-unused-vars */
 import Tooltip from '@mui/material/Tooltip';
 import { green } from '@mui/material/colors';
 import CopyIcon from '@mui/icons-material/ContentCopy';
 import CheckIcon from '@mui/icons-material/Check';
 import useCopy from './hook';
 export default function CopyButton({
-  content,
-  locale,
+  content = '',
+  locale = 'en',
   render,
-  showTooltip,
+  showTooltip = true,
   ...rest
 }) {
   const {
@@ -57,16 +57,4 @@ export default function CopyButton({
     });
   }
   return copyButton;
-}
-CopyButton.propTypes = {
-  content: PropTypes.string,
-  locale: PropTypes.oneOf(['en', 'zh']),
-  render: PropTypes.func,
-  showTooltip: PropTypes.bool
-};
-CopyButton.defaultProps = {
-  content: '',
-  locale: 'en',
-  render: undefined,
-  showTooltip: true
-};
+}