@qikdev/sdk 0.1.210 → 0.1.211

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@qikdev/sdk",
-  "version": "0.1.210",
+  "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,53 +85,111 @@ export default function (qik) {
         return result;
       }
       return val;
-    }
-    return types.map(inflate);
+    };
   }
 
   /**
-   * Inflate compressed glossary data using a Web Worker
-   * Receives results in chunks to avoid blocking during deserialization
+   * 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();
-
-      return new Promise((resolve) => {
-        const results = [];
-
-        const handler = (e) => {
-          const { chunk, done } = e.data;
-          results.push(...chunk);
+  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);
+            }
+          };
+        }
 
-          if (done) {
-            worker.removeEventListener("message", handler);
-            worker.removeEventListener("error", errorHandler);
-            resolve(results);
+        // 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);
   }
 
   /**
@@ -204,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.210";
+export const version = "0.1.211";

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

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

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

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