feat: add a histrical wit-bindgen

__wasm/wit-bindgen-sample/wit-bindgen/tests/runtime/handles/host.ts

@@ -0,0 +1,127 @@
+import { addImportsToImports, Imports } from "./imports.js";
+import { Exports } from "./exports.js";
+import * as exports from "./exports.js";
+import { getWasm, addWasiToImports } from "./helpers.js";
+// @ts-ignore
+import * as assert from 'assert';
+
+async function run() {
+  const importObj = {};
+  let sawClose = false;
+  const imports: Imports = {
+    hostStateCreate() { return 100; },
+    hostStateGet(x) { return x as number; },
+    hostState2Create() { return 101; },
+    hostState2SawClose() { return sawClose; },
+    dropHostState2(state) { sawClose = true; },
+    twoHostStates(a, b) { return [b, a]; },
+    hostState2ParamRecord(x) {},
+    hostState2ParamTuple(x) {},
+    hostState2ParamOption(x) {},
+    hostState2ParamResult(x) {},
+    hostState2ParamVariant(x) {},
+    hostState2ParamList(x) {},
+
+    hostState2ResultRecord() { return { a: {} }; },
+    hostState2ResultTuple() { return [{}]; },
+    hostState2ResultOption() { return 102; },
+    hostState2ResultResult() { return { tag: 'ok', val: {} }; },
+    hostState2ResultVariant() { return { tag: 0, val: {} }; },
+    hostState2ResultList() { return [{}, 3]; },
+
+    markdown2Create() {
+      class Markdown {
+        buf: string;
+
+        constructor() {
+          this.buf = '';
+        }
+        append(extra: string) {
+          this.buf += extra;
+        }
+        render() {
+          return this.buf.replace('red', 'green');
+        }
+      }
+
+      return new Markdown();
+    },
+
+    oddNameCreate() {
+      class OddName {
+        frobTheOdd() {}
+      }
+      return new OddName();
+    }
+  };
+  let instance: WebAssembly.Instance;
+  addImportsToImports(importObj, imports, name => instance.exports[name]);
+  const wasi = addWasiToImports(importObj);
+
+  const wasm = new Exports();
+  await wasm.instantiate(getWasm(), importObj);
+  wasi.start(wasm.instance);
+  instance = wasm.instance;
+
+  wasm.testImports();
+
+  // Param/result of a handle works in a simple fashion
+  const s: exports.WasmState = wasm.wasmStateCreate();
+  assert.strictEqual(wasm.wasmStateGetVal(s), 100);
+
+  // Deterministic destruction is possible
+  assert.strictEqual(wasm.wasmState2SawClose(), false);
+  const s2: exports.WasmState2 = wasm.wasmState2Create();
+  assert.strictEqual(wasm.wasmState2SawClose(), false);
+  s2.drop();
+  assert.strictEqual(wasm.wasmState2SawClose(), true);
+
+  const arg1 = wasm.wasmStateCreate();
+  const arg2 = wasm.wasmState2Create();
+  const [c, d] = wasm.twoWasmStates(arg1, arg2);
+  arg1.drop();
+  arg2.drop();
+
+  wasm.wasmState2ParamRecord({ a: d });
+  wasm.wasmState2ParamTuple([d]);
+  wasm.wasmState2ParamOption(d);
+  wasm.wasmState2ParamOption(null);
+  wasm.wasmState2ParamResult({ tag: 'ok', val: d });
+  wasm.wasmState2ParamResult({ tag: 'err', val: 2 });
+  wasm.wasmState2ParamVariant({ tag: 0, val: d });
+  wasm.wasmState2ParamVariant({ tag: 1, val: 2 });
+  wasm.wasmState2ParamList([]);
+  wasm.wasmState2ParamList([d]);
+  wasm.wasmState2ParamList([d, d]);
+
+  c.drop();
+  d.drop();
+
+  wasm.wasmState2ResultRecord().a?.drop();
+  wasm.wasmState2ResultTuple()[0].drop();
+  const opt = wasm.wasmState2ResultOption();
+  if (opt === null)
+    throw new Error('should be some');
+  opt.drop();
+  const result = wasm.wasmState2ResultResult();
+  if (result.tag === 'err')
+    throw new Error('should be ok');
+  result.val.drop();
+  const variant = wasm.wasmState2ResultVariant();
+  if (variant.tag === 1)
+    throw new Error('should be 0');
+  variant.val.drop();
+  for (let val of wasm.wasmState2ResultList())
+    val.drop();
+
+  s.drop();
+
+  const md = exports.Markdown.create(wasm);
+  if (md) {
+    md.append("red is the best color");
+    assert.strictEqual(md.render(), "green is the best color");
+    md.drop();
+  }
+}
+
+await run()