updates

Signed-off-by: Jess Frazelle <github@jessfraz.com>

src/lang/parser.ts

@@ -2,18 +2,19 @@ import {
   ParserWorkerResponse,
   WasmWorker,
   WasmWorkerEventType,
+  ParserWorkerCallResponse,
 } from 'lang/workers/types'
-import ParserWorker from 'lang/workers/parser?worker'
-import { wasmUrl } from 'lang/wasm'
+import Worker from 'lang/workers/parser?worker'
+import { Program, wasmUrl } from 'lang/wasm'
 import { KCLError } from 'lang/errors'
 import { v4 as uuidv4 } from 'uuid'
-export type { Program } from 'wasm-lib/kcl/bindings/Program'
 
 export default class Parser {
-  worker: ParserWorker | null = null
+  worker: any = new Worker({ name: 'parse' })
+  intitalized: boolean = false
   mappings: Map<string, Program | KCLError> = new Map()
 
-  async parse(code: string): Program {
+  async parse(code: string): Promise<Program> {
     this.ensureWorker()
     const uuid = uuidv4()
     this.worker.postMessage({
@@ -46,14 +47,17 @@ export default class Parser {
   }
 
   ensureWorker() {
-    if (!this.worker) {
+    if (!this.intitalized) {
       this.start()
     }
   }
 
   // Start the worker.
   start() {
-    this.worker = new ParserWorker({ name: 'parse' })
+    if (this.intitalized) {
+      console.log('Worker already initialized')
+      return
+    }
     this.worker.postMessage({
       worker: WasmWorker.Parser,
       eventType: WasmWorkerEventType.Init,
@@ -62,9 +66,16 @@ export default class Parser {
       },
     })
 
-    this.worker.onmessage = function (e) {
-      const { uuid, response } = e.data as ParserWorkerResponse
-      this.mappings.set(uuid, response)
+    this.worker.onmessage = function (r: ParserWorkerResponse) {
+      switch (r.eventType) {
+        case WasmWorkerEventType.Init:
+          this.intitalized = true
+          break
+        case WasmWorkerEventType.Call:
+          const c = r.response as ParserWorkerCallResponse
+          this.mappings.set(c.uuid, c.response)
+          break
+      }
     }
   }
 }

src/lang/workers/parser.ts

@@ -26,6 +26,10 @@ onmessage = function (event) {
       initialise(wasmUrl)
         .then((instantiatedModule) => {
           console.log('Worker: WASM module loaded', worker, instantiatedModule)
+          postMessage({
+            eventType: WasmWorkerEventType.Init,
+            response: { worker: worker, initialized: true },
+          })
         })
         .catch((error) => {
           console.error('Worker: Error loading wasm module', worker, error)
@@ -35,7 +39,7 @@ onmessage = function (event) {
       const data = eventData as ParserWorkerCall
       try {
         const program: Program = parse_wasm(data.code)
-        postMessage(program)
+        postMessage({ uuid: data.uuid, response: program })
       } catch (e: any) {
         const parsed: RustKclError = JSON.parse(e.toString())
         const kclError = new KCLError(
@@ -44,7 +48,10 @@ onmessage = function (event) {
           rangeTypeFix(parsed.sourceRanges)
         )
 
-        postMessage(kclError)
+        postMessage({
+          eventType: WasmWorkerEventType.Call,
+          response: { uuid: data.uuid, response: kclError },
+        })
       }
       break
     default:

src/lang/workers/types.ts

@@ -18,11 +18,21 @@ export interface ParserWorkerCall {
   code: string
 }
 
-export interface ParserWorkerResponse {
+export interface ParserWorkerInitResponse {
+  worker: WasmWorker
+  initialized: boolean
+}
+
+export interface ParserWorkerCallResponse {
   uuid: string
   response: Program | KCLError
 }
 
+export interface ParserWorkerResponse {
+  eventType: WasmWorkerEventType
+  response: ParserWorkerInitResponse | ParserWorkerCallResponse
+}
+
 export interface WasmWorkerEvent {
   eventType: WasmWorkerEventType
   eventData: Uint8Array | WasmWorkerOptions | ParserWorkerCall