@lokascript/i18n 2.9.4 → 2.10.0

package/dist/{transformer--W46PGaW.d.cts → transformer-CsOeqayN.d.cts}

@@ -145,7 +145,7 @@ interface KeywordProviderOptions {
  * - Each role has distinct grammatical markers per language (see profiles/index.ts)
  * - Usage percentages based on pattern database analysis
  */
-type SemanticRole = 'action' | 'agent' | 'patient' | 'source' | 'destination' | 'goal' | 'event' | 'condition' | 'quantity' | 'duration' | 'responseType' | 'method' | 'style' | 'manner' | 'loopType' | 'continues';
+type SemanticRole = 'action' | 'agent' | 'patient' | 'source' | 'destination' | 'goal' | 'recipient' | 'event' | 'condition' | 'quantity' | 'duration' | 'responseType' | 'method' | 'style' | 'manner' | 'loopType' | 'continues';
 /**
  * Word order patterns
  * These represent the major typological categories
@@ -907,6 +907,23 @@ declare class GrammarTransformer {
      * Transform a single hyperscript statement (no compound "then" chains).
      */
     private transformSingle;
+    /**
+     * Clause carrying a masked `using view transition` tail: strip the opaque
+     * token, transform the clause alone, and re-append the token at the very end.
+     *
+     * The tail is a clause-final modifier in every word order the corpus emits:
+     * the semantic side matches it as the literal `using view` marker plus a value
+     * word, and the SOV/VSO event-handler patterns admit it as an optional
+     * TRAILING group (after the with-marked operand). So the target position is
+     * "end of the transformed clause" for all 24 languages — no per-profile
+     * placement decision, which is what makes this a passthrough rather than a
+     * role.
+     *
+     * Returns null when the clause carries no masked tail, or when the token is
+     * not clause-final (nothing to reposition — leaving it in place still restores
+     * verbatim English).
+     */
+    private transformWithViewTransitionTail;
     /**
      * `<command …> end` fragments: transform the command without its stranded
      * terminator, then re-append the translated terminator as a standalone

package/dist/{transformer-FU06J6kG.d.ts → transformer-DWCTG1DQ.d.ts}

@@ -145,7 +145,7 @@ interface KeywordProviderOptions {
  * - Each role has distinct grammatical markers per language (see profiles/index.ts)
  * - Usage percentages based on pattern database analysis
  */
-type SemanticRole = 'action' | 'agent' | 'patient' | 'source' | 'destination' | 'goal' | 'event' | 'condition' | 'quantity' | 'duration' | 'responseType' | 'method' | 'style' | 'manner' | 'loopType' | 'continues';
+type SemanticRole = 'action' | 'agent' | 'patient' | 'source' | 'destination' | 'goal' | 'recipient' | 'event' | 'condition' | 'quantity' | 'duration' | 'responseType' | 'method' | 'style' | 'manner' | 'loopType' | 'continues';
 /**
  * Word order patterns
  * These represent the major typological categories
@@ -907,6 +907,23 @@ declare class GrammarTransformer {
      * Transform a single hyperscript statement (no compound "then" chains).
      */
     private transformSingle;
+    /**
+     * Clause carrying a masked `using view transition` tail: strip the opaque
+     * token, transform the clause alone, and re-append the token at the very end.
+     *
+     * The tail is a clause-final modifier in every word order the corpus emits:
+     * the semantic side matches it as the literal `using view` marker plus a value
+     * word, and the SOV/VSO event-handler patterns admit it as an optional
+     * TRAILING group (after the with-marked operand). So the target position is
+     * "end of the transformed clause" for all 24 languages — no per-profile
+     * placement decision, which is what makes this a passthrough rather than a
+     * role.
+     *
+     * Returns null when the clause carries no masked tail, or when the token is
+     * not clause-final (nothing to reposition — leaving it in place still restores
+     * verbatim English).
+     */
+    private transformWithViewTransitionTail;
     /**
      * `<command …> end` fragments: transform the command without its stranded
      * terminator, then re-append the translated terminator as a standalone

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lokascript/i18n",
-  "version": "2.9.4",
+  "version": "2.10.0",
   "description": "Grammar transformation and keyword translation for hyperscript",
   "type": "module",
   "main": "dist/index.cjs",
@@ -64,8 +64,8 @@
   },
   "homepage": "https://github.com/codetalcott/hyperfixi/tree/main/packages/i18n#readme",
   "dependencies": {
-    "@hyperfixi/core": "^2.9.4",
-    "@lokascript/semantic": "^2.9.4",
+    "@hyperfixi/core": "^2.10.0",
+    "@lokascript/semantic": "^2.10.0",
     "esbuild": "^0.28.0",
     "happy-dom": "^20.10.6",
     "vite": "^8.1.4"

package/src/grammar/grammar.test.ts

@@ -2662,3 +2662,90 @@ describe('SOV if-blocks get a then-connective before a positional branch head (F
     expect(out).toContain('llulla "Invalid form" ta qillqakuy');
   });
 });
+
+// `swap #a with #b using view transition` — the tail the transformer had never
+// seen. `using` is in no dictionary and no role table, so it swept into whatever
+// role phrase was open; `transition` IS a translated command keyword in every
+// dictionary AND is in ENGLISH_COMMANDS, so splitOnCommandBoundaries cut the
+// clause there and the rejoin planted a phantom translated `transition` COMMAND
+// after the target's then-connective (`intercambiar #a con #b using view
+// entonces transición`). The phrase has no native form in any of the 24
+// languages — semantic matches the literal English `using view` marker
+// everywhere (USING_VIEW_MARKER_ALL_LANGS) — so it is masked before any
+// splitting/translation and re-appended verbatim at the clause tail, which is
+// where every word order's patterns admit it.
+describe('`using view transition` is a passthrough tail, not translated content', () => {
+  const SRC = 'on click swap #a with #b using view transition';
+
+  // One per word-order family: SVO Romance/Germanic/Slavic, V2, SOV
+  // particle/agglutinative, VSO, and the two object-marking SVO languages.
+  const TRANSLATED_TRANSITION: Array<[string, string]> = [
+    ['es', 'transición'],
+    ['fr', 'transition'], // fr's own verb form — the passthrough must not re-emit it as a command
+    ['de', 'übergang'],
+    ['ja', '遷移'],
+    ['ko', '전환'],
+    ['tr', 'geçiş'],
+    ['qu', 'pasay'],
+    ['bn', 'সংক্রমণ'],
+    ['hi', 'संक्रमण'],
+    ['ar', 'انتقال'],
+    ['zh', '过渡'],
+    ['he', 'מעבר'],
+    ['ru', 'анимировать'],
+    ['th', 'เปลี่ยนผ่าน'],
+    ['vi', 'chuyển tiếp'],
+    ['tl', 'transisyon'],
+  ];
+
+  for (const [lang, translated] of TRANSLATED_TRANSITION) {
+    it(`[${lang}] emits the English tail verbatim at the clause end`, () => {
+      const out = new GrammarTransformer('en', lang).transform(SRC);
+      expect(out).toMatch(/using view transition$/);
+      // No phantom then-connective, and no translated `transition` command.
+      if (translated !== 'transition') {
+        expect(out).not.toContain(translated);
+      }
+    });
+  }
+
+  it('the tail does not displace the clause it modifies (both operands survive)', () => {
+    for (const lang of ['es', 'ja', 'ar', 'tr', 'zh', 'qu']) {
+      const out = new GrammarTransformer('en', lang).transform(SRC);
+      expect(out, lang).toContain('#a');
+      expect(out, lang).toContain('#b');
+    }
+  });
+
+  it('`transition` as a real command keyword still translates (both-ways negative)', () => {
+    // The mask must be anchored on the literal `using view` phrase, not on the
+    // word `transition` — the standalone transition command has to keep its
+    // dictionary form or every animate row would render English.
+    const es = new GrammarTransformer('en', 'es').transform(
+      'on click transition opacity to 0 over 300ms'
+    );
+    expect(es).toContain('transición');
+    const ja = new GrammarTransformer('en', 'ja').transform(
+      'on click transition opacity to 0 over 300ms'
+    );
+    expect(ja).toContain('遷移');
+  });
+
+  it('a `then`-chained clause after the tail still splits (the tail never swallows a boundary)', () => {
+    const out = new GrammarTransformer('en', 'es').transform(
+      'on click swap #a with #b using view transition then log "done"'
+    );
+    expect(out).toContain('using view transition');
+    expect(out).toContain('entonces');
+    expect(out).toContain('"done"');
+  });
+
+  it('`process partials in it using view transition` keeps its tail too', () => {
+    for (const lang of ['es', 'ja', 'tr']) {
+      const out = new GrammarTransformer('en', lang).transform(
+        'process partials in it using view transition'
+      );
+      expect(out, lang).toMatch(/using view transition$/);
+    }
+  });
+});

package/src/grammar/transformer.ts

@@ -1778,6 +1778,59 @@ function restoreCaretScopes(input: string, scopes: string[]): string {
   );
 }
 
+// =============================================================================
+// View-transition tail masking (`using view transition`)
+// =============================================================================
+
+/** Private-use sentinels bracketing a masked view-transition-tail index. */
+const VIEW_TAIL_OPEN = '\uE002';
+const VIEW_TAIL_CLOSE = '\uE003';
+
+/**
+ * Match `swap`/`process`'s trailing `using view transition` modifier.
+ *
+ * `using` is in no dictionary and in no role table, so it sweeps into whatever
+ * role phrase is open; `transition` IS a translated command keyword in every
+ * dictionary (es `transición`, de `übergang`, ja `遷移`) and is in
+ * `ENGLISH_COMMANDS`, so `splitOnCommandBoundaries` splits the clause there and
+ * the rejoin plants a phantom translated `transition` COMMAND after the target's
+ * `then`-connective (`intercambiar #a con #b using view entonces transición`).
+ *
+ * The phrase has no native form in any of the 24 languages — semantic's
+ * `USING_VIEW_MARKER_ALL_LANGS` matches the literal English `using view` marker
+ * everywhere — so it is a passthrough, matched on the English surface regardless
+ * of source locale. The value word is optional so a bare `using view` still
+ * masks rather than half-splitting; `then` is excluded so a clause boundary is
+ * never swallowed into the tail.
+ */
+const VIEW_TAIL_RE = /\busing\s+view\b(?:\s+(?!then\b)[A-Za-z][\w-]*)?/gi;
+
+/** Whether a token is a masked view-transition tail. */
+const VIEW_TAIL_TOKEN_RE = new RegExp(`^${VIEW_TAIL_OPEN}(\\d+)${VIEW_TAIL_CLOSE}$`);
+
+/**
+ * Mask every `using view <value>` tail behind an opaque token, so the phrase
+ * never reaches the splitter, the word translator, or the role parser. Returns
+ * null when there's nothing to mask.
+ */
+function maskViewTransitionTails(input: string): { masked: string; tails: string[] } | null {
+  const tails: string[] = [];
+  const masked = input.replace(VIEW_TAIL_RE, match => {
+    const idx = tails.length;
+    tails.push(match);
+    return `${VIEW_TAIL_OPEN}${idx}${VIEW_TAIL_CLOSE}`;
+  });
+  return tails.length > 0 ? { masked, tails } : null;
+}
+
+/** Restore masked view-transition tokens to their verbatim English phrase. */
+function restoreViewTransitionTails(input: string, tails: string[]): string {
+  return input.replace(
+    new RegExp(`${VIEW_TAIL_OPEN}(\\d+)${VIEW_TAIL_CLOSE}`, 'g'),
+    (_m, n: string) => tails[Number(n)] ?? ''
+  );
+}
+
 // =============================================================================
 // Main Transformer
 // =============================================================================
@@ -1813,6 +1866,17 @@ export class GrammarTransformer {
   }
 
   private transformInternal(input: string): string {
+    // `using view transition` is a passthrough phrase, not translatable content:
+    // `using` is in no dictionary and `transition` is a COMMAND keyword, so left
+    // in place the splitter tears the clause apart there and the tail renders as
+    // a phantom translated command. Mask it before any splitting/translation and
+    // restore it verbatim; transformSingle re-appends the opaque token at the
+    // clause tail so it lands after the reorder, not inside a role phrase.
+    const viewTails = maskViewTransitionTails(input);
+    if (viewTails) {
+      return restoreViewTransitionTails(this.transformInternal(viewTails.masked), viewTails.tails);
+    }
+
     // Caret-scoped variable reads (`^name on <selector>`) carry a second,
     // overloaded `on` that the splitter/event-parser would mistake for an event
     // or command boundary — mangling `put ^count on #host into me`. Mask the
@@ -1921,6 +1985,18 @@ export class GrammarTransformer {
       return setScope;
     }
 
+    // 0c. Masked `using view transition` tail (see maskViewTransitionTails):
+    //     strip the opaque token, transform the clause without it, and re-append
+    //     it at the clause tail. Left in the token stream it would be swept into
+    //     the open role's VALUE and rendered ahead of that role's marker
+    //     (ja `#b using view transition で` instead of `#b で using view
+    //     transition`) — the same failure mode transformWithTrailingEnd fixes
+    //     for a stranded `end`.
+    const viewTail = this.transformWithViewTransitionTail(input);
+    if (viewTail !== null) {
+      return viewTail;
+    }
+
     // 1. Parse into semantic roles
     const parsed = parseStatement(input, this.sourceProfile.code);
     if (!parsed) {
@@ -1963,6 +2039,36 @@ export class GrammarTransformer {
     return joinTokens(reordered.map(e => e.translated || e.value));
   }
 
+  /**
+   * Clause carrying a masked `using view transition` tail: strip the opaque
+   * token, transform the clause alone, and re-append the token at the very end.
+   *
+   * The tail is a clause-final modifier in every word order the corpus emits:
+   * the semantic side matches it as the literal `using view` marker plus a value
+   * word, and the SOV/VSO event-handler patterns admit it as an optional
+   * TRAILING group (after the with-marked operand). So the target position is
+   * "end of the transformed clause" for all 24 languages — no per-profile
+   * placement decision, which is what makes this a passthrough rather than a
+   * role.
+   *
+   * Returns null when the clause carries no masked tail, or when the token is
+   * not clause-final (nothing to reposition — leaving it in place still restores
+   * verbatim English).
+   */
+  private transformWithViewTransitionTail(input: string): string | null {
+    const trimmed = input.trim();
+    const tokens = trimmed.split(/\s+/);
+    if (tokens.length < 2) {
+      return null;
+    }
+    if (!VIEW_TAIL_TOKEN_RE.test(tokens[tokens.length - 1])) {
+      return null;
+    }
+    const tail = tokens[tokens.length - 1];
+    const head = tokens.slice(0, -1).join(' ');
+    return `${this.transformSingle(head)} ${tail}`;
+  }
+
   /**
    * `<command …> end` fragments: transform the command without its stranded
    * terminator, then re-append the translated terminator as a standalone

package/src/grammar/types.ts

@@ -66,6 +66,10 @@ export type SemanticRole =
   | 'source' // Origin (from #input, from URL)
   | 'destination' // Target location (into #output, to .class)
   | 'goal' // Target value/state (to 'red', to 100)
+  | 'recipient' // Who receives what the action transfers (take .active from .tab for me).
+  //              Declared for parity with the semantic union; NO i18n profile marks it yet
+  //              — en still maps `for` to duration lexically and suppresses the marker for
+  //              pronoun values (see insertMarkers below).
   | 'event' // Trigger (click, input, keydown)
   | 'condition' // Boolean expression (if x > 5)
   // Quantitative roles