@qikdev/sdk 0.1.214 → 0.2.2

package/package.json

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

package/src/api/qik.content.js

@@ -64,167 +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 = {};
 
   /**
-   * Load the lightweight glossary index.
-   * Returns cached version unless reload is specified.
-   * @alias content.loadGlossaryIndex
-   * @param {Object} options Additional options
-   * @param {Boolean} options.hash Return as object keyed by type key
-   * @param {Boolean} options.hex Return as object keyed by hex
-   * @param {Boolean} options.reload Force reload from server
-   * @returns {Promise<Array|Object>} The glossary index
-   * @example
-   * const index = await sdk.content.loadGlossaryIndex();
-   * const indexHash = await sdk.content.loadGlossaryIndex({ hash: true });
-   */
-  service.loadGlossaryIndex = async function (options) {
-    options = options || {};
-
-    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;
-      glossaryIndexCache.set("index", data);
-      cached = data;
-      qik.dispatch("glossary:index", data);
-    }
-
-    if (options.hash) {
-      return qik.utils.hash(cached, "key");
-    }
-
-    if (options.hex) {
-      return qik.utils.hash(cached, "hex");
-    }
-
-    return cached;
-  };
-
-  /**
-   * Get a full definition for a specific type.
-   * Returns cached if available, otherwise fetches from server.
-   * Multiple simultaneous calls for the same key share one request.
-   * @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 (request deduplication)
-    if (inflightDefinitionRequests[key]) {
-      await inflightDefinitionRequests[key];
-      return definitionCache.get(key);
-    }
-
-    // Make the request
-    inflightDefinitionRequests[key] = qik.api.get(`/glossary/index/${key}`);
-
-    try {
-      const { data } = await inflightDefinitionRequests[key];
-      definitionCache.set(key, data);
-      qik.dispatch("glossary:definition", { key, data });
-      return data;
-    } finally {
-      inflightDefinitionRequests[key] = null;
-    }
-  };
-
-  let inflightTypeRequests = {};
-  let typeResultsCache = {};
-
-  /**
-   * Load all definitions that match or extend a given type.
-   * For example, loadDefinitionsForType('submission') returns all form definitions.
-   * Results are cached individually - subsequent getDefinition() calls return from cache.
-   * @alias content.loadDefinitionsForType
-   * @param {String} type The base type key (e.g., 'submission', 'workflowcard', 'article')
-   * @param {Object} options Additional options
-   * @param {Boolean} options.hash Return as object keyed by definition key
-   * @param {Boolean} options.reload Force reload from server
-   * @returns {Promise<Array|Object>} Array of definitions, or hash if options.hash
-   * @example
-   * const submissions = await sdk.content.loadDefinitionsForType('submission');
-   * const workflowCards = await sdk.content.loadDefinitionsForType('workflowcard', { hash: true });
+   * Yield to the event loop to keep the UI responsive
+   * @private
    */
-  service.loadDefinitionsForType = async function (type, options) {
-    options = options || {};
-
-    // Return cached if available and not forcing reload
-    if (typeResultsCache[type] && !options.reload && !options.refresh) {
-      const data = typeResultsCache[type];
-      return options.hash ? qik.utils.hash(data, "key") : data;
-    }
-
-    // If already loading this type, wait for it
-    if (inflightTypeRequests[type]) {
-      await inflightTypeRequests[type];
-      const data = typeResultsCache[type];
-      return options.hash ? qik.utils.hash(data, "key") : data;
-    }
-
-    // Make the request
-    inflightTypeRequests[type] = qik.api.get(`/glossary/index/${type}/all`);
-
-    try {
-      const { data } = await inflightTypeRequests[type];
-
-      // Cache the type results for subsequent calls
-      typeResultsCache[type] = data;
-
-      // Cache each definition individually in the unified cache
-      data.forEach((definition) => {
-        definitionCache.set(definition.key, definition);
-      });
-
-      qik.dispatch("glossary:type", { type, definitions: data });
-
-      if (options.hash) {
-        return qik.utils.hash(data, "key");
+  function yieldToMain() {
+    return new Promise((resolve) => {
+      if (typeof requestIdleCallback === "function") {
+        requestIdleCallback(resolve, { timeout: 50 });
+      } else {
+        setTimeout(resolve, 0);
       }
-      return data;
-    } finally {
-      inflightTypeRequests[type] = null;
-    }
-  };
+    });
+  }
 
   /**
-   * Inflate a single value from compressed format
+   * Inflate compressed glossary data from the /glossary/compressed endpoint
+   * Processes in chunks to avoid blocking the main thread
    * @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))];
       }
@@ -237,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;
   }
 
   /**
@@ -388,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/api/qik.utils.js

@@ -797,8 +797,12 @@ service.mapFields = function (fields, options) {
     mapped.trail.push(fieldKey);
 
     mapped.path = mapped.trail.join(".");
-    mapped.titles = titles.slice();
-    mapped.titles.push(field.filterTitle || field.title || "");
+    if (field.titles && field.titles.length) {
+      mapped.titles = field.titles.slice();
+    } else {
+      mapped.titles = titles.slice();
+      mapped.titles.push(field.filterTitle || field.title || "");
+    }
 
     const isNotLayoutOrIsAllowed = !isLayout || options.includeLayout;
 

package/src/version.js

@@ -1 +1 @@
-export const version = "0.1.214";
+export const version = "0.2.2";