@jarenjs/forms 0.9.2 → 0.34.0

package/src/data.js

@@ -13,11 +13,19 @@
  * cached by pointer string and reads are allocation-free.
  */
 
+import { equalsJson } from '@jarenjs/core/object';
+import { createBoundedCache } from '@jarenjs/core/cache';
 import {
   parseJSONPointer,
   compileJSONPointer,
+  encodeJSONPointerSegment,
   JSONPOINTER_NOTHING,
 } from '@jarenjs/json/pointer';
+import {
+  compileJSONPointerSetter,
+  compileJSONPointerRemover,
+  JsonWriteError,
+} from '@jarenjs/json/write';
 
 /**
  * Split a JSON pointer into decoded segments per RFC 6901. '' -> [].
@@ -31,25 +39,17 @@ export function parsePointer(pointer) {
   return parseJSONPointer(pointer);
 }
 
-const getterCache = new Map();
-const GETTER_CACHE_LIMIT = 512;
+const getterCache = createBoundedCache(512);
 
 /**
- * Compiled getter for a pointer string, cached FIFO (the same pattern as
- * the query engine's string cache): form field pointers are a small,
- * stable set, so every keystroke after the first hits the cache.
+ * Compiled getter for a pointer string, cached in the shared bounded
+ * LRU (`@jarenjs/core/cache`): form field pointers are a small, stable
+ * set, so every keystroke after the first hits the cache.
  * @param {string} pointer
  * @returns {(root: any) => any}
  */
 function getPointerGetter(pointer) {
-  let getter = getterCache.get(pointer);
-  if (getter === undefined) {
-    getter = compileJSONPointer(pointer);
-    if (getterCache.size >= GETTER_CACHE_LIMIT)
-      getterCache.delete(getterCache.keys().next().value);
-    getterCache.set(pointer, getter);
-  }
-  return getter;
+  return getterCache.getOrCreate(pointer, compileJSONPointer);
 }
 
 /**
@@ -63,49 +63,49 @@ export function getValueAtPointer(data, pointer) {
   return value === JSONPOINTER_NOTHING ? undefined : value;
 }
 
-//#region roadmap
-// Immutable write ops (set/append/remove by pointer) are a @jarenjs/json
-// roadmap item (compiled setters beside the compiled getters, feeding the
-// JSON Patch work). Until that lands they live here; parsing already goes
-// through the shared parseJSONPointer above.
+//#region write operations
+// One write engine in the whole repo: the copy-on-write kernel behind
+// @jarenjs/json's patch and write modules. Forms adds only its two
+// data disciplines - missing parents are CREATED (a rendered field may
+// be the first write into an untouched branch) and setting `undefined`
+// deletes (parseFieldInput maps a cleared input to undefined).
+
+const setterCache = createBoundedCache(512);
+const removerCache = createBoundedCache(512);
+
+function getPointerSetter(pointer) {
+  return setterCache.getOrCreate(pointer,
+    (p) => compileJSONPointerSetter(p, { parents: 'create' }));
+}
+
+function getPointerRemover(pointer) {
+  return removerCache.getOrCreate(pointer, compileJSONPointerRemover);
+}
 
 /**
  * Return a copy of `data` with the value at `pointer` replaced.
- * Setting `undefined` REMOVES the property (array items become undefined
- * holes only when explicitly set; use removeItemAt to delete them).
- * Missing intermediate containers are created (objects for name segments,
- * arrays for numeric segments).
+ * Setting `undefined` REMOVES the location (deleting something that does
+ * not exist is a no-op returning `data` unchanged). Missing intermediate
+ * containers are created (objects for name segments, arrays for numeric
+ * segments), and untouched siblings are shared by reference — the same
+ * copy-on-write engine as `@jarenjs/json`'s patch and write modules.
  * @param {any} data
  * @param {string} pointer
  * @param {any} value
  * @returns {any} The new root value
  */
 export function setValueAtPointer(data, pointer, value) {
-  const keys = parsePointer(pointer);
-  if (keys.length === 0) return value;
-
-  const root = cloneContainer(data, keys[0]);
-  let current = root;
-  for (let i = 0; i < keys.length - 1; i++) {
-    const key = keys[i];
-    current[key] = cloneContainer(current[key], keys[i + 1]);
-    current = current[key];
-  }
-
-  const last = keys[keys.length - 1];
-  if (value === undefined && !Array.isArray(current)) {
-    delete current[last];
-  }
-  else {
-    current[last] = value;
+  if (value === undefined) {
+    if (pointer === '') return undefined;
+    try {
+      return getPointerRemover(pointer)(data);
+    }
+    catch (error) {
+      if (error instanceof JsonWriteError) return data;
+      throw error;
+    }
   }
-  return root;
-}
-
-function cloneContainer(value, nextKey) {
-  if (Array.isArray(value)) return value.slice();
-  if (value != null && typeof value === 'object') return { ...value };
-  return /^\d+$/.test(String(nextKey)) ? [] : {};
+  return getPointerSetter(pointer)(data, value);
 }
 
 /**
@@ -138,6 +138,93 @@ export function appendItem(data, pointer, value) {
   return setValueAtPointer(data, pointer, next);
 }
 
+/**
+ * Every pointer whose value differs between two documents, in
+ * document order.
+ *
+ * Membership is significant: an added or removed member (or array tail
+ * slot) contributes its pointer even when both sides read back as
+ * `null` through a pointer lookup. Reference-equal subtrees are skipped
+ * whole, so over copy-on-write edits — which is how every writer in
+ * this package produces its next document — the walk costs O(change),
+ * not O(document).
+ *
+ * Two callers rely on it: the session's navigation-guard evidence
+ * (`dirtyPaths`) and the rule memo's invalidation set.
+ * @param {any} previous
+ * @param {any} current
+ * @returns {string[]}
+ */
+export function changedPointers(previous, current) {
+  /** @type {string[]} */
+  const out = [];
+  collectChanged(previous, current, '', out);
+  return out;
+}
+
+function collectChanged(previous, current, pointer, out) {
+  // Reference equality first, at every level and before any pointer
+  // string is built: over a copy-on-write edit almost every member of
+  // the touched container is the identical value, and formatting a
+  // pointer for each of them would put the document's WIDTH back into a
+  // walk whose whole point is to cost only its depth.
+  if (previous === current) return;
+  if (Array.isArray(previous) && Array.isArray(current)) {
+    const shared = Math.min(previous.length, current.length);
+    for (let i = 0; i < shared; i++) {
+      if (previous[i] !== current[i])
+        collectChanged(previous[i], current[i], `${pointer}/${i}`, out);
+    }
+    const longest = Math.max(previous.length, current.length);
+    for (let i = shared; i < longest; i++)
+      out.push(`${pointer}/${i}`); // added or removed tail slot
+    return;
+  }
+  if (previous !== null && typeof previous === 'object' && !Array.isArray(previous)
+    && current !== null && typeof current === 'object' && !Array.isArray(current)) {
+    const before = Object.keys(previous);
+    const after = Object.keys(current);
+    // Same members in the same order — which is what a copy-on-write
+    // edit of one member produces — needs no membership probing at all,
+    // just a value compare per key. The general path below is for real
+    // shape changes.
+    if (before.length === after.length && sameOrder(before, after)) {
+      for (let i = 0; i < before.length; i++) {
+        const key = before[i];
+        if (previous[key] !== current[key]) {
+          collectChanged(previous[key], current[key],
+            `${pointer}/${encodeJSONPointerSegment(key)}`, out);
+        }
+      }
+      return;
+    }
+    // own keys only, membership by Object.hasOwn — JSON member names
+    // like 'constructor', 'toString' or a parsed own '__proto__' are
+    // legal data and must diff as data, never through the prototype
+    // chain (null-prototype records diff identically)
+    for (const key of before) {
+      if (!Object.hasOwn(current, key))
+        out.push(`${pointer}/${encodeJSONPointerSegment(key)}`); // removed member
+      else if (previous[key] !== current[key])
+        collectChanged(previous[key], current[key], `${pointer}/${encodeJSONPointerSegment(key)}`, out);
+    }
+    for (const key of after) {
+      if (!Object.hasOwn(previous, key))
+        out.push(`${pointer}/${encodeJSONPointerSegment(key)}`); // added member
+    }
+    return;
+  }
+  if (!equalsJson(previous, current)) out.push(pointer);
+}
+
+/** Whether two key lists hold the same names in the same positions. */
+function sameOrder(a, b) {
+  for (let i = 0; i < a.length; i++) {
+    if (a[i] !== b[i]) return false;
+  }
+  return true;
+}
+
 //#endregion
 
 /**

package/src/deps.js

@@ -0,0 +1,179 @@
+//@ts-check
+
+/**
+ * What a rule reads: the data dependencies of an `x-form` rule query,
+ * as JSON Pointer prefixes.
+ *
+ * The point is invalidation. `evaluateFormRules` re-runs every rule on
+ * every keystroke; with a dependency set per rule it can re-run only
+ * the rules a change can possibly have affected (rules.js, the memo).
+ * A dependency set is therefore allowed to be too LARGE — a rule that
+ * re-runs needlessly is slow, not wrong — and must never be too small.
+ *
+ * The analysis is deliberately shallow, and sound because of one
+ * property of the query language: the only way into the input document
+ * is a ROOT-ANCHORED path string (`$`, `$.x`, `$['x']`). Everything
+ * else a query can read is derived from one of those — a `$let`/`$for`
+ * variable holds the result of an expression in the same document, and
+ * the only externals a form rule may bind are `value` (the field's own
+ * value, which the rule depends on anyway) and `pointer` (a string).
+ * So collecting the root-anchored paths, and reducing each to the
+ * literal prefix it starts with, over-approximates every read.
+ *
+ * Reduction stops at the first segment that is not a plain name or
+ * index: `$.a.b[*].c` reduces to `/a/b`, and a filter's own comparisons
+ * are collected separately because a filter can name another part of
+ * the document (`$.lines[?@.id == $.selected]`).
+ *
+ * RETAINED beside `analyzeQuery` (QUERY-FORMAT.md Appendix C),
+ * deliberately: the published analysis reports which OPERATORS,
+ * functions and externals a query uses — not the data-pointer prefixes
+ * this invalidation needs — and this scanner is total over any JSON
+ * value (a rule that does not even normalize still yields a sound
+ * "depends on everything" answer) where analysis would throw. Deriving
+ * prefixes from the analysis tree's `path` nodes would be exact, at the
+ * price of a full normalization per rule per form build; take that
+ * route only if the over-approximation ever measurably hurts.
+ */
+
+import { parseJSONPath } from '@jarenjs/json/path';
+import { encodeJSONPointerSegment } from '@jarenjs/json/pointer';
+
+/**
+ * The dependency set of a rule: pointer prefixes, or `ALL_POINTERS` for
+ * "any change matters" (a query that reads the whole document).
+ * @typedef {string[]} RuleDependencies
+ */
+
+/** A rule that reads the root depends on everything. */
+export const ALL_POINTERS = [''];
+
+/**
+ * Collect the data dependencies of one rule query document.
+ * @param {any} doc - The authored rule document
+ * @returns {RuleDependencies} Pointer prefixes, deduplicated
+ */
+export function queryDependencies(doc) {
+  /** @type {Set<string>} */
+  const out = new Set();
+  collectStrings(doc, out);
+  if (out.has('')) return ALL_POINTERS;
+  return [...out];
+}
+
+/**
+ * Merge dependency sets, collapsing to {@link ALL_POINTERS} when any of
+ * them reads the root and dropping prefixes another already covers.
+ * @param {RuleDependencies[]} sets
+ * @returns {RuleDependencies}
+ */
+export function mergeDependencies(sets) {
+  /** @type {Set<string>} */
+  const all = new Set();
+  for (const set of sets) {
+    for (const dep of set) {
+      if (dep === '') return ALL_POINTERS;
+      all.add(dep);
+    }
+  }
+  const deps = [...all];
+  return deps.filter((dep) => !deps.some((other) => other !== dep && isPointerPrefix(other, dep)));
+}
+
+/**
+ * Whether a change at `changed` can affect a rule depending on `dep`.
+ * True in BOTH nesting directions: a change inside a dependency
+ * (`/a` vs `/a/b`) alters what the rule reads, and a change ABOVE one
+ * (`/a/b` vs `/a`) can replace the container it reads through.
+ * @param {string} dep @param {string} changed
+ * @returns {boolean}
+ */
+export function dependencyTouched(dep, changed) {
+  return isPointerPrefix(dep, changed) || isPointerPrefix(changed, dep);
+}
+
+/** Whether `prefix` is `pointer` itself or an ancestor location of it. */
+function isPointerPrefix(prefix, pointer) {
+  if (prefix === '') return true;
+  if (!pointer.startsWith(prefix)) return false;
+  return pointer.length === prefix.length || pointer.charCodeAt(prefix.length) === 0x2f;
+}
+
+/**
+ * Walk a rule document for path strings. A bare string is a path
+ * expression in this language, so every string is a candidate — except
+ * under `$const`, which is exactly the marker that its value is a
+ * literal.
+ */
+function collectStrings(node, out) {
+  if (typeof node === 'string') {
+    addPath(node, out);
+    return;
+  }
+  if (Array.isArray(node)) {
+    for (const item of node) collectStrings(item, out);
+    return;
+  }
+  if (node === null || typeof node !== 'object') return;
+  for (const key of Object.keys(node)) {
+    if (key === '$const') continue;
+    collectStrings(node[key], out);
+  }
+}
+
+/**
+ * Reduce one path string to its dependency prefix, if it is a
+ * root-anchored path at all. A variable-rooted path (`$item.price`) is
+ * not RFC 9535 and never parses here — deliberately: whatever the
+ * variable holds came from a root-anchored path in the same document,
+ * which this walk has already seen.
+ */
+function addPath(source, out) {
+  if (source.length === 0 || source.charCodeAt(0) !== 0x24) return; // not '$'
+  let ast;
+  try {
+    ast = parseJSONPath(source);
+  }
+  catch {
+    return; // a variable-rooted path, or not a path at all
+  }
+  out.add(prefixOf(ast.segments));
+  for (const segment of ast.segments) {
+    for (const selector of segment.selectors) {
+      if (selector.kind === 'filter') collectFilterQueries(selector.expr, out);
+    }
+  }
+}
+
+/** The literal pointer prefix a segment list starts with. */
+function prefixOf(segments) {
+  let pointer = '';
+  for (const segment of segments) {
+    if (segment.descendant || segment.selectors.length !== 1) break;
+    const selector = segment.selectors[0];
+    if (selector.kind === 'name')
+      pointer += `/${encodeJSONPointerSegment(selector.name)}`;
+    else if (selector.kind === 'index' && selector.index >= 0)
+      pointer += `/${selector.index}`;
+    else break;
+  }
+  return pointer;
+}
+
+/**
+ * Collect the root-anchored queries embedded in a filter expression —
+ * `$.selected` in `$.lines[?@.id == $.selected]` is a dependency of the
+ * enclosing rule as much as any top-level path is.
+ */
+function collectFilterQueries(node, out) {
+  if (node === null || typeof node !== 'object') return;
+  if (node.query !== undefined && Array.isArray(node.query.segments)) {
+    if (node.query.relative !== true) out.add(prefixOf(node.query.segments));
+    else collectFilterQueries(node.query, out);
+  }
+  for (const key of ['operands', 'operand', 'left', 'right', 'args', 'expr']) {
+    const child = node[key];
+    if (Array.isArray(child)) for (const item of child) collectFilterQueries(item, out);
+    else if (child !== undefined) collectFilterQueries(child, out);
+  }
+}

package/src/formats.js

@@ -17,6 +17,10 @@ import {
   numberFormatTesters,
 } from '@jarenjs/formats';
 
+import {
+  isValidGeoJson,
+} from '@jarenjs/core/geo';
+
 /**
  * @typedef {object} FormatInfo
  * @property {(value: string) => boolean} test - Synchronous validity test
@@ -26,22 +30,28 @@ import {
 
 /**
  * Rendering hints per format name. Formats without an entry render as a
- * plain text input (number-group formats as a number input).
- * @type {Record<string, { control?: string, placeholder?: string }>}
+ * plain text input (number-group formats as a number input). A hint may
+ * also override the canonical `test` when what a form field holds is not
+ * what the validator's format judges (a field holds `geojson` as text,
+ * the format applies to the parsed object).
+ * @type {Record<string, { control?: string, placeholder?: string, test?: (value: string) => boolean }>}
  */
 const FORM_HINTS = {
-  // -- date and time (RFC 3339 requires a timezone offset, which the HTML
-  //    time / datetime-local inputs cannot produce; those stay text inputs)
+  // -- date and time. Which formats get a native control is decided by
+  //    the offset, not by convenience: HTML's `datetime-local` and `time`
+  //    inputs cannot produce one, so binding them to the RFC 3339 formats
+  //    would make the control emit values its own schema rejects. The ISO
+  //    formats leave the offset optional and are exactly what those
+  //    inputs spell, so they map losslessly.
   'date': { control: 'date', placeholder: '2024-01-15' },
   'time': { placeholder: '13:45:30Z' },
   'date-time': { placeholder: '2024-01-15T13:45:30Z' },
-  'iso-date-time': { placeholder: '2024-01-15T13:45:30' },
-  'iso-time': { placeholder: '13:45:30' },
+  'iso-date-time': { control: 'datetime-local', placeholder: '2024-01-15T13:45:30' },
+  'iso-time': { control: 'time', placeholder: '13:45:30' },
   'duration': { placeholder: 'P3DT4H' },
 
   // -- email
   'email': { control: 'email', placeholder: 'user@example.com' },
-  'email--full': { control: 'email', placeholder: 'user@example.com' },
   'idn-email': { control: 'email', placeholder: 'user@example.com' },
 
   // -- hosts and addresses
@@ -53,12 +63,9 @@ const FORM_HINTS = {
 
   // -- uris
   'uri': { control: 'url', placeholder: 'https://example.com/path' },
-  'uri--full': { control: 'url', placeholder: 'https://example.com/path' },
   'uri-reference': { placeholder: '/relative/path' },
-  'uri-reference--full': { placeholder: '/relative/path' },
   'uri-template': { placeholder: '/users/{id}' },
   'url': { control: 'url', placeholder: 'https://example.com' },
-  'url--full': { control: 'url', placeholder: 'https://example.com' },
   'iri': { control: 'url', placeholder: 'https://example.com/päth' },
   'iri-reference': { placeholder: '/relative/päth' },
 
@@ -77,6 +84,7 @@ const FORM_HINTS = {
 
   // -- misc
   'regex': { placeholder: '^[a-z]+$' },
+  'iregexp': { placeholder: '[a-z]+' },
   'base64': { control: 'textarea', placeholder: 'SGVsbG8=' },
   'byte': { control: 'textarea', placeholder: 'SGVsbG8=' },
   'alpha': { placeholder: 'alpha' },
@@ -90,6 +98,23 @@ const FORM_HINTS = {
   'isbn13': { placeholder: '978-3-16-148410-0' },
   'iban': { placeholder: 'NL91ABNA0417164300' },
   'country2': { placeholder: 'NL' },
+
+  // -- geospatial. The geojson tester judges the OBJECT, but a form
+  //    field holds its text, so the field-level test parses first.
+  'geohash': { placeholder: 'u173z' },
+  'wkt': { placeholder: 'POINT (4.9041 52.3676)' },
+  'geojson': {
+    control: 'textarea',
+    placeholder: '{"type":"Point","coordinates":[4.9,52.4]}',
+    test: (text) => {
+      try {
+        return isValidGeoJson(JSON.parse(text));
+      }
+      catch {
+        return false;
+      }
+    },
+  },
 };
 
 function acceptAnything() {

package/src/index.js

@@ -25,6 +25,8 @@ export {
   compileFormRules,
   evaluateFormRules,
   formRulesToQueryAssertions,
+  pruneHiddenValues,
+  createRuleMemo,
 } from './rules.js';
 
 export {
@@ -32,6 +34,13 @@ export {
   validateAllFields,
 } from './validate.js';
 
+export {
+  formsMessagesEn,
+  formChromeLabels,
+  compileMessageTemplate,
+  compileMessageCatalog,
+} from './messages.js';
+
 export {
   createInitialData,
   createItemValue,
@@ -47,3 +56,7 @@ export {
   FORM_FORMATS,
   getFormatInfo,
 } from './formats.js';
+
+export {
+  buildFormViewModel,
+} from './viewmodel.js';

package/src/messages.js

@@ -0,0 +1,106 @@
+//@ts-check
+
+/**
+ * Forms message catalogs: structured field errors, rendered late.
+ *
+ * Every failure a form check produces is identified by a stable message
+ * key (`msgid`, the `form/`-prefixed keyword or `x-form/assert`) plus raw
+ * structured `params`; the human text comes from a catalog - a plain flat
+ * object of closures (or template strings that compile into closures).
+ * Forms keeps its second-person field voice ("This field is required"),
+ * hence the separate `form/*` key space next to the validator's document
+ * voice ("must have required property 'x'").
+ *
+ * Forms and the validator must serve one locale pack
+ * (`@jarenjs/locales`) each from its own key space, without either
+ * package depending on the other - so the catalog contract they share
+ * (template syntax, compilation, value rendering) is kernel property in
+ * `@jarenjs/core/message`. Both compilers are re-exported here so a form
+ * consumer never has to reach past `@jarenjs/forms`.
+ */
+
+import {
+  formatMessageValue,
+  compileMessageCatalog,
+} from '@jarenjs/core/message';
+
+export {
+  compileMessageTemplate,
+  compileMessageCatalog,
+} from '@jarenjs/core/message';
+
+//#region English catalog
+
+/**
+ * The built-in English forms catalog. Key set = exactly the `form/*` keys
+ * `validateField` emits, plus `x-form/assert` (the rules default). The
+ * strings are byte-identical to the historical inline template literals.
+ * @type {Record<string, string | ((params: object, error?: object) => string)>}
+ */
+export const formsMessagesEn = {
+  'form/required': 'This field is required',
+  'form/type': (p) => `Must be ${(p.type === 'integer' || p.type === 'array' || p.type === 'object') ? 'an' : 'a'} ${p.type}`,
+  'form/const': (p) => `Must be ${formatMessageValue(p.constValue)}`,
+  'form/enum': (p) => `Must be one of: ${p.enumValues?.map(formatMessageValue).join(', ')}`,
+  'form/minLength': (p) => `Must be at least ${p.limit} character${p.limit === 1 ? '' : 's'} (currently ${p.len})`,
+  'form/maxLength': (p) => `Must be at most ${p.limit} character${p.limit === 1 ? '' : 's'} (currently ${p.len})`,
+  'form/pattern': 'Must match pattern {pattern}',
+  'form/format': 'Must be a valid {format}',
+  'form/minimum': 'Must be at least {limit}',
+  'form/maximum': 'Must be at most {limit}',
+  'form/exclusiveMinimum': 'Must be greater than {limit}',
+  'form/exclusiveMaximum': 'Must be less than {limit}',
+  'form/multipleOf': 'Must be a multiple of {multipleOf}',
+  'form/minItems': (p) => `Must have at least ${p.limit} item${p.limit === 1 ? '' : 's'}`,
+  'form/maxItems': (p) => `Must have at most ${p.limit} item${p.limit === 1 ? '' : 's'}`,
+  'form/uniqueItems': 'Items must be unique',
+  'form/minProperties': 'Must have at least {limit} properties',
+  'form/maxProperties': 'Must have at most {limit} properties',
+  'x-form/assert': 'Invalid value',
+  // Form CHROME, not validation: the accessible names of the array
+  // buttons. A symbol-only button ('+', '×') is unreadable to a screen
+  // reader and untranslatable as a glyph, so the name travels as a
+  // message like every other string an operator can hear.
+  'form/addItem': 'Add item',
+  'form/removeItem': 'Remove item',
+};
+
+/** The compiled built-in English catalog (module-level singleton). */
+export const formsMessages = compileMessageCatalog(formsMessagesEn);
+
+/**
+ * Resolve a message key through a caller catalog with built-in English
+ * fallback and render it.
+ * @param {Readonly<Record<string, (params: object, error?: object) => string>>|undefined} catalog - A compiled catalog, or undefined for English
+ * @param {string} msgid - The message key
+ * @param {object} params - The structured params
+ * @returns {string} The rendered message
+ */
+export function renderFormsMessage(catalog, msgid, params) {
+  let render = catalog !== undefined ? catalog[msgid] : undefined;
+  if (render === undefined) render = formsMessages[msgid];
+  if (render === undefined) return msgid;
+  return render(params);
+}
+
+/**
+ * The localized chrome strings a form renderer needs: the accessible
+ * names of the array add/remove buttons.
+ *
+ * The stylesheet that renders a form is plain JSON built once, so it
+ * cannot look anything up at render time — the host resolves these and
+ * hands them to `createFormView`. Kept next to the error catalog on
+ * purpose: one keyspace, one parity gate across every locale pack.
+ * @param {Readonly<Record<string, (params: object, error?: object) => string>>} [catalog] - A compiled catalog, or undefined for English
+ * @returns {{addItem: string, removeItem: string}}
+ * @example
+ * createFormView({ labels: formChromeLabels(catalogs[locale]) });
+ */
+export function formChromeLabels(catalog = undefined) {
+  return {
+    addItem: renderFormsMessage(catalog, 'form/addItem', {}),
+    removeItem: renderFormsMessage(catalog, 'form/removeItem', {}),
+  };
+}
+
+//#endregion