@qikdev/sdk 0.1.207 → 0.1.209

package/package.json

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

package/src/api/qik.content.js

@@ -67,11 +67,37 @@ export default function (qik) {
 
   let inflightGlossaryRequest;
 
+  let inflateWorker = null;
+  let workerLoadPromise = null;
+
   /**
-   * Inflate compressed glossary data from the /glossary/compressed endpoint
+   * Lazily load the Worker module (Vite-specific import)
    * @private
    */
-  function inflateGlossary({ _s: strings, _k: keyMap, types }) {
+  async function loadWorkerModule() {
+    if (workerLoadPromise) return workerLoadPromise;
+    workerLoadPromise = import(
+      "../workers/inflate-glossary.worker.js?worker&inline"
+    );
+    return workerLoadPromise;
+  }
+
+  /**
+   * Get or create the inflate worker instance
+   * @private
+   */
+  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))];
@@ -89,6 +115,44 @@ export default function (qik) {
     return types.map(inflate);
   }
 
+  /**
+   * Inflate compressed glossary data using a Web Worker
+   * Runs on a separate thread to avoid blocking the UI
+   * @private
+   */
+  async function inflateGlossary(data) {
+    // Fallback for non-browser environments (SSR/Node)
+    if (typeof Worker === "undefined") {
+      return inflateGlossarySync(data);
+    }
+
+    try {
+      const worker = await getInflateWorker();
+
+      return new Promise((resolve) => {
+        const handler = (e) => {
+          worker.removeEventListener("message", handler);
+          worker.removeEventListener("error", errorHandler);
+          resolve(e.data);
+        };
+
+        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);
+    }
+  }
+
   /**
      *
      * Retrieves the glossary of all content types visible to the requesting user.
@@ -133,9 +197,9 @@ export default function (qik) {
       // Now we have the glossary
       const { data } = await inflightGlossaryRequest;
 
-      // Inflate if compressed format
+      // Inflate if compressed format (async to avoid blocking UI)
       const glossaryData =
-        data._s && data._k && data.types ? inflateGlossary(data) : data;
+        data._s && data._k && data.types ? await inflateGlossary(data) : data;
 
       // Cache it for later
       glossaryCache.set("glossary", glossaryData);

package/src/version.js

@@ -1 +1 @@
-export const version = "0.1.207";
+export const version = "0.1.209";

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

@@ -0,0 +1,25 @@
+/**
+ * Web Worker for inflating compressed glossary data
+ * Runs on a separate thread to avoid blocking the main UI
+ */
+self.onmessage = 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;
+  }
+
+  const result = types.map(inflate);
+  self.postMessage(result);
+};