jlens-wasm 0.17.0 → 0.19.0

package/jlens.d.ts

@@ -217,6 +217,26 @@ export interface ExplanationLine {
     node: number;
 }
 
+// ---------------------------------------------------------------------------------------------
+// The fields an expression reads
+
+/**
+ * What an expression reads of a value: `true` for the whole value; an object for only the fields
+ * it lists, each with its own `Read` (of an array, its items, each read the same way; of a
+ * scalar, the scalar). An empty object needs the value but none of its fields, as `$count` does.
+ */
+export type Read = true | { [field: string]: Read };
+
+/** What an expression reads of its input and of its bindings, given by `Expression.reads()`. */
+export interface Reads {
+    /** Absent when the expression does not read its input. */
+    input?: Read;
+    /** The bindings the expression reads, by name (without the `$`). */
+    bindings: Record<string, Read>;
+    /** Set when the expression may read any binding whole, as `$eval` can: keep all bindings. */
+    everyBinding?: true;
+}
+
 // ---------------------------------------------------------------------------------------------
 // Parsing
 
@@ -360,7 +380,8 @@ export class Expression {
     evaluate(input?: unknown, bindings?: Bindings | null, options?: EvaluateOptions): unknown;
     /**
      * Like `evaluate`, with the input document and the result as JSON text. This avoids
-     * converting large documents to and from JavaScript objects.
+     * converting large documents to and from JavaScript objects. The fields of the input that the
+     * expression does not read (`reads()`) are skipped while parsing, checked as JSON syntax only.
      */
     evaluateJson(
     input?: string | null,
@@ -385,6 +406,12 @@ export class Expression {
      * `JlensError` when the signature is invalid.
      */
     registerFunction(name: string, implementation: HostFunction, signature?: string): void;
+    /**
+     * The fields of the input and of the bindings the expression reads: an input cut down to them
+     * gives the same result. The functions in `bindings`, and those registered on the expression,
+     * read only their arguments; a call to a function it does not know reads its context whole.
+     */
+    reads(bindings?: Bindings | null): Reads;
     /** The processed syntax tree, as plain objects. */
     ast(): AstNode;
     /** Releases the compiled expression. */
@@ -399,8 +426,12 @@ export class Expression {
 export class Document {
     /** Converts a JSON-compatible value. */
     constructor(input: unknown);
-    /** Parses JSON text. Throws a `TypeError` when it is not valid JSON. */
-    static fromJson(text: string): Document;
+    /**
+     * Parses JSON text. Throws a `TypeError` when it is not valid JSON. With `read` (the `input`
+     * of `reads()` or of `unionReads()`), the fields it leaves out are skipped, checked as JSON
+     * syntax only, and the document serves the expressions it comes from as the whole one would.
+     */
+    static fromJson(text: string, read?: Read | null): Document;
     free(): void;
     [Symbol.dispose](): void;
 }
@@ -433,6 +464,12 @@ export class LanguageService {
     [Symbol.dispose](): void;
 }
 
+/**
+ * What any of several expressions reads: an input cut down to the union gives each of them its
+ * result. Throws a `TypeError` when an item is not in the form `reads()` returns.
+ */
+export function unionReads(reads: Reads[]): Reads;
+
 /**
  * Infers a JSON Schema (2020-12, with `x-jlens-*` annotations) from sample documents.
  * `overrides` adds descriptions, labels, allowed values and hidden fields by path, such as
@@ -469,7 +506,7 @@ export interface InitOutput {
     readonly __wbg_document_free: (a: number, b: number) => void;
     readonly __wbg_expression_free: (a: number, b: number) => void;
     readonly __wbg_languageservice_free: (a: number, b: number) => void;
-    readonly document_fromJson: (a: number, b: number) => [number, number, number];
+    readonly document_fromJson: (a: number, b: number, c: number) => [number, number, number];
     readonly document_new: (a: any) => [number, number, number];
     readonly expression_ast: (a: number) => any;
     readonly expression_evaluate: (a: number, b: number, c: number, d: number) => [number, number, number];
@@ -477,6 +514,7 @@ export interface InitOutput {
     readonly expression_evaluateJson: (a: number, b: number, c: number, d: number, e: number) => [number, number, number, number];
     readonly expression_evaluateWithAudit: (a: number, b: number, c: number, d: number) => [number, number, number];
     readonly expression_new: (a: number, b: number) => [number, number, number];
+    readonly expression_reads: (a: number, b: number) => [number, number, number];
     readonly expression_registerFunction: (a: number, b: number, c: number, d: any, e: number, f: number) => [number, number];
     readonly expression_source: (a: number) => [number, number];
     readonly functions: () => any;
@@ -487,8 +525,9 @@ export interface InitOutput {
     readonly languageservice_new: (a: number, b: number, c: number) => [number, number, number];
     readonly languageservice_signatureHelp: (a: number, b: number, c: number, d: number) => any;
     readonly parseRecover: (a: number, b: number) => any;
+    readonly unionReads: (a: any) => [number, number, number];
     readonly version: () => [number, number];
-    readonly wasm_bindgen_dfd3dc8039a2d669___convert__closures_____invoke___js_sys_94575574b531b35c___Array__core_37ee0ce0c4cd57d5___result__Result_wasm_bindgen_dfd3dc8039a2d669___JsValue__wasm_bindgen_dfd3dc8039a2d669___JsValue___false_: (a: number, b: number, c: any) => [number, number, number];
+    readonly wasm_bindgen_83299752791f6fbb___convert__closures_____invoke___js_sys_f067e63b4fcf480b___Array__core_37ee0ce0c4cd57d5___result__Result_wasm_bindgen_83299752791f6fbb___JsValue__wasm_bindgen_83299752791f6fbb___JsValue___false_: (a: number, b: number, c: any) => [number, number, number];
     readonly __wbindgen_malloc: (a: number, b: number) => number;
     readonly __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
     readonly __wbindgen_exn_store: (a: number) => void;

package/jlens.js

@@ -1,6 +1,7 @@
 /* @ts-self-types="./jlens.d.ts" */
-import { jlensCallable } from './snippets/jlens-wasm-669ebf4a414f63a3/inline0.js';
-import { jlensLevel } from './snippets/jlens-wasm-669ebf4a414f63a3/inline1.js';
+import { jlensCallable } from './snippets/jlens-wasm-14c70486967a4dac/inline0.js';
+import { jlensBuild } from './snippets/jlens-wasm-14c70486967a4dac/inline1.js';
+import { jlensLevel } from './snippets/jlens-wasm-14c70486967a4dac/inline2.js';
 
 
 /**
@@ -25,14 +26,16 @@ export class Document {
         wasm.__wbg_document_free(ptr, 0);
     }
     /**
-     * Parses JSON text.
+     * Parses JSON text. With `read` (the `input` of a `reads()`, or of a `unionReads()`), the
+     * fields it leaves out are skipped: they are checked as JSON syntax only.
      * @param {string} text
+     * @param {any | null} [read]
      * @returns {Document}
      */
-    static fromJson(text) {
+    static fromJson(text, read) {
         const ptr0 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.document_fromJson(ptr0, len0);
+        const ret = wasm.document_fromJson(ptr0, len0, isLikeNone(read) ? 0 : addToExternrefTable0(read));
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
@@ -98,7 +101,8 @@ export class Expression {
     }
     /**
      * Like `evaluate`, with the input document and the result as JSON text. This avoids
-     * converting large documents to and from JavaScript objects.
+     * converting large documents to and from JavaScript objects. The fields of the input that
+     * the expression does not read (`reads()`, without bindings) are skipped while parsing.
      * @param {string | null} [input]
      * @param {any | null} [bindings]
      * @param {any | null} [options]
@@ -169,6 +173,21 @@ export class Expression {
         ExpressionFinalization.register(this, this.__wbg_ptr, this);
         return this;
     }
+    /**
+     * The fields of the input and of the bindings the expression reads (ADR 0016). The
+     * functions in `bindings`, and those registered on the expression, read only their
+     * arguments, since a JavaScript function cannot read the context of its call; a call to a
+     * function the analysis does not know reads its context whole.
+     * @param {any | null} [bindings]
+     * @returns {any}
+     */
+    reads(bindings) {
+        const ret = wasm.expression_reads(this.__wbg_ptr, isLikeNone(bindings) ? 0 : addToExternrefTable0(bindings));
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
     /**
      * Makes `implementation` available to the expression as `$name`, in every evaluation. With
      * a `signature` (such as `<n-n?:n>`), arguments are checked before each call, as for
@@ -328,6 +347,20 @@ export function parseRecover(source) {
     return ret;
 }
 
+/**
+ * What any of several expressions reads: the union of their `reads()`. Throws a `TypeError`
+ * when an item is not in the form `reads()` returns.
+ * @param {any} reads
+ * @returns {any}
+ */
+export function unionReads(reads) {
+    const ret = wasm.unionReads(reads);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
 /**
  * The jlens version.
  * @returns {string}
@@ -431,11 +464,15 @@ function __wbg_get_imports() {
             const ret = Array.isArray(arg0);
             return ret;
         },
-        __wbg_jlensCallable_bc242b920bd3b7cb: function(arg0, arg1) {
+        __wbg_jlensBuild_de18e2fe951ffbb5: function(arg0, arg1, arg2, arg3, arg4, arg5) {
+            const ret = jlensBuild(getArrayU32FromWasm0(arg0, arg1), getArrayF64FromWasm0(arg2, arg3), getStringFromWasm0(arg4, arg5));
+            return ret;
+        },
+        __wbg_jlensCallable_089c61626da1df71: function(arg0, arg1) {
             const ret = jlensCallable(arg0, arg1 >>> 0);
             return ret;
         },
-        __wbg_jlensLevel_4984dcab128c4444: function() { return handleError(function (arg0, arg1, arg2) {
+        __wbg_jlensLevel_7fa2a312bee944b5: function() { return handleError(function (arg0, arg1, arg2) {
             const ret = jlensLevel(arg0, arg1 >>> 0, arg2 >>> 0);
             return ret;
         }, arguments); },
@@ -522,7 +559,7 @@ function __wbg_get_imports() {
         }, arguments); },
         __wbindgen_generic_0000000000000001: function(arg0, arg1) {
             var state0 = {a: arg0, b: arg1};
-            var cb0 = (arg0) => wasm_bindgen_dfd3dc8039a2d669___convert__closures_____invoke___js_sys_94575574b531b35c___Array__core_37ee0ce0c4cd57d5___result__Result_wasm_bindgen_dfd3dc8039a2d669___JsValue__wasm_bindgen_dfd3dc8039a2d669___JsValue___false_(state0.a, state0.b, arg0);
+            var cb0 = (arg0) => wasm_bindgen_83299752791f6fbb___convert__closures_____invoke___js_sys_f067e63b4fcf480b___Array__core_37ee0ce0c4cd57d5___result__Result_wasm_bindgen_83299752791f6fbb___JsValue__wasm_bindgen_83299752791f6fbb___JsValue___false_(state0.a, state0.b, arg0);
             cb0._wbg_cb_unref = () => state0.a = 0;
             // Cast intrinsic for `Closure(Closure { owned: false, function: Function { arguments: [NamedExternref("Array<any>")], shim_idx: 10, ret: Result(Externref), inner_ret: Some(Result(Externref)) }, mutable: false }) -> Externref`.
             const ret = cb0;
@@ -554,8 +591,8 @@ function __wbg_get_imports() {
     };
 }
 
-function wasm_bindgen_dfd3dc8039a2d669___convert__closures_____invoke___js_sys_94575574b531b35c___Array__core_37ee0ce0c4cd57d5___result__Result_wasm_bindgen_dfd3dc8039a2d669___JsValue__wasm_bindgen_dfd3dc8039a2d669___JsValue___false_(arg0, arg1, arg2) {
-    const ret = wasm.wasm_bindgen_dfd3dc8039a2d669___convert__closures_____invoke___js_sys_94575574b531b35c___Array__core_37ee0ce0c4cd57d5___result__Result_wasm_bindgen_dfd3dc8039a2d669___JsValue__wasm_bindgen_dfd3dc8039a2d669___JsValue___false_(arg0, arg1, arg2);
+function wasm_bindgen_83299752791f6fbb___convert__closures_____invoke___js_sys_f067e63b4fcf480b___Array__core_37ee0ce0c4cd57d5___result__Result_wasm_bindgen_83299752791f6fbb___JsValue__wasm_bindgen_83299752791f6fbb___JsValue___false_(arg0, arg1, arg2) {
+    const ret = wasm.wasm_bindgen_83299752791f6fbb___convert__closures_____invoke___js_sys_f067e63b4fcf480b___Array__core_37ee0ce0c4cd57d5___result__Result_wasm_bindgen_83299752791f6fbb___JsValue__wasm_bindgen_83299752791f6fbb___JsValue___false_(arg0, arg1, arg2);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
@@ -654,6 +691,11 @@ function getArrayF64FromWasm0(ptr, len) {
     return getFloat64ArrayMemory0().subarray(ptr / 8, ptr / 8 + len);
 }
 
+function getArrayU32FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getUint32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
+}
+
 let cachedDataViewMemory0 = null;
 function getDataViewMemory0() {
     if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
@@ -674,6 +716,14 @@ function getStringFromWasm0(ptr, len) {
     return decodeText(ptr >>> 0, len);
 }
 
+let cachedUint32ArrayMemory0 = null;
+function getUint32ArrayMemory0() {
+    if (cachedUint32ArrayMemory0 === null || cachedUint32ArrayMemory0.byteLength === 0) {
+        cachedUint32ArrayMemory0 = new Uint32Array(wasm.memory.buffer);
+    }
+    return cachedUint32ArrayMemory0;
+}
+
 let cachedUint8ArrayMemory0 = null;
 function getUint8ArrayMemory0() {
     if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
@@ -774,6 +824,7 @@ function __wbg_finalize_init(instance, module) {
     wasmModule = module;
     cachedDataViewMemory0 = null;
     cachedFloat64ArrayMemory0 = null;
+    cachedUint32ArrayMemory0 = null;
     cachedUint8ArrayMemory0 = null;
     wasm.__wbindgen_start();
     return wasm;

package/jlens_bg.wasm.d.ts

@@ -4,7 +4,7 @@ export const memory: WebAssembly.Memory;
 export const __wbg_document_free: (a: number, b: number) => void;
 export const __wbg_expression_free: (a: number, b: number) => void;
 export const __wbg_languageservice_free: (a: number, b: number) => void;
-export const document_fromJson: (a: number, b: number) => [number, number, number];
+export const document_fromJson: (a: number, b: number, c: number) => [number, number, number];
 export const document_new: (a: any) => [number, number, number];
 export const expression_ast: (a: number) => any;
 export const expression_evaluate: (a: number, b: number, c: number, d: number) => [number, number, number];
@@ -12,6 +12,7 @@ export const expression_evaluateDocument: (a: number, b: number, c: number, d: n
 export const expression_evaluateJson: (a: number, b: number, c: number, d: number, e: number) => [number, number, number, number];
 export const expression_evaluateWithAudit: (a: number, b: number, c: number, d: number) => [number, number, number];
 export const expression_new: (a: number, b: number) => [number, number, number];
+export const expression_reads: (a: number, b: number) => [number, number, number];
 export const expression_registerFunction: (a: number, b: number, c: number, d: any, e: number, f: number) => [number, number];
 export const expression_source: (a: number) => [number, number];
 export const functions: () => any;
@@ -22,8 +23,9 @@ export const languageservice_hover: (a: number, b: number, c: number, d: number)
 export const languageservice_new: (a: number, b: number, c: number) => [number, number, number];
 export const languageservice_signatureHelp: (a: number, b: number, c: number, d: number) => any;
 export const parseRecover: (a: number, b: number) => any;
+export const unionReads: (a: any) => [number, number, number];
 export const version: () => [number, number];
-export const wasm_bindgen_dfd3dc8039a2d669___convert__closures_____invoke___js_sys_94575574b531b35c___Array__core_37ee0ce0c4cd57d5___result__Result_wasm_bindgen_dfd3dc8039a2d669___JsValue__wasm_bindgen_dfd3dc8039a2d669___JsValue___false_: (a: number, b: number, c: any) => [number, number, number];
+export const wasm_bindgen_83299752791f6fbb___convert__closures_____invoke___js_sys_f067e63b4fcf480b___Array__core_37ee0ce0c4cd57d5___result__Result_wasm_bindgen_83299752791f6fbb___JsValue__wasm_bindgen_83299752791f6fbb___JsValue___false_: (a: number, b: number, c: any) => [number, number, number];
 export const __wbindgen_malloc: (a: number, b: number) => number;
 export const __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
 export const __wbindgen_exn_store: (a: number) => void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jlens-wasm",
-  "version": "0.17.0",
+  "version": "0.19.0",
   "description": "JSONata in WebAssembly, with evaluation audits and schema-driven autocomplete",
   "license": "MIT",
   "repository": {

package/snippets/jlens-wasm-14c70486967a4dac/inline1.js

@@ -0,0 +1,48 @@
+
+// Builds the values that `ops` describes, in order: a stack holds the values built, and the
+// arrays and objects being filled. `text` holds the strings and the new keys, one after the
+// other (lengths in UTF-16 code units). Returns the last value built: the result.
+export function jlensBuild(ops, nums, text) {
+  const stack = [];
+  const keys = [];
+  // The index of the key `__proto__`, which an assignment would take for the prototype.
+  let proto = -1;
+  let num = 0, pos = 0;
+  for (let i = 0; i < ops.length; i++) {
+    switch (ops[i]) {
+      case 0: stack.push(null); break;
+      case 1: stack.push(false); break;
+      case 2: stack.push(true); break;
+      case 3: stack.push(nums[num++]); break;
+      case 4: { const end = pos + ops[++i]; stack.push(text.slice(pos, end)); pos = end; break; }
+      case 5: stack.push([]); break;
+      case 6: { const item = stack.pop(); stack[stack.length - 1].push(item); break; }
+      case 7: stack.push({}); break;
+      case 8: {
+        const key = ops[++i];
+        const value = stack.pop();
+        if (key === proto) own(stack[stack.length - 1], keys[key], value);
+        else stack[stack.length - 1][keys[key]] = value;
+        break;
+      }
+      case 9: {
+        const end = pos + ops[++i];
+        const key = text.slice(pos, end);
+        pos = end;
+        const value = stack.pop();
+        if (key === "__proto__") {
+          proto = keys.length;
+          own(stack[stack.length - 1], key, value);
+        } else stack[stack.length - 1][key] = value;
+        keys.push(key);
+        break;
+      }
+    }
+  }
+  return stack.pop();
+}
+
+// Defines an own property, as JSON.parse does.
+function own(object, key, value) {
+  Object.defineProperty(object, key, { value, writable: true, enumerable: true, configurable: true });
+}