ax-libs 0.0.1

package/dist/hooks/common/useComponentPool.d.ts

@@ -0,0 +1,28 @@
+import { Component } from 'vue';
+import { ListConfig } from '..';
+export interface ComponentPool<T> {
+    source?: T[];
+    className?: string;
+}
+export interface FieldsConfig<T extends Record<string, any>> extends ListConfig<T> {
+    fields: T[];
+    className?: string;
+}
+export declare function useComponentPool<T extends Record<string, any>>(component: Component, options?: FieldsConfig<T>): readonly [import('vue').DefineComponent<{}, (() => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+    [key: string]: any;
+}>) | (() => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+    [key: string]: any;
+}>[]), {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>, {
+    readonly config: import('..').StateApi<ListConfig<T>>;
+    readonly source: (source: T[]) => void;
+    readonly add: (data: T) => void;
+    readonly set: (data: import('ts-essentials').DeepPartial<import('..').ListItem<T>>, key: number | T[keyof T]) => boolean;
+    readonly get: (key: number | T[keyof T]) => import('..').ListItem<T> | null;
+    readonly hide: (key: number | T[keyof T]) => boolean;
+    readonly del: (key: number | T[keyof T]) => boolean;
+    readonly remove: (key: number | T[keyof T]) => boolean;
+    readonly expand: (bool?: boolean) => void;
+    readonly configInfo: () => ListConfig<T>;
+    readonly setClass: import('..').StateApi<string | undefined>;
+    readonly getList: () => import('..').ListItem<T>[];
+}];

package/dist/hooks/common/useDefineProps.d.ts

@@ -0,0 +1,3 @@
+export declare function useDefineProps<T extends Record<string, any> = any>(props: T, defaultProps?: Partial<T>): import('vue').ComputedRef<Partial<T> & {
+    [k: string]: any;
+}>;

package/dist/hooks/core/useFetch.d.ts

@@ -0,0 +1,28 @@
+import { Result } from '../../utils';
+import { StateApi } from '..';
+import { Ref } from 'vue';
+export type RequestFetch<P, R> = ((params: P) => Promise<Result<R>>) | (() => Promise<Result<R>>) | null;
+export interface FetchOptions<T, R> {
+    params?: T;
+    beforeFetch?: (params: T) => T;
+    success?: (data: Result<R>) => void;
+    fail?: (data: Result<any>) => void;
+    error?: (err: any) => void;
+    loading?: boolean;
+    immediate?: boolean;
+}
+export interface FetchApi<P, R> {
+    /** 响应式的配置对象，支持读取和修改配置 */
+    readonly setConfig: StateApi<FetchOptions<P, R>>;
+    /** 动态替换或设置当前的请求 API 函数 */
+    readonly setApi: StateApi<RequestFetch<P, R>>;
+    /** 手动发起网络请求，可传入局部参数进行合并 */
+    readonly load: (params?: P) => Promise<any>;
+    /** 获取当前完整的配置信息 */
+    readonly getConfig: () => FetchOptions<P, R>;
+    readonly get: () => any;
+    readonly getReady: () => boolean;
+    readonly setParams: (data: P, load?: boolean) => void;
+    readonly reload: () => void;
+}
+export declare function useFetch<P, R>(request: RequestFetch<P, R>, options?: FetchOptions<P, R>): [Ref<any>, FetchApi<P, R>];

package/dist/hooks/core/useList.d.ts

@@ -0,0 +1,71 @@
+import { StateApi } from '..';
+import { ComputedRef } from 'vue';
+import { DeepPartial } from 'ts-essentials';
+/**
+ * 列表项的基础类型
+ * @template T - 原始数据的类型，必须继承自 Record<string, any>
+ * @description 在原始数据类型 T 的基础上，扩展了内部使用的 _key（唯一标识）和 _hidden（显隐状态）属性
+ */
+export type ListItem<T extends Record<string, any>> = T & {
+    _key: keyof T | number;
+    _hidden: boolean;
+};
+/**
+ * useList 组合式函数的配置项接口
+ * @template T - 列表数据的类型
+ */
+export interface ListConfig<T extends Record<string, any>> {
+    /** 指定作为唯一标识的字段名，若不指定则使用内部自增计数 */
+    key?: keyof T;
+    /** 列表展示的截断数量，配合 expand 使用 */
+    over?: number;
+    /** 是否默认展开全部列表 */
+    expand?: boolean;
+    /**
+     * 移除策略：
+     * 'if' - 物理删除（从数组中移除）
+     * 'show' - 视觉隐藏（仅标记 _hidden 为 true）
+     */
+    strategy?: 'if' | 'show';
+}
+/**
+ * useList 组合式函数对外暴露的 API 接口
+ * @template T - 列表数据的类型
+ */
+export interface ListApi<T extends Record<string, any>> {
+    /** 更新列表配置 */
+    readonly config: StateApi<ListConfig<T>>;
+    /** 重置或替换整个列表的数据源 */
+    readonly source: (source: T[]) => void;
+    /** 向列表中添加一项 */
+    readonly add: (data: T) => void;
+    /** 根据 key 更新列表中的某一项（深度合并） */
+    readonly set: (data: DeepPartial<ListItem<T>>, key: number | T[keyof T]) => boolean;
+    /** 根据 key 获取列表中的某一项原始数据 */
+    readonly get: (key: number | T[keyof T]) => ListItem<T> | null;
+    /** 根据 key 隐藏列表中的某一项（仅修改 _hidden 状态） */
+    readonly hide: (key: number | T[keyof T]) => boolean;
+    /** 根据 key 物理删除列表中的某一项 */
+    readonly del: (key: number | T[keyof T]) => boolean;
+    /** 根据配置的 strategy 策略移除某一项（物理删除或视觉隐藏） */
+    readonly remove: (key: number | T[keyof T]) => boolean;
+    /** 切换或设置列表的展开/收起状态 */
+    readonly expand: (bool?: boolean) => void;
+    /** 获取当前列表的配置信息 */
+    readonly configInfo: () => ListConfig<T>;
+}
+/**
+ * useList 组合式函数的返回值类型定义
+ * @template T - 列表数据的类型
+ */
+export type UseListResult<T extends Record<string, any>> = [ComputedRef<ListItem<T>[]>, ListApi<T>];
+/**
+ * 强大的 Vue3 列表管理组合式函数
+ * @template T - 列表数据的类型，必须继承自 Record<string, any>
+ * @param {T[]} [_source=[]] - 初始化的列表数据数组
+ * @param {ListConfig<T>} [options={}] - 列表的配置项
+ * @returns {UseListResult<T>} 返回一个元组，包含响应式的 list 和一系列操作方法
+ * @example
+ * const [list, { add, del, set }] = useList([{ id: 1, name: 'A' }], { key: 'id' });
+ */
+export declare function useList<T extends Record<string, any>>(_source?: T[], options?: ListConfig<T>): UseListResult<T>;

package/dist/hooks/core/useState.d.ts

@@ -0,0 +1,7 @@
+import { Ref } from 'vue';
+export type StateApi<T> = (data: T, write?: boolean) => void;
+export type StateResult<T> = [
+    Ref<T>,
+    StateApi<T>
+];
+export declare function useState<T>(initialState: T): StateResult<T>;

package/dist/hooks/index.d.ts

@@ -0,0 +1,12 @@
+export * from './core/useState';
+export * from './core/useList';
+export * from './core/useFetch';
+export * from './ui/useAxButon';
+export * from './ui/useAxModal';
+export * from './ui/useAxFormModal';
+export * from './ui/useAxTable';
+export * from './ui/useAxForm';
+export * from './common/useComponentPool';
+export * from './common/useDefineProps';
+export * from './ui/exposed/useFormExposed';
+export * from './ui/exposed/useTableExposed.ts';

package/dist/hooks/ui/exposed/useFormExposed.d.ts

@@ -0,0 +1,11 @@
+import { Ref } from 'vue';
+import { AxFormInstance } from '../../../ui/form';
+export declare function useAxFormExpose<T>(form: Ref<AxFormInstance>): {
+    getValues: () => T;
+    getFlForm: () => import('element-plus').FormInstance | undefined;
+    getFields: () => (keyof T)[];
+    getDefaultValues: () => {} & Record<string, any>;
+    setValues: (data: Partial<T>) => void;
+    resetValues: () => void;
+    clearValues: () => void;
+};

package/dist/hooks/ui/exposed/useTableExposed.d.ts

@@ -0,0 +1,15 @@
+import { Ref } from 'vue';
+import { AxTableInstance } from '../../../ui/table';
+import { FetchOptions, RequestFetch } from '../..';
+import { PageData } from '../../../utils';
+export declare function useTableExposed<P, R>(table: Ref<AxTableInstance>): {
+    load: (params?: P) => void;
+    setConfig: (config: FetchOptions<P, R[] | PageData<R>>) => void;
+    setApi: (api: RequestFetch<P, R[] | PageData<R>>) => void;
+    getConfig: () => FetchOptions<P, R>;
+    get: () => any;
+    getReady: () => boolean;
+    setParams: (data: P, load?: boolean) => void;
+    getElTable: () => import('element-plus').TableInstance | undefined;
+    reload: () => void;
+};

package/dist/hooks/ui/useAxButon.d.ts

@@ -0,0 +1,4 @@
+import { AxButtonOptions } from '../../ui/button';
+export declare function useAxButon(options?: AxButtonOptions): readonly [import('vue').DefineComponent<{}, () => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>, import('..').StateApi<AxButtonOptions>];

package/dist/hooks/ui/useAxModal.d.ts

@@ -0,0 +1,8 @@
+import { AxModalOptions } from '../../ui/modal';
+export declare function useAxModal(options?: AxModalOptions): readonly [import('vue').DefineComponent<{}, () => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>, {
+    readonly setModal: import('..').StateApi<import('lodash').Omit<AxModalOptions, "slot" | "buttonConfig">>;
+    readonly close: () => void;
+    readonly open: () => void;
+}];

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export * from './ui';
+export * from './plugin';
+export * from './hooks';
+export * from './utils';

package/dist/plugin/index.d.ts

@@ -0,0 +1 @@
+export * from './ui';

package/dist/plugin/ui.d.ts

@@ -0,0 +1,10 @@
+import { App } from 'vue';
+export declare const buttonPlugin: {
+    install(): void;
+};
+export declare const formPlugin: {
+    install(): void;
+};
+export declare const axUI: {
+    install(app: App): void;
+};

package/dist/ui/button/components/button/button.vue.d.ts

@@ -0,0 +1,25 @@
+import { AxButtonProps } from '../../..';
+import { ButtonProps } from 'element-plus';
+declare const __VLS_export: <T = ButtonProps>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: import('vue').PublicProps & __VLS_PrettifyLocal<AxButtonProps<T> & {
+        onClick?: (() => any) | undefined;
+        onDblclick?: (() => any) | undefined;
+    }> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {
+        default?: (props: {}) => any;
+    };
+    emit: ((evt: "click") => void) & ((evt: "dblclick") => void);
+}>) => import('vue').VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_PrettifyLocal<T> = (T extends any ? {
+    [K in keyof T]: T[K];
+} : {
+    [K in keyof T as K]: T[K];
+}) & {};

package/dist/ui/button/components/button/index.d.ts

@@ -0,0 +1,29 @@
+export * from './props';
+export declare const AxButton: <T = import('element-plus').ButtonProps>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: {
+    attrs: any;
+    emit: ((evt: "click") => void) & ((evt: "dblclick") => void);
+    slots: {
+        default?: (props: {}) => any;
+    };
+}, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: import('vue').PublicProps & {
+        type?: string | undefined;
+        componentProps?: T | undefined;
+        text?: string | undefined;
+        auth?: string | undefined;
+        className?: string | undefined;
+        onClick?: (() => any) | undefined;
+        onDblclick?: (() => any) | undefined;
+    } & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {
+        default?: (props: {}) => any;
+    };
+    emit: ((evt: "click") => void) & ((evt: "dblclick") => void);
+}>) => import('vue').VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export default AxButton;

package/dist/ui/button/components/button/props.d.ts

@@ -0,0 +1,15 @@
+import { ButtonProps } from 'element-plus';
+import { EmitsToProps } from '../../../../utils';
+export interface AxButtonProps<T = ButtonProps> {
+    type?: string;
+    componentProps?: T;
+    text?: string;
+    auth?: string;
+    className?: string;
+}
+export interface AxButtonEmits {
+    'click': [];
+    'dblclick': [];
+}
+export interface AxButtonOptions extends AxButtonProps, EmitsToProps<AxButtonEmits> {
+}

package/dist/ui/button/components/fields/index.d.ts

@@ -0,0 +1 @@
+export declare const initButtonFields: () => void;

package/dist/ui/button/index.d.ts

@@ -0,0 +1,3 @@
+export * from './components/fields';
+export * from './components/button';
+export * from './util';

package/dist/ui/button/util/index.d.ts

@@ -0,0 +1,3 @@
+import { Component } from 'vue';
+export declare const buttonFields: Record<string, Component>;
+export declare const addButtonField: (type: string, component: Component) => void;

package/dist/ui/form/components/fields/index.d.ts

@@ -0,0 +1 @@
+export declare const initFormFields: () => void;

package/dist/ui/form/components/form/form.vue.d.ts

@@ -0,0 +1,35 @@
+import { FormInstance } from 'element-plus';
+import { AxFormProps } from './props';
+declare const __VLS_export: <T extends Record<string, any>>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: import('vue').PublicProps & __VLS_PrettifyLocal<AxFormProps & {
+        onSubmit?: ((data: T) => any) | undefined;
+        onChange?: ((data: T) => any) | undefined;
+    }> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: import('vue').ShallowUnwrapRef<{
+        getElForm: () => FormInstance | undefined;
+        getValues: () => T;
+        getFields: () => (keyof T)[];
+        getDefaultValues: () => {} & T;
+        setValues: (values: Partial<T>) => void;
+        resetValues: () => void;
+        clearValues: () => void;
+    }>) => void;
+    attrs: any;
+    slots: {
+        default?: (props: {}) => any;
+    } & {
+        button?: (props: {}) => any;
+    };
+    emit: ((evt: "submit", data: T) => void) & ((evt: "change", data: T) => void);
+}>) => import('vue').VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_PrettifyLocal<T> = (T extends any ? {
+    [K in keyof T]: T[K];
+} : {
+    [K in keyof T as K]: T[K];
+}) & {};

package/dist/ui/form/components/form/index.d.ts

@@ -0,0 +1,57 @@
+import { default as form } from './form.vue';
+import { ComponentExposed } from 'vue-component-type-helpers';
+export * from './props';
+export type AxFormInstance = ComponentExposed<typeof form>;
+export declare const AxForm: <T extends Record<string, any>>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: {
+    attrs: any;
+    emit: ((evt: "submit", data: T) => void) & ((evt: "change", data: T) => void);
+    slots: {
+        default?: (props: {}) => any;
+    } & {
+        button?: (props: {}) => any;
+    };
+}, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: import('vue').PublicProps & {
+        isDefault?: boolean | undefined;
+        submitButton?: import('../../..').AxButtonProps | undefined;
+        loading?: boolean | undefined;
+        size?: import('element-plus').ComponentSize | undefined;
+        disabled?: boolean | undefined;
+        rules?: import('element-plus').FormRules | undefined;
+        labelPosition?: "left" | "right" | "top" | undefined;
+        requireAsteriskPosition?: "left" | "right" | undefined;
+        labelWidth?: string | number | undefined;
+        labelSuffix?: string | undefined;
+        inline?: boolean | undefined;
+        inlineMessage?: boolean | undefined;
+        statusIcon?: boolean | undefined;
+        showMessage?: boolean | undefined;
+        validateOnRuleChange?: boolean | undefined;
+        hideRequiredAsterisk?: boolean | undefined;
+        scrollToError?: boolean | undefined;
+        scrollIntoViewOptions?: (ScrollIntoViewOptions | boolean) | undefined;
+        onSubmit?: ((data: T) => any) | undefined;
+        onChange?: ((data: T) => any) | undefined;
+    } & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: import('vue').ShallowUnwrapRef<{
+        getElForm: () => import('element-plus').FormInstance | undefined;
+        getValues: () => T;
+        getFields: () => (keyof T)[];
+        getDefaultValues: () => {} & T;
+        setValues: (values: Partial<T>) => void;
+        resetValues: () => void;
+        clearValues: () => void;
+    }>) => void;
+    attrs: any;
+    slots: {
+        default?: (props: {}) => any;
+    } & {
+        button?: (props: {}) => any;
+    };
+    emit: ((evt: "submit", data: T) => void) & ((evt: "change", data: T) => void);
+}>) => import('vue').VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export default AxForm;

package/dist/ui/form/components/form/props.d.ts

@@ -0,0 +1,14 @@
+import { FormProps } from 'element-plus';
+import { AxButtonProps } from '../../../button';
+import { EmitsToProps } from '../../../../utils';
+export interface AxFormProps extends Omit<FormProps, 'model'> {
+    isDefault?: boolean;
+    submitButton?: AxButtonProps;
+    loading?: boolean;
+}
+export interface AxFormEmits<T> {
+    'submit': [data: T];
+    'change': [data: T];
+}
+export interface AxFormOptions<T> extends AxFormProps, EmitsToProps<AxFormEmits<T>> {
+}

package/dist/ui/form/components/form-item/form-item.vue.d.ts

@@ -0,0 +1,21 @@
+import { AxFormItemProps } from './props';
+declare const __VLS_export: <T extends Record<string, any>>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: import('vue').PublicProps & __VLS_PrettifyLocal<AxFormItemProps<T>> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {
+        [x: string]: ((props: {}) => any) | undefined;
+    };
+    emit: {};
+}>) => import('vue').VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_PrettifyLocal<T> = (T extends any ? {
+    [K in keyof T]: T[K];
+} : {
+    [K in keyof T as K]: T[K];
+}) & {};

package/dist/ui/form/components/form-item/index.d.ts

@@ -0,0 +1,39 @@
+export declare const AxFormItem: <T extends Record<string, any>>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: {
+    attrs: any;
+    emit: {};
+    slots: {
+        [x: string]: ((props: {}) => any) | undefined;
+    };
+}, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: import('vue').PublicProps & {
+        fieldName: keyof T;
+        type?: string | undefined;
+        defaultValue?: any;
+        vtypes?: string[] | undefined;
+        label?: string | undefined;
+        componentProps?: Record<string, any> | undefined;
+        placeholder?: string | undefined;
+        size?: import('element-plus').ComponentSize | undefined;
+        validateStatus?: import('element-plus').FormItemValidateState | undefined;
+        required?: boolean | undefined;
+        rules?: import('element-plus/es/utils/typescript.mjs').Arrayable<import('element-plus').FormItemRule> | undefined;
+        labelPosition?: "left" | "right" | "top" | "" | undefined;
+        labelWidth?: string | number | undefined;
+        inlineMessage?: boolean | undefined;
+        showMessage?: boolean | undefined;
+        error?: string | undefined;
+        for?: string | undefined;
+    } & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {
+        [x: string]: ((props: {}) => any) | undefined;
+    };
+    emit: {};
+}>) => import('vue').VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export default AxFormItem;
+export * from './props';

package/dist/ui/form/components/form-item/props.d.ts

@@ -0,0 +1,14 @@
+import { FormItemProps, InputEmits, SelectEmits, CheckboxEmits, RadioEmits, CalendarEmits, CascaderEmits } from 'element-plus';
+import { EmitsToProps } from '../../../../utils';
+export interface AxFormItemProps<T extends Record<string, any>> extends Omit<FormItemProps, 'prop'> {
+    fieldName: keyof T;
+    type?: string;
+    defaultValue?: any;
+    vtypes?: string[];
+    label?: string;
+    componentProps?: Record<string, any>;
+    placeholder?: string;
+}
+export type AxFormItemEmits = RadioEmits & CascaderEmits & InputEmits & SelectEmits & CheckboxEmits & CalendarEmits;
+export interface AxFormItemOptions<T extends Record<string, any>> extends AxFormItemProps<T>, EmitsToProps<AxFormItemEmits> {
+}

package/dist/ui/form/index.d.ts

@@ -0,0 +1,4 @@
+export * from './components/fields';
+export * from './components/form';
+export * from './components/form-item';
+export * from './util';

package/dist/ui/form/util/index.d.ts

@@ -0,0 +1,8 @@
+import { Component } from 'vue';
+import { FormItemRule } from 'element-plus';
+export type VFormItemRule = FormItemRule | (() => FormItemRule) | ((type: string, label?: string) => FormItemRule);
+export declare const formFields: Record<string, Component>;
+export declare const formRules: Record<string, VFormItemRule>;
+export declare const addFormFields: (type: string, component: Component) => void;
+export declare const addFormRules: (type: string, rule: any) => void;
+export declare const isTip: (type: string) => "请选择" | "请输入";

package/dist/ui/index.d.ts

@@ -0,0 +1,4 @@
+export * from './button';
+export * from './form';
+export * from './modal';
+export * from './table';

package/dist/ui/modal/components/form-modal/form-modal.vue.d.ts

@@ -0,0 +1,38 @@
+import { DrawerInstance } from 'element-plus';
+import { AxFormModalProps } from './props';
+declare const __VLS_export: <T extends Record<string, any>>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: import('vue').PublicProps & __VLS_PrettifyLocal<AxFormModalProps & {
+        onChange?: ((data: T) => any) | undefined;
+        "onUpdate:open"?: ((data: boolean) => any) | undefined;
+        onConfirm?: ((data: T) => any) | undefined;
+    }> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: import('vue').ShallowUnwrapRef<{
+        getValues: () => T;
+        getFlForm: () => import('element-plus').FormInstance | undefined;
+        getFields: () => (keyof T)[];
+        getDefaultValues: () => {} & Record<string, any>;
+        setValues: (data: Partial<T>) => void;
+        resetValues: () => void;
+        clearValues: () => void;
+        getModal: () => DrawerInstance | undefined;
+        close: () => void;
+    }>) => void;
+    attrs: any;
+    slots: {
+        default?: (props: {}) => any;
+    } & {
+        footer?: (props: {}) => any;
+    };
+    emit: ((evt: "change", data: T) => void) & ((evt: "update:open", data: boolean) => void) & ((evt: "confirm", data: T) => void);
+}>) => import('vue').VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_PrettifyLocal<T> = (T extends any ? {
+    [K in keyof T]: T[K];
+} : {
+    [K in keyof T as K]: T[K];
+}) & {};