@hkdigital/lib-sveltekit 0.1.73 → 0.1.75

package/dist/classes/cache/index.js

@@ -1,6 +1,5 @@
 
 export { default as MemoryResponseCache } from "./MemoryResponseCache.js";
-// export { default as PersistentResponseCache } from "./PersistentResponseCache.js";
 export { default as IndexedDbCache } from "./IndexedDbCache.js";
 
 export * from './typedef.js';

package/dist/classes/cache/typedef.d.ts

@@ -2,33 +2,34 @@ declare const _default: {};
 export default _default;
 export type CacheEntry = {
     /**
-     * The cached response
+     * - Cached Response object
      */
     response: Response;
     /**
-     * Cache metadata including expiration
+     * - Cache entry metadata
      */
     metadata: any;
     /**
-     * The request URL
+     * - Original URL
      */
     url: string;
     /**
-     * When the entry was cached
+     * - When the entry was cached
      */
     timestamp: number;
     /**
-     * When the entry expires
+     * - Expiration timestamp (null if no expiration)
      */
     expires: number | null;
     /**
-     * ETag for conditional requests
+     * - ETag header if present
      */
     etag: string | null;
     /**
-     * Last-Modified for conditional requests
+     * - Last-Modified header if present
      */
     lastModified: string | null;
+    cacheVersion: string | null;
 };
 export type CacheStorage = {
     /**
@@ -48,3 +49,19 @@ export type CacheStorage = {
      */
     clear: () => Promise<void>;
 };
+export type IDBRequestEvent = {
+    /**
+     * - The request that generated the event
+     */
+    target: IDBRequest;
+};
+export type IDBVersionChangeEvent = {
+    /**
+     * - The request that generated the event
+     */
+    target: IDBOpenDBRequest;
+    /**
+     * - The transaction for database upgrade
+     */
+    transaction?: IDBTransaction;
+};

package/dist/classes/cache/typedef.js

@@ -1,13 +1,14 @@
 
 /**
  * @typedef {Object} CacheEntry
- * @property {Response} response The cached response
- * @property {Object} metadata Cache metadata including expiration
- * @property {string} url The request URL
- * @property {number} timestamp When the entry was cached
- * @property {number|null} expires When the entry expires
- * @property {string|null} etag ETag for conditional requests
- * @property {string|null} lastModified Last-Modified for conditional requests
+ * @property {Response} response - Cached Response object
+ * @property {Object} metadata - Cache entry metadata
+ * @property {string} url - Original URL
+ * @property {number} timestamp - When the entry was cached
+ * @property {number|null} expires - Expiration timestamp (null if no expiration)
+ * @property {string|null} etag - ETag header if present
+ * @property {string|null} lastModified - Last-Modified header if present
+ * @property {string|null} cacheVersion
  */
 
 /**
@@ -22,4 +23,19 @@
  *   Clear all cached responses
  */
 
+// > IndexedDB
+
+/**
+ * @typedef {Object} IDBRequestEvent
+ * @property {IDBRequest} target - The request that generated the event
+ */
+
+/**
+ * @typedef {Object} IDBVersionChangeEvent
+ * @property {IDBOpenDBRequest} target - The request that generated the event
+ * @property {IDBTransaction} [target.transaction] - The transaction for database upgrade
+ */
+
+// > Export default
+
 export default {};

package/dist/widgets/presenter/Presenter.state.svelte.js

@@ -289,7 +289,9 @@ export class PresenterState {
     }
 
     if (slide.name === this.currentSlideName) {
-      throw new Error(`gotoSlide cannot transition to current slide`);
+      //throw new Error(`gotoSlide cannot transition to current slide`);
+      console.error(`gotoSlide cannot transition to current slide`);
+      return;
     }
 
     this.nextSlideName = slide.name;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@hkdigital/lib-sveltekit",
-	"version": "0.1.73",
+	"version": "0.1.75",
 	"author": {
 		"name": "HKdigital",
 		"url": "https://hkdigital.nl"

package/dist/classes/cache/CacheStorage.js__

@@ -1,45 +0,0 @@
-/**
- * @typedef {Object} CacheEntry
- * @property {Response} response The cached response
- * @property {Object} metadata Cache metadata including expiration
- * @property {string} url The request URL
- * @property {number} timestamp When the entry was cached
- * @property {number|null} expires When the entry expires
- * @property {string|null} etag ETag for conditional requests
- * @property {string|null} lastModified Last-Modified for conditional requests
- */
-
-/**
- * Cache Storage Interface
- * @interface
- */
-class CacheStorage {
-  /**
-   * Get a cached response for a key
-   * @param {string} key Cache key
-   * @returns {Promise<CacheEntry|null>} Cached response or null if not found
-   */
-  async get(key) { throw new Error('Not implemented'); }
-  
-  /**
-   * Store a response in the cache
-   * @param {string} key Cache key
-   * @param {Response} response Response to cache
-   * @param {Object} metadata Cache metadata
-   * @returns {Promise<void>}
-   */
-  async set(key, response, metadata) { throw new Error('Not implemented'); }
-  
-  /**
-   * Remove a cached response
-   * @param {string} key Cache key
-   * @returns {Promise<boolean>} True if entry was removed
-   */
-  async delete(key) { throw new Error('Not implemented'); }
-  
-  /**
-   * Clear all cached responses
-   * @returns {Promise<void>}
-   */
-  async clear() { throw new Error('Not implemented'); }
-}

package/dist/classes/cache/PersistentResponseCache.js__

@@ -1,165 +0,0 @@
-
-
-/**
- * ReponseCache
- * Using IndexedDB for persistent storage
- */
-export default class ResponseCache {
-  /**
-   * Create a new IndexedDB cache storage
-   * @param {string} dbName Database name
-   * @param {string} storeName Store name
-   */
-  constructor(dbName = 'http-cache', storeName = 'responses') {
-    this.dbName = dbName;
-    this.storeName = storeName;
-    this.dbPromise = this._openDatabase();
-  }
-  
-  /**
-   * Open the IndexedDB database
-   * @private
-   * @returns {Promise<IDBDatabase>}
-   */
-  async _openDatabase() {
-    return new Promise((resolve, reject) => {
-      const request = indexedDB.open(this.dbName, 1);
-      
-      request.onerror = () => reject(request.error);
-      request.onsuccess = () => resolve(request.result);
-      
-      request.onupgradeneeded = (event) => {
-        const db = event.target.result;
-        if (!db.objectStoreNames.contains(this.storeName)) {
-          db.createObjectStore(this.storeName, { keyPath: 'key' });
-        }
-      };
-    });
-  }
-  
-  /**
-   * Get a cached response
-   * @param {string} key Cache key
-   * @returns {Promise<import('./typedef').CacheEntry|null>}
-   */
-  async get(key) {
-    const db = await this.dbPromise;
-    
-    return new Promise((resolve, reject) => {
-      const transaction = db.transaction(this.storeName, 'readonly');
-      const store = transaction.objectStore(this.storeName);
-      const request = store.get(key);
-      
-      request.onerror = () => reject(request.error);
-      request.onsuccess = () => {
-        const entry = request.result;
-        
-        if (!entry) {
-          resolve(null);
-          return;
-        }
-        
-        // Check if expired
-        if (entry.expires && Date.now() > entry.expires) {
-          // Delete expired entry
-          this.delete(key).catch(console.error);
-          resolve(null);
-          return;
-        }
-        
-        // Deserialize the response
-        const response = new Response(entry.body, {
-          status: entry.status,
-          statusText: entry.statusText,
-          headers: new Headers(entry.headers)
-        });
-        
-        resolve({
-          response,
-          metadata: entry.metadata,
-          url: entry.url,
-          timestamp: entry.timestamp,
-          expires: entry.expires,
-          etag: entry.etag,
-          lastModified: entry.lastModified
-        });
-      };
-    });
-  }
-  
-  /**
-   * Store a response in the cache
-   * @param {string} key Cache key
-   * @param {Response} response Response to cache
-   * @param {Object} metadata Cache metadata
-   * @returns {Promise<void>}
-   */
-  async set(key, response, metadata) {
-    const db = await this.dbPromise;
-    
-    // Clone the response to avoid consuming it
-    const clonedResponse = response.clone();
-    
-    // Extract response data
-    const body = await clonedResponse.blob();
-    const headers = Array.from(clonedResponse.headers.entries());
-    
-    const entry = {
-      key,
-      url: clonedResponse.url,
-      status: clonedResponse.status,
-      statusText: clonedResponse.statusText,
-      headers,
-      body,
-      metadata,
-      timestamp: Date.now(),
-      expires: metadata.expires || null,
-      etag: clonedResponse.headers.get('ETag'),
-      lastModified: clonedResponse.headers.get('Last-Modified')
-    };
-    
-    return new Promise((resolve, reject) => {
-      const transaction = db.transaction(this.storeName, 'readwrite');
-      const store = transaction.objectStore(this.storeName);
-      const request = store.put(entry);
-      
-      request.onerror = () => reject(request.error);
-      request.onsuccess = () => resolve();
-    });
-  }
-  
-  /**
-   * Delete a cached response
-   * @param {string} key Cache key
-   * @returns {Promise<boolean>}
-   */
-  async delete(key) {
-    const db = await this.dbPromise;
-    
-    return new Promise((resolve, reject) => {
-      const transaction = db.transaction(this.storeName, 'readwrite');
-      const store = transaction.objectStore(this.storeName);
-      const request = store.delete(key);
-      
-      request.onerror = () => reject(request.error);
-      request.onsuccess = () => resolve(true);
-    });
-  }
-  
-  /**
-   * Clear all cached responses
-   * @returns {Promise<void>}
-   */
-  async clear() {
-    const db = await this.dbPromise;
-    
-    return new Promise((resolve, reject) => {
-      const transaction = db.transaction(this.storeName, 'readwrite');
-      const store = transaction.objectStore(this.storeName);
-      const request = store.clear();
-      
-      request.onerror = () => reject(request.error);
-      request.onsuccess = () => resolve();
-    });
-  }
-}