@qikdev/sdk 0.1.213 → 0.2.0

package/package.json

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

package/src/api/qik.content.js

@@ -64,148 +64,30 @@ export default function (qik) {
   ///////////////////////////////////////////////////
 
   const glossaryCache = qik.cache.get("user:glossary");
-  const glossaryIndexCache = qik.cache.get("user:glossary:index");
-  const definitionCache = qik.cache.get("user:glossary:definitions");
 
   let inflightGlossaryRequest;
-  let inflightGlossaryIndexRequest;
-  let inflightDefinitionRequests = {};
-  let indexItemsByKey = {};
-  let hydrationQueue = [];
-  let isHydrating = false;
-
-  const CONCURRENT_HYDRATION_REQUESTS = 3;
 
   /**
-   * Start background hydration of all definitions
-   * Uses concurrent workers for faster loading
+   * Yield to the event loop to keep the UI responsive
    * @private
    */
-  async function startBackgroundHydration(keys) {
-    hydrationQueue = [...keys];
-    if (isHydrating) return;
-    isHydrating = true;
-
-    // Worker function that pulls from the shared queue
-    async function worker() {
-      while (hydrationQueue.length > 0) {
-        const key = hydrationQueue.shift();
-
-        // Skip if already populated or loading
-        if (indexItemsByKey[key]?.populated) continue;
-        if (inflightDefinitionRequests[key]) continue;
-
-        try {
-          await loadDefinition(key);
-        } catch (e) {
-          console.warn(`Failed to hydrate ${key}:`, e);
-        }
+  function yieldToMain() {
+    return new Promise((resolve) => {
+      if (typeof requestIdleCallback === "function") {
+        requestIdleCallback(resolve, { timeout: 50 });
+      } else {
+        setTimeout(resolve, 0);
       }
-    }
-
-    // Start concurrent workers
-    const workers = [];
-    for (let i = 0; i < CONCURRENT_HYDRATION_REQUESTS; i++) {
-      workers.push(worker());
-    }
-    await Promise.all(workers);
-
-    isHydrating = false;
+    });
   }
 
   /**
-   * Load a single definition from the server
+   * Inflate compressed glossary data from the /glossary/compressed endpoint
+   * Processes in chunks to avoid blocking the main thread
    * @private
    */
-  async function loadDefinition(key) {
-    inflightDefinitionRequests[key] = qik.api.get(`/glossary/${key}`);
-
-    try {
-      const { data } = await inflightDefinitionRequests[key];
-
-      // Merge full data into existing index item (mutate in place)
-      const indexItem = indexItemsByKey[key];
-      if (indexItem) {
-        Object.assign(indexItem, data, { populated: true });
-      }
-
-      // Also cache separately for getDefinition()
-      const cached = indexItem || { ...data, populated: true };
-      definitionCache.set(key, cached);
-      qik.dispatch("glossary:definition", { key, data: cached });
-      return cached;
-    } finally {
-      inflightDefinitionRequests[key] = null;
-    }
-  }
-
-  /**
-   * Get a full definition for a specific type.
-   * Returns cached if available, otherwise fetches from server.
-   * If background hydration is in progress, prioritizes this key.
-   * @alias content.getDefinition
-   * @param {String} key The type key (e.g., 'article', 'profile')
-   * @param {Object} options Additional options
-   * @param {Boolean} options.reload Force reload from server
-   * @returns {Promise<Object>} The full type definition
-   * @example
-   * const article = await sdk.content.getDefinition('article');
-   * console.log(article.fields);
-   */
-  service.getDefinition = async function (key, options) {
-    options = options || {};
-
-    // Return cached if available and not forcing reload
-    let cached = definitionCache.get(key);
-    if (cached && !options.reload && !options.refresh) {
-      return cached;
-    }
-
-    // If already loading, wait for it
-    if (inflightDefinitionRequests[key]) {
-      await inflightDefinitionRequests[key];
-      return definitionCache.get(key);
-    }
-
-    // Prioritize: move to front of queue
-    const queueIndex = hydrationQueue.indexOf(key);
-    if (queueIndex > 0) {
-      hydrationQueue.splice(queueIndex, 1);
-      hydrationQueue.unshift(key);
-    }
-
-    // Load it now
-    return loadDefinition(key);
-  };
-
-  /**
-   * Start loading all remaining definitions in the background.
-   * Requires glossary({ index: true }) to be called first.
-   * Uses concurrent requests for faster loading.
-   * @alias content.hydrateInBackground
-   * @example
-   * await sdk.content.glossary({ index: true });
-   * sdk.content.hydrateInBackground();
-   */
-  service.hydrateInBackground = function () {
-    const cached = glossaryIndexCache.get("index");
-    if (!cached) {
-      console.warn(
-        "Call glossary({ index: true }) before hydrateInBackground()",
-      );
-      return;
-    }
-
-    const keys = cached.map((item) => item.key);
-    startBackgroundHydration(keys);
-  };
-
-  /**
-   * Inflate a single value from compressed format
-   * @private
-   */
-  function createInflator(strings, keyMap) {
-    return function inflate(val) {
+  async function inflateGlossary({ _s: strings, _k: keyMap, types }) {
+    function inflate(val) {
       if (typeof val === "string" && val[0] === "~") {
         return strings[parseInt(val.slice(1))];
       }
@@ -218,111 +100,22 @@ export default function (qik) {
         return result;
       }
       return val;
-    };
-  }
+    }
 
-  /**
-   * Create a lazy-inflating array that only inflates items when accessed
-   * This avoids the upfront cost of inflating the entire glossary
-   * @private
-   */
-  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);
-            }
-          };
-        }
+    const CHUNK_SIZE = 50;
+    const 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];
-        }
+    for (let i = 0; i < types.length; i += CHUNK_SIZE) {
+      const chunk = types.slice(i, i + CHUNK_SIZE);
+      results.push(...chunk.map(inflate));
 
-        // Pass through other properties
-        return Reflect.get(target, prop);
-      },
-    });
-  }
+      // Yield to main thread between chunks
+      if (i + CHUNK_SIZE < types.length) {
+        await yieldToMain();
+      }
+    }
 
-  /**
-   * Process compressed glossary data
-   * Uses lazy inflation to avoid blocking the main thread
-   * @private
-   */
-  function inflateGlossary(data) {
-    return createLazyGlossary(data);
+    return results;
   }
 
   /**
@@ -336,62 +129,15 @@ export default function (qik) {
      * @param  {Boolean} options.reload Force glossary to reload and not be cached.
       If false will retrieve content type data from the in memory cache
      * @param  {Boolean} options.uncompressed Use the uncompressed endpoint
-     * @param  {Boolean} options.index Use lightweight index mode with background hydration
      * @example
      *
      * const { article, profile } = await sdk.content.glossary({hash:true});
      * // Use compressed endpoint for faster loading
      * const glossary = await sdk.content.glossary({compressed:true});
-     * // Use lightweight index with background hydration
-     * const glossary = await sdk.content.glossary({index:true, hash:true});
      */
   service.glossary = async function (options) {
     options = options || {};
 
-    // Index mode: lightweight load with background hydration
-    if (options.index) {
-      let cached = glossaryIndexCache.get("index");
-      const reload = options.reload || options.refresh || !cached;
-
-      if (reload) {
-        if (!inflightGlossaryIndexRequest) {
-          inflightGlossaryIndexRequest = qik.api.get("/glossary/index");
-          inflightGlossaryIndexRequest.then(
-            () => {
-              inflightGlossaryIndexRequest = null;
-            },
-            () => {
-              inflightGlossaryIndexRequest = null;
-            },
-          );
-        }
-
-        const { data } = await inflightGlossaryIndexRequest;
-
-        // Add populated:false to each item and build lookup map
-        data.forEach((item) => {
-          item.populated = false;
-          indexItemsByKey[item.key] = item;
-        });
-
-        glossaryIndexCache.set("index", data);
-        cached = data;
-        qik.dispatch("glossary:index", data);
-        // No auto-hydration - call hydrateInBackground() explicitly if needed
-      }
-
-      if (options.hash) {
-        return qik.utils.hash(cached, "key");
-      }
-
-      if (options.hex) {
-        return qik.utils.hash(cached, "hex");
-      }
-
-      return cached;
-    }
-
-    // Full glossary mode (existing behavior)
     // Check if we already have the glossary cached
     let cached = glossaryCache.get("glossary");
     const uncompressed = !!options.uncompressed;
@@ -416,9 +162,9 @@ export default function (qik) {
       // Now we have the glossary
       const { data } = await inflightGlossaryRequest;
 
-      // Inflate if compressed format (lazy - inflates on access)
+      // 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.213";
+export const version = "0.2.0";