@jarenjs/locales 0.34.0

package/src/ko.js

@@ -0,0 +1,129 @@
+//@ts-check
+
+/**
+ * Korean (ko) 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):
+ * - Korean has no grammatical plural, so there is no plural helper here;
+ *   counts read through counters ("2자", "3개"). Where a subject particle
+ *   would depend on the final consonant of interpolated text, the
+ *   messages either hedge ("이(가)") or attach the particle to a fixed
+ *   noun instead - the standard software-string conventions,
+ * - `Intl.NumberFormat` renders numeric limits the Korean 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('ko-KR');
+const listFormat = new Intl.ListFormat('ko', { style: 'long', type: 'disjunction' });
+
+/**
+ * Render a numeric limit through the Korean number format; non-numbers
+ * (e.g. an unresolved $data pointer) render as-is.
+ */
+const num = makeNumberRenderer(numberFormat);
+
+/** Korean 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 Korean display name. */
+const typeName = makeTypeNamer(TYPE_NAMES);
+
+//#endregion
+
+/**
+ * The Korean 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 ko = {
+  //#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: '유효한 항목을 하나 이상 포함해야 합니다',
+  items: '배열의 항목이 유효하지 않습니다',
+  allOf: '모든 하위 스키마와 일치해야 합니다',
+  anyOf: 'anyOf의 하위 스키마 중 하나와 일치해야 합니다',
+  oneOf: 'oneOf의 하위 스키마 중 정확히 하나와 일치해야 합니다',
+  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
+};

package/src/nl.js

@@ -0,0 +1,130 @@
+//@ts-check
+
+/**
+ * Dutch (nl) 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 teken" / "2 tekens"),
+ * - `Intl.NumberFormat` renders numeric limits the Dutch way,
+ * - `Intl.ListFormat` renders enum alternatives ("a, b of 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('nl');
+const numberFormat = new Intl.NumberFormat('nl-NL');
+const listFormat = new Intl.ListFormat('nl', { style: 'long', type: 'disjunction' });
+
+/** Pick the Dutch singular or plural noun form for a count. */
+const plural = makePluralPicker(pluralRules);
+
+/**
+ * Render a numeric limit through the Dutch number format; non-numbers
+ * (e.g. an unresolved $data pointer) render as-is.
+ */
+const num = makeNumberRenderer(numberFormat);
+
+/** Dutch names for the JSON Schema type keyword values. */
+const TYPE_NAMES = {
+  string: 'tekst (string)',
+  number: 'getal',
+  integer: 'geheel getal',
+  boolean: 'boolean',
+  array: 'lijst (array)',
+  object: 'object',
+  null: 'null',
+};
+
+/** Type keyword values under their Dutch display name. */
+const typeName = makeTypeNamer(TYPE_NAMES);
+
+//#endregion
+
+/**
+ * The Dutch 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 nl = {
+  //#region @jarenjs/validate (document voice)
+  type: (p) => p.types
+    ? `moet een van de volgende typen zijn: ${p.types.join(', ')}`
+    : `moet een ${typeName(p.type)} zijn`,
+  required: (p) => p.missingProperty
+    ? `moet de verplichte eigenschap '${p.missingProperty}' bevatten`
+    : 'moet de verplichte eigenschappen bevatten',
+  minimum: (p) => `moet ${p.comparison} ${num(p.limit)} zijn`,
+  maximum: (p) => `moet ${p.comparison} ${num(p.limit)} zijn`,
+  exclusiveMinimum: (p) => `moet ${p.comparison} ${num(p.limit)} zijn`,
+  exclusiveMaximum: (p) => `moet ${p.comparison} ${num(p.limit)} zijn`,
+  multipleOf: (p) => `moet een veelvoud van ${num(p.multipleOf)} zijn`,
+  minLength: (p) => `mag niet minder dan ${num(p.limit)} ${plural(p.limit, 'teken', 'tekens')} bevatten`,
+  maxLength: (p) => `mag niet meer dan ${num(p.limit)} ${plural(p.limit, 'teken', 'tekens')} bevatten`,
+  pattern: 'moet overeenkomen met patroon "{pattern}"',
+  additionalProperties: (p) => p.additionalProperty
+    ? `mag de extra eigenschap '${p.additionalProperty}' niet bevatten`
+    : 'mag geen extra eigenschappen bevatten',
+  minProperties: (p) => `mag niet minder dan ${num(p.limit)} ${plural(p.limit, 'eigenschap', 'eigenschappen')} bevatten`,
+  maxProperties: (p) => `mag niet meer dan ${num(p.limit)} ${plural(p.limit, 'eigenschap', 'eigenschappen')} bevatten`,
+  minItems: (p) => `mag niet minder dan ${num(p.limit)} ${plural(p.limit, 'item', 'items')} bevatten`,
+  maxItems: (p) => `mag niet meer dan ${num(p.limit)} ${plural(p.limit, 'item', 'items')} bevatten`,
+  uniqueItems: 'mag geen dubbele items bevatten',
+  contains: 'moet ten minste één geldig item bevatten',
+  items: 'de items van de lijst zijn ongeldig',
+  allOf: "moet aan alle subschema's voldoen",
+  anyOf: 'moet aan een subschema in anyOf voldoen',
+  oneOf: 'moet aan precies één subschema in oneOf voldoen',
+  not: 'mag NIET aan het subschema voldoen',
+  format: 'moet overeenkomen met formaat "{format}"',
+  if: 'moet aan het "if"-schema voldoen',
+  then: 'moet aan het "then"-schema voldoen',
+  else: 'moet aan het "else"-schema voldoen',
+  'false schema': 'booleaans schema false is altijd ongeldig',
+  $query: (p) => p.code
+    ? `de '$query'-assertie gaf ${p.code} op '${p.docPath}'`
+    : "moet aan de '$query'-assertie voldoen",
+  JQ2001: (p) => `de '$query'-assertie kon niet worden berekend (${p.code} op '${p.docPath}')`,
+  JQ2003: (p) => `de '$query'-assertie gaf meerdere resultaten (${p.code} op '${p.docPath}')`,
+  //#endregion
+
+  //#region @jarenjs/forms (second-person field voice)
+  'form/required': 'Dit veld is verplicht',
+  'form/type': (p) => `Moet een ${typeName(p.type)} zijn`,
+  'form/const': (p) => `Moet ${formatMessageValue(p.constValue)} zijn`,
+  'form/enum': (p) => `Moet ${Array.isArray(p.enumValues) ? listFormat.format(p.enumValues.map(formatMessageValue)) : formatMessageValue(p.enumValues)} zijn`,
+  'form/minLength': (p) => `Moet ten minste ${num(p.limit)} ${plural(p.limit, 'teken', 'tekens')} bevatten (nu ${num(p.len)})`,
+  'form/maxLength': (p) => `Mag ten hoogste ${num(p.limit)} ${plural(p.limit, 'teken', 'tekens')} bevatten (nu ${num(p.len)})`,
+  'form/pattern': 'Moet overeenkomen met patroon {pattern}',
+  'form/format': (p) => `Moet een geldige ${p.format} zijn`,
+  'form/minimum': (p) => `Moet ten minste ${num(p.limit)} zijn`,
+  'form/maximum': (p) => `Mag ten hoogste ${num(p.limit)} zijn`,
+  'form/exclusiveMinimum': (p) => `Moet groter zijn dan ${num(p.limit)}`,
+  'form/exclusiveMaximum': (p) => `Moet kleiner zijn dan ${num(p.limit)}`,
+  'form/multipleOf': (p) => `Moet een veelvoud van ${num(p.multipleOf)} zijn`,
+  'form/minItems': (p) => `Moet ten minste ${num(p.limit)} ${plural(p.limit, 'item', 'items')} bevatten`,
+  'form/maxItems': (p) => `Mag ten hoogste ${num(p.limit)} ${plural(p.limit, 'item', 'items')} bevatten`,
+  'form/uniqueItems': 'Items moeten uniek zijn',
+  'form/minProperties': (p) => `Moet ten minste ${num(p.limit)} ${plural(p.limit, 'eigenschap', 'eigenschappen')} bevatten`,
+  'form/maxProperties': (p) => `Mag ten hoogste ${num(p.limit)} ${plural(p.limit, 'eigenschap', 'eigenschappen')} bevatten`,
+  'x-form/assert': 'Ongeldige waarde',
+  'form/addItem': 'Item toevoegen',
+  'form/removeItem': 'Item verwijderen',
+  //#endregion
+};

package/src/pt.js

@@ -0,0 +1,131 @@
+//@ts-check
+
+/**
+ * Portuguese (pt) 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 "item" pluralizes
+ *   irregularly ("1 item" / "2 itens"),
+ * - `Intl.NumberFormat` renders numeric limits the Portuguese 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('pt');
+const numberFormat = new Intl.NumberFormat('pt');
+const listFormat = new Intl.ListFormat('pt', { style: 'long', type: 'disjunction' });
+
+/** Pick the Portuguese singular or plural noun form for a count. */
+const plural = makePluralPicker(pluralRules);
+
+/**
+ * Render a numeric limit through the Portuguese number format;
+ * non-numbers (e.g. an unresolved $data pointer) render as-is.
+ */
+const num = makeNumberRenderer(numberFormat);
+
+/** Portuguese names (with article) for the JSON Schema type keyword values. */
+const TYPE_NAMES = {
+  string: 'um texto (string)',
+  number: 'um número',
+  integer: 'um número inteiro',
+  boolean: 'um booleano',
+  array: 'uma lista (array)',
+  object: 'um objeto',
+  null: 'null',
+};
+
+/** Type keyword values under their Portuguese display name, article included. */
+const typeName = makeTypeNamer(TYPE_NAMES);
+
+//#endregion
+
+/**
+ * The Portuguese 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 pt = {
+  //#region @jarenjs/validate (document voice)
+  type: (p) => p.types
+    ? `deve ser um dos seguintes tipos: ${p.types.join(', ')}`
+    : `deve ser ${typeName(p.type)}`,
+  required: (p) => p.missingProperty
+    ? `deve ter a propriedade obrigatória '${p.missingProperty}'`
+    : 'deve ter as propriedades obrigatórias',
+  minimum: (p) => `deve ser ${p.comparison} ${num(p.limit)}`,
+  maximum: (p) => `deve ser ${p.comparison} ${num(p.limit)}`,
+  exclusiveMinimum: (p) => `deve ser ${p.comparison} ${num(p.limit)}`,
+  exclusiveMaximum: (p) => `deve ser ${p.comparison} ${num(p.limit)}`,
+  multipleOf: (p) => `deve ser um múltiplo de ${num(p.multipleOf)}`,
+  minLength: (p) => `não deve ter menos de ${num(p.limit)} ${plural(p.limit, 'caractere', 'caracteres')}`,
+  maxLength: (p) => `não deve ter mais de ${num(p.limit)} ${plural(p.limit, 'caractere', 'caracteres')}`,
+  pattern: 'deve corresponder ao padrão "{pattern}"',
+  additionalProperties: (p) => p.additionalProperty
+    ? `não deve ter a propriedade adicional '${p.additionalProperty}'`
+    : 'não deve ter propriedades adicionais',
+  minProperties: (p) => `não deve ter menos de ${num(p.limit)} ${plural(p.limit, 'propriedade', 'propriedades')}`,
+  maxProperties: (p) => `não deve ter mais de ${num(p.limit)} ${plural(p.limit, 'propriedade', 'propriedades')}`,
+  minItems: (p) => `não deve ter menos de ${num(p.limit)} ${plural(p.limit, 'item', 'itens')}`,
+  maxItems: (p) => `não deve ter mais de ${num(p.limit)} ${plural(p.limit, 'item', 'itens')}`,
+  uniqueItems: 'não deve ter itens duplicados',
+  contains: 'deve conter pelo menos um item válido',
+  items: 'os itens da lista são inválidos',
+  allOf: 'deve corresponder a todos os subesquemas',
+  anyOf: 'deve corresponder a um subesquema de anyOf',
+  oneOf: 'deve corresponder a exatamente um subesquema de oneOf',
+  not: 'NÃO deve corresponder ao subesquema',
+  format: 'deve corresponder ao formato "{format}"',
+  if: 'deve corresponder ao esquema "if"',
+  then: 'deve corresponder ao esquema "then"',
+  else: 'deve corresponder ao esquema "else"',
+  'false schema': 'o esquema booleano false é sempre inválido',
+  $query: (p) => p.code
+    ? `a asserção '$query' gerou ${p.code} em '${p.docPath}'`
+    : "deve satisfazer a asserção '$query'",
+  JQ2001: (p) => `a asserção '$query' não pôde ser avaliada (${p.code} em '${p.docPath}')`,
+  JQ2003: (p) => `a asserção '$query' gerou vários resultados (${p.code} em '${p.docPath}')`,
+  //#endregion
+
+  //#region @jarenjs/forms (second-person field voice)
+  'form/required': 'Este campo é obrigatório',
+  'form/type': (p) => `Deve ser ${typeName(p.type)}`,
+  'form/const': (p) => `Deve ser ${formatMessageValue(p.constValue)}`,
+  'form/enum': (p) => `Deve ser ${Array.isArray(p.enumValues) ? listFormat.format(p.enumValues.map(formatMessageValue)) : formatMessageValue(p.enumValues)}`,
+  'form/minLength': (p) => `Deve ter pelo menos ${num(p.limit)} ${plural(p.limit, 'caractere', 'caracteres')} (atualmente ${num(p.len)})`,
+  'form/maxLength': (p) => `Deve ter no máximo ${num(p.limit)} ${plural(p.limit, 'caractere', 'caracteres')} (atualmente ${num(p.len)})`,
+  'form/pattern': 'Deve corresponder ao padrão {pattern}',
+  'form/format': (p) => `Deve respeitar o formato ${p.format}`,
+  'form/minimum': (p) => `Deve ser pelo menos ${num(p.limit)}`,
+  'form/maximum': (p) => `Deve ser no máximo ${num(p.limit)}`,
+  'form/exclusiveMinimum': (p) => `Deve ser maior que ${num(p.limit)}`,
+  'form/exclusiveMaximum': (p) => `Deve ser menor que ${num(p.limit)}`,
+  'form/multipleOf': (p) => `Deve ser um múltiplo de ${num(p.multipleOf)}`,
+  'form/minItems': (p) => `Deve ter pelo menos ${num(p.limit)} ${plural(p.limit, 'item', 'itens')}`,
+  'form/maxItems': (p) => `Deve ter no máximo ${num(p.limit)} ${plural(p.limit, 'item', 'itens')}`,
+  'form/uniqueItems': 'Os itens devem ser únicos',
+  'form/minProperties': (p) => `Deve ter pelo menos ${num(p.limit)} ${plural(p.limit, 'propriedade', 'propriedades')}`,
+  'form/maxProperties': (p) => `Deve ter no máximo ${num(p.limit)} ${plural(p.limit, 'propriedade', 'propriedades')}`,
+  'x-form/assert': 'Valor inválido',
+  'form/addItem': 'Adicionar item',
+  'form/removeItem': 'Remover item',
+  //#endregion
+};

package/src/ru.js

@@ -0,0 +1,141 @@
+//@ts-check
+
+/**
+ * Russian (ru) 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. Russian counts split
+ *   one/few/many, but every counted noun here follows "менее/более"
+ *   and therefore reads in the genitive - where only the 'one'
+ *   category differs ("21 символа" / "22 символов"), so a two-form
+ *   helper suffices,
+ * - `Intl.NumberFormat` renders numeric limits the Russian way,
+ * - `Intl.ListFormat` renders enum alternatives ("a, b или 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('ru');
+const numberFormat = new Intl.NumberFormat('ru-RU');
+const listFormat = new Intl.ListFormat('ru', { style: 'long', type: 'disjunction' });
+
+/**
+ * Pick the genitive singular ('символа') or genitive plural
+ * ('символов') noun form for a count - the shape every "менее/более
+ * N ..." message needs.
+ */
+const plural = makePluralPicker(pluralRules);
+
+/**
+ * Render a numeric limit through the Russian number format; non-numbers
+ * (e.g. an unresolved $data pointer) render as-is.
+ */
+const num = makeNumberRenderer(numberFormat);
+
+/**
+ * Russian names for the JSON Schema type keyword values, in the
+ * instrumental case ("должно быть строкой").
+ */
+const TYPE_NAMES = {
+  string: 'строкой (string)',
+  number: 'числом',
+  integer: 'целым числом',
+  boolean: 'булевым значением',
+  array: 'списком (array)',
+  object: 'объектом',
+  null: 'null',
+};
+
+/** Type keyword values under their Russian display name, instrumental case. */
+const typeName = makeTypeNamer(TYPE_NAMES);
+
+//#endregion
+
+/**
+ * The Russian 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 ru = {
+  //#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)} ${plural(p.limit, 'символа', 'символов')}`,
+  maxLength: (p) => `не должно содержать более ${num(p.limit)} ${plural(p.limit, 'символа', 'символов')}`,
+  pattern: 'должно соответствовать шаблону "{pattern}"',
+  additionalProperties: (p) => p.additionalProperty
+    ? `не должно содержать дополнительное свойство '${p.additionalProperty}'`
+    : 'не должно содержать дополнительных свойств',
+  minProperties: (p) => `не должно содержать менее ${num(p.limit)} ${plural(p.limit, 'свойства', 'свойств')}`,
+  maxProperties: (p) => `не должно содержать более ${num(p.limit)} ${plural(p.limit, 'свойства', 'свойств')}`,
+  minItems: (p) => `не должно содержать менее ${num(p.limit)} ${plural(p.limit, 'элемента', 'элементов')}`,
+  maxItems: (p) => `не должно содержать более ${num(p.limit)} ${plural(p.limit, 'элемента', 'элементов')}`,
+  uniqueItems: 'не должно содержать повторяющихся элементов',
+  contains: 'должно содержать хотя бы один допустимый элемент',
+  items: 'элементы списка недопустимы',
+  allOf: 'должно соответствовать всем подсхемам',
+  anyOf: 'должно соответствовать одной из подсхем в anyOf',
+  oneOf: 'должно соответствовать ровно одной подсхеме в oneOf',
+  not: 'НЕ должно соответствовать подсхеме',
+  format: 'должно соответствовать формату "{format}"',
+  if: 'должно соответствовать схеме "if"',
+  then: 'должно соответствовать схеме "then"',
+  else: 'должно соответствовать схеме "else"',
+  'false schema': 'булева схема false всегда недопустима',
+  $query: (p) => p.code
+    ? `утверждение '$query' вызвало ${p.code} в '${p.docPath}'`
+    : "должно удовлетворять утверждению '$query'",
+  JQ2001: (p) => `утверждение '$query' не удалось вычислить (${p.code} в '${p.docPath}')`,
+  JQ2003: (p) => `утверждение '$query' вернуло несколько результатов (${p.code} в '${p.docPath}')`,
+  //#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)} ${plural(p.limit, 'символа', 'символов')} (сейчас ${num(p.len)})`,
+  'form/maxLength': (p) => `Должно содержать не более ${num(p.limit)} ${plural(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)} ${plural(p.limit, 'элемента', 'элементов')}`,
+  'form/maxItems': (p) => `Должно содержать не более ${num(p.limit)} ${plural(p.limit, 'элемента', 'элементов')}`,
+  'form/uniqueItems': 'Элементы должны быть уникальными',
+  'form/minProperties': (p) => `Должно содержать не менее ${num(p.limit)} ${plural(p.limit, 'свойства', 'свойств')}`,
+  'form/maxProperties': (p) => `Должно содержать не более ${num(p.limit)} ${plural(p.limit, 'свойства', 'свойств')}`,
+  'x-form/assert': 'Недопустимое значение',
+  'form/addItem': 'Добавить элемент',
+  'form/removeItem': 'Удалить элемент',
+  //#endregion
+};

package/src/tr.js

@@ -0,0 +1,128 @@
+//@ts-check
+
+/**
+ * Turkish (tr) 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):
+ * - Turkish nouns stay singular after a numeral ("2 karakter"), so
+ *   there is no plural helper. Case suffixes obey vowel harmony, so
+ *   every message attaches suffixes to FIXED nouns ("'name'
+ *   özelliğini", "5 sayısının katı"), never to interpolated text,
+ * - `Intl.NumberFormat` renders numeric limits the Turkish way,
+ * - `Intl.ListFormat` renders enum alternatives ("a, b veya c"),
+ * all held as module-level singletons (allocation discipline).
+ */
+
+import {
+  formatMessageValue,
+  makeNumberRenderer,
+  makeTypeNamer,
+} from './helpers.js';
+
+//#region Intl singletons
+
+const numberFormat = new Intl.NumberFormat('tr-TR');
+const listFormat = new Intl.ListFormat('tr', { style: 'long', type: 'disjunction' });
+
+/**
+ * Render a numeric limit through the Turkish number format; non-numbers
+ * (e.g. an unresolved $data pointer) render as-is.
+ */
+const num = makeNumberRenderer(numberFormat);
+
+/** Turkish names for the JSON Schema type keyword values. */
+const TYPE_NAMES = {
+  string: 'metin (string)',
+  number: 'sayı',
+  integer: 'tam sayı',
+  boolean: 'boole değeri',
+  array: 'liste (array)',
+  object: 'nesne',
+  null: 'null',
+};
+
+/** Type keyword values under their Turkish display name. */
+const typeName = makeTypeNamer(TYPE_NAMES);
+
+//#endregion
+
+/**
+ * The Turkish 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 tr = {
+  //#region @jarenjs/validate (document voice)
+  type: (p) => p.types
+    ? `şu türlerden biri olmalıdır: ${p.types.join(', ')}`
+    : `${typeName(p.type)} olmalıdır`,
+  required: (p) => p.missingProperty
+    ? `zorunlu '${p.missingProperty}' özelliğini içermelidir`
+    : 'zorunlu özellikleri içermelidir',
+  minimum: (p) => `${p.comparison} ${num(p.limit)} olmalıdır`,
+  maximum: (p) => `${p.comparison} ${num(p.limit)} olmalıdır`,
+  exclusiveMinimum: (p) => `${p.comparison} ${num(p.limit)} olmalıdır`,
+  exclusiveMaximum: (p) => `${p.comparison} ${num(p.limit)} olmalıdır`,
+  multipleOf: (p) => `${num(p.multipleOf)} sayısının katı olmalıdır`,
+  minLength: (p) => `en az ${num(p.limit)} karakter içermelidir`,
+  maxLength: (p) => `en fazla ${num(p.limit)} karakter içermelidir`,
+  pattern: '"{pattern}" desenine uymalıdır',
+  additionalProperties: (p) => p.additionalProperty
+    ? `ek '${p.additionalProperty}' özelliğini içermemelidir`
+    : 'ek özellikler içermemelidir',
+  minProperties: (p) => `en az ${num(p.limit)} özellik içermelidir`,
+  maxProperties: (p) => `en fazla ${num(p.limit)} özellik içermelidir`,
+  minItems: (p) => `en az ${num(p.limit)} öğe içermelidir`,
+  maxItems: (p) => `en fazla ${num(p.limit)} öğe içermelidir`,
+  uniqueItems: 'yinelenen öğeler içermemelidir',
+  contains: 'en az bir geçerli öğe içermelidir',
+  items: 'listedeki öğeler geçersiz',
+  allOf: 'tüm alt şemalarla eşleşmelidir',
+  anyOf: "anyOf içindeki bir alt şemayla eşleşmelidir",
+  oneOf: "oneOf içindeki tam olarak bir alt şemayla eşleşmelidir",
+  not: 'alt şemayla eşleşmemelidir',
+  format: '"{format}" biçimine uymalıdır',
+  if: '"if" şemasıyla eşleşmelidir',
+  then: '"then" şemasıyla eşleşmelidir',
+  else: '"else" şemasıyla eşleşmelidir',
+  'false schema': 'false boole şeması her zaman geçersizdir',
+  $query: (p) => p.code
+    ? `'$query' doğrulaması '${p.docPath}' konumunda ${p.code} hatası verdi`
+    : "'$query' doğrulamasını karşılamalıdır",
+  JQ2001: (p) => `'$query' doğrulaması değerlendirilemedi ('${p.docPath}' konumunda ${p.code})`,
+  JQ2003: (p) => `'$query' doğrulaması birden çok sonuç döndürdü ('${p.docPath}' konumunda ${p.code})`,
+  //#endregion
+
+  //#region @jarenjs/forms (second-person field voice)
+  'form/required': 'Bu alan zorunludur',
+  'form/type': (p) => `${typeName(p.type)} olmalıdır`,
+  'form/const': (p) => `${formatMessageValue(p.constValue)} olmalıdır`,
+  'form/enum': (p) => `${Array.isArray(p.enumValues) ? listFormat.format(p.enumValues.map(formatMessageValue)) : formatMessageValue(p.enumValues)} değerlerinden biri olmalıdır`,
+  'form/minLength': (p) => `En az ${num(p.limit)} karakter içermelidir (şu an ${num(p.len)})`,
+  'form/maxLength': (p) => `En fazla ${num(p.limit)} karakter içermelidir (şu an ${num(p.len)})`,
+  'form/pattern': '{pattern} desenine uymalıdır',
+  'form/format': (p) => `Geçerli bir ${p.format} değeri olmalıdır`,
+  'form/minimum': (p) => `En az ${num(p.limit)} olmalıdır`,
+  'form/maximum': (p) => `En fazla ${num(p.limit)} olmalıdır`,
+  'form/exclusiveMinimum': (p) => `${num(p.limit)} değerinden büyük olmalıdır`,
+  'form/exclusiveMaximum': (p) => `${num(p.limit)} değerinden küçük olmalıdır`,
+  'form/multipleOf': (p) => `${num(p.multipleOf)} sayısının katı olmalıdır`,
+  'form/minItems': (p) => `En az ${num(p.limit)} öğe içermelidir`,
+  'form/maxItems': (p) => `En fazla ${num(p.limit)} öğe içermelidir`,
+  'form/uniqueItems': 'Öğeler benzersiz olmalıdır',
+  'form/minProperties': (p) => `En az ${num(p.limit)} özellik içermelidir`,
+  'form/maxProperties': (p) => `En fazla ${num(p.limit)} özellik içermelidir`,
+  'x-form/assert': 'Geçersiz değer',
+  'form/addItem': 'Öğe ekle',
+  'form/removeItem': 'Öğeyi kaldır',
+  //#endregion
+};