@datamoc/mw_games 0.4.0 → 0.4.2

package/dist/i18n/Content.js

@@ -0,0 +1,219 @@
+import { diffCatalogKeys } from './Validate.js';
+/**
+ * A catalog message reduced to plain, comparable text: a string as-is, a `PluralForms`
+ * reduced to its `other` branch (or the first form present, the same fallback
+ * `resolvePlural` itself uses with no count), and a `FluentMessage` formatted with no
+ * params - best-effort, since a `.ftl` message needing a required variable throws rather
+ * than resolving; that failure reads as empty text here rather than aborting the caller's
+ * whole scan.
+ *
+ * @example
+ * ```ts
+ * import { messageText } from '@datamoc/mw_games/i18n';
+ *
+ * messageText('Hello'); // 'Hello'
+ * messageText({ one: '1 item', other: '{count} items' }); // '{count} items'
+ * ```
+ */
+export function messageText(value) {
+    if (typeof value === 'string')
+        return value;
+    if (typeof value === 'object' && value !== null && 'format' in value) {
+        try {
+            return value.format();
+        }
+        catch {
+            return '';
+        }
+    }
+    const forms = value;
+    return forms.other ?? Object.values(forms)[0] ?? '';
+}
+/**
+ * The classic edit distance: how many single-character insertions, deletions or
+ * substitutions turn `a` into `b`. The primitive `findSimilarMessages` is built on, exposed
+ * on its own since "how different are these two strings" is useful wherever a catalog's own
+ * message text is not the only thing worth comparing.
+ *
+ * @example
+ * ```ts
+ * import { levenshteinDistance } from '@datamoc/mw_games/i18n';
+ *
+ * levenshteinDistance('kitten', 'sitting'); // 3
+ * levenshteinDistance('same', 'same'); // 0
+ * ```
+ */
+export function levenshteinDistance(a, b) {
+    if (a === b)
+        return 0;
+    if (a.length === 0)
+        return b.length;
+    if (b.length === 0)
+        return a.length;
+    let previous = Array.from({ length: b.length + 1 }, (_, i) => i);
+    let current = new Array(b.length + 1);
+    for (let i = 1; i <= a.length; i++) {
+        current[0] = i;
+        for (let j = 1; j <= b.length; j++) {
+            const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+            current[j] = Math.min(previous[j] + 1, //deletion
+            current[j - 1] + 1, //insertion
+            previous[j - 1] + cost //substitution
+            );
+        }
+        [previous, current] = [current, previous];
+    }
+    return previous[b.length];
+}
+/**
+ * Every pair of keys in `catalog` whose message text is at least `minSimilarity` alike
+ * (default 0.8), surfaced for a human to decide whether they are genuinely the same message
+ * translated three separate times - `mwg` finds the candidates, never merges anything on
+ * its own. Empty messages are skipped (nothing to compare), and pairs are sorted most
+ * similar first.
+ *
+ * @example
+ * ```ts
+ * import { findSimilarMessages } from '@datamoc/mw_games/i18n';
+ *
+ * const catalog = {
+ *   locale: 'en', direction: 'ltr' as const,
+ *   messages: { 'confirm.quit': 'Are you sure?', 'confirm.delete': 'Are you sure?' },
+ * };
+ *
+ * findSimilarMessages(catalog); // [{ a: 'confirm.quit', b: 'confirm.delete', distance: 0, similarity: 1 }]
+ * ```
+ */
+export function findSimilarMessages(catalog, minSimilarity = 0.8) {
+    const entries = Object.entries(catalog.messages)
+        .map(([key, value]) => [key, messageText(value)])
+        .filter(([, text]) => text.length > 0);
+    const pairs = [];
+    for (let i = 0; i < entries.length; i++) {
+        for (let j = i + 1; j < entries.length; j++) {
+            const [keyA, textA] = entries[i];
+            const [keyB, textB] = entries[j];
+            const maxLen = Math.max(textA.length, textB.length);
+            const distance = levenshteinDistance(textA, textB);
+            const similarity = maxLen === 0 ? 1 : 1 - distance / maxLen;
+            if (similarity >= minSimilarity)
+                pairs.push({ a: keyA, b: keyB, distance, similarity });
+        }
+    }
+    return pairs.sort((x, y) => y.similarity - x.similarity);
+}
+/**
+ * Which of a catalog's keys a game's own source actually references, and which just sit
+ * there. `mwg` has no idea how a game's code names a message key (a string literal, a
+ * generated constant, a `SemanticMessage.type`) - `referencedKeys` is however the caller
+ * already found that out (typically a grep or a build-time scan over its own source), the
+ * same boundary `rollRoster` draws around a game's own roster values.
+ *
+ * @example
+ * ```ts
+ * import { catalogUsage } from '@datamoc/mw_games/i18n';
+ *
+ * const catalog = {
+ *   locale: 'en', direction: 'ltr' as const,
+ *   messages: { greeting: 'Hi', unused: 'never shown' },
+ * };
+ *
+ * catalogUsage(catalog, ['greeting']); // { totalKeys: 2, usedKeys: 1, unusedKeys: ['unused'] }
+ * ```
+ */
+export function catalogUsage(catalog, referencedKeys) {
+    const referenced = new Set(referencedKeys);
+    const keys = Object.keys(catalog.messages);
+    const unusedKeys = keys.filter((key) => !referenced.has(key));
+    return { totalKeys: keys.length, usedKeys: keys.length - unusedKeys.length, unusedKeys };
+}
+/**
+ * How complete `other` is against `reference`, as a 0-1 fraction of `reference`'s own keys
+ * that `other` also has - built on `diffCatalogKeys` rather than recomputing the same set
+ * difference, so the two never disagree about what "missing" means.
+ *
+ * @example
+ * ```ts
+ * import { catalogCompleteness } from '@datamoc/mw_games/i18n';
+ *
+ * const en = { locale: 'en', direction: 'ltr' as const, messages: { a: '1', b: '2' } };
+ * const fr = { locale: 'fr', direction: 'ltr' as const, messages: { a: '1' } };
+ *
+ * catalogCompleteness(en, fr); // 0.5
+ * ```
+ */
+export function catalogCompleteness(reference, other) {
+    const referenceKeys = Object.keys(reference.messages);
+    if (referenceKeys.length === 0)
+        return 1;
+    const { missing } = diffCatalogKeys(reference, other);
+    return (referenceKeys.length - missing.length) / referenceKeys.length;
+}
+/**
+ * How many of a catalog's plural-form messages define each CLDR category - `'few'`/`'many'`
+ * sitting at 0 while `'other'` covers every key is exactly the gap a language needing those
+ * categories (Polish, Arabic) would otherwise only discover once a player hit the wrong count.
+ *
+ * @example
+ * ```ts
+ * import { pluralFormCoverage } from '@datamoc/mw_games/i18n';
+ *
+ * const catalog = {
+ *   locale: 'en', direction: 'ltr' as const,
+ *   messages: { items: { one: '{count} item', other: '{count} items' } },
+ * };
+ *
+ * pluralFormCoverage(catalog); // { pluralKeys: 1, formsPresent: { one: 1, other: 1 } }
+ * ```
+ */
+export function pluralFormCoverage(catalog) {
+    const formsPresent = {};
+    let pluralKeys = 0;
+    for (const value of Object.values(catalog.messages)) {
+        if (typeof value === 'string' || (typeof value === 'object' && value !== null && 'format' in value))
+            continue;
+        pluralKeys++;
+        for (const category of Object.keys(value)) {
+            formsPresent[category] = (formsPresent[category] ?? 0) + 1;
+        }
+    }
+    return { pluralKeys, formsPresent };
+}
+/**
+ * Drops `mergedKey` from `catalog`, keeping `survivingKey` (and its current text) exactly as
+ * it was - the mechanical half of collapsing two keys a human decided are the same message.
+ * Apply this to every language's own catalog to merge consistently across all of them.
+ *
+ * Rewriting whichever call sites used `mergedKey` is deliberately not this function's job:
+ * `mwg` has no view into a game's own source tree, the same boundary `catalogUsage`'s
+ * `referencedKeys` already draws - a caller doing that rewrite already knows exactly where
+ * `mergedKey` is used, since it had to find `referencedKeys` the same way to begin with.
+ *
+ * @example
+ * ```ts
+ * import { mergeCatalogKeys } from '@datamoc/mw_games/i18n';
+ *
+ * const catalog = {
+ *   locale: 'en', direction: 'ltr' as const,
+ *   messages: { 'confirm.quit': 'Are you sure?', 'confirm.delete': 'Are you sure?' },
+ * };
+ *
+ * const merged = mergeCatalogKeys(catalog, 'confirm.quit', 'confirm.delete');
+ * console.log(Object.keys(merged.messages)); // ['confirm.quit']
+ * ```
+ */
+export function mergeCatalogKeys(catalog, survivingKey, mergedKey) {
+    if (!(survivingKey in catalog.messages)) {
+        throw new Error(`mergeCatalogKeys: "${survivingKey}" is not a key in this catalog`);
+    }
+    if (!(mergedKey in catalog.messages)) {
+        throw new Error(`mergeCatalogKeys: "${mergedKey}" is not a key in this catalog`);
+    }
+    if (survivingKey === mergedKey) {
+        throw new Error('mergeCatalogKeys: survivingKey and mergedKey must be different keys');
+    }
+    const messages = { ...catalog.messages };
+    delete messages[mergedKey];
+    return { ...catalog, messages };
+}
+//# sourceMappingURL=Content.js.map

package/dist/i18n/Content.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Content.js","sourceRoot":"","sources":["../../src/i18n/Content.ts"],"names":[],"mappings":"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"}

package/dist/i18n/Format.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Locale-aware number/date/list formatting, for a catalog message that needs more than
+ * `{token}` substitution can give it - "1,234" vs "1 234", "3 items" vs "3 éléments" joined
+ * with "and"/"et". A game calls these while building a `t()`/`SemanticMessage` param, the
+ * same way it already resolves an entity id to display text; MWG does not parse a format
+ * directive out of the message string itself.
+ *
+ * All three read the active locale from `i18n`'s own `locale()`, so a language switch takes
+ * effect the same way it already does for plurals and typography.
+ *
+ * @example
+ * ```ts
+ * import { setActive, t, formatNumber, formatDate, formatList } from '@datamoc/mw_games/i18n';
+ *
+ * setActive({ locale: 'fr-FR', direction: 'ltr', messages: { found: 'Vous trouvez {amount}.' } });
+ *
+ * console.log(formatNumber(1234.5)); // '1 234,5'
+ * console.log(formatDate(new Date(2024, 0, 15))); // '15/01/2024'
+ * console.log(t('found', { amount: formatList(['une épée', 'un bouclier']) })); // '... une épée et un bouclier.'
+ * ```
+ */
+export declare function formatNumber(value: number, options?: Intl.NumberFormatOptions): string;
+export declare function formatDate(value: Date | number, options?: Intl.DateTimeFormatOptions): string;
+export declare function formatList(items: readonly string[], options?: Intl.ListFormatOptions): string;
+//# sourceMappingURL=Format.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Format.d.ts","sourceRoot":"","sources":["../../src/i18n/Format.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,IAAI,CAAC,mBAAmB,GAAG,MAAM,CAEtF;AAED,wBAAgB,UAAU,CAAC,KAAK,EAAE,IAAI,GAAG,MAAM,EAAE,OAAO,CAAC,EAAE,IAAI,CAAC,qBAAqB,GAAG,MAAM,CAE7F;AAED,wBAAgB,UAAU,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,EAAE,OAAO,CAAC,EAAE,IAAI,CAAC,iBAAiB,GAAG,MAAM,CAE7F"}

package/dist/i18n/Format.js

@@ -0,0 +1,32 @@
+import { locale } from './index.js';
+/**
+ * Locale-aware number/date/list formatting, for a catalog message that needs more than
+ * `{token}` substitution can give it - "1,234" vs "1 234", "3 items" vs "3 éléments" joined
+ * with "and"/"et". A game calls these while building a `t()`/`SemanticMessage` param, the
+ * same way it already resolves an entity id to display text; MWG does not parse a format
+ * directive out of the message string itself.
+ *
+ * All three read the active locale from `i18n`'s own `locale()`, so a language switch takes
+ * effect the same way it already does for plurals and typography.
+ *
+ * @example
+ * ```ts
+ * import { setActive, t, formatNumber, formatDate, formatList } from '@datamoc/mw_games/i18n';
+ *
+ * setActive({ locale: 'fr-FR', direction: 'ltr', messages: { found: 'Vous trouvez {amount}.' } });
+ *
+ * console.log(formatNumber(1234.5)); // '1 234,5'
+ * console.log(formatDate(new Date(2024, 0, 15))); // '15/01/2024'
+ * console.log(t('found', { amount: formatList(['une épée', 'un bouclier']) })); // '... une épée et un bouclier.'
+ * ```
+ */
+export function formatNumber(value, options) {
+    return new Intl.NumberFormat(locale(), options).format(value);
+}
+export function formatDate(value, options) {
+    return new Intl.DateTimeFormat(locale(), options).format(value);
+}
+export function formatList(items, options) {
+    return new Intl.ListFormat(locale(), options).format(items);
+}
+//# sourceMappingURL=Format.js.map

package/dist/i18n/Format.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Format.js","sourceRoot":"","sources":["../../src/i18n/Format.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AAEpC;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,UAAU,YAAY,CAAC,KAAa,EAAE,OAAkC;IAC7E,OAAO,IAAI,IAAI,CAAC,YAAY,CAAC,MAAM,EAAE,EAAE,OAAO,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;AAC/D,CAAC;AAED,MAAM,UAAU,UAAU,CAAC,KAAoB,EAAE,OAAoC;IACpF,OAAO,IAAI,IAAI,CAAC,cAAc,CAAC,MAAM,EAAE,EAAE,OAAO,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;AACjE,CAAC;AAED,MAAM,UAAU,UAAU,CAAC,KAAwB,EAAE,OAAgC;IACpF,OAAO,IAAI,IAAI,CAAC,UAAU,CAAC,MAAM,EAAE,EAAE,OAAO,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;AAC7D,CAAC"}

package/dist/i18n/SemanticMessage.d.ts

@@ -0,0 +1,71 @@
+/**
+ * A structured communication intent, not a finished sentence: a type naming what happened,
+ * plus the parameters a catalog needs to say it. The same message renders as a full log
+ * line, a compact HUD number, an accessibility announcement, or a debug dump, all from one
+ * event the simulation only has to produce once.
+ *
+ * `params` must already be interpolation-ready by the time a message reaches
+ * `MessageFormatter.format` - a game resolves any entity/item id to display text itself
+ * (typically through its own `EntityTextResolver`) while building the message, the same way
+ * it decides everything else about its own vocabulary. MWG only defines the shape.
+ */
+export interface SemanticMessage<TType extends string = string, TParams extends Record<string, unknown> = Record<string, unknown>> {
+    type: TType;
+    params: TParams;
+}
+/**
+ * Resolves a game-defined entity/item id to the display text a message substitutes for it.
+ * A type contract only - MWG never calls this itself; a game calls it while building a
+ * `SemanticMessage`'s params, the same way it already owns every other piece of vocabulary.
+ */
+export type EntityTextResolver<Id = string> = (id: Id) => string;
+/**
+ * Optional linguistic metadata about one entity - gender, number, or a proper-noun flag a
+ * catalog's own grammar rules may need to pick an article or an agreement. MWG never
+ * interprets this itself; it exists so a game's `EntityTextResolver` and catalog can agree
+ * on a common shape instead of each game inventing its own.
+ */
+export interface GrammaticalEntity {
+    gender?: 'masculine' | 'feminine' | 'neuter' | 'common';
+    plural?: boolean;
+    properNoun?: boolean;
+    /** other lexical forms a catalog's grammar might need - a possessive, a vocative */
+    forms?: Record<string, string>;
+}
+/** Where the same semantic message ends up: a game log line, a compact HUD number, an
+ * accessibility announcement, or a debug dump - one simulation event, several presentations. */
+export type MessageChannel = 'log' | 'compact' | 'accessibility' | 'debug';
+export interface MessageFormatter {
+    format(message: SemanticMessage, channel: MessageChannel): string;
+}
+/**
+ * The reference `MessageFormatter`: looks up `${type}.${channel}` in the active catalog
+ * (`setBase`/`setActive`, `src/i18n/index.ts`), falling back to `${type}` alone for a message
+ * that reads the same on every channel, then formats through `t()` - the same interpolation,
+ * pluralisation and RTL handling every other message in the game already gets. A catalog
+ * missing both keys fails the same observable way `t()` already does for any key: returning
+ * the lookup key itself, rather than throwing or going silent.
+ *
+ * @example
+ * ```ts
+ * import { setBase, createCatalogFormatter, type SemanticMessage } from '@datamoc/mw_games/i18n';
+ *
+ * setBase({
+ *   locale: 'en',
+ *   direction: 'ltr',
+ *   messages: {
+ *     'combat.damage.log': 'The {target} takes {amount} damage.',
+ *     'combat.damage.compact': '-{amount} HP',
+ *   },
+ * });
+ *
+ * const formatter = createCatalogFormatter();
+ * const message: SemanticMessage = { type: 'combat.damage', params: { target: 'gnoll', amount: 7 } };
+ *
+ * console.log(formatter.format(message, 'log'));     // 'The gnoll takes 7 damage.'
+ * console.log(formatter.format(message, 'compact'));  // '-7 HP'
+ * console.log(formatter.format(message, 'debug'));    // falls back to the bare type: the key itself, if undeclared
+ * ```
+ */
+export declare function createCatalogFormatter(): MessageFormatter;
+//# sourceMappingURL=SemanticMessage.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"SemanticMessage.d.ts","sourceRoot":"","sources":["../../src/i18n/SemanticMessage.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;GAUG;AACH,MAAM,WAAW,eAAe,CAC/B,KAAK,SAAS,MAAM,GAAG,MAAM,EAC7B,OAAO,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAEjE,IAAI,EAAE,KAAK,CAAC;IACZ,MAAM,EAAE,OAAO,CAAC;CAChB;AAED;;;;GAIG;AACH,MAAM,MAAM,kBAAkB,CAAC,EAAE,GAAG,MAAM,IAAI,CAAC,EAAE,EAAE,EAAE,KAAK,MAAM,CAAC;AAEjE;;;;;GAKG;AACH,MAAM,WAAW,iBAAiB;IACjC,MAAM,CAAC,EAAE,WAAW,GAAG,UAAU,GAAG,QAAQ,GAAG,QAAQ,CAAC;IACxD,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,oFAAoF;IACpF,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC/B;AAED;gGACgG;AAChG,MAAM,MAAM,cAAc,GAAG,KAAK,GAAG,SAAS,GAAG,eAAe,GAAG,OAAO,CAAC;AAE3E,MAAM,WAAW,gBAAgB;IAChC,MAAM,CAAC,OAAO,EAAE,eAAe,EAAE,OAAO,EAAE,cAAc,GAAG,MAAM,CAAC;CAClE;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,sBAAsB,IAAI,gBAAgB,CAQzD"}

package/dist/i18n/SemanticMessage.js

@@ -0,0 +1,40 @@
+import { t, has } from './index.js';
+/**
+ * The reference `MessageFormatter`: looks up `${type}.${channel}` in the active catalog
+ * (`setBase`/`setActive`, `src/i18n/index.ts`), falling back to `${type}` alone for a message
+ * that reads the same on every channel, then formats through `t()` - the same interpolation,
+ * pluralisation and RTL handling every other message in the game already gets. A catalog
+ * missing both keys fails the same observable way `t()` already does for any key: returning
+ * the lookup key itself, rather than throwing or going silent.
+ *
+ * @example
+ * ```ts
+ * import { setBase, createCatalogFormatter, type SemanticMessage } from '@datamoc/mw_games/i18n';
+ *
+ * setBase({
+ *   locale: 'en',
+ *   direction: 'ltr',
+ *   messages: {
+ *     'combat.damage.log': 'The {target} takes {amount} damage.',
+ *     'combat.damage.compact': '-{amount} HP',
+ *   },
+ * });
+ *
+ * const formatter = createCatalogFormatter();
+ * const message: SemanticMessage = { type: 'combat.damage', params: { target: 'gnoll', amount: 7 } };
+ *
+ * console.log(formatter.format(message, 'log'));     // 'The gnoll takes 7 damage.'
+ * console.log(formatter.format(message, 'compact'));  // '-7 HP'
+ * console.log(formatter.format(message, 'debug'));    // falls back to the bare type: the key itself, if undeclared
+ * ```
+ */
+export function createCatalogFormatter() {
+    return {
+        format(message, channel) {
+            const key = `${message.type}.${channel}`;
+            const params = message.params;
+            return has(key) ? t(key, params) : t(message.type, params);
+        },
+    };
+}
+//# sourceMappingURL=SemanticMessage.js.map

package/dist/i18n/SemanticMessage.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SemanticMessage.js","sourceRoot":"","sources":["../../src/i18n/SemanticMessage.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,GAAG,EAAsB,MAAM,YAAY,CAAC;AAkDxD;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,MAAM,UAAU,sBAAsB;IACrC,OAAO;QACN,MAAM,CAAC,OAAwB,EAAE,OAAuB;YACvD,MAAM,GAAG,GAAG,GAAG,OAAO,CAAC,IAAI,IAAI,OAAO,EAAE,CAAC;YACzC,MAAM,MAAM,GAAG,OAAO,CAAC,MAAuB,CAAC;YAC/C,OAAO,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;QAC5D,CAAC;KACD,CAAC;AACH,CAAC"}

package/dist/i18n/Validate.d.ts

@@ -0,0 +1,56 @@
+import type { Catalog } from './index.ts';
+/** the keys two catalogs disagree on - what a translation catalog missing a key, or one
+ * abandoned key nobody removed, looks like structurally. */
+export interface CatalogKeyDiff {
+    /** in `reference` but not `other` - an untranslated key */
+    missing: readonly string[];
+    /** in `other` but not `reference` - a stale or misspelled key */
+    extra: readonly string[];
+}
+/**
+ * Compares two catalogs' key sets - typically a base language against a translation, so a
+ * missing or stray key is caught before a player sees a raw key fall through `t()`'s own
+ * fallback, rather than after.
+ *
+ * @example
+ * ```ts
+ * import { diffCatalogKeys } from '@datamoc/mw_games/i18n';
+ *
+ * const en = { locale: 'en', direction: 'ltr' as const, messages: { greeting: 'Hello', farewell: 'Bye' } };
+ * const fr = { locale: 'fr', direction: 'ltr' as const, messages: { greeting: 'Bonjour', extra: 'oops' } };
+ *
+ * console.log(diffCatalogKeys(en, fr)); // { missing: ['farewell'], extra: ['extra'] }
+ * ```
+ */
+export declare function diffCatalogKeys(reference: Catalog, other: Catalog): CatalogKeyDiff;
+export interface CatalogIssue {
+    key: string;
+    kind: 'empty-message' | 'plural-missing-other';
+    detail: string;
+}
+/**
+ * Structural problems inside one catalog, independent of any other: an empty string, or a
+ * plural form with no `other` branch - `Intl.PluralRules` guarantees `other` is always a
+ * valid category for every locale, so a form set lacking it will silently degrade for any
+ * count the more specific branches don't cover (`t()`'s own `resolvePlural` falls back to
+ * *any* form present, which hides exactly this mistake instead of surfacing it).
+ *
+ * This is deliberately not a parameter schema validator: `SemanticMessage<TType, TParams>`
+ * already gives a game compile-time checking of which params a message needs, which the
+ * source document calls the primary mechanism - a runtime schema on top would duplicate that
+ * for no case a game's own types do not already catch.
+ *
+ * @example
+ * ```ts
+ * import { validateCatalog } from '@datamoc/mw_games/i18n';
+ *
+ * const catalog = {
+ *   locale: 'en', direction: 'ltr' as const,
+ *   messages: { empty: '', broken: { few: 'a few' } },
+ * };
+ *
+ * console.log(validateCatalog(catalog).map((issue) => issue.key)); // ['empty', 'broken']
+ * ```
+ */
+export declare function validateCatalog(catalog: Catalog): CatalogIssue[];
+//# sourceMappingURL=Validate.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Validate.d.ts","sourceRoot":"","sources":["../../src/i18n/Validate.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAgB,MAAM,YAAY,CAAC;AAExD;4DAC4D;AAC5D,MAAM,WAAW,cAAc;IAC9B,2DAA2D;IAC3D,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;IAC3B,iEAAiE;IACjE,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;CACzB;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,eAAe,CAAC,SAAS,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,GAAG,cAAc,CAOlF;AAED,MAAM,WAAW,YAAY;IAC5B,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,eAAe,GAAG,sBAAsB,CAAC;IAC/C,MAAM,EAAE,MAAM,CAAC;CACf;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,OAAO,GAAG,YAAY,EAAE,CAchE"}

package/dist/i18n/Validate.js

@@ -0,0 +1,65 @@
+/**
+ * Compares two catalogs' key sets - typically a base language against a translation, so a
+ * missing or stray key is caught before a player sees a raw key fall through `t()`'s own
+ * fallback, rather than after.
+ *
+ * @example
+ * ```ts
+ * import { diffCatalogKeys } from '@datamoc/mw_games/i18n';
+ *
+ * const en = { locale: 'en', direction: 'ltr' as const, messages: { greeting: 'Hello', farewell: 'Bye' } };
+ * const fr = { locale: 'fr', direction: 'ltr' as const, messages: { greeting: 'Bonjour', extra: 'oops' } };
+ *
+ * console.log(diffCatalogKeys(en, fr)); // { missing: ['farewell'], extra: ['extra'] }
+ * ```
+ */
+export function diffCatalogKeys(reference, other) {
+    const referenceKeys = new Set(Object.keys(reference.messages));
+    const otherKeys = new Set(Object.keys(other.messages));
+    return {
+        missing: [...referenceKeys].filter((key) => !otherKeys.has(key)),
+        extra: [...otherKeys].filter((key) => !referenceKeys.has(key)),
+    };
+}
+/**
+ * Structural problems inside one catalog, independent of any other: an empty string, or a
+ * plural form with no `other` branch - `Intl.PluralRules` guarantees `other` is always a
+ * valid category for every locale, so a form set lacking it will silently degrade for any
+ * count the more specific branches don't cover (`t()`'s own `resolvePlural` falls back to
+ * *any* form present, which hides exactly this mistake instead of surfacing it).
+ *
+ * This is deliberately not a parameter schema validator: `SemanticMessage<TType, TParams>`
+ * already gives a game compile-time checking of which params a message needs, which the
+ * source document calls the primary mechanism - a runtime schema on top would duplicate that
+ * for no case a game's own types do not already catch.
+ *
+ * @example
+ * ```ts
+ * import { validateCatalog } from '@datamoc/mw_games/i18n';
+ *
+ * const catalog = {
+ *   locale: 'en', direction: 'ltr' as const,
+ *   messages: { empty: '', broken: { few: 'a few' } },
+ * };
+ *
+ * console.log(validateCatalog(catalog).map((issue) => issue.key)); // ['empty', 'broken']
+ * ```
+ */
+export function validateCatalog(catalog) {
+    const issues = [];
+    for (const [key, value] of Object.entries(catalog.messages)) {
+        if (typeof value === 'string') {
+            if (value === '')
+                issues.push({ key, kind: 'empty-message', detail: 'message resolves to an empty string' });
+            continue;
+        }
+        if (isPluralForms(value) && value.other === undefined) {
+            issues.push({ key, kind: 'plural-missing-other', detail: 'plural forms have no "other" branch' });
+        }
+    }
+    return issues;
+}
+function isPluralForms(value) {
+    return typeof value === 'object' && value !== null && !('format' in value);
+}
+//# sourceMappingURL=Validate.js.map

package/dist/i18n/Validate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Validate.js","sourceRoot":"","sources":["../../src/i18n/Validate.ts"],"names":[],"mappings":"AAWA;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,eAAe,CAAC,SAAkB,EAAE,KAAc;IACjE,MAAM,aAAa,GAAG,IAAI,GAAG,CAAC,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC,CAAC;IAC/D,MAAM,SAAS,GAAG,IAAI,GAAG,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC,CAAC;IACvD,OAAO;QACN,OAAO,EAAE,CAAC,GAAG,aAAa,CAAC,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC,SAAS,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QAChE,KAAK,EAAE,CAAC,GAAG,SAAS,CAAC,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC,aAAa,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;KAC9D,CAAC;AACH,CAAC;AAQD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,MAAM,UAAU,eAAe,CAAC,OAAgB;IAC/C,MAAM,MAAM,GAAmB,EAAE,CAAC;IAElC,KAAK,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAC;QAC7D,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;YAC/B,IAAI,KAAK,KAAK,EAAE;gBAAE,MAAM,CAAC,IAAI,CAAC,EAAE,GAAG,EAAE,IAAI,EAAE,eAAe,EAAE,MAAM,EAAE,qCAAqC,EAAE,CAAC,CAAC;YAC7G,SAAS;QACV,CAAC;QACD,IAAI,aAAa,CAAC,KAAK,CAAC,IAAI,KAAK,CAAC,KAAK,KAAK,SAAS,EAAE,CAAC;YACvD,MAAM,CAAC,IAAI,CAAC,EAAE,GAAG,EAAE,IAAI,EAAE,sBAAsB,EAAE,MAAM,EAAE,qCAAqC,EAAE,CAAC,CAAC;QACnG,CAAC;IACF,CAAC;IAED,OAAO,MAAM,CAAC;AACf,CAAC;AAED,SAAS,aAAa,CAAC,KAAmB;IACzC,OAAO,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,IAAI,IAAI,CAAC,CAAC,QAAQ,IAAI,KAAK,CAAC,CAAC;AAC5E,CAAC"}

package/dist/i18n/index.d.ts

@@ -13,6 +13,40 @@
  * A missing key in the active language falls back to the base language rather than showing
  * a raw key to the player - a translation catalog is nearly always incomplete somewhere,
  * and a placeholder key breaks immersion far worse than the wrong language would.
+ *
+ * @example
+ * ```ts
+ * import { setBase, setActive, t, locale, direction, typographic, parseFTL, reset } from '@datamoc/mw_games/i18n';
+ *
+ * setBase({ locale: 'en', direction: 'ltr', messages: { greeting: 'Hello, {name}!' } });
+ *
+ * const french = parseFTL('fr', 'greeting = Bonjour, { $name } !');
+ * setActive(french);
+ *
+ * console.log(t('greeting', { name: 'Ada' })); // 'Bonjour, Ada !'
+ * console.log(locale(), direction()); // 'fr' 'ltr'
+ * console.log(typographic("aujourd'hui")); // "aujourd’hui"
+ *
+ * reset(); // back to unset, for the next test or a language switch from scratch
+ * ```
+ *
+ * `createCatalogFormatter` (`SemanticMessage.ts`) sits on top of the same catalog: a
+ * simulation emits one typed `SemanticMessage` and a game renders it differently per channel
+ * (log line, compact HUD, accessibility, debug) without touching the message itself.
+ * ```ts
+ * import { setBase, createCatalogFormatter, type SemanticMessage } from '@datamoc/mw_games/i18n';
+ *
+ * setBase({
+ *   locale: 'en',
+ *   direction: 'ltr',
+ *   messages: { 'combat.damage.log': 'The {target} takes {amount} damage.', 'combat.damage.compact': '-{amount} HP' },
+ * });
+ *
+ * const formatter = createCatalogFormatter();
+ * const message: SemanticMessage = { type: 'combat.damage', params: { target: 'gnoll', amount: 7 } };
+ * console.log(formatter.format(message, 'log'), formatter.format(message, 'compact'));
+ * // 'The gnoll takes 7 damage.' '-7 HP'
+ * ```
  */
 /** left-to-right is the default; right-to-left is the other case `mwg/ui` mirrors against */
 export type Direction = 'ltr' | 'rtl';
@@ -51,15 +85,52 @@ export interface MessageParams {
  */
 export declare function t(key: string, params?: MessageParams): string;
 /**
- * Replaces apostrophes between letters for locales whose ordinary elisions use a curly
- * apostrophe. English and other locales are left untouched, as a straight apostrophe can
- * be intentional punctuation there.
+ * Locale-specific punctuation/spacing conventions, applied on top of interpolation - the
+ * things a translator would type by hand if this project asked every catalog to carry
+ * literal U+202F/U+00A0 characters, which no one would ever remember to do consistently.
+ *
+ * French (Imprimerie nationale's rules, `Lexique des règles typographiques`): a narrow
+ * no-break space before `; : ! ?` and around `« »`, and an ordinary no-break space between a
+ * numbering word and the number following it ("Chapitre 3"). Also replaces apostrophes
+ * between letters with a curly one, for French, Italian, and Dutch elisions - English and
+ * other locales are left untouched, as a straight apostrophe can be intentional punctuation
+ * there.
+ *
+ * German (Duden K 116/117): a no-break space between a number and its unit ("5 kg"), and
+ * after a small set of abbreviations before whatever follows ("Nr. 3", "Dr. Müller").
+ *
+ * Deliberately not attempted here: a *game's own* units ("pièces d'or", "points de vie") -
+ * `mwg` cannot know a game's vocabulary any more than it knows its item names, so gluing a
+ * value to a game-specific unit is `nonBreakingUnit`'s job, not this function's.
  */
 export declare function typographic(text: string, language?: string): string;
+/** joins a value and its unit with whatever space French/German typography requires to keep
+ * them from breaking across a line - the unit's own text ("pièces d'or", "points de vie",
+ * "kg") is always the game's own vocabulary; this only picks the space that glues it to the
+ * value in front of it, the same division `SemanticMessage`/`EntityTextResolver` already draw
+ * between mechanism and content.
+ *
+ * @example
+ * ```ts
+ * import { nonBreakingUnit } from '@datamoc/mw_games/i18n';
+ *
+ * console.log(nonBreakingUnit(12, 'pièces d\'or', 'fr')); // '12 pièces d\'or'
+ * console.log(nonBreakingUnit(5, 'kg', 'de')); // '5 kg'
+ * console.log(nonBreakingUnit(3, 'gold', 'en')); // '3 gold'
+ * ```
+ */
+export declare function nonBreakingUnit(value: string | number, unit: string, language?: string): string;
 /** true when `key` resolves to something other than itself, in either language */
 export declare function has(key: string): boolean;
 /** clears both languages, mainly so tests do not leak state into one another */
 export declare function reset(): void;
 export { parseFTL } from './Fluent.ts';
 export type { FluentOptions } from './Fluent.ts';
+export { createCatalogFormatter } from './SemanticMessage.ts';
+export type { SemanticMessage, EntityTextResolver, GrammaticalEntity, MessageChannel, MessageFormatter } from './SemanticMessage.ts';
+export { formatNumber, formatDate, formatList } from './Format.ts';
+export { diffCatalogKeys, validateCatalog } from './Validate.ts';
+export type { CatalogKeyDiff, CatalogIssue } from './Validate.ts';
+export { messageText, levenshteinDistance, findSimilarMessages, catalogUsage, catalogCompleteness, pluralFormCoverage, mergeCatalogKeys, } from './Content.ts';
+export type { SimilarMessagePair, CatalogUsageStats, PluralCoverage } from './Content.ts';
 //# sourceMappingURL=index.d.ts.map