wrote wasm binding for eval_boolean function - let's see if it works

pkg/argus_wasm.d.ts

@@ -1,7 +1,17 @@
 /* tslint:disable */
 /* eslint-disable */
-export function parse_str(s: string): WrappedExpr;
-export class WrappedExpr {
+export function eval_boolean(s: string, trace: StateBuddyTrace): StateBuddyEvalResult;
+export class StateBuddyEvalResult {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+}
+export class StateBuddyEvalResultEntry {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+}
+export class StateBuddyTrace {
   private constructor();
   free(): void;
   [Symbol.dispose](): void;
@@ -11,8 +21,10 @@ export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembl
 
 export interface InitOutput {
   readonly memory: WebAssembly.Memory;
-  readonly __wbg_wrappedexpr_free: (a: number, b: number) => void;
-  readonly parse_str: (a: number, b: number) => number;
+  readonly __wbg_statebuddytrace_free: (a: number, b: number) => void;
+  readonly eval_boolean: (a: number, b: number, c: number) => number;
+  readonly __wbg_statebuddyevalresultentry_free: (a: number, b: number) => void;
+  readonly __wbg_statebuddyevalresult_free: (a: number, b: number) => void;
   readonly __wbindgen_externrefs: WebAssembly.Table;
   readonly __wbindgen_malloc: (a: number, b: number) => number;
   readonly __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;

pkg/argus_wasm.js

@@ -83,44 +83,92 @@ function passStringToWasm0(arg, malloc, realloc) {
     WASM_VECTOR_LEN = offset;
     return ptr;
 }
+
+function _assertClass(instance, klass) {
+    if (!(instance instanceof klass)) {
+        throw new Error(`expected instance of ${klass.name}`);
+    }
+}
 /**
  * @param {string} s
- * @returns {WrappedExpr}
+ * @param {StateBuddyTrace} trace
+ * @returns {StateBuddyEvalResult}
  */
-export function parse_str(s) {
+export function eval_boolean(s, trace) {
     const ptr0 = passStringToWasm0(s, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
     const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.parse_str(ptr0, len0);
-    return WrappedExpr.__wrap(ret);
+    _assertClass(trace, StateBuddyTrace);
+    const ret = wasm.eval_boolean(ptr0, len0, trace.__wbg_ptr);
+    return StateBuddyEvalResult.__wrap(ret);
 }
 
-const WrappedExprFinalization = (typeof FinalizationRegistry === 'undefined')
+const StateBuddyEvalResultFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_wrappedexpr_free(ptr >>> 0, 1));
+    : new FinalizationRegistry(ptr => wasm.__wbg_statebuddyevalresult_free(ptr >>> 0, 1));
 
-export class WrappedExpr {
+export class StateBuddyEvalResult {
 
     static __wrap(ptr) {
         ptr = ptr >>> 0;
-        const obj = Object.create(WrappedExpr.prototype);
+        const obj = Object.create(StateBuddyEvalResult.prototype);
         obj.__wbg_ptr = ptr;
-        WrappedExprFinalization.register(obj, obj.__wbg_ptr, obj);
+        StateBuddyEvalResultFinalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
 
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        WrappedExprFinalization.unregister(this);
+        StateBuddyEvalResultFinalization.unregister(this);
         return ptr;
     }
 
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_wrappedexpr_free(ptr, 0);
+        wasm.__wbg_statebuddyevalresult_free(ptr, 0);
     }
 }
-if (Symbol.dispose) WrappedExpr.prototype[Symbol.dispose] = WrappedExpr.prototype.free;
+if (Symbol.dispose) StateBuddyEvalResult.prototype[Symbol.dispose] = StateBuddyEvalResult.prototype.free;
+
+const StateBuddyEvalResultEntryFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_statebuddyevalresultentry_free(ptr >>> 0, 1));
+
+export class StateBuddyEvalResultEntry {
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        StateBuddyEvalResultEntryFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_statebuddyevalresultentry_free(ptr, 0);
+    }
+}
+if (Symbol.dispose) StateBuddyEvalResultEntry.prototype[Symbol.dispose] = StateBuddyEvalResultEntry.prototype.free;
+
+const StateBuddyTraceFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_statebuddytrace_free(ptr >>> 0, 1));
+
+export class StateBuddyTrace {
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        StateBuddyTraceFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_statebuddytrace_free(ptr, 0);
+    }
+}
+if (Symbol.dispose) StateBuddyTrace.prototype[Symbol.dispose] = StateBuddyTrace.prototype.free;
 
 const EXPECTED_RESPONSE_TYPES = new Set(['basic', 'cors', 'default']);
 

pkg/argus_wasm_bg.wasm.d.ts

@@ -1,8 +1,10 @@
 /* tslint:disable */
 /* eslint-disable */
 export const memory: WebAssembly.Memory;
-export const __wbg_wrappedexpr_free: (a: number, b: number) => void;
-export const parse_str: (a: number, b: number) => number;
+export const __wbg_statebuddytrace_free: (a: number, b: number) => void;
+export const eval_boolean: (a: number, b: number, c: number) => number;
+export const __wbg_statebuddyevalresultentry_free: (a: number, b: number) => void;
+export const __wbg_statebuddyevalresult_free: (a: number, b: number) => void;
 export const __wbindgen_externrefs: WebAssembly.Table;
 export const __wbindgen_malloc: (a: number, b: number) => number;
 export const __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;