@xiaohaih/json-form-vant 0.0.1

package/dist/components/dynamic-group/types.d.ts

@@ -0,0 +1,403 @@
+import { usePlain } from '@xiaohaih/json-form-core';
+import { ExtractPublicPropTypes, PropType } from 'vue';
+import { ComponentType } from '../share';
+/** 组件传参 - 私有 */
+export declare function dynamicGroupPropsGeneric<Query extends Record<string, any>, OptionQuery extends Record<string, any>>(): {
+    /** 当前组件类型(防止被继承, 主动声明) */
+    readonly t: {
+        readonly type: StringConstructor;
+    };
+    /** 渲染的标签 */
+    readonly tag: {
+        readonly type: PropType<any>;
+        readonly default: "div";
+    };
+    /** 渲染的子条件 */
+    readonly config: {
+        readonly type: PropType<any>;
+    };
+    /**
+     * 如果是组件是存在于数组中的, 需要传递一个唯一键, 读取当前对象中的某个值
+     * 防止依赖本数组其它下标中的值时, 如果前一项被删除, 导致依赖误触发
+     * 也是作为循环时唯一 key
+     *
+     * @example
+     * ``` ts
+     * // 当表单项根据 query.users 动态生成时, 想保证某些情况下依赖不会产生错误
+     * // 可传递 uniqueKey: 'id', 此时依赖判断会以条件项的 user[].id 的值做唯一值判断
+     * const query = { users: [{ id: '1', name: '', value: '' }, { id: '2', name: '', value: '' }, ...] }
+     * ```
+     */
+    readonly uniqueKey: {
+        readonly type: StringConstructor;
+    };
+    /** 传递给每行表单项 DOM 节点的属性 */
+    readonly contentProps: {
+        readonly type: PropType<Partial<Record<"class" | "style", string | Record<string, any> | any[]>>>;
+    };
+    /** 传递给组件的插槽 - 重写声明 */
+    readonly slots: {
+        readonly type: PropType<DynamicGroupSlots<Query, OptionQuery>>;
+    };
+    /** 传递给动态渲染组件的插槽 */
+    readonly itemSlots: {
+        readonly type: PropType<{
+            /** 在动态表单项前渲染 */
+            prepend?: ComponentType<{
+                query: Query;
+                checked: any[];
+                index: number;
+                plain: ReturnType<typeof usePlain>;
+            }>;
+            /** 在动态表单项后渲染 */
+            append?: ComponentType<{
+                query: Query;
+                checked: any[];
+                index: number;
+                plain: ReturnType<typeof usePlain>;
+            }>;
+        }>;
+        readonly default: () => {};
+    };
+    readonly field: Omit<{
+        readonly type: PropType<string>;
+        readonly required: true;
+    }, "required">;
+    readonly fields: {
+        readonly type: PropType<string[]>;
+    };
+    readonly query: {
+        readonly type: PropType<Query>;
+        readonly required: true;
+    };
+    readonly parentQuery: {
+        readonly type: PropType<Record<string, any>>;
+    };
+    readonly depend: {
+        readonly type: PropType<boolean>;
+        readonly default: undefined;
+    };
+    readonly resetByDependValueChange: {
+        readonly type: PropType<boolean | ((query: Query) => boolean)>;
+        readonly default: true;
+    };
+    readonly dependFields: {
+        readonly type: PropType<string | string[]>;
+    };
+    readonly dependWatchOption: {
+        readonly type: PropType<import('vue').WatchOptions>;
+    };
+    readonly optionsDepend: {
+        readonly type: PropType<boolean>;
+    };
+    readonly optionsDependFields: {
+        readonly type: PropType<string | string[]>;
+    };
+    readonly validator: {
+        readonly type: PropType<(query: Query) => any | Promise<any>>;
+    };
+    readonly initialValue: {
+        readonly type: PropType<((option: {
+            query: Query_1;
+        }) => any) | any>;
+        readonly default: undefined;
+    };
+    readonly defaultValue: {
+        readonly type: PropType<((option: {
+            query: Query_1;
+        }) => any) | any>;
+        readonly default: undefined;
+    };
+    readonly defaultValueConflictCallback: {
+        readonly type: PropType<(value: any, checked: import('vue').Ref<any>) => void>;
+        readonly default: typeof import('@xiaohaih/json-form-core').noop;
+    };
+    readonly options: {
+        readonly type: PropType<any>;
+        readonly default: () => never[];
+    };
+    readonly getOptions: {
+        readonly type: PropType<import('@xiaohaih/json-form-core').GetOptions<Query, OptionQuery>>;
+    };
+    readonly uniqueValue: {
+        readonly type: PropType<string | number>;
+    };
+    readonly hooks: {
+        readonly type: PropType<import('@xiaohaih/json-form-core').HookOption<Query, OptionQuery>>;
+        readonly default: undefined;
+    };
+};
+/** 组件传参 - 私有 */
+export declare const dynamicGroupPropsPrivate: {
+    /** 当前组件类型(防止被继承, 主动声明) */
+    readonly t: {
+        readonly type: StringConstructor;
+    };
+    /** 渲染的标签 */
+    readonly tag: {
+        readonly type: PropType<any>;
+        readonly default: "div";
+    };
+    /** 渲染的子条件 */
+    readonly config: {
+        readonly type: PropType<any>;
+    };
+    /**
+     * 如果是组件是存在于数组中的, 需要传递一个唯一键, 读取当前对象中的某个值
+     * 防止依赖本数组其它下标中的值时, 如果前一项被删除, 导致依赖误触发
+     * 也是作为循环时唯一 key
+     *
+     * @example
+     * ``` ts
+     * // 当表单项根据 query.users 动态生成时, 想保证某些情况下依赖不会产生错误
+     * // 可传递 uniqueKey: 'id', 此时依赖判断会以条件项的 user[].id 的值做唯一值判断
+     * const query = { users: [{ id: '1', name: '', value: '' }, { id: '2', name: '', value: '' }, ...] }
+     * ```
+     */
+    readonly uniqueKey: {
+        readonly type: StringConstructor;
+    };
+    /** 传递给每行表单项 DOM 节点的属性 */
+    readonly contentProps: {
+        readonly type: PropType<Partial<Record<"class" | "style", string | Record<string, any> | any[]>>>;
+    };
+    /** 传递给组件的插槽 - 重写声明 */
+    readonly slots: {
+        readonly type: PropType<DynamicGroupSlots<Record<string, any>, Record<string, any>>>;
+    };
+    /** 传递给动态渲染组件的插槽 */
+    readonly itemSlots: {
+        readonly type: PropType<{
+            /** 在动态表单项前渲染 */
+            prepend?: ComponentType<{
+                query: Record<string, any>;
+                checked: any[];
+                index: number;
+                plain: ReturnType<typeof usePlain>;
+            }> | undefined;
+            /** 在动态表单项后渲染 */
+            append?: ComponentType<{
+                query: Record<string, any>;
+                checked: any[];
+                index: number;
+                plain: ReturnType<typeof usePlain>;
+            }> | undefined;
+        }>;
+        readonly default: () => {};
+    };
+    readonly field: Omit<{
+        readonly type: PropType<string>;
+        readonly required: true;
+    }, "required">;
+    readonly fields: {
+        readonly type: PropType<string[]>;
+    };
+    readonly query: {
+        readonly type: PropType<Record<string, any>>;
+        readonly required: true;
+    };
+    readonly parentQuery: {
+        readonly type: PropType<Record<string, any>>;
+    };
+    readonly depend: {
+        readonly type: PropType<boolean>;
+        readonly default: undefined;
+    };
+    readonly resetByDependValueChange: {
+        readonly type: PropType<boolean | ((query: Record<string, any>) => boolean)>;
+        readonly default: true;
+    };
+    readonly dependFields: {
+        readonly type: PropType<string | string[]>;
+    };
+    readonly dependWatchOption: {
+        readonly type: PropType<import('vue').WatchOptions>;
+    };
+    readonly optionsDepend: {
+        readonly type: PropType<boolean>;
+    };
+    readonly optionsDependFields: {
+        readonly type: PropType<string | string[]>;
+    };
+    readonly validator: {
+        readonly type: PropType<(query: Record<string, any>) => any | Promise<any>>;
+    };
+    readonly initialValue: {
+        readonly type: PropType<((option: {
+            query: Query;
+        }) => any) | any>;
+        readonly default: undefined;
+    };
+    readonly defaultValue: {
+        readonly type: PropType<((option: {
+            query: Query;
+        }) => any) | any>;
+        readonly default: undefined;
+    };
+    readonly defaultValueConflictCallback: {
+        readonly type: PropType<(value: any, checked: import('vue').Ref<any>) => void>;
+        readonly default: typeof import('@xiaohaih/json-form-core').noop;
+    };
+    readonly options: {
+        readonly type: PropType<any>;
+        readonly default: () => never[];
+    };
+    readonly getOptions: {
+        readonly type: PropType<import('@xiaohaih/json-form-core').GetOptions<Record<string, any>, Record<string, any>>>;
+    };
+    readonly uniqueValue: {
+        readonly type: PropType<string | number>;
+    };
+    readonly hooks: {
+        readonly type: PropType<import('@xiaohaih/json-form-core').HookOption<Record<string, any>, Record<string, any>>>;
+        readonly default: undefined;
+    };
+};
+/** 组件传参 - 外部调用 */
+export declare const dynamicGroupProps: {
+    /** 当前组件类型(防止被继承, 主动声明) */
+    readonly t: {
+        readonly type: StringConstructor;
+    };
+    /** 渲染的标签 */
+    readonly tag: {
+        readonly type: PropType<any>;
+        readonly default: "div";
+    };
+    /** 渲染的子条件 */
+    readonly config: {
+        readonly type: PropType<any>;
+    };
+    /**
+     * 如果是组件是存在于数组中的, 需要传递一个唯一键, 读取当前对象中的某个值
+     * 防止依赖本数组其它下标中的值时, 如果前一项被删除, 导致依赖误触发
+     * 也是作为循环时唯一 key
+     *
+     * @example
+     * ``` ts
+     * // 当表单项根据 query.users 动态生成时, 想保证某些情况下依赖不会产生错误
+     * // 可传递 uniqueKey: 'id', 此时依赖判断会以条件项的 user[].id 的值做唯一值判断
+     * const query = { users: [{ id: '1', name: '', value: '' }, { id: '2', name: '', value: '' }, ...] }
+     * ```
+     */
+    readonly uniqueKey: {
+        readonly type: StringConstructor;
+    };
+    /** 传递给每行表单项 DOM 节点的属性 */
+    readonly contentProps: {
+        readonly type: PropType<Partial<Record<"class" | "style", string | Record<string, any> | any[]>>>;
+    };
+    /** 传递给组件的插槽 - 重写声明 */
+    readonly slots: {
+        readonly type: PropType<DynamicGroupSlots<Record<string, any>, Record<string, any>>>;
+    };
+    /** 传递给动态渲染组件的插槽 */
+    readonly itemSlots: {
+        readonly type: PropType<{
+            /** 在动态表单项前渲染 */
+            prepend?: ComponentType<{
+                query: Record<string, any>;
+                checked: any[];
+                index: number;
+                plain: ReturnType<typeof usePlain>;
+            }> | undefined;
+            /** 在动态表单项后渲染 */
+            append?: ComponentType<{
+                query: Record<string, any>;
+                checked: any[];
+                index: number;
+                plain: ReturnType<typeof usePlain>;
+            }> | undefined;
+        }>;
+        readonly default: () => {};
+    };
+    readonly field: Omit<{
+        readonly type: PropType<string>;
+        readonly required: true;
+    }, "required">;
+    readonly fields: {
+        readonly type: PropType<string[]>;
+    };
+    readonly query: {
+        readonly type: PropType<Record<string, any>>;
+        readonly required: true;
+    };
+    readonly parentQuery: {
+        readonly type: PropType<Record<string, any>>;
+    };
+    readonly depend: {
+        readonly type: PropType<boolean>;
+        readonly default: undefined;
+    };
+    readonly resetByDependValueChange: {
+        readonly type: PropType<boolean | ((query: Record<string, any>) => boolean)>;
+        readonly default: true;
+    };
+    readonly dependFields: {
+        readonly type: PropType<string | string[]>;
+    };
+    readonly dependWatchOption: {
+        readonly type: PropType<import('vue').WatchOptions>;
+    };
+    readonly optionsDepend: {
+        readonly type: PropType<boolean>;
+    };
+    readonly optionsDependFields: {
+        readonly type: PropType<string | string[]>;
+    };
+    readonly validator: {
+        readonly type: PropType<(query: Record<string, any>) => any | Promise<any>>;
+    };
+    readonly initialValue: {
+        readonly type: PropType<((option: {
+            query: Query;
+        }) => any) | any>;
+        readonly default: undefined;
+    };
+    readonly defaultValue: {
+        readonly type: PropType<((option: {
+            query: Query;
+        }) => any) | any>;
+        readonly default: undefined;
+    };
+    readonly defaultValueConflictCallback: {
+        readonly type: PropType<(value: any, checked: import('vue').Ref<any>) => void>;
+        readonly default: typeof import('@xiaohaih/json-form-core').noop;
+    };
+    readonly options: {
+        readonly type: PropType<any>;
+        readonly default: () => never[];
+    };
+    readonly getOptions: {
+        readonly type: PropType<import('@xiaohaih/json-form-core').GetOptions<Record<string, any>, Record<string, any>>>;
+    };
+    readonly uniqueValue: {
+        readonly type: PropType<string | number>;
+    };
+    readonly hooks: {
+        readonly type: PropType<import('@xiaohaih/json-form-core').HookOption<Record<string, any>, Record<string, any>>>;
+        readonly default: undefined;
+    };
+};
+export type DynamicGroupProps<Query extends Record<string, any>, OptionQuery extends Record<string, any>> = ExtractPublicPropTypes<ReturnType<typeof dynamicGroupPropsGeneric<Query, OptionQuery>>>;
+/** 组件事件 - 私有 */
+export declare function dynamicGroupEmitsGeneric<T>(): {};
+/** 组件事件 - 私有 */
+export declare const dynamicGroupEmitsPrivate: {};
+/** 组件事件 - 外部调用 */
+export declare const dynamicGroupEmits: {};
+export type DynamicGroupEmits<T> = ReturnType<typeof dynamicGroupEmitsGeneric<T>>;
+export interface DynamicGroupSlots<Query extends Record<string, any> = any, OptionQuery extends Record<string, any> = any> {
+    /** 在表单项前渲染 */
+    prepend?: ComponentType<{
+        query: Query;
+        checked: any[];
+        plain: ReturnType<typeof usePlain>;
+    }>;
+    /** 在表单项后渲染 */
+    append?: ComponentType<{
+        query: Query;
+        checked: any[];
+        plain: ReturnType<typeof usePlain>;
+    }>;
+}

package/dist/components/group/assist.d.ts

@@ -0,0 +1,58 @@
+import { HArea, HCascader, HCheckbox, HCheckboxGroup, HCustomRender, HDatePicker, HDatetimePicker, HDateTimePickerGroup, HInput, HNumberKeyboard, HPasswordInput, HPicker, HRadio, HRadioGroup, HRate, HSignature, HSlider, HStepper, HSwitch, HTimePicker, HTreeSelect, HUpload } from '../component-definition/components';
+declare const compMap: {
+    area: typeof HArea;
+    cascader: typeof HCascader;
+    checkbox: typeof HCheckbox;
+    'checkbox-group': typeof HCheckboxGroup;
+    'custom-render': typeof HCustomRender;
+    datepicker: typeof HDatePicker;
+    'date-picker': typeof HDatePicker;
+    'date-time-picker-group': typeof HDateTimePickerGroup;
+    'datetime-picker': typeof HDatetimePicker;
+    input: typeof HInput;
+    'number-keyboard': typeof HNumberKeyboard;
+    'password-input': typeof HPasswordInput;
+    picker: typeof HPicker;
+    select: typeof HPicker;
+    radio: typeof HRadio;
+    'radio-group': typeof HRadioGroup;
+    rate: typeof HRate;
+    signature: typeof HSignature;
+    slider: typeof HSlider;
+    stepper: typeof HStepper;
+    switch: typeof HSwitch;
+    'time-picker': typeof HTimePicker;
+    timepicker: typeof HTimePicker;
+    'tree-select': typeof HTreeSelect;
+    upload: typeof HUpload;
+};
+/** 默认定义组件的类型 */
+export type ComponentTypeDef = (typeof compMap)[keyof typeof compMap];
+/**
+ * 注册自定义组件
+ * @param {string} name 类型
+ * @param {} comp 可渲染的组件
+ */
+export declare function registerComponent(name: string, comp: any): void;
+/**
+ * 删除自定义组件
+ * @param {string} name 定义的类型
+ */
+export declare function unregisterComponent(name: string): void;
+/**
+ * 获取指定组件
+ * 根据组件类型名称获取对应的组件实例，优先从用户自定义组件中查找
+ *
+ * @param {string} name - 组件类型名称
+ * @returns {ComponentTypeDef | null} - 返回指定的组件
+ */
+export declare function getComponent(name: string): ComponentTypeDef | null;
+/**
+ * 获取指定类型/所有组件
+ *
+ * @param {string} [type] 内置组件(builtIn)
+ *
+ * @returns {Record<string, ComponentTypeDef>} - 返回指定的组件或所有组件的映射表
+ */
+export declare function getAllComponent(type?: 'builtIn' | 'user'): Record<string, ComponentTypeDef>;
+export {};

package/dist/components/group/index.d.ts

@@ -0,0 +1,6 @@
+import { ComponentExposed } from 'vue-component-type-helpers';
+import { default as HGroup } from './index.vue';
+export { HGroup };
+export type HGroupInstance = ComponentExposed<typeof HGroup>;
+export * from './assist';
+export * from './types';

package/dist/components/group/index.vue.d.ts

@@ -0,0 +1,139 @@
+import { getNode, getProvideValue } from '@xiaohaih/json-form-core';
+import { SlotsType } from 'vue';
+import { GroupSlots } from './types';
+/**
+ * @file 自定义组件 - 支持多列渲染
+ */
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    readonly t: {
+        readonly type: StringConstructor;
+    };
+    readonly field: {
+        readonly type: StringConstructor;
+    };
+    readonly query: {
+        readonly type: import('vue').PropType<Record<string, any>>;
+        readonly required: true;
+    };
+    readonly tag: {
+        readonly type: import('vue').PropType<any>;
+        readonly default: "div";
+    };
+    readonly tagSlots: {
+        readonly type: import('vue').PropType<Record<string, import('..').ComponentType<{
+            query: Record<string, any>;
+            wrapper: ReturnType<typeof getProvideValue>;
+        }>>>;
+    };
+    readonly config: {
+        readonly type: import('vue').PropType<any>;
+    };
+    readonly slots: {
+        readonly type: import('vue').PropType<GroupSlots<Record<string, any>, Record<string, any>>>;
+    };
+    readonly hooks: {
+        readonly type: import('vue').PropType<import('./types').GroupHookOption>;
+        readonly default: undefined;
+    };
+    readonly getFormRef: {
+        readonly type: import('vue').PropType<() => any>;
+    };
+    readonly class: {
+        type: import('vue').PropType<string | Record<string, any> | any[]>;
+    };
+    readonly style: {
+        type: import('vue').PropType<string | Record<string, any> | any[]>;
+    };
+}>, {
+    hyphenate: <T extends string>(str: T) => import('@xiaohaih/json-form-core').Hyphenate<T>;
+    getNode: typeof getNode;
+    REWRITE_FIELD_KEY: "__field__";
+    virtualGroupRef: import('vue').Ref<Record<string, any> | undefined, Record<string, any> | undefined>;
+    virtualTag: import('vue').ComputedRef<any>;
+    virtualSlots: import('vue').ComputedRef<Record<string, any> | undefined>;
+    tagRef: import('vue').ComputedRef<any>;
+    wrapper: import('@xiaohaih/json-form-core').ProvideValue<Record<string, any>, Record<string, any>, any> | undefined;
+    finalConfig: import('vue').ComputedRef<any[]>;
+    getComponent2: (name: string) => import('./assist').ComponentTypeDef | "HGroup" | null;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    readonly t: {
+        readonly type: StringConstructor;
+    };
+    readonly field: {
+        readonly type: StringConstructor;
+    };
+    readonly query: {
+        readonly type: import('vue').PropType<Record<string, any>>;
+        readonly required: true;
+    };
+    readonly tag: {
+        readonly type: import('vue').PropType<any>;
+        readonly default: "div";
+    };
+    readonly tagSlots: {
+        readonly type: import('vue').PropType<Record<string, import('..').ComponentType<{
+            query: Record<string, any>;
+            wrapper: ReturnType<typeof getProvideValue>;
+        }>>>;
+    };
+    readonly config: {
+        readonly type: import('vue').PropType<any>;
+    };
+    readonly slots: {
+        readonly type: import('vue').PropType<GroupSlots<Record<string, any>, Record<string, any>>>;
+    };
+    readonly hooks: {
+        readonly type: import('vue').PropType<import('./types').GroupHookOption>;
+        readonly default: undefined;
+    };
+    readonly getFormRef: {
+        readonly type: import('vue').PropType<() => any>;
+    };
+    readonly class: {
+        type: import('vue').PropType<string | Record<string, any> | any[]>;
+    };
+    readonly style: {
+        type: import('vue').PropType<string | Record<string, any> | any[]>;
+    };
+}>> & Readonly<{}>, {
+    readonly hooks: import('./types').GroupHookOption;
+    readonly tag: any;
+}, SlotsType<GroupSlots<any, any>>, {
+    VirtualGroup: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+        tag: {
+            type: import('vue').PropType<any>;
+            default: string;
+        };
+        slots: {
+            type: import('vue').PropType<Record<string, any>>;
+        };
+        wrapper: {
+            type: import('vue').PropType<Record<string, any>>;
+        };
+        query: {
+            type: import('vue').PropType<Record<string, any>>;
+        };
+    }>, {
+        getNode: typeof getNode;
+        tagRef: import('vue').Ref<Record<string, any> | undefined, Record<string, any> | undefined>;
+        events: import('vue').ComputedRef<any>;
+    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+        tag: {
+            type: import('vue').PropType<any>;
+            default: string;
+        };
+        slots: {
+            type: import('vue').PropType<Record<string, any>>;
+        };
+        wrapper: {
+            type: import('vue').PropType<Record<string, any>>;
+        };
+        query: {
+            type: import('vue').PropType<Record<string, any>>;
+        };
+    }>> & Readonly<{}>, {
+        tag: any;
+    }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;