@verbb/plugin-kit-vue 2.0.0

package/dist/forms/builtin-field-loaders.d.ts

@@ -0,0 +1,11 @@
+import { SchemaFormFieldComponent } from './engine/context.js';
+type BuiltinFieldLoader = () => Promise<SchemaFormFieldComponent>;
+/**
+ * Built-in SchemaForm `$field` types load on first render so Vue CP bundles only
+ * pay for field facades that appear in the active schema.
+ */
+export declare const builtinFormFieldLoaders: Record<string, BuiltinFieldLoader>;
+export declare const isBuiltinFormFieldType: (name: string) => boolean;
+export declare const loadBuiltinFormField: (name: string) => Promise<SchemaFormFieldComponent | null>;
+export {};
+//# sourceMappingURL=builtin-field-loaders.d.ts.map

package/dist/forms/builtin-field-loaders.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"builtin-field-loaders.d.ts","sourceRoot":"","sources":["../../src/forms/builtin-field-loaders.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,qBAAqB,CAAC;AAEpE,KAAK,kBAAkB,GAAG,MAAM,OAAO,CAAC,wBAAwB,CAAC,CAAC;AAElE;;;GAGG;AACH,eAAO,MAAM,uBAAuB,EAAE,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAatE,CAAC;AAEF,eAAO,MAAM,sBAAsB,GAAI,MAAM,MAAM,KAAG,OAErD,CAAC;AAEF,eAAO,MAAM,oBAAoB,GAAU,MAAM,MAAM,KAAG,OAAO,CAAC,wBAAwB,GAAG,IAAI,CAQhG,CAAC"}

package/dist/forms/builtin-field-loaders.js

@@ -0,0 +1,31 @@
+//#region src/forms/builtin-field-loaders.ts
+/**
+* Built-in SchemaForm `$field` types load on first render so Vue CP bundles only
+* pay for field facades that appear in the active schema.
+*/
+var builtinFormFieldLoaders = {
+	text: async () => (await import("./fields/TextField.js")).TextField,
+	textarea: async () => (await import("./fields/TextareaField.js")).TextareaField,
+	number: async () => (await import("./fields/NumberField.js")).NumberField,
+	select: async () => (await import("./fields/SelectField.js")).SelectField,
+	lightswitch: async () => (await import("./fields/LightswitchField.js")).LightswitchField,
+	color: async () => (await import("./fields/ColorField.js")).ColorField,
+	radioGroup: async () => (await import("./fields/RadioGroupField.js")).RadioGroupField,
+	checkboxSelect: async () => (await import("./fields/CheckboxSelectField.js")).CheckboxSelectField,
+	combobox: async () => (await import("./fields/ComboboxField.js")).ComboboxField,
+	group: async () => (await import("./fields/GroupField.js")).GroupField,
+	date: async () => (await import("./fields/DateTimeField.js")).DateTimeField,
+	codeEditor: async () => (await import("./fields/CodeEditorField.js")).CodeEditorField
+};
+var isBuiltinFormFieldType = (name) => {
+	return Object.prototype.hasOwnProperty.call(builtinFormFieldLoaders, name);
+};
+var loadBuiltinFormField = async (name) => {
+	const loader = builtinFormFieldLoaders[name];
+	if (!loader) return null;
+	return loader();
+};
+//#endregion
+export { isBuiltinFormFieldType, loadBuiltinFormField };
+
+//# sourceMappingURL=builtin-field-loaders.js.map

package/dist/forms/builtin-field-loaders.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"builtin-field-loaders.js","names":[],"sources":["../../src/forms/builtin-field-loaders.ts"],"sourcesContent":["import type { SchemaFormFieldComponent } from './engine/context.js';\n\ntype BuiltinFieldLoader = () => Promise<SchemaFormFieldComponent>;\n\n/**\n * Built-in SchemaForm `$field` types load on first render so Vue CP bundles only\n * pay for field facades that appear in the active schema.\n */\nexport const builtinFormFieldLoaders: Record<string, BuiltinFieldLoader> = {\n    text: async () => (await import('./fields/TextField.js')).TextField as SchemaFormFieldComponent,\n    textarea: async () => (await import('./fields/TextareaField.js')).TextareaField as SchemaFormFieldComponent,\n    number: async () => (await import('./fields/NumberField.js')).NumberField as SchemaFormFieldComponent,\n    select: async () => (await import('./fields/SelectField.js')).SelectField as SchemaFormFieldComponent,\n    lightswitch: async () => (await import('./fields/LightswitchField.js')).LightswitchField as SchemaFormFieldComponent,\n    color: async () => (await import('./fields/ColorField.js')).ColorField as SchemaFormFieldComponent,\n    radioGroup: async () => (await import('./fields/RadioGroupField.js')).RadioGroupField as SchemaFormFieldComponent,\n    checkboxSelect: async () => (await import('./fields/CheckboxSelectField.js')).CheckboxSelectField as SchemaFormFieldComponent,\n    combobox: async () => (await import('./fields/ComboboxField.js')).ComboboxField as SchemaFormFieldComponent,\n    group: async () => (await import('./fields/GroupField.js')).GroupField as SchemaFormFieldComponent,\n    date: async () => (await import('./fields/DateTimeField.js')).DateTimeField as SchemaFormFieldComponent,\n    codeEditor: async () => (await import('./fields/CodeEditorField.js')).CodeEditorField as SchemaFormFieldComponent,\n};\n\nexport const isBuiltinFormFieldType = (name: string): boolean => {\n    return Object.prototype.hasOwnProperty.call(builtinFormFieldLoaders, name);\n};\n\nexport const loadBuiltinFormField = async (name: string): Promise<SchemaFormFieldComponent | null> => {\n    const loader = builtinFormFieldLoaders[name];\n\n    if (!loader) {\n        return null;\n    }\n\n    return loader();\n};\n"],"mappings":";;;;;AAQA,IAAa,0BAA8D;CACvE,MAAM,aAAa,MAAM,OAAO,0BAA0B;CAC1D,UAAU,aAAa,MAAM,OAAO,8BAA8B;CAClE,QAAQ,aAAa,MAAM,OAAO,4BAA4B;CAC9D,QAAQ,aAAa,MAAM,OAAO,4BAA4B;CAC9D,aAAa,aAAa,MAAM,OAAO,iCAAiC;CACxE,OAAO,aAAa,MAAM,OAAO,2BAA2B;CAC5D,YAAY,aAAa,MAAM,OAAO,gCAAgC;CACtE,gBAAgB,aAAa,MAAM,OAAO,oCAAoC;CAC9E,UAAU,aAAa,MAAM,OAAO,8BAA8B;CAClE,OAAO,aAAa,MAAM,OAAO,2BAA2B;CAC5D,MAAM,aAAa,MAAM,OAAO,8BAA8B;CAC9D,YAAY,aAAa,MAAM,OAAO,gCAAgC;CACzE;AAED,IAAa,0BAA0B,SAA0B;AAC7D,QAAO,OAAO,UAAU,eAAe,KAAK,yBAAyB,KAAK;;AAG9E,IAAa,uBAAuB,OAAO,SAA2D;CAClG,MAAM,SAAS,wBAAwB;AAEvC,KAAI,CAAC,OACD,QAAO;AAGX,QAAO,QAAQ"}

package/dist/forms/components/FieldWrap.d.ts

@@ -0,0 +1,124 @@
+import { PropType } from 'vue';
+import { SchemaFormComponentProps } from '../engine/context.js';
+/**
+ * Schema `$cmp: 'FieldWrap'` labels a control cluster and promotes nested errors
+ * onto the wrapper, matching the v1/Formie field-wrap contract.
+ */
+export declare const FieldWrap: {
+    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
+        name: {
+            type: StringConstructor;
+            default: undefined;
+        };
+        label: {
+            type: StringConstructor;
+            default: undefined;
+        };
+        instructions: {
+            type: StringConstructor;
+            default: undefined;
+        };
+        required: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        warning: {
+            type: StringConstructor;
+            default: undefined;
+        };
+        schemaNode: {
+            type: PropType<SchemaFormComponentProps["schemaNode"]>;
+            default: undefined;
+        };
+    }>> & Readonly<{}>, () => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+        [key: string]: any;
+    }>, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {
+        name: string;
+        label: string;
+        required: boolean;
+        instructions: string;
+        warning: string;
+        schemaNode: import('@verbb/plugin-kit-forms').SchemaNode | undefined;
+    }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import('vue').ExtractPropTypes<{
+        name: {
+            type: StringConstructor;
+            default: undefined;
+        };
+        label: {
+            type: StringConstructor;
+            default: undefined;
+        };
+        instructions: {
+            type: StringConstructor;
+            default: undefined;
+        };
+        required: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        warning: {
+            type: StringConstructor;
+            default: undefined;
+        };
+        schemaNode: {
+            type: PropType<SchemaFormComponentProps["schemaNode"]>;
+            default: undefined;
+        };
+    }>> & Readonly<{}>, () => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+        [key: string]: any;
+    }>, {}, {}, {}, {
+        name: string;
+        label: string;
+        required: boolean;
+        instructions: string;
+        warning: string;
+        schemaNode: import('@verbb/plugin-kit-forms').SchemaNode | undefined;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
+    name: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    label: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    instructions: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    required: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    warning: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    schemaNode: {
+        type: PropType<SchemaFormComponentProps["schemaNode"]>;
+        default: undefined;
+    };
+}>> & Readonly<{}>, () => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {
+    name: string;
+    label: string;
+    required: boolean;
+    instructions: string;
+    warning: string;
+    schemaNode: import('@verbb/plugin-kit-forms').SchemaNode | undefined;
+}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & {
+    usesSchemaNode: true;
+};
+//# sourceMappingURL=FieldWrap.d.ts.map

package/dist/forms/components/FieldWrap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FieldWrap.d.ts","sourceRoot":"","sources":["../../../src/forms/components/FieldWrap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAsD,KAAK,QAAQ,EAAE,MAAM,KAAK,CAAC;AAIxF,OAAO,EAA0B,KAAK,wBAAwB,EAAE,MAAM,sBAAsB,CAAC;AAmB7F;;;GAGG;AACH,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;kBAQgB,QAAQ,CAAC,wBAAwB,CAAC,YAAY,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAAhD,QAAQ,CAAC,wBAAwB,CAAC,YAAY,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAAhD,QAAQ,CAAC,wBAAwB,CAAC,YAAY,CAAC,CAAC;;;;;;;;;;;;;;CA4EhD,CAAC"}

package/dist/forms/components/FieldWrap.js

@@ -0,0 +1,99 @@
+import { FieldLayout } from "../Field.js";
+import { useSchemaEngineContext } from "../engine/context.js";
+import { collectSchemaFieldNames } from "./schemaErrors.js";
+import { computed, defineComponent, h, onBeforeUnmount, ref } from "vue";
+//#region src/forms/components/FieldWrap.ts
+var ATTRIBUTE_MESSAGE_PATTERN = /^(.+?) (cannot be blank\.|must be .+)$/;
+var formatWrapperMessage = (message, wrapperLabel) => {
+	if (!wrapperLabel) return message;
+	const match = String(message).match(ATTRIBUTE_MESSAGE_PATTERN);
+	if (match) {
+		const [, , suffix] = match;
+		return `${wrapperLabel} ${suffix}`;
+	}
+	return `${wrapperLabel} ${message}`;
+};
+/**
+* Schema `$cmp: 'FieldWrap'` labels a control cluster and promotes nested errors
+* onto the wrapper, matching the v1/Formie field-wrap contract.
+*/
+var FieldWrap = Object.assign(defineComponent({
+	name: "SchemaFieldWrap",
+	props: {
+		name: {
+			type: String,
+			default: void 0
+		},
+		label: {
+			type: String,
+			default: void 0
+		},
+		instructions: {
+			type: String,
+			default: void 0
+		},
+		required: {
+			type: Boolean,
+			default: false
+		},
+		warning: {
+			type: String,
+			default: void 0
+		},
+		schemaNode: {
+			type: Object,
+			default: void 0
+		}
+	},
+	setup(props, { slots }) {
+		const form = useSchemaEngineContext();
+		const version = ref(0);
+		onBeforeUnmount(form.store.subscribe(() => {
+			version.value += 1;
+		}));
+		const fieldName = computed(() => props.name || props.label || "field");
+		const nestedFieldNames = computed(() => {
+			return Array.from(collectSchemaFieldNames(props.schemaNode?.children || []));
+		});
+		const errors = computed(() => {
+			version.value;
+			if (props.name && typeof form.getGroupedErrorsForPath === "function") return form.getGroupedErrorsForPath(props.name) || [];
+			if (!nestedFieldNames.value.length) return [];
+			const errorMap = form.getErrorMapFields() || {};
+			const groupedErrors = [];
+			nestedFieldNames.value.forEach((fieldPath) => {
+				(errorMap[fieldPath] || []).forEach((message) => {
+					groupedErrors.push(formatWrapperMessage(String(message), props.label || props.name || fieldName.value));
+				});
+				Object.entries(errorMap).forEach(([errorPath, messages]) => {
+					if (!errorPath.startsWith(`${fieldPath}.`)) return;
+					(messages || []).forEach((message) => {
+						groupedErrors.push(formatWrapperMessage(String(message), props.label || props.name || fieldName.value));
+					});
+				});
+			});
+			return Array.from(new Set(groupedErrors));
+		});
+		return () => h(FieldLayout, {
+			name: fieldName.value,
+			label: props.label,
+			instructions: props.instructions,
+			required: props.required,
+			warning: props.warning,
+			errors: errors.value
+		}, { default: () => h("div", {
+			"data-pk-field-wrap-controls": "",
+			style: {
+				display: "flex",
+				alignItems: "center",
+				flexDirection: "row",
+				flexWrap: "wrap",
+				gap: "0.5rem"
+			}
+		}, slots.default?.() ?? []) });
+	}
+}), { usesSchemaNode: true });
+//#endregion
+export { FieldWrap };
+
+//# sourceMappingURL=FieldWrap.js.map

package/dist/forms/components/FieldWrap.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"FieldWrap.js","names":[],"sources":["../../../src/forms/components/FieldWrap.ts"],"sourcesContent":["import { computed, defineComponent, h, onBeforeUnmount, ref, type PropType } from 'vue';\nimport type { SchemaRenderable } from '@verbb/plugin-kit-forms';\n\nimport { FieldLayout } from '../Field.js';\nimport { useSchemaEngineContext, type SchemaFormComponentProps } from '../engine/context.js';\nimport { collectSchemaFieldNames } from './schemaErrors.js';\n\nconst ATTRIBUTE_MESSAGE_PATTERN = /^(.+?) (cannot be blank\\.|must be .+)$/;\n\nconst formatWrapperMessage = (message: string, wrapperLabel?: string): string => {\n    if (!wrapperLabel) {\n        return message;\n    }\n\n    const match = String(message).match(ATTRIBUTE_MESSAGE_PATTERN);\n    if (match) {\n        const [, , suffix] = match;\n        return `${wrapperLabel} ${suffix}`;\n    }\n\n    return `${wrapperLabel} ${message}`;\n};\n\n/**\n * Schema `$cmp: 'FieldWrap'` labels a control cluster and promotes nested errors\n * onto the wrapper, matching the v1/Formie field-wrap contract.\n */\nexport const FieldWrap = Object.assign(defineComponent({\n    name: 'SchemaFieldWrap',\n    props: {\n        name: { type: String, default: undefined },\n        label: { type: String, default: undefined },\n        instructions: { type: String, default: undefined },\n        required: { type: Boolean, default: false },\n        warning: { type: String, default: undefined },\n        schemaNode: { type: Object as PropType<SchemaFormComponentProps['schemaNode']>, default: undefined },\n    },\n    setup(props, { slots }) {\n        const form = useSchemaEngineContext();\n        const version = ref(0);\n        const unsubscribe = form.store.subscribe(() => {\n            version.value += 1;\n        });\n\n        onBeforeUnmount(unsubscribe);\n\n        const fieldName = computed(() => props.name || props.label || 'field');\n        const nestedFieldNames = computed(() => {\n            return Array.from(collectSchemaFieldNames((props.schemaNode?.children || []) as SchemaRenderable));\n        });\n        const errors = computed(() => {\n            version.value;\n\n            if (props.name && typeof form.getGroupedErrorsForPath === 'function') {\n                return form.getGroupedErrorsForPath(props.name) || [];\n            }\n\n            if (!nestedFieldNames.value.length) {\n                return [];\n            }\n\n            const errorMap = form.getErrorMapFields() || {};\n            const groupedErrors: string[] = [];\n\n            nestedFieldNames.value.forEach((fieldPath) => {\n                (errorMap[fieldPath] || []).forEach((message) => {\n                    groupedErrors.push(formatWrapperMessage(String(message), props.label || props.name || fieldName.value));\n                });\n\n                Object.entries(errorMap).forEach(([errorPath, messages]) => {\n                    if (!errorPath.startsWith(`${fieldPath}.`)) {\n                        return;\n                    }\n\n                    (messages || []).forEach((message) => {\n                        groupedErrors.push(formatWrapperMessage(String(message), props.label || props.name || fieldName.value));\n                    });\n                });\n            });\n\n            return Array.from(new Set(groupedErrors));\n        });\n\n        return () => h(\n            FieldLayout,\n            {\n                name: fieldName.value,\n                label: props.label,\n                instructions: props.instructions,\n                required: props.required,\n                warning: props.warning,\n                errors: errors.value,\n            },\n            {\n                default: () => h(\n                    'div',\n                    {\n                        'data-pk-field-wrap-controls': '',\n                        style: {\n                            display: 'flex',\n                            alignItems: 'center',\n                            flexDirection: 'row',\n                            flexWrap: 'wrap',\n                            gap: '0.5rem',\n                        },\n                    },\n                    slots.default?.() ?? [],\n                ),\n            },\n        );\n    },\n}), { usesSchemaNode: true as const });\n"],"mappings":";;;;;AAOA,IAAM,4BAA4B;AAElC,IAAM,wBAAwB,SAAiB,iBAAkC;AAC7E,KAAI,CAAC,aACD,QAAO;CAGX,MAAM,QAAQ,OAAO,QAAQ,CAAC,MAAM,0BAA0B;AAC9D,KAAI,OAAO;EACP,MAAM,KAAK,UAAU;AACrB,SAAO,GAAG,aAAa,GAAG;;AAG9B,QAAO,GAAG,aAAa,GAAG;;;;;;AAO9B,IAAa,YAAY,OAAO,OAAO,gBAAgB;CACnD,MAAM;CACN,OAAO;EACH,MAAM;GAAE,MAAM;GAAQ,SAAS,KAAA;GAAW;EAC1C,OAAO;GAAE,MAAM;GAAQ,SAAS,KAAA;GAAW;EAC3C,cAAc;GAAE,MAAM;GAAQ,SAAS,KAAA;GAAW;EAClD,UAAU;GAAE,MAAM;GAAS,SAAS;GAAO;EAC3C,SAAS;GAAE,MAAM;GAAQ,SAAS,KAAA;GAAW;EAC7C,YAAY;GAAE,MAAM;GAA4D,SAAS,KAAA;GAAW;EACvG;CACD,MAAM,OAAO,EAAE,SAAS;EACpB,MAAM,OAAO,wBAAwB;EACrC,MAAM,UAAU,IAAI,EAAE;AAKtB,kBAJoB,KAAK,MAAM,gBAAgB;AAC3C,WAAQ,SAAS;IAGL,CAAY;EAE5B,MAAM,YAAY,eAAe,MAAM,QAAQ,MAAM,SAAS,QAAQ;EACtE,MAAM,mBAAmB,eAAe;AACpC,UAAO,MAAM,KAAK,wBAAyB,MAAM,YAAY,YAAY,EAAE,CAAsB,CAAC;IACpG;EACF,MAAM,SAAS,eAAe;AAC1B,WAAQ;AAER,OAAI,MAAM,QAAQ,OAAO,KAAK,4BAA4B,WACtD,QAAO,KAAK,wBAAwB,MAAM,KAAK,IAAI,EAAE;AAGzD,OAAI,CAAC,iBAAiB,MAAM,OACxB,QAAO,EAAE;GAGb,MAAM,WAAW,KAAK,mBAAmB,IAAI,EAAE;GAC/C,MAAM,gBAA0B,EAAE;AAElC,oBAAiB,MAAM,SAAS,cAAc;AAC1C,KAAC,SAAS,cAAc,EAAE,EAAE,SAAS,YAAY;AAC7C,mBAAc,KAAK,qBAAqB,OAAO,QAAQ,EAAE,MAAM,SAAS,MAAM,QAAQ,UAAU,MAAM,CAAC;MACzG;AAEF,WAAO,QAAQ,SAAS,CAAC,SAAS,CAAC,WAAW,cAAc;AACxD,SAAI,CAAC,UAAU,WAAW,GAAG,UAAU,GAAG,CACtC;AAGJ,MAAC,YAAY,EAAE,EAAE,SAAS,YAAY;AAClC,oBAAc,KAAK,qBAAqB,OAAO,QAAQ,EAAE,MAAM,SAAS,MAAM,QAAQ,UAAU,MAAM,CAAC;OACzG;MACJ;KACJ;AAEF,UAAO,MAAM,KAAK,IAAI,IAAI,cAAc,CAAC;IAC3C;AAEF,eAAa,EACT,aACA;GACI,MAAM,UAAU;GAChB,OAAO,MAAM;GACb,cAAc,MAAM;GACpB,UAAU,MAAM;GAChB,SAAS,MAAM;GACf,QAAQ,OAAO;GAClB,EACD,EACI,eAAe,EACX,OACA;GACI,+BAA+B;GAC/B,OAAO;IACH,SAAS;IACT,YAAY;IACZ,eAAe;IACf,UAAU;IACV,KAAK;IACR;GACJ,EACD,MAAM,WAAW,IAAI,EAAE,CAC1B,EACJ,CACJ;;CAER,CAAC,EAAE,EAAE,gBAAgB,MAAe,CAAC"}

package/dist/forms/components/ModalTabs.d.ts

@@ -0,0 +1,147 @@
+import { Ref, PropType } from 'vue';
+import { SchemaNode } from '@verbb/plugin-kit-forms';
+import { SchemaFormComponentProps } from '../engine/context.js';
+export declare const useModalTabsErrors: () => Ref<Record<string, boolean>>;
+/**
+ * Schema `$cmp: 'ModalTabs'` wraps stock `Tabs variant="modal"` and keeps tab
+ * error markers in sync with the shared SchemaForm store.
+ */
+export declare const ModalTabs: {
+    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
+        schemaNode: {
+            type: PropType<SchemaFormComponentProps["schemaNode"]>;
+            default: undefined;
+        };
+        class: {
+            type: PropType<unknown>;
+            default: undefined;
+        };
+        value: {
+            type: StringConstructor;
+            default: undefined;
+        };
+        defaultValue: {
+            type: StringConstructor;
+            default: string;
+        };
+    }>> & Readonly<{}>, () => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+        [key: string]: any;
+    }>, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {
+        class: undefined;
+        value: string;
+        schemaNode: SchemaNode | undefined;
+        defaultValue: string;
+    }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import('vue').ExtractPropTypes<{
+        schemaNode: {
+            type: PropType<SchemaFormComponentProps["schemaNode"]>;
+            default: undefined;
+        };
+        class: {
+            type: PropType<unknown>;
+            default: undefined;
+        };
+        value: {
+            type: StringConstructor;
+            default: undefined;
+        };
+        defaultValue: {
+            type: StringConstructor;
+            default: string;
+        };
+    }>> & Readonly<{}>, () => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+        [key: string]: any;
+    }>, {}, {}, {}, {
+        class: undefined;
+        value: string;
+        schemaNode: SchemaNode | undefined;
+        defaultValue: string;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
+    schemaNode: {
+        type: PropType<SchemaFormComponentProps["schemaNode"]>;
+        default: undefined;
+    };
+    class: {
+        type: PropType<unknown>;
+        default: undefined;
+    };
+    value: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    defaultValue: {
+        type: StringConstructor;
+        default: string;
+    };
+}>> & Readonly<{}>, () => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {
+    class: undefined;
+    value: string;
+    schemaNode: SchemaNode | undefined;
+    defaultValue: string;
+}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & {
+    usesSchemaNode: true;
+};
+export declare const ModalTabsList: import('vue').DefineComponent<{}, () => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+    [key: string]: any;
+}>[] | undefined, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export declare const ModalTabsTrigger: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    value: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    class: {
+        type: PropType<unknown>;
+        default: undefined;
+    };
+}>, () => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    value: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    class: {
+        type: PropType<unknown>;
+        default: undefined;
+    };
+}>> & Readonly<{}>, {
+    class: undefined;
+    value: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export declare const ModalTabsContent: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    class: {
+        type: PropType<unknown>;
+        default: undefined;
+    };
+    value: {
+        type: StringConstructor;
+        default: undefined;
+    };
+}>, () => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    class: {
+        type: PropType<unknown>;
+        default: undefined;
+    };
+    value: {
+        type: StringConstructor;
+        default: undefined;
+    };
+}>> & Readonly<{}>, {
+    class: undefined;
+    value: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+//# sourceMappingURL=ModalTabs.d.ts.map

package/dist/forms/components/ModalTabs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ModalTabs.d.ts","sourceRoot":"","sources":["../../../src/forms/components/ModalTabs.ts"],"names":[],"mappings":"AAAA,OAAO,EAQH,KAAK,GAAG,EAER,KAAK,QAAQ,EAEhB,MAAM,KAAK,CAAC;AACb,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AAG1D,OAAO,EAA0B,KAAK,wBAAwB,EAAE,MAAM,sBAAsB,CAAC;AAK7F,eAAO,MAAM,kBAAkB,QAAO,GAAG,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAEhE,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,SAAS;;;kBAGgB,QAAQ,CAAC,wBAAwB,CAAC,YAAY,CAAC,CAAC;;;;kBAC5C,QAAQ,CAAC,OAAO,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;kBADrB,QAAQ,CAAC,wBAAwB,CAAC,YAAY,CAAC,CAAC;;;;kBAC5C,QAAQ,CAAC,OAAO,CAAC;;;;;;;;;;;;;;;;;;;;;;;;cADrB,QAAQ,CAAC,wBAAwB,CAAC,YAAY,CAAC,CAAC;;;;cAC5C,QAAQ,CAAC,OAAO,CAAC;;;;;;;;;;;;;;;;;;;;CAsErB,CAAC;AAEvC,eAAO,MAAM,aAAa;;yPAKxB,CAAC;AAEH,eAAO,MAAM,gBAAgB;;;;;;cAIa,QAAQ,CAAC,OAAO,CAAC;;;;;;;;;;;cAAjB,QAAQ,CAAC,OAAO,CAAC;;;;;;4EA0BzD,CAAC;AAEH,eAAO,MAAM,gBAAgB;;cAGa,QAAQ,CAAC,OAAO,CAAC;;;;;;;;;;;cAAjB,QAAQ,CAAC,OAAO,CAAC;;;;;;;;;;4EAgBzD,CAAC"}

package/dist/forms/components/ModalTabs.js

@@ -0,0 +1,135 @@
+import { Icon } from "../../components/Icon.js";
+import { Tab, TabPanel, Tabs } from "../../components/Tabs.js";
+import { SchemaEngineContextKey } from "../engine/context.js";
+import { schemaSubtreeHasErrors } from "./schemaErrors.js";
+import { computed, defineComponent, h, inject, onBeforeUnmount, provide, ref } from "vue";
+//#region src/forms/components/ModalTabs.ts
+var ModalTabsErrorsContext = Symbol("ModalTabsErrorsContext");
+var useModalTabsErrors = () => {
+	return inject(ModalTabsErrorsContext, ref({}));
+};
+/**
+* Schema `$cmp: 'ModalTabs'` wraps stock `Tabs variant="modal"` and keeps tab
+* error markers in sync with the shared SchemaForm store.
+*/
+var ModalTabs = Object.assign(defineComponent({
+	name: "SchemaModalTabs",
+	props: {
+		schemaNode: {
+			type: Object,
+			default: void 0
+		},
+		class: {
+			type: null,
+			default: void 0
+		},
+		value: {
+			type: String,
+			default: void 0
+		},
+		defaultValue: {
+			type: String,
+			default: ""
+		}
+	},
+	setup(props, { attrs, slots }) {
+		const form = inject(SchemaEngineContextKey, null);
+		const tabErrors = ref({});
+		const uncontrolledValue = ref(props.value ?? props.defaultValue ?? "");
+		const isControlled = computed(() => props.value !== void 0 && props.value !== null);
+		const resolvedValue = computed(() => isControlled.value ? String(props.value) : uncontrolledValue.value);
+		const getTabErrors = () => {
+			const errors = {};
+			const children = props.schemaNode?.children;
+			if (!children || !form?.getErrorMapFields) return errors;
+			const formErrors = form.getErrorMapFields() || {};
+			(Array.isArray(children) ? children : Object.values(children)).forEach((item) => {
+				if (typeof item !== "object" || item === null || Array.isArray(item)) return;
+				const childNode = item;
+				const value = typeof childNode.props?.value === "string" ? childNode.props.value : "";
+				if (childNode.$cmp === "ModalTabsContent" && value) errors[value] = schemaSubtreeHasErrors(formErrors, childNode.children || []);
+			});
+			return errors;
+		};
+		const updateTabErrors = () => {
+			tabErrors.value = getTabErrors();
+		};
+		updateTabErrors();
+		const unsubscribe = form?.store?.subscribe(updateTabErrors);
+		if (unsubscribe) onBeforeUnmount(unsubscribe);
+		provide(ModalTabsErrorsContext, tabErrors);
+		return () => {
+			return h(Tabs, {
+				...attrs,
+				variant: "modal",
+				value: resolvedValue.value,
+				class: ["h-full min-h-0", props.class],
+				onPkChange: (event) => {
+					event.stopPropagation();
+					const next = event.detail?.value;
+					if (typeof next !== "string" || !next || isControlled.value) return;
+					uncontrolledValue.value = next;
+				}
+			}, { default: () => slots.default?.() });
+		};
+	}
+}), { usesSchemaNode: true });
+var ModalTabsList = defineComponent({
+	name: "SchemaModalTabsList",
+	setup(_props, { slots }) {
+		return () => slots.default?.();
+	}
+});
+var ModalTabsTrigger = defineComponent({
+	name: "SchemaModalTabsTrigger",
+	props: {
+		value: {
+			type: String,
+			default: void 0
+		},
+		class: {
+			type: null,
+			default: void 0
+		}
+	},
+	setup(props, { attrs, slots }) {
+		const tabErrors = useModalTabsErrors();
+		return () => {
+			const hasErrors = Boolean(props.value && tabErrors.value[props.value]);
+			return h(Tab, {
+				...attrs,
+				value: props.value,
+				"data-has-errors": hasErrors ? "true" : void 0,
+				class: [hasErrors ? "text-[var(--pk-color-rose-600,#e11d48)]" : void 0, props.class],
+				slot: "nav"
+			}, { default: () => [...slots.default?.() ?? [], hasErrors ? h(Icon, {
+				icon: "triangle-exclamation",
+				class: "block size-3"
+			}) : null] });
+		};
+	}
+});
+var ModalTabsContent = defineComponent({
+	name: "SchemaModalTabsContent",
+	props: {
+		class: {
+			type: null,
+			default: void 0
+		},
+		value: {
+			type: String,
+			default: void 0
+		}
+	},
+	setup(props, { attrs, slots }) {
+		return () => h(TabPanel, {
+			...attrs,
+			value: props.value,
+			class: props.class
+		}, { default: () => h("div", { class: "grid grid-cols-1 gap-4" }, slots.default?.()) });
+	}
+});
+//#endregion
+export { ModalTabs, ModalTabsContent, ModalTabsList, ModalTabsTrigger, useModalTabsErrors };
+
+//# sourceMappingURL=ModalTabs.js.map

package/dist/forms/components/ModalTabs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ModalTabs.js","names":[],"sources":["../../../src/forms/components/ModalTabs.ts"],"sourcesContent":["import {\n    computed,\n    defineComponent,\n    h,\n    inject,\n    onBeforeUnmount,\n    provide,\n    ref,\n    type Ref,\n    type InjectionKey,\n    type PropType,\n    type Component,\n} from 'vue';\nimport type { SchemaNode } from '@verbb/plugin-kit-forms';\n\nimport { Icon, Tab, TabPanel, Tabs } from '../../components/index.js';\nimport { SchemaEngineContextKey, type SchemaFormComponentProps } from '../engine/context.js';\nimport { schemaSubtreeHasErrors } from './schemaErrors.js';\n\nconst ModalTabsErrorsContext: InjectionKey<Ref<Record<string, boolean>>> = Symbol('ModalTabsErrorsContext');\n\nexport const useModalTabsErrors = (): Ref<Record<string, boolean>> => {\n    return inject(ModalTabsErrorsContext, ref({}));\n};\n\n/**\n * Schema `$cmp: 'ModalTabs'` wraps stock `Tabs variant=\"modal\"` and keeps tab\n * error markers in sync with the shared SchemaForm store.\n */\nexport const ModalTabs = Object.assign(defineComponent({\n    name: 'SchemaModalTabs',\n    props: {\n        schemaNode: { type: Object as PropType<SchemaFormComponentProps['schemaNode']>, default: undefined },\n        class: { type: null as unknown as PropType<unknown>, default: undefined },\n        value: { type: String, default: undefined },\n        defaultValue: { type: String, default: '' },\n    },\n    setup(props, { attrs, slots }) {\n        const form = inject(SchemaEngineContextKey, null);\n        const tabErrors = ref<Record<string, boolean>>({});\n        const uncontrolledValue = ref(props.value ?? props.defaultValue ?? '');\n        const isControlled = computed(() => props.value !== undefined && props.value !== null);\n        const resolvedValue = computed(() => (isControlled.value ? String(props.value) : uncontrolledValue.value));\n\n        const getTabErrors = (): Record<string, boolean> => {\n            const errors: Record<string, boolean> = {};\n            const children = props.schemaNode?.children;\n\n            if (!children || !form?.getErrorMapFields) {\n                return errors;\n            }\n\n            const formErrors = form.getErrorMapFields() || {};\n            const values = Array.isArray(children) ? children : Object.values(children as Record<string, unknown>);\n\n            values.forEach((item) => {\n                if (typeof item !== 'object' || item === null || Array.isArray(item)) {\n                    return;\n                }\n\n                const childNode = item as SchemaNode;\n                const value = typeof childNode.props?.value === 'string' ? childNode.props.value : '';\n                if (childNode.$cmp === 'ModalTabsContent' && value) {\n                    errors[value] = schemaSubtreeHasErrors(formErrors, childNode.children || []);\n                }\n            });\n\n            return errors;\n        };\n\n        const updateTabErrors = () => {\n            tabErrors.value = getTabErrors();\n        };\n\n        updateTabErrors();\n        const unsubscribe = form?.store?.subscribe(updateTabErrors);\n        if (unsubscribe) {\n            onBeforeUnmount(unsubscribe);\n        }\n\n        provide(ModalTabsErrorsContext, tabErrors);\n\n        return () => {\n            return h(\n                Tabs as Component,\n                {\n                    ...attrs,\n                    variant: 'modal',\n                    value: resolvedValue.value,\n                    class: ['h-full min-h-0', props.class],\n                    onPkChange: (event: Event) => {\n                        event.stopPropagation();\n                        const next = (event as CustomEvent<{ value?: string }>).detail?.value;\n                        if (typeof next !== 'string' || !next || isControlled.value) {\n                            return;\n                        }\n                        uncontrolledValue.value = next;\n                    },\n                },\n                { default: () => slots.default?.() },\n            );\n        };\n    },\n}), { usesSchemaNode: true as const });\n\nexport const ModalTabsList = defineComponent({\n    name: 'SchemaModalTabsList',\n    setup(_props, { slots }) {\n        return () => slots.default?.();\n    },\n});\n\nexport const ModalTabsTrigger = defineComponent({\n    name: 'SchemaModalTabsTrigger',\n    props: {\n        value: { type: String, default: undefined },\n        class: { type: null as unknown as PropType<unknown>, default: undefined },\n    },\n    setup(props, { attrs, slots }) {\n        const tabErrors = useModalTabsErrors();\n\n        return () => {\n            const hasErrors = Boolean(props.value && tabErrors.value[props.value]);\n\n            return h(\n                Tab as Component,\n                {\n                    ...attrs,\n                    value: props.value,\n                    'data-has-errors': hasErrors ? 'true' : undefined,\n                    class: [hasErrors ? 'text-[var(--pk-color-rose-600,#e11d48)]' : undefined, props.class],\n                    slot: 'nav',\n                },\n                {\n                    default: () => [\n                        ...(slots.default?.() ?? []),\n                        hasErrors ? h(Icon as Component, { icon: 'triangle-exclamation', class: 'block size-3' }) : null,\n                    ],\n                },\n            );\n        };\n    },\n});\n\nexport const ModalTabsContent = defineComponent({\n    name: 'SchemaModalTabsContent',\n    props: {\n        class: { type: null as unknown as PropType<unknown>, default: undefined },\n        value: { type: String, default: undefined },\n    },\n    setup(props, { attrs, slots }) {\n        return () => h(\n            TabPanel as Component,\n            {\n                ...attrs,\n                value: props.value,\n                class: props.class,\n            },\n            {\n                default: () => h('div', { class: 'grid grid-cols-1 gap-4' }, slots.default?.()),\n            },\n        );\n    },\n});\n"],"mappings":"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"}

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

@@ -0,0 +1,3 @@
+export { FieldWrap, } from './FieldWrap.js';
+export { ModalTabs, ModalTabsList, ModalTabsTrigger, ModalTabsContent, useModalTabsErrors, } from './ModalTabs.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/forms/components/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/forms/components/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACH,SAAS,GACZ,MAAM,gBAAgB,CAAC;AACxB,OAAO,EACH,SAAS,EACT,aAAa,EACb,gBAAgB,EAChB,gBAAgB,EAChB,kBAAkB,GACrB,MAAM,gBAAgB,CAAC"}

package/dist/forms/components/schemaErrors.d.ts

@@ -0,0 +1,4 @@
+import { SchemaRenderable } from '@verbb/plugin-kit-forms';
+export declare const collectSchemaFieldNames: (schema: SchemaRenderable) => Set<string>;
+export declare const schemaSubtreeHasErrors: (errors: Record<string, unknown>, schema: SchemaRenderable) => boolean;
+//# sourceMappingURL=schemaErrors.d.ts.map

package/dist/forms/components/schemaErrors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemaErrors.d.ts","sourceRoot":"","sources":["../../../src/forms/components/schemaErrors.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAc,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAM5E,eAAO,MAAM,uBAAuB,GAAI,QAAQ,gBAAgB,KAAG,GAAG,CAAC,MAAM,CAiC5E,CAAC;AAEF,eAAO,MAAM,sBAAsB,GAC/B,QAAQ,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC/B,QAAQ,gBAAgB,KACzB,OAYF,CAAC"}

package/dist/forms/components/schemaErrors.js

@@ -0,0 +1,34 @@
+//#region src/forms/components/schemaErrors.ts
+var isRecord = (value) => {
+	return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+};
+var collectSchemaFieldNames = (schema) => {
+	const names = /* @__PURE__ */ new Set();
+	const walk = (node) => {
+		if (typeof node === "string") return;
+		if (Array.isArray(node)) {
+			node.forEach(walk);
+			return;
+		}
+		if (!isRecord(node)) return;
+		const schemaNode = node;
+		if (schemaNode.$field && typeof schemaNode.name === "string" && schemaNode.name) names.add(schemaNode.name);
+		if (schemaNode.children) walk(schemaNode.children);
+		if (schemaNode.schema) walk(schemaNode.schema);
+	};
+	walk(schema);
+	return names;
+};
+var schemaSubtreeHasErrors = (errors, schema) => {
+	const fieldNames = collectSchemaFieldNames(schema);
+	return Array.from(fieldNames).some((fieldName) => {
+		if (Array.isArray(errors[fieldName]) && errors[fieldName].length > 0) return true;
+		return Object.keys(errors).some((errorPath) => {
+			return errorPath.startsWith(`${fieldName}.`);
+		});
+	});
+};
+//#endregion
+export { collectSchemaFieldNames, schemaSubtreeHasErrors };
+
+//# sourceMappingURL=schemaErrors.js.map