@zcomponent/core 1.27.2 → 1.28.0-beta.1

package/lib/cache.d.ts

@@ -0,0 +1,12 @@
+export interface CacheOptions {
+    key: string;
+    expireMS?: number;
+    revalidateMS?: number;
+    expireError?: number;
+    cacheError?: boolean;
+    lifetime?: 'pageload' | 'session' | 'persistent';
+}
+export interface CachePerformer<T> extends CacheOptions {
+    perform: () => Promise<T>;
+}
+export declare function cache<T>(opts: CachePerformer<T>): Promise<T>;

package/lib/cache.js

@@ -0,0 +1,139 @@
+const dbPromise = new Promise((resolve, reject) => {
+    const db = indexedDB.open('zee-cache-db');
+    db.onupgradeneeded = event => {
+        if (!event || !event.target)
+            return;
+        const db = event.target.result;
+        db.createObjectStore('zee-cache', { keyPath: 'key' });
+    };
+    db.onsuccess = event => {
+        if (!event || !event.target)
+            return;
+        const idb = event.target.result;
+        resolve(idb);
+        clearExpired();
+    };
+    db.onerror = event => {
+        reject(event);
+    };
+});
+const pageLoadByKey = new Map();
+const inflight = new Map();
+function isError(result) {
+    return typeof result['err'] === 'string';
+}
+export async function cache(opts) {
+    const lifetime = opts.lifetime ?? 'pageload';
+    const now = Date.now();
+    let entry;
+    if (lifetime === 'pageload') {
+        entry = pageLoadByKey.get(opts.key);
+        if (entry && entry.expireTime && entry.expireTime < now) {
+            pageLoadByKey.delete(opts.key);
+            entry = undefined;
+        }
+    }
+    else {
+        if (lifetime === 'persistent' || window.sessionStorage.getItem(opts.key) === '1') {
+            entry = await getItemFromDB(opts.key);
+            if (entry && entry.expireTime && entry.expireTime < now) {
+                // Will be deleted next open
+                entry = undefined;
+            }
+        }
+    }
+    const revalidate = entry && opts.revalidateMS && entry.startTime && now - entry.startTime > opts.revalidateMS;
+    const revalidateEntry = revalidate ? entry : undefined;
+    if (!entry) {
+        entry = await inflight.get(opts.key);
+    }
+    if (!entry || revalidate) {
+        const promise = (async () => {
+            let ret;
+            try {
+                const res = await opts.perform();
+                ret = {
+                    key: opts.key,
+                    expireTime: opts.expireMS ? Date.now() + opts.expireMS : undefined,
+                    startTime: now,
+                    result: { val: res },
+                };
+            }
+            catch (err) {
+                if (!opts.cacheError)
+                    throw err;
+                ret = {
+                    key: opts.key,
+                    expireTime: opts.expireError ? Date.now() + opts.expireError : undefined,
+                    startTime: now,
+                    result: { err: err instanceof Error ? err.message : typeof err === 'string' ? err : 'Unknown error' },
+                };
+            }
+            if (lifetime === 'pageload') {
+                pageLoadByKey.set(opts.key, ret);
+            }
+            else {
+                await addItemToDB(ret);
+                if (lifetime === 'session')
+                    window.sessionStorage.setItem(opts.key, '1');
+            }
+            return ret;
+        })();
+        inflight.set(opts.key, promise);
+        promise
+            .then(() => {
+            inflight.delete(opts.key);
+        })
+            .catch(() => {
+            inflight.delete(opts.key);
+        });
+        if (!revalidate)
+            entry = await promise;
+        else
+            entry = revalidateEntry;
+    }
+    if (!entry)
+        throw new Error('No value');
+    if (isError(entry.result))
+        throw new Error(entry.result.err);
+    return entry.result.val;
+}
+function handleRequest(r) {
+    return new Promise((resolve, reject) => {
+        r.onsuccess = () => {
+            resolve(r.result);
+        };
+        r.onerror = event => {
+            reject(event);
+        };
+    });
+}
+async function clearExpired() {
+    const db = await dbPromise;
+    const os = db.transaction('zee-cache', 'readonly').objectStore('zee-cache');
+    const objects = (await handleRequest(os.getAll()));
+    const toDelete = new Set();
+    const now = Date.now();
+    for (const obj of objects) {
+        if (obj.expireTime && obj.expireTime < now) {
+            toDelete.add(obj.key);
+        }
+    }
+    if (toDelete.size > 0) {
+        const os = db.transaction('zee-cache', 'readwrite').objectStore('zee-cache');
+        for (const key of toDelete) {
+            os.delete(key);
+        }
+        os.transaction.commit();
+    }
+}
+async function addItemToDB(e) {
+    const db = await dbPromise;
+    const os = db.transaction('zee-cache', 'readwrite').objectStore('zee-cache');
+    await handleRequest(os.put(e));
+}
+async function getItemFromDB(key) {
+    const db = await dbPromise;
+    const os = db.transaction('zee-cache', 'readonly').objectStore('zee-cache');
+    return await handleRequest(os.get(key));
+}

package/lib/contexts/textalertcontext.d.ts

@@ -41,6 +41,10 @@ export interface TextAlertOptions {
      * Text color of the text alert.
      */
     textColor?: string;
+    /**
+     * Delay in milliseconds before showing the text alert.
+     */
+    delay?: number;
 }
 /**
  * Triggers the display of a text alert.

package/lib/contexts/textalertcontext.js

@@ -39,7 +39,7 @@ export class TextAlertContext extends Context {
         const timeout = options?.timeout ?? 3000;
         setTimeout(() => {
             entry.classList.add('zcomponent-textalert-shown');
-        }, 30);
+        }, options?.delay ?? 30);
         if (timeout >= 0) {
             setTimeout(() => {
                 entry.classList.remove('zcomponent-textalert-shown');

package/lib/index.d.ts

@@ -16,3 +16,4 @@ export * from './observable';
 export * from './contexts/environmentcontext';
 export * from './contexts/audiocontextcontext';
 export * from './animation';
+export { cache, CacheOptions, CachePerformer } from './cache';

package/lib/index.js

@@ -16,6 +16,7 @@ export * from './observable';
 export * from './contexts/environmentcontext';
 export * from './contexts/audiocontextcontext';
 export * from './animation';
+export { cache } from './cache';
 const link = document.createElement('link');
 link.setAttribute('rel', 'stylesheet');
 link.setAttribute('href', new URL('../css/zcomponent.css', import.meta.url).toString());

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zcomponent/core",
-  "version": "1.27.2",
+  "version": "1.28.0-beta.1",
   "description": "The core component model and built-in functionality for Mattercraft.",
   "author": "Zappar Limited",
   "license": "Proprietary",