@vunk/form 2.6.2 → 2.7.1

package/components/information-collection/index.cjs

@@ -0,0 +1,78 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+var formItem = require('@vunk/form/components/form-item');
+var informationTag = require('@vunk/form/components/information-tag');
+var templateInstancesProvider = require('@vunk/form/components/template-instances-provider');
+var informationTemplatesDefault = require('@vunk/form/components/information-templates-default');
+var _pluginVue_exportHelper = require('../_plugin-vue_export-helper.cjs');
+
+const props = {
+  ...formItem._VkfFormItemCtx.props,
+  modelValue: {
+    type: Array,
+    default: () => []
+  },
+  columns: {
+    type: Array,
+    default: () => []
+  },
+  labelRender: {
+    type: Function,
+    default: void 0
+  },
+  typeRender: {
+    type: Function,
+    default: void 0
+  }
+};
+const emits = {};
+
+var _sfc_main = /* @__PURE__ */ vue.defineComponent({
+  name: "VkfInformationCollection",
+  props,
+  emits,
+  setup(props2, {
+    emit
+  }) {
+    const formItemProps = formItem._VkfFormItemCtx.createBindProps(props2);
+    return () => vue.createVNode(formItem.VkfFormItem, vue.mergeProps({
+      "class": "vk-information-collection",
+      "information": true
+    }, formItemProps.value), {
+      default: () => [vue.createVNode("div", {
+        "class": "vk-information-collection-value"
+      }, [vue.createVNode(templateInstancesProvider.VkfTemplateInstancesProvider, null, {
+        placeholder: () => vue.createVNode(informationTemplatesDefault.VkfInformationTemplatesDefault, null, null),
+        default: () => props2.modelValue.map((item, index) => vue.createVNode(informationTag.VkfInformationTag, {
+          "key": index,
+          "data": item,
+          "type": props2.typeRender?.(item),
+          "labelRender": props2.labelRender,
+          "formItems": props2.columns.map(v => ({
+            ...v,
+            ...v.templateProps?.createTemplateProps?.({
+              row: item
+            })
+          }))
+        }, null))
+      })])]
+    });
+  }
+});
+
+var VkfInformationCollection = /* @__PURE__ */ _pluginVue_exportHelper._export_sfc(_sfc_main, [["__file", "/home/runner/work/private-vunk-form/private-vunk-form/packages/components/information-collection/src/index.vue"]]);
+
+var types = /*#__PURE__*/Object.freeze({
+  __proto__: null
+});
+
+VkfInformationCollection.install = (app) => {
+  app.component(VkfInformationCollection.name || "VkfInformationCollection", VkfInformationCollection);
+};
+
+exports.VkfInformationCollection = VkfInformationCollection;
+exports.__VkfInformationCollection = types;
+exports.default = VkfInformationCollection;

package/components/information-collection/index.d.ts

@@ -0,0 +1,4 @@
+import VkfInformationCollection from './src/index.vue';
+export * as __VkfInformationCollection from './src/types';
+export { VkfInformationCollection, };
+export default VkfInformationCollection;

package/components/information-collection/index.mjs

@@ -0,0 +1,72 @@
+import { defineComponent, createVNode, mergeProps } from 'vue';
+import { _VkfFormItemCtx, VkfFormItem } from '@vunk/form/components/form-item';
+import { VkfInformationTag } from '@vunk/form/components/information-tag';
+import { VkfTemplateInstancesProvider } from '@vunk/form/components/template-instances-provider';
+import { VkfInformationTemplatesDefault } from '@vunk/form/components/information-templates-default';
+import { _ as _export_sfc } from '../_plugin-vue_export-helper.mjs';
+
+const props = {
+  ..._VkfFormItemCtx.props,
+  modelValue: {
+    type: Array,
+    default: () => []
+  },
+  columns: {
+    type: Array,
+    default: () => []
+  },
+  labelRender: {
+    type: Function,
+    default: void 0
+  },
+  typeRender: {
+    type: Function,
+    default: void 0
+  }
+};
+const emits = {};
+
+var _sfc_main = /* @__PURE__ */ defineComponent({
+  name: "VkfInformationCollection",
+  props,
+  emits,
+  setup(props2, {
+    emit
+  }) {
+    const formItemProps = _VkfFormItemCtx.createBindProps(props2);
+    return () => createVNode(VkfFormItem, mergeProps({
+      "class": "vk-information-collection",
+      "information": true
+    }, formItemProps.value), {
+      default: () => [createVNode("div", {
+        "class": "vk-information-collection-value"
+      }, [createVNode(VkfTemplateInstancesProvider, null, {
+        placeholder: () => createVNode(VkfInformationTemplatesDefault, null, null),
+        default: () => props2.modelValue.map((item, index) => createVNode(VkfInformationTag, {
+          "key": index,
+          "data": item,
+          "type": props2.typeRender?.(item),
+          "labelRender": props2.labelRender,
+          "formItems": props2.columns.map(v => ({
+            ...v,
+            ...v.templateProps?.createTemplateProps?.({
+              row: item
+            })
+          }))
+        }, null))
+      })])]
+    });
+  }
+});
+
+var VkfInformationCollection = /* @__PURE__ */ _export_sfc(_sfc_main, [["__file", "/home/runner/work/private-vunk-form/private-vunk-form/packages/components/information-collection/src/index.vue"]]);
+
+var types = /*#__PURE__*/Object.freeze({
+  __proto__: null
+});
+
+VkfInformationCollection.install = (app) => {
+  app.component(VkfInformationCollection.name || "VkfInformationCollection", VkfInformationCollection);
+};
+
+export { VkfInformationCollection, types as __VkfInformationCollection, VkfInformationCollection as default };

package/components/information-collection/src/ctx.d.ts

@@ -0,0 +1,112 @@
+import { Func } from '@vunk/core';
+import { NormalObject } from '@vunk/shared';
+import { PropType } from 'vue';
+import { TagProps } from 'element-plus';
+export declare const props: {
+    modelValue: {
+        type: {
+            (arrayLength: number): NormalObject[];
+            (...items: NormalObject[]): NormalObject[];
+            new (arrayLength: number): NormalObject[];
+            new (...items: NormalObject[]): NormalObject[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+            from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            of<T>(...items: T[]): T[];
+            fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+            fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>) => U, thisArg?: any): Promise<Awaited<U>[]>;
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+        default: () => any[];
+    };
+    columns: {
+        type: {
+            (arrayLength: number): any[];
+            (...items: any[]): any[];
+            new (arrayLength: number): any[];
+            new (...items: any[]): any[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+            from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            of<T>(...items: T[]): T[];
+            fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+            fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>) => U, thisArg?: any): Promise<Awaited<U>[]>;
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+        default: () => any[];
+    };
+    labelRender: {
+        type: PropType<Func<any, string>>;
+        default: any;
+    };
+    typeRender: {
+        type: PropType<Func<any, TagProps["type"]>>;
+        default: any;
+    };
+    required: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, undefined, boolean>;
+    formItemSize: {
+        type: PropType<"default" | "small" | "large">;
+        default: "default" | "small" | "large";
+    };
+    formItemSlots: {
+        type: PropType<import("@vunk/form/components/form-item/src/types").FormItemSlots>;
+        default: any;
+    };
+    elRef: {
+        type: PropType<any>;
+        required: boolean;
+    };
+    inline: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    readonly: {
+        type: BooleanConstructor;
+        default: any;
+    };
+    formItemTip: {
+        type: StringConstructor;
+        default: any;
+    };
+    formItemTipClass: any;
+    labelTip: {
+        type: StringConstructor;
+        default: any;
+    };
+    information: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    label: StringConstructor;
+    labelWidth: import("element-plus/es/utils").EpPropFinalized<readonly [StringConstructor, NumberConstructor], unknown, unknown, "", boolean>;
+    labelPosition: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "" | "top" | "left" | "right", unknown, "", boolean>;
+    prop: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => string | string[]) | (() => import("element-plus").FormItemProp) | ((new (...args: any[]) => string | string[]) | (() => import("element-plus").FormItemProp))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    rules: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => import("element-plus").FormItemRule | import("element-plus").FormItemRule[]) | (() => import("element-plus/es/utils").Arrayable<import("element-plus").FormItemRule>) | ((new (...args: any[]) => import("element-plus").FormItemRule | import("element-plus").FormItemRule[]) | (() => import("element-plus/es/utils").Arrayable<import("element-plus").FormItemRule>))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    error: StringConstructor;
+    validateStatus: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "error" | "success" | "validating", unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    for: StringConstructor;
+    inlineMessage: import("element-plus/es/utils").EpPropFinalized<readonly [StringConstructor, BooleanConstructor], unknown, unknown, "", boolean>;
+    showMessage: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+};
+export declare const emits: {};

package/components/information-collection/src/index.vue.d.ts

@@ -0,0 +1,232 @@
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    modelValue: {
+        type: {
+            (arrayLength: number): import("@vunk/shared").NormalObject[];
+            (...items: import("@vunk/shared").NormalObject[]): import("@vunk/shared").NormalObject[];
+            new (arrayLength: number): import("@vunk/shared").NormalObject[];
+            new (...items: import("@vunk/shared").NormalObject[]): import("@vunk/shared").NormalObject[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+            from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            of<T>(...items: T[]): T[];
+            fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+            fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>) => U, thisArg?: any): Promise<Awaited<U>[]>;
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+        default: () => any[];
+    };
+    columns: {
+        type: {
+            (arrayLength: number): any[];
+            (...items: any[]): any[];
+            new (arrayLength: number): any[];
+            new (...items: any[]): any[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+            from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            of<T>(...items: T[]): T[];
+            fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+            fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>) => U, thisArg?: any): Promise<Awaited<U>[]>;
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+        default: () => any[];
+    };
+    labelRender: {
+        type: import("vue").PropType<import("@vunk/core").Func<any, string>>;
+        default: any;
+    };
+    typeRender: {
+        type: import("vue").PropType<import("@vunk/core").Func<any, import("element-plus").TagProps["type"]>>;
+        default: any;
+    };
+    required: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, undefined, boolean>;
+    formItemSize: {
+        type: import("vue").PropType<"default" | "small" | "large">;
+        default: "default" | "small" | "large";
+    };
+    formItemSlots: {
+        type: import("vue").PropType<import("@vunk/form/components/form-item/src/types").FormItemSlots>;
+        default: any;
+    };
+    elRef: {
+        type: import("vue").PropType<any>;
+        required: boolean;
+    };
+    inline: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    readonly: {
+        type: BooleanConstructor;
+        default: any;
+    };
+    formItemTip: {
+        type: StringConstructor;
+        default: any;
+    };
+    formItemTipClass: any;
+    labelTip: {
+        type: StringConstructor;
+        default: any;
+    };
+    information: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    label: StringConstructor;
+    labelWidth: import("element-plus/es/utils").EpPropFinalized<readonly [StringConstructor, NumberConstructor], unknown, unknown, "", boolean>;
+    labelPosition: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "" | "top" | "left" | "right", unknown, "", boolean>;
+    prop: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => string | string[]) | (() => import("element-plus").FormItemProp) | ((new (...args: any[]) => string | string[]) | (() => import("element-plus").FormItemProp))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    rules: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => import("element-plus").FormItemRule | import("element-plus").FormItemRule[]) | (() => import("element-plus/es/utils").Arrayable<import("element-plus").FormItemRule>) | ((new (...args: any[]) => import("element-plus").FormItemRule | import("element-plus").FormItemRule[]) | (() => import("element-plus/es/utils").Arrayable<import("element-plus").FormItemRule>))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    error: StringConstructor;
+    validateStatus: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "error" | "success" | "validating", unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    for: StringConstructor;
+    inlineMessage: import("element-plus/es/utils").EpPropFinalized<readonly [StringConstructor, BooleanConstructor], unknown, unknown, "", boolean>;
+    showMessage: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+}>, () => JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    modelValue: {
+        type: {
+            (arrayLength: number): import("@vunk/shared").NormalObject[];
+            (...items: import("@vunk/shared").NormalObject[]): import("@vunk/shared").NormalObject[];
+            new (arrayLength: number): import("@vunk/shared").NormalObject[];
+            new (...items: import("@vunk/shared").NormalObject[]): import("@vunk/shared").NormalObject[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+            from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            of<T>(...items: T[]): T[];
+            fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+            fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>) => U, thisArg?: any): Promise<Awaited<U>[]>;
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+        default: () => any[];
+    };
+    columns: {
+        type: {
+            (arrayLength: number): any[];
+            (...items: any[]): any[];
+            new (arrayLength: number): any[];
+            new (...items: any[]): any[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+            from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            of<T>(...items: T[]): T[];
+            fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+            fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>) => U, thisArg?: any): Promise<Awaited<U>[]>;
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+        default: () => any[];
+    };
+    labelRender: {
+        type: import("vue").PropType<import("@vunk/core").Func<any, string>>;
+        default: any;
+    };
+    typeRender: {
+        type: import("vue").PropType<import("@vunk/core").Func<any, import("element-plus").TagProps["type"]>>;
+        default: any;
+    };
+    required: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, undefined, boolean>;
+    formItemSize: {
+        type: import("vue").PropType<"default" | "small" | "large">;
+        default: "default" | "small" | "large";
+    };
+    formItemSlots: {
+        type: import("vue").PropType<import("@vunk/form/components/form-item/src/types").FormItemSlots>;
+        default: any;
+    };
+    elRef: {
+        type: import("vue").PropType<any>;
+        required: boolean;
+    };
+    inline: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    readonly: {
+        type: BooleanConstructor;
+        default: any;
+    };
+    formItemTip: {
+        type: StringConstructor;
+        default: any;
+    };
+    formItemTipClass: any;
+    labelTip: {
+        type: StringConstructor;
+        default: any;
+    };
+    information: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    label: StringConstructor;
+    labelWidth: import("element-plus/es/utils").EpPropFinalized<readonly [StringConstructor, NumberConstructor], unknown, unknown, "", boolean>;
+    labelPosition: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "" | "top" | "left" | "right", unknown, "", boolean>;
+    prop: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => string | string[]) | (() => import("element-plus").FormItemProp) | ((new (...args: any[]) => string | string[]) | (() => import("element-plus").FormItemProp))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    rules: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => import("element-plus").FormItemRule | import("element-plus").FormItemRule[]) | (() => import("element-plus/es/utils").Arrayable<import("element-plus").FormItemRule>) | ((new (...args: any[]) => import("element-plus").FormItemRule | import("element-plus").FormItemRule[]) | (() => import("element-plus/es/utils").Arrayable<import("element-plus").FormItemRule>))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    error: StringConstructor;
+    validateStatus: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "error" | "success" | "validating", unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    for: StringConstructor;
+    inlineMessage: import("element-plus/es/utils").EpPropFinalized<readonly [StringConstructor, BooleanConstructor], unknown, unknown, "", boolean>;
+    showMessage: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+}>> & Readonly<{}>, {
+    required: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    formItemSize: "default" | "small" | "large";
+    formItemSlots: import("@vunk/form/components/form-item/src/types").FormItemSlots;
+    inline: boolean;
+    readonly: boolean;
+    formItemTip: string;
+    formItemTipClass: any;
+    labelTip: string;
+    information: boolean;
+    labelWidth: import("element-plus/es/utils").EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
+    labelPosition: import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "top" | "left" | "right", unknown>;
+    inlineMessage: import("element-plus/es/utils").EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
+    showMessage: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    modelValue: import("@vunk/shared").NormalObject[];
+    columns: any[];
+    labelRender: ((...args: any) => string) | ((arg: any) => string);
+    typeRender: ((...args: any) => import("element-plus/es/utils").EpPropMergeType<StringConstructor, "success" | "warning" | "info" | "primary" | "danger", unknown>) | ((arg: any) => import("element-plus/es/utils").EpPropMergeType<StringConstructor, "success" | "warning" | "info" | "primary" | "danger", unknown>);
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/components/information-collection/src/types.d.ts

@@ -0,0 +1,6 @@
+import { __VkfInputCollection } from '@vunk/form/components/input-collection';
+import { __VkfTemplatesDefault } from '@vunk/form';
+import { Keyof, NormalObject, VueComponentPropsType } from '@vunk/shared';
+import type Core from './index.vue';
+export type Column<R extends NormalObject = NormalObject, SourceType extends NormalObject = __VkfTemplatesDefault.CoreSource<Keyof<R>>> = __VkfInputCollection.Column<R, SourceType>;
+export type ComponentProps = VueComponentPropsType<typeof Core>;

package/components/information-tag/index.cjs

@@ -0,0 +1,101 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+var elementPlus = require('element-plus');
+var form = require('@vunk/form');
+var _function = require('@vunk/shared/function');
+var elementPlus$1 = require('@vunk/form/shared/element-plus');
+var utilsVue = require('@vunk/core/shared/utils-vue');
+var _pluginVue_exportHelper = require('../_plugin-vue_export-helper.cjs');
+
+const props = {
+  ...elementPlus.tagProps,
+  data: {
+    type: Object,
+    default: () => ({})
+  },
+  labelRender: {
+    type: Function,
+    default: (data) => data.label
+  },
+  title: {
+    type: [String, Function],
+    default: ""
+  },
+  placement: {
+    type: String,
+    default: "top"
+  },
+  formItems: {
+    type: Array,
+    default: () => []
+  },
+  trigger: {
+    type: String,
+    default: "hover"
+  },
+  showAfter: {
+    type: Number,
+    default: 500
+  }
+};
+const emits = {
+  ...elementPlus.tagEmits
+};
+
+function _isSlot(s) {
+  return typeof s === 'function' || Object.prototype.toString.call(s) === '[object Object]' && !vue.isVNode(s);
+}
+var _sfc_main = /* @__PURE__ */ vue.defineComponent({
+  name: "VkfInformationTag",
+  props,
+  emits,
+  setup(props2, {
+    emit,
+    slots
+  }) {
+    const theTitle = vue.computed(() => {
+      return _function.isCallable(props2.title) ? props2.title(props2.data) : props2.title;
+    });
+    const tagProps = elementPlus$1.createTagBindProps(props2);
+    const tagEmits = elementPlus$1.createTagOnEmits(emit);
+    return () => vue.createVNode(elementPlus.ElPopover, {
+      "placement": props2.placement,
+      "title": theTitle.value,
+      "width": 250,
+      "trigger": props2.trigger,
+      "show-after": props2.showAfter
+    }, {
+      reference: () => {
+        let _slot;
+        return vue.createVNode(elementPlus.ElTag, vue.mergeProps({
+          "class": "vkf-information-tag__tag"
+        }, tagProps.value, utilsVue.vOn(tagEmits)), _isSlot(_slot = props2.labelRender(props2.data)) ? _slot : {
+          default: () => [_slot]
+        });
+      },
+      default: () => vue.createVNode(form.VkfInformation, {
+        "data": props2.data,
+        "form-items": props2.formItems
+      }, {
+        default: () => [slots.default?.()]
+      })
+    });
+  }
+});
+
+var VkfInformationTag = /* @__PURE__ */ _pluginVue_exportHelper._export_sfc(_sfc_main, [["__file", "/home/runner/work/private-vunk-form/private-vunk-form/packages/components/information-tag/src/index.vue"]]);
+
+var types = /*#__PURE__*/Object.freeze({
+  __proto__: null
+});
+
+VkfInformationTag.install = (app) => {
+  app.component(VkfInformationTag.name || "VkfInformationTag", VkfInformationTag);
+};
+
+exports.VkfInformationTag = VkfInformationTag;
+exports.__VkfInformationTag = types;
+exports.default = VkfInformationTag;

package/components/information-tag/index.css

@@ -0,0 +1,6 @@
+.vkf-information-tag__tag{
+  cursor: pointer;
+}
+.vkf-information-tag__tag + .vkf-information-tag__tag {
+  margin-left: 0.5em;
+}

package/components/information-tag/index.d.ts

@@ -0,0 +1,4 @@
+import VkfInformationTag from './src/index.vue';
+export * as __VkfInformationTag from './src/types';
+export { VkfInformationTag, };
+export default VkfInformationTag;