@qikdev/sdk 0.1.209 → 0.1.211

package/package.json

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

package/src/api/qik.content.js

@@ -67,38 +67,12 @@ export default function (qik) {
 
   let inflightGlossaryRequest;
 
-  let inflateWorker = null;
-  let workerLoadPromise = null;
-
-  /**
-   * Lazily load the Worker module (Vite-specific import)
-   * @private
-   */
-  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
+   * Inflate a single value from compressed format
    * @private
    */
-  function inflateGlossarySync({ _s: strings, _k: keyMap, types }) {
-    function inflate(val) {
+  function createInflator(strings, keyMap) {
+    return function inflate(val) {
       if (typeof val === "string" && val[0] === "~") {
         return strings[parseInt(val.slice(1))];
       }
@@ -111,46 +85,111 @@ export default function (qik) {
         return result;
       }
       return val;
-    }
-    return types.map(inflate);
+    };
   }
 
   /**
-   * Inflate compressed glossary data using a Web Worker
-   * Runs on a separate thread to avoid blocking the UI
+   * Create a lazy-inflating array that only inflates items when accessed
+   * This avoids the upfront cost of inflating the entire glossary
    * @private
    */
-  async function inflateGlossary(data) {
-    // Fallback for non-browser environments (SSR/Node)
-    if (typeof Worker === "undefined") {
-      return inflateGlossarySync(data);
-    }
-
-    try {
-      const worker = await getInflateWorker();
+  function createLazyGlossary({ _s: strings, _k: keyMap, types }) {
+    const inflate = createInflator(strings, keyMap);
+    const cache = new Array(types.length);
+    const inflated = new Array(types.length).fill(false);
+
+    return new Proxy(types, {
+      get(target, prop) {
+        // Handle array methods and properties
+        if (prop === "length") return target.length;
+        if (prop === Symbol.iterator) {
+          return function* () {
+            for (let i = 0; i < target.length; i++) {
+              if (!inflated[i]) {
+                cache[i] = inflate(target[i]);
+                inflated[i] = true;
+              }
+              yield cache[i];
+            }
+          };
+        }
+        if (prop === "map") {
+          return function (fn) {
+            const result = [];
+            for (let i = 0; i < target.length; i++) {
+              if (!inflated[i]) {
+                cache[i] = inflate(target[i]);
+                inflated[i] = true;
+              }
+              result.push(fn(cache[i], i, this));
+            }
+            return result;
+          };
+        }
+        if (prop === "filter") {
+          return function (fn) {
+            const result = [];
+            for (let i = 0; i < target.length; i++) {
+              if (!inflated[i]) {
+                cache[i] = inflate(target[i]);
+                inflated[i] = true;
+              }
+              if (fn(cache[i], i, this)) {
+                result.push(cache[i]);
+              }
+            }
+            return result;
+          };
+        }
+        if (prop === "find") {
+          return function (fn) {
+            for (let i = 0; i < target.length; i++) {
+              if (!inflated[i]) {
+                cache[i] = inflate(target[i]);
+                inflated[i] = true;
+              }
+              if (fn(cache[i], i, this)) {
+                return cache[i];
+              }
+            }
+            return undefined;
+          };
+        }
+        if (prop === "forEach") {
+          return function (fn) {
+            for (let i = 0; i < target.length; i++) {
+              if (!inflated[i]) {
+                cache[i] = inflate(target[i]);
+                inflated[i] = true;
+              }
+              fn(cache[i], i, this);
+            }
+          };
+        }
 
-      return new Promise((resolve) => {
-        const handler = (e) => {
-          worker.removeEventListener("message", handler);
-          worker.removeEventListener("error", errorHandler);
-          resolve(e.data);
-        };
+        // Handle numeric indices
+        const index = typeof prop === "string" ? parseInt(prop, 10) : prop;
+        if (Number.isInteger(index) && index >= 0 && index < target.length) {
+          if (!inflated[index]) {
+            cache[index] = inflate(target[index]);
+            inflated[index] = true;
+          }
+          return cache[index];
+        }
 
-        const errorHandler = () => {
-          worker.removeEventListener("message", handler);
-          worker.removeEventListener("error", errorHandler);
-          // Fallback to sync on error
-          resolve(inflateGlossarySync(data));
-        };
+        // Pass through other properties
+        return Reflect.get(target, prop);
+      },
+    });
+  }
 
-        worker.addEventListener("message", handler);
-        worker.addEventListener("error", errorHandler);
-        worker.postMessage(data);
-      });
-    } catch {
-      // Dynamic import failed (Node.js or unsupported environment)
-      return inflateGlossarySync(data);
-    }
+  /**
+   * Process compressed glossary data
+   * Uses lazy inflation to avoid blocking the main thread
+   * @private
+   */
+  function inflateGlossary(data) {
+    return createLazyGlossary(data);
   }
 
   /**
@@ -197,9 +236,9 @@ export default function (qik) {
       // Now we have the glossary
       const { data } = await inflightGlossaryRequest;
 
-      // Inflate if compressed format (async to avoid blocking UI)
+      // Inflate if compressed format (lazy - inflates on access)
       const glossaryData =
-        data._s && data._k && data.types ? await inflateGlossary(data) : data;
+        data._s && data._k && data.types ? inflateGlossary(data) : data;
 
       // Cache it for later
       glossaryCache.set("glossary", glossaryData);

package/src/version.js

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

package/dist/inflate-glossary.worker-DEO1byBA.js

@@ -1,24 +0,0 @@
-const s = `(function(){"use strict";self.onmessage=function(r){const{_s:o,_k:f,types:i}=r.data;function e(t){if(typeof t=="string"&&t[0]==="~")return o[parseInt(t.slice(1))];if(Array.isArray(t))return t.map(e);if(t&&typeof t=="object"){const s={};for(const[n,u]of Object.entries(t))s[f[n]||n]=e(u);return s}return t}const c=i.map(e);self.postMessage(c)}})();
-`, n = typeof self < "u" && self.Blob && new Blob(["(self.URL || self.webkitURL).revokeObjectURL(self.location.href);", s], { type: "text/javascript;charset=utf-8" });
-function o(r) {
-  let e;
-  try {
-    if (e = n && (self.URL || self.webkitURL).createObjectURL(n), !e) throw "";
-    const t = new Worker(e, {
-      name: r?.name
-    });
-    return t.addEventListener("error", () => {
-      (self.URL || self.webkitURL).revokeObjectURL(e);
-    }), t;
-  } catch {
-    return new Worker(
-      "data:text/javascript;charset=utf-8," + encodeURIComponent(s),
-      {
-        name: r?.name
-      }
-    );
-  }
-}
-export {
-  o as default
-};

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

@@ -1,25 +0,0 @@
-/**
- * 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);
-};