@hkdigital/lib-core 0.4.30 → 0.4.32

package/dist/services/service-base/ServiceBase.js

@@ -85,7 +85,8 @@ import {
  * @extends EventEmitter
  */
 export class ServiceBase extends EventEmitter {
-  /** @type {*} */
+
+  /** @type {Object<string,any>|null} */
   #lastConfig = null;
 
   /**
@@ -97,6 +98,11 @@ export class ServiceBase extends EventEmitter {
   constructor(name, options = {}) {
     super();
 
+    if( typeof name !== 'string' )
+    {
+      throw new Error(`Service misses constructor parameter [name]`);
+    }
+
     /** @type {string} */
     this.name = name;
 
@@ -122,7 +128,7 @@ export class ServiceBase extends EventEmitter {
   /**
    * Configure the service with configuration
    *
-   * @param {*} [config={}] - Service-specific configuration
+   * @param {Object<string,any>|null} [config={}]
    *
    * @returns {Promise<boolean>} True if configuration succeeded
    */
@@ -152,11 +158,20 @@ export class ServiceBase extends EventEmitter {
       this.logger.info('Service configured');
       return true;
     } catch (error) {
-      this._setError('configuration', error);
+      this._setError('configuration', /** @type {Error} */ (error));
       return false;
     }
   }
 
+  /**
+   * Get the last applied config
+   *
+   * @returns {Object<string,any>} config
+   */
+  get lastConfig() {
+    return { ...this.#lastConfig };
+  }
+
   /**
    * Start the service
    *
@@ -180,7 +195,7 @@ export class ServiceBase extends EventEmitter {
       this.logger.info('Service started');
       return true;
     } catch (error) {
-      this._setError('startup', error);
+      this._setError('startup', /** @type {Error} */ (error));
       return false;
     }
   }
@@ -224,12 +239,15 @@ export class ServiceBase extends EventEmitter {
       this.logger.info('Service stopped');
       return true;
     } catch (error) {
-      if (error.message === 'Shutdown timeout' && options.force) {
+      if (
+        /** @type {Error} */ (error).message === 'Shutdown timeout' &&
+        options.force
+      ) {
         this.logger.warn('Forced shutdown after timeout');
         this._setState(STATE_STOPPED);
         return true;
       }
-      this._setError('shutdown', error);
+      this._setError('shutdown', /** @type {Error} */ (error));
       return false;
     }
   }
@@ -267,7 +285,7 @@ export class ServiceBase extends EventEmitter {
       this.logger.info('Recovery successful');
       return true;
     } catch (error) {
-      this._setError('recovery', error);
+      this._setError('recovery', /** @type {Error} */ (error));
       return false;
     }
   }
@@ -305,7 +323,7 @@ export class ServiceBase extends EventEmitter {
 
       return true;
     } catch (error) {
-      this._setError('destruction', error);
+      this._setError('destruction', /** @type {Error} */ (error));
       return false;
     }
   }
@@ -332,7 +350,7 @@ export class ServiceBase extends EventEmitter {
         return {
           ...baseHealth,
           healthy: false,
-          checkError: error.message
+          checkError: /** @type {Error} */ (error).message
         };
       }
     }

package/dist/services/service-base/typedef.d.ts

@@ -9,11 +9,11 @@ export type ServiceOptions = {
     /**
      * - Initial log level for the service
      */
-    logLevel?: string;
+    logLevel?: string | undefined;
     /**
      * - Timeout for graceful shutdown
      */
-    shutdownTimeout?: number;
+    shutdownTimeout?: number | undefined;
 };
 /**
  * Options for stopping a service
@@ -22,11 +22,11 @@ export type StopOptions = {
     /**
      * - Override shutdown timeout
      */
-    timeout?: number;
+    timeout?: number | undefined;
     /**
      * - Force stop even if timeout exceeded
      */
-    force?: boolean;
+    force?: boolean | undefined;
 };
 /**
  * Health status returned by service health checks
@@ -47,11 +47,11 @@ export type HealthStatus = {
     /**
      * - Error message if unhealthy
      */
-    error?: string;
+    error?: string | undefined;
     /**
      * - Error from health check itself
      */
-    checkError?: string;
+    checkError?: string | undefined;
     /**
      * - Additional health check properties
      */
@@ -61,7 +61,7 @@ export type HealthStatus = {
  * Base class interface that services must implement
  * Allows additional custom properties and methods via Record<string, any>
  */
-export type ServiceInstance = any & Record<string, any>;
+export type ServiceInstance = Object & Record<string, any>;
 export type StateChangeEvent = {
     /**
      * - Service name (added by ServiceManager)
@@ -94,7 +94,7 @@ export type HealthChangeEvent = {
     /**
      * - Previous health status
      */
-    wasHealthy?: boolean;
+    wasHealthy?: boolean | undefined;
 };
 /**
  * Event emitted when service encounters an error

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

@@ -7,6 +7,10 @@
  * @typedef {import('./typedef.js').HealthCheckResult} HealthCheckResult
  *
  * @typedef {import('../service-base/typedef.js').StopOptions} StopOptions
+ * @typedef {import('../service-base/typedef.js').StateChangeEvent} StateChangeEvent
+ * @typedef {import('../service-base/typedef.js').HealthChangeEvent} HealthChangeEvent
+ * @typedef {import('../service-base/typedef.js').ServiceErrorEvent} ServiceErrorEvent
+ * @typedef {import('../../logging/typedef.js').LogEvent} LogEvent
  */
 /**
  * Service Manager for lifecycle and dependency management
@@ -131,11 +135,11 @@ export class ServiceManager extends EventEmitter {
     /**
      * Listen to log messages emitted by individual services
      *
-     * @param {Function} listener - Log event handler
+     * @param {(logEvent: LogEvent) => void} listener - Log event handler
      *
      * @returns {Function} Unsubscribe function
      */
-    onServiceLogEvent(listener: Function): Function;
+    onServiceLogEvent(listener: (logEvent: LogEvent) => void): Function;
     /**
      * Set log level for the ServiceManager itself
      *
@@ -181,5 +185,9 @@ export type ServiceEntry = import("./typedef.js").ServiceEntry;
 export type ServiceConfigOrLabel = import("./typedef.js").ServiceConfigOrLabel;
 export type HealthCheckResult = import("./typedef.js").HealthCheckResult;
 export type StopOptions = import("../service-base/typedef.js").StopOptions;
+export type StateChangeEvent = import("../service-base/typedef.js").StateChangeEvent;
+export type HealthChangeEvent = import("../service-base/typedef.js").HealthChangeEvent;
+export type ServiceErrorEvent = import("../service-base/typedef.js").ServiceErrorEvent;
+export type LogEvent = import("../../logging/typedef.js").LogEvent;
 import { EventEmitter } from '../../generic/events.js';
 import { Logger } from '../../logging/index.js';

package/dist/services/service-manager/ServiceManager.js

@@ -85,6 +85,10 @@ import {
  * @typedef {import('./typedef.js').HealthCheckResult} HealthCheckResult
  *
  * @typedef {import('../service-base/typedef.js').StopOptions} StopOptions
+ * @typedef {import('../service-base/typedef.js').StateChangeEvent} StateChangeEvent
+ * @typedef {import('../service-base/typedef.js').HealthChangeEvent} HealthChangeEvent
+ * @typedef {import('../service-base/typedef.js').ServiceErrorEvent} ServiceErrorEvent
+ * @typedef {import('../../logging/typedef.js').LogEvent} LogEvent
  */
 
 /**
@@ -197,10 +201,8 @@ export class ServiceManager extends EventEmitter {
 
     // Track dependents
     entry.dependencies.forEach((dep) => {
-      const depEntry = this.services.get(dep);
-      if (depEntry) {
-        depEntry.dependents.add(name);
-      }
+      const depEntry = this.#getServiceEntry(dep);
+      depEntry.dependents.add(name);
     });
 
     this.services.set(name, entry);
@@ -220,11 +222,8 @@ export class ServiceManager extends EventEmitter {
    *   Service instance or null if not found
    */
   get(name) {
-    const entry = this.services.get(name);
-    if (!entry) {
-      this.logger.warn(`Service '${name}' not found`);
-      return null;
-    }
+    // @throws service not found
+    const entry = this.#getServiceEntry(name);
 
     if (!entry.instance) {
       try {
@@ -241,7 +240,10 @@ export class ServiceManager extends EventEmitter {
 
         this.logger.debug(`Created instance for '${name}'`);
       } catch (error) {
-        this.logger.error(`Failed to create instance for '${name}'`, error);
+        this.logger.error(
+          `Failed to create instance for '${name}'`,
+          /** @type {Error} */ (error)
+        );
         return null;
       }
     }
@@ -260,7 +262,8 @@ export class ServiceManager extends EventEmitter {
     const instance = this.get(name);
     if (!instance) return false;
 
-    const entry = this.services.get(name);
+    const entry = this.#getServiceEntry(name);
+
     const config = await this.#resolveServiceConfig(name, entry);
 
     return await instance.configure(config);
@@ -274,7 +277,7 @@ export class ServiceManager extends EventEmitter {
    * @returns {Promise<boolean>} True if service started successfully
    */
   async startService(name) {
-    const entry = this.services.get(name);
+    const entry = this.#getServiceEntry(name);
     if (!entry) {
       this.logger.warn(`Cannot start unregistered service '${name}'`);
       return false;
@@ -325,13 +328,15 @@ export class ServiceManager extends EventEmitter {
    */
   async stopService(name, options = {}) {
     const instance = this.get(name);
+
     if (!instance) {
       this.logger.warn(`Cannot stop unregistered service '${name}'`);
       return true; // Already stopped
     }
 
     // Check dependents
-    const entry = this.services.get(name);
+    const entry = this.#getServiceEntry(name);
+
     if (!options.force && entry && entry.dependents.size > 0) {
       const runningDependents = [];
       for (const dep of entry.dependents) {
@@ -490,7 +495,7 @@ export class ServiceManager extends EventEmitter {
   /**
    * Listen to log messages emitted by individual services
    *
-   * @param {Function} listener - Log event handler
+   * @param {(logEvent: LogEvent) => void} listener - Log event handler
    *
    * @returns {Function} Unsubscribe function
    */
@@ -582,27 +587,45 @@ export class ServiceManager extends EventEmitter {
    */
   _attachServiceEvents(name, instance) {
     // Forward service events
-    instance.on('stateChanged', (data) => {
+    instance.on('stateChanged', (/** @type {StateChangeEvent} */ data) => {
       this.emit('service:stateChanged', { service: name, data });
     });
 
-    instance.on('healthChanged', (data) => {
+    instance.on('healthChanged', (/** @type {HealthChangeEvent} */ data) => {
       this.emit('service:healthChanged', { service: name, data });
     });
 
-    instance.on('error', (data) => {
+    instance.on('error', (/** @type {ServiceErrorEvent} */ data) => {
       this.emit('service:error', { service: name, data });
     });
 
     // Forward log events
-
-    instance.logger.on('log', (logEvent) => {
+    instance.logger.on('log', (/** @type {LogEvent} */ logEvent) => {
       this.emit('service:log', logEvent);
     });
   }
 
   // Internal methods
 
+  /**
+   * Get internal service registration entry by name
+   *
+   * @param {string} name
+   *
+   * @throws {Error} service not registered
+   *
+   * @returns {ServiceEntry}
+   */
+  #getServiceEntry(name) {
+    const entry = this.services.get(name);
+
+    if (!entry) {
+      throw new Error(`Service [${name}] has not been registered`);
+    }
+
+    return entry;
+  }
+
   /**
    * Resolve service configuration using plugins
    *
@@ -674,7 +697,10 @@ export class ServiceManager extends EventEmitter {
         const success = await this.stopService(name, options);
         results.set(name, success);
       } catch (error) {
-        this.logger.error(`Error stopping '${name}'`, error);
+        this.logger.error(
+          `Error stopping '${name}'`,
+          /** @type {Error} */ (error)
+        );
         results.set(name, false);
       }
     }
@@ -683,15 +709,18 @@ export class ServiceManager extends EventEmitter {
   /**
    * Sort services by dependencies using topological sort
    *
-   * @returns {string[]} Service names in dependency order
    * @throws {Error} If circular dependencies are detected
+   *
+   * @returns {string[]} Service names in dependency order
    */
   #topologicalSort() {
+    /** @type {string[]}*/
     const sorted = [];
+
     const visited = new Set();
     const visiting = new Set();
 
-    const visit = (name) => {
+    const visit = (/** @type {string} */ name) => {
       if (visited.has(name)) return;
       if (visiting.has(name)) {
         throw new Error(`Circular dependency detected involving '${name}'`);
@@ -699,11 +728,10 @@ export class ServiceManager extends EventEmitter {
 
       visiting.add(name);
 
-      const entry = this.services.get(name);
-      if (entry) {
-        for (const dep of entry.dependencies) {
-          visit(dep);
-        }
+      const entry = this.#getServiceEntry(name);
+
+      for (const dep of entry.dependencies) {
+        visit(dep);
       }
 
       visiting.delete(name);

package/dist/services/service-manager/typedef.d.ts

@@ -11,15 +11,15 @@ export type ServiceRegistrationOptions = {
     /**
      * - Services this service depends on
      */
-    dependencies?: string[];
+    dependencies?: string[] | undefined;
     /**
      * - Tags for grouping services
      */
-    tags?: string[];
+    tags?: string[] | undefined;
     /**
      * - Higher starts first
      */
-    startupPriority?: number;
+    startupPriority?: number | undefined;
 };
 /**
  * Configuration for ServiceManager
@@ -28,23 +28,23 @@ export type ServiceManagerConfig = {
     /**
      * - Debug mode switch
      */
-    debug?: boolean;
+    debug?: boolean | undefined;
     /**
      * - Auto-start services on registration
      */
-    autoStart?: boolean;
+    autoStart?: boolean | undefined;
     /**
      * - Default timeout for stopping services
      */
-    stopTimeout?: number;
+    stopTimeout?: number | undefined;
     /**
      * - Default log level for new services
      */
-    defaultLogLevel?: string;
+    defaultLogLevel?: string | undefined;
     /**
      * - Initial log level for ServiceManager
      */
-    managerLogLevel?: string;
+    managerLogLevel?: string | undefined;
     /**
      * Per-service log levels:
      * - String: "auth:debug,database:info"
@@ -52,7 +52,7 @@ export type ServiceManagerConfig = {
      */
     serviceLogLevels?: string | {
         [x: string]: string;
-    };
+    } | undefined;
 };
 /**
  * Result of health check for all services
@@ -87,10 +87,11 @@ export type ServiceManagerPlugin = {
     /**
      * - Optional config resolution method
      */
-    resolveServiceConfig?: (arg0: string, arg1: ServiceEntry, arg2: any) => Promise<any | undefined>;
+    resolveServiceConfig?: ((arg0: string, arg1: ServiceEntry, arg2: any) => Promise<any | undefined>) | undefined;
 };
 /**
- * Internal service registry entry
+ * Internal service registry entry, an internal registry entry that the
+ * ServiceManager uses to track each registered service.
  */
 export type ServiceEntry = {
     /**

package/dist/services/service-manager/typedef.js

@@ -87,7 +87,8 @@
 // ============================================================================
 
 /**
- * Internal service registry entry
+ * Internal service registry entry, an internal registry entry that the
+ * ServiceManager uses to track each registered service.
  *
  * @typedef {Object} ServiceEntry
  * @property {ServiceConstructor} ServiceClass - Service class constructor

package/dist/state/machines/finite-state-machine/FiniteStateMachine.svelte.d.ts

@@ -45,7 +45,7 @@ export default class FiniteStateMachine extends EventEmitter {
      * @param {string} event
      * @param {any[]} args
      */
-    debounce(wait: number, event: string, ...args: any[]): Promise<any>;
+    debounce(wait: number | undefined, event: string, ...args: any[]): Promise<any>;
     /** The current state. */
     get current(): any;
     #private;

package/dist/state/machines/loading-state-machine/LoadingStateMachine.svelte.d.ts

@@ -4,7 +4,7 @@
 export default class LoadingStateMachine extends FiniteStateMachine {
     constructor();
     /** The last error */
-    get error(): Error;
+    get error(): Error | null;
     /**
      * Transition to timeout state
      * - Only valid when currently loading

package/dist/state/stores/theme.d.ts

@@ -21,7 +21,7 @@ export namespace metaThemeColorBase {
     function get(): void;
 }
 export namespace metaThemeColorDark {
-    let subscribe_1: (this: void, run: import("svelte/store").Subscriber<string>, invalidate?: () => void) => import("svelte/store").Unsubscriber;
+    let subscribe_1: (this: void, run: import("svelte/store").Subscriber<string | null>, invalidate?: () => void) => import("svelte/store").Unsubscriber;
     export { subscribe_1 as subscribe };
     export function get_1(): void;
     export { get_1 as get };

package/dist/ui/components/button-group/ButtonGroup.svelte.d.ts

@@ -3,17 +3,17 @@ type ButtonGroup = {
     $on?(type: string, callback: (e: any) => void): () => void;
     $set?(props: Partial<{
         [attr: string]: any;
-        base?: string;
-        bg?: string;
-        classes?: string;
+        base?: string | undefined;
+        bg?: string | undefined;
+        classes?: string | undefined;
         buttons: ButtonDef[];
-        selected?: ButtonDef;
-        select?: (label: string) => void;
+        selected?: ButtonDef | null | undefined;
+        select?: ((label: string) => void) | undefined;
         buttonSnippet: Snippet<[{
             text: string;
             value: string;
             label: string;
-            props: any;
+            props: Object;
         }]>;
     }>): void;
 };
@@ -29,6 +29,6 @@ declare const ButtonGroup: import("svelte").Component<{
         text: string;
         value: string;
         label: string;
-        props: any;
+        props: Object;
     }]>;
 }, {}, "select" | "selected">;

package/dist/ui/components/button-group/typedef.d.ts

@@ -3,5 +3,5 @@ export type ButtonDef = {
     value?: any;
     label?: string;
     hide?: boolean;
-    props?: any;
+    props?: Object;
 };

package/dist/ui/components/compare-left-right/CompareLeftRight.svelte.d.ts

@@ -2,11 +2,11 @@ export default CompareLeftRight;
 type CompareLeftRight = {
     $on?(type: string, callback: (e: any) => void): () => void;
     $set?(props: Partial<{
-        leftContent?: Snippet<[]>;
-        rightContent?: Snippet<[]>;
-        classes?: string;
-        dividerColor?: string;
-        handleColor?: string;
+        leftContent?: Snippet<[]> | undefined;
+        rightContent?: Snippet<[]> | undefined;
+        classes?: string | undefined;
+        dividerColor?: string | undefined;
+        handleColor?: string | undefined;
     } & Record<string, any>>): void;
 };
 declare const CompareLeftRight: import("svelte").Component<{

package/dist/ui/components/drag-drop/DragController.d.ts

@@ -8,7 +8,7 @@ export class DragController {
      */
     constructor(event: DragEvent);
     event: DragEvent;
-    dataTransfer: DataTransfer;
+    dataTransfer: DataTransfer | null;
     targetElement: HTMLElement;
     offsetX: number;
     offsetY: number;

package/dist/ui/components/drag-drop/DragDropContext.svelte.d.ts

@@ -3,9 +3,9 @@ type DragDropContext = {
     $on?(type: string, callback: (e: any) => void): () => void;
     $set?(props: Partial<{
         [key: string]: any;
-        contextKey?: ContextKey;
-        base?: string;
-        classes?: string;
+        contextKey?: ContextKey | undefined;
+        base?: string | undefined;
+        classes?: string | undefined;
         children: Snippet<[]>;
     }>): void;
 };

package/dist/ui/components/drag-drop/Draggable.svelte.d.ts

@@ -4,12 +4,12 @@ type Draggable = {
     $set?(props: Partial<{
         [key: string]: any;
         item: any;
-        group?: string;
-        source?: string;
-        disabled?: boolean;
-        dragDelay?: number;
-        base?: string;
-        classes?: string;
+        group?: string | undefined;
+        source?: string | undefined;
+        disabled?: boolean | undefined;
+        dragDelay?: number | undefined;
+        base?: string | undefined;
+        classes?: string | undefined;
         children: Snippet<[{
             element: HTMLElement;
             rect: DOMRect;
@@ -18,33 +18,33 @@ type Draggable = {
         draggingSnippet?: Snippet<[{
             element: HTMLElement;
             rect: DOMRect;
-        }]>;
-        contextKey?: ContextKey;
-        isDragging?: boolean;
-        isDropping?: boolean;
-        isDragPreview?: boolean;
-        onDragStart?: (detail: {
+        }]> | undefined;
+        contextKey?: ContextKey | undefined;
+        isDragging?: boolean | undefined;
+        isDropping?: boolean | undefined;
+        isDragPreview?: boolean | undefined;
+        onDragStart?: ((detail: {
             event: DragEvent;
             item: any;
             source: string;
             group: string;
             getController: () => DragController;
-        }) => void;
-        onDragging?: (detail: {
+        }) => void) | undefined;
+        onDragging?: ((detail: {
             event: DragEvent;
             item: any;
-        }) => void;
-        onDragEnd?: (detail: {
+        }) => void) | undefined;
+        onDragEnd?: ((detail: {
             event: DragEvent;
             item: any;
             wasDropped: boolean;
-        }) => void;
-        onDrop?: (detail: {
+        }) => void) | undefined;
+        onDrop?: ((detail: {
             event: DragEvent;
             item: any;
             wasDropped: boolean;
-        }) => void;
-        canDrag?: (item: any) => boolean;
+        }) => void) | undefined;
+        canDrag?: ((item: any) => boolean) | undefined;
     }>): void;
 };
 declare const Draggable: import("svelte").Component<{