Initialization of web worker is fixed.

Author: jcreedcmu

src/index.ts

@@ -83,10 +83,10 @@ async function initTwelf(editor: EditorView) {
   }
 
   (document.getElementById('twelf-response') as HTMLTextAreaElement).value = '';
-  const twelfService = await mkTwelfWorker();
+  const worker = await mkTwelfWorker();
 
   async function execAndShowStatus(text: string): Promise<void> {
-    const result = await twelfService.exec(text);
+    const result = await worker.exec(text);
     showStatus(result.status);
     showErrors(result.errors);
     (document.getElementById('twelf-response') as HTMLTextAreaElement).value = result.output.join('');

src/twelf-service.ts

@@ -1,4 +1,4 @@
-import { Status, TwelfError, TwelfWorkerResponse } from "./twelf-worker-types";
+import { Status, TwelfError, TwelfExecResponse } from "./twelf-worker-types";
 import { WasiSnapshotPreview1, args_get, args_sizes_get, clock_time_get, environ_sizes_get, fd_write } from "./wasi";
 
 type TwelfExports = {
@@ -60,7 +60,7 @@ export class TwelfService {
 
   constructor(public instance: WebAssembly.Instance, public output: string[]) { }
 
-  async exec(input: string): Promise<TwelfWorkerResponse> {
+  async exec(input: string): Promise<TwelfExecResponse> {
     this.output.splice(0); // Erase output
 
     const exports = this.instance.exports as TwelfExports;

src/twelf-worker-types.ts

@@ -10,12 +10,19 @@ export type TwelfError = {
 
 export type WithId<T> = { id: number, body: T };
 
-export type TwelfWorkerRequest = {
+export type TwelfExecRequest = {
   input: string,
 }
 
-export type TwelfWorkerResponse = {
+export type TwelfExecResponse = {
   status: Status,
   output: string[],
   errors: TwelfError[],
 }
+
+export type TwelfReadyResponse = {};
+
+export type TwelfResponse =
+  | { t: 'ready', id: number, response: TwelfReadyResponse }
+  | { t: 'execResponse', id: number, response: TwelfExecResponse }
+  ;

src/twelf-worker.ts

@@ -1,35 +1,53 @@
-import { TwelfWorkerRequest, TwelfWorkerResponse, WithId } from "./twelf-worker-types";
+import { TwelfExecRequest, TwelfExecResponse, TwelfResponse, WithId } from "./twelf-worker-types";
 
-export function mkTwelfWorker(): TwelfWorker {
-  return new TwelfWorker();
+export async function mkTwelfWorker(): Promise<TwelfWorker> {
+  const worker = new TwelfWorker();
+  await worker.isReady();
+  return worker;
 }
 
 class TwelfWorker {
   requestIdCounter: number = 0;
-  responseMap: Record<number, (result: TwelfWorkerResponse) => void> = {};
+  responseMap: Record<number, (result: TwelfResponse) => void>;
   worker: Worker;
+  _readyPromise: Promise<void>;
 
   constructor() {
     this.worker = new Worker('./assets/worker.js');
     this.worker.onmessage = (msg) => {
-      const data: WithId<TwelfWorkerResponse> = msg.data;
-      this.responseMap[data.id](data.body);
+      const data: TwelfResponse = msg.data;
+      this.responseMap[data.id](data);
     }
+    this.responseMap = {};
+    const readyPromise = new Promise<void>((res, rej) => {
+      this.responseMap[-1] = msg => {
+        res();
+      }
+    });
+    this._readyPromise = readyPromise;
   }
 
-  mkRequest(input: string): WithId<TwelfWorkerRequest> {
+  mkRequest(input: string): WithId<TwelfExecRequest> {
     return {
       id: this.requestIdCounter++,
       body: { input },
     };
   }
 
-  exec(input: string): Promise<TwelfWorkerResponse> {
+  async exec(input: string): Promise<TwelfExecResponse> {
     const req = this.mkRequest(input);
-    const prom = new Promise<TwelfWorkerResponse>((res, rej) => {
+    const prom = new Promise<TwelfResponse>((res, rej) => {
       this.responseMap[req.id] = res;
     });
     this.worker.postMessage(req);
-    return prom;
+    const p = await prom;
+    if (p.t != 'execResponse') {
+      throw new Error(`expected execReponse but got ${p.t}`);
+    }
+    return p.response;
+  }
+
+  isReady(): Promise<void> {
+    return this._readyPromise;
   }
 }

src/worker.ts

@@ -1,19 +1,19 @@
 import { mkTwelfService } from "./twelf-service";
-import { Status, TwelfWorkerRequest, TwelfWorkerResponse, WithId } from "./twelf-worker-types";
+import { Status, TwelfExecRequest, TwelfExecResponse, TwelfResponse, WithId } from "./twelf-worker-types";
 
 async function go() {
   const service = await mkTwelfService('./twelf.wasm');
 
-  // XXX What happens if we get a message before twelf wasm is loaded?
-  // Should send a "we're all initialized" message back to host.
+  function post(r: TwelfResponse): void {
+    self.postMessage(r);
+  }
 
   self.onmessage = async event => {
-    const { body, id } = event.data as WithId<TwelfWorkerRequest>;
-    const response: WithId<TwelfWorkerResponse> =
-      { id, body: await service.exec(body.input) };
-    self.postMessage(response);
+    const { body, id } = event.data as WithId<TwelfExecRequest>;
+    post({ t: 'execResponse', id, response: await service.exec(body.input) });
   };
 
+  post({ t: 'ready', id: -1, response: {} });
 }
 
 go();