@phtngyn/cms 0.2.0-beta.8 → 0.3.0

package/src/Forms.js

@@ -1,13 +1,348 @@
-import { validateFormCapabilities } from "./internal/form-capabilities.js";
-import { useCmsForm } from "./runtime/forms/useCmsForm.js";
-
+import { r as FormCapabilities, s as FormResult, u as formAnswerKey } from "./contracts-rprW3ZOB.js";
+import { t as validateFormValues } from "./answers-DcTg0Xv2.js";
+import { a as encodePreviewSource, r as StudioFocusMessage } from "./PreviewFocus-C_EelZO5.js";
+import { t as previewContextKey } from "./previewContext-dt3ZUh-w.js";
+import { Result, Schema } from "effect";
+import { computed, getCurrentInstance, inject, readonly, ref, shallowRef, toValue, useId, watch } from "vue";
+import { tryOnScopeDispose, useEventListener } from "@vueuse/core";
+//#region src/runtime/forms/internal/values.ts
+function normalizeFormValue(field, input) {
+	if (field.type === "checkbox") return input === true;
+	if (field.type === "number") {
+		if (input === "" || input == null) return null;
+		const value = Schema.is(Schema.Finite)(input) || Schema.is(Schema.String)(input) ? Number(input) : NaN;
+		if (Number.isFinite(value)) return value;
+		return Schema.is(Schema.String)(input) ? input : null;
+	}
+	return Schema.is(Schema.String)(input) ? input : "";
+}
+function emptyFormValue(field) {
+	if (field.type === "checkbox") return false;
+	if (field.type === "number") return null;
+	return "";
+}
+//#endregion
+//#region src/runtime/forms/internal/controls.ts
+/** Keeps field normalization, validation feedback, and DOM bindings in one place. */
+function useFormControls({ fields, currentStep, values, errors, touched, previewAttrs }) {
+	const fieldIdPrefix = getCurrentInstance() ? useId() : "cms-form";
+	const controls = /* @__PURE__ */ new Map();
+	function control(input) {
+		const fieldId = Schema.is(Schema.String)(input) ? input : input.id;
+		const existing = controls.get(fieldId);
+		if (existing) return existing;
+		if (!fields.value.some((candidate) => candidate.id === fieldId)) throw new Error(`Unknown CMS form field ${fieldId}.`);
+		const current = computed(() => {
+			const candidate = fields.value.find((field) => field.id === fieldId);
+			if (!candidate) throw new Error(`CMS form field ${fieldId} no longer exists.`);
+			return candidate;
+		});
+		const answerKey = computed(() => formAnswerKey(current.value));
+		const controlId = `${fieldIdPrefix}-${encodeURIComponent(fieldId)}`;
+		const helpId = `${controlId}-help`;
+		const errorId = `${controlId}-error`;
+		const helpAttrs = { id: helpId };
+		const errorAttrs = {
+			id: errorId,
+			role: "alert"
+		};
+		const refreshError = () => {
+			const issue = validateFormValues([current.value], values.value)[answerKey.value];
+			const nextErrors = { ...errors.value };
+			if (issue) nextErrors[answerKey.value] = issue;
+			else delete nextErrors[answerKey.value];
+			errors.value = nextErrors;
+		};
+		const value = computed({
+			get: () => values.value[answerKey.value] ?? emptyFormValue(current.value),
+			set: (next) => {
+				values.value[answerKey.value] = normalizeFormValue(current.value, next);
+				if (touched.value.has(fieldId) || errors.value[answerKey.value]) refreshError();
+			}
+		});
+		const dirty = computed(() => values.value[answerKey.value] !== emptyFormValue(current.value));
+		const touchedState = computed(() => touched.value.has(fieldId));
+		const valid = computed(() => !errors.value[answerKey.value] && validateFormValues([current.value], values.value)[answerKey.value] === void 0);
+		const error = computed(() => errors.value[answerKey.value]);
+		const attrs = computed(() => {
+			const fieldError = errors.value[answerKey.value];
+			const describedBy = [current.value.help ? helpId : void 0, fieldError ? errorId : void 0].filter((part) => part !== void 0).join(" ");
+			return {
+				id: controlId,
+				name: answerKey.value,
+				required: current.value.required === true,
+				"aria-invalid": fieldError ? "true" : void 0,
+				"aria-describedby": describedBy || void 0
+			};
+		});
+		const state = {
+			get field() {
+				return current.value;
+			},
+			get value() {
+				return value.value;
+			},
+			set value(next) {
+				value.value = next;
+			},
+			get dirty() {
+				return dirty.value;
+			},
+			get touched() {
+				return touchedState.value;
+			},
+			get valid() {
+				return valid.value;
+			},
+			get error() {
+				return error.value;
+			},
+			get attrs() {
+				return attrs.value;
+			},
+			get previewAttrs() {
+				return previewAttrs(current.value);
+			},
+			helpAttrs,
+			errorAttrs,
+			touch: () => {
+				touched.value = /* @__PURE__ */ new Set([...touched.value, fieldId]);
+				refreshError();
+			}
+		};
+		controls.set(fieldId, state);
+		return state;
+	}
+	const visibleControls = computed(() => currentStep.value?.fields.map((entry) => control(entry)) ?? []);
+	const invalidControls = computed(() => fields.value.map((entry) => control(entry)).filter((entry) => !entry.valid));
+	return {
+		control,
+		visibleControls,
+		invalidControls,
+		firstInvalidControlId: computed(() => invalidControls.value[0]?.attrs.id)
+	};
+}
+//#endregion
+//#region src/runtime/forms/internal/preview.ts
+function formPreviewTarget(definition, step, field) {
+	return {
+		kind: "blockField",
+		blockId: definition.blockId,
+		path: [
+			{
+				kind: "field",
+				name: "steps"
+			},
+			{
+				kind: "item",
+				id: step.id
+			},
+			...field ? [{
+				kind: "field",
+				name: "fields"
+			}, {
+				kind: "item",
+				id: field.id
+			}] : []
+		]
+	};
+}
+/** Select mode reveals authored questions without running visitor validation. */
+function formPreviewStep(definition, target) {
+	if (!definition.preview || target.kind !== "blockField" || target.blockId !== definition.blockId || target.path[0]?.kind !== "field" || target.path[0].name !== "steps" || target.path[1]?.kind !== "item") return -1;
+	const stepId = target.path[1].id;
+	const index = definition.steps.findIndex((step) => step.id === stepId);
+	if (index < 0) return -1;
+	if (target.path.length === 2) return index;
+	if (target.path[2]?.kind !== "field" || target.path[2].name !== "fields" || target.path[3]?.kind !== "item") return -1;
+	const fieldId = target.path[3].id;
+	return definition.steps[index]?.fields.some((field) => field.id === fieldId) ? index : -1;
+}
+function useFormPreview(definition, stepIndex, isSuccess) {
+	const context = getCurrentInstance() ? inject(previewContextKey, null) : null;
+	if (typeof window !== "undefined" && context) useEventListener(window, "message", (event) => {
+		if (!context.interactive.value || event.origin !== window.location.origin || event.source !== window.parent || !Schema.is(StudioFocusMessage)(event.data) || event.data.documentId !== definition.value.documentId) return;
+		const index = formPreviewStep(definition.value, event.data.target);
+		if (index < 0) return;
+		stepIndex.value = index;
+		isSuccess.value = false;
+	});
+	return (step, field) => definition.value.preview ? { "data-cms-source": encodePreviewSource({
+		documentId: definition.value.documentId,
+		target: formPreviewTarget(definition.value, step, field),
+		approximate: false
+	}) } : {};
+}
+//#endregion
+//#region src/runtime/forms/useCmsForm.ts
+const CMS_FORM_SUBMIT_PATH = "/_cms/api/forms/submit";
+/** Headless, per-instance form state. Definition changes preserve answers for unchanged field types. */
+function useCmsForm(input, options = {}) {
+	const definition = computed(() => toValue(input));
+	const steps = computed(() => definition.value.steps);
+	const fields = computed(() => steps.value.flatMap((step) => step.fields));
+	const values = ref({});
+	const errors = shallowRef({});
+	const stepIndex = shallowRef(0);
+	const currentStep = computed(() => steps.value[stepIndex.value]);
+	const isFirstStep = computed(() => stepIndex.value === 0);
+	const isLastStep = computed(() => stepIndex.value === steps.value.length - 1);
+	const submitting = shallowRef(false);
+	const isSuccess = shallowRef(false);
+	const isPreview = computed(() => definition.value.preview);
+	const submitError = shallowRef();
+	const touched = shallowRef(/* @__PURE__ */ new Set());
+	let controller;
+	let generation = 0;
+	let previousFields = /* @__PURE__ */ new Map();
+	const previewAttrs = useFormPreview(definition, stepIndex, isSuccess);
+	const stepPreviewAttrs = computed(() => currentStep.value ? previewAttrs(currentStep.value) : {});
+	const { control, visibleControls, invalidControls, firstInvalidControlId } = useFormControls({
+		fields,
+		currentStep,
+		values,
+		errors,
+		touched,
+		previewAttrs: (field) => {
+			const step = steps.value.find((item) => item.fields.some((item) => item.id === field.id));
+			return step ? previewAttrs(step, field) : {};
+		}
+	});
+	const stop = watch(definition, (next, before) => {
+		generation++;
+		controller?.abort();
+		submitting.value = false;
+		const sameForm = before?.documentId === next.documentId && before.blockId === next.blockId && before.name === next.name;
+		values.value = Object.fromEntries(next.steps.flatMap((step) => step.fields).map((field) => [formAnswerKey(field), sameForm && previousFields.get(field.id)?.type === field.type ? values.value[previousFields.get(field.id)?.answerKey ?? field.id] ?? null : field.type === "checkbox" ? false : field.type === "number" ? null : ""]));
+		previousFields = new Map(next.steps.flatMap((step) => step.fields).map((field) => [field.id, field]));
+		stepIndex.value = Math.max(0, next.steps.findIndex((step) => step.id === before?.steps[stepIndex.value]?.id));
+		errors.value = {};
+		touched.value = /* @__PURE__ */ new Set();
+		submitError.value = void 0;
+		isSuccess.value = false;
+	}, {
+		immediate: true,
+		deep: true,
+		flush: "sync"
+	});
+	function validate() {
+		touched.value = new Set(fields.value.map((field) => field.id));
+		errors.value = validateFormValues(fields.value, values.value);
+		return Object.keys(errors.value).length === 0;
+	}
+	function next() {
+		if (submitting.value || isLastStep.value) return false;
+		const stepFields = currentStep.value?.fields ?? [];
+		touched.value = /* @__PURE__ */ new Set([...touched.value, ...stepFields.map((field) => field.id)]);
+		const issues = validateFormValues(stepFields, values.value);
+		errors.value = {
+			...Object.fromEntries(Object.entries(errors.value).filter(([id]) => !stepFields.some((field) => formAnswerKey(field) === id))),
+			...issues
+		};
+		if (Object.keys(issues).length) return false;
+		stepIndex.value++;
+		return true;
+	}
+	function previous() {
+		if (!submitting.value && !isFirstStep.value) stepIndex.value--;
+	}
+	function reset() {
+		generation++;
+		controller?.abort();
+		submitting.value = false;
+		values.value = Object.fromEntries(fields.value.map((field) => [formAnswerKey(field), emptyFormValue(field)]));
+		errors.value = {};
+		touched.value = /* @__PURE__ */ new Set();
+		submitError.value = void 0;
+		isSuccess.value = false;
+		stepIndex.value = 0;
+	}
+	async function submit() {
+		if (submitting.value || isSuccess.value) return false;
+		submitError.value = void 0;
+		if (!validate()) {
+			stepIndex.value = Math.max(0, steps.value.findIndex((step) => step.fields.some((field) => errors.value[formAnswerKey(field)])));
+			return false;
+		}
+		if (isPreview.value) {
+			isSuccess.value = true;
+			return true;
+		}
+		const currentGeneration = ++generation;
+		controller = new AbortController();
+		submitting.value = true;
+		try {
+			const { documentId, blockId, revision, locale } = definition.value;
+			const result = await (options.submit ?? send)({
+				documentId,
+				blockId,
+				revision,
+				locale,
+				values: { ...values.value }
+			}, controller.signal);
+			if (generation !== currentGeneration) return false;
+			errors.value = result.status === "invalid" ? { ...result.errors } : {};
+			isSuccess.value = result.status === "accepted";
+			if (result.status === "invalid") stepIndex.value = Math.max(0, steps.value.findIndex((step) => step.fields.some((field) => errors.value[formAnswerKey(field)])));
+			if (result.status !== "accepted" && result.status !== "invalid") submitError.value = result.status;
+			return isSuccess.value;
+		} catch {
+			if (generation === currentGeneration) submitError.value = "failed";
+			return false;
+		} finally {
+			if (generation === currentGeneration) submitting.value = false;
+		}
+	}
+	tryOnScopeDispose(() => {
+		generation++;
+		controller?.abort();
+		stop();
+	});
+	const canSubmit = computed(() => !submitting.value && !isSuccess.value && invalidControls.value.length === 0);
+	return {
+		fields,
+		steps,
+		values,
+		errors: readonly(errors),
+		currentStep,
+		stepIndex: readonly(stepIndex),
+		isFirstStep,
+		isLastStep,
+		submitting: readonly(submitting),
+		isSuccess: readonly(isSuccess),
+		isPreview,
+		submitError: readonly(submitError),
+		canSubmit,
+		visibleControls,
+		invalidControls,
+		firstInvalidControlId,
+		control,
+		stepPreviewAttrs,
+		next,
+		previous,
+		validate,
+		submit,
+		reset
+	};
+}
+async function send(submission, signal) {
+	const response = await fetch(CMS_FORM_SUBMIT_PATH, {
+		method: "POST",
+		headers: { "content-type": "application/json" },
+		body: JSON.stringify(submission),
+		signal
+	});
+	if (!response.ok) throw new Error("Submission failed.");
+	return Result.getOrThrow(Schema.decodeUnknownResult(FormResult)(await response.json()));
+}
+//#endregion
 //#region src/Forms.ts
-/** Register this definition under the kebab-case name of your Vue form renderer. */
+/** Declare the question types and rules Studio may author for this block. */
 function defineCmsForm(definition) {
-	validateFormCapabilities(definition);
+	Schema.decodeSync(FormCapabilities)(definition);
+	if (new Set(definition.fieldTypes).size !== definition.fieldTypes.length) throw new Error("Form question types must be unique.");
+	if (new Set(definition.rules).size !== definition.rules.length) throw new Error("Form rules must be unique.");
 	return definition;
 }
-
 //#endregion
 export { defineCmsForm, useCmsForm };
-//# sourceMappingURL=Forms.js.map

package/src/I18n-Ckf9h0rC.js

@@ -0,0 +1,154 @@
+//#region ../model/src/I18n.ts
+/** Canonical language/script/region identity, excluding Unicode and private-use extensions. */
+function canonicalLocale(locale) {
+	try {
+		return new Intl.Locale(locale).baseName;
+	} catch {
+		return;
+	}
+}
+/** A display name in an explicitly selected language, or the code when it cannot be named. */
+function languageName(locale, displayLocale = locale) {
+	try {
+		return new Intl.DisplayNames(displayLocale, { type: "language" }).of(locale) ?? locale;
+	} catch {
+		return locale;
+	}
+}
+const rightToLeftScripts = /* @__PURE__ */ new Set([
+	"Adlm",
+	"Arab",
+	"Armi",
+	"Avst",
+	"Chrs",
+	"Cprt",
+	"Elym",
+	"Gara",
+	"Hatr",
+	"Hebr",
+	"Hung",
+	"Khar",
+	"Lydi",
+	"Mand",
+	"Mani",
+	"Mend",
+	"Merc",
+	"Mero",
+	"Narb",
+	"Nbat",
+	"Nkoo",
+	"Orkh",
+	"Ougr",
+	"Palm",
+	"Phli",
+	"Phlp",
+	"Phnx",
+	"Prti",
+	"Rohg",
+	"Samr",
+	"Sarb",
+	"Sidt",
+	"Sogd",
+	"Sogo",
+	"Syrc",
+	"Thaa",
+	"Yezi"
+]);
+/** Derives text direction from Intl's likely script, without reading browser or application state. */
+function localeDirection(locale) {
+	try {
+		const script = new Intl.Locale(locale).maximize().script;
+		return script && rightToLeftScripts.has(script) ? "rtl" : "ltr";
+	} catch {
+		return "ltr";
+	}
+}
+/**
+* Matches preferred BCP 47 languages in order, using exact and progressively
+* broader language ranges. Returns the caller's original supported locale code.
+*/
+function matchLocale(preferred, supported, fallback) {
+	const available = supported.map((locale) => {
+		const canonical = canonicalLocale(locale);
+		if (!canonical) throw new RangeError(`Invalid supported locale "${locale}".`);
+		return {
+			locale,
+			canonical
+		};
+	});
+	const fallbackLocale = canonicalLocale(fallback);
+	const fallbackMatch = available.find((item) => item.canonical === fallbackLocale);
+	if (!fallbackMatch) throw new RangeError(`Fallback locale "${fallback}" must be supported.`);
+	for (const preference of preferred) {
+		let range = canonicalLocale(preference);
+		while (range) {
+			const match = available.find((item) => item.canonical === range) ?? available.find((item) => item.canonical.startsWith(`${range}-`));
+			if (match) return match.locale;
+			const separator = range.lastIndexOf("-");
+			range = separator === -1 ? void 0 : range.slice(0, separator);
+		}
+	}
+	return fallbackMatch.locale;
+}
+function parameterNames(message) {
+	const texts = typeof message === "string" ? [message] : Object.values(message);
+	const names = new Set(texts.flatMap((text) => [...text.matchAll(/\{([^{}]+)\}/gu)].map((match) => match[1] ?? "")));
+	if (typeof message !== "string") names.add("count");
+	return names;
+}
+/**
+* Creates a stateless translator. The caller supplies locale for every message,
+* so separate applications and concurrent server requests cannot share language state.
+* Numeric values use the selected locale's number format; strings stay unchanged.
+*/
+function createTranslator(base, options) {
+	const fallbackLocale = canonicalLocale(options.fallbackLocale);
+	if (!fallbackLocale) throw new RangeError(`Invalid fallback locale "${options.fallbackLocale}".`);
+	const catalogs = /* @__PURE__ */ new Map();
+	for (const [locale, catalog] of Object.entries(options.translations ?? {})) {
+		const canonical = canonicalLocale(locale);
+		if (!canonical) throw new RangeError(`Invalid translation locale "${locale}".`);
+		if (canonical === fallbackLocale || catalogs.has(canonical)) throw new RangeError(`Duplicate message locale "${locale}".`);
+		for (const [key, message] of Object.entries(catalog)) {
+			if (message === void 0) continue;
+			const original = base[key];
+			if (original === void 0) throw new RangeError(`Unknown translated message "${key}".`);
+			const expected = parameterNames(original);
+			const actual = parameterNames(message);
+			if (expected.size !== actual.size || [...expected].some((name) => !actual.has(name))) throw new RangeError(`Translated message "${key}" in "${locale}" must keep the base named values.`);
+		}
+		catalogs.set(canonical, catalog);
+	}
+	const supported = [fallbackLocale, ...catalogs.keys()];
+	return (locale, key, ...args) => {
+		const selectedLocale = locale === fallbackLocale || catalogs.has(locale) ? locale : matchLocale([locale], supported, fallbackLocale);
+		const translated = catalogs.get(selectedLocale)?.[key];
+		const message = translated ?? base[key];
+		if (message === void 0) throw new RangeError(`Unknown message "${key}".`);
+		const values = args[0];
+		let text;
+		if (typeof message === "string") text = message;
+		else {
+			const count = values?.count;
+			if (typeof count !== "number" || !Number.isFinite(count)) throw new TypeError(`Plural message "${key}" needs a finite numeric count.`);
+			const messageLocale = translated === void 0 ? fallbackLocale : selectedLocale;
+			text = message[new Intl.PluralRules(messageLocale).select(count)] ?? message.other;
+		}
+		return text.replace(/\{([^{}]+)\}/gu, (_match, name) => {
+			const value = values?.[name];
+			if (value === void 0) throw new TypeError(`Message "${key}" needs a value for "${name}".`);
+			return typeof value === "number" ? formatNumber(selectedLocale, value) : value;
+		});
+	};
+}
+function formatNumber(locale, value, options) {
+	return new Intl.NumberFormat(locale, options).format(value);
+}
+function formatDate(locale, value, options) {
+	return new Intl.DateTimeFormat(locale, options).format(value);
+}
+function formatRelativeTime(locale, value, unit, options) {
+	return new Intl.RelativeTimeFormat(locale, options).format(value, unit);
+}
+//#endregion
+export { formatRelativeTime as a, matchLocale as c, formatNumber as i, createTranslator as n, languageName as o, formatDate as r, localeDirection as s, canonicalLocale as t };

package/src/I18n.d.ts

@@ -1,2 +1,45 @@
-import { a as CmsMessageParameters, i as CmsMessageKey, n as CmsI18nRegistry, o as CmsMessages, r as CmsLocale, t as CmsI18nOptions } from "./I18n-wxswIRyY.js";
-export { CmsI18nOptions, CmsI18nRegistry, CmsLocale, CmsMessageKey, CmsMessageParameters, CmsMessages };
+//#region ../model/src/I18n.d.ts
+/** A message may select an Intl plural category. Every plural supplies an `other` form. */
+type PluralMessage = Readonly<Partial<Record<Intl.LDMLPluralRule, string>> & {
+  other: string;
+}>;
+type Message = string | PluralMessage;
+/** Flat, stable keys keep message identity independent from the displayed language. */
+type MessageCatalog = Readonly<Record<string, Message>>;
+type MessageKey<Catalog extends MessageCatalog> = Extract<keyof Catalog, string>;
+type ParameterNames<Text extends string> = string extends Text ? never : Text extends `${string}{${infer Name}}${infer Rest}` ? Name | ParameterNames<Rest> : never;
+type MessageText<Value extends Message> = Value extends string ? Value : Extract<Value[keyof Value], string>;
+/** The base message defines named values. A plural always needs a numeric count. */
+type MessageParameters<Value extends Message> = { readonly [Name in ParameterNames<MessageText<Value>> | (Value extends PluralMessage ? 'count' : never)]: Name extends 'count' ? number : string | number; };
+type MessageArguments<Value extends Message> = keyof MessageParameters<Value> extends never ? [] : [values: MessageParameters<Value>];
+/** Missing translated keys use the complete base message. */
+type TranslationCatalog<Base extends MessageCatalog> = { readonly [Key in keyof Base]?: Base[Key] extends string ? string : PluralMessage; };
+interface Translator<Catalog extends MessageCatalog> {
+  <Key extends MessageKey<Catalog>>(locale: string, key: Key, ...args: MessageArguments<Catalog[Key]>): string;
+}
+interface TranslatorOptions<Base extends MessageCatalog> {
+  readonly fallbackLocale: string;
+  readonly translations?: Readonly<Record<string, TranslationCatalog<Base>>>;
+}
+/** Canonical language/script/region identity, excluding Unicode and private-use extensions. */
+export declare function canonicalLocale(locale: string): string | undefined;
+/** A display name in an explicitly selected language, or the code when it cannot be named. */
+export declare function languageName(locale: string, displayLocale?: string): string;
+/** Derives text direction from Intl's likely script, without reading browser or application state. */
+export declare function localeDirection(locale: string): 'ltr' | 'rtl';
+/**
+ * Matches preferred BCP 47 languages in order, using exact and progressively
+ * broader language ranges. Returns the caller's original supported locale code.
+ */
+export declare function matchLocale<const Supported extends readonly string[]>(preferred: readonly string[], supported: Supported, fallback: NoInfer<Supported[number]>): Supported[number];
+/**
+ * Creates a stateless translator. The caller supplies locale for every message,
+ * so separate applications and concurrent server requests cannot share language state.
+ * Numeric values use the selected locale's number format; strings stay unchanged.
+ */
+export declare function createTranslator<const Base extends MessageCatalog>(base: Base, options: TranslatorOptions<NoInfer<Base>>): Translator<Base>;
+export declare function formatNumber(locale: string, value: number | bigint, options?: Intl.NumberFormatOptions): string;
+export declare function formatDate(locale: string, value: Date | number, options?: Intl.DateTimeFormatOptions): string;
+export declare function formatRelativeTime(locale: string, value: number, unit: Intl.RelativeTimeFormatUnit, options?: Intl.RelativeTimeFormatOptions): string;
+//#endregion
+export type { Message, MessageArguments, MessageCatalog, MessageKey, MessageParameters, PluralMessage, TranslationCatalog, Translator, TranslatorOptions };

package/src/I18n.js

@@ -1 +1,2 @@
-export {  };
+import { a as formatRelativeTime, c as matchLocale, i as formatNumber, n as createTranslator, o as languageName, r as formatDate, s as localeDirection, t as canonicalLocale } from "./I18n-Ckf9h0rC.js";
+export { canonicalLocale, createTranslator, formatDate, formatNumber, formatRelativeTime, languageName, localeDirection, matchLocale };

package/src/Image-CJWPLnhP.js

@@ -0,0 +1,110 @@
+import { i as MediaId } from "./Media-DSyvd14o.js";
+import { Schema } from "effect";
+//#region ../model/src/Image.ts
+const ImagePosition = Schema.Int.check(Schema.isBetween({
+	minimum: 0,
+	maximum: 100
+}));
+const ImageZoom = Schema.Finite.check(Schema.isBetween({
+	minimum: 1,
+	maximum: 3
+}));
+const ImagePlacement = Schema.Struct({
+	focalX: Schema.optionalKey(ImagePosition),
+	focalY: Schema.optionalKey(ImagePosition),
+	zoom: Schema.optionalKey(ImageZoom)
+});
+/** A framed image authored in a collection field or block property. */
+const AuthoredImage = Schema.Struct({
+	kind: Schema.Literal("image"),
+	mediaId: Schema.String.check(Schema.isUUID()),
+	alt: Schema.optionalKey(Schema.String),
+	frame: Schema.optionalKey(Schema.Literals(["square", "wide"])),
+	...ImagePlacement.fields
+});
+function imageAspectRatio(frame) {
+	return frame === "square" ? 1 : 16 / 9;
+}
+/** CSS placement shared by Studio's framed preview and published images. */
+function imagePlacementStyle(placement) {
+	const x = placement.focalX ?? 50;
+	const y = placement.focalY ?? 50;
+	const zoom = placement.zoom ?? 1;
+	return {
+		objectFit: "cover",
+		objectPosition: `${x}% ${y}%`,
+		transform: `scale(${zoom}) translate(${(50 - x) * (zoom - 1) / zoom}%, ${(50 - y) * (zoom - 1) / zoom}%)`
+	};
+}
+const ImageDimension = Schema.Int.check(Schema.isBetween({
+	minimum: 1,
+	maximum: 4096
+}));
+const ImageQuality = Schema.Int.check(Schema.isBetween({
+	minimum: 1,
+	maximum: 100
+}));
+const ImageFit = Schema.Literals([
+	"contain",
+	"cover",
+	"fill",
+	"inside",
+	"outside"
+]);
+const ImageFormat = Schema.Literals([
+	"avif",
+	"gif",
+	"jpeg",
+	"png",
+	"webp"
+]);
+const ImageModifiers = Schema.Struct({
+	width: Schema.optionalKey(ImageDimension),
+	height: Schema.optionalKey(ImageDimension),
+	fit: Schema.optionalKey(ImageFit),
+	format: Schema.optionalKey(ImageFormat),
+	quality: Schema.optionalKey(ImageQuality)
+});
+function imagePath(id, modifiers = {}) {
+	const checked = Schema.decodeSync(ImageModifiers)(modifiers);
+	return `/_cms/image/${[
+		checked.width === void 0 ? void 0 : `w_${checked.width}`,
+		checked.height === void 0 ? void 0 : `h_${checked.height}`,
+		checked.fit === void 0 ? void 0 : `fit_${checked.fit}`,
+		checked.format === void 0 ? void 0 : `f_${checked.format}`,
+		checked.quality === void 0 ? void 0 : `q_${checked.quality}`
+	].filter((operation) => operation !== void 0).join(",") || "_"}/${id}`;
+}
+function parseImagePath(pathname) {
+	const match = /^\/_cms\/image\/([^/]+)\/([^/]+)$/u.exec(pathname);
+	const operationPath = match?.[1];
+	const id = match?.[2];
+	if (!operationPath || !Schema.is(MediaId)(id)) return void 0;
+	const raw = {};
+	if (operationPath !== "_") for (const operation of operationPath.split(",")) {
+		const part = /^(w|h|fit|f|q)_([a-z0-9]+)$/u.exec(operation);
+		const name = part?.[1];
+		const value = part?.[2];
+		if (!name || !value) return void 0;
+		const key = {
+			w: "width",
+			h: "height",
+			fit: "fit",
+			f: "format",
+			q: "quality"
+		}[name];
+		if (!key || Object.hasOwn(raw, key)) return void 0;
+		raw[key] = [
+			"w",
+			"h",
+			"q"
+		].includes(name) ? Number(value) : value;
+	}
+	if (!Schema.is(ImageModifiers)(raw)) return void 0;
+	return {
+		id,
+		modifiers: raw
+	};
+}
+//#endregion
+export { imagePath as a, imageAspectRatio as i, ImagePosition as n, imagePlacementStyle as o, ImageZoom as r, parseImagePath as s, AuthoredImage as t };