@hkdigital/lib-sveltekit 0.1.74 → 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/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.74",
+	"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();
-    });
-  }
-}