@hkdigital/lib-sveltekit 0.1.70 → 0.1.72

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

@@ -1,19 +1,106 @@
 /**
- * ReponseCache
- * Using in-memory storage
+ * @fileoverview In-memory implementation of response cache.
+ *
+ * This implementation provides a simple in-memory cache for HTTP responses
+ * with the same API as IndexedDbCache. It's useful for tests and environments
+ * where persistent storage isn't needed or available.
+ *
+ * @example
+ * // Create a memory cache
+ * const cache = new MemoryResponseCache();
+ *
+ * // Store a response
+ * const response = await fetch('https://example.com/api/data');
+ * await cache.set('api-data', response, { expiresIn: 3600000 });
+ *
+ * // Retrieve a cached response
+ * const cached = await cache.get('api-data');
+ * if (cached) {
+ *   console.log(cached.response);
+ * }
+ */
+/**
+ * @typedef {Object} CacheEntry
+ * @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
+ */
+/**
+ * In-memory response cache implementation
  */
 export default class MemoryResponseCache {
-    cache: Map<any, any>;
-    get(key: any): Promise<{
-        response: any;
-        metadata: any;
-        url: any;
-        timestamp: any;
-        expires: any;
-        etag: any;
-        lastModified: any;
-    }>;
-    set(key: any, response: any, metadata: any): Promise<void>;
-    delete(key: any): Promise<boolean>;
+    /**
+     * Internal cache storage using Map
+     * @type {Map<string, Object>}
+     */
+    cache: Map<string, any>;
+    /**
+     * Get a cached response
+     *
+     * @param {string} key - Cache key
+     * @returns {Promise<CacheEntry|null>} Cache entry or null if not found/expired
+     */
+    get(key: string): Promise<CacheEntry | null>;
+    /**
+     * 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>}
+     */
+    set(key: string, response: Response, metadata?: any): Promise<void>;
+    /**
+     * Delete a cached entry
+     *
+     * @param {string} key - Cache key
+     * @returns {Promise<boolean>} True if entry was deleted
+     */
+    delete(key: string): Promise<boolean>;
+    /**
+     * Clear all cached responses
+     *
+     * @returns {Promise<void>}
+     */
     clear(): Promise<void>;
+    /**
+     * Close the cache (no-op for memory cache, for API compatibility)
+     *
+     * @returns {Promise<void>}
+     */
+    close(): Promise<void>;
 }
+export type CacheEntry = {
+    /**
+     * - Cached Response object
+     */
+    response: Response;
+    /**
+     * - Cache entry metadata
+     */
+    metadata: any;
+    /**
+     * - Original URL
+     */
+    url: string;
+    /**
+     * - When the entry was cached
+     */
+    timestamp: number;
+    /**
+     * - Expiration timestamp (null if no expiration)
+     */
+    expires: number | null;
+    /**
+     * - ETag header if present
+     */
+    etag: string | null;
+    /**
+     * - Last-Modified header if present
+     */
+    lastModified: string | null;
+};

package/dist/classes/cache/MemoryResponseCache.js

@@ -1,25 +1,73 @@
 /**
- * ReponseCache
- * Using in-memory storage
+ * @fileoverview In-memory implementation of response cache.
+ *
+ * This implementation provides a simple in-memory cache for HTTP responses
+ * with the same API as IndexedDbCache. It's useful for tests and environments
+ * where persistent storage isn't needed or available.
+ *
+ * @example
+ * // Create a memory cache
+ * const cache = new MemoryResponseCache();
+ *
+ * // Store a response
+ * const response = await fetch('https://example.com/api/data');
+ * await cache.set('api-data', response, { expiresIn: 3600000 });
+ *
+ * // Retrieve a cached response
+ * const cached = await cache.get('api-data');
+ * if (cached) {
+ *   console.log(cached.response);
+ * }
+ */
+
+/**
+ * @typedef {Object} CacheEntry
+ * @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
+ */
+
+/**
+ * In-memory response cache implementation
  */
 export default class MemoryResponseCache {
+  /**
+   * Create a new in-memory cache
+   */
   constructor() {
+    /**
+     * Internal cache storage using Map
+     * @type {Map<string, Object>}
+     */
     this.cache = new Map();
   }
-  
+
+  /**
+   * Get a cached response
+   *
+   * @param {string} key - Cache key
+   * @returns {Promise<CacheEntry|null>} Cache entry or null if not found/expired
+   */
   async get(key) {
     const entry = this.cache.get(key);
-    
+
     if (!entry) {
       return null;
     }
-    
+
     // Check if expired
     if (entry.expires && Date.now() > entry.expires) {
       this.delete(key);
       return null;
     }
-    
+
+    // Update last accessed time
+    entry.lastAccessed = Date.now();
+
     return {
       response: entry.response.clone(),
       metadata: entry.metadata,
@@ -30,24 +78,61 @@ export default class MemoryResponseCache {
       lastModified: entry.lastModified
     };
   }
-  
-  async set(key, response, metadata) {
+
+  /**
+   * 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 now = Date.now();
+
+    // Calculate expiration time if expiresIn is provided
+    let expires = metadata.expires || null;
+    if (!expires && metadata.expiresIn) {
+      expires = now + metadata.expiresIn;
+    }
+
     this.cache.set(key, {
       response: response.clone(),
       metadata,
       url: response.url,
-      timestamp: Date.now(),
-      expires: metadata.expires || null,
+      timestamp: now,
+      lastAccessed: now,
+      expires,
       etag: response.headers.get('ETag'),
       lastModified: response.headers.get('Last-Modified')
     });
   }
-  
+
+  /**
+   * Delete a cached entry
+   *
+   * @param {string} key - Cache key
+   * @returns {Promise<boolean>} True if entry was deleted
+   */
   async delete(key) {
     return this.cache.delete(key);
   }
-  
+
+  /**
+   * Clear all cached responses
+   *
+   * @returns {Promise<void>}
+   */
   async clear() {
     this.cache.clear();
   }
+
+  /**
+   * Close the cache (no-op for memory cache, for API compatibility)
+   *
+   * @returns {Promise<void>}
+   */
+  async close() {
+    // No-op for memory cache
+  }
 }

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

@@ -1,3 +1,3 @@
 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/index.js

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

package/dist/classes/events/EventEmitter.d.ts

@@ -0,0 +1,142 @@
+/**
+ * @fileoverview Simple event emitter implementation to support event-based architecture
+ * in service management and other parts of the application.
+ *
+ * This implementation provides standard event publishing and subscription methods
+ * with support for namespaced events, wildcard listeners, and callback removal.
+ *
+ * @example
+ * // Basic usage
+ * import { EventEmitter } from './EventEmitter.js';
+ *
+ * // Create an emitter
+ * const events = new EventEmitter();
+ *
+ * // Subscribe to events
+ * const unsubscribe = events.on('data-loaded', (data) => {
+ *   console.log('Data loaded:', data);
+ * });
+ *
+ * // Subscribe to all events with a specific prefix
+ * events.on('database:*', ({ event, data }) => {
+ *   console.log(`Database event ${event}:`, data);
+ * });
+ *
+ * // Emit events
+ * events.emit('data-loaded', { items: [1, 2, 3] });
+ * events.emit('database:connected', { connectionId: 'abc123' });
+ *
+ * // Clean up when done
+ * unsubscribe();
+ *
+ * // Or remove all listeners
+ * events.removeAllListeners();
+ */
+/**
+ * EventEmitter class for event-based programming
+ */
+export default class EventEmitter {
+    /**
+     * Map to store event handlers
+     * @type {Map<string, Set<Function>>}
+     * @private
+     */
+    private eventHandlers;
+    /**
+     * Map to store wildcard event handlers (events ending with *)
+     * @type {Map<string, Set<Function>>}
+     * @private
+     */
+    private wildcardHandlers;
+    /**
+     * Register an event handler
+     *
+     * @param {string} eventName - Event name to listen for. Can use wildcard (*)
+     *        at the end to listen to all events with a specific prefix.
+     * @param {Function} handler - Handler function to call when event is emitted
+     * @returns {Function} Function to remove this specific handler
+     *
+     * @example
+     * // Listen for a specific event
+     * emitter.on('userLoggedIn', (user) => {
+     *   console.log(`User logged in: ${user.name}`);
+     * });
+     *
+     * // Listen for all events with a prefix
+     * emitter.on('api:*', ({ event, data }) => {
+     *   console.log(`API event ${event}:`, data);
+     * });
+     */
+    on(eventName: string, handler: Function): Function;
+    /**
+     * Register a one-time event handler that will be removed after first execution
+     *
+     * @param {string} eventName - Event name to listen for
+     * @param {Function} handler - Handler function to call when event is emitted
+     * @returns {Function} Function to remove this specific handler
+     *
+     * @example
+     * emitter.once('initialization', () => {
+     *   console.log('Initialization happened');
+     * });
+     */
+    once(eventName: string, handler: Function): Function;
+    /**
+     * Remove an event handler
+     *
+     * @param {string} eventName - Event name the handler was registered for
+     * @param {Function} handler - Handler function to remove
+     * @returns {boolean} True if the handler was removed, false otherwise
+     *
+     * @example
+     * const handler = (data) => console.log(data);
+     * emitter.on('data', handler);
+     * emitter.off('data', handler);
+     */
+    off(eventName: string, handler: Function): boolean;
+    /**
+     * Remove all event handlers for a specific event
+     *
+     * @param {string} [eventName] - Event name to remove handlers for.
+     *        If not provided, removes all handlers for all events.
+     *
+     * @example
+     * // Remove all 'data' event handlers
+     * emitter.removeAllListeners('data');
+     *
+     * // Remove all event handlers
+     * emitter.removeAllListeners();
+     */
+    removeAllListeners(eventName?: string): void;
+    /**
+     * Emit an event
+     *
+     * @param {string} eventName - Name of the event to emit
+     * @param {*} data - Data to pass to event handlers
+     * @returns {boolean} True if there were handlers for this event, false otherwise
+     *
+     * @example
+     * emitter.emit('dataLoaded', { users: [...] });
+     */
+    emit(eventName: string, data: any): boolean;
+    /**
+     * Get the number of listeners for a specific event
+     *
+     * @param {string} eventName - Event name to count listeners for
+     * @returns {number} Number of listeners for this event
+     *
+     * @example
+     * const count = emitter.listenerCount('data');
+     * console.log(`There are ${count} data event listeners`);
+     */
+    listenerCount(eventName: string): number;
+    /**
+     * Get all registered event names
+     *
+     * @returns {string[]} Array of event names that have listeners
+     *
+     * @example
+     * console.log('Events with listeners:', emitter.eventNames());
+     */
+    eventNames(): string[];
+}

package/dist/classes/events/EventEmitter.js

@@ -0,0 +1,275 @@
+/**
+ * @fileoverview Simple event emitter implementation to support event-based architecture
+ * in service management and other parts of the application. 
+ * 
+ * This implementation provides standard event publishing and subscription methods
+ * with support for namespaced events, wildcard listeners, and callback removal.
+ *
+ * @example
+ * // Basic usage
+ * import { EventEmitter } from './EventEmitter.js';
+ * 
+ * // Create an emitter
+ * const events = new EventEmitter();
+ * 
+ * // Subscribe to events
+ * const unsubscribe = events.on('data-loaded', (data) => {
+ *   console.log('Data loaded:', data);
+ * });
+ * 
+ * // Subscribe to all events with a specific prefix
+ * events.on('database:*', ({ event, data }) => {
+ *   console.log(`Database event ${event}:`, data);
+ * });
+ * 
+ * // Emit events
+ * events.emit('data-loaded', { items: [1, 2, 3] });
+ * events.emit('database:connected', { connectionId: 'abc123' });
+ * 
+ * // Clean up when done
+ * unsubscribe();
+ * 
+ * // Or remove all listeners
+ * events.removeAllListeners();
+ */
+
+/**
+ * EventEmitter class for event-based programming
+ */
+export default class EventEmitter {
+  /**
+   * Create a new EventEmitter instance
+   */
+  constructor() {
+    /**
+     * Map to store event handlers
+     * @type {Map<string, Set<Function>>}
+     * @private
+     */
+    this.eventHandlers = new Map();
+    
+    /**
+     * Map to store wildcard event handlers (events ending with *)
+     * @type {Map<string, Set<Function>>}
+     * @private
+     */
+    this.wildcardHandlers = new Map();
+  }
+  
+  /**
+   * Register an event handler
+   * 
+   * @param {string} eventName - Event name to listen for. Can use wildcard (*)
+   *        at the end to listen to all events with a specific prefix.
+   * @param {Function} handler - Handler function to call when event is emitted
+   * @returns {Function} Function to remove this specific handler
+   * 
+   * @example
+   * // Listen for a specific event
+   * emitter.on('userLoggedIn', (user) => {
+   *   console.log(`User logged in: ${user.name}`);
+   * });
+   * 
+   * // Listen for all events with a prefix
+   * emitter.on('api:*', ({ event, data }) => {
+   *   console.log(`API event ${event}:`, data);
+   * });
+   */
+  on(eventName, handler) {
+    if (typeof handler !== 'function') {
+      throw new TypeError('Event handler must be a function');
+    }
+    
+    // Handle wildcard listeners
+    if (eventName.endsWith('*')) {
+      const prefix = eventName.slice(0, -1);
+      
+      if (!this.wildcardHandlers.has(prefix)) {
+        this.wildcardHandlers.set(prefix, new Set());
+      }
+      
+      this.wildcardHandlers.get(prefix).add(handler);
+      
+      return () => this.off(eventName, handler);
+    }
+    
+    // Handle normal listeners
+    if (!this.eventHandlers.has(eventName)) {
+      this.eventHandlers.set(eventName, new Set());
+    }
+    
+    this.eventHandlers.get(eventName).add(handler);
+    
+    return () => this.off(eventName, handler);
+  }
+  
+  /**
+   * Register a one-time event handler that will be removed after first execution
+   * 
+   * @param {string} eventName - Event name to listen for
+   * @param {Function} handler - Handler function to call when event is emitted
+   * @returns {Function} Function to remove this specific handler
+   * 
+   * @example
+   * emitter.once('initialization', () => {
+   *   console.log('Initialization happened');
+   * });
+   */
+  once(eventName, handler) {
+    if (typeof handler !== 'function') {
+      throw new TypeError('Event handler must be a function');
+    }
+    
+    const wrapper = (...args) => {
+      this.off(eventName, wrapper);
+      handler(...args);
+    };
+    
+    return this.on(eventName, wrapper);
+  }
+  
+  /**
+   * Remove an event handler
+   * 
+   * @param {string} eventName - Event name the handler was registered for
+   * @param {Function} handler - Handler function to remove
+   * @returns {boolean} True if the handler was removed, false otherwise
+   * 
+   * @example
+   * const handler = (data) => console.log(data);
+   * emitter.on('data', handler);
+   * emitter.off('data', handler);
+   */
+  off(eventName, handler) {
+    // Handle wildcard listeners
+    if (eventName.endsWith('*')) {
+      const prefix = eventName.slice(0, -1);
+      const handlers = this.wildcardHandlers.get(prefix);
+      
+      if (handlers) {
+        return handlers.delete(handler);
+      }
+      
+      return false;
+    }
+    
+    // Handle normal listeners
+    const handlers = this.eventHandlers.get(eventName);
+    
+    if (handlers) {
+      return handlers.delete(handler);
+    }
+    
+    return false;
+  }
+  
+  /**
+   * Remove all event handlers for a specific event
+   * 
+   * @param {string} [eventName] - Event name to remove handlers for.
+   *        If not provided, removes all handlers for all events.
+   * 
+   * @example
+   * // Remove all 'data' event handlers
+   * emitter.removeAllListeners('data');
+   * 
+   * // Remove all event handlers
+   * emitter.removeAllListeners();
+   */
+  removeAllListeners(eventName) {
+    if (eventName) {
+      // Handle wildcard listeners
+      if (eventName.endsWith('*')) {
+        const prefix = eventName.slice(0, -1);
+        this.wildcardHandlers.delete(prefix);
+      } else {
+        this.eventHandlers.delete(eventName);
+      }
+    } else {
+      // Clear all handlers
+      this.eventHandlers.clear();
+      this.wildcardHandlers.clear();
+    }
+  }
+  
+  /**
+   * Emit an event
+   * 
+   * @param {string} eventName - Name of the event to emit
+   * @param {*} data - Data to pass to event handlers
+   * @returns {boolean} True if there were handlers for this event, false otherwise
+   * 
+   * @example
+   * emitter.emit('dataLoaded', { users: [...] });
+   */
+  emit(eventName, data) {
+    let handled = false;
+    
+    // Call specific event handlers
+    const handlers = this.eventHandlers.get(eventName);
+    if (handlers && handlers.size > 0) {
+      handlers.forEach(handler => handler(data));
+      handled = true;
+    }
+    
+    // Call matching wildcard handlers
+    this.wildcardHandlers.forEach((handlers, prefix) => {
+      if (eventName.startsWith(prefix)) {
+        handlers.forEach(handler => 
+          handler({ event: eventName, data })
+        );
+        handled = true;
+      }
+    });
+    
+    return handled;
+  }
+  
+  /**
+   * Get the number of listeners for a specific event
+   * 
+   * @param {string} eventName - Event name to count listeners for
+   * @returns {number} Number of listeners for this event
+   * 
+   * @example
+   * const count = emitter.listenerCount('data');
+   * console.log(`There are ${count} data event listeners`);
+   */
+  listenerCount(eventName) {
+    let count = 0;
+    
+    // Count specific event handlers
+    const handlers = this.eventHandlers.get(eventName);
+    if (handlers) {
+      count += handlers.size;
+    }
+    
+    // Count matching wildcard handlers
+    this.wildcardHandlers.forEach((handlers, prefix) => {
+      if (eventName.startsWith(prefix)) {
+        count += handlers.size;
+      }
+    });
+    
+    return count;
+  }
+  
+  /**
+   * Get all registered event names
+   * 
+   * @returns {string[]} Array of event names that have listeners
+   * 
+   * @example
+   * console.log('Events with listeners:', emitter.eventNames());
+   */
+  eventNames() {
+    const events = [...this.eventHandlers.keys()];
+    
+    // Add wildcard events
+    this.wildcardHandlers.forEach((_, prefix) => {
+      events.push(`${prefix}*`);
+    });
+    
+    return events;
+  }
+}

package/dist/classes/events/index.d.ts

@@ -0,0 +1 @@
+export { default as EventEmitter } from "./EventEmitter.js";

package/dist/classes/events/index.js

@@ -0,0 +1,2 @@
+
+export { default as EventEmitter } from './EventEmitter.js';