@valfuse-node/react 0.2.0

package/dist/index.mjs

@@ -0,0 +1,957 @@
+// src/hooks/use-valfuse-form.ts
+import { useMemo as useMemo3 } from "react";
+
+// src/hooks/sub-hooks/use-form-core.ts
+import { useState, useRef } from "react";
+function useFormCore(props) {
+  const { schema, defaultValues, mode = "onSubmit" } = props;
+  const [values, setValues] = useState(
+    () => ({ ...defaultValues })
+  );
+  const [errors, setErrorsState] = useState({});
+  const [isSubmitting, setIsSubmitting] = useState(false);
+  const [isSubmitted, setIsSubmitted] = useState(false);
+  const [isSubmitSuccessful, setIsSubmitSuccessful] = useState(false);
+  const [submitCount, setSubmitCount] = useState(0);
+  const [touchedFields, setTouchedFields] = useState(
+    () => /* @__PURE__ */ new Set()
+  );
+  const valuesRef = useRef(values);
+  valuesRef.current = values;
+  const errorsRef = useRef(errors);
+  errorsRef.current = errors;
+  const touchedFieldsRef = useRef(touchedFields);
+  touchedFieldsRef.current = touchedFields;
+  const modeRef = useRef(mode);
+  modeRef.current = mode;
+  const schemaRef = useRef(schema);
+  schemaRef.current = schema;
+  const watchSubscribersRef = useRef(/* @__PURE__ */ new Set());
+  const lastChangedFieldRef = useRef(void 0);
+  return {
+    schema,
+    defaultValues,
+    mode,
+    values,
+    errors,
+    isSubmitting,
+    isSubmitted,
+    isSubmitSuccessful,
+    submitCount,
+    touchedFields,
+    setValues,
+    setErrorsState,
+    setTouchedFields,
+    setIsSubmitting,
+    setIsSubmitted,
+    setIsSubmitSuccessful,
+    setSubmitCount,
+    refs: {
+      valuesRef,
+      errorsRef,
+      touchedFieldsRef,
+      modeRef,
+      schemaRef,
+      lastChangedFieldRef,
+      watchSubscribersRef
+    }
+  };
+}
+
+// src/hooks/sub-hooks/use-field-validation.ts
+import { useCallback } from "react";
+import { validateSchema } from "@valfuse-node/form";
+
+// src/helpers/validation-mode.ts
+function shouldValidateOnChange(mode, isTouched) {
+  return mode === "onChange" || mode === "all" || mode === "onTouched" && isTouched;
+}
+function shouldValidateOnBlur(mode) {
+  return mode === "onBlur" || mode === "all" || mode === "onTouched";
+}
+
+// src/helpers/field-error.ts
+function buildFieldError(fieldErrors, field) {
+  const err = fieldErrors[field];
+  if (!err) return null;
+  return {
+    message: err.message,
+    type: err.type ?? "validation",
+    ...err.code !== void 0 && { code: err.code }
+  };
+}
+function mapToFieldErrors(schemaErrors) {
+  return Object.fromEntries(
+    Object.entries(schemaErrors).map(([key, err]) => {
+      const fieldError = {
+        message: err.message,
+        type: err.type ?? "validation",
+        ...err.code !== void 0 && { code: err.code },
+        ...err.metadata !== void 0 && { metadata: err.metadata }
+      };
+      return [key, fieldError];
+    })
+  );
+}
+
+// src/hooks/sub-hooks/use-field-validation.ts
+function useFieldValidation({
+  schema,
+  setErrorsState
+}) {
+  const validateField = useCallback(
+    (name, currentValues) => {
+      if (!schema[name]) return;
+      const raw = validateSchema({ [name]: schema[name] }, currentValues);
+      const error = buildFieldError(raw, name);
+      setErrorsState((prev) => {
+        if (!error && !(name in prev)) return prev;
+        const prevError = prev[name];
+        if (error && prevError && error.message === prevError.message && error.type === prevError.type && error.code === prevError.code) return prev;
+        const next = { ...prev };
+        if (error) {
+          next[name] = error;
+        } else {
+          delete next[name];
+        }
+        return next;
+      });
+    },
+    [schema, setErrorsState]
+  );
+  const clearStaleFieldError = useCallback(
+    (name) => {
+      setErrorsState((prev) => {
+        if (!(name in prev)) return prev;
+        const next = { ...prev };
+        delete next[name];
+        return next;
+      });
+    },
+    [setErrorsState]
+  );
+  return { validateField, clearStaleFieldError };
+}
+
+// src/hooks/sub-hooks/use-form-registration.ts
+import { useCallback as useCallback2, useMemo } from "react";
+function useFormRegistration({
+  core,
+  validateField,
+  clearStaleFieldError
+}) {
+  const { values, refs, touchedFields, setValues, setTouchedFields } = core;
+  const valuesRef = refs.valuesRef;
+  const modeRef = refs.modeRef;
+  const schemaRef = refs.schemaRef;
+  const touchedFieldsRef = refs.touchedFieldsRef;
+  const lastChangedFieldRef = refs.lastChangedFieldRef;
+  const register = useCallback2(
+    (name) => ({
+      name,
+      value: valuesRef.current[name],
+      onChange: (e) => {
+        const rawValue = e.target.value;
+        const fieldTransform = schemaRef.current[name]?.transform;
+        const newValue = fieldTransform ? fieldTransform(rawValue) : rawValue;
+        const updated = { ...valuesRef.current, [name]: newValue };
+        lastChangedFieldRef.current = name;
+        setValues(updated);
+        if (shouldValidateOnChange(modeRef.current, touchedFieldsRef.current.has(name))) {
+          validateField(name, updated);
+        } else {
+          clearStaleFieldError(name);
+        }
+      },
+      onBlur: () => {
+        setTouchedFields((prev) => {
+          if (prev.has(name)) return prev;
+          const next = new Set(prev);
+          next.add(name);
+          return next;
+        });
+        if (shouldValidateOnBlur(modeRef.current)) {
+          const current = valuesRef.current;
+          const fieldTransform = schemaRef.current[name]?.transform;
+          const forValidation = fieldTransform ? { ...current, [name]: fieldTransform(current[name]) } : current;
+          validateField(name, forValidation);
+        }
+      }
+    }),
+    // mode/touchedFields/schema read via refs — only stable deps here.
+    [validateField, clearStaleFieldError]
+  );
+  const _updateField = useCallback2(
+    (name, value) => {
+      const fieldTransform = schemaRef.current[name]?.transform;
+      const transformedValue = fieldTransform ? fieldTransform(value) : value;
+      const updated = { ...valuesRef.current, [name]: transformedValue };
+      lastChangedFieldRef.current = name;
+      setValues(updated);
+      if (shouldValidateOnChange(modeRef.current, touchedFieldsRef.current.has(name))) {
+        validateField(name, updated);
+      } else {
+        clearStaleFieldError(name);
+      }
+    },
+    // schema/mode/touchedFields/values read via refs.
+    [validateField, clearStaleFieldError]
+  );
+  const _touchField = useCallback2(
+    (name) => {
+      setTouchedFields((prev) => {
+        if (prev.has(name)) return prev;
+        const next = new Set(prev);
+        next.add(name);
+        return next;
+      });
+      if (shouldValidateOnBlur(modeRef.current)) {
+        const current = valuesRef.current;
+        const fieldTransform = schemaRef.current[name]?.transform;
+        const forValidation = fieldTransform ? { ...current, [name]: fieldTransform(current[name]) } : current;
+        validateField(name, forValidation);
+      }
+    },
+    // schema/mode/values read via refs — only validateField is a dep.
+    [validateField]
+  );
+  const control = useMemo(
+    () => ({
+      _values: values,
+      _errors: core.errors,
+      _updateField,
+      _touchField,
+      _touchedFields: touchedFields
+    }),
+    [values, core.errors, touchedFields, _updateField, _touchField]
+  );
+  return { register, control, _updateField, _touchField };
+}
+
+// src/hooks/sub-hooks/use-form-watch.ts
+import { useCallback as useCallback3, useEffect } from "react";
+function useFormWatch(core) {
+  const { watchSubscribersRef, lastChangedFieldRef } = core.refs;
+  useEffect(() => {
+    if (watchSubscribersRef.current.size > 0) {
+      const info = {
+        name: lastChangedFieldRef.current,
+        type: lastChangedFieldRef.current ? "change" : void 0
+      };
+      watchSubscribersRef.current.forEach((cb) => cb(core.values, info));
+    }
+    lastChangedFieldRef.current = void 0;
+  }, [core.values, watchSubscribersRef, lastChangedFieldRef]);
+  const watch = useCallback3(
+    (nameOrNamesOrCallback) => {
+      const { valuesRef } = core.refs;
+      if (typeof nameOrNamesOrCallback === "function") {
+        const cb = nameOrNamesOrCallback;
+        watchSubscribersRef.current.add(cb);
+        return () => watchSubscribersRef.current.delete(cb);
+      }
+      if (Array.isArray(nameOrNamesOrCallback)) {
+        return nameOrNamesOrCallback.map(
+          (n) => valuesRef.current[n]
+        );
+      }
+      if (typeof nameOrNamesOrCallback === "string") {
+        return valuesRef.current[nameOrNamesOrCallback];
+      }
+      return valuesRef.current;
+    },
+    [core.refs, watchSubscribersRef]
+  );
+  return { watch };
+}
+
+// src/hooks/sub-hooks/use-form-actions.ts
+import { useCallback as useCallback4 } from "react";
+import {
+  validateSchema as validateSchema2,
+  normalizeError,
+  transformValues
+} from "@valfuse-node/form";
+function useFormActions(core, clearStaleFieldError) {
+  const handleSubmit = useCallback4(
+    (onValid) => async (e) => {
+      e?.preventDefault?.();
+      const { schema, refs } = core;
+      const currentValues = refs.valuesRef.current;
+      const transformedValues = transformValues(
+        schema,
+        currentValues
+      );
+      const schemaErrors = validateSchema2(
+        schema,
+        transformedValues
+      );
+      core.setSubmitCount((c) => c + 1);
+      core.setIsSubmitted(true);
+      if (Object.keys(schemaErrors).length > 0) {
+        core.setErrorsState(mapToFieldErrors(schemaErrors));
+        core.setIsSubmitSuccessful(false);
+        return;
+      }
+      if (Object.keys(refs.errorsRef.current).length > 0) core.setErrorsState({});
+      core.setIsSubmitting(true);
+      try {
+        await onValid(transformedValues);
+        core.setIsSubmitSuccessful(true);
+      } catch (err) {
+        core.setIsSubmitSuccessful(false);
+        throw err;
+      } finally {
+        core.setIsSubmitting(false);
+      }
+    },
+    // All read via core.* — list each stable field explicitly.
+    [
+      core.schema,
+      core.refs.valuesRef,
+      core.refs.errorsRef,
+      core.setSubmitCount,
+      core.setIsSubmitted,
+      core.setIsSubmitting,
+      core.setIsSubmitSuccessful,
+      core.setErrorsState
+    ]
+  );
+  const setErrors = useCallback4(
+    (fieldErrors) => {
+      core.setErrorsState((prev) => {
+        const next = { ...prev };
+        let changed = false;
+        for (const [fieldName, rawError] of Object.entries(fieldErrors)) {
+          if (rawError === void 0) continue;
+          const normalized = normalizeError(rawError);
+          const prevFieldError = prev[fieldName];
+          if (prevFieldError && prevFieldError.message === normalized.message && prevFieldError.type === (normalized.type ?? "manual") && prevFieldError.code === normalized.code) continue;
+          next[fieldName] = {
+            message: normalized.message,
+            type: normalized.type ?? "manual",
+            ...normalized.code !== void 0 && { code: normalized.code },
+            ...normalized.metadata !== void 0 && {
+              metadata: normalized.metadata
+            }
+          };
+          changed = true;
+        }
+        return changed ? next : prev;
+      });
+    },
+    [core.setErrorsState]
+  );
+  const clearErrors = useCallback4(
+    (name) => {
+      if (name === void 0) {
+        if (Object.keys(core.refs.errorsRef.current).length === 0) return;
+        core.setErrorsState({});
+        return;
+      }
+      const fields = Array.isArray(name) ? name : [name];
+      core.setErrorsState((prev) => {
+        const toDelete = fields.filter((k) => k in prev);
+        if (toDelete.length === 0) return prev;
+        const next = { ...prev };
+        for (const n of toDelete) delete next[n];
+        return next;
+      });
+    },
+    [core.refs.errorsRef, core.setErrorsState]
+  );
+  const trigger = useCallback4(
+    (name) => {
+      const { schema, refs } = core;
+      const current = refs.valuesRef.current;
+      const transformed = transformValues(schema, current);
+      const fieldsToValidate = name === void 0 ? Object.keys(schema) : Array.isArray(name) ? name : [name];
+      let allValid = true;
+      let changed = false;
+      const prevErrors = refs.errorsRef.current;
+      const nextErrors = { ...prevErrors };
+      for (const field of fieldsToValidate) {
+        if (!schema[field]) continue;
+        const raw = validateSchema2({ [field]: schema[field] }, transformed);
+        const error = buildFieldError(raw, field);
+        if (error) {
+          allValid = false;
+          const prev = prevErrors[field];
+          if (!prev || prev.message !== error.message || prev.type !== error.type || prev.code !== error.code) {
+            changed = true;
+          }
+          nextErrors[field] = error;
+        } else {
+          if (field in nextErrors) {
+            changed = true;
+            delete nextErrors[field];
+          }
+        }
+      }
+      if (changed) core.setErrorsState(nextErrors);
+      return allValid;
+    },
+    [core.schema, core.refs.valuesRef, core.refs.errorsRef, core.setErrorsState]
+  );
+  const setValue = useCallback4(
+    (name, value, options) => {
+      const { schema, refs } = core;
+      const fieldTransform = refs.schemaRef.current[name]?.transform;
+      const transformedValue = fieldTransform ? fieldTransform(value) : value;
+      const updated = { ...refs.valuesRef.current, [name]: transformedValue };
+      refs.valuesRef.current = updated;
+      refs.lastChangedFieldRef.current = name;
+      core.setValues(updated);
+      if (options?.shouldValidate) {
+        const field = name;
+        if (!schema[field]) return;
+        const raw = validateSchema2(
+          { [field]: schema[field] },
+          updated
+        );
+        const error = buildFieldError(raw, field);
+        core.setErrorsState((prev) => {
+          if (!error && !(field in prev)) return prev;
+          const prevError = prev[name];
+          if (error && prevError && error.message === prevError.message && error.type === prevError.type && error.code === prevError.code) return prev;
+          const next = { ...prev };
+          if (error) {
+            next[name] = error;
+          } else {
+            delete next[name];
+          }
+          return next;
+        });
+      } else {
+        clearStaleFieldError(name);
+      }
+    },
+    [
+      core.schema,
+      core.refs.schemaRef,
+      core.refs.valuesRef,
+      core.refs.lastChangedFieldRef,
+      core.setValues,
+      core.setErrorsState,
+      clearStaleFieldError
+    ]
+  );
+  const reset = useCallback4(
+    (newValues) => {
+      core.setValues({ ...core.defaultValues, ...newValues });
+      core.setErrorsState({});
+      core.setTouchedFields(/* @__PURE__ */ new Set());
+      core.setIsSubmitted(false);
+      core.setIsSubmitSuccessful(false);
+      core.setSubmitCount(0);
+    },
+    [
+      core.defaultValues,
+      core.setValues,
+      core.setErrorsState,
+      core.setTouchedFields,
+      core.setIsSubmitted,
+      core.setIsSubmitSuccessful,
+      core.setSubmitCount
+    ]
+  );
+  return { handleSubmit, setErrors, clearErrors, setValue, trigger, reset };
+}
+
+// src/hooks/sub-hooks/use-form-derived-state.ts
+import { useMemo as useMemo2 } from "react";
+import { validateSchema as validateSchema3, transformValues as transformValues2 } from "@valfuse-node/form";
+function useFormDerivedState(core) {
+  const { schema, defaultValues, values, errors, touchedFields } = core;
+  const isDirty = useMemo2(
+    () => Object.keys(defaultValues).some(
+      (key) => values[key] !== defaultValues[key]
+    ),
+    [values, defaultValues]
+  );
+  const dirtyFields = useMemo2(
+    () => Object.keys(defaultValues).reduce(
+      (acc, key) => {
+        const k = key;
+        if (values[k] !== defaultValues[k]) acc[k] = true;
+        return acc;
+      },
+      {}
+    ),
+    [values, defaultValues]
+  );
+  const touchedFieldsRecord = useMemo2(
+    () => Array.from(touchedFields).reduce(
+      (acc, key) => {
+        acc[key] = true;
+        return acc;
+      },
+      {}
+    ),
+    [touchedFields]
+  );
+  const isValid = useMemo2(() => {
+    if (Object.keys(errors).length > 0) return false;
+    const transformed = transformValues2(
+      schema,
+      values
+    );
+    return Object.keys(validateSchema3(schema, transformed)).length === 0;
+  }, [schema, values, errors]);
+  return { isDirty, dirtyFields, touchedFieldsRecord, isValid };
+}
+
+// src/hooks/use-valfuse-form.ts
+function useValfuseForm(props) {
+  const { defaultValues } = props;
+  const core = useFormCore(props);
+  const { validateField, clearStaleFieldError } = useFieldValidation({
+    schema: core.schema,
+    setErrorsState: core.setErrorsState
+  });
+  const { register, control } = useFormRegistration({
+    core,
+    validateField,
+    clearStaleFieldError
+  });
+  const { watch } = useFormWatch(core);
+  const { handleSubmit, setErrors, clearErrors, setValue, trigger, reset } = useFormActions(core, clearStaleFieldError);
+  const { isDirty, dirtyFields, touchedFieldsRecord, isValid } = useFormDerivedState(core);
+  const formState = useMemo3(
+    () => ({
+      errors: core.errors,
+      isSubmitting: core.isSubmitting,
+      isSubmitted: core.isSubmitted,
+      isSubmitSuccessful: core.isSubmitSuccessful,
+      submitCount: core.submitCount,
+      isDirty,
+      isValid,
+      dirtyFields,
+      touchedFields: touchedFieldsRecord,
+      defaultValues
+    }),
+    [
+      core.errors,
+      core.isSubmitting,
+      core.isSubmitted,
+      core.isSubmitSuccessful,
+      core.submitCount,
+      isDirty,
+      isValid,
+      dirtyFields,
+      touchedFieldsRecord,
+      defaultValues
+    ]
+  );
+  return {
+    register,
+    control,
+    handleSubmit,
+    formState,
+    setErrors,
+    clearErrors,
+    setValue,
+    trigger,
+    watch,
+    reset
+  };
+}
+
+// src/components/valfuse-controller.tsx
+import { useCallback as useCallback5, useMemo as useMemo4 } from "react";
+function ValfuseController({
+  control,
+  name,
+  render
+}) {
+  const onChange = useCallback5(
+    (value) => control._updateField(name, value),
+    [control._updateField, name]
+  );
+  const onBlur = useCallback5(
+    () => control._touchField(name),
+    [control._touchField, name]
+  );
+  const fieldValue = control._values[name];
+  const fieldError = control._errors[name];
+  const isTouched = control._touchedFields.has(name);
+  const field = useMemo4(
+    () => ({
+      name,
+      value: fieldValue,
+      onChange,
+      onBlur
+    }),
+    [name, fieldValue, onChange, onBlur]
+  );
+  const fieldState = useMemo4(
+    () => ({
+      error: fieldError,
+      isTouched
+    }),
+    [fieldError, isTouched]
+  );
+  return render({ field, fieldState });
+}
+
+// src/localization/provider/localization-provider.tsx
+import { createContext, useCallback as useCallback6, useMemo as useMemo5, useState as useState2 } from "react";
+
+// src/localization/bridge/create-localization-store.ts
+import { interpolate, lookupMessage } from "@valfuse-node/localization/runtime";
+function createLocalizationStore(manifest, initialLocale) {
+  let locale = initialLocale ?? manifest.base_locale;
+  return {
+    getLocale: () => locale,
+    setLocale(nextLocale) {
+      locale = nextLocale;
+    },
+    t(key, params) {
+      const value = lookupMessage(
+        {
+          locale,
+          fallbackLocale: manifest.fallback_locale,
+          messages: manifest.messages
+        },
+        key
+      );
+      return interpolate(value, params);
+    }
+  };
+}
+
+// src/localization/provider/localization-provider.tsx
+import { jsx } from "react/jsx-runtime";
+var LocalizationContext = createContext(null);
+function determineInitialLocale(manifest, initialLocale, storage) {
+  const stored = storage?.get();
+  if (stored && manifest.locales.includes(stored)) return stored;
+  if (initialLocale && manifest.locales.includes(initialLocale)) return initialLocale;
+  return manifest.base_locale;
+}
+function LocalizationProvider({
+  manifest,
+  initialLocale,
+  storage,
+  children
+}) {
+  const [locale, _setLocale] = useState2(
+    () => determineInitialLocale(manifest, initialLocale, storage)
+  );
+  const setLocale = useCallback6(
+    (nextLocale) => {
+      storage?.set(nextLocale);
+      _setLocale(nextLocale);
+    },
+    [storage]
+  );
+  const value = useMemo5(() => {
+    const store = createLocalizationStore(manifest, locale);
+    return { locale, setLocale, store, manifest };
+  }, [locale, manifest, setLocale]);
+  return /* @__PURE__ */ jsx(LocalizationContext.Provider, { value, children });
+}
+
+// src/localization/hooks/use-localization.ts
+import { useCallback as useCallback7, useContext, useMemo as useMemo6 } from "react";
+import {
+  interpolate as interpolate2,
+  lookupMessage as lookupMessage2,
+  pickStructuredContextVariant,
+  pickStructuredGenderVariant,
+  pickStructuredPluralVariant
+} from "@valfuse-node/localization/runtime";
+function pickFallbackText(fallback, key) {
+  if (!fallback) return void 0;
+  if (typeof fallback === "string") return fallback;
+  if (typeof fallback === "function") return fallback(key);
+  return fallback[key];
+}
+function useLocalization(options = {}) {
+  const context = useContext(LocalizationContext);
+  if (!context) {
+    throw new Error("useLocalization must be used within LocalizationProvider.");
+  }
+  const { locale, manifest } = context;
+  const fallback = options.fallback;
+  const runtimeContext = useMemo6(
+    () => ({
+      locale,
+      fallbackLocale: manifest.fallback_locale,
+      messages: manifest.messages
+    }),
+    [locale, manifest.fallback_locale, manifest.messages]
+  );
+  const readTranslation = useCallback7(
+    (key) => lookupMessage2(runtimeContext, key),
+    [runtimeContext]
+  );
+  const hasKey = useCallback7(
+    (key) => key in (manifest.messages[locale] ?? {}) || key in (manifest.messages[manifest.fallback_locale] ?? {}),
+    [locale, manifest.fallback_locale, manifest.messages]
+  );
+  const translate = useCallback7(
+    (key, fallbackValue) => {
+      const translated = readTranslation(key);
+      if (!translated || translated === key) {
+        if (fallbackValue === null) return translated;
+        return fallbackValue ?? pickFallbackText(fallback, key) ?? translated;
+      }
+      return translated;
+    },
+    [fallback, readTranslation]
+  );
+  const format = useCallback7(
+    (key, params) => interpolate2(translate(key), params),
+    [translate]
+  );
+  const translateOrNull = useCallback7(
+    (key) => {
+      if (key == null) return null;
+      return hasKey(key) ? translate(key) : null;
+    },
+    [hasKey, translate]
+  );
+  const formatOrNull = useCallback7(
+    (key, params) => {
+      if (key == null) return null;
+      return hasKey(key) ? format(key, params) : null;
+    },
+    [hasKey, format]
+  );
+  const raw = useCallback7(
+    (key) => manifest.messages[locale]?.[key] ?? manifest.messages[manifest.fallback_locale]?.[key] ?? "",
+    [locale, manifest.fallback_locale, manifest.messages]
+  );
+  const plural = useCallback7(
+    (key, count) => pickStructuredPluralVariant(raw(key), count),
+    [raw]
+  );
+  const pluralOrNull = useCallback7(
+    (key, count) => {
+      if (key == null) return null;
+      return hasKey(key) ? plural(key, count) : null;
+    },
+    [hasKey, plural]
+  );
+  const gender = useCallback7(
+    (key, value, params) => interpolate2(pickStructuredGenderVariant(raw(key), value), params),
+    [raw]
+  );
+  const contextFn = useCallback7(
+    (key, value, params) => {
+      const translated = pickStructuredContextVariant(raw(key), value);
+      return params ? interpolate2(translated, params) : translated;
+    },
+    [raw]
+  );
+  const namespace = useCallback7(
+    (scope) => ({
+      translate: (key, fallbackValue) => translate(`${scope}.${key}`, fallbackValue),
+      translateOrNull: (key) => key == null ? null : translateOrNull(`${scope}.${key}`),
+      format: (key, params) => format(`${scope}.${key}`, params),
+      formatOrNull: (key, params) => key == null ? null : formatOrNull(`${scope}.${key}`, params),
+      plural: (key, count) => plural(`${scope}.${key}`, count),
+      pluralOrNull: (key, count) => key == null ? null : pluralOrNull(`${scope}.${key}`, count),
+      gender: (key, value, params) => gender(`${scope}.${key}`, value, params),
+      context: (key, value, params) => contextFn(`${scope}.${key}`, value, params)
+    }),
+    [translate, translateOrNull, format, formatOrNull, plural, pluralOrNull, gender, contextFn]
+  );
+  const entriesForLocale = useMemo6(
+    () => Object.entries(manifest.messages[locale] ?? {}).sort(
+      ([a], [b]) => a.localeCompare(b)
+    ),
+    [locale, manifest.messages]
+  );
+  return {
+    ...context,
+    translate,
+    translateOrNull,
+    format,
+    formatOrNull,
+    plural,
+    pluralOrNull,
+    gender,
+    context: contextFn,
+    namespace,
+    entriesForLocale
+  };
+}
+
+// src/localization/hooks/use-localization-tree.ts
+import { useMemo as useMemo7 } from "react";
+function toSegments(key) {
+  return key.split(".").slice(1);
+}
+function useLocalizationTree() {
+  const { store, manifest } = useLocalization();
+  return useMemo7(() => {
+    const strings = {};
+    const placeholders = {};
+    for (const entry of manifest.entries) {
+      const segments = toSegments(entry.key);
+      if (segments.length === 0) continue;
+      const target = entry.placeholders.length > 0 ? placeholders : strings;
+      let cursor = target;
+      for (let i = 0; i < segments.length - 1; i += 1) {
+        const segment = segments[i];
+        if (!segment) continue;
+        cursor[segment] ?? (cursor[segment] = {});
+        cursor = cursor[segment];
+      }
+      const leaf = segments[segments.length - 1];
+      if (!leaf) continue;
+      if (entry.placeholders.length > 0) {
+        cursor[leaf] = (params) => store.t(entry.key, params);
+      } else {
+        cursor[leaf] = store.t(entry.key);
+      }
+    }
+    return { strings, placeholders };
+  }, [store, manifest]);
+}
+
+// src/localization/lazy/create-lazy-locale-loader.ts
+function createLazyLocaleLoader(manifest) {
+  return async (locale) => manifest.messages[locale] ?? {};
+}
+
+// src/localization/ssr/create-ssr-localization-state.ts
+function createSsrLocalizationState(manifest, locale) {
+  const activeLocale = locale ?? manifest.base_locale;
+  return {
+    locale: activeLocale,
+    messages: manifest.messages[activeLocale] ?? {}
+  };
+}
+
+// src/localization/storage/locale-storage.ts
+function localStorageStrategy(options = {}) {
+  const key = options.key ?? "locale";
+  return {
+    get() {
+      try {
+        return window.localStorage.getItem(key) ?? void 0;
+      } catch {
+        return void 0;
+      }
+    },
+    set(locale) {
+      try {
+        window.localStorage.setItem(key, locale);
+      } catch {
+      }
+    },
+    remove() {
+      try {
+        window.localStorage.removeItem(key);
+      } catch {
+      }
+    }
+  };
+}
+function sessionStorageStrategy(options = {}) {
+  const key = options.key ?? "locale";
+  return {
+    get() {
+      try {
+        return window.sessionStorage.getItem(key) ?? void 0;
+      } catch {
+        return void 0;
+      }
+    },
+    set(locale) {
+      try {
+        window.sessionStorage.setItem(key, locale);
+      } catch {
+      }
+    },
+    remove() {
+      try {
+        window.sessionStorage.removeItem(key);
+      } catch {
+      }
+    }
+  };
+}
+function cookieStrategy(options = {}) {
+  const {
+    key = "locale",
+    domain,
+    path = "/",
+    maxAge = 31536e3,
+    sameSite = "Lax"
+  } = options;
+  function buildCookie(value, age) {
+    const isSecure = options.secure !== void 0 ? options.secure : typeof location !== "undefined" && location.protocol === "https:";
+    let cookie = `${encodeURIComponent(key)}=${encodeURIComponent(value)}`;
+    cookie += `; path=${path}`;
+    cookie += `; max-age=${age}`;
+    if (domain) cookie += `; domain=${domain}`;
+    if (isSecure) cookie += "; Secure";
+    cookie += `; SameSite=${sameSite}`;
+    return cookie;
+  }
+  return {
+    get() {
+      if (typeof document === "undefined") return void 0;
+      const encodedKey = encodeURIComponent(key);
+      const match = document.cookie.split("; ").find((c) => c.startsWith(`${encodedKey}=`));
+      const rawValue = match?.split("=").slice(1).join("=");
+      return rawValue !== void 0 ? decodeURIComponent(rawValue) : void 0;
+    },
+    set(locale) {
+      if (typeof document === "undefined") return;
+      document.cookie = buildCookie(locale, maxAge);
+    },
+    remove() {
+      if (typeof document === "undefined") return;
+      document.cookie = buildCookie("", 0);
+    }
+  };
+}
+function memoryStrategy(options = {}) {
+  let stored = options.initialLocale;
+  return {
+    get: () => stored,
+    set: (locale) => {
+      stored = locale;
+    },
+    remove: () => {
+      stored = void 0;
+    }
+  };
+}
+function composeStorage(...storages) {
+  return {
+    get() {
+      for (const s of storages) {
+        const v = s.get();
+        if (v !== void 0) return v;
+      }
+      return void 0;
+    },
+    set(locale) {
+      storages.forEach((s) => s.set(locale));
+    },
+    remove() {
+      storages.forEach((s) => s.remove?.());
+    }
+  };
+}
+export {
+  LocalizationProvider,
+  ValfuseController,
+  composeStorage,
+  cookieStrategy,
+  createLazyLocaleLoader,
+  createLocalizationStore,
+  createSsrLocalizationState,
+  localStorageStrategy,
+  memoryStrategy,
+  sessionStorageStrategy,
+  useLocalization,
+  useLocalizationTree,
+  useValfuseForm
+};