@nxgt/i18n 1.0.4 → 2.0.0

package/README.md

@@ -51,10 +51,31 @@ and `errors.service-unavailable`.
 
 `getLanguage()` asks, most specific first:
 
-1. the Hono request context (`LANGUAGE_KEY`, `'language'`)
+1. every registered **language source**, in the order registered
 2. `localStorage.language`, when that object exists
 3. `FALLBACK_LANGUAGE` (`'en'`)
 
+A source is a function answering the current request's language, or nothing.
+This package knows no server; the server says where its request keeps the
+language:
+
+```ts
+import { registerLanguageSource } from '@nxgt/i18n';
+
+const remove = registerLanguageSource(() => currentRequest()?.language);
+```
+
+| server | its source |
+| --- | --- |
+| Hono | `@nxgt/shared-hono` registers `honoLanguageSource` when imported: the `language` variable `languageDetector()` sets, read through `contextStorage()` |
+| GraphQL Yoga on Hono | `@nxgt/shared-graphql`'s `createYogaHono()` registers the same |
+| alxia | `@alxia/i18n`'s `createI18n()` registers the request's language |
+
+A source that answers nothing, a language no catalogue has, or throws is
+skipped. Registering one twice keeps one. The registry is on `globalThis`, so
+two copies of this package in one app — one a dependency of
+`@nxgt/shared-hono`, one the app's own — share it.
+
 The two consuming monorepos had forked exactly this — one read the request, the
 other read `localStorage` — and neither could run where the other did. Asking
 both serves either without a caller changing anything. Pass a provider (a
@@ -63,8 +84,29 @@ and not the other.
 
 `SUPPORTED_LANGUAGES` is derived from the catalogue keys, not typed out.
 
+### Since 2.0
+
+Until 2.0, `getLanguage()` read the Hono request context itself, through
+`hono/context-storage`: every consumer depended on Hono, and a server on
+anything else got the fallback. The Hono part lives in `@nxgt/shared-hono`
+now, with the `ContextVariableMap` augmentation that types `c.get('language')`.
+An app that imports `@nxgt/shared-hono` sees no difference; one that used
+`@nxgt/i18n` beside Hono without it calls `useHonoLanguage()` from
+`@nxgt/shared-hono` once, or registers its own source.
+
+## In a browser bundle
+
+Nothing to change: `import { translate } from '@nxgt/i18n'` is the same import
+whether the code runs in Node, Bun, or a bundler that resolves the `browser`
+export condition (Vite, Nuxt's client build). Since 2.0 nothing in the package
+is Node-only, and the `browser` entry is the same code; a client app registers
+a source as a server does, or relies on `localStorage`.
+
 ## Things that bite
 
+- **A server's language is a registered source.** Without one, every
+  request is translated in `localStorage`'s language — none, on a server — or
+  the fallback.
 - **Messages are keys.** Rendering at the throw site (or translating in a
   service) freezes the language of whoever threw, not of whoever reads.
 - **ICU formatting failures are swallowed** (`console.error`) and the

package/dist/chunks/index-vknxbeh1.js

@@ -0,0 +1,524 @@
+// src/resources/en/common.json
+var common_default = {
+  mail: {
+    common: {
+      thanks: "Thanks,",
+      greeting: "Hello {name},",
+      copyright: "© {date} Strange. All rights reserved."
+    },
+    templates: {
+      verification: {
+        message: "We''re happy to have you on board! Use your verification code in order to activate your account. Verification code:",
+        verify: "Verify email",
+        notes: "We are not responsible if you decide to share you're account credentials. Make sure to keep secret."
+      }
+    }
+  },
+  "opening-hours": {
+    errors: {
+      "invalid-start-time-format": "The opening time format is invalid. Please use the HH:mm format.",
+      "invalid-end-time-format": "The closing time format is invalid. Please use the HH:mm format."
+    }
+  }
+};
+// src/resources/en/errors.json
+var errors_default = {
+  "not-found": "Could not find the requested resource.",
+  unauthenticated: "You're not authenticated",
+  "duplicate-key": "There was a duplicate key error. Please, check data and try again",
+  "something-went-wrong": "Something went wrong. Please, check and try again.",
+  "insufficient-permissions": "You don't have required permissions to access this resource. Please, contact your administrator.",
+  "cast-failed": "Incorrect value for the field ''{field}''. Please, check the value and try again.",
+  "server-connection-failed": "Failed to connect to the database server. Please, contact your administrator.",
+  forbidden: "You don't have necessary permission to access this resource. Please, contact your administrator.",
+  "optimistic-lock-failed": "The resource has been modified by another user. Please refresh and try again.",
+  "internal-server-error": "Internal server error. Please, contact your administrator.",
+  "validation-failed": "Validation failed for one or more fields. Please, check the data and try again.",
+  "address-blocked": "The access is blocked for address ``{address}``.",
+  "could-not-use-first-and-last-together": "You cannot use ''first'' and ''last'' parameters together in pagination.",
+  "invalid-cursor": "The provided cursor is invalid. Please, check and try again.",
+  "invalid-status-transition": "Cannot change status from ''{from}'' to ''{to}''.",
+  "service-unavailable": "A service this request depends on is not answering. Nothing was changed; please try again in a moment.",
+  "graphql-parse-failed": "Failed to parse the GraphQL query. Check your query syntax.",
+  "graphql-validation-failed": "The GraphQL query is invalid. Please check the operation and variables.",
+  "persisted-query-not-found": "Persisted query not found. The query hash is unknown.",
+  "persisted-query-not-supported": "Persisted queries are not supported on this server.",
+  "bad-user-input": "Invalid input provided. Please check your data and try again.",
+  "operation-resolution-failure": "Failed to resolve the GraphQL operation.",
+  "bad-request": "The request is invalid or malformed. Please verify the request format."
+};
+// src/resources/en/validation.json
+var validation_default = {
+  errors: {
+    "invalid-account-number": "The provided value is not a valid account number.",
+    "invalid-big-int": "The value must be a valid BigInt.",
+    "invalid-country-code": "The value must be a valid two-letter ISO country code.",
+    "invalid-country-name": "The value must be a valid country name.",
+    "invalid-cuid": "The value must be a valid CUID.",
+    "invalid-currency": "The value must be a valid ISO 4217 currency code.",
+    "invalid-date": "The value must be a valid date in the format YYYY-MM-DD.",
+    "invalid-date-time": "The value must be a valid ISO 8601 date-time string.",
+    "invalid-duration": "The value must be a valid duration in ISO 8601 format.",
+    "invalid-email-address": "The value must be a valid email address.",
+    "invalid-geo-json": "The value must be a valid GeoJSON object.",
+    "invalid-guid": "The value must be a valid GUID.",
+    "invalid-hex-color-code": "The value must be a valid hexadecimal color code.",
+    "invalid-hexadecimal": "The value must be a valid hexadecimal string.",
+    "invalid-hsl": "The value must be a valid HSL (Hue, Saturation, Lightness) color format.",
+    "invalid-hsla": "The value must be a valid HSLA (Hue, Saturation, Lightness, Alpha) color format.",
+    "invalid-iban": "The value must be a valid International Bank Account Number (IBAN).",
+    "invalid-ip": "The value must be a valid IP address.",
+    "invalid-ipv4": "The value must be a valid IPv4 address.",
+    "invalid-ipv6": "The value must be a valid IPv6 address.",
+    "invalid-isbn": "The value must be a valid ISBN (International Standard Book Number).",
+    "invalid-json": "The value must be valid JSON.",
+    "invalid-json-object": "The value must be a valid JSON object.",
+    "invalid-jwt": "The value must be a valid JSON Web Token (JWT).",
+    "invalid-latitude": "The value must be a valid latitude coordinate.",
+    "invalid-locale": "The value must be a valid locale code.",
+    "invalid-longitude": "The value must be a valid longitude coordinate.",
+    "invalid-long": "The value must be a valid long integer.",
+    "invalid-mac": "The value must be a valid MAC address.",
+    "invalid-negative-float": "The value must be a negative floating-point number.",
+    "invalid-negative-int": "The value must be a negative integer.",
+    "invalid-non-empty-string": "The value must be a non-empty string.",
+    "invalid-non-negative-float": "The value must be a floating-point number equal to 0 or more.",
+    "invalid-non-negative-int": "The value must be a integer equal to 0 or more.",
+    "invalid-non-positive-float": "The value must be a floating-point number equal to 0 or less.",
+    "invalid-non-positive-int": "The value must be a integer equal to 0 or less.",
+    "invalid-object-id": "The value must be a valid MongoDB ObjectID.",
+    "invalid-phone-number": "The value must be a valid phone number.",
+    "invalid-port": "The value must be a valid port number.",
+    "invalid-positive-float": "The value must be a positive floating-point number.",
+    "invalid-positive-int": "The value must be a positive integer.",
+    "invalid-postal-code": "The value must be a valid postal code.",
+    "invalid-rgb": "The value must be a valid RGB (Red, Green, Blue) color format.",
+    "invalid-rgba": "The value must be a valid RGBA (Red, Green, Blue, Alpha) color format.",
+    "invalid-sessn": "The value must be a valid session identifier.",
+    "invalid-time": "The value must be a valid time in the format HH:mm:ss.",
+    "invalid-timestamp": "The value must be a valid timestamp.",
+    "invalid-url": "The value must be a valid URL.",
+    "invalid-us-currency": "The value must be a valid US currency format.",
+    "invalid-utc-offset": "The value must be a valid UTC offset.",
+    "invalid-uuid": "The value must be a valid UUID.",
+    "invalid-void": "The value must be null or undefined.",
+    min: "The minimum value for the field ''{path}'' must be greater than or equal to {min}.",
+    max: "The maximum value for the field ''{path}'' must be less than or equal to {max}.",
+    "min-length": "The minimum length for the field ''{path}'' must be at least {minLength} characters.",
+    "max-length": "The maximum length for the field ''{path}'' must not exceed {maxLength} characters.",
+    range: "The value for the field ''{path}'' must be between {min} and {max}.",
+    size: "The length of the field ''{path}'' must be between {min} and {max}.",
+    past: "The value for the field ''{path}'' must be a valid date before {limit}.",
+    future: "The value for the field ''{path}'' must be a valid date after {limit}.",
+    email: "The value for the field ''{path}'' must be {numberOfDomains, plural, =0 {a valid email address} =1 {an email address within the domain ''{domains}''} other {an email address within one of the following domains: [{domains}]}.",
+    ip: "The value for the field ''{path}'' must be a valid IP address.",
+    ipv4: "The value for the field ''{path}'' must be a valid IPv4 address.",
+    ipv6: "The value for the field ''{path}'' must be a valid IPv6 address.",
+    mac: "The value for the field ''{path}'' must be a valid MAC address.",
+    url: "The value for the field ''{path}'' must be {numberOfDomains, plural, =0 {a valid URL} =1 {a URL within the domain ''{domains}''} other {a URL within one of the following domains: [{domains}]}.",
+    uuid: "The value for the field ''{path}'' must be a valid UUID.",
+    guid: "The value for the field ''{path}'' must be a valid GUID.",
+    ssn: "The value for the field ''{path}'' must be a valid social security number(SSN).",
+    phone: "The value for the field ''{path}'' must be a valid phone number.",
+    street: "The value for the field ''{path}'' must be a valid street address.",
+    "zip-code": "The value for the field ''{path}'' must be a valid ZIP code.",
+    "object-id": "The value for the field ''{path}'' must be a 24-character hexadecimal string.",
+    pattern: "Invalid value for the field ''{path}'. The value must match the pattern: ''{pattern}''.",
+    "not-blank": "The field ''{path}'' must not be blank.",
+    "not-empty": "The field ''{path}'' must not be empty.",
+    positive: "The value for the field ''{path}'' must be a positive number.",
+    negative: "The value for the field ''{path}'' must be a negative number.",
+    "no-scalars": "Invalid type: ''{type}'' is not a scalar type.",
+    "not-null": "The value for {length, plural, =0 {the field} other {each item of the field} ''{path}'' should not be null.",
+    required: "The value for the field ''{path}'' is required.",
+    time: "The value for the field ''{path}'' must be a valid time in the format HH:mm."
+  }
+};
+// src/resources/en/zod.json
+var zod_default = {
+  required: "This field is required.",
+  invalid_type: {
+    string: "Une chaîne de texte est attendue.",
+    number: "Un nombre est attendu.",
+    boolean: "Un booléen est attendu.",
+    object: "Un objet est attendu.",
+    array: "Une liste est attendue.",
+    bigint: "Un nombre entier très grand est attendu.",
+    date: "Une date valide est attendue.",
+    symbol: "Un symbole est attendu.",
+    undefined: "Cette valeur est manquante.",
+    null: "La valeur doit être nulle.",
+    function: "Une fonction est attendue.",
+    enum: "L’option choisie est invalide.",
+    default: "Type invalide."
+  },
+  invalid_value_single: "This value is not allowed.",
+  invalid_value_multiple: "This option is not valid.",
+  too_big_inclusive: "This value is too large: it must be at most {maximum} {unit}.",
+  too_big_exclusive: "This value is too large: it must be less than {maximum} {unit}.",
+  too_big_no_unit_inclusive: "This value is too large: it must be at most {maximum}.",
+  too_big_no_unit_exclusive: "This value is too large: it must be less than {maximum}.",
+  too_small_inclusive: "This value is too small: it must be at least {minimum} {unit}.",
+  too_small_exclusive: "This value is too small: it must be more than {minimum} {unit}.",
+  too_small_no_unit_inclusive: "This value is too small: it must be at least {minimum}.",
+  too_small_no_unit_exclusive: "This value is too small: it must be more than {minimum}.",
+  invalid_format: {
+    starts_with: 'This text must start with "{prefix}".',
+    ends_with: 'This text must end with "{suffix}".',
+    includes: 'This text must include "{includes}".',
+    regex: "This value doesn’t match the required format.",
+    default: "Invalid {noun}."
+  },
+  not_multiple_of: "This number must be a multiple of {divisor}.",
+  unrecognized_keys_single: "Unknown field: {keys}.",
+  unrecognized_keys_multiple: "Unknown fields: {keys}.",
+  invalid_key: "This key is not valid in {origin}.",
+  invalid_union: "This value does not match any of the allowed formats.",
+  invalid_element: "This field contains an invalid value in {origin}.",
+  default: "This value is not valid.",
+  nouns: {
+    regex: "value",
+    email: "email address",
+    url: "URL",
+    emoji: "emoji",
+    uuid: "UUID",
+    uuidv4: "UUIDv4",
+    uuidv6: "UUIDv6",
+    nanoid: "nanoid",
+    guid: "GUID",
+    cuid: "cuid",
+    cuid2: "cuid2",
+    ulid: "ULID",
+    xid: "XID",
+    ksuid: "KSUID",
+    datetime: "date and time",
+    date: "date",
+    time: "time",
+    duration: "duration",
+    ipv4: "IPv4 address",
+    ipv6: "IPv6 address",
+    mac: "MAC address",
+    cidrv4: "IPv4 range",
+    cidrv6: "IPv6 range",
+    base64: "base64 string",
+    base64url: "base64url string",
+    json_string: "JSON string",
+    e164: "phone number",
+    jwt: "JWT",
+    template_literal: "value"
+  },
+  sizing: {
+    string: { unit: "characters", verb: "contain" },
+    file: { unit: "bytes", verb: "contain" },
+    array: { unit: "items", verb: "contain" },
+    set: { unit: "items", verb: "contain" }
+  }
+};
+
+// src/resources/en/index.ts
+var en = {
+  ...common_default,
+  errors: errors_default,
+  validation: validation_default,
+  zod: zod_default
+};
+// src/resources/fr/common.json
+var common_default2 = {
+  mail: {
+    common: {
+      thanks: "Merci,",
+      greeting: "Bonjour {name},",
+      copyright: "© {date} Strange. Tous droits réservés."
+    },
+    templates: {
+      verification: {
+        message: "Nous sommes heureux de vous compter parmi nous ! Utilisez votre code de vérification pour activer votre compte. Code de vérification :",
+        verify: "Vérifier l''e-mail",
+        notes: "Nous ne sommes pas responsables si vous décidez de partager les informations d''identification de votre compte. Veillez à garder le secret."
+      }
+    }
+  },
+  "opening-hours": {
+    errors: {
+      "invalid-start-time-format": "Le format de l''heure d''ouverture est invalide. Utilisez le format HH:mm.",
+      "invalid-end-time-format": "Le format de l''heure de fermeture est invalide. Utilisez le format HH:mm."
+    }
+  }
+};
+// src/resources/fr/errors.json
+var errors_default2 = {
+  "not-found": "Impossible de trouver la ressource demandée.",
+  unauthenticated: "Vous n'êtes pas authentifié",
+  "duplicate-key": "Il y a eu une erreur de clé dupliquée. Veuillez vérifier les données et réessayer",
+  "something-went-wrong": "Quelque chose n'a pas fonctionné. Veuillez vérifier et réessayer.",
+  "insufficient-permissions": "Vous n'avez pas les permissions nécessaires pour accéder à cette ressource. Veuillez contacter votre administrateur.",
+  "cast-failed": "Valeur incorrecte pour le champ ''{field}''. Veuillez vérifier la valeur et réessayer.",
+  "server-connection-failed": "Échec de la connexion au serveur de base de données. Veuillez contacter votre administrateur.",
+  forbidden: "Vous n'avez pas la permission nécessaire pour accéder à cette ressource. Veuillez contacter votre administrateur.",
+  "optimistic-lock-failed": "La ressource a été modifiée par un autre utilisateur. Veuillez actualiser et réessayer.",
+  "internal-server-error": "Erreur interne du serveur. Veuillez contacter votre administrateur.",
+  "validation-failed": "La validation a échoué pour un ou plusieurs champs. Veuillez vérifier les données et réessayer.",
+  "address-blocked": "L'accès est bloqué pour l'adresse ``{address}``.",
+  "could-not-use-first-and-last-together": "Vous ne pouvez pas utiliser les paramètres ''first'' et ''last'' ensemble dans la pagination.",
+  "invalid-cursor": "Le curseur fourni est invalide. Veuillez vérifier et réessayer.",
+  "invalid-status-transition": "Impossible de changer le statut de ''{from}'' à ''{to}''.",
+  "service-unavailable": "Un service dont dépend cette requête ne répond pas. Rien n'a été modifié ; réessayez dans un instant.",
+  "graphql-parse-failed": "Échec de l'analyse de la requête GraphQL. Vérifiez la syntaxe de votre requête.",
+  "graphql-validation-failed": "La requête GraphQL est invalide. Veuillez vérifier l'opération et les variables.",
+  "persisted-query-not-found": "Requête persistante non trouvée. Le hash de la requête est inconnu.",
+  "persisted-query-not-supported": "Les requêtes persistantes ne sont pas prises en charge sur ce serveur.",
+  "bad-user-input": "Données saisies invalides. Veuillez vérifier vos informations et réessayer.",
+  "operation-resolution-failure": "Échec de la résolution de l'opération GraphQL.",
+  "bad-request": "La requête est invalide ou mal formée. Veuillez vérifier le format de la requête."
+};
+// src/resources/fr/validation.json
+var validation_default2 = {
+  errors: {
+    "invalid-account-number": "La valeur fournie n'est pas un numéro de compte valide.",
+    "invalid-big-int": "La valeur doit être un BigInt valide.",
+    "invalid-country-code": "La valeur doit être un code pays ISO à deux lettres valide.",
+    "invalid-country-name": "La valeur doit être un nom de pays valide.",
+    "invalid-cuid": "La valeur doit être un CUID valide.",
+    "invalid-currency": "La valeur doit être un code de devise ISO 4217 valide.",
+    "invalid-date": "La valeur doit être une date valide au format AAAA-MM-JJ.",
+    "invalid-date-time": "La valeur doit être une date et une heure valides au format ISO 8601.",
+    "invalid-duration": "La valeur doit être une durée valide au format ISO 8601.",
+    "invalid-email-address": "La valeur doit être une adresse e-mail valide.",
+    "invalid-geo-json": "La valeur doit être un objet GeoJSON valide.",
+    "invalid-guid": "La valeur doit être un GUID valide.",
+    "invalid-hex-color-code": "La valeur doit être un code couleur hexadécimal valide.",
+    "invalid-hexadecimal": "La valeur doit être une chaîne hexadécimale valide.",
+    "invalid-hsl": "La valeur doit être un format de couleur HSL (Teinte, Saturation, Luminosité) valide.",
+    "invalid-hsla": "La valeur doit être un format de couleur HSLA (Teinte, Saturation, Luminosité, Alpha) valide.",
+    "invalid-iban": "La valeur doit être un numéro IBAN (International Bank Account Number) valide.",
+    "invalid-ip": "La valeur doit être une adresse IP valide.",
+    "invalid-ipv4": "La valeur doit être une adresse IPv4 valide.",
+    "invalid-ipv6": "La valeur doit être une adresse IPv6 valide.",
+    "invalid-isbn": "La valeur doit être un ISBN (International Standard Book Number) valide.",
+    "invalid-json": "La valeur doit être un JSON valide.",
+    "invalid-json-object": "La valeur doit être un objet JSON valide.",
+    "invalid-jwt": "La valeur doit être un jeton JSON Web Token (JWT) valide.",
+    "invalid-latitude": "La valeur doit être une coordonnée de latitude valide.",
+    "invalid-locale": "La valeur doit être un code de langue valide.",
+    "invalid-longitude": "La valeur doit être une coordonnée de longitude valide.",
+    "invalid-long": "La valeur doit être un entier long valide.",
+    "invalid-mac": "La valeur doit être une adresse MAC valide.",
+    "invalid-negative-float": "La valeur doit être un nombre flottant négatif.",
+    "invalid-negative-int": "La valeur doit être un entier négatif.",
+    "invalid-non-empty-string": "La valeur doit être une chaîne non vide.",
+    "invalid-non-negative-float": "La valeur doit être un nombre à virgule flottante égal ou supérieur à 0.",
+    "invalid-non-negative-int": "La valeur doit être un entier égal ou supérieur à 0.",
+    "invalid-non-positive-float": "La valeur doit être un nombre à virgule flottante égal ou inférieur à 0.",
+    "invalid-non-positive-int": "La valeur doit être un entier égal ou inférieur à 0.",
+    "invalid-object-id": "La valeur doit être un ObjectID MongoDB valide.",
+    "invalid-phone-number": "La valeur doit être un numéro de téléphone valide.",
+    "invalid-port": "La valeur doit être un numéro de port valide.",
+    "invalid-positive-float": "La valeur doit être un nombre flottant positif.",
+    "invalid-positive-int": "La valeur doit être un entier positif.",
+    "invalid-postal-code": "La valeur doit être un code postal valide.",
+    "invalid-rgb": "La valeur doit être un format de couleur RGB (Rouge, Vert, Bleu) valide.",
+    "invalid-rgba": "La valeur doit être un format de couleur RGBA (Rouge, Vert, Bleu, Alpha) valide.",
+    "invalid-sessn": "La valeur doit être un identifiant de session valide.",
+    "invalid-time": "La valeur doit être une heure valide au format HH:mm:ss.",
+    "invalid-timestamp": "La valeur doit être un horodatage valide.",
+    "invalid-url": "La valeur doit être une URL valide.",
+    "invalid-us-currency": "La valeur doit être un format de devise US valide.",
+    "invalid-utc-offset": "La valeur doit être un décalage UTC valide.",
+    "invalid-uuid": "La valeur doit être un UUID valide.",
+    "invalid-void": "La valeur doit être nulle ou non définie.",
+    min: "La valeur minimale pour le champ ''{path}''  doit être supérieure ou égale à {min}.",
+    max: "La valeur maximale pour le champ ''{path}''  doit être inférieure ou égale à {max}.",
+    "min-length": "La longueur minimale pour le champ {path} doit être d'au moins {minLength} caractères.",
+    "max-length": "La longueur maximale pour le champ ''{path}''  ne doit pas dépasser {maxLength} caractères.",
+    range: "La valeur pour le champ ''{path}''  doit être comprise entre {min} et {max}.",
+    size: "La longueur du champ ''{path}''  doit être comprise entre {min} et {max}.",
+    past: "La valeur pour le champ ''{path}''  doit être une date valide antérieure à {limit}.",
+    future: "La valeur pour le champ ''{path}''  doit être une date valide postérieure à {limit}.",
+    email: "La valeur pour le champ ''{path}''  doit être {numberOfDomains, plural, =0 {une adresse électronique valide} =1 {une adresse électronique dans le domaine ''{domains}'' } other {une adresse électronique dans l'un des domaines suivants : [{domains}]}.",
+    ip: "La valeur pour le champ ''{path}''  doit être une adresse IP valide.",
+    ipv4: "La valeur pour le champ ''{path}''  doit être une adresse IPv4 valide.",
+    ipv6: "La valeur pour le champ ''{path}''  doit être une adresse IPv6 valide.",
+    mac: "La valeur pour le champ ''{path}''  doit être une adresse MAC valide.",
+    url: "La valeur pour le champ ''{path}''  doit être {numberOfDomains, plural, =0 {une URL valide} =1 {une URL dans le domaine ''{domains}'' } other {une URL dans l'un des domaines suivants : [{domains}]}.",
+    uuid: "La valeur pour le champ ''{path}''  doit être un UUID valide.",
+    guid: "La valeur pour le champ ''{path}''  doit être un GUID valide.",
+    ssn: "La valeur pour le champ ''{path}''  doit être un numéro de sécurité social valide.",
+    phone: "La valeur pour le champ ''{path}''  doit être un numéro de téléphone valide.",
+    street: "La valeur pour le champ ''{path}''  doit être une adresse postale valide.",
+    "zip-code": "La valeur pour le champ ''{path}''  doit être un code postal valide.",
+    "object-id": "La valeur pour le champ ''{path}''  doit être une chaîne hexadécimale de 24 caractères.",
+    pattern: "Valeur invalide pour le champ ''{path}'' . La valeur doit correspondre au motif : ''{pattern}'' .",
+    "not-blank": "{length, plural, =0 {Le champ} other {Chaque élément du champ} ''{path}''  ne doit pas être vide.",
+    "not-empty": "{length, plural, =0 {Le champ} other {Chaque élément du champ} ''{path}''  ne doit pas être vide.",
+    positive: "La valeur pour le champ ''{path}''  doit être un nombre positif.",
+    negative: "La valeur pour le champ ''{path}''  doit être un nombre négatif.",
+    "no-scalars": "Type invalide : ''{type}''  n'est pas un type scalaire.",
+    "not-null": "La valeur pour le champ ''{path}''  ne doit pas être nulle.",
+    required: "La valeur pour le champ ''{path}''  est requise.",
+    time: "La valeur pour le champ ''{path}''  doit être une heure valide au format HH:mm."
+  }
+};
+// src/resources/fr/zod.json
+var zod_default2 = {
+  required: "Ce champ est requis.",
+  invalid_type: {
+    string: "Une chaîne de texte est attendue.",
+    number: "Un nombre est attendu.",
+    boolean: "Un booléen est attendu.",
+    object: "Un objet est attendu.",
+    array: "Une liste est attendue.",
+    bigint: "Un nombre entier très grand est attendu.",
+    date: "Une date valide est attendue.",
+    symbol: "Un symbole est attendu.",
+    undefined: "Cette valeur est manquante.",
+    null: "La valeur doit être nulle.",
+    function: "Une fonction est attendue.",
+    enum: "L’option choisie est invalide.",
+    default: "Type invalide."
+  },
+  invalid_value_single: "Cette valeur n’est pas autorisée.",
+  invalid_value_multiple: "Cette option n’est pas valide.",
+  too_big_inclusive: "Cette valeur est trop grande : elle doit être au maximum {maximum} {unit}.",
+  too_big_exclusive: "Cette valeur est trop grande : elle doit être inférieure à {maximum} {unit}.",
+  too_big_no_unit_inclusive: "Cette valeur est trop grande : elle doit être au maximum {maximum}.",
+  too_big_no_unit_exclusive: "Cette valeur est trop grande : elle doit être inférieure à {maximum}.",
+  too_small_inclusive: "Cette valeur est trop petite : elle doit être au minimum {minimum} {unit}.",
+  too_small_exclusive: "Cette valeur est trop petite : elle doit être supérieure à {minimum} {unit}.",
+  too_small_no_unit_inclusive: "Cette valeur est trop petite : elle doit être au minimum {minimum}.",
+  too_small_no_unit_exclusive: "Cette valeur est trop petite : elle doit être supérieure à {minimum}.",
+  invalid_format: {
+    starts_with: 'Le texte doit commencer par "{prefix}".',
+    ends_with: 'Le texte doit se terminer par "{suffix}".',
+    includes: 'Le texte doit contenir "{includes}".',
+    regex: "Ce format n’est pas valide.",
+    default: "{noun} invalide."
+  },
+  not_multiple_of: "Ce nombre doit être un multiple de {divisor}.",
+  unrecognized_keys_single: "Champ inconnu : {keys}.",
+  unrecognized_keys_multiple: "Champs inconnus : {keys}.",
+  invalid_key: "Ce champ n’est pas valide dans {origin}.",
+  invalid_union: "Cette valeur ne correspond à aucun des formats acceptés.",
+  invalid_element: "Ce champ contient une valeur invalide dans {origin}.",
+  default: "Cette valeur n’est pas valide.",
+  nouns: {
+    regex: "valeur",
+    email: "adresse e-mail",
+    url: "URL",
+    emoji: "emoji",
+    uuid: "UUID",
+    uuidv4: "UUIDv4",
+    uuidv6: "UUIDv6",
+    nanoid: "nanoid",
+    guid: "GUID",
+    cuid: "cuid",
+    cuid2: "cuid2",
+    ulid: "ULID",
+    xid: "XID",
+    ksuid: "KSUID",
+    datetime: "date et heure",
+    date: "date",
+    time: "heure",
+    duration: "durée",
+    ipv4: "adresse IPv4",
+    ipv6: "adresse IPv6",
+    mac: "adresse MAC",
+    cidrv4: "plage IPv4",
+    cidrv6: "plage IPv6",
+    base64: "chaîne base64",
+    base64url: "chaîne base64url",
+    json_string: "chaîne JSON",
+    e164: "numéro de téléphone",
+    jwt: "JWT",
+    template_literal: "valeur"
+  },
+  sizing: {
+    string: { unit: "caractères", verb: "contenir" },
+    file: { unit: "octets", verb: "contenir" },
+    array: { unit: "éléments", verb: "contenir" },
+    set: { unit: "éléments", verb: "contenir" }
+  }
+};
+
+// src/resources/fr/index.ts
+var fr = {
+  ...common_default2,
+  errors: errors_default2,
+  validation: validation_default2,
+  zod: zod_default2
+};
+
+// src/resources/index.ts
+var resources2 = {
+  en,
+  fr
+};
+
+// src/consts.ts
+var LANGUAGE_KEY2 = "language";
+var SUPPORTED_LANGUAGES2 = Object.keys(resources2);
+var FALLBACK_LANGUAGE2 = "en";
+
+// src/sources.ts
+var REGISTRY = Symbol.for("@nxgt/i18n/language-sources");
+function registry() {
+  const global = globalThis;
+  global[REGISTRY] ??= [];
+  return global[REGISTRY];
+}
+function registerLanguageSource2(source) {
+  const sources = registry();
+  if (!sources.includes(source))
+    sources.push(source);
+  return () => {
+    const index = sources.indexOf(source);
+    if (index !== -1)
+      sources.splice(index, 1);
+  };
+}
+function languageFromSources2() {
+  for (const source of registry()) {
+    let answer;
+    try {
+      answer = source();
+    } catch {
+      continue;
+    }
+    if (SUPPORTED_LANGUAGES2.includes(answer)) {
+      return answer;
+    }
+  }
+  return;
+}
+
+// src/i18n.ts
+import { IntlMessageFormat } from "intl-messageformat";
+import _ from "lodash";
+function getLanguage2() {
+  const fromSource = languageFromSources2();
+  if (fromSource !== undefined)
+    return fromSource;
+  if (typeof localStorage !== "undefined") {
+    const stored = localStorage.getItem(LANGUAGE_KEY2);
+    if (SUPPORTED_LANGUAGES2.includes(stored)) {
+      return stored;
+    }
+  }
+  return FALLBACK_LANGUAGE2;
+}
+function createTranslator2(resources = {}, localeProvider = getLanguage2) {
+  return (key, context = undefined, provideLanguage = localeProvider) => {
+    const language = typeof provideLanguage === "function" ? provideLanguage() : provideLanguage;
+    let message = _.get(resources[language], key) ?? key;
+    try {
+      message = new IntlMessageFormat(message, language).format(context);
+    } catch (e) {
+      console.error(e);
+    }
+    return message;
+  };
+}
+var translate2 = createTranslator2(resources2);
+export { resources2, LANGUAGE_KEY2, SUPPORTED_LANGUAGES2, FALLBACK_LANGUAGE2, registerLanguageSource2, languageFromSources2, getLanguage2, createTranslator2, translate2 };
+
+//# debugId=104509F5A9E2FCCE64756E2164756E21
+//# sourceMappingURL=index-vknxbeh1.js.map

package/dist/chunks/index-vknxbeh1.js.map

@@ -0,0 +1,15 @@
+{
+  "version": 3,
+  "sources": ["../src/resources/en/index.ts", "../src/resources/fr/index.ts", "../src/resources/index.ts", "../src/consts.ts", "../src/sources.ts", "../src/i18n.ts"],
+  "sourcesContent": [
+    "import common from './common.json';\nimport errors from './errors.json';\nimport validation from './validation.json';\nimport zod from './zod.json';\n\nexport const en = {\n\t...common,\n\terrors,\n\tvalidation,\n\tzod,\n};\n",
+    "import common from './common.json';\nimport errors from './errors.json';\nimport validation from './validation.json';\nimport zod from './zod.json';\n\nexport const fr = {\n\t...common,\n\terrors,\n\tvalidation,\n\tzod,\n};\n",
+    "import { en } from './en';\nimport { fr } from './fr';\n\nexport const resources = {\n\ten,\n\tfr,\n};\n",
+    "import { resources } from './resources';\nimport type { Language } from './types';\n\nexport const LANGUAGE_KEY = 'language';\n\nexport const SUPPORTED_LANGUAGES = Object.keys(resources) as Language[];\n\nexport const FALLBACK_LANGUAGE: Language = 'en';\n",
+    "import { SUPPORTED_LANGUAGES } from './consts';\nimport type { Language } from './types';\n\n/**\n * Where a language may come from: a server's request context, a framework's\n * state. It answers the request's language, or nothing — `undefined`, `null`,\n * a language no catalogue has — and the next source is asked.\n */\nexport type LanguageSource = () => string | null | undefined;\n\n/**\n * One registry for the process, on `globalThis`: an app can hold two copies\n * of this package — one a dependency of `@nxgt/shared-hono`, one its own —\n * and a source registered through either must answer both.\n */\nconst REGISTRY = Symbol.for('@nxgt/i18n/language-sources');\n\nfunction registry(): LanguageSource[] {\n\tconst global = globalThis as { [REGISTRY]?: LanguageSource[] };\n\tglobal[REGISTRY] ??= [];\n\treturn global[REGISTRY];\n}\n\n/**\n * Adds a source `getLanguage()` asks, after those registered before it.\n * Registering one twice keeps one. Answers the function that removes it.\n *\n * This package knows no server: `@nxgt/shared-hono` registers the Hono\n * request context's `language`, `@alxia/i18n` the alxia request's.\n */\nexport function registerLanguageSource(source: LanguageSource): () => void {\n\tconst sources = registry();\n\tif (!sources.includes(source)) sources.push(source);\n\treturn () => {\n\t\tconst index = sources.indexOf(source);\n\t\tif (index !== -1) sources.splice(index, 1);\n\t};\n}\n\n/**\n * The first supported language a registered source answers. A source that\n * throws is skipped: a language is never worth a failed request.\n */\nexport function languageFromSources(): Language | undefined {\n\tfor (const source of registry()) {\n\t\tlet answer: string | null | undefined;\n\t\ttry {\n\t\t\tanswer = source();\n\t\t} catch {\n\t\t\tcontinue;\n\t\t}\n\t\tif (SUPPORTED_LANGUAGES.includes(answer as Language)) {\n\t\t\treturn answer as Language;\n\t\t}\n\t}\n\treturn undefined;\n}\n",
+    "import { IntlMessageFormat } from 'intl-messageformat';\nimport _ from 'lodash';\nimport { FALLBACK_LANGUAGE, LANGUAGE_KEY, SUPPORTED_LANGUAGES } from './consts';\nimport { resources } from './resources';\nimport { languageFromSources } from './sources';\nimport type {\n\tLanguage,\n\tLanguageProvider,\n\tLocaleKey,\n\tTranslationContext,\n} from './types';\n\n/**\n * Where the language comes from when the caller does not say, most specific\n * first:\n *\n * 1. a registered source — `registerLanguageSource()`: a server's request\n *    context, which `@nxgt/shared-hono` registers for Hono and\n *    `@alxia/i18n` for alxia;\n * 2. `localStorage`, when that object exists;\n * 3. the fallback language.\n *\n * Until 2.0 this read Hono's request context itself, through\n * `hono/context-storage`, which tied every consumer — a browser bundle, an\n * alxia server — to Hono. The Hono part lives in `@nxgt/shared-hono` now.\n *\n * `createTranslator` still takes a provider, so a caller that wants one source\n * and not the others passes it.\n */\nexport function getLanguage(): Language {\n\tconst fromSource = languageFromSources();\n\tif (fromSource !== undefined) return fromSource;\n\tif (typeof localStorage !== 'undefined') {\n\t\tconst stored = localStorage.getItem(LANGUAGE_KEY);\n\t\tif (SUPPORTED_LANGUAGES.includes(stored as Language)) {\n\t\t\treturn stored as Language;\n\t\t}\n\t}\n\treturn FALLBACK_LANGUAGE;\n}\n\nexport function createTranslator<K extends string = LocaleKey>(\n\tresources: Record<string, any> = {},\n\tlocaleProvider: LanguageProvider = getLanguage,\n) {\n\treturn (\n\t\tkey: K,\n\t\tcontext: TranslationContext = undefined,\n\t\tprovideLanguage: LanguageProvider = localeProvider,\n\t): string => {\n\t\tconst language =\n\t\t\ttypeof provideLanguage === 'function'\n\t\t\t\t? provideLanguage()\n\t\t\t\t: provideLanguage;\n\t\tlet message: string = _.get(resources[language], key) ?? key;\n\t\ttry {\n\t\t\tmessage = new IntlMessageFormat(message, language).format(context);\n\t\t} catch (e) {\n\t\t\tconsole.error(e);\n\t\t}\n\n\t\treturn message;\n\t};\n}\n\nexport const translate = createTranslator(resources);\n"
+  ],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAKO,IAAM,KAAK;AAAA,KACd;AAAA,EACH;AAAA,EACA;AAAA,EACA;AACD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACLO,IAAM,KAAK;AAAA,KACd;AAAA,EACH;AAAA,EACA;AAAA,EACA;AACD;;;ACPO,IAAM,aAAY;AAAA,EACxB;AAAA,EACA;AACD;;;ACHO,IAAM,gBAAe;AAErB,IAAM,uBAAsB,OAAO,KAAK,UAAS;AAEjD,IAAM,qBAA8B;;;ACQ3C,IAAM,WAAW,OAAO,IAAI,6BAA6B;AAEzD,SAAS,QAAQ,GAAqB;AAAA,EACrC,MAAM,SAAS;AAAA,EACf,OAAO,cAAc,CAAC;AAAA,EACtB,OAAO,OAAO;AAAA;AAUR,SAAS,uBAAsB,CAAC,QAAoC;AAAA,EAC1E,MAAM,UAAU,SAAS;AAAA,EACzB,IAAI,CAAC,QAAQ,SAAS,MAAM;AAAA,IAAG,QAAQ,KAAK,MAAM;AAAA,EAClD,OAAO,MAAM;AAAA,IACZ,MAAM,QAAQ,QAAQ,QAAQ,MAAM;AAAA,IACpC,IAAI,UAAU;AAAA,MAAI,QAAQ,OAAO,OAAO,CAAC;AAAA;AAAA;AAQpC,SAAS,oBAAmB,GAAyB;AAAA,EAC3D,WAAW,UAAU,SAAS,GAAG;AAAA,IAChC,IAAI;AAAA,IACJ,IAAI;AAAA,MACH,SAAS,OAAO;AAAA,MACf,MAAM;AAAA,MACP;AAAA;AAAA,IAED,IAAI,qBAAoB,SAAS,MAAkB,GAAG;AAAA,MACrD,OAAO;AAAA,IACR;AAAA,EACD;AAAA,EACA;AAAA;;;ACvDD;AACA;AA4BO,SAAS,YAAW,GAAa;AAAA,EACvC,MAAM,aAAa,qBAAoB;AAAA,EACvC,IAAI,eAAe;AAAA,IAAW,OAAO;AAAA,EACrC,IAAI,OAAO,iBAAiB,aAAa;AAAA,IACxC,MAAM,SAAS,aAAa,QAAQ,aAAY;AAAA,IAChD,IAAI,qBAAoB,SAAS,MAAkB,GAAG;AAAA,MACrD,OAAO;AAAA,IACR;AAAA,EACD;AAAA,EACA,OAAO;AAAA;AAGD,SAAS,iBAA8C,CAC7D,YAAiC,CAAC,GAClC,iBAAmC,cAClC;AAAA,EACD,OAAO,CACN,KACA,UAA8B,WAC9B,kBAAoC,mBACxB;AAAA,IACZ,MAAM,WACL,OAAO,oBAAoB,aACxB,gBAAgB,IAChB;AAAA,IACJ,IAAI,UAAkB,EAAE,IAAI,UAAU,WAAW,GAAG,KAAK;AAAA,IACzD,IAAI;AAAA,MACH,UAAU,IAAI,kBAAkB,SAAS,QAAQ,EAAE,OAAO,OAAO;AAAA,MAChE,OAAO,GAAG;AAAA,MACX,QAAQ,MAAM,CAAC;AAAA;AAAA,IAGhB,OAAO;AAAA;AAAA;AAIF,IAAM,aAAY,kBAAiB,UAAS;",
+  "debugId": "104509F5A9E2FCCE64756E2164756E21",
+  "names": []
+}

package/dist/i18n.browser.d.ts

@@ -0,0 +1,9 @@
+/**
+ * The `browser` condition's build of `./i18n`. They were two files while
+ * `./i18n` imported `hono/context-storage`, which pulls in `node:async_hooks`;
+ * since 2.0 neither imports anything Node-only, and a browser registers its
+ * own language sources as a server does. The entry point stays, so a bundler
+ * that resolves the `browser` condition keeps resolving it.
+ */
+export * from './i18n';
+//# sourceMappingURL=i18n.browser.d.ts.map

package/dist/i18n.browser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"i18n.browser.d.ts","sourceRoot":"","sources":["../src/i18n.browser.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,cAAc,QAAQ,CAAC"}