@kernhq/module-inventory 0.2.0 → 0.3.0

package/src/client/messages.test.ts

@@ -1,3 +1,6 @@
+import { readdirSync, readFileSync } from 'node:fs'
+import { dirname, join } from 'node:path'
+import { fileURLToPath } from 'node:url'
 import { describe, expect, it } from 'vitest'
 import { ar, de, en, fa, inventoryMessageBundles, tr } from './messages.js'
 
@@ -80,6 +83,38 @@ describe('bundles', () => {
     }
   })
 
+  /**
+   * The slip that six forms invite: writing five of them and abbreviating the sixth.
+   *
+   * `many` is the form for 11–99, where Arabic puts the counted noun in the singular accusative —
+   * "{n} أصلاً". Because that form is written *differently* from `other`, it gets written from
+   * scratch rather than copied, and a compound noun loses half of itself on the way: the shell's
+   * `modules_meta_objects` said "{n} نوعاً" — "{n} type" — where every other form said "نوع كائن",
+   * "object type". Nothing catches that. It compiles, it has all six categories, it has the right
+   * placeholder, and it is missing the word the sentence is about.
+   *
+   * Word count against `other` is a heuristic and is named as one: a form with *fewer* words than
+   * `other` has dropped one, and in a counted phrase the word it drops is the noun. Inflection
+   * changes a word's letters, not how many words there are, so this stays true across all six.
+   */
+  it('never drops a word from an Arabic plural form that the `other` form has', () => {
+    const words = (form: string) => form.split(/\s+/).filter((word) => word && !word.includes('{')).length
+    for (const [key, value] of Object.entries(ar)) {
+      if (typeof value === 'string') continue
+      const other = (value as Record<string, string>).other ?? ''
+      for (const [category, form] of Object.entries(value as Record<string, string>)) {
+        // `zero` is a negation — "لا أصول" — and is the one form entitled to a different shape.
+        if (category === 'zero') continue
+        expect({ key, category, form, atLeast: words(other) }).toEqual({
+          key,
+          category,
+          form,
+          atLeast: Math.min(words(form), words(other)),
+        })
+      }
+    }
+  })
+
   it('makes a plural of a key wherever English has one', () => {
     for (const [key, value] of Object.entries(en)) {
       if (typeof value === 'string') continue
@@ -93,6 +128,71 @@ describe('bundles', () => {
   })
 })
 
+// ------------------------------------------------------ keys nothing asks for any more
+
+const HERE = dirname(fileURLToPath(import.meta.url))
+
+/** Everything in this client that could name a key — components included, catalogue excluded. */
+function clientSource(): string {
+  const files = readdirSync(HERE, { recursive: true, encoding: 'utf8' }).filter(
+    (file) =>
+      (file.endsWith('.ts') || file.endsWith('.svelte')) &&
+      !file.endsWith('.test.ts') &&
+      !file.endsWith('messages.ts'),
+  )
+  return files.map((file) => readFileSync(join(HERE, file), 'utf8')).join('\n')
+}
+
+/**
+ * The two families of key that are *built* rather than written, and so are never literals.
+ *
+ * `t(`status_${status}`)` and `actionKey()`'s `history_${action}`. Both lists are duplicated here
+ * on purpose — the file is data-only and importing the contract to check a catalogue would be a
+ * circular sort of proof — and `status labels` below already holds the first one to the contract.
+ */
+const BUILT = new Set([
+  ...['in_stock', 'assigned', 'reserved', 'under_repair', 'lost', 'retired'].map((s) => `status_${s}`),
+  ...[
+    'created',
+    'updated',
+    'assigned',
+    'transferred',
+    'returned',
+    'retired',
+    'restored',
+    'repair_logged',
+    'repair_completed',
+    'attachment_added',
+    'attachment_removed',
+  ].map((a) => `history_${a}`),
+])
+
+describe('every key is one something asks for', () => {
+  /**
+   * `inventory.settings_save_error` — "The settings could not be saved" — sat in all five bundles
+   * with nothing reading it: the save bar renders `errorMessage(err, t)`, which names the actual
+   * refusal instead. A dead key is five translations somebody maintains, reviews and re-reads for
+   * a sentence that cannot appear, and nothing about it looks wrong from inside the catalogue.
+   *
+   * Literals rather than a runtime trace, because a `.svelte` file cannot be unit-tested here —
+   * the same reason `errors.test.ts` reads `src/server` off disk. It misses a key that happens to
+   * appear as an unrelated string somewhere, which is a false *pass*; it never fails a key that is
+   * really used, which is the direction that matters for a check nobody wants to fight.
+   */
+  it('has nothing in the catalogue that no screen can reach', () => {
+    const source = clientSource()
+    const dead = Object.keys(en)
+      .map((key) => key.slice('inventory.'.length))
+      .filter((name) => !BUILT.has(name))
+      .filter((name) => !(source.includes(`'${name}'`) || source.includes(`"${name}"`)))
+    expect(dead).toEqual([])
+  })
+
+  it('is reading the client rather than passing on an empty sweep', () => {
+    expect(clientSource().length).toBeGreaterThan(10_000)
+  })
+})
+
 /**
  * Every status the contract can hold has a label, in every language.
  *
@@ -167,3 +267,30 @@ describe('counted messages', () => {
     expect(pick('en', 'inventory.count', 5)).toContain('5')
   })
 })
+
+/**
+ * One word per idea, across the whole product and not just across this module.
+ *
+ * A module is read beside the shell, so a second Turkish word for un-archiving something is a
+ * product that says two things for one action. `ws_archive_hint` and `ws_archive_confirm_body` in
+ * `shell/messages/tr.json` both say **geri getir** about an archived workspace; this bundle said
+ * *geri yükle*, three lines away from "Daha fazla yükle" (load more) and "sayfayı yeniden yükleyin"
+ * (reload) — one verb doing three jobs in one panel.
+ *
+ * Pinned here because it cannot be checked against the shell: a module is built standalone, and
+ * `shell/messages/*.json` is not in this package. The word is the decision; the test is the memory.
+ */
+describe('the words Kern already uses', () => {
+  it('un-archives with the shell’s own Turkish verb, and never overloads “yükle”', () => {
+    expect(tr['inventory.restore']).toBe('Geri getir')
+    const overloaded = Object.entries(tr)
+      .filter(([, value]) => typeof value === 'string' && (value as string).includes('geri yükle'))
+      .map(([key]) => key)
+    expect(overloaded).toEqual([])
+  })
+
+  /** «إعادة التحميل» is what the shell calls Reload (`pwa_update_reload`), so a reload says that. */
+  it('reloads with the shell’s own words in Arabic', () => {
+    expect(ar['inventory.error_conflict']).toContain('أعد تحميل الصفحة')
+  })
+})