@tabnas/json 0.5.17 → 0.5.19

package/dist/json.d.ts

@@ -1,5 +1,5 @@
 import { Tabnas, TabnasError, type Plugin } from '@tabnas/parser';
-export declare const VERSION = "0.5.17";
+export declare const VERSION = "0.5.19";
 export interface JsonGrammarOptions {
     chainOff?: boolean;
 }

package/dist/json.js

@@ -29,7 +29,7 @@ Object.defineProperty(exports, "JsonError", { enumerable: true, get: function ()
 // VERSION is this package's version. It MUST equal package.json "version":
 // the release orchestrator rewrites both, and test/version.test.js fails the
 // build if they drift. Mirrors `const VERSION` in go/json.go.
-exports.VERSION = '0.5.17';
+exports.VERSION = '0.5.19';
 // JSON-only lexer/parser options. Restrictive enough to mirror
 // JSON.parse: double-quoted strings only, plain decimal numbers, quoted
 // keys only, no comments, no trailing-comma map extension, no empty

package/dist/translate.d.ts

@@ -7,6 +7,7 @@ type TranslationParts = Readonly<{
     lift?: TranslationPart;
     embed?: TranslationPart;
     render?: TranslationPart;
+    transduce?: TranslationPart;
 }>;
 declare function translate(): TranslationParts | undefined;
 export { translate, };

package/dist/translate.js

@@ -46,13 +46,39 @@ const TRANSLATION = Object.freeze({
     "writes": "tree",
     "root": "any",
     "render": "json",
+    "transduce": "alchemy/transduce.alc",
     "loss": [
       "JSON has no spelling for Infinity or NaN, so a number that is not finite is written as null."
     ]
   }
 }
 `,
-    render: Object.freeze({ entry: "json" })
+    render: Object.freeze({ entry: "json" }),
+    transduce: Object.freeze({ entry: "json-transduce", source: `; JSON's transducer part: the document's JSON events from the json
+; grammar's rule passes (ParserEvents/1), streamed as the parser makes
+; them, so that a host that reads parser events (alchemy-cli's translate
+; and run --grammar, aless) reads a JSON document through this file rather
+; than through transduce's inference over the grammar's rule events.
+;
+; The grammar's rules map onto a tree, so the part is the library's
+; declarative transducer, transduce-tree, with a spec keyed by rule name:
+; a map rule's open pass begins an object and its close pass ends it, a
+; list rule's an array; a pair rule's open pass announces the member's
+; name, its first token's value; and a val rule's open pass yields the
+; scalar its first token carries, with the lexeme a number token keeps
+; (2.50 is written 2.50). Every event is the one the walk of the grammar's
+; value gives, a number's lexeme aside, which alchemy-cli's transduce.tsv
+; runner holds it to; a repeated member is streamed twice, as the
+; document spells it, for a tree-contract or a capture's policy to judge.
+def json-transduce [input]
+  transduce-tree
+    record
+      entry :map (record (entry :container :object))
+      entry :list (record (entry :container :array))
+      entry :pair (record (entry :key 0))
+      entry :val (record (entry :scalar 0))
+    input
+` })
 });
 function translate() {
     return TRANSLATION;

package/dist/translate.js.map

@@ -1 +1 @@
-{"version":3,"file":"translate.js","sourceRoot":"","sources":["../src/translate.ts"],"names":[],"mappings":";AAAA,4CAA4C;;QA2E1C,SAAS;AA1DX,MAAM,WAAW,GAAqB,MAAM,CAAC,MAAM,CAAC;IAClD,QAAQ,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgDX;IACC,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,CAAC;CACzC,CAAC,CAAA;AAEF,SAAS,SAAS;IAChB,OAAO,WAAW,CAAA;AACpB,CAAC"}
+{"version":3,"file":"translate.js","sourceRoot":"","sources":["../src/translate.ts"],"names":[],"mappings":";AAAA,4CAA4C;;QAsG1C,SAAS;AApFX,MAAM,WAAW,GAAqB,MAAM,CAAC,MAAM,CAAC;IAClD,QAAQ,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiDX;IACC,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,CAAC;IACxC,SAAS,EAAE,MAAM,CAAC,MAAM,CAAC,EAAE,KAAK,EAAE,gBAAgB,EAAE,MAAM,EAAE;;;;;;;;;;;;;;;;;;;;;;;;CAwB7D,EAAE,CAAC;CACH,CAAC,CAAA;AAEF,SAAS,SAAS;IAChB,OAAO,WAAW,CAAA;AACpB,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tabnas/json",
-  "version": "0.5.17",
+  "version": "0.5.19",
   "main": "dist/json.js",
   "type": "commonjs",
   "types": "dist/json.d.ts",

package/src/json.ts

@@ -23,7 +23,7 @@ import { Tabnas, TabnasError, type Plugin } from '@tabnas/parser'
 // VERSION is this package's version. It MUST equal package.json "version":
 // the release orchestrator rewrites both, and test/version.test.js fails the
 // build if they drift. Mirrors `const VERSION` in go/json.go.
-export const VERSION = '0.5.17'
+export const VERSION = '0.5.19'
 
 // JSON-only lexer/parser options. Restrictive enough to mirror
 // JSON.parse: double-quoted strings only, plain decimal numbers, quoted

package/src/translate.ts

@@ -13,6 +13,7 @@ type TranslationParts = Readonly<{
   lift?: TranslationPart
   embed?: TranslationPart
   render?: TranslationPart
+  transduce?: TranslationPart
 }>
 
 const TRANSLATION: TranslationParts = Object.freeze({
@@ -59,13 +60,39 @@ const TRANSLATION: TranslationParts = Object.freeze({
     "writes": "tree",
     "root": "any",
     "render": "json",
+    "transduce": "alchemy/transduce.alc",
     "loss": [
       "JSON has no spelling for Infinity or NaN, so a number that is not finite is written as null."
     ]
   }
 }
 `,
-  render: Object.freeze({ entry: "json" })
+  render: Object.freeze({ entry: "json" }),
+  transduce: Object.freeze({ entry: "json-transduce", source: `; JSON's transducer part: the document's JSON events from the json
+; grammar's rule passes (ParserEvents/1), streamed as the parser makes
+; them, so that a host that reads parser events (alchemy-cli's translate
+; and run --grammar, aless) reads a JSON document through this file rather
+; than through transduce's inference over the grammar's rule events.
+;
+; The grammar's rules map onto a tree, so the part is the library's
+; declarative transducer, transduce-tree, with a spec keyed by rule name:
+; a map rule's open pass begins an object and its close pass ends it, a
+; list rule's an array; a pair rule's open pass announces the member's
+; name, its first token's value; and a val rule's open pass yields the
+; scalar its first token carries, with the lexeme a number token keeps
+; (2.50 is written 2.50). Every event is the one the walk of the grammar's
+; value gives, a number's lexeme aside, which alchemy-cli's transduce.tsv
+; runner holds it to; a repeated member is streamed twice, as the
+; document spells it, for a tree-contract or a capture's policy to judge.
+def json-transduce [input]
+  transduce-tree
+    record
+      entry :map (record (entry :container :object))
+      entry :list (record (entry :container :array))
+      entry :pair (record (entry :key 0))
+      entry :val (record (entry :scalar 0))
+    input
+` })
 })
 
 function translate (): TranslationParts | undefined {