@oktis-works/admin 0.1.7 → 0.1.8

package/dist/server/chunks/{ContentEditor_DwBpNq-K.mjs → ContentEditor_CrO12IkK.mjs}

@@ -1,19 +1,515 @@
-import "./rolldown-runtime_BMI-E3GI.mjs";
-import { t as apiClient } from "./api_BWOj0bUJ.mjs";
-import { t as require_semver } from "./semver_WbqCUY_o.mjs";
+import { a as For2, d as createMemo$1, f as createSignal$1, l as Show2 } from "./DashboardLayout_h9iqOf7E.mjs";
+import { t as apiClient } from "./api_C1VC3OiH.mjs";
 import { createComponent, escape, memo, ssr, ssrAttribute, ssrHydrationKey } from "solid-js/web";
-import { For, For as For$1, Show, Show as Show$1, createMemo, createMemo as createMemo$1, createSignal, createSignal as createSignal$1, onMount } from "solid-js";
-//#region src/lib/validation.ts
-function validateFieldClient(_field, _value) {
-	return {
-		valid: true,
-		errors: []
-	};
+import { For, Show, createMemo, createSignal, onMount } from "solid-js";
+//#region ../../packages/validation/dist/client-validate.js
+function isEmptyValue(value) {
+	if (value === null || value === void 0) return true;
+	if (typeof value === "string") return value.trim() === "";
+	if (Array.isArray(value)) return value.length === 0;
+	return false;
+}
+function checkRequired(value, required, field, errors) {
+	if (!required) return true;
+	if (isEmptyValue(value)) {
+		errors.push({
+			field,
+			code: "REQUIRED",
+			message: `${field} é obrigatório`
+		});
+		return false;
+	}
+	return true;
+}
+function validateTextLike(value, config, field, errors) {
+	if (isEmptyValue(value)) return;
+	const str = String(value);
+	const characterLimit = config["characterLimit"];
+	if (characterLimit !== void 0 && str.length > characterLimit) errors.push({
+		field,
+		code: "CHARACTER_LIMIT",
+		message: `${field} excede o limite de ${characterLimit} caracteres`
+	});
+}
+function validateEmail(value, field, errors) {
+	if (isEmptyValue(value)) return;
+	if (!/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(String(value))) errors.push({
+		field,
+		code: "INVALID_EMAIL",
+		message: `${field} não é um e-mail válido`
+	});
+}
+function validateUrl(value, field, errors) {
+	if (isEmptyValue(value)) return;
+	try {
+		const parsed = new URL(String(value));
+		if (!["http:", "https:"].includes(parsed.protocol)) throw new Error("protocol");
+	} catch {
+		errors.push({
+			field,
+			code: "INVALID_URL",
+			message: `${field} não é uma URL válida (http/https)`
+		});
+	}
+}
+function validateNumber(value, config, field, errors) {
+	if (isEmptyValue(value)) return;
+	const num = Number(value);
+	if (Number.isNaN(num)) {
+		errors.push({
+			field,
+			code: "NOT_A_NUMBER",
+			message: `${field} deve ser um número`
+		});
+		return;
+	}
+	const minValue = config["minValue"];
+	const maxValue = config["maxValue"];
+	const step = config["step"];
+	if (minValue !== void 0 && num < minValue) errors.push({
+		field,
+		code: "MIN_VALUE",
+		message: `${field} deve ser maior ou igual a ${minValue}`
+	});
+	if (maxValue !== void 0 && num > maxValue) errors.push({
+		field,
+		code: "MAX_VALUE",
+		message: `${field} deve ser menor ou igual a ${maxValue}`
+	});
+	if (step !== void 0 && step > 0) {
+		const base = minValue ?? 0;
+		if (Math.abs((num - base) / step - Math.round((num - base) / step)) > 1e-9) errors.push({
+			field,
+			code: "STEP_MISMATCH",
+			message: `${field} deve seguir o incremento de ${step}`
+		});
+	}
+}
+function getValidChoiceValues(config) {
+	const choices = config["choices"] ?? [];
+	return new Set(choices.map((c) => String(c.value)));
+}
+function checkClosedSet(value, valid, allowCustom, field, errors) {
+	if (allowCustom) return;
+	if (!valid.has(String(value))) errors.push({
+		field,
+		code: "INVALID_CHOICE",
+		message: `${field} contém um valor fora das opções permitidas`
+	});
+}
+function checkSelectionCount(values, config, field, errors) {
+	const min = config["minSelections"];
+	const max = config["maxSelections"];
+	if (min !== void 0 && values.length < min) errors.push({
+		field,
+		code: "MIN_SELECTIONS",
+		message: `${field} requer no mínimo ${min} seleção(ões)`
+	});
+	if (max !== void 0 && values.length > max) errors.push({
+		field,
+		code: "MAX_SELECTIONS",
+		message: `${field} permite no máximo ${max} seleção(ões)`
+	});
+}
+function validateSelect(value, config, field, errors) {
+	if (isEmptyValue(value)) return;
+	const multiple = Boolean(config["multiple"]);
+	const allowCustom = Boolean(config["allowCustom"] ?? false);
+	const valid = getValidChoiceValues(config);
+	if (multiple) {
+		if (!Array.isArray(value)) {
+			errors.push({
+				field,
+				code: "NOT_ARRAY",
+				message: `${field} deve ser uma lista`
+			});
+			return;
+		}
+		if (!allowCustom) for (const item of value) checkClosedSet(item, valid, false, field, errors);
+		checkSelectionCount(value, config, field, errors);
+		return;
+	}
+	checkClosedSet(value, valid, allowCustom, field, errors);
+	if (Array.isArray(value)) errors.push({
+		field,
+		code: "SINGLE_ONLY",
+		message: `${field} aceita apenas um valor`
+	});
+}
+function validateCheckbox(value, config, field, errors) {
+	if (isEmptyValue(value)) return;
+	if (!Array.isArray(value)) {
+		errors.push({
+			field,
+			code: "NOT_ARRAY",
+			message: `${field} deve ser uma lista de valores`
+		});
+		return;
+	}
+	const valid = getValidChoiceValues(config);
+	for (const item of value) checkClosedSet(item, valid, true, field, errors);
+	checkSelectionCount(value, config, field, errors);
+}
+function validateRadio(value, config, field, errors) {
+	if (isEmptyValue(value)) return;
+	checkClosedSet(value, getValidChoiceValues(config), Boolean(config["allowCustom"]), field, errors);
+}
+function validateTrueFalse(value, field, errors) {
+	if (value === null || value === void 0) return;
+	if (!(typeof value === "boolean" || value === 0 || value === 1 || value === "0" || value === "1")) errors.push({
+		field,
+		code: "NOT_BOOLEAN",
+		message: `${field} deve ser verdadeiro ou falso`
+	});
+}
+function validateMediaItem(item, config, field, errors) {
+	if (typeof item !== "object" || item === null || Array.isArray(item)) {
+		errors.push({
+			field,
+			code: "INVALID_MEDIA",
+			message: `${field} deve referenciar uma mídia válida`
+		});
+		return;
+	}
+	const media = item;
+	const mimeTypes = config["mimeTypes"] ?? [];
+	if (mimeTypes.length > 0 && media.mimeType) {
+		if (!mimeTypes.map((m) => m.toLowerCase()).includes(media.mimeType.toLowerCase())) errors.push({
+			field,
+			code: "INVALID_MIME",
+			message: `${field} não aceita arquivos do tipo ${media.mimeType}`
+		});
+	}
+	const maxSize = config["maxSize"];
+	const minSize = config["minSize"];
+	if (media.size !== void 0) {
+		if (maxSize !== void 0 && media.size > maxSize) errors.push({
+			field,
+			code: "FILE_TOO_LARGE",
+			message: `${field} excede o tamanho máximo de ${Math.round(maxSize / 1024)}KB`
+		});
+		if (minSize !== void 0 && media.size < minSize) errors.push({
+			field,
+			code: "FILE_TOO_SMALL",
+			message: `${field} está abaixo do tamanho mínimo de ${Math.round(minSize / 1024)}KB`
+		});
+	}
+	if (media.width !== void 0 && media.height !== void 0) {
+		const minWidth = config["minWidth"];
+		const maxWidth = config["maxWidth"];
+		const minHeight = config["minHeight"];
+		const maxHeight = config["maxHeight"];
+		if (minWidth !== void 0 && media.width < minWidth) errors.push({
+			field,
+			code: "MIN_WIDTH",
+			message: `${field} requer largura mínima de ${minWidth}px`
+		});
+		if (maxWidth !== void 0 && media.width > maxWidth) errors.push({
+			field,
+			code: "MAX_WIDTH",
+			message: `${field} permite largura máxima de ${maxWidth}px`
+		});
+		if (minHeight !== void 0 && media.height < minHeight) errors.push({
+			field,
+			code: "MIN_HEIGHT",
+			message: `${field} requer altura mínima de ${minHeight}px`
+		});
+		if (maxHeight !== void 0 && media.height > maxHeight) errors.push({
+			field,
+			code: "MAX_HEIGHT",
+			message: `${field} permite altura máxima de ${maxHeight}px`
+		});
+	}
+}
+function validateImage(value, config, field, errors) {
+	if (isEmptyValue(value)) return;
+	validateMediaItem(value, config, field, errors);
+}
+function validateFile(value, config, field, errors) {
+	if (isEmptyValue(value)) return;
+	validateMediaItem(value, config, field, errors);
 }
+function validateGallery(value, config, field, errors) {
+	if (value === null || value === void 0) return;
+	if (!Array.isArray(value)) {
+		errors.push({
+			field,
+			code: "NOT_ARRAY",
+			message: `${field} deve ser uma lista de imagens`
+		});
+		return;
+	}
+	const hasLimits = config["minSelections"] !== void 0 || config["maxSelections"] !== void 0;
+	if (value.length === 0 && !hasLimits) return;
+	const minSelections = config["minSelections"];
+	const maxSelections = config["maxSelections"];
+	if (minSelections !== void 0 && value.length < minSelections) errors.push({
+		field,
+		code: "MIN_SELECTIONS",
+		message: `${field} requer no mínimo ${minSelections} imagem(ns)`
+	});
+	if (maxSelections !== void 0 && value.length > maxSelections) errors.push({
+		field,
+		code: "MAX_SELECTIONS",
+		message: `${field} permite no máximo ${maxSelections} imagem(ns)`
+	});
+	for (const item of value) validateMediaItem(item, config, field, errors);
+}
+function validateRelationshipIds(value, config, field, errors) {
+	if (isEmptyValue(value)) return;
+	const multiple = config["multiple"] !== false;
+	const minSelections = config["minSelections"];
+	const maxSelections = config["maxSelections"];
+	const ids = Array.isArray(value) ? value : [value];
+	for (const id of ids) if (typeof id !== "string" && typeof id !== "number") {
+		errors.push({
+			field,
+			code: "INVALID_ID",
+			message: `${field} contém um identificador inválido`
+		});
+		return;
+	}
+	if (multiple) {
+		if (maxSelections !== void 0 && ids.length > maxSelections) errors.push({
+			field,
+			code: "MAX_SELECTIONS",
+			message: `${field} permite no máximo ${maxSelections} seleção(ões)`
+		});
+		if (minSelections !== void 0 && ids.length < minSelections) errors.push({
+			field,
+			code: "MIN_SELECTIONS",
+			message: `${field} requer no mínimo ${minSelections} seleção(ões)`
+		});
+	} else if (ids.length > 1) errors.push({
+		field,
+		code: "SINGLE_ONLY",
+		message: `${field} aceita apenas um valor`
+	});
+}
+function validateLink(value, field, errors) {
+	if (isEmptyValue(value)) return;
+	if (typeof value !== "object" || value === null) {
+		errors.push({
+			field,
+			code: "INVALID_LINK",
+			message: `${field} deve ser um objeto de link`
+		});
+		return;
+	}
+	const link = value;
+	if (!link.url || typeof link.url !== "string") {
+		errors.push({
+			field,
+			code: "LINK_URL_REQUIRED",
+			message: `${field} requer uma URL`
+		});
+		return;
+	}
+	try {
+		const parsed = new URL(link.url);
+		if (![
+			"http:",
+			"https:",
+			"mailto:",
+			"tel:"
+		].includes(parsed.protocol) && !link.url.startsWith("#") && !link.url.startsWith("/")) throw new Error("protocol");
+	} catch {
+		if (!link.url.startsWith("#") && !link.url.startsWith("/") && !link.url.startsWith("?")) errors.push({
+			field,
+			code: "INVALID_URL",
+			message: `${field} contém uma URL inválida`
+		});
+	}
+	if (link.target !== void 0 && !["_self", "_blank"].includes(String(link.target))) errors.push({
+		field,
+		code: "INVALID_TARGET",
+		message: `${field} aceita apenas _self ou _blank`
+	});
+}
+function validateGoogleMap(value, field, errors) {
+	if (isEmptyValue(value)) return;
+	if (typeof value !== "object" || value === null) {
+		errors.push({
+			field,
+			code: "INVALID_MAP",
+			message: `${field} deve conter endereço e coordenadas`
+		});
+		return;
+	}
+	const map = value;
+	if (isEmptyValue(map.address)) errors.push({
+		field,
+		code: "ADDRESS_REQUIRED",
+		message: `${field} requer um endereço`
+	});
+	const lat = Number(map.lat);
+	const lng = Number(map.lng);
+	if (!Number.isFinite(lat) || lat < -90 || lat > 90) errors.push({
+		field,
+		code: "INVALID_LATITUDE",
+		message: `${field} contém latitude inválida (-90 a 90)`
+	});
+	if (!Number.isFinite(lng) || lng < -180 || lng > 180) errors.push({
+		field,
+		code: "INVALID_LONGITUDE",
+		message: `${field} contém longitude inválida (-180 a 180)`
+	});
+}
+var HEX_PATTERN = /^#(?:[0-9a-fA-F]{3}|[0-9a-fA-F]{6}|[0-9a-fA-F]{8})$/;
+function validateColorPicker(value, config, field, errors) {
+	if (isEmptyValue(value)) return;
+	const color = String(value);
+	const isRgba = color.startsWith("rgba(");
+	if (isRgba && !config["enableOpacity"]) {
+		errors.push({
+			field,
+			code: "OPACITY_DISABLED",
+			message: `${field} não permite transparência`
+		});
+		return;
+	}
+	if (!isRgba && !HEX_PATTERN.test(color)) {
+		errors.push({
+			field,
+			code: "INVALID_COLOR",
+			message: `${field} deve ser uma cor em formato hexadecimal válido`
+		});
+		return;
+	}
+	const palette = config["palette"] ?? [];
+	if (palette.length > 0) {
+		if (!palette.map((e) => e.toLowerCase()).includes(color.toLowerCase())) errors.push({
+			field,
+			code: "NOT_IN_PALETTE",
+			message: `${field} deve usar uma cor da paleta definida`
+		});
+	}
+}
+/**
+* Valida um único campo no cliente e retorna a primeira mensagem de erro
+* ou null quando válido. Não considera lógica condicional.
+*/
+function validateFieldClient(field, value) {
+	if (field.type === "clone" || field.type === "repeater" || field.type === "group" || field.type === "flexible_content") return null;
+	const config = field.config ?? {};
+	const errors = [];
+	checkRequired(value, field.required, field.label, errors);
+	switch (field.type) {
+		case "text":
+		case "textarea":
+		case "password":
+			validateTextLike(value, config, field.label, errors);
+			break;
+		case "email":
+			validateEmail(value, field.label, errors);
+			break;
+		case "url":
+		case "oembed":
+			validateUrl(value, field.label, errors);
+			break;
+		case "number":
+		case "range":
+			validateNumber(value, config, field.label, errors);
+			break;
+		case "wysiwyg":
+			validateTextLike(value, config, field.label, errors);
+			break;
+		case "select":
+			validateSelect(value, config, field.label, errors);
+			break;
+		case "checkbox":
+			validateCheckbox(value, config, field.label, errors);
+			break;
+		case "radio":
+			validateRadio(value, config, field.label, errors);
+			break;
+		case "true_false":
+			validateTrueFalse(value, field.label, errors);
+			break;
+		case "image":
+			validateImage(value, config, field.label, errors);
+			break;
+		case "file":
+			validateFile(value, config, field.label, errors);
+			break;
+		case "gallery":
+			validateGallery(value, config, field.label, errors);
+			break;
+		case "link":
+			validateLink(value, field.label, errors);
+			break;
+		case "page_link":
+		case "post_object":
+		case "relationship":
+		case "taxonomy":
+		case "user":
+			validateRelationshipIds(value, config, field.label, errors);
+			break;
+		case "google_map":
+			validateGoogleMap(value, field.label, errors);
+			break;
+		case "color_picker": validateColorPicker(value, config, field.label, errors);
+	}
+	return errors[0]?.message ?? null;
+}
+//#endregion
+//#region ../../packages/validation/dist/clone.js
+/**
+* Expande campos do tipo `clone` nas definições alvo.
+*
+* - `display: 'seamless'` (default): os campos referenciados entram
+*   diretamente na lista, com os mesmos nomes (valores "inline").
+* - `display: 'group'`: os campos viram subcampos de um pseudo-group com o
+*   nome do clone, e os nomes internos recebem o prefixo `{clone}_`
+*   (valores aninhados em data[clone.name]).
+*
+* Referências inexistentes são ignoradas; clones de clones não são
+* resolvidos recursivamente (profundidade 1, como o modo básico do ACF).
+*/
 function expandCloneFields(fields) {
-	return fields;
+	const byName = /* @__PURE__ */ new Map();
+	for (const field of fields) byName.set(field.name, field);
+	const result = [];
+	const emittedNames = /* @__PURE__ */ new Set();
+	const emit = (field) => {
+		if (emittedNames.has(field.name)) return;
+		emittedNames.add(field.name);
+		result.push(field);
+	};
+	for (const field of fields) {
+		if (field.type !== "clone") {
+			emit(field);
+			continue;
+		}
+		const config = field.config ?? {};
+		const display = config["display"] ?? "seamless";
+		const targets = config["clone"] ?? [];
+		const resolved = [];
+		for (const targetName of targets) {
+			const target = byName.get(targetName);
+			if (!target || target.type === "clone") continue;
+			resolved.push(target);
+		}
+		if (resolved.length === 0) continue;
+		if (display === "group") {
+			emit({
+				...field,
+				type: "group",
+				name: field.name,
+				label: field.label,
+				required: false,
+				conditionalLogic: void 0,
+				subFields: resolved.map((target) => ({
+					...target,
+					name: `${field.name}_${target.name}`
+				}))
+			});
+			continue;
+		}
+		for (const target of resolved) emit(target);
+	}
+	return result;
 }
-require_semver();
 //#endregion
 //#region src/components/content/RelationshipPicker.tsx
 var _tmpl$$3 = [
@@ -59,36 +555,36 @@ function RelationshipPicker(props) {
 		if (Array.isArray(value)) return value.map(String);
 		return value ? [String(value)] : [];
 	});
-	return ssr(_tmpl$5$3, ssrHydrationKey(), escape(createComponent(Show$1, {
+	return ssr(_tmpl$5$3, ssrHydrationKey(), escape(createComponent(Show2, {
 		get when() {
 			return selected().length > 0 || selectedIds().length > 0;
 		},
 		get children() {
-			return ssr(_tmpl$$3, ssrHydrationKey(), escape(createComponent(For$1, {
+			return ssr(_tmpl$$3, ssrHydrationKey(), escape(createComponent(For2, {
 				get each() {
 					return selected();
 				},
 				children: (entry) => ssr(_tmpl$6$2, ssrHydrationKey(), escape(entry.title))
 			})));
 		}
-	})), ssrAttribute("placeholder", escape(props.placeholder ?? "Buscar conteúdo...", true), false) + ssrAttribute("value", escape(query(), true), false), escape(createComponent(Show$1, {
+	})), ssrAttribute("placeholder", escape(props.placeholder ?? "Buscar conteúdo...", true), false) + ssrAttribute("value", escape(query(), true), false), escape(createComponent(Show2, {
 		get when() {
 			return memo(() => !!open())() && (loading() || results().length > 0);
 		},
 		get children() {
-			return ssr(_tmpl$4$3, ssrHydrationKey(), escape(createComponent(Show$1, {
+			return ssr(_tmpl$4$3, ssrHydrationKey(), escape(createComponent(Show2, {
 				get when() {
 					return loading();
 				},
 				get children() {
 					return ssr(_tmpl$2$3, ssrHydrationKey());
 				}
-			})), escape(createComponent(For$1, {
+			})), escape(createComponent(For2, {
 				get each() {
 					return results();
 				},
 				children: (option) => ssr(_tmpl$7$2, ssrHydrationKey(), escape(option.title), escape(option.type))
-			})), escape(createComponent(Show$1, {
+			})), escape(createComponent(Show2, {
 				get when() {
 					return memo(() => !!!loading())() && results().length === 0;
 				},
@@ -318,10 +814,10 @@ function FieldRenderer(props) {
 				}
 			})), escape(createComponent(Show, {
 				get when() {
-					return memo(() => !!validationError())() && !validationError()?.valid;
+					return validationError();
 				},
 				get children() {
-					return ssr(_tmpl$3$2, ssrHydrationKey(), escape(validationError()?.errors.join(", ")));
+					return ssr(_tmpl$3$2, ssrHydrationKey(), escape(validationError()));
 				}
 			})));
 		}