@cloudbase/weda-ui 3.5.3 → 3.6.0

package/dist/web/utils/getModelParams.js

@@ -15,6 +15,8 @@ export const convertWhere = (props, supportManyRelated) => {
         where = getParseValue(where);
     }
     catch (e) { }
+    const isEmptyObj = (obj) => Object.keys(obj).length === 0;
+    where = where === null || where === void 0 ? void 0 : where.filter((i) => !isEmptyObj(i));
     return Array.isArray(where) ? where : [];
 };
 /**

package/dist/web/utils/getPageQuery.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 /**
  * 获取 query 参数
  */

package/dist/web/utils/global-context.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+/**
+ * 直接使用React.createContext 的话，因为引用不一致，创建Context跟使用context 不是同一个组件库的时候（插槽/容器自定义库跟现网库混用）会有问题。
+ * @param defaultValue React default value
+ * @param uniqueKey unique id for this context
+ * @returns normal React.Context
+ */
+export declare function createContext<T>(defaultValue: T, uniqueKey: string): React.Context<T>;

package/dist/web/utils/global-context.js

@@ -0,0 +1,22 @@
+import { createContext as ReactCreateContext } from 'react';
+const globalObject = typeof globalThis !== 'undefined'
+    ? globalThis
+    : typeof self !== 'undefined'
+        ? self
+        : window;
+const ns = 'weda-ui-global-context:';
+/**
+ * 直接使用React.createContext 的话，因为引用不一致，创建Context跟使用context 不是同一个组件库的时候（插槽/容器自定义库跟现网库混用）会有问题。
+ * @param defaultValue React default value
+ * @param uniqueKey unique id for this context
+ * @returns normal React.Context
+ */
+export function createContext(defaultValue, uniqueKey) {
+    const sym = Symbol.for(`${ns}${uniqueKey}`);
+    const globalSymbols = Object.getOwnPropertySymbols(globalObject);
+    if (!globalSymbols.includes(sym)) {
+        const context = ReactCreateContext(defaultValue);
+        globalObject[sym] = context;
+    }
+    return globalObject[sym];
+}

package/dist/web/utils/hooks/EnumHoc.js

@@ -1,5 +1,5 @@
 import { jsx as _jsx } from "react/jsx-runtime";
-import { useState, useEffect } from 'react';
+import { useState, useEffect, useMemo } from 'react';
 import { callWedaApi } from '../tcb';
 import { EnumContext } from './context';
 import isObjectEqual from '../isObjectEqual';
@@ -21,7 +21,7 @@ export function EnumHoc(props) {
         };
         fetch();
     }, [fields]);
-    return (_jsx(EnumContext.Provider, { value: { enumOptions, loading, setFields }, children: props.children }));
+    return (_jsx(EnumContext.Provider, { value: useMemo(() => ({ enumOptions, loading, setFields }), [enumOptions, loading, setFields]), children: props.children }));
 }
 /**
  * 获取通用选项集

package/dist/web/utils/hooks/context.d.ts

@@ -9,23 +9,3 @@ export declare const useEnumContext: () => {
     loading: boolean;
     setFields: any;
 };
-export declare const GlobalContext: import("react").Context<{
-    IS_WEDA_IDE: boolean;
-    wedaUserId: any;
-    wedaRelatedRoles: any[];
-    getDataSourceByName: () => void;
-    callWorkflow: () => void;
-    callWedaApi: () => void;
-    showToast: () => void;
-    showError: () => void;
-}>;
-export declare const useGlobalContext: () => {
-    IS_WEDA_IDE: boolean;
-    wedaUserId: any;
-    wedaRelatedRoles: any[];
-    getDataSourceByName: () => void;
-    callWorkflow: () => void;
-    callWedaApi: () => void;
-    showToast: () => void;
-    showError: () => void;
-};

package/dist/web/utils/hooks/context.js

@@ -10,19 +10,3 @@ export const useEnumContext = () => {
     const value = useContext(EnumContext);
     return value;
 };
-// 全局状态
-export const GlobalContext = createContext({
-    IS_WEDA_IDE: false,
-    wedaUserId: null,
-    wedaRelatedRoles: [],
-    getDataSourceByName: () => { },
-    callWorkflow: () => { },
-    callWedaApi: () => { },
-    showToast: () => { },
-    showError: () => { },
-});
-// 全局状态-hook
-export const useGlobalContext = () => {
-    const value = useContext(GlobalContext);
-    return value;
-};

package/dist/web/utils/hooks/use-cloud-id-temp-url.d.ts

@@ -1,3 +1,3 @@
-export declare function useTempUrl(src: string): import("swr/_internal").SWRResponse<any, any, Required<{
+export declare function useTempUrl(src: string): import("swr/_internal").SWRResponse<any, any, {
     dedupingInterval: number;
-}>>;
+}>;

package/dist/web/utils/hooks/use-debounced-callback.d.ts

@@ -0,0 +1,104 @@
+export interface CallOptions {
+    /**
+     * Controls if the function should be invoked on the leading edge of the timeout.
+     */
+    leading?: boolean;
+    /**
+     * Controls if the function should be invoked on the trailing edge of the timeout.
+     */
+    trailing?: boolean;
+}
+export interface Options extends CallOptions {
+    /**
+     * The maximum time the given function is allowed to be delayed before it's invoked.
+     */
+    maxWait?: number;
+}
+export interface ControlFunctions {
+    /**
+     * Cancel pending function invocations
+     */
+    cancel: () => void;
+    /**
+     * Immediately invoke pending function invocations
+     */
+    flush: () => void;
+    /**
+     * Returns `true` if there are any pending function invocations
+     */
+    isPending: () => boolean;
+}
+/**
+ * Subsequent calls to the debounced function `debounced.callback` return the result of the last func invocation.
+ * Note, that if there are no previous invocations it's mean you will get undefined. You should check it in your code properly.
+ */
+export interface DebouncedState<T extends (...args: any) => ReturnType<T>> extends ControlFunctions {
+    (...args: Parameters<T>): ReturnType<T> | undefined;
+}
+/**
+ * Creates a debounced function that delays invoking `func` until after `wait`
+ * milliseconds have elapsed since the last time the debounced function was
+ * invoked, or until the next browser frame is drawn.
+ *
+ * The debounced function comes with a `cancel` method to cancel delayed `func`
+ * invocations and a `flush` method to immediately invoke them.
+ *
+ * Provide `options` to indicate whether `func` should be invoked on the leading
+ * and/or trailing edge of the `wait` timeout. The `func` is invoked with the
+ * last arguments provided to the debounced function.
+ *
+ * Subsequent calls to the debounced function return the result of the last
+ * `func` invocation.
+ *
+ * **Note:** If `leading` and `trailing` options are `true`, `func` is
+ * invoked on the trailing edge of the timeout only if the debounced function
+ * is invoked more than once during the `wait` timeout.
+ *
+ * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred
+ * until the next tick, similar to `setTimeout` with a timeout of `0`.
+ *
+ * If `wait` is omitted in an environment with `requestAnimationFrame`, `func`
+ * invocation will be deferred until the next frame is drawn (typically about
+ * 16ms).
+ *
+ * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)
+ * for details over the differences between `debounce` and `throttle`.
+ *
+ * @category Function
+ * @param {Function} func The function to debounce.
+ * @param {number} [wait=0]
+ *  The number of milliseconds to delay; if omitted, `requestAnimationFrame` is
+ *  used (if available, otherwise it will be setTimeout(...,0)).
+ * @param {Object} [options={}] The options object.
+ *  Controls if `func` should be invoked on the leading edge of the timeout.
+ * @param {boolean} [options.leading=false]
+ *  The maximum time `func` is allowed to be delayed before it's invoked.
+ * @param {number} [options.maxWait]
+ *  Controls if `func` should be invoked the trailing edge of the timeout.
+ * @param {boolean} [options.trailing=true]
+ * @returns {Function} Returns the new debounced function.
+ * @example
+ *
+ * // Avoid costly calculations while the window size is in flux.
+ * const resizeHandler = useDebouncedCallback(calculateLayout, 150);
+ * window.addEventListener('resize', resizeHandler)
+ *
+ * // Invoke `sendMail` when clicked, debouncing subsequent calls.
+ * const clickHandler = useDebouncedCallback(sendMail, 300, {
+ *   leading: true,
+ *   trailing: false,
+ * })
+ * <button onClick={clickHandler}>click me</button>
+ *
+ * // Ensure `batchLog` is invoked once after 1 second of debounced calls.
+ * const debounced = useDebouncedCallback(batchLog, 250, { 'maxWait': 1000 })
+ * const source = new EventSource('/stream')
+ * source.addEventListener('message', debounced)
+ *
+ * // Cancel the trailing debounced invocation.
+ * window.addEventListener('popstate', debounced.cancel)
+ *
+ * // Check for pending invocations.
+ * const status = debounced.pending() ? "Pending..." : "Ready"
+ */
+export default function useDebouncedCallback<T extends (...args: any) => ReturnType<T>>(func: T, wait?: number, options?: Options): DebouncedState<T>;

package/dist/web/utils/hooks/use-debounced-callback.js

@@ -0,0 +1,213 @@
+/* eslint-disable  rulesdir/no-timer */
+import { useRef, useEffect, useMemo } from 'react';
+/**
+ * Creates a debounced function that delays invoking `func` until after `wait`
+ * milliseconds have elapsed since the last time the debounced function was
+ * invoked, or until the next browser frame is drawn.
+ *
+ * The debounced function comes with a `cancel` method to cancel delayed `func`
+ * invocations and a `flush` method to immediately invoke them.
+ *
+ * Provide `options` to indicate whether `func` should be invoked on the leading
+ * and/or trailing edge of the `wait` timeout. The `func` is invoked with the
+ * last arguments provided to the debounced function.
+ *
+ * Subsequent calls to the debounced function return the result of the last
+ * `func` invocation.
+ *
+ * **Note:** If `leading` and `trailing` options are `true`, `func` is
+ * invoked on the trailing edge of the timeout only if the debounced function
+ * is invoked more than once during the `wait` timeout.
+ *
+ * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred
+ * until the next tick, similar to `setTimeout` with a timeout of `0`.
+ *
+ * If `wait` is omitted in an environment with `requestAnimationFrame`, `func`
+ * invocation will be deferred until the next frame is drawn (typically about
+ * 16ms).
+ *
+ * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)
+ * for details over the differences between `debounce` and `throttle`.
+ *
+ * @category Function
+ * @param {Function} func The function to debounce.
+ * @param {number} [wait=0]
+ *  The number of milliseconds to delay; if omitted, `requestAnimationFrame` is
+ *  used (if available, otherwise it will be setTimeout(...,0)).
+ * @param {Object} [options={}] The options object.
+ *  Controls if `func` should be invoked on the leading edge of the timeout.
+ * @param {boolean} [options.leading=false]
+ *  The maximum time `func` is allowed to be delayed before it's invoked.
+ * @param {number} [options.maxWait]
+ *  Controls if `func` should be invoked the trailing edge of the timeout.
+ * @param {boolean} [options.trailing=true]
+ * @returns {Function} Returns the new debounced function.
+ * @example
+ *
+ * // Avoid costly calculations while the window size is in flux.
+ * const resizeHandler = useDebouncedCallback(calculateLayout, 150);
+ * window.addEventListener('resize', resizeHandler)
+ *
+ * // Invoke `sendMail` when clicked, debouncing subsequent calls.
+ * const clickHandler = useDebouncedCallback(sendMail, 300, {
+ *   leading: true,
+ *   trailing: false,
+ * })
+ * <button onClick={clickHandler}>click me</button>
+ *
+ * // Ensure `batchLog` is invoked once after 1 second of debounced calls.
+ * const debounced = useDebouncedCallback(batchLog, 250, { 'maxWait': 1000 })
+ * const source = new EventSource('/stream')
+ * source.addEventListener('message', debounced)
+ *
+ * // Cancel the trailing debounced invocation.
+ * window.addEventListener('popstate', debounced.cancel)
+ *
+ * // Check for pending invocations.
+ * const status = debounced.pending() ? "Pending..." : "Ready"
+ */
+export default function useDebouncedCallback(func, wait, options) {
+    const lastCallTime = useRef(null);
+    const lastInvokeTime = useRef(0);
+    const timerId = useRef(null);
+    const lastArgs = useRef([]);
+    const lastThis = useRef();
+    const result = useRef();
+    const funcRef = useRef(func);
+    const mounted = useRef(true);
+    useEffect(() => {
+        funcRef.current = func;
+    }, [func]);
+    // Bypass `requestAnimationFrame` by explicitly setting `wait=0`.
+    const useRAF = !wait && wait !== 0 && typeof window !== 'undefined';
+    if (typeof func !== 'function') {
+        throw new TypeError('Expected a function');
+    }
+    wait = +wait || 0;
+    options = options || {};
+    const leading = !!options.leading;
+    const trailing = 'trailing' in options ? !!options.trailing : true; // `true` by default
+    const maxing = 'maxWait' in options;
+    const maxWait = maxing ? Math.max(+options.maxWait || 0, wait) : null;
+    useEffect(() => {
+        mounted.current = true;
+        return () => {
+            mounted.current = false;
+        };
+    }, []);
+    // You may have a question, why we have so many code under the useMemo definition.
+    //
+    // This was made as we want to escape from useCallback hell and
+    // not to initialize a number of functions each time useDebouncedCallback is called.
+    //
+    // It means that we have less garbage for our GC calls which improves performance.
+    // Also, it makes this library smaller.
+    //
+    // And the last reason, that the code without lots of useCallback with deps is easier to read.
+    // You have only one place for that.
+    const debounced = useMemo(() => {
+        const invokeFunc = (time) => {
+            const args = lastArgs.current;
+            const thisArg = lastThis.current;
+            lastArgs.current = lastThis.current = null;
+            lastInvokeTime.current = time;
+            return (result.current = funcRef.current.apply(thisArg, args));
+        };
+        const startTimer = (pendingFunc, wait) => {
+            if (useRAF)
+                cancelAnimationFrame(timerId.current);
+            timerId.current = useRAF
+                ? requestAnimationFrame(pendingFunc)
+                : setTimeout(pendingFunc, wait);
+        };
+        const shouldInvoke = (time) => {
+            if (!mounted.current)
+                return false;
+            const timeSinceLastCall = time - lastCallTime.current;
+            const timeSinceLastInvoke = time - lastInvokeTime.current;
+            // Either this is the first call, activity has stopped and we're at the
+            // trailing edge, the system time has gone backwards and we're treating
+            // it as the trailing edge, or we've hit the `maxWait` limit.
+            return (!lastCallTime.current ||
+                timeSinceLastCall >= wait ||
+                timeSinceLastCall < 0 ||
+                (maxing && timeSinceLastInvoke >= maxWait));
+        };
+        const trailingEdge = (time) => {
+            timerId.current = null;
+            // Only invoke if we have `lastArgs` which means `func` has been
+            // debounced at least once.
+            if (trailing && lastArgs.current) {
+                return invokeFunc(time);
+            }
+            lastArgs.current = lastThis.current = null;
+            return result.current;
+        };
+        const timerExpired = () => {
+            const time = Date.now();
+            if (shouldInvoke(time)) {
+                return trailingEdge(time);
+            }
+            // https://github.com/xnimorz/use-debounce/issues/97
+            if (!mounted.current) {
+                return;
+            }
+            // Remaining wait calculation
+            const timeSinceLastCall = time - lastCallTime.current;
+            const timeSinceLastInvoke = time - lastInvokeTime.current;
+            const timeWaiting = wait - timeSinceLastCall;
+            const remainingWait = maxing
+                ? Math.min(timeWaiting, maxWait - timeSinceLastInvoke)
+                : timeWaiting;
+            // Restart the timer
+            startTimer(timerExpired, remainingWait);
+        };
+        const func = (...args) => {
+            const time = Date.now();
+            const isInvoking = shouldInvoke(time);
+            lastArgs.current = args;
+            lastThis.current = this;
+            lastCallTime.current = time;
+            if (isInvoking) {
+                if (!timerId.current && mounted.current) {
+                    // Reset any `maxWait` timer.
+                    lastInvokeTime.current = lastCallTime.current;
+                    // Start the timer for the trailing edge.
+                    startTimer(timerExpired, wait);
+                    // Invoke the leading edge.
+                    return leading ? invokeFunc(lastCallTime.current) : result.current;
+                }
+                if (maxing) {
+                    // Handle invocations in a tight loop.
+                    startTimer(timerExpired, wait);
+                    return invokeFunc(lastCallTime.current);
+                }
+            }
+            if (!timerId.current) {
+                startTimer(timerExpired, wait);
+            }
+            return result.current;
+        };
+        func.cancel = () => {
+            if (timerId.current) {
+                useRAF
+                    ? cancelAnimationFrame(timerId.current)
+                    : clearTimeout(timerId.current);
+            }
+            lastInvokeTime.current = 0;
+            lastArgs.current =
+                lastCallTime.current =
+                    lastThis.current =
+                        timerId.current =
+                            null;
+        };
+        func.isPending = () => {
+            return !!timerId.current;
+        };
+        func.flush = () => {
+            return !timerId.current ? result.current : trailingEdge(Date.now());
+        };
+        return func;
+    }, [leading, maxing, wait, maxWait, trailing, useRAF]);
+    return debounced;
+}

package/dist/web/utils/hooks/use-delay-events.d.ts

@@ -0,0 +1,8 @@
+/**
+ * 利用 useEffect 延时执行方法，目的是先挂载 widget api
+ */
+export declare const useDelayFn: (cb: any) => (...rest: any[]) => void;
+/**
+ * 延时执行 events 中某些方法，如 events.change
+ */
+export declare const useDelayEvents: (events: any) => any;

package/dist/web/utils/hooks/use-delay-events.js

@@ -0,0 +1,31 @@
+import { useState, useEffect, useCallback, useRef, useMemo } from 'react';
+import { useSyncedRef } from '@react-hookz/web';
+/**
+ * 利用 useEffect 延时执行方法，目的是先挂载 widget api
+ */
+export const useDelayFn = (cb) => {
+    const cbRef = useSyncedRef(cb);
+    const paramsRef = useRef([]);
+    const triggerRef = useRef(false);
+    const [count, setCount] = useState(0);
+    useEffect(() => {
+        if (triggerRef.current &&
+            Object.prototype.toString.call(cbRef.current) === '[object Function]') {
+            cbRef.current(...paramsRef.current);
+        }
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [count]);
+    const fn = useCallback((...rest) => {
+        setCount((d) => d + 1);
+        triggerRef.current = true;
+        paramsRef.current = rest;
+    }, []);
+    return fn;
+};
+/**
+ * 延时执行 events 中某些方法，如 events.change
+ */
+export const useDelayEvents = (events) => {
+    const eventsChange = useDelayFn(events === null || events === void 0 ? void 0 : events.change);
+    return useMemo(() => ({ ...events, change: eventsChange }), [events, eventsChange]);
+};

package/dist/web/utils/hooks/use-selected.d.ts

@@ -0,0 +1,16 @@
+type SelectedProps = {
+    range: any;
+    value: any;
+    multiple?: boolean;
+};
+type SelectedResult = {
+    options: any[];
+    selectedItem: any;
+    selectedLabel: any;
+};
+/**
+ * 下拉单选/下拉多选/标签选择等，根据 value 和 options 计算出对应的 item / label
+ * 返回 null：value与单选/多选类型不一致，或者 value 为 null 时
+ */
+export declare const useSelected: (props: SelectedProps) => SelectedResult;
+export {};

package/dist/web/utils/hooks/use-selected.js

@@ -0,0 +1,38 @@
+import { useMemo } from 'react';
+import { arrayToMap, isObjHasProp } from '../tool';
+/**
+ * 下拉单选/下拉多选/标签选择等，根据 value 和 options 计算出对应的 item / label
+ * 返回 null：value与单选/多选类型不一致，或者 value 为 null 时
+ */
+export const useSelected = (props) => {
+    const { range, value, multiple } = props;
+    const [options, itemMap] = useMemo(() => {
+        const list = Array.isArray(range) ? range : [];
+        const r = list.filter((item) => isObjHasProp(item, 'value'));
+        const rm = arrayToMap(r, 'value');
+        return [r, rm];
+    }, [range]);
+    const [selectedItem, selectedLabel] = useMemo(() => {
+        var _a;
+        let selectedItem, selectedLabel;
+        if (value == null) {
+            selectedItem = selectedLabel = null;
+        }
+        else {
+            if (multiple) {
+                selectedItem = Array.isArray(value)
+                    ? value.map((d) => itemMap.get(d))
+                    : null;
+                selectedLabel = Array.isArray(value)
+                    ? value.map((d) => { var _a; return (_a = itemMap.get(d)) === null || _a === void 0 ? void 0 : _a.label; })
+                    : null;
+            }
+            else {
+                selectedItem = itemMap.get(value);
+                selectedLabel = (_a = itemMap.get(value)) === null || _a === void 0 ? void 0 : _a.label;
+            }
+        }
+        return [selectedItem, selectedLabel];
+    }, [itemMap, value, multiple]);
+    return { options, selectedItem, selectedLabel };
+};

package/dist/web/utils/hooks/useCanPreview.d.ts

@@ -0,0 +1 @@
+export declare function useCanPreview(): any;

package/dist/web/utils/hooks/useCanPreview.js

@@ -0,0 +1,20 @@
+import * as React from 'react';
+// eslint-disable-next-line rulesdir/no-phantom-deps
+import { autorun } from 'mobx';
+// 小程序组件能否在编辑器中渲染
+export function useCanPreview() {
+    var _a, _b;
+    const [editorPlatforms, setEditorPlatforms] = React.useState([]);
+    const dispose = React.useMemo(() => {
+        return autorun(() => {
+            var _a, _b;
+            setEditorPlatforms((_b = (_a = window === null || window === void 0 ? void 0 : window.$w) === null || _a === void 0 ? void 0 : _a.wedaContext) === null || _b === void 0 ? void 0 : _b.editorPlatforms);
+        });
+    }, []);
+    React.useEffect(() => {
+        return () => {
+            dispose();
+        };
+    }, [dispose]);
+    return (((_b = (_a = window.$w) === null || _a === void 0 ? void 0 : _a.wedaContext) === null || _b === void 0 ? void 0 : _b.isEditorMode) || (editorPlatforms === null || editorPlatforms === void 0 ? void 0 : editorPlatforms.includes('MP')));
+}

package/dist/web/utils/hooks/useDataSource.d.ts

@@ -1,3 +1,3 @@
-export declare const useDataSource: (dbName: string, GetColumnAuth?: boolean) => import("swr/_internal").SWRResponse<any, any, Required<{
+export declare const useDataSource: (dbName: string, GetColumnAuth?: boolean, swrMode?: boolean) => import("swr/_internal").SWRResponse<any, any, {
     onError(err: any): void;
-}>>;
+}>;

package/dist/web/utils/hooks/useFormLegacy.d.ts

@@ -1,9 +1,20 @@
+import { convertMoment } from '../moment';
 import type { IDate, IOption } from '../../components/wd-date/elements/interface';
-import { FormInputTraitParams } from '../../components/form-input-hooks';
 export declare const MAX_TIME = 86399999;
+export declare const SELECT_ICON_H5 = "chevronright";
+export declare const SELECT_ICON_PC = "chevrondown";
+export declare const ICON_SIZE_MAP: {
+    lg: string;
+    md: string;
+    sm: string;
+};
+export declare const WEEKS: string[];
 export declare const useSize: (props: any) => any;
-export declare const useIconSize: (props: any) => any;
-export declare const useBlock: (props: any) => any;
+export declare const convertIconSize: (s: any, map?: {
+    lg: string;
+    md: string;
+    sm: string;
+}) => any;
 export declare const useLayout: (props: any) => any;
 export declare const useLabelAlign: (props: any) => any;
 export declare const useRules: (props: any) => any;
@@ -11,7 +22,7 @@ export declare const useStatus: (props: any) => {
     disabled: boolean;
     readOnly: boolean;
 };
-export declare const converValueFix: (_inputValue: any, _before?: any, _after?: any, type?: any, isUnionValue?: any) => any;
+export declare const converValueFix: (_inputValue: any, _before?: any, _after?: any, type?: any, isUnionValue?: any, isConvert?: boolean) => any;
 export declare const converInputValue: (_value: any, _before: any, _after: any, isUnionValue: any) => string;
 export declare const convertMethodParam: (val: any) => any;
 export declare const useStringProp: (props: any) => {
@@ -23,19 +34,29 @@ export declare const useStringProp: (props: any) => {
 export declare const convertPx: (val: any, unit?: string) => string;
 /** 日期时间组件相关方法 start */
 export declare const useDateFormat: (props: any) => any;
-export declare const convertMoment: (val: any) => any;
-export declare const convertYearMonthToWeeks: (year: any, month: any, range?: any[]) => {
+export { convertMoment };
+export declare const getStartMoment: (mode?: string, value?: any, setDefault?: boolean) => any;
+export declare const getEndMoment: (mode?: string, value?: any) => any;
+export declare const getValueByAddYear: (num?: number) => number;
+export interface IWeekItem {
     day: any;
-    disabled?: boolean;
     year: any;
     month: any;
-}[][];
+    disabled?: boolean;
+    isPre?: boolean;
+    isNext?: boolean;
+    marked?: boolean;
+}
+export declare const convertYearMonthToWeeks: (year: any, month: any, range?: any[], config?: {
+    isDynamic?: boolean;
+    isPreNext?: boolean;
+}) => IWeekItem[][];
 export declare const getFullDay: (v: any) => string;
 export declare const convertDateItemToValue: (param: IDate, fixMonth?: boolean) => any;
 export declare const convertValueToDateItem: (v: any) => IDate;
 export declare const getYMD: (item: IDate) => string;
 export declare const getExistValue: (value: any, options: IOption[]) => any;
-export declare const convertYears: (currentYear: any, page?: number) => {
+export declare const convertYears: (currentYear: any, page?: number, row?: number, col?: number) => {
     years: number[][];
     yearStart: number;
     yearEnd: number;
@@ -43,26 +64,15 @@ export declare const convertYears: (currentYear: any, page?: number) => {
 export declare const useDateValue: (props: any) => any;
 export declare const isDateInRange: (_value: any, _start?: any, _end?: any, _format?: any) => (string | boolean)[];
 export declare const convertTimeValue: (value: any) => any;
-export declare const convertTimeToMoment: (value: any) => import("moment").Moment;
+export declare const convertTimeToMoment: (value: any) => any;
+export declare const convertTimePickerValue: (_value: any, _start?: any, _end?: any, mode?: any) => any;
 /** 日期时间组件相关方法 end */
 /** 组件 API start */
-export declare const useFormItemCommonTrait: (props: FormInputTraitParams<any>) => {
-    visible: boolean;
-    onChange: (value: unknown) => void;
-    value: unknown;
-    disabled: boolean;
-    readOnly: boolean;
-    required: boolean;
-    name: string;
-    validateState: "success" | "error" | "warn";
-    validateErrorMsg: string;
-    layout: "vertical" | "horizontal";
-    initValidate: (validateState: any, validateErrorMsg: any) => void;
-};
 export declare const useHandleClear: (props: {
     onChange?: any;
     clearable?: boolean;
     disabled?: boolean;
+    readOnly?: boolean;
     value?: any;
 }) => {
     onMouseEnter: () => void;
@@ -70,3 +80,5 @@ export declare const useHandleClear: (props: {
     onClear: () => any;
     hasClearIcon: boolean;
 };
+export declare const convertAcceptTypes: (_acceptTypes?: string) => any[];
+export declare const useFixedIcon: (props: any) => any[];