3h1-ui 3.0.0-next.25 → 3.0.0-next.251

package/lib/ui/src/Modal/src/components/ModalWrapper.vue.d.ts

@@ -0,0 +1,97 @@
+declare const _sfc_main: import("vue").DefineComponent<{
+    loading: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    useWrapper: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    modalHeaderHeight: {
+        type: NumberConstructor;
+        default: number;
+    };
+    modalFooterHeight: {
+        type: NumberConstructor;
+        default: number;
+    };
+    minHeight: {
+        type: NumberConstructor;
+        default: number;
+    };
+    height: {
+        type: NumberConstructor;
+    };
+    footerOffset: {
+        type: NumberConstructor;
+        default: number;
+    };
+    visible: {
+        type: BooleanConstructor;
+    };
+    fullScreen: {
+        type: BooleanConstructor;
+    };
+    loadingTip: {
+        type: StringConstructor;
+    };
+    size: {
+        type: PropType<"small" | "default" | "large">;
+        default: string;
+    };
+}, any, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("height-change" | "ext-height")[], "height-change" | "ext-height", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    loading: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    useWrapper: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    modalHeaderHeight: {
+        type: NumberConstructor;
+        default: number;
+    };
+    modalFooterHeight: {
+        type: NumberConstructor;
+        default: number;
+    };
+    minHeight: {
+        type: NumberConstructor;
+        default: number;
+    };
+    height: {
+        type: NumberConstructor;
+    };
+    footerOffset: {
+        type: NumberConstructor;
+        default: number;
+    };
+    visible: {
+        type: BooleanConstructor;
+    };
+    fullScreen: {
+        type: BooleanConstructor;
+    };
+    loadingTip: {
+        type: StringConstructor;
+    };
+    size: {
+        type: PropType<"small" | "default" | "large">;
+        default: string;
+    };
+}>> & {
+    "onHeight-change"?: (...args: any[]) => any;
+    "onExt-height"?: (...args: any[]) => any;
+}, {
+    size: "small" | "default" | "large";
+    loading: boolean;
+    useWrapper: boolean;
+    footerOffset: number;
+    modalHeaderHeight: number;
+    modalFooterHeight: number;
+    minHeight: number;
+    visible: boolean;
+    fullScreen: boolean;
+}, {}>;
+export default _sfc_main;

package/lib/ui/src/Modal/src/components/ScrollContainer.vue.d.ts

@@ -0,0 +1,2 @@
+declare const _sfc_main: any;
+export default _sfc_main;

package/lib/ui/src/Modal/src/hooks/useAttrs.d.ts

@@ -0,0 +1,9 @@
+import type { Ref } from 'vue';
+interface Params {
+    excludeListeners?: boolean;
+    excludeKeys?: string[];
+    excludeDefaultKeys?: boolean;
+}
+export declare function entries<T>(obj: Recordable<T>): [string, T][];
+export declare function useAttrs(params?: Params): Ref<Recordable> | {};
+export {};

package/lib/ui/src/Modal/src/hooks/useContext.d.ts

@@ -0,0 +1,10 @@
+import { InjectionKey } from 'vue';
+export interface CreateContextOptions {
+    readonly?: boolean;
+    createProvider?: boolean;
+    native?: boolean;
+}
+export declare function createContext<T>(context: any, key?: InjectionKey<T>, options?: CreateContextOptions): {
+    state: any;
+};
+export declare function useContext<T>(key: InjectionKey<T>, native?: boolean): T;

package/lib/ui/src/Modal/src/hooks/useI18n.d.ts

@@ -0,0 +1,15 @@
+import { createI18n } from 'vue-i18n';
+export declare let i18n: ReturnType<typeof createI18n>;
+type I18nGlobalTranslation = {
+    (key: string): string;
+    (key: string, locale: string): string;
+    (key: string, locale: string, list: unknown[]): string;
+    (key: string, locale: string, named: Record<string, unknown>): string;
+    (key: string, list: unknown[]): string;
+    (key: string, named: Record<string, unknown>): string;
+};
+export declare function useI18n(namespace?: string): {
+    t: I18nGlobalTranslation;
+};
+export declare const t: (key: string) => string;
+export {};

package/lib/ui/src/Modal/src/hooks/useModal.d.ts

@@ -0,0 +1,6 @@
+import type { UseModalReturnType, UseModalInnerReturnType } from '../typing';
+/**
+ * @description: Applicable to independent modal and call outside
+ */
+export declare function useModal(): UseModalReturnType;
+export declare const useModalInner: (callbackFn?: Fn) => UseModalInnerReturnType;

package/lib/ui/src/Modal/src/hooks/useModalContext.d.ts

@@ -0,0 +1,7 @@
+export interface ModalContextProps {
+    redoModalHeight: () => void;
+}
+export declare function createModalContext(context: ModalContextProps): {
+    state: any;
+};
+export declare function useModalContext(): ModalContextProps;

package/lib/ui/src/Modal/src/hooks/useModalDrag.d.ts

@@ -0,0 +1,7 @@
+import { Ref } from 'vue';
+export interface UseModalDragMoveContext {
+    draggable: Ref<boolean>;
+    destroyOnClose: Ref<boolean | undefined> | undefined;
+    visible: Ref<boolean>;
+}
+export declare function useModalDragMove(context: UseModalDragMoveContext): void;

package/lib/ui/src/Modal/src/hooks/useModalFullScreen.d.ts

@@ -0,0 +1,11 @@
+import { Ref } from 'vue';
+export interface UseFullScreenContext {
+    wrapClassName: Ref<string | undefined>;
+    modalWrapperRef: Ref<ComponentRef>;
+    extHeightRef: Ref<number>;
+}
+export declare function useFullScreen(context: UseFullScreenContext): {
+    getWrapClassName: import("vue").ComputedRef<string>;
+    handleFullScreen: (e: Event) => void;
+    fullScreenRef: Ref<boolean>;
+};

package/lib/ui/src/Modal/src/hooks/useScrollTo.d.ts

@@ -0,0 +1,10 @@
+export interface ScrollToParams {
+    el: any;
+    to: number;
+    duration?: number;
+    callback?: () => any;
+}
+export declare function useScrollTo({ el, to, duration, callback }: ScrollToParams): {
+    start: () => void;
+    stop: () => void;
+};

package/lib/ui/src/Modal/src/hooks/useTimeout.d.ts

@@ -0,0 +1,10 @@
+export declare function useTimeoutFn(handle: Fn<any>, wait: number, native?: boolean): {
+    readyRef: import("vue").Ref<boolean>;
+    stop: () => void;
+    start: () => void;
+};
+export declare function useTimeoutRef(wait: number): {
+    readyRef: import("vue").Ref<boolean>;
+    stop: () => void;
+    start: () => void;
+};

package/lib/ui/src/Modal/src/hooks/useWindowSizeFn.d.ts

@@ -0,0 +1,7 @@
+interface WindowSizeOptions {
+    once?: boolean;
+    immediate?: boolean;
+    listenerOptions?: AddEventListenerOptions | boolean;
+}
+export declare function useWindowSizeFn<T>(fn: Fn<T>, wait?: number, options?: WindowSizeOptions): (() => void)[];
+export {};

package/lib/ui/src/Modal/src/props.d.ts

@@ -0,0 +1,171 @@
+import type { PropType, CSSProperties } from 'vue';
+import type { ModalWrapperProps } from './typing';
+export declare const modalProps: {
+    visible: {
+        type: BooleanConstructor;
+    };
+    scrollTop: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    height: {
+        type: NumberConstructor;
+    };
+    minHeight: {
+        type: NumberConstructor;
+    };
+    draggable: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    centered: {
+        type: BooleanConstructor;
+    };
+    cancelText: {
+        type: StringConstructor;
+        default: string;
+    };
+    okText: {
+        type: StringConstructor;
+        default: string;
+    };
+    closeFunc: PropType<() => Promise<boolean>>;
+};
+export declare const basicProps: {
+    defaultFullscreen: {
+        type: BooleanConstructor;
+    };
+    canFullscreen: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    wrapperFooterOffset: {
+        type: NumberConstructor;
+        default: number;
+    };
+    helpMessage: ((new (...args: any[]) => string | string[]) | (() => string | string[])) | ((new (...args: any[]) => string | string[]) | (() => string | string[]))[];
+    useWrapper: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    loading: {
+        type: BooleanConstructor;
+    };
+    loadingTip: {
+        type: StringConstructor;
+    };
+    showCancelBtn: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    showOkBtn: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    wrapperProps: ((new (...args: any[]) => Partial<ModalWrapperProps>) | (() => Partial<ModalWrapperProps>)) | ((new (...args: any[]) => Partial<ModalWrapperProps>) | (() => Partial<ModalWrapperProps>))[];
+    afterClose: ((new (...args: any[]) => () => Promise<VueNode>) | (() => () => Promise<VueNode>) | {
+        (): () => Promise<VueNode>;
+        new (): any;
+        readonly prototype: any;
+    }) | ((new (...args: any[]) => () => Promise<VueNode>) | (() => () => Promise<VueNode>) | {
+        (): () => Promise<VueNode>;
+        new (): any;
+        readonly prototype: any;
+    })[];
+    bodyStyle: ((new (...args: any[]) => CSSProperties) | (() => CSSProperties)) | ((new (...args: any[]) => CSSProperties) | (() => CSSProperties))[];
+    closable: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    closeIcon: ((new (...args: any[]) => VueNode & {}) | (() => VueNode)) | ((new (...args: any[]) => VueNode & {}) | (() => VueNode))[];
+    confirmLoading: {
+        type: BooleanConstructor;
+    };
+    destroyOnClose: {
+        type: BooleanConstructor;
+    };
+    footer: ((new (...args: any[]) => VueNode & {}) | (() => VueNode)) | ((new (...args: any[]) => VueNode & {}) | (() => VueNode))[];
+    getContainer: ((new (...args: any[]) => () => any) | (() => () => any) | {
+        (): () => any;
+        new (): any;
+        readonly prototype: any;
+    }) | ((new (...args: any[]) => () => any) | (() => () => any) | {
+        (): () => any;
+        new (): any;
+        readonly prototype: any;
+    })[];
+    mask: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    maskClosable: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    keyboard: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    maskStyle: ((new (...args: any[]) => CSSProperties) | (() => CSSProperties)) | ((new (...args: any[]) => CSSProperties) | (() => CSSProperties))[];
+    okType: {
+        type: StringConstructor;
+        default: string;
+    };
+    okButtonProps: {
+        type: ((new (...args: any[]) => Recordable<any>) | (() => Recordable<any>)) | ((new (...args: any[]) => Recordable<any>) | (() => Recordable<any>))[];
+    };
+    cancelButtonProps: {
+        type: ((new (...args: any[]) => Recordable<any>) | (() => Recordable<any>)) | ((new (...args: any[]) => Recordable<any>) | (() => Recordable<any>))[];
+    };
+    title: {
+        type: StringConstructor;
+    };
+    visible: {
+        type: BooleanConstructor;
+    };
+    width: ((new (...args: any[]) => string | number) | (() => string | number)) | ((new (...args: any[]) => string | number) | (() => string | number))[];
+    wrapClassName: {
+        type: StringConstructor;
+    };
+    zIndex: {
+        type: NumberConstructor;
+    };
+    size: {
+        type: ((new (...args: any[]) => "small" | "default" | "large") | (() => "small" | "default" | "large")) | ((new (...args: any[]) => "small" | "default" | "large") | (() => "small" | "default" | "large"))[];
+        default: string;
+    };
+    scrollTop: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    height: {
+        type: NumberConstructor;
+    };
+    minHeight: {
+        type: NumberConstructor;
+    };
+    draggable: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    centered: {
+        type: BooleanConstructor;
+    };
+    cancelText: {
+        type: StringConstructor;
+        default: string;
+    };
+    okText: {
+        type: StringConstructor;
+        default: string;
+    };
+    closeFunc: ((new (...args: any[]) => () => Promise<boolean>) | (() => () => Promise<boolean>) | {
+        (): () => Promise<boolean>;
+        new (): any;
+        readonly prototype: any;
+    }) | ((new (...args: any[]) => () => Promise<boolean>) | (() => () => Promise<boolean>) | {
+        (): () => Promise<boolean>;
+        new (): any;
+        readonly prototype: any;
+    })[];
+};

package/lib/ui/src/Modal/src/typing.d.ts

@@ -0,0 +1,174 @@
+import type { ButtonProps } from 'ant-design-vue/lib/button/buttonTypes';
+import type { CSSProperties, VNodeChild, ComputedRef } from 'vue';
+/**
+ * @description: 弹窗对外暴露的方法
+ */
+export interface ModalMethods {
+    setModalProps: (props: Partial<ModalProps>) => void;
+    emitVisible?: (visible: boolean, uid: number) => void;
+    redoModalHeight?: () => void;
+}
+export type RegisterFn = (modalMethods: ModalMethods, uuid?: string) => void;
+export interface ReturnMethods extends ModalMethods {
+    openModal: <T = any>(props?: boolean, data?: T, openOnSet?: boolean) => void;
+    closeModal: () => void;
+    getVisible?: ComputedRef<boolean>;
+}
+export type UseModalReturnType = [RegisterFn, ReturnMethods];
+export interface ReturnInnerMethods extends ModalMethods {
+    closeModal: () => void;
+    changeLoading: (loading: boolean) => void;
+    changeOkLoading: (loading: boolean) => void;
+    getVisible?: ComputedRef<boolean>;
+    redoModalHeight: () => void;
+}
+export type UseModalInnerReturnType = [RegisterFn, ReturnInnerMethods];
+export interface ModalProps {
+    minHeight?: number;
+    height?: number;
+    wrapperFooterOffset?: number;
+    draggable?: boolean;
+    scrollTop?: boolean;
+    canFullscreen?: boolean;
+    defaultFullscreen?: boolean;
+    visible?: boolean;
+    helpMessage: string | string[];
+    useWrapper: boolean;
+    loading: boolean;
+    loadingTip?: string;
+    wrapperProps: Omit<ModalWrapperProps, 'loading'>;
+    showOkBtn: boolean;
+    showCancelBtn: boolean;
+    closeFunc: () => Promise<any>;
+    /**
+     * Specify a function that will be called when modal is closed completely.
+     * @type Function
+     */
+    afterClose?: () => any;
+    /**
+     * Body style for modal body element. Such as height, padding etc.
+     * @default {}
+     * @type object
+     */
+    bodyStyle?: CSSProperties;
+    /**
+     * Text of the Cancel button
+     * @default 'cancel'
+     * @type string
+     */
+    cancelText?: string;
+    /**
+     * Centered Modal
+     * @default false
+     * @type boolean
+     */
+    centered?: boolean;
+    /**
+     * Whether a close (x) button is visible on top right of the modal dialog or not
+     * @default true
+     * @type boolean
+     */
+    closable?: boolean;
+    /**
+     * Whether a close (x) button is visible on top right of the modal dialog or not
+     */
+    closeIcon?: VNodeChild | JSX.Element;
+    /**
+     * Whether to apply loading visual effect for OK button or not
+     * @default false
+     * @type boolean
+     */
+    confirmLoading?: boolean;
+    /**
+     * Whether to unmount child components on onClose
+     * @default false
+     * @type boolean
+     */
+    destroyOnClose?: boolean;
+    /**
+     * Footer content, set as :footer="null" when you don't need default buttons
+     * @default OK and Cancel buttons
+     * @type any (string | slot)
+     */
+    footer?: VNodeChild | JSX.Element;
+    /**
+     * Return the mount node for Modal
+     * @default () => document.body
+     * @type Function
+     */
+    getContainer?: (instance: any) => HTMLElement;
+    /**
+     * Whether show mask or not.
+     * @default true
+     * @type boolean
+     */
+    mask?: boolean;
+    /**
+     * Whether to close the modal dialog when the mask (area outside the modal) is clicked
+     * @default true
+     * @type boolean
+     */
+    maskClosable?: boolean;
+    /**
+     * Style for modal's mask element.
+     * @default {}
+     * @type object
+     */
+    maskStyle?: CSSProperties;
+    /**
+     * Text of the OK button
+     * @default 'OK'
+     * @type string
+     */
+    okText?: string;
+    /**
+     * Button type of the OK button
+     * @default 'primary'
+     * @type string
+     */
+    okType?: 'primary' | 'danger' | 'dashed' | 'ghost' | 'default';
+    /**
+     * The ok button props, follow jsx rules
+     * @type object
+     */
+    okButtonProps?: ButtonProps;
+    /**
+     * The cancel button props, follow jsx rules
+     * @type object
+     */
+    cancelButtonProps?: ButtonProps;
+    /**
+     * The modal dialog's title
+     * @type any (string | slot)
+     */
+    title?: VNodeChild | JSX.Element;
+    /**
+     * Width of the modal dialog
+     * @default 520
+     * @type string | number
+     */
+    width?: string | number;
+    /**
+     * The class name of the container of the modal dialog
+     * @type string
+     */
+    wrapClassName?: string;
+    /**
+     * The z-index of the Modal
+     * @default 1000
+     * @type number
+     */
+    zIndex?: number;
+    size: 'small' | 'default' | 'large';
+}
+export interface ModalWrapperProps {
+    footerOffset?: number;
+    loading: boolean;
+    modalHeaderHeight: number;
+    modalFooterHeight: number;
+    minHeight: number;
+    height: number;
+    visible: boolean;
+    fullScreen: boolean;
+    useWrapper: boolean;
+}

package/lib/ui/src/Modal/src/utils/index.d.ts

@@ -0,0 +1,5 @@
+export declare function deepMerge<T = any>(src?: any, target?: any): T;
+/**
+ * @description:  Set ui mount node
+ */
+export declare function getPopupContainer(node?: HTMLElement): HTMLElement;

package/lib/ui/src/Modal/src/utils/is.d.ts

@@ -0,0 +1,13 @@
+export declare function is(val: unknown, type: string): boolean;
+export declare function isFunction(val: unknown): val is Function;
+export declare function isObject(val: any): val is Record<any, any>;
+export declare function isDef<T = unknown>(val?: T): val is T;
+export declare function isUnDef<T = unknown>(val?: T): val is T;
+/**
+ * @description: Is it a production mode
+ * @returns:
+ * @example:
+ */
+export declare function isProdMode(): boolean;
+export declare function isString(val: unknown): val is string;
+export declare function isArray(val: any): val is Array<any>;

package/lib/ui/src/Modal/src/utils/log.d.ts

@@ -0,0 +1,2 @@
+export declare function warn(message: string): void;
+export declare function error(message: string): void;

package/lib/ui/src/Modal/src/utils/tsxHelper.d.ts

@@ -0,0 +1,13 @@
+import { Slots } from 'vue';
+/**
+ * @description:  Get slot to prevent empty error
+ */
+export declare function getSlot(slots: Slots, slot?: string, data?: any): import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>[];
+/**
+ * extends slots
+ * @param slots
+ * @param excludeKeys
+ */
+export declare function extendSlots(slots: Slots, excludeKeys?: string[]): any;

package/lib/ui/src/Page/index.d.ts

@@ -0,0 +1,5 @@
+import PageFooter from './src/PageFooter.vue';
+import PageWrapper from './src/PageWrapper.vue';
+import PageSecond from './src/PageSecond';
+export { PageFooter, PageWrapper, PageSecond };
+export declare const PageWrapperFixedHeightKey = "PageWrapperFixedHeight";

package/lib/ui/src/Page/src/PageFooter.vue.d.ts

@@ -0,0 +1,5 @@
+declare const _sfc_main: import("vue").DefineComponent<{}, {
+    prefixCls: string;
+    getCalcContentWidth: string;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{}>>, {}, {}>;
+export default _sfc_main;

package/lib/ui/src/Page/src/PageSecond.d.ts

@@ -0,0 +1,63 @@
+declare const _default: import("vue").DefineComponent<{
+    title: {
+        type: StringConstructor;
+        default: () => string;
+    };
+    isShowCancelButton: {
+        type: BooleanConstructor;
+        default: () => boolean;
+    };
+    isShowConfirmButton: {
+        type: BooleanConstructor;
+        default: () => boolean;
+    };
+    isShowFooter: {
+        type: BooleanConstructor;
+        default: () => boolean;
+    };
+    confirmButtonText: {
+        type: StringConstructor;
+        default: () => string;
+    };
+    cancelButtonText: {
+        type: StringConstructor;
+        default: () => string;
+    };
+}, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("cancel" | "click-return" | "confirm")[], "cancel" | "click-return" | "confirm", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    title: {
+        type: StringConstructor;
+        default: () => string;
+    };
+    isShowCancelButton: {
+        type: BooleanConstructor;
+        default: () => boolean;
+    };
+    isShowConfirmButton: {
+        type: BooleanConstructor;
+        default: () => boolean;
+    };
+    isShowFooter: {
+        type: BooleanConstructor;
+        default: () => boolean;
+    };
+    confirmButtonText: {
+        type: StringConstructor;
+        default: () => string;
+    };
+    cancelButtonText: {
+        type: StringConstructor;
+        default: () => string;
+    };
+}>> & {
+    onCancel?: (...args: any[]) => any;
+    "onClick-return"?: (...args: any[]) => any;
+    onConfirm?: (...args: any[]) => any;
+}, {
+    title: string;
+    isShowFooter: boolean;
+    isShowCancelButton: boolean;
+    isShowConfirmButton: boolean;
+    confirmButtonText: string;
+    cancelButtonText: string;
+}, {}>;
+export default _default;