@hyperfixi/testing-framework 4.1.0 → 4.3.0

package/src/multilingual/direct-path-shapes.ts

@@ -376,8 +376,15 @@ export async function initDirectPathHosts(): Promise<DirectPathHosts> {
     for (const steps of scriptOf(c)) parts.push(await run(host, c, code, lang, steps));
     return parts.join(' ‖ ');
   };
-  const rejects = (host: ScriptHost, code: string): string | undefined =>
-    host.parse(code)?.errors?.[0]?.message.split('\n')[0];
+  // Two failure channels: parse errors, and the tokenizer THROWING on a
+  // character it does not know (the text a refused translation leaves as written).
+  const rejects = (host: ScriptHost, code: string): string | undefined => {
+    try {
+      return host.parse(code)?.errors?.[0]?.message.split('\n')[0];
+    } catch (e) {
+      return (e as Error).message.split('\n')[0] ?? 'threw';
+    }
+  };
 
   return {
     async runCase(c) {

package/src/multilingual/value-matrix.branch-phrases.test.ts

@@ -0,0 +1,13 @@
+/**
+ * Value matrix gate — the `branch` position's operator-phrase cells (`is equal
+ * to`, `includes`, `is an Element`, …). See value-matrix.ts for the matrix
+ * and value-matrix-gate.ts for the assertions.
+ *
+ * @vitest-environment node
+ * Required, not a preference: under happy-dom the engines bind happy-dom's
+ * DOM constructors, not the jsdom window's (see
+ * shipped-examples-execution.test.ts).
+ */
+import { describeValueMatrixShard } from './value-matrix-gate';
+
+describeValueMatrixShard('branch', 'phrases');

package/src/multilingual/value-matrix.branch.test.ts

@@ -0,0 +1,13 @@
+/**
+ * Value matrix gate — the `branch` cells. See value-matrix.ts for the matrix and
+ * value-matrix-gate.ts for the assertions; one position per file so the
+ * shards run in parallel.
+ *
+ * @vitest-environment node
+ * Required, not a preference: under happy-dom the engines bind happy-dom's
+ * DOM constructors, not the jsdom window's (see
+ * shipped-examples-execution.test.ts).
+ */
+import { describeValueMatrixShard } from './value-matrix-gate';
+
+describeValueMatrixShard('branch');

package/src/multilingual/value-matrix.ts

@@ -9,16 +9,17 @@
  *
  * This does. A CELL is one value expression in one position:
  *
- *   - OPERANDS: eleven kinds (literal, variable, selector, possessive, `of`,
+ *   - OPERANDS: twelve kinds (literal, variable, selector, possessive, `of`,
  *     dotted, call, array, parens, a reference's property: `event's type`,
- *     `the id of target`, and a sigil variable: `$n`), each with instances
- *     of the value types it produces;
+ *     `the id of target`, a sigil variable: `$n`, and a CSS length: `100px`),
+ *     each with instances of the value types it produces;
  *   - OPERATORS: arithmetic, comparison, equality, logic, membership, and the
  *     prefix and postfix forms (`not`, `-`, `no`, `is empty`, `is null`,
  *     `exists`, `as`), and core's operator PHRASES (`is greater than or equal
  *     to`, `does not include`, `is an Element`, …);
- *   - POSITIONS: a `put` value, a `set` value, an `if` condition, a `repeat
- *     while` condition, a loop's count (`repeat … times`), an `increment …
+ *   - POSITIONS: a `put` value, a `set` value, an `if` condition, an `if`
+ *     condition with no `then` before a command that names no target
+ *     (`branch`), a `repeat while` condition, a loop's count (`repeat … times`), an `increment …
  *     by` amount, a `set` value in the second command of a chain (`chain`),
  *     what a `get` reads (`get`), and two written targets: what a `set`
  *     writes (`assign`) and what an `increment` counts (`count`).
@@ -112,15 +113,27 @@ export type OperandKind =
   | 'array'
   | 'parens'
   | 'reference'
-  | 'sigil';
+  | 'sigil'
+  | 'length';
 
 export type Position =
-  'put' | 'set' | 'if' | 'while' | 'times' | 'increment' | 'chain' | 'get' | 'assign' | 'count';
+  | 'put'
+  | 'set'
+  | 'if'
+  | 'branch'
+  | 'while'
+  | 'times'
+  | 'increment'
+  | 'chain'
+  | 'get'
+  | 'assign'
+  | 'count';
 
 export const POSITIONS: readonly Position[] = [
   'put',
   'set',
   'if',
+  'branch',
   'while',
   'times',
   'increment',
@@ -164,7 +177,7 @@ export interface MatrixCell {
  */
 export const FIXTURE =
   '<div id="out">∅</div>' +
-  '<p id="a" class="x" title="t1">6</p>' +
+  '<p id="a" class="x" title="t1" aria-pressed="true">6</p>' +
   '<div id="w"><p class="w">w</p><p class="w">v</p></div>' +
   '<button id="b">b</button>';
 
@@ -197,12 +210,16 @@ export const OPERANDS: readonly Operand[] = [
   { kind: 'possessive', type: 'num', text: "obj's v" },
   { kind: 'possessive', type: 'num', text: "arr's length" },
   { kind: 'possessive', type: 'num', text: "#a's textContent's length" },
+  // A property name a lexicon translates and no reader brings back: es wrote
+  // `hijos`, which read back as a property named `hijos`.
+  { kind: 'possessive', type: 'num', text: "#w's children's length" },
   { kind: 'of', type: 'nstr', text: 'textContent of #a' },
   { kind: 'of', type: 'nstr', text: 'the textContent of #a' },
   { kind: 'of', type: 'num', text: 'v of obj' },
   { kind: 'of', type: 'num', text: 'length of arr' },
   { kind: 'of', type: 'str', text: '@title of #a' },
   { kind: 'of', type: 'num', text: 'v of w of obj' },
+  { kind: 'of', type: 'num', text: 'the length of the children of #w' },
   { kind: 'of', type: 'arr', text: 'textContent of .w' },
   { kind: 'dotted', type: 'nstr', text: '#a.textContent' },
   { kind: 'dotted', type: 'str', text: 'me.id' },
@@ -213,8 +230,15 @@ export const OPERANDS: readonly Operand[] = [
   { kind: 'call', type: 'nstr', text: 'String(n)' },
   { kind: 'call', type: 'str', text: 's.toUpperCase()' },
   { kind: 'call', type: 'bool', text: 'Array.isArray(arr)' },
+  // A word a lexicon translates, inside a call's arguments, which every reader
+  // takes as written: es `Math.max(n, verdadero)`.
+  { kind: 'call', type: 'num', text: 'Math.max(n, true)' },
   { kind: 'array', type: 'arr', text: '[1, 2]' },
   { kind: 'array', type: 'arr', text: '[n, 2]' },
+  // A word some language's lexicon translates, inside an array in a larger
+  // expression: every reader takes a bracket group whole, so a renderer that
+  // localized `true` there (es `2 is in [verdadero, n]`) lost it in all 23.
+  { kind: 'array', type: 'arr', text: '[true, n]' },
   { kind: 'parens', type: 'num', text: '(n + 1)' },
   { kind: 'parens', type: 'str', text: '(s + "c")' },
   { kind: 'parens', type: 'bool', text: '(n > 1)' },
@@ -235,6 +259,10 @@ export const OPERANDS: readonly Operand[] = [
   // a variable, but no cell had one: semantic's English dropped a whole loop
   // counted by one (`repeat $n times`), and every translation with it.
   { kind: 'sigil', type: 'num', text: '$n' },
+  // A number with a CSS unit is one string upstream (`100px`): every reader
+  // split it, so `set my *width to 100px` was refused in all 24 languages.
+  { kind: 'length', type: 'str', text: '100px' },
+  { kind: 'length', type: 'str', text: '50%' },
 ];
 
 /** An operator slot, and the value types that fill it. */
@@ -330,7 +358,16 @@ export const BINARY_OPERATORS: readonly BinaryOperator[] = [
     representative: true,
     signatures: [sig('num', 'arr', '2', '[1, 2, 6]', 'bool')],
   },
-  { op: 'matches', representative: true, signatures: [sig('one', 'none', '#a', '.x', 'bool')] },
+  {
+    op: 'matches',
+    representative: true,
+    // An attribute selector whose value a lexicon translates: es wrote
+    // `<[aria-pressed=verdadero]/>`, another selector, in all 23 languages.
+    signatures: [
+      sig('one', 'none', '#a', '.x', 'bool'),
+      sig('one', 'none', '#a', '<[aria-pressed=true]/>', 'bool'),
+    ],
+  },
   // Operator PHRASES (the after-85 handoff, part 2): the words each language
   // renders for them are read back by the join and the sense table, which no
   // single-word operator exercises. One of each class is representative, so the
@@ -623,6 +660,7 @@ const TEMPLATES: Record<Position, (expression: string) => string> = {
   put: e => `on click put ${e} into #out`,
   set: e => `on click set x to ${e} then put x into #out`,
   if: e => `on click if ${e} then put "Y" into #out else put "N" into #out end`,
+  branch: e => `on click if ${e} add .y else add .n end then put my className into #out`,
   while: e => `on click set i to 0 then repeat while i < ${e} increment i end then put i into #out`,
   times: e => `on click set i to 0 then repeat ${e} times increment i end then put i into #out`,
   increment: e => `on click set i to 1 then increment i by ${e} then put i into #out`,
@@ -649,10 +687,18 @@ const TEMPLATES: Record<Position, (expression: string) => string> = {
  * `it`, but its role took no literal, so English dropped `get "hello"`, `get
  * 3` and `get true` whole (and every translation with them) while `get n` and
  * `get #a's textContent` read.
+ *
+ * A `branch` condition is every `if` condition but the names (none failed
+ * there that `if` did not). The `if` cells write `then` and a `put` with its
+ * target, so a reader always saw where the condition ended. Without `then`, an
+ * SOV language writes the branch's first role right after the condition, and
+ * its reader has to find the seam: tr read `if 2 is in arr add .a end` as
+ * `if 2 add .a to is in arr end` (its destination marker is optional, and `in`
+ * is also one), with every operand, and the `if` cells all passed.
  */
 function positionsFor(type: ValueType, bare: boolean, group: MatrixCell['group']): Position[] {
   const out: Position[] = ['put', 'set'];
-  if (type === 'bool' || bare) out.push('if');
+  if (type === 'bool' || bare) out.push('if', 'branch');
   if (type === 'num' || type === 'nstr') out.push('while', 'times', 'increment');
   if (group !== 'operand-operator') out.push('chain', 'get');
   return out;