@jarenjs/locales 0.34.0

package/src/de.js

@@ -0,0 +1,131 @@
+//@ts-check
+
+/**
+ * German (de) message catalog for @jarenjs/validate and @jarenjs/forms.
+ *
+ * A catalog is a plain flat object `{ [key]: closure | template string }`;
+ * compile it with `compileMessageCatalog` from either consumer package
+ * and hand it to `localizeErrors` (validate) or the `catalog` parameters
+ * of `validateField` / `evaluateFormRules` (forms). A pack imports only
+ * the shared rendering helpers; key parity with the built-in English
+ * catalogs is enforced by tests in the repo, not by imports.
+ *
+ * Globalization mechanics (the pack-authoring pattern - see
+ * packages/validate/docs/ERROR-MESSAGES.md):
+ * - `Intl.PluralRules` picks plural categories ("1 Eigenschaft" /
+ *   "2 Eigenschaften"; "Zeichen" is invariant and needs none),
+ * - `Intl.NumberFormat` renders numeric limits the German way,
+ * - `Intl.ListFormat` renders enum alternatives ("a, b oder c"),
+ * all held as module-level singletons (allocation discipline).
+ */
+
+import {
+  formatMessageValue,
+  makeNumberRenderer,
+  makePluralPicker,
+  makeTypeNamer,
+} from './helpers.js';
+
+//#region Intl singletons
+
+const pluralRules = new Intl.PluralRules('de');
+const numberFormat = new Intl.NumberFormat('de-DE');
+const listFormat = new Intl.ListFormat('de', { style: 'long', type: 'disjunction' });
+
+/** Pick the German singular or plural noun form for a count. */
+const plural = makePluralPicker(pluralRules);
+
+/**
+ * Render a numeric limit through the German number format; non-numbers
+ * (e.g. an unresolved $data pointer) render as-is.
+ */
+const num = makeNumberRenderer(numberFormat);
+
+/** German names (with article) for the JSON Schema type keyword values. */
+const TYPE_NAMES = {
+  string: 'eine Zeichenkette (string)',
+  number: 'eine Zahl',
+  integer: 'eine ganze Zahl',
+  boolean: 'ein boolescher Wert',
+  array: 'eine Liste (array)',
+  object: 'ein Objekt',
+  null: 'null',
+};
+
+/** Type keyword values under their German display name, article included. */
+const typeName = makeTypeNamer(TYPE_NAMES);
+
+//#endregion
+
+/**
+ * The German catalog. Covers every key of validate's `messagesEn`, every
+ * `form/*` key of forms' `formsMessagesEn`, `x-form/assert`, and the
+ * `JQ2xxx` codes reachable through `$query`.
+ * @type {Record<string, string | ((params: any, error?: object) => string)>}
+ */
+export const de = {
+  //#region @jarenjs/validate (document voice)
+  type: (p) => p.types
+    ? `muss einer der folgenden Typen sein: ${p.types.join(', ')}`
+    : `muss ${typeName(p.type)} sein`,
+  required: (p) => p.missingProperty
+    ? `muss die Pflichteigenschaft '${p.missingProperty}' enthalten`
+    : 'muss die Pflichteigenschaften enthalten',
+  minimum: (p) => `muss ${p.comparison} ${num(p.limit)} sein`,
+  maximum: (p) => `muss ${p.comparison} ${num(p.limit)} sein`,
+  exclusiveMinimum: (p) => `muss ${p.comparison} ${num(p.limit)} sein`,
+  exclusiveMaximum: (p) => `muss ${p.comparison} ${num(p.limit)} sein`,
+  multipleOf: (p) => `muss ein Vielfaches von ${num(p.multipleOf)} sein`,
+  minLength: (p) => `darf nicht weniger als ${num(p.limit)} Zeichen enthalten`,
+  maxLength: (p) => `darf nicht mehr als ${num(p.limit)} Zeichen enthalten`,
+  pattern: 'muss dem Muster "{pattern}" entsprechen',
+  additionalProperties: (p) => p.additionalProperty
+    ? `darf die zusätzliche Eigenschaft '${p.additionalProperty}' nicht enthalten`
+    : 'darf keine zusätzlichen Eigenschaften enthalten',
+  minProperties: (p) => `darf nicht weniger als ${num(p.limit)} ${plural(p.limit, 'Eigenschaft', 'Eigenschaften')} enthalten`,
+  maxProperties: (p) => `darf nicht mehr als ${num(p.limit)} ${plural(p.limit, 'Eigenschaft', 'Eigenschaften')} enthalten`,
+  minItems: (p) => `darf nicht weniger als ${num(p.limit)} ${plural(p.limit, 'Element', 'Elemente')} enthalten`,
+  maxItems: (p) => `darf nicht mehr als ${num(p.limit)} ${plural(p.limit, 'Element', 'Elemente')} enthalten`,
+  uniqueItems: 'darf keine doppelten Elemente enthalten',
+  contains: 'muss mindestens ein gültiges Element enthalten',
+  items: 'die Elemente der Liste sind ungültig',
+  allOf: 'muss allen Teilschemata entsprechen',
+  anyOf: 'muss einem Teilschema in anyOf entsprechen',
+  oneOf: 'muss genau einem Teilschema in oneOf entsprechen',
+  not: 'darf dem Teilschema NICHT entsprechen',
+  format: 'muss dem Format "{format}" entsprechen',
+  if: 'muss dem "if"-Schema entsprechen',
+  then: 'muss dem "then"-Schema entsprechen',
+  else: 'muss dem "else"-Schema entsprechen',
+  'false schema': 'das boolesche Schema false ist immer ungültig',
+  $query: (p) => p.code
+    ? `die '$query'-Assertion meldete ${p.code} bei '${p.docPath}'`
+    : "muss die '$query'-Assertion erfüllen",
+  JQ2001: (p) => `die '$query'-Assertion konnte nicht ausgewertet werden (${p.code} bei '${p.docPath}')`,
+  JQ2003: (p) => `die '$query'-Assertion lieferte mehrere Ergebnisse (${p.code} bei '${p.docPath}')`,
+  //#endregion
+
+  //#region @jarenjs/forms (second-person field voice)
+  'form/required': 'Dieses Feld ist erforderlich',
+  'form/type': (p) => `Muss ${typeName(p.type)} sein`,
+  'form/const': (p) => `Muss ${formatMessageValue(p.constValue)} sein`,
+  'form/enum': (p) => `Muss ${Array.isArray(p.enumValues) ? listFormat.format(p.enumValues.map(formatMessageValue)) : formatMessageValue(p.enumValues)} sein`,
+  'form/minLength': (p) => `Muss mindestens ${num(p.limit)} Zeichen enthalten (derzeit ${num(p.len)})`,
+  'form/maxLength': (p) => `Darf höchstens ${num(p.limit)} Zeichen enthalten (derzeit ${num(p.len)})`,
+  'form/pattern': 'Muss dem Muster {pattern} entsprechen',
+  'form/format': (p) => `Muss dem Format ${p.format} entsprechen`,
+  'form/minimum': (p) => `Muss mindestens ${num(p.limit)} sein`,
+  'form/maximum': (p) => `Darf höchstens ${num(p.limit)} sein`,
+  'form/exclusiveMinimum': (p) => `Muss größer als ${num(p.limit)} sein`,
+  'form/exclusiveMaximum': (p) => `Muss kleiner als ${num(p.limit)} sein`,
+  'form/multipleOf': (p) => `Muss ein Vielfaches von ${num(p.multipleOf)} sein`,
+  'form/minItems': (p) => `Muss mindestens ${num(p.limit)} ${plural(p.limit, 'Element', 'Elemente')} enthalten`,
+  'form/maxItems': (p) => `Darf höchstens ${num(p.limit)} ${plural(p.limit, 'Element', 'Elemente')} enthalten`,
+  'form/uniqueItems': 'Die Elemente müssen eindeutig sein',
+  'form/minProperties': (p) => `Muss mindestens ${num(p.limit)} ${plural(p.limit, 'Eigenschaft', 'Eigenschaften')} enthalten`,
+  'form/maxProperties': (p) => `Darf höchstens ${num(p.limit)} ${plural(p.limit, 'Eigenschaft', 'Eigenschaften')} enthalten`,
+  'x-form/assert': 'Ungültiger Wert',
+  'form/addItem': 'Element hinzufügen',
+  'form/removeItem': 'Element entfernen',
+  //#endregion
+};

package/src/es.js

@@ -0,0 +1,131 @@
+//@ts-check
+
+/**
+ * Spanish (es) message catalog for @jarenjs/validate and @jarenjs/forms.
+ *
+ * A catalog is a plain flat object `{ [key]: closure | template string }`;
+ * compile it with `compileMessageCatalog` from either consumer package
+ * and hand it to `localizeErrors` (validate) or the `catalog` parameters
+ * of `validateField` / `evaluateFormRules` (forms). A pack imports only
+ * the shared rendering helpers; key parity with the built-in English
+ * catalogs is enforced by tests in the repo, not by imports.
+ *
+ * Globalization mechanics (the pack-authoring pattern - see
+ * packages/validate/docs/ERROR-MESSAGES.md):
+ * - `Intl.PluralRules` picks plural categories, and the singular of
+ *   "caracteres" shifts its accent ("1 carácter" / "2 caracteres"),
+ * - `Intl.NumberFormat` renders numeric limits the Spanish way,
+ * - `Intl.ListFormat` renders enum alternatives ("a, b o c"),
+ * all held as module-level singletons (allocation discipline).
+ */
+
+import {
+  formatMessageValue,
+  makeNumberRenderer,
+  makePluralPicker,
+  makeTypeNamer,
+} from './helpers.js';
+
+//#region Intl singletons
+
+const pluralRules = new Intl.PluralRules('es');
+const numberFormat = new Intl.NumberFormat('es-ES');
+const listFormat = new Intl.ListFormat('es', { style: 'long', type: 'disjunction' });
+
+/** Pick the Spanish singular or plural noun form for a count. */
+const plural = makePluralPicker(pluralRules);
+
+/**
+ * Render a numeric limit through the Spanish number format; non-numbers
+ * (e.g. an unresolved $data pointer) render as-is.
+ */
+const num = makeNumberRenderer(numberFormat);
+
+/** Spanish names (with article) for the JSON Schema type keyword values. */
+const TYPE_NAMES = {
+  string: 'una cadena (string)',
+  number: 'un número',
+  integer: 'un número entero',
+  boolean: 'un booleano',
+  array: 'una lista (array)',
+  object: 'un objeto',
+  null: 'null',
+};
+
+/** Type keyword values under their Spanish display name, article included. */
+const typeName = makeTypeNamer(TYPE_NAMES);
+
+//#endregion
+
+/**
+ * The Spanish catalog. Covers every key of validate's `messagesEn`, every
+ * `form/*` key of forms' `formsMessagesEn`, `x-form/assert`, and the
+ * `JQ2xxx` codes reachable through `$query`.
+ * @type {Record<string, string | ((params: any, error?: object) => string)>}
+ */
+export const es = {
+  //#region @jarenjs/validate (document voice)
+  type: (p) => p.types
+    ? `debe ser uno de los siguientes tipos: ${p.types.join(', ')}`
+    : `debe ser ${typeName(p.type)}`,
+  required: (p) => p.missingProperty
+    ? `debe tener la propiedad obligatoria '${p.missingProperty}'`
+    : 'debe tener las propiedades obligatorias',
+  minimum: (p) => `debe ser ${p.comparison} ${num(p.limit)}`,
+  maximum: (p) => `debe ser ${p.comparison} ${num(p.limit)}`,
+  exclusiveMinimum: (p) => `debe ser ${p.comparison} ${num(p.limit)}`,
+  exclusiveMaximum: (p) => `debe ser ${p.comparison} ${num(p.limit)}`,
+  multipleOf: (p) => `debe ser un múltiplo de ${num(p.multipleOf)}`,
+  minLength: (p) => `no debe tener menos de ${num(p.limit)} ${plural(p.limit, 'carácter', 'caracteres')}`,
+  maxLength: (p) => `no debe tener más de ${num(p.limit)} ${plural(p.limit, 'carácter', 'caracteres')}`,
+  pattern: 'debe coincidir con el patrón "{pattern}"',
+  additionalProperties: (p) => p.additionalProperty
+    ? `no debe tener la propiedad adicional '${p.additionalProperty}'`
+    : 'no debe tener propiedades adicionales',
+  minProperties: (p) => `no debe tener menos de ${num(p.limit)} ${plural(p.limit, 'propiedad', 'propiedades')}`,
+  maxProperties: (p) => `no debe tener más de ${num(p.limit)} ${plural(p.limit, 'propiedad', 'propiedades')}`,
+  minItems: (p) => `no debe tener menos de ${num(p.limit)} ${plural(p.limit, 'elemento', 'elementos')}`,
+  maxItems: (p) => `no debe tener más de ${num(p.limit)} ${plural(p.limit, 'elemento', 'elementos')}`,
+  uniqueItems: 'no debe tener elementos duplicados',
+  contains: 'debe contener al menos un elemento válido',
+  items: 'los elementos de la lista no son válidos',
+  allOf: 'debe cumplir todos los subesquemas',
+  anyOf: 'debe cumplir un subesquema de anyOf',
+  oneOf: 'debe cumplir exactamente un subesquema de oneOf',
+  not: 'NO debe cumplir el subesquema',
+  format: 'debe coincidir con el formato "{format}"',
+  if: 'debe cumplir el esquema "if"',
+  then: 'debe cumplir el esquema "then"',
+  else: 'debe cumplir el esquema "else"',
+  'false schema': 'el esquema booleano false siempre es inválido',
+  $query: (p) => p.code
+    ? `la aserción '$query' produjo ${p.code} en '${p.docPath}'`
+    : "debe cumplir la aserción '$query'",
+  JQ2001: (p) => `la aserción '$query' no se pudo evaluar (${p.code} en '${p.docPath}')`,
+  JQ2003: (p) => `la aserción '$query' produjo varios resultados (${p.code} en '${p.docPath}')`,
+  //#endregion
+
+  //#region @jarenjs/forms (second-person field voice)
+  'form/required': 'Este campo es obligatorio',
+  'form/type': (p) => `Debe ser ${typeName(p.type)}`,
+  'form/const': (p) => `Debe ser ${formatMessageValue(p.constValue)}`,
+  'form/enum': (p) => `Debe ser ${Array.isArray(p.enumValues) ? listFormat.format(p.enumValues.map(formatMessageValue)) : formatMessageValue(p.enumValues)}`,
+  'form/minLength': (p) => `Debe tener al menos ${num(p.limit)} ${plural(p.limit, 'carácter', 'caracteres')} (actualmente ${num(p.len)})`,
+  'form/maxLength': (p) => `Debe tener como máximo ${num(p.limit)} ${plural(p.limit, 'carácter', 'caracteres')} (actualmente ${num(p.len)})`,
+  'form/pattern': 'Debe coincidir con el patrón {pattern}',
+  'form/format': (p) => `Debe cumplir el formato ${p.format}`,
+  'form/minimum': (p) => `Debe ser al menos ${num(p.limit)}`,
+  'form/maximum': (p) => `Debe ser como máximo ${num(p.limit)}`,
+  'form/exclusiveMinimum': (p) => `Debe ser mayor que ${num(p.limit)}`,
+  'form/exclusiveMaximum': (p) => `Debe ser menor que ${num(p.limit)}`,
+  'form/multipleOf': (p) => `Debe ser un múltiplo de ${num(p.multipleOf)}`,
+  'form/minItems': (p) => `Debe tener al menos ${num(p.limit)} ${plural(p.limit, 'elemento', 'elementos')}`,
+  'form/maxItems': (p) => `Debe tener como máximo ${num(p.limit)} ${plural(p.limit, 'elemento', 'elementos')}`,
+  'form/uniqueItems': 'Los elementos deben ser únicos',
+  'form/minProperties': (p) => `Debe tener al menos ${num(p.limit)} ${plural(p.limit, 'propiedad', 'propiedades')}`,
+  'form/maxProperties': (p) => `Debe tener como máximo ${num(p.limit)} ${plural(p.limit, 'propiedad', 'propiedades')}`,
+  'x-form/assert': 'Valor no válido',
+  'form/addItem': 'Añadir elemento',
+  'form/removeItem': 'Eliminar elemento',
+  //#endregion
+};

package/src/fr.js

@@ -0,0 +1,131 @@
+//@ts-check
+
+/**
+ * French (fr) message catalog for @jarenjs/validate and @jarenjs/forms.
+ *
+ * A catalog is a plain flat object `{ [key]: closure | template string }`;
+ * compile it with `compileMessageCatalog` from either consumer package
+ * and hand it to `localizeErrors` (validate) or the `catalog` parameters
+ * of `validateField` / `evaluateFormRules` (forms). A pack imports only
+ * the shared rendering helpers; key parity with the built-in English
+ * catalogs is enforced by tests in the repo, not by imports.
+ *
+ * Globalization mechanics (the pack-authoring pattern - see
+ * packages/validate/docs/ERROR-MESSAGES.md):
+ * - `Intl.PluralRules` picks plural categories (French counts 0 and 1
+ *   as singular: "0 caractère" / "2 caractères"),
+ * - `Intl.NumberFormat` renders numeric limits the French way,
+ * - `Intl.ListFormat` renders enum alternatives ("a, b ou c"),
+ * all held as module-level singletons (allocation discipline).
+ */
+
+import {
+  formatMessageValue,
+  makeNumberRenderer,
+  makePluralPicker,
+  makeTypeNamer,
+} from './helpers.js';
+
+//#region Intl singletons
+
+const pluralRules = new Intl.PluralRules('fr');
+const numberFormat = new Intl.NumberFormat('fr-FR');
+const listFormat = new Intl.ListFormat('fr', { style: 'long', type: 'disjunction' });
+
+/** Pick the French singular or plural noun form for a count. */
+const plural = makePluralPicker(pluralRules);
+
+/**
+ * Render a numeric limit through the French number format; non-numbers
+ * (e.g. an unresolved $data pointer) render as-is.
+ */
+const num = makeNumberRenderer(numberFormat);
+
+/** French names (with article) for the JSON Schema type keyword values. */
+const TYPE_NAMES = {
+  string: 'une chaîne (string)',
+  number: 'un nombre',
+  integer: 'un nombre entier',
+  boolean: 'un booléen',
+  array: 'une liste (array)',
+  object: 'un objet',
+  null: 'null',
+};
+
+/** Type keyword values under their French display name, article included. */
+const typeName = makeTypeNamer(TYPE_NAMES);
+
+//#endregion
+
+/**
+ * The French catalog. Covers every key of validate's `messagesEn`, every
+ * `form/*` key of forms' `formsMessagesEn`, `x-form/assert`, and the
+ * `JQ2xxx` codes reachable through `$query`.
+ * @type {Record<string, string | ((params: any, error?: object) => string)>}
+ */
+export const fr = {
+  //#region @jarenjs/validate (document voice)
+  type: (p) => p.types
+    ? `doit être l'un des types suivants : ${p.types.join(', ')}`
+    : `doit être ${typeName(p.type)}`,
+  required: (p) => p.missingProperty
+    ? `doit contenir la propriété obligatoire '${p.missingProperty}'`
+    : 'doit contenir les propriétés obligatoires',
+  minimum: (p) => `doit être ${p.comparison} ${num(p.limit)}`,
+  maximum: (p) => `doit être ${p.comparison} ${num(p.limit)}`,
+  exclusiveMinimum: (p) => `doit être ${p.comparison} ${num(p.limit)}`,
+  exclusiveMaximum: (p) => `doit être ${p.comparison} ${num(p.limit)}`,
+  multipleOf: (p) => `doit être un multiple de ${num(p.multipleOf)}`,
+  minLength: (p) => `ne doit pas contenir moins de ${num(p.limit)} ${plural(p.limit, 'caractère', 'caractères')}`,
+  maxLength: (p) => `ne doit pas contenir plus de ${num(p.limit)} ${plural(p.limit, 'caractère', 'caractères')}`,
+  pattern: 'doit correspondre au motif "{pattern}"',
+  additionalProperties: (p) => p.additionalProperty
+    ? `ne doit pas contenir la propriété supplémentaire '${p.additionalProperty}'`
+    : 'ne doit pas contenir de propriétés supplémentaires',
+  minProperties: (p) => `ne doit pas contenir moins de ${num(p.limit)} ${plural(p.limit, 'propriété', 'propriétés')}`,
+  maxProperties: (p) => `ne doit pas contenir plus de ${num(p.limit)} ${plural(p.limit, 'propriété', 'propriétés')}`,
+  minItems: (p) => `ne doit pas contenir moins de ${num(p.limit)} ${plural(p.limit, 'élément', 'éléments')}`,
+  maxItems: (p) => `ne doit pas contenir plus de ${num(p.limit)} ${plural(p.limit, 'élément', 'éléments')}`,
+  uniqueItems: "ne doit pas contenir d'éléments en double",
+  contains: 'doit contenir au moins un élément valide',
+  items: 'les éléments de la liste sont invalides',
+  allOf: 'doit satisfaire tous les sous-schémas',
+  anyOf: 'doit satisfaire un sous-schéma de anyOf',
+  oneOf: 'doit satisfaire exactement un sous-schéma de oneOf',
+  not: 'ne doit PAS satisfaire le sous-schéma',
+  format: 'doit correspondre au format "{format}"',
+  if: 'doit satisfaire le schéma "if"',
+  then: 'doit satisfaire le schéma "then"',
+  else: 'doit satisfaire le schéma "else"',
+  'false schema': 'le schéma booléen false est toujours invalide',
+  $query: (p) => p.code
+    ? `l'assertion '$query' a levé ${p.code} à '${p.docPath}'`
+    : "doit satisfaire l'assertion '$query'",
+  JQ2001: (p) => `l'assertion '$query' n'a pas pu être évaluée (${p.code} à '${p.docPath}')`,
+  JQ2003: (p) => `l'assertion '$query' a produit plusieurs résultats (${p.code} à '${p.docPath}')`,
+  //#endregion
+
+  //#region @jarenjs/forms (second-person field voice)
+  'form/required': 'Ce champ est obligatoire',
+  'form/type': (p) => `Doit être ${typeName(p.type)}`,
+  'form/const': (p) => `Doit être ${formatMessageValue(p.constValue)}`,
+  'form/enum': (p) => `Doit être ${Array.isArray(p.enumValues) ? listFormat.format(p.enumValues.map(formatMessageValue)) : formatMessageValue(p.enumValues)}`,
+  'form/minLength': (p) => `Doit contenir au moins ${num(p.limit)} ${plural(p.limit, 'caractère', 'caractères')} (actuellement ${num(p.len)})`,
+  'form/maxLength': (p) => `Doit contenir au plus ${num(p.limit)} ${plural(p.limit, 'caractère', 'caractères')} (actuellement ${num(p.len)})`,
+  'form/pattern': 'Doit correspondre au motif {pattern}',
+  'form/format': (p) => `Doit respecter le format ${p.format}`,
+  'form/minimum': (p) => `Doit être au moins ${num(p.limit)}`,
+  'form/maximum': (p) => `Doit être au plus ${num(p.limit)}`,
+  'form/exclusiveMinimum': (p) => `Doit être supérieur à ${num(p.limit)}`,
+  'form/exclusiveMaximum': (p) => `Doit être inférieur à ${num(p.limit)}`,
+  'form/multipleOf': (p) => `Doit être un multiple de ${num(p.multipleOf)}`,
+  'form/minItems': (p) => `Doit contenir au moins ${num(p.limit)} ${plural(p.limit, 'élément', 'éléments')}`,
+  'form/maxItems': (p) => `Doit contenir au plus ${num(p.limit)} ${plural(p.limit, 'élément', 'éléments')}`,
+  'form/uniqueItems': 'Les éléments doivent être uniques',
+  'form/minProperties': (p) => `Doit contenir au moins ${num(p.limit)} ${plural(p.limit, 'propriété', 'propriétés')}`,
+  'form/maxProperties': (p) => `Doit contenir au plus ${num(p.limit)} ${plural(p.limit, 'propriété', 'propriétés')}`,
+  'x-form/assert': 'Valeur invalide',
+  'form/addItem': 'Ajouter un élément',
+  "form/removeItem": "Supprimer l'élément",
+  //#endregion
+};

package/src/helpers.js

@@ -0,0 +1,59 @@
+//@ts-check
+
+/**
+ * The pack-authoring toolkit: the rendering steps every locale pack
+ * performs identically, parameterised by the one thing that is actually
+ * per-language.
+ *
+ * Each factory takes a pack's own `Intl` singleton or translated table
+ * and returns the render closure the catalog entries call. Building the
+ * closure once at module load keeps the packs' allocation discipline:
+ * nothing is constructed per message. This module is internal to
+ * `@jarenjs/locales` - packs import it, consumers never see it.
+ */
+
+export { formatMessageValue } from '@jarenjs/core/message';
+
+/**
+ * Build a numeric-limit renderer over a pack's number format. Values
+ * that are not numbers (e.g. an unresolved $data pointer) render as-is,
+ * so a limit is always readable even when it never resolved.
+ *
+ * @param {Intl.NumberFormat} numberFormat - The pack's number format
+ * @returns {(value: unknown) => string} The limit renderer
+ */
+export function makeNumberRenderer(numberFormat) {
+  return function renderNumber(value) {
+    return typeof value === 'number' ? numberFormat.format(value) : String(value);
+  };
+}
+
+/**
+ * Build a two-form noun picker over a pack's plural rules: the count's
+ * CLDR category selects the `one` form, everything else the `other`
+ * form. Only for languages whose counted messages need exactly two
+ * forms - a pack that needs more categories, or that avoids agreement
+ * altogether by phrasing around a fixed noun, does not use this.
+ *
+ * @param {Intl.PluralRules} pluralRules - The pack's plural rules
+ * @returns {(count: number, one: string, other: string) => string} The form picker
+ */
+export function makePluralPicker(pluralRules) {
+  return function pickPluralForm(count, one, other) {
+    return pluralRules.select(count) === 'one' ? one : other;
+  };
+}
+
+/**
+ * Build a type-name renderer over a pack's translated table. An
+ * unlisted type (a custom or future keyword value) renders under its
+ * JSON Schema name rather than disappearing.
+ *
+ * @param {Record<string, string>} typeNames - The pack's translated type names
+ * @returns {(type: string) => string} The type-name renderer
+ */
+export function makeTypeNamer(typeNames) {
+  return function renderTypeName(type) {
+    return typeNames[type] ?? type;
+  };
+}

package/src/index.js

@@ -0,0 +1,26 @@
+//@ts-check
+
+/**
+ * @jarenjs/locales - locale packs (message catalogs) for the error
+ * messages of @jarenjs/validate and @jarenjs/forms.
+ *
+ * Each pack is a plain flat object of message-key -> closure/template
+ * entries (the catalog contract of
+ * packages/validate/docs/ERROR-MESSAGES.md); compile them with
+ * `compileMessageCatalog` from the consuming package. A pack holds its
+ * own translations and `Intl` singletons, and imports nothing but the
+ * rendering helpers of `./helpers.js` - never a consumer package, so
+ * either consumer can serve any pack.
+ */
+
+export { ar } from './ar.js';
+export { de } from './de.js';
+export { es } from './es.js';
+export { fr } from './fr.js';
+export { ja } from './ja.js';
+export { ko } from './ko.js';
+export { nl } from './nl.js';
+export { pt } from './pt.js';
+export { ru } from './ru.js';
+export { tr } from './tr.js';
+export { zhTW } from './zh-tw.js';

package/src/ja.js

@@ -0,0 +1,126 @@
+//@ts-check
+
+/**
+ * Japanese (ja) message catalog for @jarenjs/validate and @jarenjs/forms.
+ *
+ * A catalog is a plain flat object `{ [key]: closure | template string }`;
+ * compile it with `compileMessageCatalog` from either consumer package
+ * and hand it to `localizeErrors` (validate) or the `catalog` parameters
+ * of `validateField` / `evaluateFormRules` (forms). A pack imports only
+ * the shared rendering helpers; key parity with the built-in English
+ * catalogs is enforced by tests in the repo, not by imports.
+ *
+ * Globalization mechanics (the pack-authoring pattern - see
+ * packages/validate/docs/ERROR-MESSAGES.md):
+ * - Japanese has no grammatical plural, so there is no plural helper
+ *   here; counts read through counters ("2 文字", "3 個"),
+ * - `Intl.NumberFormat` renders numeric limits the Japanese way,
+ * - `Intl.ListFormat` renders enum alternatives ("a、b、または c"),
+ * all held as module-level singletons (allocation discipline).
+ */
+
+import {
+  formatMessageValue,
+  makeNumberRenderer,
+  makeTypeNamer,
+} from './helpers.js';
+
+//#region Intl singletons
+
+const numberFormat = new Intl.NumberFormat('ja-JP');
+const listFormat = new Intl.ListFormat('ja', { style: 'long', type: 'disjunction' });
+
+/**
+ * Render a numeric limit through the Japanese number format; non-numbers
+ * (e.g. an unresolved $data pointer) render as-is.
+ */
+const num = makeNumberRenderer(numberFormat);
+
+/** Japanese names for the JSON Schema type keyword values. */
+const TYPE_NAMES = {
+  string: '文字列 (string)',
+  number: '数値',
+  integer: '整数',
+  boolean: '真偽値',
+  array: '配列 (array)',
+  object: 'オブジェクト',
+  null: 'null',
+};
+
+/** Type keyword values under their Japanese display name. */
+const typeName = makeTypeNamer(TYPE_NAMES);
+
+//#endregion
+
+/**
+ * The Japanese catalog. Covers every key of validate's `messagesEn`,
+ * every `form/*` key of forms' `formsMessagesEn`, `x-form/assert`, and
+ * the `JQ2xxx` codes reachable through `$query`.
+ * @type {Record<string, string | ((params: any, error?: object) => string)>}
+ */
+export const ja = {
+  //#region @jarenjs/validate (document voice)
+  type: (p) => p.types
+    ? `次のいずれかの型でなければなりません: ${p.types.join(', ')}`
+    : `${typeName(p.type)}でなければなりません`,
+  required: (p) => p.missingProperty
+    ? `必須プロパティ '${p.missingProperty}' が必要です`
+    : '必須プロパティが必要です',
+  minimum: (p) => `${p.comparison} ${num(p.limit)} でなければなりません`,
+  maximum: (p) => `${p.comparison} ${num(p.limit)} でなければなりません`,
+  exclusiveMinimum: (p) => `${p.comparison} ${num(p.limit)} でなければなりません`,
+  exclusiveMaximum: (p) => `${p.comparison} ${num(p.limit)} でなければなりません`,
+  multipleOf: (p) => `${num(p.multipleOf)} の倍数でなければなりません`,
+  minLength: (p) => `${num(p.limit)} 文字以上でなければなりません`,
+  maxLength: (p) => `${num(p.limit)} 文字以下でなければなりません`,
+  pattern: 'パターン "{pattern}" に一致しなければなりません',
+  additionalProperties: (p) => p.additionalProperty
+    ? `追加のプロパティ '${p.additionalProperty}' は使用できません`
+    : '追加のプロパティは使用できません',
+  minProperties: (p) => `プロパティは ${num(p.limit)} 個以上でなければなりません`,
+  maxProperties: (p) => `プロパティは ${num(p.limit)} 個以下でなければなりません`,
+  minItems: (p) => `項目は ${num(p.limit)} 個以上でなければなりません`,
+  maxItems: (p) => `項目は ${num(p.limit)} 個以下でなければなりません`,
+  uniqueItems: '重複する項目は使用できません',
+  contains: '有効な項目を少なくとも 1 つ含まなければなりません',
+  items: '配列の項目が無効です',
+  allOf: 'すべてのサブスキーマに一致しなければなりません',
+  anyOf: 'anyOf のいずれかのサブスキーマに一致しなければなりません',
+  oneOf: 'oneOf のちょうど 1 つのサブスキーマに一致しなければなりません',
+  not: 'サブスキーマに一致してはいけません',
+  format: '形式 "{format}" に一致しなければなりません',
+  if: '"if" スキーマに一致しなければなりません',
+  then: '"then" スキーマに一致しなければなりません',
+  else: '"else" スキーマに一致しなければなりません',
+  'false schema': 'ブールスキーマ false は常に無効です',
+  $query: (p) => p.code
+    ? `'$query' アサーションが '${p.docPath}' で ${p.code} を発生させました`
+    : "'$query' アサーションを満たさなければなりません",
+  JQ2001: (p) => `'$query' アサーションを評価できませんでした（'${p.docPath}' で ${p.code}）`,
+  JQ2003: (p) => `'$query' アサーションが複数の結果を返しました（'${p.docPath}' で ${p.code}）`,
+  //#endregion
+
+  //#region @jarenjs/forms (second-person field voice)
+  'form/required': 'この項目は必須です',
+  'form/type': (p) => `${typeName(p.type)}でなければなりません`,
+  'form/const': (p) => `${formatMessageValue(p.constValue)} でなければなりません`,
+  'form/enum': (p) => `${Array.isArray(p.enumValues) ? listFormat.format(p.enumValues.map(formatMessageValue)) : formatMessageValue(p.enumValues)} のいずれかでなければなりません`,
+  'form/minLength': (p) => `${num(p.limit)} 文字以上で入力してください（現在 ${num(p.len)} 文字）`,
+  'form/maxLength': (p) => `${num(p.limit)} 文字以下で入力してください（現在 ${num(p.len)} 文字）`,
+  'form/pattern': 'パターン {pattern} に一致しなければなりません',
+  'form/format': (p) => `有効な ${p.format} 形式で入力してください`,
+  'form/minimum': (p) => `${num(p.limit)} 以上でなければなりません`,
+  'form/maximum': (p) => `${num(p.limit)} 以下でなければなりません`,
+  'form/exclusiveMinimum': (p) => `${num(p.limit)} より大きくなければなりません`,
+  'form/exclusiveMaximum': (p) => `${num(p.limit)} より小さくなければなりません`,
+  'form/multipleOf': (p) => `${num(p.multipleOf)} の倍数でなければなりません`,
+  'form/minItems': (p) => `項目は ${num(p.limit)} 個以上必要です`,
+  'form/maxItems': (p) => `項目は ${num(p.limit)} 個以下にしてください`,
+  'form/uniqueItems': '項目は一意でなければなりません',
+  'form/minProperties': (p) => `プロパティは ${num(p.limit)} 個以上必要です`,
+  'form/maxProperties': (p) => `プロパティは ${num(p.limit)} 個以下にしてください`,
+  'x-form/assert': '無効な値です',
+  'form/addItem': '項目を追加',
+  'form/removeItem': '項目を削除',
+  //#endregion
+};