@hkdigital/lib-core 0.3.8 → 0.3.10

package/dist/classes/data/IterableTree.d.ts

@@ -1,10 +1,3 @@
-/**
- * @typedef {object} Options
- * @property {boolean} walkArrays
- * @property {boolean} ignoreEmptyObjectLeaves
- * @property {boolean} expandPathKeys
- * @property {boolean} outputIntermediateNodes
- */
 export default class IterableTree {
     /**
      * Construct an object that can be used to iterate paths and values in
@@ -13,13 +6,10 @@ export default class IterableTree {
      * - Iterates "own properties" only (not inherited properties)
      *
      * @param {object} obj - Object to iterate
-     * @param {Options} [options]
+     * @param {import('./typedef.js').IterableTreeOptions} [options]
      * @param {string[]} [_parentArrPath]
-     *
-     *
-     * @return {Iterator} iterable object
      */
-    constructor(obj: object, options?: Options, _parentArrPath?: string[]);
+    constructor(obj: object, options?: import("./typedef.js").IterableTreeOptions, _parentArrPath?: string[]);
     obj: any;
     _parentArrPath: string[];
     /**
@@ -43,9 +33,3 @@ export default class IterableTree {
     values(): Iterator<any, any, any>;
     #private;
 }
-export type Options = {
-    walkArrays: boolean;
-    ignoreEmptyObjectLeaves: boolean;
-    expandPathKeys: boolean;
-    outputIntermediateNodes: boolean;
-};

package/dist/classes/data/IterableTree.js

@@ -6,20 +6,9 @@ import { PATH_SEPARATOR } from '../../util/object/index.js';
 
 /* ------------------------------------------------------------------ Typedef */
 
-/**
- * @typedef {object} Options
- * @property {boolean} walkArrays
- * @property {boolean} ignoreEmptyObjectLeaves
- * @property {boolean} expandPathKeys
- * @property {boolean} outputIntermediateNodes
- */
-
 /* ------------------------------------------------------------------ Exports */
 
 export default class IterableTree {
-	/**
-	 * @type {Options}
-	 */
 	#options;
 
 	/**
@@ -29,11 +18,8 @@ export default class IterableTree {
 	 * - Iterates "own properties" only (not inherited properties)
 	 *
 	 * @param {object} obj - Object to iterate
-	 * @param {Options} [options]
+	 * @param {import('./typedef.js').IterableTreeOptions} [options]
 	 * @param {string[]} [_parentArrPath]
-	 *
-	 *
-	 * @return {Iterator} iterable object
 	 */
 	constructor(obj, options, _parentArrPath) {
 		//super( ...arguments );
@@ -68,7 +54,7 @@ export default class IterableTree {
 		const obj = this.obj;
 		const parentArrPath = this._parentArrPath;
 
-		const options = this.options;
+		const options = this.#options;
 
 		let { expandPathKeys, ignoreEmptyObjectLeaves, outputIntermediateNodes } = this.#options;
 

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

@@ -0,0 +1,8 @@
+declare const _default: {};
+export default _default;
+export type IterableTreeOptions = {
+    walkArrays: boolean;
+    ignoreEmptyObjectLeaves: boolean;
+    expandPathKeys: boolean;
+    outputIntermediateNodes: boolean;
+};

package/dist/classes/data/typedef.js

@@ -0,0 +1,9 @@
+/**
+ * @typedef {object} IterableTreeOptions
+ * @property {boolean} walkArrays
+ * @property {boolean} ignoreEmptyObjectLeaves
+ * @property {boolean} expandPathKeys
+ * @property {boolean} outputIntermediateNodes
+ */
+
+export default {};

package/dist/classes/event-emitter/EventEmitter.js

@@ -1,34 +1,34 @@
 /**
  * @fileoverview Simple event emitter implementation to support event-based architecture
- * in service management and other parts of the application. 
- * 
+ * 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();
  */
@@ -47,7 +47,7 @@ export default class EventEmitter {
      * @private
      */
     this.eventHandlers = new Map();
-    
+
     /**
      * Map to store wildcard event handlers (events ending with *)
      * @type {Map<string, Set<Function>>}
@@ -55,21 +55,21 @@ export default class EventEmitter {
      */
     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);
@@ -79,37 +79,37 @@ export default class EventEmitter {
     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');
@@ -119,22 +119,22 @@ export default class EventEmitter {
     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);
@@ -145,34 +145,34 @@ export default class EventEmitter {
     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();
    */
@@ -191,85 +191,83 @@ export default class EventEmitter {
       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));
+      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 })
-        );
+        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/logging/internal/adapters/pino.d.ts

@@ -22,4 +22,5 @@ export class PinoAdapter {
      * @returns {PinoAdapter} New adapter instance with context
      */
     child(context: any): PinoAdapter;
+    #private;
 }

package/dist/logging/internal/adapters/pino.js

@@ -9,12 +9,16 @@ import { dev } from '$app/environment';
  * Pino adapter that bridges Logger events to pino
  */
 export class PinoAdapter {
+  #projectRoot = null;
+
   /**
    * Create a new PinoAdapter
    *
    * @param {Object} [options] - Pino configuration options
    */
   constructor(options = {}) {
+    // Determine project root once for stack trace cleaning
+    this.#projectRoot = import.meta.env.VITE_PROJECT_ROOT || process.cwd();
     const baseOptions = {
       serializers: {
         err: (err) => {
@@ -23,14 +27,24 @@ export class PinoAdapter {
           let isFirst = true;
 
           while (current) {
+            /** @type {import('./typedef').ErrorSummary} */
             const serialized = {
               name: current.name,
               message: current.message,
               ...(isFirst &&
                 this.pino.level === 'debug' && {
-                  stack: current.stack
+                  stack: this.#cleanStackTrace(current.stack)
                 })
             };
+
+            // Include HttpError-specific properties
+            if (current.status !== undefined) {
+              serialized.status = current.status;
+            }
+            if (current.details !== undefined) {
+              serialized.details = current.details;
+            }
+
             chain.push(serialized);
             current = current.cause;
             isFirst = false;
@@ -56,6 +70,28 @@ export class PinoAdapter {
     this.pino = pino({ ...baseOptions, ...devOptions, ...options });
   }
 
+  /**
+   * Clean stack trace by removing project root path
+   *
+   * @param {string} stack - Original stack trace
+   * @returns {string} Cleaned stack trace
+   */
+  #cleanStackTrace(stack) {
+    if (!stack || !this.#projectRoot) {
+      return stack;
+    }
+
+    // Escape special regex characters in the project root path
+    const escapedRoot = this.#projectRoot.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    
+    // Replace project root path with relative path, but only after "at " to avoid 
+    // accidental replacements in error messages or other parts of the stack
+    // Match the project root followed by a path separator
+    const regex = new RegExp(`(\\s+at\\s+.*\\()${escapedRoot}[\\/\\\\]`, 'g');
+    
+    return stack.replace(regex, '$1');
+  }
+
   /**
    * Handle log events from Logger
    *

package/dist/logging/internal/adapters/typedef.d.ts

@@ -0,0 +1,24 @@
+declare const _default: {};
+export default _default;
+export type ErrorSummary = {
+    /**
+     * - The name of the exception/error
+     */
+    name: string;
+    /**
+     * - The error message
+     */
+    message: string;
+    /**
+     * Stack trace (in debug mode for first exception)
+     */
+    stack?: string;
+    /**
+     * - HTTP status code (for HttpError instances)
+     */
+    status?: number;
+    /**
+     * - Additional error details (for HttpError instances)
+     */
+    details?: any;
+};

package/dist/logging/internal/adapters/typedef.js

@@ -0,0 +1,10 @@
+/**
+ * @typedef {Object} ErrorSummary
+ * @property {string} name - The name of the exception/error
+ * @property {string} message - The error message
+ * @property {string} [stack] Stack trace (in debug mode for first exception)
+ * @property {number} [status] - HTTP status code (for HttpError instances)
+ * @property {*} [details] - Additional error details (for HttpError instances)
+ */
+
+ export default {};

package/dist/services/internal/service-manager/ServiceManager.d.ts

@@ -95,15 +95,6 @@ export class ServiceManager extends EventEmitter {
     stopAll(options?: StopOptions): Promise<{
         [x: string]: boolean;
     }>;
-    /**
-     * Stop services sequentially
-     *
-     * @private
-     * @param {string[]} serviceNames - Ordered list of service names
-     * @param {Map<string, boolean>} results - Results map to populate
-     * @param {StopOptions} options - Stop options
-     */
-    private _stopAllSequentially;
     /**
      * Get health status for all services
      *
@@ -133,39 +124,15 @@ export class ServiceManager extends EventEmitter {
      * @returns {string[]} Array of service names
      */
     getServicesByTag(tag: string): string[];
-    /**
-     * Setup logging configuration based on config.dev
-     *
-     * @private
-     */
-    private _setupLogging;
-    /**
-     * Get the appropriate log level for a service
-     *
-     * @private
-     * @param {string} name - Service name
-     *
-     * @returns {string|undefined} Log level or undefined
-     */
-    private _getServiceLogLevel;
     /**
      * Attach event listeners to forward service events
      *
-     * @private
      * @param {string} name - Service name
      * @param {import('../service-base/typedef.js').ServiceInstance} instance
      *   Service instance
      */
-    private _attachServiceEvents;
-    /**
-     * Sort services by dependencies using topological sort
-     *
-     * @private
-     *
-     * @returns {string[]} Service names in dependency order
-     * @throws {Error} If circular dependencies are detected
-     */
-    private _topologicalSort;
+    _attachServiceEvents(name: string, instance: import("../service-base/typedef.js").ServiceInstance): void;
+    #private;
 }
 export default ServiceManager;
 export type ServiceConstructor = import("./typedef.js").ServiceConstructor;