jlens-wasm 0.6.0 → 0.8.0

package/jlens.d.ts

@@ -21,7 +21,7 @@ export type HostFunction = (...args: any[]) => unknown;
 export interface EvaluateOptions {
     /** Maximum duration of one evaluation, in milliseconds (error `D1012`). */
     timeout?: number;
-    /** Maximum evaluation depth (default 1,000; error `D1011`). */
+    /** Maximum evaluation depth (default 800; error `D1011`). */
     maxDepth?: number;
     /** Maximum length, in bytes of UTF-8, of a string the evaluation builds (default 256 MiB; error `U1001`). */
     maxStringLength?: number;

package/jlens.js

@@ -1,4 +1,6 @@
 /* @ts-self-types="./jlens.d.ts" */
+import { jlensLevel } from './snippets/jlens-wasm-014be9ee22038758/inline0.js';
+
 
 /**
  * A JSON document converted once into jlens's internal representation, for evaluating
@@ -136,6 +138,9 @@ export class Expression {
      * `$limit`, and `{rate: (region) => ...}` defines `$rate(region)`.
      * Returns `undefined` when the result is undefined; throws a `JlensError` when the
      * evaluation fails.
+     *
+     * The input is read during the evaluation, one level at a time, as the expression reaches
+     * it (ADR 0010).
      * @param {any | null} [input]
      * @param {any | null} [bindings]
      * @param {any | null} [options]
@@ -400,18 +405,40 @@ function __wbg_get_imports() {
             const ret = Reflect.has(arg0, arg1);
             return ret;
         }, arguments); },
+        __wbg_instanceof_Error_80a725f81f2e102d: function(arg0) {
+            let result;
+            try {
+                result = arg0 instanceof Error;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
         __wbg_isArray_e15a2ff68ffdbef2: function(arg0) {
             const ret = Array.isArray(arg0);
             return ret;
         },
+        __wbg_jlensLevel_9fcd70f252c83ea4: function() { return handleError(function (arg0, arg1, arg2) {
+            const ret = jlensLevel(arg0, arg1 >>> 0, arg2 >>> 0);
+            return ret;
+        }, arguments); },
         __wbg_length_3121141f8e1c8c58: function(arg0) {
             const ret = arg0.length;
             return ret;
         },
+        __wbg_length_b5f0008bbf60cf59: function(arg0) {
+            const ret = arg0.length;
+            return ret;
+        },
         __wbg_length_d4bdea10311bd9cf: function(arg0) {
             const ret = arg0.length;
             return ret;
         },
+        __wbg_message_5f8387f0c32b90a7: function(arg0) {
+            const ret = arg0.message;
+            return ret;
+        },
         __wbg_new_2bdcdfcebdfc34d2: function(arg0, arg1) {
             const ret = new TypeError(getStringFromWasm0(arg0, arg1));
             return ret;
@@ -440,6 +467,9 @@ function __wbg_get_imports() {
             const ret = arg0.performance;
             return ret;
         },
+        __wbg_prototypesetcall_d49a4fab5ca427bc: function(arg0, arg1, arg2) {
+            Float64Array.prototype.set.call(getArrayF64FromWasm0(arg0, arg1), arg2);
+        },
         __wbg_push_2baf45db356cf468: function(arg0, arg1) {
             const ret = arg0.push(arg1);
             return ret;
@@ -584,6 +614,11 @@ function debugString(val) {
     return className;
 }
 
+function getArrayF64FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getFloat64ArrayMemory0().subarray(ptr / 8, ptr / 8 + len);
+}
+
 let cachedDataViewMemory0 = null;
 function getDataViewMemory0() {
     if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
@@ -592,6 +627,14 @@ function getDataViewMemory0() {
     return cachedDataViewMemory0;
 }
 
+let cachedFloat64ArrayMemory0 = null;
+function getFloat64ArrayMemory0() {
+    if (cachedFloat64ArrayMemory0 === null || cachedFloat64ArrayMemory0.byteLength === 0) {
+        cachedFloat64ArrayMemory0 = new Float64Array(wasm.memory.buffer);
+    }
+    return cachedFloat64ArrayMemory0;
+}
+
 function getStringFromWasm0(ptr, len) {
     return decodeText(ptr >>> 0, len);
 }
@@ -695,6 +738,7 @@ function __wbg_finalize_init(instance, module) {
     wasm = instance.exports;
     wasmModule = module;
     cachedDataViewMemory0 = null;
+    cachedFloat64ArrayMemory0 = null;
     cachedUint8ArrayMemory0 = null;
     wasm.__wbindgen_start();
     return wasm;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jlens-wasm",
-  "version": "0.6.0",
+  "version": "0.8.0",
   "description": "JSONata in WebAssembly, with evaluation audits and schema-driven autocomplete",
   "license": "MIT",
   "repository": {
@@ -25,6 +25,7 @@
     "jlens.d.ts",
     "jlens_bg.wasm",
     "jlens_bg.wasm.d.ts",
+    "snippets/",
     "README.md",
     "LICENSE"
   ],

package/snippets/jlens-wasm-014be9ee22038758/inline0.js

@@ -0,0 +1,79 @@
+
+const CIRCULAR = "Converting circular structure to JSON";
+const BIGINT = "Do not know how to serialize a BigInt";
+
+// Reads one level: `kind` 0 is the input itself (`node` is the value), 1 an array and 2 an
+// object (`node` is {v, up}: the value and its parent's node, to detect cycles). Returns the
+// number of values then their tags and numbers, their strings and keys as one text (lengths
+// in UTF-16 code units), and the nodes of the nested arrays and objects. In an object,
+// each value is followed by the length of its key. An array or object of more than `whole`
+// values is returned as its JSON text instead (a cycle back to an ancestor passes through it
+// again, so JSON.stringify sees it).
+export function jlensLevel(node, kind, whole) {
+  const nums = [0];
+  let text = "";
+  const nested = [];
+  const up = kind === 0 ? null : node;
+  const put = (v, key) => {
+    if ((typeof v === "object" && v !== null) || typeof v === "bigint") {
+      const toJSON = v.toJSON;
+      if (typeof toJSON === "function") v = toJSON.call(v, key);
+    }
+    if (typeof v === "object" && v !== null) {
+      if (v instanceof Number) v = Number(v);
+      else if (v instanceof String) v = String(v);
+      else if (v instanceof Boolean) v = v.valueOf();
+      else if (v instanceof BigInt) throw new TypeError(BIGINT);
+    }
+    switch (typeof v) {
+      case "string":
+        nums.push(5, v.length);
+        text += v;
+        return true;
+      case "number":
+        if (isFinite(v)) nums.push(4, v);
+        else nums.push(1);
+        return true;
+      case "boolean":
+        nums.push(v ? 3 : 2);
+        return true;
+      case "bigint":
+        throw new TypeError(BIGINT);
+      case "object":
+        if (v === null) {
+          nums.push(1);
+          return true;
+        }
+        for (let n = up; n !== null; n = n.up) {
+          if (n.v === v) throw new TypeError(CIRCULAR);
+        }
+        nums.push(Array.isArray(v) ? 6 : 7);
+        nested.push({ v, up });
+        return true;
+      default:
+        return false;
+    }
+  };
+  if (kind === 0) {
+    put(node, "");
+  } else if (kind === 1) {
+    const items = node.v;
+    if (items.length > whole) return JSON.stringify(items);
+    nums[0] = items.length;
+    for (let i = 0; i < items.length; i++) {
+      if (!put(items[i], String(i))) nums.push(1);
+    }
+  } else {
+    const fields = node.v;
+    const keys = Object.keys(fields);
+    if (keys.length > whole) return JSON.stringify(fields);
+    nums[0] = keys.length;
+    for (const key of keys) {
+      if (put(fields[key], key)) {
+        nums.push(key.length);
+        text += key;
+      }
+    }
+  }
+  return [new Float64Array(nums), text, nested];
+}