@jarenjs/locales 0.34.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019 Joham
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,119 @@
+# @jarenjs/locales
+
+Locale packs (message catalogs) for the error messages of
+[`@jarenjs/validate`](../validate/README.md) and
+[`@jarenjs/forms`](../forms/README.md).
+
+Jaren validators and form checks never bake prose into the hot path: every
+failure carries a stable message key (`msgid`) plus raw structured
+`params`, and human text is produced at report/render time through a
+**catalog** - a plain flat object of closures. This package is the home of
+the non-English catalogs. The normative contract (message-key registry,
+template syntax, resolution precedence) lives in
+[`packages/validate/docs/ERROR-MESSAGES.md`](../validate/docs/ERROR-MESSAGES.md).
+
+## Usage
+
+Post-hoc localization of a collect-mode validation result:
+
+```js
+import { JarenValidator, compileMessageCatalog, localizeErrors } from '@jarenjs/validate';
+import { nl } from '@jarenjs/locales';
+
+const catalog = compileMessageCatalog(nl);
+const validator = new JarenValidator({ collectErrors: true });
+const validate = validator.compile({ type: 'string', minLength: 2 });
+
+const result = validate('x');
+localizeErrors(result.errors, catalog);
+// result.errors[0].message === 'mag niet minder dan 2 tekens bevatten'
+```
+
+Per-keystroke form feedback in Dutch:
+
+```js
+import { buildFormModel, validateAllFields, compileMessageCatalog } from '@jarenjs/forms';
+import { nl } from '@jarenjs/locales';
+
+const catalog = compileMessageCatalog(nl);
+const errors = validateAllFields(model, data, catalog);
+// errors['/name'][0].message === 'Dit veld is verplicht'
+```
+
+Subpath import when you only want one pack (tree-shaking friendly either
+way - the package is `sideEffects: false`):
+
+```js
+import { nl } from '@jarenjs/locales/nl';
+```
+
+## Authoring a pack
+
+A catalog is a plain flat object; each entry is either a **template
+string** or a **closure**:
+
+```js
+export const xx = {
+  // template string: {name} substitutes the params member 'name';
+  // {{ escapes a literal brace; unknown names stay literal
+  pattern: 'must match pattern "{pattern}"',
+
+  // closure: full control, receives (params, error)
+  minLength: (p) => `at least ${p.limit} character${p.limit === 1 ? '' : 's'}`,
+};
+```
+
+Rules of the road:
+
+1. **Key parity.** Cover every key of validate's `messagesEn`, every
+   `form/*` key of forms' `formsMessagesEn`, plus `x-form/assert` and the
+   `JQ2xxx` query runtime codes. The repo enforces this with tests
+   (`test/locales/`); missing keys silently fall back to English.
+2. **Never depend on a consumer.** A pack must stay importable without
+   dragging in `@jarenjs/validate` or `@jarenjs/forms`, so that either one
+   can serve any pack. The platform and `@jarenjs/core` are the only things
+   a pack may reach for - core is where the shared value renderer lives, so
+   a pack cannot drift from the catalog contract by re-implementing it.
+3. **Use `Intl`, as module-level singletons.** `Intl.PluralRules` for
+   plural categories (see `nl.js`: "1 teken" / "2 tekens"),
+   `Intl.NumberFormat` for `{limit}`-style numbers, `Intl.ListFormat` for
+   enum lists. Construct them once at module level - catalog entries run
+   on the failure path, which is cheap, but allocation discipline is the
+   house rule.
+4. **Bidi.** Packs targeting RTL scripts should isolate interpolated user
+   values with FSI/PDI (U+2068/U+2069) so a Latin value cannot reorder
+   the surrounding text. That call belongs to the pack author, not core.
+   The harder rule, paid for by `ar.js`: **an ASCII comparison operator
+   placed between RTL text and a number displays flipped** - the
+   operator is bidi-neutral, so `>=` before a Latin-digit limit reorders
+   and reads as `=<`. Never interpolate `{comparison}` as a symbol.
+   Arabic therefore renders the four operators validate emits for
+   `minimum`/`maximum`/`exclusiveMinimum`/`exclusiveMaximum` as whole
+   **phrases** ("يجب ألا تقل القيمة عن 2" - "the value must not be less
+   than 2"), and falls back for an operator it does not know to the
+   symbol wrapped in a directional isolate (U+2066 … U+2069) so it at
+   least still reads left-to-right inside the RTL sentence. Do the same
+   before shipping a Hebrew, Farsi or Urdu pack, and always eyeball the
+   rendered strings - a flipped operator is silently *valid* text.
+5. **Voice.** Validate keys speak about the document ("must have required
+   property 'x'"); `form/*` keys speak to the person filling the field
+   ("This field is required"). Keep both voices.
+
+## Available packs
+
+| Export | Subpath | Locale |
+|--------|---------|--------|
+| `ar` | `./ar` | Arabic (العربية) - RTL |
+| `de` | `./de` | German (Deutsch) |
+| `es` | `./es` | Spanish (Español) |
+| `fr` | `./fr` | French (Français) |
+| `ja` | `./ja` | Japanese (日本語) |
+| `ko` | `./ko` | Korean (한국어) |
+| `nl` | `./nl` | Dutch (Nederlands) |
+| `pt` | `./pt` | Portuguese (Português) |
+| `ru` | `./ru` | Russian (Русский) |
+| `tr` | `./tr` | Turkish (Türkçe) |
+| `zhTW` | `./zh-tw` | Traditional Chinese, Taiwan (繁體中文) |
+
+The named export is the locale tag camel-cased (`zhTW`), the subpath keeps
+the tag itself (`@jarenjs/locales/zh-tw`).

package/dist/types/ar.d.ts

@@ -0,0 +1,7 @@
+/**
+ * The Arabic 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 declare const ar: Record<string, string | ((params: any, error?: object) => string)>;

package/dist/types/de.d.ts

@@ -0,0 +1,7 @@
+/**
+ * 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 declare const de: Record<string, string | ((params: any, error?: object) => string)>;

package/dist/types/es.d.ts

@@ -0,0 +1,7 @@
+/**
+ * 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 declare const es: Record<string, string | ((params: any, error?: object) => string)>;

package/dist/types/fr.d.ts

@@ -0,0 +1,7 @@
+/**
+ * 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 declare const fr: Record<string, string | ((params: any, error?: object) => string)>;

package/dist/types/helpers.d.ts

@@ -0,0 +1,41 @@
+/**
+ * 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 declare function makeNumberRenderer(numberFormat: Intl.NumberFormat): (value: unknown) => string;
+/**
+ * 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 declare function makePluralPicker(pluralRules: Intl.PluralRules): (count: number, one: string, other: string) => string;
+/**
+ * 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 declare function makeTypeNamer(typeNames: Record<string, string>): (type: string) => string;

package/dist/types/index.d.ts

@@ -0,0 +1,23 @@
+/**
+ * @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/dist/types/ja.d.ts

@@ -0,0 +1,7 @@
+/**
+ * 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 declare const ja: Record<string, string | ((params: any, error?: object) => string)>;

package/dist/types/ko.d.ts

@@ -0,0 +1,7 @@
+/**
+ * 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 declare const ko: Record<string, string | ((params: any, error?: object) => string)>;

package/dist/types/nl.d.ts

@@ -0,0 +1,7 @@
+/**
+ * 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 declare const nl: Record<string, string | ((params: any, error?: object) => string)>;

package/dist/types/pt.d.ts

@@ -0,0 +1,7 @@
+/**
+ * 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 declare const pt: Record<string, string | ((params: any, error?: object) => string)>;

package/dist/types/ru.d.ts

@@ -0,0 +1,7 @@
+/**
+ * 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 declare const ru: Record<string, string | ((params: any, error?: object) => string)>;

package/dist/types/tr.d.ts

@@ -0,0 +1,7 @@
+/**
+ * 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 declare const tr: Record<string, string | ((params: any, error?: object) => string)>;

package/dist/types/zh-tw.d.ts

@@ -0,0 +1,7 @@
+/**
+ * The zh-TW 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 declare const zhTW: Record<string, string | ((params: any, error?: object) => string)>;

package/package.json

@@ -0,0 +1,95 @@
+{
+  "name": "@jarenjs/locales",
+  "private": false,
+  "version": "0.34.0",
+  "type": "module",
+  "main": "./src/index.js",
+  "types": "./dist/types/index.d.ts",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/types/index.d.ts",
+      "default": "./src/index.js"
+    },
+    "./ar": {
+      "types": "./dist/types/ar.d.ts",
+      "default": "./src/ar.js"
+    },
+    "./de": {
+      "types": "./dist/types/de.d.ts",
+      "default": "./src/de.js"
+    },
+    "./es": {
+      "types": "./dist/types/es.d.ts",
+      "default": "./src/es.js"
+    },
+    "./fr": {
+      "types": "./dist/types/fr.d.ts",
+      "default": "./src/fr.js"
+    },
+    "./ja": {
+      "types": "./dist/types/ja.d.ts",
+      "default": "./src/ja.js"
+    },
+    "./ko": {
+      "types": "./dist/types/ko.d.ts",
+      "default": "./src/ko.js"
+    },
+    "./nl": {
+      "types": "./dist/types/nl.d.ts",
+      "default": "./src/nl.js"
+    },
+    "./pt": {
+      "types": "./dist/types/pt.d.ts",
+      "default": "./src/pt.js"
+    },
+    "./ru": {
+      "types": "./dist/types/ru.d.ts",
+      "default": "./src/ru.js"
+    },
+    "./tr": {
+      "types": "./dist/types/tr.d.ts",
+      "default": "./src/tr.js"
+    },
+    "./zh-tw": {
+      "types": "./dist/types/zh-tw.d.ts",
+      "default": "./src/zh-tw.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist/types/",
+    "src/"
+  ],
+  "description": "Locale packs (message catalogs) for @jarenjs/validate and @jarenjs/forms error messages",
+  "author": "joham",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/jklarenbeek/jarenjs.git",
+    "directory": "packages/locales"
+  },
+  "license": "MIT",
+  "engines": {
+    "node": ">=24"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "keywords": [
+    "jaren",
+    "json-schema",
+    "i18n",
+    "l10n",
+    "locales",
+    "error-messages"
+  ],
+  "scripts": {
+    "build": "npm run build:types",
+    "build:types": "tsc -p tsconfig.json",
+    "prepack": "npm run build:types"
+  },
+  "dependencies": {
+    "@jarenjs/core": "^0.34.0"
+  }
+}

package/src/ar.js

@@ -0,0 +1,159 @@
+//@ts-check
+
+/**
+ * Arabic (ar) 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):
+ * - Arabic pluralizes across six categories, so counted messages phrase
+ *   around a fixed "عدد" (count-of) noun ("يجب ألا يقل عدد الأحرف عن 2")
+ *   instead of agreeing the noun with the number - the standard
+ *   software-string convention; no plural helper is needed,
+ * - `Intl.NumberFormat` is pinned to Latin digits (`numberingSystem:
+ *   'latn'`): the limits describe JSON documents, which are written in
+ *   Latin digits regardless of UI language,
+ * - `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('ar', { numberingSystem: 'latn' });
+const listFormat = new Intl.ListFormat('ar', { style: 'long', type: 'disjunction' });
+
+/**
+ * Render a numeric limit through the Arabic (Latin-digit) number
+ * format; non-numbers (e.g. an unresolved $data pointer) render as-is.
+ */
+const num = makeNumberRenderer(numberFormat);
+
+/** Arabic 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 Arabic display name. */
+const typeName = makeTypeNamer(TYPE_NAMES);
+
+/**
+ * The limit comparisons in words: an ASCII operator between RTL text
+ * and a number falls to the bidi algorithm's neutral reordering and
+ * displays flipped ("=<"), so the four operators validate emits render
+ * as phrases instead.
+ */
+const COMPARISON_PHRASES = {
+  '>=': 'يجب ألا تقل القيمة عن',
+  '<=': 'يجب ألا تزيد القيمة عن',
+  '>': 'يجب أن تكون القيمة أكبر من',
+  '<': 'يجب أن تكون القيمة أصغر من',
+};
+
+/**
+ * Render a limit comparison; an unexpected operator falls back to the
+ * symbol wrapped in a left-to-right isolate (U+2066 LRI … U+2069 PDI) so
+ * it still reads left-to-right inside the RTL sentence. LRI rather than
+ * the first-strong FSI on purpose: an operator has no strong character
+ * for FSI to sample, so the direction has to be stated outright.
+ * @param {{ comparison: string, limit: unknown }} p - The message params
+ * @returns {string}
+ */
+function compareLimit(p) {
+  const phrase = COMPARISON_PHRASES[p.comparison];
+  return phrase !== undefined
+    ? `${phrase} ${num(p.limit)}`
+    : `يجب أن تكون القيمة ⁦${p.comparison} ${num(p.limit)}⁩`;
+}
+
+//#endregion
+
+/**
+ * The Arabic 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 ar = {
+  //#region @jarenjs/validate (document voice)
+  type: (p) => p.types
+    ? `يجب أن تكون القيمة من أحد الأنواع التالية: ${p.types.join(', ')}`
+    : `يجب أن تكون القيمة من نوع ${typeName(p.type)}`,
+  required: (p) => p.missingProperty
+    ? `يجب أن تحتوي على الخاصية الإلزامية '${p.missingProperty}'`
+    : 'يجب أن تحتوي على الخصائص الإلزامية',
+  minimum: compareLimit,
+  maximum: compareLimit,
+  exclusiveMinimum: compareLimit,
+  exclusiveMaximum: compareLimit,
+  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.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)} (حاليًا ${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
+};