@things-factory/worklist 10.1.147 → 10.1.150

package/package.json

@@ -1,8 +1,24 @@
 {
   "name": "@things-factory/worklist",
-  "version": "10.1.147",
+  "version": "10.1.150",
   "main": "dist-server/index.js",
   "browser": "dist-client/index.js",
+  "exports": {
+    ".": {
+      "browser": "./dist-client/index.js",
+      "default": "./dist-server/index.js"
+    },
+    "./issue": "./dist-server/controllers/activity-instance/issue.js",
+    "./dist-client": "./dist-client/index.js",
+    "./*": "./*"
+  },
+  "typesVersions": {
+    "*": {
+      "issue": [
+        "dist-server/controllers/activity-instance/issue.d.ts"
+      ]
+    }
+  },
   "things-factory": true,
   "author": "heartyoh <heartyoh@hatiolab.com>",
   "description": "Module to manage the todo list of business participants",
@@ -25,7 +41,7 @@
     "clean:server": "npx rimraf dist-server",
     "clean": "npm run clean:server && npm run clean:client",
     "migration:create": "node ../../node_modules/typeorm/cli.js migration:create ./server/migrations/migration",
-    "test": "node --import ./test/resolve-ts-siblings.mjs --test --test-force-exit test/*.test.ts"
+    "test": "node --import ./test/resolve-ts-siblings.mjs --test test/*.test.ts"
   },
   "dependencies": {
     "@material/web": "^2.0.0",
@@ -38,14 +54,15 @@
     "@operato/moment-timezone-es": "^10.0.0",
     "@operato/p13n": "^10.0.0",
     "@operato/popup": "^10.15.0",
-    "@things-factory/attachment-base": "^10.1.147",
-    "@things-factory/auth-base": "^10.1.147",
-    "@things-factory/board-service": "^10.1.147",
-    "@things-factory/context-ui": "^10.1.147",
-    "@things-factory/organization": "^10.1.147",
-    "@things-factory/personalization": "^10.1.147",
-    "@things-factory/scheduler-client": "^10.1.147",
-    "@things-factory/shell": "^10.1.147"
+    "@things-factory/attachment-base": "^10.1.150",
+    "@things-factory/auth-base": "^10.1.150",
+    "@things-factory/board-service": "^10.1.150",
+    "@things-factory/context-ui": "^10.1.150",
+    "@things-factory/i18n-base": "^10.1.150",
+    "@things-factory/organization": "^10.1.150",
+    "@things-factory/personalization": "^10.1.150",
+    "@things-factory/scheduler-client": "^10.1.150",
+    "@things-factory/shell": "^10.1.150"
   },
-  "gitHead": "df93dddb6ac19a27c32fad21e29ca0ce02d08eb6"
+  "gitHead": "39c135863f5f7455dcd80b8907550a1c91a86118"
 }

package/shared/decision-sentences.d.ts

@@ -0,0 +1,30 @@
+/** The declaration fields a sentence reads. The full declaration type lives with each side. */
+export interface DecisionSentenceKey {
+  inputPath?: string
+  /** i18n key for the value sentence. */
+  valueTKey?: string
+  /** What the sentence puts in its blanks: name in the sentence → inputPath to read it from. */
+  params?: { [name: string]: string }
+}
+
+export type Translate = (key: string, options?: { [name: string]: unknown }) => string
+
+export function valueAtPath(input: any, path: string): { value: unknown; found: boolean }
+
+export function paramsFrom(
+  declared: { [name: string]: string } | undefined,
+  input: { [key: string]: any } | undefined | null
+): { [name: string]: unknown } | undefined
+
+export function freezeDecisionSentences<T>(
+  decisionKeys: DecisionSentenceKey[] | null | undefined,
+  input: T,
+  t: Translate,
+  language?: string
+): T
+
+export class DecisionSentenceMissing extends Error {
+  readonly code: 'decision-sentence-missing'
+  readonly params: { key: string; language: string }
+  constructor(key: string, language?: string)
+}

package/shared/decision-sentences.js

@@ -0,0 +1,146 @@
+/*
+ * The value sentences of an approval — read by the decision screen and frozen by the server. No UI, i18n or DB
+ * imports: both sides pass in what they have.
+ *
+ * ── Why one file (2026-10-11) ────────────────────────────────────────────
+ * A door declares, for each sentence, its key (`valueTKey`) and where its blanks come from (`params`). The
+ * screen read the blanks out of the input here; the server kept its own copy of every sentence in Korean and
+ * froze that. When the translations were reworded (plant 8d073d11, 39 sentences) the server copies were not,
+ * and the stored sentence no longer said what the screen said. Now the server freezes what the translation
+ * says, through the same reading of the blanks the screen uses.
+ */
+
+/**
+ * The value at a dotted path, and whether the path led anywhere.
+ *
+ * A path that runs into a non-object partway reports found: false rather than throwing. The screen has to
+ * draw something either way, and a thrown error would take the whole approval down over one slot.
+ */
+function valueAtPath(input, path) {
+  const steps = String(path == null ? '' : path)
+    .split('.')
+    .filter(step => step.length > 0)
+
+  if (!steps.length) {
+    return { value: undefined, found: false }
+  }
+
+  let at = input
+
+  for (const step of steps) {
+    if (at === null || at === undefined || typeof at !== 'object') {
+      return { value: undefined, found: false }
+    }
+
+    if (!Object.prototype.hasOwnProperty.call(at, step)) {
+      return { value: undefined, found: false }
+    }
+
+    at = at[step]
+  }
+
+  return { value: at, found: true }
+}
+
+/**
+ * Read a sentence's blanks out of the input.
+ *
+ * A path that leads nowhere lands as `undefined` — i18next prints an empty blank rather than the word
+ * `undefined`. Returns undefined when nothing was declared, so a slot without blanks carries no empty object.
+ */
+function paramsFrom(declared, input) {
+  const names = Object.keys(declared || {})
+
+  if (!names.length) {
+    return undefined
+  }
+
+  const read = {}
+
+  for (const name of names) {
+    read[name] = valueAtPath(input, String(declared[name] == null ? '' : declared[name])).value
+  }
+
+  return read
+}
+
+/** What a translator answers for a key it does not have. Not a sentence anyone could write. */
+const MISSING = '\u0000decision-sentence-missing'
+
+/** Put in a blank that has no value, to see whether the chosen wording uses it. */
+const NO_VALUE = '\u0000decision-sentence-no-value'
+
+/**
+ * A sentence key with no translation in the language being frozen. Thrown rather than stored: a stored key
+ * reads as gibberish on every screen that shows the record, and nobody can tell why later.
+ */
+class DecisionSentenceMissing extends Error {
+  constructor(key, language) {
+    super(`there is no ${language ? language + ' ' : ''}sentence for ${key}.`)
+    this.code = 'decision-sentence-missing'
+    this.params = { key, language: language || '' }
+  }
+}
+
+/** A copy of `input` with `value` at `path` — only the objects along the path are copied. */
+function withValueAt(input, path, value) {
+  const steps = String(path).split('.').filter(step => step.length > 0)
+  const root = { ...(input || {}) }
+  let at = root
+
+  for (let i = 0; i < steps.length - 1; i++) {
+    const next = at[steps[i]]
+    at[steps[i]] = next && typeof next === 'object' && !Array.isArray(next) ? { ...next } : {}
+    at = at[steps[i]]
+  }
+
+  at[steps[steps.length - 1]] = value
+  return root
+}
+
+/**
+ * The input with every declared value sentence written in, read from the translation through `t`.
+ *
+ * A sentence is written only when **the wording its branch picks** has a value for every blank it uses — a
+ * sentence is not made without its values (a maintenance order with no due date has no "the date it carries
+ * now"). A blank the declaration names but the chosen wording does not use may be empty: the no-lot branch of
+ * a substitution declares `{lot}` and does not say it. `context` picks the wording and is never a blank.
+ *
+ * `t` should not fall back to another language; a key it does not have throws `DecisionSentenceMissing`.
+ * `language` only names that language in the error.
+ */
+function freezeDecisionSentences(decisionKeys, input, t, language) {
+  let frozen = input
+
+  for (const key of decisionKeys || []) {
+    if (!key || !key.valueTKey || !key.inputPath) {
+      continue
+    }
+
+    const params = paramsFrom(key.params, input) || {}
+    const filled = {}
+
+    for (const [name, value] of Object.entries(params)) {
+      filled[name] = value === undefined && name !== 'context' ? NO_VALUE : value
+    }
+
+    const sentence = t(key.valueTKey, { ...filled, defaultValue: MISSING })
+
+    if (typeof sentence !== 'string' || sentence === MISSING) {
+      throw new DecisionSentenceMissing(key.valueTKey, language)
+    }
+
+    if (sentence.includes(NO_VALUE)) {
+      continue
+    }
+
+    frozen = withValueAt(frozen, key.inputPath, sentence)
+  }
+
+  return frozen
+}
+
+exports.valueAtPath = valueAtPath
+exports.paramsFrom = paramsFrom
+exports.freezeDecisionSentences = freezeDecisionSentences
+exports.DecisionSentenceMissing = DecisionSentenceMissing