@qikdev/sdk 0.1.208 → 0.1.210

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@qikdev/sdk",
-  "version": "0.1.208",
+  "version": "0.1.210",
   "type": "module",
   "description": "Promise based Javascript SDK",
   "main": "./dist/main.js",

package/src/api/qik.content.js

@@ -67,26 +67,37 @@ export default function (qik) {
 
   let inflightGlossaryRequest;
 
+  let inflateWorker = null;
+  let workerLoadPromise = null;
+
   /**
-   * Yield to the event loop to keep the UI responsive
+   * Lazily load the Worker module (Vite-specific import)
    * @private
    */
-  function yieldToMain() {
-    return new Promise((resolve) => {
-      if (typeof requestIdleCallback === "function") {
-        requestIdleCallback(resolve, { timeout: 50 });
-      } else {
-        setTimeout(resolve, 0);
-      }
-    });
+  async function loadWorkerModule() {
+    if (workerLoadPromise) return workerLoadPromise;
+    workerLoadPromise = import(
+      "../workers/inflate-glossary.worker.js?worker&inline"
+    );
+    return workerLoadPromise;
   }
 
   /**
-   * Inflate compressed glossary data from the /glossary/compressed endpoint
-   * Processes in chunks to avoid blocking the main thread
+   * Get or create the inflate worker instance
    * @private
    */
-  async function inflateGlossary({ _s: strings, _k: keyMap, types }) {
+  async function getInflateWorker() {
+    if (inflateWorker) return inflateWorker;
+    const module = await loadWorkerModule();
+    inflateWorker = new module.default();
+    return inflateWorker;
+  }
+
+  /**
+   * Sync fallback for SSR/Node environments where Workers don't exist
+   * @private
+   */
+  function inflateGlossarySync({ _s: strings, _k: keyMap, types }) {
     function inflate(val) {
       if (typeof val === "string" && val[0] === "~") {
         return strings[parseInt(val.slice(1))];
@@ -101,21 +112,52 @@ export default function (qik) {
       }
       return val;
     }
+    return types.map(inflate);
+  }
+
+  /**
+   * Inflate compressed glossary data using a Web Worker
+   * Receives results in chunks to avoid blocking during deserialization
+   * @private
+   */
+  async function inflateGlossary(data) {
+    // Fallback for non-browser environments (SSR/Node)
+    if (typeof Worker === "undefined") {
+      return inflateGlossarySync(data);
+    }
 
-    const CHUNK_SIZE = 50;
-    const results = [];
+    try {
+      const worker = await getInflateWorker();
 
-    for (let i = 0; i < types.length; i += CHUNK_SIZE) {
-      const chunk = types.slice(i, i + CHUNK_SIZE);
-      results.push(...chunk.map(inflate));
+      return new Promise((resolve) => {
+        const results = [];
 
-      // Yield to main thread between chunks
-      if (i + CHUNK_SIZE < types.length) {
-        await yieldToMain();
-      }
-    }
+        const handler = (e) => {
+          const { chunk, done } = e.data;
+          results.push(...chunk);
 
-    return results;
+          if (done) {
+            worker.removeEventListener("message", handler);
+            worker.removeEventListener("error", errorHandler);
+            resolve(results);
+          }
+        };
+
+        const errorHandler = () => {
+          worker.removeEventListener("message", handler);
+          worker.removeEventListener("error", errorHandler);
+          // Fallback to sync on error
+          resolve(inflateGlossarySync(data));
+        };
+
+        worker.addEventListener("message", handler);
+        worker.addEventListener("error", errorHandler);
+        worker.postMessage(data);
+      });
+    } catch {
+      // Dynamic import failed (Node.js or unsupported environment)
+      return inflateGlossarySync(data);
+    }
   }
 
   /**

package/src/version.js

@@ -1 +1 @@
-export const version = "0.1.208";
+export const version = "0.1.210";

package/src/workers/inflate-glossary.worker.js

@@ -0,0 +1,38 @@
+/**
+ * Web Worker for inflating compressed glossary data
+ * Streams results back in chunks with delays to avoid blocking the main thread
+ */
+self.onmessage = async function (e) {
+  const { _s: strings, _k: keyMap, types } = e.data;
+
+  function inflate(val) {
+    if (typeof val === "string" && val[0] === "~") {
+      return strings[parseInt(val.slice(1))];
+    }
+    if (Array.isArray(val)) return val.map(inflate);
+    if (val && typeof val === "object") {
+      const result = {};
+      for (const [k, v] of Object.entries(val)) {
+        result[keyMap[k] || k] = inflate(v);
+      }
+      return result;
+    }
+    return val;
+  }
+
+  // Send results back in chunks with small delays
+  // This lets the main thread process each chunk before receiving the next
+  const CHUNK_SIZE = 20;
+  const total = types.length;
+
+  for (let i = 0; i < total; i += CHUNK_SIZE) {
+    const chunk = types.slice(i, i + CHUNK_SIZE).map(inflate);
+    const done = i + CHUNK_SIZE >= total;
+    self.postMessage({ chunk, done });
+
+    // Small delay between chunks to let main thread breathe
+    if (!done) {
+      await new Promise((r) => setTimeout(r, 0));
+    }
+  }
+};