@morscherlab/mint-sdk 1.0.0 → 1.0.1

package/dist/useFormBuilder-COfYWDuC.js

@@ -0,0 +1,729 @@
+import { D as getTypeDefault, E as getFieldRegistryEntry } from "./useControlSchema-0n8Bcftq.js";
+import { computed, onMounted, onUnmounted, reactive, ref, shallowRef, toRaw, watch } from "vue";
+//#region src/composables/usePlatformContext.ts
+var DEFAULT_CONTEXT = {
+	isIntegrated: false,
+	theme: "system"
+};
+var platformContext = ref({ ...DEFAULT_CONTEXT });
+var inferredOrigins = /* @__PURE__ */ new Set();
+var allowedOrigins = /* @__PURE__ */ new Set();
+var allowAnyOrigin = false;
+var initialized = false;
+var listenerCount = 0;
+var nextConsumerId = 0;
+var currentHandler = null;
+var consumerOrigins = /* @__PURE__ */ new Map();
+var allowAnyOriginConsumers = /* @__PURE__ */ new Set();
+/**
+* Derive origin from URL (protocol + host)
+*/
+function getOriginFromUrl(url) {
+	try {
+		return new URL(url).origin;
+	} catch {
+		return null;
+	}
+}
+function normalizeAllowedOrigins(origins) {
+	const normalized = /* @__PURE__ */ new Set();
+	if (!origins) return normalized;
+	for (const origin of origins) normalized.add(getOriginFromUrl(origin) || origin);
+	return normalized;
+}
+function recomputeOriginPolicy() {
+	allowedOrigins = new Set(inferredOrigins);
+	for (const origins of consumerOrigins.values()) for (const origin of origins) allowedOrigins.add(origin);
+	allowAnyOrigin = allowAnyOriginConsumers.size > 0;
+}
+function resetPlatformContextState() {
+	inferredOrigins = /* @__PURE__ */ new Set();
+	allowedOrigins = /* @__PURE__ */ new Set();
+	allowAnyOrigin = false;
+	initialized = false;
+	listenerCount = 0;
+	currentHandler = null;
+	consumerOrigins.clear();
+	allowAnyOriginConsumers.clear();
+	platformContext.value = { ...DEFAULT_CONTEXT };
+}
+/**
+* Check if an origin is allowed for postMessage communication
+*/
+function isOriginAllowed(origin) {
+	if (allowAnyOrigin) {
+		console.warn("[MINT SDK] postMessage origin validation disabled - only use in development");
+		return true;
+	}
+	if (origin === window.location.origin) return true;
+	return allowedOrigins.has(origin);
+}
+/**
+* Platform context composable for plugin integration with MINT Platform.
+*
+* Provides secure communication with the parent platform via postMessage.
+*
+* @param options - Configuration options
+* @param options.allowedOrigins - List of allowed origins for postMessage
+* @param options.allowAnyOrigin - Allow any origin (UNSAFE, development only)
+*
+* @example
+* ```typescript
+* // Basic usage - derives origin from platform injection
+* const { isIntegrated, user, theme } = usePlatformContext()
+*
+* // With explicit allowed origins
+* const { isIntegrated } = usePlatformContext({
+*   allowedOrigins: ['https://mint.example.com']
+* })
+*
+* // Development mode (UNSAFE)
+* const { isIntegrated } = usePlatformContext({
+*   allowAnyOrigin: import.meta.env.DEV
+* })
+* ```
+*/
+/** Connects a plugin to the MINT platform via postMessage, exposing user, theme, and experiment context. */
+function usePlatformContext(options = {}) {
+	const consumerId = ++nextConsumerId;
+	const instanceOrigins = normalizeAllowedOrigins(options.allowedOrigins);
+	const instanceAllowAnyOrigin = options.allowAnyOrigin === true;
+	function detectPlatform() {
+		const detectedOrigins = /* @__PURE__ */ new Set();
+		const platformData = window.__MINT_PLATFORM__;
+		if (platformData) {
+			platformContext.value = {
+				...platformData,
+				isIntegrated: true
+			};
+			if (platformData.platformOrigin) detectedOrigins.add(platformData.platformOrigin);
+			else if (platformData.platformApiUrl) {
+				const origin = getOriginFromUrl(platformData.platformApiUrl);
+				if (origin) detectedOrigins.add(origin);
+			}
+		} else {
+			const urlParams = new URLSearchParams(window.location.search);
+			const hasPluginParam = urlParams.has("mint-plugin");
+			const platformOrigin = urlParams.get("mint-origin");
+			if (platformOrigin) {
+				const origin = getOriginFromUrl(platformOrigin);
+				if (origin) detectedOrigins.add(origin);
+			}
+			platformContext.value = {
+				isIntegrated: hasPluginParam,
+				theme: (() => {
+					try {
+						const s = localStorage.getItem("mint-settings");
+						if (s) return JSON.parse(s).theme || "system";
+					} catch {}
+					return "system";
+				})(),
+				platformOrigin: platformOrigin || void 0
+			};
+		}
+		inferredOrigins = detectedOrigins;
+	}
+	function handlePlatformMessage(event) {
+		if (event.source !== window.parent) return;
+		if (!isOriginAllowed(event.origin)) {
+			console.warn(`[MINT SDK] Rejected postMessage from untrusted origin: ${event.origin}`);
+			return;
+		}
+		try {
+			const platformEvent = event.data;
+			if (!platformEvent.type?.startsWith("mint:")) return;
+			switch (platformEvent.type) {
+				case "mint:theme-changed":
+					platformContext.value.theme = platformEvent.payload;
+					break;
+				case "mint:user-changed":
+					platformContext.value.user = platformEvent.payload;
+					break;
+			}
+		} catch {}
+	}
+	/**
+	* Send a message to the parent platform.
+	* Uses validated target origin for security.
+	*/
+	function sendToPlatform(event) {
+		if (!platformContext.value.isIntegrated || window.parent === window) return;
+		let targetOrigin;
+		if (platformContext.value.platformOrigin) targetOrigin = platformContext.value.platformOrigin;
+		else if (allowedOrigins.size > 0) targetOrigin = allowedOrigins.values().next().value;
+		else if (allowAnyOrigin) {
+			targetOrigin = "*";
+			console.warn("[MINT SDK] Using wildcard origin for postMessage - only use in development");
+		} else {
+			console.warn("[MINT SDK] Cannot send postMessage: no platform origin configured");
+			return;
+		}
+		window.parent.postMessage(event, targetOrigin);
+	}
+	/**
+	* Request navigation to a path in the platform.
+	*/
+	function navigate(path) {
+		sendToPlatform({
+			type: "mint:navigate",
+			payload: path
+		});
+	}
+	/**
+	* Show a notification in the platform.
+	*/
+	function notify(message, type = "info") {
+		sendToPlatform({
+			type: "mint:notification",
+			payload: {
+				message,
+				type
+			}
+		});
+	}
+	onMounted(() => {
+		consumerOrigins.set(consumerId, instanceOrigins);
+		if (instanceAllowAnyOrigin) allowAnyOriginConsumers.add(consumerId);
+		if (!initialized) {
+			detectPlatform();
+			currentHandler = handlePlatformMessage;
+			window.addEventListener("message", handlePlatformMessage);
+			initialized = true;
+		}
+		listenerCount++;
+		recomputeOriginPolicy();
+	});
+	onUnmounted(() => {
+		consumerOrigins.delete(consumerId);
+		allowAnyOriginConsumers.delete(consumerId);
+		listenerCount = Math.max(0, listenerCount - 1);
+		if (listenerCount === 0) {
+			if (currentHandler) window.removeEventListener("message", currentHandler);
+			resetPlatformContextState();
+			return;
+		}
+		recomputeOriginPolicy();
+	});
+	return {
+		context: platformContext,
+		isIntegrated: computed(() => platformContext.value.isIntegrated),
+		plugin: computed(() => platformContext.value.plugin),
+		user: computed(() => platformContext.value.user),
+		theme: computed(() => platformContext.value.theme),
+		features: computed(() => platformContext.value.features),
+		navigate,
+		notify,
+		sendToPlatform
+	};
+}
+//#endregion
+//#region src/composables/useFormValidation.ts
+var validators = {
+	required: (value, message = "This field is required") => {
+		if (value === null || value === void 0 || value === "") return message;
+		if (Array.isArray(value) && value.length === 0) return message;
+		return null;
+	},
+	minLength: (value, min, message) => {
+		if (typeof value !== "string") return null;
+		if (value.length < min) return message || `Must be at least ${min} characters`;
+		return null;
+	},
+	maxLength: (value, max, message) => {
+		if (typeof value !== "string") return null;
+		if (value.length > max) return message || `Must be at most ${max} characters`;
+		return null;
+	},
+	min: (value, min, message) => {
+		if (typeof value !== "number") return null;
+		if (value < min) return message || `Must be at least ${min}`;
+		return null;
+	},
+	max: (value, max, message) => {
+		if (typeof value !== "number") return null;
+		if (value > max) return message || `Must be at most ${max}`;
+		return null;
+	},
+	pattern: (value, pattern, message) => {
+		if (typeof value !== "string") return null;
+		if (!pattern.test(value)) return message || "Invalid format";
+		return null;
+	},
+	email: (value, message = "Invalid email address") => {
+		if (typeof value !== "string" || !value) return null;
+		if (!/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value)) return message;
+		return null;
+	}
+};
+function validateFieldValue(value, fieldRules, formData) {
+	if (!fieldRules) return null;
+	if (fieldRules.required) {
+		const message = typeof fieldRules.required === "string" ? fieldRules.required : void 0;
+		const error = validators.required(value, message);
+		if (error) return error;
+	}
+	if (value === null || value === void 0 || value === "") return null;
+	if (fieldRules.minLength !== void 0) {
+		const config = typeof fieldRules.minLength === "number" ? {
+			value: fieldRules.minLength,
+			message: void 0
+		} : fieldRules.minLength;
+		const error = validators.minLength(value, config.value, config.message);
+		if (error) return error;
+	}
+	if (fieldRules.maxLength !== void 0) {
+		const config = typeof fieldRules.maxLength === "number" ? {
+			value: fieldRules.maxLength,
+			message: void 0
+		} : fieldRules.maxLength;
+		const error = validators.maxLength(value, config.value, config.message);
+		if (error) return error;
+	}
+	if (fieldRules.min !== void 0) {
+		const config = typeof fieldRules.min === "number" ? {
+			value: fieldRules.min,
+			message: void 0
+		} : fieldRules.min;
+		const error = validators.min(value, config.value, config.message);
+		if (error) return error;
+	}
+	if (fieldRules.max !== void 0) {
+		const config = typeof fieldRules.max === "number" ? {
+			value: fieldRules.max,
+			message: void 0
+		} : fieldRules.max;
+		const error = validators.max(value, config.value, config.message);
+		if (error) return error;
+	}
+	if (fieldRules.pattern !== void 0) {
+		const config = fieldRules.pattern instanceof RegExp ? {
+			value: fieldRules.pattern,
+			message: void 0
+		} : fieldRules.pattern;
+		const error = validators.pattern(value, config.value, config.message);
+		if (error) return error;
+	}
+	if (fieldRules.email) {
+		const message = typeof fieldRules.email === "string" ? fieldRules.email : void 0;
+		const error = validators.email(value, message);
+		if (error) return error;
+	}
+	if (fieldRules.custom) {
+		const customRules = Array.isArray(fieldRules.custom) ? fieldRules.custom : [fieldRules.custom];
+		for (const rule of customRules) {
+			const error = rule(value, formData);
+			if (error) return error;
+		}
+	}
+	return null;
+}
+//#endregion
+//#region src/composables/useForm.ts
+/**
+* Form state management composable with validation.
+*
+* @param initialValues - Initial form values
+* @param rules - Validation rules for each field
+*
+* @example
+* ```typescript
+* const { data, errors, isValid, handleSubmit, getFieldProps } = useForm(
+*   { email: '', password: '' },
+*   {
+*     email: { required: true, email: true },
+*     password: { required: true, minLength: 8 },
+*   }
+* )
+*
+* // In template
+* <BaseInput v-bind="getFieldProps('email')" label="Email" />
+* <BaseInput v-bind="getFieldProps('password')" type="password" label="Password" />
+* <BaseButton @click="handleSubmit(onSubmit)" :disabled="!isValid">Submit</BaseButton>
+* ```
+*/
+/** Reactive form state with field-level validation, dirty tracking, and submit handling. */
+function useForm(initialValues, rules = {}) {
+	const cloneableInitialValues = deepToRaw(initialValues);
+	let _initialValues = structuredClone(cloneableInitialValues);
+	const data = reactive(structuredClone(cloneableInitialValues));
+	const errors = reactive(Object.keys(initialValues).reduce((acc, key) => {
+		acc[key] = null;
+		return acc;
+	}, {}));
+	const touched = reactive(Object.keys(initialValues).reduce((acc, key) => {
+		acc[key] = false;
+		return acc;
+	}, {}));
+	const dirty = reactive(Object.keys(initialValues).reduce((acc, key) => {
+		acc[key] = false;
+		return acc;
+	}, {}));
+	const isSubmitting = ref(false);
+	watch(() => ({ ...data }), (newData) => {
+		for (const key of Object.keys(newData)) dirty[key] = newData[key] !== _initialValues[key];
+	}, { deep: true });
+	function validateField(field) {
+		const value = data[field];
+		const fieldRules = rules[field];
+		const error = validateFieldValue(value, fieldRules, data);
+		errors[field] = error;
+		return error === null;
+	}
+	function validate() {
+		let isAllValid = true;
+		for (const field of Object.keys(data)) if (!validateField(field)) isAllValid = false;
+		return isAllValid;
+	}
+	const isValid = computed(() => {
+		return Object.values(errors).every((error) => error === null);
+	});
+	const isDirty = computed(() => {
+		return Object.values(dirty).some((d) => d);
+	});
+	function setFieldValue(field, value) {
+		data[field] = value;
+		if (touched[field]) validateField(field);
+	}
+	function setFieldError(field, error) {
+		errors[field] = error;
+	}
+	function setFieldTouched(field, isTouched = true) {
+		touched[field] = isTouched;
+		if (isTouched) validateField(field);
+	}
+	function reset(values) {
+		const resetValues = values ? {
+			..._initialValues,
+			...values
+		} : _initialValues;
+		for (const key of Object.keys(data)) {
+			data[key] = structuredClone(deepToRaw(resetValues[key]));
+			errors[key] = null;
+			touched[key] = false;
+			dirty[key] = false;
+		}
+	}
+	function replaceState(values) {
+		const nextValues = structuredClone(deepToRaw(values));
+		_initialValues = structuredClone(nextValues);
+		for (const key of Object.keys(data)) {
+			if (key in nextValues) continue;
+			delete data[key];
+			delete errors[key];
+			delete touched[key];
+			delete dirty[key];
+		}
+		for (const key of Object.keys(nextValues)) {
+			data[key] = structuredClone(deepToRaw(nextValues[key]));
+			errors[key] = null;
+			touched[key] = false;
+			dirty[key] = false;
+		}
+	}
+	function handleSubmit(onSubmit) {
+		return async (e) => {
+			e?.preventDefault();
+			for (const field of Object.keys(data)) touched[field] = true;
+			if (!validate()) return;
+			isSubmitting.value = true;
+			try {
+				await onSubmit(data);
+			} finally {
+				isSubmitting.value = false;
+			}
+		};
+	}
+	function getFieldProps(field) {
+		const fieldStr = field;
+		return {
+			modelValue: data[field],
+			"onUpdate:modelValue": (value) => setFieldValue(field, value),
+			onBlur: () => setFieldTouched(fieldStr),
+			error: touched[fieldStr] ? errors[fieldStr] : null
+		};
+	}
+	return {
+		data,
+		errors,
+		touched,
+		dirty,
+		isValid,
+		isDirty,
+		isSubmitting,
+		setFieldValue,
+		setFieldError,
+		setFieldTouched,
+		validateField,
+		validate,
+		reset,
+		replaceState,
+		handleSubmit,
+		getFieldProps
+	};
+}
+function deepToRaw(value) {
+	const raw = toRaw(value);
+	if (Array.isArray(raw)) return raw.map((item) => deepToRaw(item));
+	if (isPlainRecord(raw)) return Object.fromEntries(Object.entries(raw).map(([key, item]) => [key, deepToRaw(item)]));
+	return raw;
+}
+function isPlainRecord(value) {
+	return Object.prototype.toString.call(value) === "[object Object]";
+}
+//#endregion
+//#region src/composables/formBuilderSchema.ts
+/**
+* Evaluate a JSON-serializable field condition against the current form data.
+*
+* Supports logical operators (`and`, `or`, `not`) and comparison operators
+* (`eq`, `neq`, `gt`, `lt`, `gte`, `lte`, `in`, `notIn`, `truthy`, `falsy`,
+* `contains`). Returns `true` if the condition passes.
+*/
+function evaluateCondition(condition, data) {
+	if ("and" in condition) return condition.and.every((c) => evaluateCondition(c, data));
+	if ("or" in condition) return condition.or.some((c) => evaluateCondition(c, data));
+	if ("not" in condition) return !evaluateCondition(condition.not, data);
+	const value = data[condition.field];
+	if ("eq" in condition) return value === condition.eq;
+	if ("neq" in condition) return value !== condition.neq;
+	if ("gt" in condition) return typeof value === "number" && value > condition.gt;
+	if ("lt" in condition) return typeof value === "number" && value < condition.lt;
+	if ("gte" in condition) return typeof value === "number" && value >= condition.gte;
+	if ("lte" in condition) return typeof value === "number" && value <= condition.lte;
+	if ("in" in condition) return condition.in.includes(value);
+	if ("notIn" in condition) return !condition.notIn.includes(value);
+	if ("truthy" in condition) return !!value;
+	if ("falsy" in condition) return !value;
+	if ("contains" in condition) {
+		if (typeof value === "string") return value.includes(condition.contains);
+		if (Array.isArray(value)) return value.includes(condition.contains);
+		return false;
+	}
+	return true;
+}
+/** Return all sections across steps (wizard) or directly from a flat schema. */
+function collectSections(schema) {
+	return schema.steps ? schema.steps.flatMap((step) => step.sections) : schema.sections;
+}
+/** Return all field schemas in schema order, flattening sections and steps. */
+function flattenFields(schema) {
+	return collectSections(schema).flatMap((section) => section.fields);
+}
+/** Convert a JSON-safe `FieldValidation` descriptor to a runtime `FieldRules` object. */
+function convertValidation(v) {
+	const rules = {};
+	if (v.required !== void 0) rules.required = v.required;
+	if (v.minLength !== void 0) rules.minLength = v.minLength;
+	if (v.maxLength !== void 0) rules.maxLength = v.maxLength;
+	if (v.min !== void 0) rules.min = v.min;
+	if (v.max !== void 0) rules.max = v.max;
+	if (v.email !== void 0) rules.email = v.email;
+	if (v.pattern !== void 0) rules.pattern = typeof v.pattern === "string" ? new RegExp(v.pattern) : {
+		value: new RegExp(v.pattern.value),
+		message: v.pattern.message
+	};
+	return rules;
+}
+function buildInitialValues(fields, initialData) {
+	const initialValues = {};
+	for (const field of fields) {
+		const key = field.name;
+		if (initialData && hasOwnKey(initialData, key)) initialValues[key] = initialData[key];
+		else if (field.defaultValue !== void 0) initialValues[key] = field.defaultValue;
+		else initialValues[key] = getTypeDefault(field.type);
+	}
+	return initialValues;
+}
+function buildRules(fields, enhancements) {
+	const rules = {};
+	for (const field of fields) {
+		const base = field.validation ? convertValidation(field.validation) : {};
+		const enhancement = enhancements?.fields?.[field.name];
+		const customValidators = [];
+		if (enhancement?.validate) {
+			const fn = enhancement.validate;
+			customValidators.push((value, formData) => fn(value, formData));
+		}
+		if (customValidators.length > 0) base.custom = customValidators;
+		if (Object.keys(base).length > 0) rules[field.name] = base;
+	}
+	return rules;
+}
+function replaceArray(target, values) {
+	target.splice(0, target.length, ...values);
+}
+function replaceRecord(target, source) {
+	for (const key of Object.keys(target)) delete target[key];
+	Object.assign(target, source);
+}
+function hasOwnKey(source, key) {
+	return Object.prototype.hasOwnProperty.call(source, key);
+}
+//#endregion
+//#region src/composables/useFormBuilder.ts
+/**
+* Drive a `FormSchema` as reactive form state.
+*
+* Builds initial values from schema defaults and `initialData`, derives
+* validation rules from `FieldValidation` descriptors and enhancement
+* validators, evaluates `FieldCondition` expressions for field/section
+* visibility, and wires wizard step navigation when `schema.steps` is set.
+*
+* @param schema - Declarative form or wizard schema.
+* @param initialData - Values that override schema defaults.
+* @param enhancements - TypeScript-only callbacks (dynamic options, validators,
+*   submit handler, transform, field-change watcher).
+*/
+/** Drives a declarative FormSchema as reactive state with conditional fields, wizard steps, and validation. */
+function useFormBuilder(schema, initialData, enhancements) {
+	const currentSchema = shallowRef(schema);
+	const fields = reactive(flattenFields(schema));
+	const sections = reactive(collectSections(schema));
+	const rules = reactive(buildRules(fields, enhancements));
+	const form = useForm(buildInitialValues(fields, initialData), rules);
+	function isFieldVisible(name) {
+		const enhancement = enhancements?.fields?.[name];
+		if (enhancement?.visible) return enhancement.visible(form.data);
+		const field = fields.find((f) => f.name === name);
+		if (field?.condition) return evaluateCondition(field.condition, form.data);
+		return true;
+	}
+	function isSectionVisible(id) {
+		const section = sections.find((s) => s.id === id);
+		if (section?.condition) return evaluateCondition(section.condition, form.data);
+		return true;
+	}
+	function getResolvedFieldProps(field) {
+		const entry = getFieldRegistryEntry(field.type);
+		const formProps = form.getFieldProps(field.name);
+		const merged = {
+			...entry.defaults,
+			...field.props ?? {}
+		};
+		const enhancement = enhancements?.fields?.[field.name];
+		if (enhancement?.props) Object.assign(merged, enhancement.props(form.data));
+		const options = getFieldOptions(field.name);
+		if (options) merged.options = options;
+		if (entry.vModel) {
+			merged.modelValue = formProps.modelValue;
+			merged["onUpdate:modelValue"] = formProps["onUpdate:modelValue"];
+		}
+		merged.onBlur = formProps.onBlur;
+		if (formProps.error) merged.error = true;
+		if (field.placeholder) merged.placeholder = field.placeholder;
+		if (field.size) merged.size = field.size;
+		if (field.disabled) merged.disabled = true;
+		if (field.readonly) merged.readonly = true;
+		if (field.type === "radio" && !merged.name) merged.name = field.name;
+		return merged;
+	}
+	function getFieldOptions(name) {
+		const enhancement = enhancements?.fields?.[name];
+		if (enhancement?.options) return enhancement.options(form.data);
+		const field = fields.find((f) => f.name === name);
+		if (field?.props?.options) return field.props.options;
+	}
+	const currentStep = ref(0);
+	const isCurrentStepValid = computed(() => {
+		if (!currentSchema.value.steps) return form.isValid.value;
+		const step = currentSchema.value.steps[currentStep.value];
+		if (!step) return true;
+		for (const section of step.sections) {
+			if (!isSectionVisible(section.id)) continue;
+			for (const field of section.fields) {
+				if (!isFieldVisible(field.name)) continue;
+				if (!form.validateField(field.name)) return false;
+			}
+		}
+		return true;
+	});
+	function goNext() {
+		if (!currentSchema.value.steps) return false;
+		const step = currentSchema.value.steps[currentStep.value];
+		if (!step) return false;
+		let valid = true;
+		for (const section of step.sections) {
+			if (!isSectionVisible(section.id)) continue;
+			for (const field of section.fields) {
+				if (!isFieldVisible(field.name)) continue;
+				form.setFieldTouched(field.name, true);
+				if (!form.validateField(field.name)) valid = false;
+			}
+		}
+		if (!valid) return false;
+		if (currentStep.value < currentSchema.value.steps.length - 1) currentStep.value++;
+		return true;
+	}
+	function goBack() {
+		if (currentStep.value > 0) currentStep.value--;
+	}
+	function goToStep(index) {
+		if (!currentSchema.value.steps) return;
+		if (index >= 0 && index < currentSchema.value.steps.length) currentStep.value = index;
+	}
+	function validate() {
+		let allValid = true;
+		for (const field of fields) {
+			if (!isFieldVisible(field.name)) continue;
+			form.setFieldTouched(field.name, true);
+			if (!form.validateField(field.name)) allValid = false;
+		}
+		return allValid;
+	}
+	async function submit() {
+		if (!validate()) return;
+		let submitData = {};
+		for (const field of fields) if (isFieldVisible(field.name)) submitData[field.name] = form.data[field.name];
+		if (enhancements?.transform) submitData = enhancements.transform(submitData);
+		if (enhancements?.onSubmit) {
+			form.isSubmitting.value = true;
+			try {
+				await enhancements.onSubmit(submitData);
+			} finally {
+				form.isSubmitting.value = false;
+			}
+		}
+	}
+	function reset(values) {
+		form.reset(values);
+		currentStep.value = 0;
+	}
+	function updateSchema(nextSchema, nextData) {
+		currentSchema.value = nextSchema;
+		const nextFields = flattenFields(nextSchema);
+		replaceArray(fields, nextFields);
+		replaceArray(sections, collectSections(nextSchema));
+		replaceRecord(rules, buildRules(nextFields, enhancements));
+		form.replaceState(buildInitialValues(nextFields, nextData));
+		currentStep.value = 0;
+	}
+	if (enhancements?.onFieldChange) {
+		const callback = enhancements.onFieldChange;
+		watch(() => ({ ...form.data }), (newData, oldData) => {
+			if (!oldData) return;
+			for (const key of Object.keys(newData)) if (newData[key] !== oldData[key]) callback(key, newData[key], newData);
+		}, { deep: true });
+	}
+	return {
+		form,
+		rules,
+		isFieldVisible,
+		isSectionVisible,
+		fields,
+		getResolvedFieldProps,
+		getFieldOptions,
+		currentStep,
+		isCurrentStepValid,
+		goNext,
+		goBack,
+		goToStep,
+		validate,
+		reset,
+		submit,
+		updateSchema
+	};
+}
+//#endregion
+export { usePlatformContext as i, evaluateCondition as n, useForm as r, useFormBuilder as t };
+
+//# sourceMappingURL=useFormBuilder-COfYWDuC.js.map