@case-framework/survey-items 0.1.0

package/dist/form.mjs

@@ -0,0 +1,766 @@
+import { ContentType, ValueType, generateCodingKey, generateId, getContentPlainText } from "@case-framework/survey-core";
+//#region src/form.ts
+const FORM_DATEPICKER_FIELD_MODES = [
+	"year",
+	"year-month",
+	"year-month-day"
+];
+function getFormFieldValueType(field) {
+	switch (field.type) {
+		case "number":
+		case "slider": return ValueType.number;
+		case "datepicker": return ValueType.date;
+		case "switch": return ValueType.boolean;
+		default: return ValueType.string;
+	}
+}
+function getFormFieldEffectiveValidations(field) {
+	const effectiveValidations = field.validations.map((validation) => ({
+		...validation,
+		source: "validation"
+	}));
+	if (field.required !== true || effectiveValidations.some((validation) => validation.type === "required")) return effectiveValidations;
+	return [{
+		id: `${field.id}-required`,
+		type: "required",
+		source: "required"
+	}, ...effectiveValidations];
+}
+function createFormItemConfig(itemId) {
+	return {
+		id: itemId,
+		authoringMode: "custom",
+		fieldGroups: []
+	};
+}
+function createPlainTextContent(value) {
+	const normalizedValue = normalizeOptionalString(value);
+	return normalizedValue ? {
+		type: ContentType.plain,
+		content: normalizedValue
+	} : void 0;
+}
+function getTranslatedPlainText(itemTranslations, locale, contentKey, fallbackLocale) {
+	const content = itemTranslations?.getContent(locale, contentKey, fallbackLocale);
+	return getContentPlainText(content).trim() || void 0;
+}
+const FORM_FIELD_TRANSLATION_PREFIX = "fields";
+const FORM_FIELD_GROUP_TRANSLATION_PREFIX = "fieldGroups";
+function withFormTranslationNamespace(prefix, translationNamespace) {
+	return translationNamespace?.trim() ? `${translationNamespace}.${prefix}` : prefix;
+}
+function getFormFieldGroupTranslationPrefix(groupId, translationNamespace) {
+	return withFormTranslationNamespace(`${FORM_FIELD_GROUP_TRANSLATION_PREFIX}.${groupId}`, translationNamespace);
+}
+function getFormFieldGroupTitleContentKey(groupId, translationNamespace) {
+	return `${getFormFieldGroupTranslationPrefix(groupId, translationNamespace)}.title`;
+}
+function getFormFieldGroupDescriptionContentKey(groupId, translationNamespace) {
+	return `${getFormFieldGroupTranslationPrefix(groupId, translationNamespace)}.description`;
+}
+function getFormFieldTranslationPrefix(fieldId, translationNamespace) {
+	return withFormTranslationNamespace(`${FORM_FIELD_TRANSLATION_PREFIX}.${fieldId}`, translationNamespace);
+}
+function getFormFieldLabelContentKey(fieldId, translationNamespace) {
+	return `${getFormFieldTranslationPrefix(fieldId, translationNamespace)}.label`;
+}
+function getFormFieldDescriptionContentKey(fieldId, translationNamespace) {
+	return `${getFormFieldTranslationPrefix(fieldId, translationNamespace)}.description`;
+}
+function getFormFieldErrorMessageContentKey(fieldId, translationNamespace) {
+	return `${getFormFieldTranslationPrefix(fieldId, translationNamespace)}.error`;
+}
+function getFormFieldPlaceholderContentKey(fieldId, translationNamespace) {
+	return `${getFormFieldTranslationPrefix(fieldId, translationNamespace)}.placeholder`;
+}
+function getFormFieldUnitContentKey(fieldId, translationNamespace) {
+	return `${getFormFieldTranslationPrefix(fieldId, translationNamespace)}.unit`;
+}
+function getFormFieldCheckedLabelContentKey(fieldId, translationNamespace) {
+	return `${getFormFieldTranslationPrefix(fieldId, translationNamespace)}.checkedLabel`;
+}
+function getFormFieldUncheckedLabelContentKey(fieldId, translationNamespace) {
+	return `${getFormFieldTranslationPrefix(fieldId, translationNamespace)}.uncheckedLabel`;
+}
+function getFormFieldOptionLabelContentKey(fieldId, optionId, translationNamespace) {
+	return `${getFormFieldTranslationPrefix(fieldId, translationNamespace)}.options.${optionId}.label`;
+}
+function getFormFieldValidationMessageContentKey(fieldId, validationId, translationNamespace) {
+	return `${getFormFieldTranslationPrefix(fieldId, translationNamespace)}.validations.${validationId}.message`;
+}
+function getFormFieldTranslationKeys(field, translationNamespace) {
+	const keys = [
+		getFormFieldLabelContentKey(field.id, translationNamespace),
+		getFormFieldDescriptionContentKey(field.id, translationNamespace),
+		getFormFieldErrorMessageContentKey(field.id, translationNamespace),
+		...field.validations.map((validation) => getFormFieldValidationMessageContentKey(field.id, validation.id, translationNamespace))
+	];
+	switch (field.type) {
+		case "textarea":
+		case "datepicker":
+		case "input":
+			keys.push(getFormFieldPlaceholderContentKey(field.id, translationNamespace));
+			break;
+		case "number":
+			keys.push(getFormFieldPlaceholderContentKey(field.id, translationNamespace));
+			keys.push(getFormFieldUnitContentKey(field.id, translationNamespace));
+			break;
+		case "switch":
+			keys.push(getFormFieldCheckedLabelContentKey(field.id, translationNamespace));
+			keys.push(getFormFieldUncheckedLabelContentKey(field.id, translationNamespace));
+			break;
+		case "select": {
+			keys.push(getFormFieldPlaceholderContentKey(field.id, translationNamespace));
+			const controller = field.controller;
+			keys.push(...controller.options.map((option) => getFormFieldOptionLabelContentKey(field.id, option.id, translationNamespace)));
+			break;
+		}
+		case "slider": break;
+	}
+	return keys;
+}
+function getFormFieldGroupTranslationKeys(group, translationNamespace) {
+	return [getFormFieldGroupTitleContentKey(group.id, translationNamespace), getFormFieldGroupDescriptionContentKey(group.id, translationNamespace)];
+}
+function writeFormFieldGroupTranslations(itemTranslations, locale, group, translationNamespace) {
+	itemTranslations.setContent(locale, getFormFieldGroupTitleContentKey(group.id, translationNamespace), createPlainTextContent(group.title));
+	itemTranslations.setContent(locale, getFormFieldGroupDescriptionContentKey(group.id, translationNamespace), createPlainTextContent(group.description));
+}
+function writeFormFieldTranslations(itemTranslations, locale, field, translationNamespace) {
+	itemTranslations.setContent(locale, getFormFieldLabelContentKey(field.id, translationNamespace), createPlainTextContent(field.label));
+	itemTranslations.setContent(locale, getFormFieldDescriptionContentKey(field.id, translationNamespace), createPlainTextContent(field.description));
+	itemTranslations.setContent(locale, getFormFieldErrorMessageContentKey(field.id, translationNamespace), createPlainTextContent(field.errorMessage));
+	for (const validation of field.validations) itemTranslations.setContent(locale, getFormFieldValidationMessageContentKey(field.id, validation.id, translationNamespace), createPlainTextContent(validation.message));
+	switch (field.type) {
+		case "textarea":
+		case "datepicker":
+		case "input": {
+			const controller = field.controller;
+			itemTranslations.setContent(locale, getFormFieldPlaceholderContentKey(field.id, translationNamespace), createPlainTextContent(controller.placeholder));
+			break;
+		}
+		case "number": {
+			const controller = field.controller;
+			itemTranslations.setContent(locale, getFormFieldPlaceholderContentKey(field.id, translationNamespace), createPlainTextContent(controller.placeholder));
+			itemTranslations.setContent(locale, getFormFieldUnitContentKey(field.id, translationNamespace), createPlainTextContent(controller.unit));
+			break;
+		}
+		case "switch": {
+			const controller = field.controller;
+			itemTranslations.setContent(locale, getFormFieldCheckedLabelContentKey(field.id, translationNamespace), createPlainTextContent(controller.checkedLabel));
+			itemTranslations.setContent(locale, getFormFieldUncheckedLabelContentKey(field.id, translationNamespace), createPlainTextContent(controller.uncheckedLabel));
+			break;
+		}
+		case "select": {
+			const controller = field.controller;
+			itemTranslations.setContent(locale, getFormFieldPlaceholderContentKey(field.id, translationNamespace), createPlainTextContent(controller.placeholder));
+			for (const option of controller.options) itemTranslations.setContent(locale, getFormFieldOptionLabelContentKey(field.id, option.id, translationNamespace), createPlainTextContent(option.label));
+			break;
+		}
+		case "slider": break;
+	}
+}
+function withTranslatedFieldContent(field, itemTranslations, locale, fallbackLocale, translationNamespace) {
+	const translatedField = {
+		...field,
+		label: getTranslatedPlainText(itemTranslations, locale, getFormFieldLabelContentKey(field.id, translationNamespace), fallbackLocale) ?? field.label,
+		description: getTranslatedPlainText(itemTranslations, locale, getFormFieldDescriptionContentKey(field.id, translationNamespace), fallbackLocale) ?? field.description,
+		errorMessage: getTranslatedPlainText(itemTranslations, locale, getFormFieldErrorMessageContentKey(field.id, translationNamespace), fallbackLocale) ?? field.errorMessage,
+		validations: field.validations.map((validation) => ({
+			...validation,
+			message: getTranslatedPlainText(itemTranslations, locale, getFormFieldValidationMessageContentKey(field.id, validation.id, translationNamespace), fallbackLocale) ?? validation.message
+		}))
+	};
+	switch (field.type) {
+		case "textarea": {
+			const controller = field.controller;
+			translatedField.controller = {
+				...controller,
+				placeholder: getTranslatedPlainText(itemTranslations, locale, getFormFieldPlaceholderContentKey(field.id, translationNamespace), fallbackLocale) ?? controller.placeholder
+			};
+			break;
+		}
+		case "number": {
+			const controller = field.controller;
+			translatedField.controller = {
+				...controller,
+				placeholder: getTranslatedPlainText(itemTranslations, locale, getFormFieldPlaceholderContentKey(field.id, translationNamespace), fallbackLocale) ?? controller.placeholder,
+				unit: getTranslatedPlainText(itemTranslations, locale, getFormFieldUnitContentKey(field.id, translationNamespace), fallbackLocale) ?? controller.unit
+			};
+			break;
+		}
+		case "datepicker": {
+			const controller = field.controller;
+			translatedField.controller = {
+				...controller,
+				placeholder: getTranslatedPlainText(itemTranslations, locale, getFormFieldPlaceholderContentKey(field.id, translationNamespace), fallbackLocale) ?? controller.placeholder
+			};
+			break;
+		}
+		case "switch": {
+			const controller = field.controller;
+			translatedField.controller = {
+				...controller,
+				checkedLabel: getTranslatedPlainText(itemTranslations, locale, getFormFieldCheckedLabelContentKey(field.id, translationNamespace), fallbackLocale) ?? controller.checkedLabel,
+				uncheckedLabel: getTranslatedPlainText(itemTranslations, locale, getFormFieldUncheckedLabelContentKey(field.id, translationNamespace), fallbackLocale) ?? controller.uncheckedLabel
+			};
+			break;
+		}
+		case "select": {
+			const controller = field.controller;
+			translatedField.controller = {
+				...controller,
+				placeholder: getTranslatedPlainText(itemTranslations, locale, getFormFieldPlaceholderContentKey(field.id, translationNamespace), fallbackLocale) ?? controller.placeholder,
+				options: controller.options.map((option) => ({
+					...option,
+					label: getTranslatedPlainText(itemTranslations, locale, getFormFieldOptionLabelContentKey(field.id, option.id, translationNamespace), fallbackLocale) ?? option.label
+				}))
+			};
+			break;
+		}
+		case "slider": break;
+		default: {
+			const controller = field.controller;
+			translatedField.controller = {
+				...controller,
+				placeholder: getTranslatedPlainText(itemTranslations, locale, getFormFieldPlaceholderContentKey(field.id, translationNamespace), fallbackLocale) ?? controller.placeholder
+			};
+			break;
+		}
+	}
+	return translatedField;
+}
+function withTranslatedFieldGroupContent(group, itemTranslations, locale, fallbackLocale, translationNamespace) {
+	return {
+		...group,
+		title: getTranslatedPlainText(itemTranslations, locale, getFormFieldGroupTitleContentKey(group.id, translationNamespace), fallbackLocale) ?? group.title,
+		description: getTranslatedPlainText(itemTranslations, locale, getFormFieldGroupDescriptionContentKey(group.id, translationNamespace), fallbackLocale) ?? group.description,
+		fields: group.fields.map((field) => withTranslatedFieldContent(field, itemTranslations, locale, fallbackLocale, translationNamespace))
+	};
+}
+function withFormItemTranslatedContent(config, itemTranslations, locale, options = {}) {
+	const { fallbackLocale, translationNamespace } = options;
+	return {
+		...config,
+		fieldGroups: config.fieldGroups.map((group) => withTranslatedFieldGroupContent(group, itemTranslations, locale, fallbackLocale, translationNamespace))
+	};
+}
+function withoutTranslatedFieldContent(field) {
+	const serializedField = {
+		...field,
+		label: void 0,
+		description: void 0,
+		errorMessage: void 0,
+		required: void 0,
+		hasValidations: void 0,
+		isInvalid: void 0,
+		validations: field.validations.map((validation) => ({
+			...validation,
+			message: void 0
+		}))
+	};
+	switch (field.type) {
+		case "textarea":
+			serializedField.controller = {
+				...field.controller,
+				placeholder: void 0
+			};
+			break;
+		case "number":
+			serializedField.controller = {
+				...field.controller,
+				placeholder: void 0,
+				unit: void 0
+			};
+			break;
+		case "datepicker":
+			serializedField.controller = {
+				...field.controller,
+				placeholder: void 0
+			};
+			break;
+		case "switch":
+			serializedField.controller = {
+				...field.controller,
+				checkedLabel: void 0,
+				uncheckedLabel: void 0
+			};
+			break;
+		case "select": {
+			const controller = field.controller;
+			serializedField.controller = {
+				...controller,
+				placeholder: void 0,
+				options: controller.options.map((option) => ({
+					...option,
+					label: void 0
+				}))
+			};
+			break;
+		}
+		case "slider": break;
+		default:
+			serializedField.controller = {
+				...field.controller,
+				placeholder: void 0
+			};
+			break;
+	}
+	return serializedField;
+}
+function withoutTranslatedFieldGroupContent(group) {
+	return {
+		...group,
+		title: void 0,
+		description: void 0,
+		fields: group.fields.map((field) => withoutTranslatedFieldContent(field))
+	};
+}
+function withoutFormItemTranslatedContent(config) {
+	return {
+		...config,
+		fieldGroups: config.fieldGroups.map((group) => withoutTranslatedFieldGroupContent(group))
+	};
+}
+function normalizeColumnCount(value) {
+	if (typeof value !== "number" || !Number.isFinite(value)) return 1;
+	return Math.min(4, Math.max(1, Math.round(value)));
+}
+function normalizeFormFieldGroupLayoutConfig(rawLayout) {
+	const layout = rawLayout && typeof rawLayout === "object" ? rawLayout : {};
+	const hasBaseKey = Object.prototype.hasOwnProperty.call(layout, "base");
+	const hasXsKey = Object.prototype.hasOwnProperty.call(layout, "xs");
+	if (!hasBaseKey && !hasXsKey && (layout.sm !== void 0 || layout.md !== void 0 || layout.lg !== void 0)) {
+		const narrow = normalizeColumnCount(layout.sm);
+		return {
+			base: narrow,
+			xs: narrow,
+			sm: normalizeColumnCount(layout.md ?? layout.sm),
+			md: normalizeColumnCount(layout.lg ?? layout.md ?? layout.sm),
+			xl: normalizeColumnCount(layout.lg ?? layout.md ?? layout.sm)
+		};
+	}
+	const xs = normalizeColumnCount(layout.xs ?? layout.sm ?? 1);
+	const sm = normalizeColumnCount(layout.sm ?? 1);
+	const md = normalizeColumnCount(layout.md ?? 1);
+	const xl = normalizeColumnCount(layout.xl ?? layout.lg ?? 1);
+	return {
+		base: normalizeColumnCount(hasBaseKey ? layout.base : xs),
+		xs,
+		sm,
+		md,
+		xl
+	};
+}
+/** CSS custom properties for `.form-field-group-layout-scope` + `.form-field-group-grid`. */
+function formFieldGroupLayoutCssVars(layout) {
+	return {
+		"--form-group-cols-base": String(layout.base),
+		"--form-group-cols-xs": String(layout.xs),
+		"--form-group-cols-sm": String(layout.sm),
+		"--form-group-cols-md": String(layout.md),
+		"--form-group-cols-xl": String(layout.xl)
+	};
+}
+function normalizeOptionalString(value) {
+	if (typeof value !== "string") return;
+	return value.trim() || void 0;
+}
+function normalizeOptionalNumber(value) {
+	if (typeof value !== "number" || !Number.isFinite(value)) return;
+	return value;
+}
+function normalizeOptionalBoolean(value) {
+	return value === true ? true : value === false ? false : void 0;
+}
+function normalizeFormFieldKey(id, key) {
+	return key?.trim() || id.replace(/[^a-zA-Z0-9]/g, "").slice(0, 4).toUpperCase() || generateCodingKey(4);
+}
+function createDefaultFormFieldControlConfig(type) {
+	switch (type) {
+		case "textarea": return {
+			type,
+			rows: 3
+		};
+		case "number": return {
+			type,
+			step: 1
+		};
+		case "datepicker": return {
+			type,
+			mode: "year-month-day"
+		};
+		case "switch": return {
+			type,
+			defaultChecked: false
+		};
+		case "select": return {
+			type,
+			options: []
+		};
+		case "slider": return {
+			type,
+			min: 0,
+			max: 100,
+			step: 1,
+			defaultValue: 50,
+			showValue: true
+		};
+		default: return {
+			type: "input",
+			inputMode: "text"
+		};
+	}
+}
+function normalizeFormFieldSelectOptionConfig(rawOption) {
+	if (!rawOption || typeof rawOption !== "object") return null;
+	const option = rawOption;
+	const id = normalizeOptionalString(option.id) ?? generateId();
+	const value = normalizeOptionalString(option.value);
+	const label = normalizeOptionalString(option.label);
+	if (!value && !label) return null;
+	return {
+		id,
+		value: value ?? label ?? id,
+		label
+	};
+}
+function hasDuplicateSelectOptionValue(options) {
+	const seenValues = /* @__PURE__ */ new Set();
+	for (const option of options) {
+		const normalizedValue = option.value.trim().toLowerCase();
+		if (!normalizedValue) continue;
+		if (seenValues.has(normalizedValue)) return true;
+		seenValues.add(normalizedValue);
+	}
+	return false;
+}
+function normalizeFormFieldValidationConfig(rawValidation) {
+	if (!rawValidation || typeof rawValidation !== "object") return null;
+	const validation = rawValidation;
+	const id = normalizeOptionalString(validation.id) ?? generateId();
+	const message = normalizeOptionalString(validation.message);
+	switch (validation.type) {
+		case "minLength":
+		case "maxLength":
+		case "min":
+		case "max": {
+			const value = normalizeOptionalNumber(validation.value);
+			if (value === void 0) return null;
+			return {
+				id,
+				type: validation.type,
+				value,
+				message
+			};
+		}
+		case "pattern": {
+			const value = normalizeOptionalString(validation.value);
+			if (!value) return null;
+			return {
+				id,
+				type: "pattern",
+				value,
+				message
+			};
+		}
+		case "minDate":
+		case "maxDate": {
+			const value = normalizeOptionalString(validation.value);
+			if (!value) return null;
+			return {
+				id,
+				type: validation.type,
+				value,
+				message
+			};
+		}
+		case "email":
+		case "url":
+		case "integer":
+		case "required":
+		case "mustBeTrue": return {
+			id,
+			type: validation.type,
+			message
+		};
+		default: return null;
+	}
+}
+function normalizeFormFieldControlConfig(rawController, type) {
+	const controller = rawController && typeof rawController === "object" ? rawController : {};
+	switch (type) {
+		case "textarea": {
+			const defaults = createDefaultFormFieldControlConfig(type);
+			return {
+				type,
+				placeholder: normalizeOptionalString(controller.placeholder),
+				rows: Math.min(12, Math.max(2, Math.round(normalizeOptionalNumber(controller.rows) ?? defaults.rows ?? 3)))
+			};
+		}
+		case "number": {
+			const defaults = createDefaultFormFieldControlConfig(type);
+			return {
+				type,
+				placeholder: normalizeOptionalString(controller.placeholder),
+				step: normalizeOptionalNumber(controller.step) ?? defaults.step,
+				unit: normalizeOptionalString(controller.unit),
+				defaultValue: normalizeOptionalNumber(controller.defaultValue)
+			};
+		}
+		case "datepicker": {
+			const defaults = createDefaultFormFieldControlConfig(type);
+			return {
+				type,
+				placeholder: normalizeOptionalString(controller.placeholder),
+				mode: controller.mode === "year" || controller.mode === "year-month" ? controller.mode : defaults.mode
+			};
+		}
+		case "switch": return {
+			type,
+			checkedLabel: normalizeOptionalString(controller.checkedLabel),
+			uncheckedLabel: normalizeOptionalString(controller.uncheckedLabel),
+			defaultChecked: normalizeOptionalBoolean(controller.defaultChecked) ?? false
+		};
+		case "select": {
+			const defaults = createDefaultFormFieldControlConfig(type);
+			return {
+				type,
+				placeholder: normalizeOptionalString(controller.placeholder),
+				allowClear: normalizeOptionalBoolean(controller.allowClear),
+				options: Array.isArray(controller.options) ? controller.options.map((option) => normalizeFormFieldSelectOptionConfig(option)).filter((option) => option !== null) : defaults.options
+			};
+		}
+		case "slider": {
+			const defaults = createDefaultFormFieldControlConfig(type);
+			return {
+				type,
+				min: normalizeOptionalNumber(controller.min) ?? defaults.min,
+				max: normalizeOptionalNumber(controller.max) ?? defaults.max,
+				step: normalizeOptionalNumber(controller.step) ?? defaults.step,
+				defaultValue: normalizeOptionalNumber(controller.defaultValue) ?? defaults.defaultValue,
+				showValue: normalizeOptionalBoolean(controller.showValue) ?? defaults.showValue ?? true
+			};
+		}
+		default: return {
+			type: "input",
+			placeholder: normalizeOptionalString(controller.placeholder),
+			inputMode: controller.inputMode === "email" || controller.inputMode === "tel" || controller.inputMode === "url" || controller.inputMode === "password" ? controller.inputMode : "text",
+			autocomplete: normalizeOptionalString(controller.autocomplete)
+		};
+	}
+}
+function hasDuplicateValidationType(validations) {
+	const seenValidationTypes = /* @__PURE__ */ new Set();
+	for (const validation of validations) {
+		if (seenValidationTypes.has(validation.type)) return true;
+		seenValidationTypes.add(validation.type);
+	}
+	return false;
+}
+function isFormFieldConfigInvalid(field) {
+	if (!field.key.trim()) return true;
+	if (hasDuplicateValidationType(field.validations)) return true;
+	switch (field.type) {
+		case "number": {
+			const controller = field.controller;
+			if (controller.step !== void 0 && controller.step <= 0) return true;
+			return false;
+		}
+		case "datepicker": {
+			const minDate = field.validations.find((validation) => validation.type === "minDate")?.value;
+			const maxDate = field.validations.find((validation) => validation.type === "maxDate")?.value;
+			if (typeof minDate === "string" && typeof maxDate === "string" && minDate > maxDate) return true;
+			return false;
+		}
+		case "select": {
+			const controller = field.controller;
+			return controller.options.length === 0 || controller.options.some((option) => !option.value.trim()) || hasDuplicateSelectOptionValue(controller.options);
+		}
+		case "slider": {
+			const controller = field.controller;
+			if (controller.min === void 0 || controller.max === void 0 || controller.step === void 0 || controller.defaultValue === void 0) return true;
+			return controller.min >= controller.max || controller.step <= 0 || controller.defaultValue < controller.min || controller.defaultValue > controller.max;
+		}
+		default: return field.validations.some((validation) => {
+			if ((validation.type === "minLength" || validation.type === "maxLength" || validation.type === "min" || validation.type === "max") && typeof validation.value === "number") return validation.value < 0;
+			if ((validation.type === "pattern" || validation.type === "minDate" || validation.type === "maxDate") && typeof validation.value === "string") return validation.value.trim().length === 0;
+			return false;
+		});
+	}
+}
+function normalizeFormFieldConfig(rawField) {
+	if (!rawField || typeof rawField !== "object") return null;
+	const field = rawField;
+	const trimmedId = typeof field.id === "string" ? field.id.trim() : "";
+	const trimmedKey = typeof field.key === "string" ? field.key.trim() : "";
+	if (!trimmedId) return null;
+	const normalizedKey = normalizeFormFieldKey(trimmedId, trimmedKey);
+	const type = field.type === "textarea" || field.type === "number" || field.type === "datepicker" || field.type === "switch" || field.type === "select" || field.type === "slider" ? field.type : "input";
+	const normalizedRawValidations = Array.isArray(field.validations) ? field.validations.map((validation) => normalizeFormFieldValidationConfig(validation)).filter((validation) => validation !== null) : [];
+	const validations = getFormFieldEffectiveValidations({
+		id: trimmedId,
+		required: field.required === true ? true : void 0,
+		validations: normalizedRawValidations
+	}).map((validation) => ({
+		id: validation.id,
+		type: validation.type,
+		value: validation.value,
+		message: validation.message
+	}));
+	const controller = normalizeFormFieldControlConfig(field.controller, type);
+	const hasEffectiveValidations = getFormFieldEffectiveValidations({
+		id: trimmedId,
+		validations
+	}).length > 0;
+	return {
+		id: trimmedId,
+		key: normalizedKey,
+		type,
+		label: normalizeOptionalString(field.label),
+		description: normalizeOptionalString(field.description),
+		errorMessage: normalizeOptionalString(field.errorMessage),
+		required: validations.some((validation) => validation.type === "required") ? true : void 0,
+		controller,
+		validations,
+		hasValidations: hasEffectiveValidations ? true : void 0,
+		isInvalid: isFormFieldConfigInvalid({
+			key: normalizedKey,
+			type,
+			controller,
+			validations
+		}) ? true : void 0
+	};
+}
+function normalizeFormFieldGroupConfig(rawGroup) {
+	if (!rawGroup || typeof rawGroup !== "object") return null;
+	const group = rawGroup;
+	const trimmedId = typeof group.id === "string" ? group.id.trim() : "";
+	const trimmedTitle = typeof group.title === "string" ? group.title.trim() : "";
+	const trimmedDescription = typeof group.description === "string" ? group.description.trim() : "";
+	if (!trimmedId) return null;
+	return {
+		id: trimmedId,
+		title: trimmedTitle || void 0,
+		description: trimmedDescription || void 0,
+		hasDisplayCondition: group.hasDisplayCondition === true ? true : void 0,
+		layout: normalizeFormFieldGroupLayoutConfig(group.layout),
+		fields: Array.isArray(group.fields) ? group.fields.map((field) => normalizeFormFieldConfig(field)).filter((field) => field !== null) : []
+	};
+}
+function normalizeFormItemConfig(rawConfig, itemId) {
+	const config = rawConfig ?? {};
+	return {
+		id: typeof config.id === "string" && config.id.trim() ? config.id : itemId,
+		authoringMode: config.authoringMode === "simple" ? "simple" : "custom",
+		fieldGroups: Array.isArray(config.fieldGroups) ? config.fieldGroups.map((group) => normalizeFormFieldGroupConfig(group)).filter((group) => group !== null) : []
+	};
+}
+function createFormFieldGroupConfig() {
+	return {
+		id: generateId(),
+		layout: {
+			base: 1,
+			xs: 1,
+			sm: 1,
+			md: 1,
+			xl: 1
+		},
+		fields: []
+	};
+}
+function getNextAvailableFormFieldKey(fields) {
+	const usedKeys = new Set(fields.map((field) => field.key.trim().toLowerCase()).filter(Boolean));
+	let nextIndex = 1;
+	while (usedKeys.has(`f${nextIndex}`)) nextIndex += 1;
+	return `F${nextIndex}`;
+}
+function createFormFieldConfig(type, key = generateCodingKey(4)) {
+	return {
+		id: generateId(),
+		key,
+		type,
+		controller: createDefaultFormFieldControlConfig(type),
+		validations: []
+	};
+}
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const SIMPLE_FORM_FIELD_TYPES = new Set([
+	"input",
+	"textarea",
+	"number",
+	"slider",
+	"select",
+	"datepicker",
+	"switch"
+]);
+const getFormAuthoringMode = (config) => isRecord(config) && config.authoringMode === "simple" ? "simple" : "custom";
+const hasSingleFormField = (config) => {
+	if (!isRecord(config) || !Array.isArray(config.fieldGroups) || config.fieldGroups.length !== 1) return false;
+	const [group] = config.fieldGroups;
+	if (!isRecord(group) || !Array.isArray(group.fields) || group.fields.length !== 1) return false;
+	const layout = isRecord(group.layout) ? group.layout : void 0;
+	if (group.hasDisplayCondition === true || layout && [
+		"base",
+		"xs",
+		"sm",
+		"md",
+		"xl"
+	].some((breakpoint) => layout[breakpoint] !== void 0 && layout[breakpoint] !== 1)) return false;
+	const [field] = group.fields;
+	return isRecord(field) && typeof field.id === "string" && field.id.length > 0 && typeof field.key === "string" && field.key.length > 0 && typeof field.type === "string" && SIMPLE_FORM_FIELD_TYPES.has(field.type) && isRecord(field.controller) && field.controller.type === field.type;
+};
+const isValidSimpleFormConfig = (config) => getFormAuthoringMode(config) !== "simple" || hasSingleFormField(config);
+/**
+* Canonicalizes the editor-facing mode without modifying groups, fields, or translations.
+* Missing modes and malformed simple forms become custom; valid simple forms stay simple.
+*/
+const normalizeFormAuthoringConfig = (config) => {
+	if (!isRecord(config)) return;
+	return {
+		...config,
+		authoringMode: config.authoringMode === "simple" && hasSingleFormField(config) ? "simple" : "custom"
+	};
+};
+/**
+* Returns true only for an in-place edit of the existing sole field that the simple editor can
+* still represent. Adding, moving, retyping, or exposing hidden field configuration is structural.
+*/
+const isCompatibleSimpleFieldUpsert = ({ config, field, groupId, index }) => {
+	if (getFormAuthoringMode(config) !== "simple" || !isRecord(config) || !Array.isArray(config.fieldGroups) || config.fieldGroups.length !== 1 || (index ?? 0) > 0) return false;
+	const [group] = config.fieldGroups;
+	if (!isRecord(group) || group.id !== groupId || !Array.isArray(group.fields)) return false;
+	const [existingField] = group.fields;
+	if (!isRecord(existingField) || group.fields.length !== 1) return false;
+	const controller = isRecord(field.controller) ? field.controller : void 0;
+	const validationsUnchanged = field.validations === void 0 || JSON.stringify(field.validations) === JSON.stringify(existingField.validations);
+	const simpleEditableKeys = new Set([
+		"id",
+		"key",
+		"type",
+		"controller",
+		"required",
+		"validations"
+	]);
+	const hiddenConfigUnchanged = Object.keys(field).filter((key) => !simpleEditableKeys.has(key)).every((key) => JSON.stringify(field[key]) === JSON.stringify(existingField[key]));
+	return existingField.id === field.id && existingField.key === field.key && existingField.type === field.type && controller?.type === field.type && validationsUnchanged && hiddenConfigUnchanged;
+};
+/** Structural form edits leave simple mode unless the sole field remains representable there. */
+const transitionFormAuthoringMode = ({ config, fieldGroups, preserveSimpleMode = false }) => {
+	const nextConfig = {
+		...config,
+		fieldGroups
+	};
+	if (getFormAuthoringMode(config) !== "simple") return {
+		...nextConfig,
+		authoringMode: "custom"
+	};
+	return {
+		...nextConfig,
+		authoringMode: preserveSimpleMode && hasSingleFormField(nextConfig) ? "simple" : "custom"
+	};
+};
+//#endregion
+export { FORM_DATEPICKER_FIELD_MODES, createFormFieldConfig, createFormFieldGroupConfig, createFormItemConfig, formFieldGroupLayoutCssVars, getFormAuthoringMode, getFormFieldCheckedLabelContentKey, getFormFieldDescriptionContentKey, getFormFieldEffectiveValidations, getFormFieldErrorMessageContentKey, getFormFieldGroupDescriptionContentKey, getFormFieldGroupTitleContentKey, getFormFieldGroupTranslationKeys, getFormFieldGroupTranslationPrefix, getFormFieldLabelContentKey, getFormFieldOptionLabelContentKey, getFormFieldPlaceholderContentKey, getFormFieldTranslationKeys, getFormFieldTranslationPrefix, getFormFieldUncheckedLabelContentKey, getFormFieldUnitContentKey, getFormFieldValidationMessageContentKey, getFormFieldValueType, getNextAvailableFormFieldKey, hasSingleFormField, isCompatibleSimpleFieldUpsert, isValidSimpleFormConfig, normalizeFormAuthoringConfig, normalizeFormItemConfig, transitionFormAuthoringMode, withFormItemTranslatedContent, withoutFormItemTranslatedContent, writeFormFieldGroupTranslations, writeFormFieldTranslations };
+
+//# sourceMappingURL=form.mjs.map