@getdom/studio 0.1.0

package/src/pages/forms/form/adapters/fieldBuilder.js

@@ -0,0 +1,45 @@
+export function fieldPath(scope, key) {
+	return scope ? `${scope}.${key}` : key;
+}
+
+export function fieldId(prefix, path) {
+	return `${prefix}-${path.replace(/\W+/g, '-')}`;
+}
+
+export function nestedFormNode({ idPrefix, path, key, field, children }) {
+	return {
+		id: fieldId(idPrefix, path),
+		component: 'DomForm',
+		props: {
+			name: key,
+			class: field.class || 'space-y-3 rounded-xl border border-border bg-secondary/25 p-4',
+			...(field.props || {}),
+		},
+		children,
+	};
+}
+
+export function childrenForFieldShape(shape, scope, options, adapter) {
+	return Object.entries(shape || {}).map(([key, childSchema]) => {
+		const path = fieldPath(scope, key);
+		const nested = adapter.nestedShape(childSchema, path, key, options);
+		const nestedShape = nested?.shape || nested;
+		const nestedAdapter = nested?.adapter || adapter;
+
+		if (nestedShape) {
+			return nestedFormNode({
+				idPrefix: adapter.idPrefix,
+				path,
+				key,
+				field: adapter.fieldForNested(childSchema, path, key, options),
+				children: childrenForFieldShape(nestedShape, path, options, nestedAdapter),
+			});
+		}
+
+		return {
+			id: fieldId(adapter.idPrefix, path),
+			component: adapter.componentFor(childSchema, path, options),
+			props: adapter.fieldPropsFor(childSchema, path, key, options),
+		};
+	});
+}

package/src/pages/forms/form/adapters/jsonSchema.js

@@ -0,0 +1,264 @@
+import {
+	clone,
+	fieldOptions,
+	formatLabel,
+	formDecoration,
+	hasOwn,
+	isEmpty,
+	optionObjects,
+	raw,
+} from './shared.js';
+import { childrenForFieldShape } from './fieldBuilder.js';
+
+function jsonSchemaType(schema) {
+	const plain = raw(schema) || {};
+	const type = Array.isArray(plain.type)
+		? plain.type.find((item) => item !== 'null') || plain.type[0]
+		: plain.type;
+
+	if (type) return String(type).toLowerCase();
+	if (hasOwn(plain, 'const')) return plain.const === null ? 'null' : typeof plain.const;
+	if (plain.enum?.length) {
+		const value = plain.enum.find((item) => item !== null);
+		return value === undefined ? 'null' : typeof value;
+	}
+	if (plain.properties) return 'object';
+	if (plain.items) return 'array';
+	return '';
+}
+
+function jsonSchemaFormat(schema) {
+	const plain = raw(schema) || {};
+	return String(plain.format || '').toLowerCase();
+}
+
+function jsonSchemaValues(schema) {
+	const plain = raw(schema) || {};
+	if (plain.enum) return plain.enum;
+	if (hasOwn(plain, 'const')) return [plain.const];
+	return null;
+}
+
+function jsonSchemaAllowsNull(schema) {
+	const plain = raw(schema) || {};
+	return Array.isArray(plain.type) && plain.type.includes('null');
+}
+
+export function isJsonSchema(schema) {
+	const plain = raw(schema) || {};
+	return Boolean(
+		plain.$schema
+		|| plain.properties
+		|| plain.items
+		|| plain.enum
+		|| hasOwn(plain, 'const')
+		|| ['object', 'array', 'string', 'number', 'integer', 'boolean', 'null'].includes(jsonSchemaType(plain)),
+	);
+}
+
+function emailLike(value) {
+	return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(String(value));
+}
+
+function uriLike(value) {
+	try {
+		const url = new URL(String(value));
+		return Boolean(url.protocol);
+	} catch {
+		return false;
+	}
+}
+
+function jsonTypeMatches(value, type, schema) {
+	if (!type || value === null) return value !== null || jsonSchemaAllowsNull(schema);
+	if (type === 'integer') return Number.isInteger(Number(value));
+	if (type === 'number') return Number.isFinite(Number(value));
+	if (type === 'array') return Array.isArray(value);
+	if (type === 'object') return value && typeof value === 'object' && !Array.isArray(value);
+	if (type === 'boolean') return typeof value === 'boolean';
+	if (type === 'string') return typeof value === 'string';
+	return true;
+}
+
+function jsonSchemaValidator(schema) {
+	const plain = raw(schema);
+	if (!plain || typeof plain !== 'object') return null;
+
+	const type = jsonSchemaType(plain);
+	const format = jsonSchemaFormat(plain);
+	const values = jsonSchemaValues(plain);
+
+	return {
+		name: 'json-schema',
+		message: 'This field does not match the schema.',
+		validate(value) {
+			if (isEmpty(value)) return true;
+			if (!jsonTypeMatches(value, type, plain)) return `Use a ${type} value.`;
+			if (values && !values.includes(value)) return 'Choose one of the allowed values.';
+			if ((type === 'string' || !type) && plain.minLength != null && String(value).length < plain.minLength) return `Use at least ${plain.minLength} characters.`;
+			if ((type === 'string' || !type) && plain.maxLength != null && String(value).length > plain.maxLength) return `Use ${plain.maxLength} characters or fewer.`;
+			if (plain.pattern) {
+				try {
+					if (!new RegExp(plain.pattern).test(String(value))) return plain.errorMessage?.pattern || 'This field does not match the required pattern.';
+				} catch {
+					return true;
+				}
+			}
+			if ((type === 'number' || type === 'integer') && plain.minimum != null && Number(value) < plain.minimum) return `Use a value of ${plain.minimum} or greater.`;
+			if ((type === 'number' || type === 'integer') && plain.maximum != null && Number(value) > plain.maximum) return `Use a value of ${plain.maximum} or less.`;
+			if ((type === 'number' || type === 'integer') && plain.exclusiveMinimum != null && Number(value) <= plain.exclusiveMinimum) return `Use a value greater than ${plain.exclusiveMinimum}.`;
+			if ((type === 'number' || type === 'integer') && plain.exclusiveMaximum != null && Number(value) >= plain.exclusiveMaximum) return `Use a value less than ${plain.exclusiveMaximum}.`;
+			if ((type === 'number' || type === 'integer') && plain.multipleOf != null && Number(value) % plain.multipleOf !== 0) return `Use a multiple of ${plain.multipleOf}.`;
+			if (type === 'array' && plain.minItems != null && value.length < plain.minItems) return `Add at least ${plain.minItems} items.`;
+			if (type === 'array' && plain.maxItems != null && value.length > plain.maxItems) return `Use ${plain.maxItems} items or fewer.`;
+			if (format === 'email' && !emailLike(value)) return 'Enter a valid email address.';
+			if ((format === 'uri' || format === 'url') && !uriLike(value)) return 'Enter a valid URL.';
+			if (format === 'date' && !/^\d{4}-\d{2}-\d{2}$/.test(String(value))) return 'Use YYYY-MM-DD.';
+			return true;
+		},
+	};
+}
+
+function jsonSchemaComponentFor(schema, path, options) {
+	const plain = raw(schema) || {};
+	const type = jsonSchemaType(plain);
+	const format = jsonSchemaFormat(plain);
+	const values = jsonSchemaValues(plain);
+	const field = fieldOptions(options, path, path.split('.').pop(), schema);
+	const override = field.component || plain.component;
+
+	if (override) return override;
+	if (values) return 'DomSelect';
+	if (format === 'binary' || format === 'file' || plain.contentMediaType || plain.contentEncoding === 'base64') return 'DomFileUpload';
+	if (format === 'currency' || format === 'money' || format === 'decimal') return 'DomMoneyInput';
+	if (type === 'decimal' || type === 'currency' || type === 'money') return 'DomMoneyInput';
+	if (type === 'file') return 'DomFileUpload';
+	if (type === 'array') return 'DomJsonListInput';
+	if (format === 'email') return 'DomEmailInput';
+	if (format === 'uri' || format === 'url') return 'DomUrlInput';
+	if (format === 'time') return 'DomTimeSelector';
+	if (format === 'date-time' || format === 'datetime') return 'DomDateTimePicker';
+	if (format === 'date') return 'DomDatePicker';
+	if (type === 'number' || type === 'integer') return 'DomNumberInput';
+	if (type === 'boolean') return 'DomToggle';
+	if (plain.maxLength && plain.maxLength > 160) return 'DomTextareaInput';
+	return 'DomTextInput';
+}
+
+function jsonListFieldType(schema) {
+	const type = jsonSchemaType(schema);
+	const format = jsonSchemaFormat(schema);
+	if (format === 'email') return 'email';
+	if (format === 'uri' || format === 'url') return 'url';
+	if (format === 'time') return 'time';
+	if (format === 'date-time' || format === 'datetime') return 'datetime';
+	if (format === 'date') return 'date';
+	if (format === 'currency' || format === 'money' || format === 'decimal') return 'number';
+	if (format === 'binary' || format === 'file') return 'file';
+	if (type === 'decimal' || type === 'currency' || type === 'money') return 'number';
+	if (type === 'file') return 'file';
+	if (type === 'number' || type === 'integer') return 'number';
+	if (type === 'object' || type === 'array') return 'json';
+	return 'text';
+}
+
+function jsonListSchemaForItems(items) {
+	const plain = raw(items) || {};
+	const properties = plain.properties || {};
+	return Object.entries(properties).map(([key, child]) => {
+		const childSchema = raw(child) || {};
+		const decoration = formDecoration(child);
+		return {
+			key,
+			label: decoration.label || childSchema.title || formatLabel(key),
+			type: decoration.type || jsonListFieldType(childSchema),
+			placeholder: decoration.placeholder || childSchema.examples?.[0] || '',
+			...(hasOwn(childSchema, 'default') ? { default: clone(childSchema.default) } : {}),
+		};
+	});
+}
+
+function defaultValueForJsonSchema(schema) {
+	const plain = raw(schema) || {};
+	const type = jsonSchemaType(plain);
+
+	if (hasOwn(plain, 'default')) return clone(plain.default);
+	if (hasOwn(plain, 'const')) return clone(plain.const);
+	if (type === 'array') return [];
+	if (type === 'boolean') return false;
+	return undefined;
+}
+
+function jsonSchemaFieldPropsFor(schema, path, required, options) {
+	const key = path.split('.').pop();
+	const plain = raw(schema) || {};
+	const field = fieldOptions(options, path, key, schema);
+	const type = jsonSchemaType(plain);
+	const values = jsonSchemaValues(plain);
+	const validators = [
+		jsonSchemaValidator(schema),
+		...(field.props?.validators || []),
+	].filter(Boolean);
+	const defaultValue = defaultValueForJsonSchema(plain);
+
+	const props = {
+		name: key,
+		label: field.label || plain.title || formatLabel(key),
+		description: field.description ?? plain.description ?? '',
+		required,
+		...(plain.examples?.[0] ? { placeholder: plain.examples[0] } : {}),
+		...(validators.length ? { validators } : {}),
+		...(defaultValue !== undefined ? { modelValue: defaultValue } : {}),
+		...(field.props || {}),
+	};
+
+	if (values && !props.options) props.options = optionObjects(values);
+	if (plain.minimum != null && props.min == null) props.min = plain.minimum;
+	if (plain.maximum != null && props.max == null) props.max = plain.maximum;
+	if (type === 'integer' && props.step == null) props.step = 1;
+	if (plain.multipleOf != null && props.step == null) props.step = plain.multipleOf;
+	if (type === 'array' && plain.items?.properties && !props.schema) props.schema = jsonListSchemaForItems(plain.items);
+
+	return props;
+}
+
+function jsonSchemaObjectAdapter(schema) {
+	const plain = raw(schema) || {};
+	const required = new Set(Array.isArray(plain.required) ? plain.required : []);
+
+	return {
+		idPrefix: 'json-schema',
+		nestedShape(childSchema) {
+			const child = raw(childSchema) || {};
+			return jsonSchemaType(child) === 'object' && child.properties
+				? { shape: child.properties, adapter: jsonSchemaObjectAdapter(child) }
+				: null;
+		},
+		fieldForNested(childSchema, path, key, adapterOptions) {
+			return fieldOptions(adapterOptions, path, key, childSchema);
+		},
+		componentFor: jsonSchemaComponentFor,
+		fieldPropsFor(childSchema, path, key, adapterOptions) {
+			return jsonSchemaFieldPropsFor(childSchema, path, required.has(key), adapterOptions);
+		},
+	};
+}
+
+function childrenForJsonSchemaObject(schema, scope, options) {
+	const plain = raw(schema) || {};
+
+	return childrenForFieldShape(plain.properties || {}, scope, options, jsonSchemaObjectAdapter(plain));
+}
+
+export function jsonSchemaToChildren(schema, options = {}) {
+	const plain = raw(schema);
+	if (!plain || typeof plain !== 'object' || !isJsonSchema(plain)) return [];
+	if (jsonSchemaType(plain) !== 'object' || !plain.properties) return [];
+	return childrenForJsonSchemaObject(plain, '', options);
+}
+
+export const jsonSchemaAdapter = {
+	name: 'json-schema',
+	matches: isJsonSchema,
+	toChildren: jsonSchemaToChildren,
+};

package/src/pages/forms/form/adapters/shared.js

@@ -0,0 +1,53 @@
+export function raw(value) {
+	return value && typeof value === 'object' && '__v_raw' in value ? value.__v_raw : value;
+}
+
+export function hasOwn(value, key) {
+	return Object.prototype.hasOwnProperty.call(value || {}, key);
+}
+
+export function clone(value) {
+	if (value == null || typeof value !== 'object') return value;
+	if (Array.isArray(value)) return value.map((item) => clone(item));
+	return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, clone(item)]));
+}
+
+export function formatLabel(value) {
+	return String(value || '')
+		.replace(/[-_]+/g, ' ')
+		.replace(/([a-z0-9])([A-Z])/g, '$1 $2')
+		.replace(/^./, (letter) => letter.toUpperCase());
+}
+
+export function optionObjects(values) {
+	return values.map((value) => ({
+		label: formatLabel(value),
+		value,
+	}));
+}
+
+export function isEmpty(value) {
+	return value === undefined || value === null || value === '';
+}
+
+export function mergeFieldConfig(base = {}, override = {}) {
+	return {
+		...base,
+		...override,
+		props: {
+			...(base.props || {}),
+			...(override.props || {}),
+		},
+	};
+}
+
+export function formDecoration(schema) {
+	const plain = raw(schema) || {};
+	return plain['x-el'] || plain.xEl || plain['x-form'] || plain.xForm || {};
+}
+
+export function fieldOptions(options, path, key, schema) {
+	const inline = formDecoration(schema);
+	const external = options.fields?.[path] || options.fields?.[key] || {};
+	return mergeFieldConfig(inline, external);
+}

package/src/pages/forms/form/adapters/zod.js

@@ -0,0 +1,235 @@
+import {
+	fieldOptions,
+	formatLabel,
+	isEmpty,
+	optionObjects,
+	raw,
+} from './shared.js';
+import { childrenForFieldShape } from './fieldBuilder.js';
+
+function defOf(schema) {
+	return raw(schema)?._def || raw(schema)?.def || raw(schema)?._zod?.def || {};
+}
+
+function typeOf(schema) {
+	const schemaDef = defOf(schema);
+	return schemaDef.typeName || schemaDef.type || raw(schema)?.type || raw(schema)?.kind || '';
+}
+
+function hasCallable(schema, name) {
+	return typeof raw(schema)?.[name] === 'function';
+}
+
+function call(schema, name, ...args) {
+	if (!hasCallable(schema, name)) return undefined;
+	try {
+		return raw(schema)[name](...args);
+	} catch {
+		return undefined;
+	}
+}
+
+function unwrap(schema) {
+	let current = raw(schema);
+	let optional = Boolean(current?.optional || current?.isOptional || current?.required === false);
+	let nullable = Boolean(current?.nullable || current?.isNullable);
+
+	for (let index = 0; index < 12; index += 1) {
+		const schemaDef = defOf(current);
+		const type = typeOf(current);
+		if (/optional/i.test(type)) optional = true;
+		if (/nullable/i.test(type)) nullable = true;
+		if (/default|catch/i.test(type)) optional = true;
+
+		const next = schemaDef.innerType
+			|| schemaDef.schema
+			|| schemaDef.type
+			|| schemaDef.in
+			|| schemaDef.out;
+
+		if (!next || next === current || typeof next === 'string') break;
+		current = raw(next);
+	}
+
+	if (typeof current?.isOptional === 'function') optional = optional || current.isOptional();
+	if (typeof current?.isNullable === 'function') nullable = nullable || current.isNullable();
+
+	return { schema: current, optional, nullable };
+}
+
+export function objectShape(schema) {
+	const unwrapped = unwrap(schema).schema;
+	const schemaDef = defOf(unwrapped);
+	const shape = schemaDef.shape || unwrapped?.shape || unwrapped?.fields;
+	if (typeof shape === 'function') return shape();
+	if (shape && typeof shape === 'object') return shape;
+	return null;
+}
+
+export function isZodLikeSchema(schema) {
+	return Boolean(objectShape(schema));
+}
+
+function enumValues(schema) {
+	const unwrapped = unwrap(schema).schema;
+	const schemaDef = defOf(unwrapped);
+	const values = schemaDef.values
+		|| schemaDef.entries
+		|| schemaDef.options
+		|| unwrapped?.values
+		|| unwrapped?.options
+		|| unwrapped?.enum;
+
+	if (Array.isArray(values)) return values;
+	if (values && typeof values === 'object') return Object.values(values);
+	return null;
+}
+
+function checksOf(schema) {
+	const schemaDef = defOf(unwrap(schema).schema);
+	const checks = [
+		...(schemaDef.checks || []),
+		...(raw(schema)?.checks || []),
+	];
+	return checks.map((check) => ({
+		raw: check,
+		kind: check.kind || check.check || check._zod?.def?.check || check.def?.check || check._def?.check || '',
+		value: check.value ?? check.minimum ?? check.maximum ?? check.length ?? check._zod?.def?.value,
+		format: check.format || check._zod?.def?.format || check.def?.format || '',
+		message: check.message || check._zod?.def?.message || check.def?.message || '',
+	}));
+}
+
+function schemaFormat(schema) {
+	const plain = raw(schema);
+	if (plain?.format) return plain.format;
+	if (plain?.email) return 'email';
+	if (plain?.url) return 'url';
+	const checks = checksOf(schema);
+	if (checks.some((check) => /email/i.test(`${check.kind} ${check.format}`))) return 'email';
+	if (checks.some((check) => /url/i.test(`${check.kind} ${check.format}`))) return 'url';
+	return '';
+}
+
+function schemaValidator(schema, optional) {
+	if (!schema || (!hasCallable(schema, 'safeParse') && !hasCallable(schema, 'parse'))) return null;
+
+	return {
+		name: 'schema',
+		message: 'This field does not match the schema.',
+		validate(value) {
+			const normalized = optional && value === '' ? undefined : value;
+			const result = call(schema, 'safeParse', normalized);
+			if (result) {
+				if (result.success) return true;
+				return result.error?.issues?.[0]?.message || result.error?.message || 'This field does not match the schema.';
+			}
+			try {
+				call(schema, 'parse', normalized);
+				return true;
+			} catch (error) {
+				return error?.issues?.[0]?.message || error?.message || 'This field does not match the schema.';
+			}
+		},
+	};
+}
+
+function plainValidator(schema) {
+	const plain = raw(schema);
+	if (!plain || typeof plain !== 'object' || hasCallable(plain, 'safeParse') || hasCallable(plain, 'parse')) return null;
+
+	return {
+		name: 'schema',
+		validate(value) {
+			if ((plain.optional || plain.required === false) && isEmpty(value)) return true;
+			if (plain.minLength != null && String(value || '').length < plain.minLength) return `Use at least ${plain.minLength} characters.`;
+			if (plain.maxLength != null && String(value || '').length > plain.maxLength) return `Use ${plain.maxLength} characters or fewer.`;
+			if (plain.min != null && Number(value) < plain.min) return `Use a value of ${plain.min} or greater.`;
+			if (plain.max != null && Number(value) > plain.max) return `Use a value of ${plain.max} or less.`;
+			if (plain.regex && !new RegExp(plain.regex).test(String(value || ''))) return plain.message || 'This field does not match the required pattern.';
+			return true;
+		},
+	};
+}
+
+function componentFor(schema, path, options) {
+	const plain = raw(schema) || {};
+	const type = String(typeOf(schema) || plain.type || '').toLowerCase();
+	const format = schemaFormat(schema);
+	const values = enumValues(schema) || plain.values || plain.options || plain.enum;
+	const override = fieldOptions(options, path, path.split('.').pop(), schema).component || plain.component;
+
+	if (override) return override;
+	if (values) return 'DomSelect';
+	if (format === 'binary' || format === 'file') return 'DomFileUpload';
+	if (format === 'currency' || format === 'money' || format === 'decimal') return 'DomMoneyInput';
+	if (format === 'email') return 'DomEmailInput';
+	if (format === 'url') return 'DomUrlInput';
+	if (format === 'time') return 'DomTimeSelector';
+	if (format === 'date-time' || format === 'datetime') return 'DomDateTimePicker';
+	if (/decimal|currency|money/.test(type)) return 'DomMoneyInput';
+	if (/file/.test(type)) return 'DomFileUpload';
+	if (/number|bigint|int|float|double/.test(type)) return 'DomNumberInput';
+	if (/boolean|bool/.test(type)) return 'DomToggle';
+	if (/datetime|date-time/.test(type)) return 'DomDateTimePicker';
+	if (/time/.test(type)) return 'DomTimeSelector';
+	if (/date/.test(type)) return 'DomCalendar';
+	return 'DomTextInput';
+}
+
+function fieldPropsFor(schema, path, options) {
+	const key = path.split('.').pop();
+	const plain = raw(schema) || {};
+	const field = fieldOptions(options, path, key, schema);
+	const unwrapped = unwrap(schema);
+	const values = enumValues(schema) || plain.values || plain.options || plain.enum;
+	const validators = [
+		schemaValidator(schema, unwrapped.optional),
+		plainValidator(schema),
+		...(field.props?.validators || []),
+	].filter(Boolean);
+
+	const props = {
+		name: key,
+		label: field.label || plain.label || plain.description || raw(schema)?.description || formatLabel(key),
+		description: field.description || plain.help || plain.hint || '',
+		required: field.required ?? plain.required ?? !unwrapped.optional,
+		...(plain.placeholder ? { placeholder: plain.placeholder } : {}),
+		...(validators.length ? { validators } : {}),
+		...(field.props || {}),
+	};
+
+	if (values && !props.options) props.options = optionObjects(Array.isArray(values) ? values : Object.values(values));
+	if (plain.min != null && props.min == null) props.min = plain.min;
+	if (plain.max != null && props.max == null) props.max = plain.max;
+	if (plain.step != null && props.step == null) props.step = plain.step;
+
+	return props;
+}
+
+function childrenForShape(shape, scope, options) {
+	return childrenForFieldShape(shape, scope, options, {
+		idPrefix: 'schema',
+		nestedShape: objectShape,
+		fieldForNested(childSchema, path, key, adapterOptions) {
+			return fieldOptions(adapterOptions, path, key, childSchema);
+		},
+		componentFor,
+		fieldPropsFor(childSchema, path, _key, adapterOptions) {
+			return fieldPropsFor(childSchema, path, adapterOptions);
+		},
+	});
+}
+
+export function zodSchemaToChildren(schema, options = {}) {
+	if (!schema) return [];
+	const shape = objectShape(schema) || raw(schema)?.shape || raw(schema)?.fields;
+	if (!shape) return [];
+	return childrenForShape(typeof shape === 'function' ? shape() : shape, '', options);
+}
+
+export const zodSchemaAdapter = {
+	name: 'zod',
+	matches: isZodLikeSchema,
+	toChildren: zodSchemaToChildren,
+};

package/src/pages/forms/form/formApi.js

@@ -0,0 +1,38 @@
+import { reactive } from 'vue';
+
+export const forms = reactive({});
+
+export function getPathValue(source, path) {
+	if (!path) return source;
+	return String(path)
+		.split('.')
+		.filter(Boolean)
+		.reduce((value, part) => value?.[part], source);
+}
+
+export function setPathValue(source, path, value) {
+	const parts = String(path).split('.').filter(Boolean);
+	if (!parts.length) return;
+	let target = source;
+	for (let index = 0; index < parts.length - 1; index += 1) {
+		const part = parts[index];
+		const nextPart = parts[index + 1];
+		if (target[part] == null || typeof target[part] !== 'object') {
+			target[part] = /^\d+$/.test(nextPart) ? [] : {};
+		}
+		target = target[part];
+	}
+	target[parts[parts.length - 1]] = value;
+}
+
+export function deletePathValue(source, path) {
+	const parts = String(path).split('.').filter(Boolean);
+	if (!parts.length) return;
+	const key = parts.pop();
+	const target = getPathValue(source, parts.join('.'));
+	if (target && typeof target === 'object') delete target[key];
+}
+
+export function createFormRegistry() {
+	return reactive({});
+}