@hkdigital/lib-core 0.4.15 → 0.4.16

package/dist/auth/jwt/util.d.ts

@@ -36,3 +36,9 @@ export function sign(claims: import("./typedef.js").JwtPayload, secretOrPrivateK
  * @returns {import('./typedef.js').JwtPayload} claims - The decoded JWT payload
  */
 export function verify(token: string, secretOrPrivateKey: import("./typedef.js").Secret, options?: import("./typedef.js").VerifyOptions): import("./typedef.js").JwtPayload;
+/**
+ * Casts jsonwebtoken library errors to internal error types
+ * @param {Error} error - The original jsonwebtoken error
+ * @returns {Error} - The corresponding internal error
+ */
+export function castJwtError(error: Error): Error;

package/dist/auth/jwt/util.js

@@ -131,7 +131,7 @@ export function verify( token, secretOrPrivateKey, options=VERIFY_OPTIONS )
  * @param {Error} error - The original jsonwebtoken error
  * @returns {Error} - The corresponding internal error
  */
-function castJwtError(error) {
+export function castJwtError(error) {
   if (error instanceof JwtTokenExpiredError) {
     return new TokenExpiredError(error.message, error.expiredAt, error);
   }

package/dist/logging/README.md

@@ -109,11 +109,9 @@ const logger = createClientLogger('client');
 
 /** @type {import('@sveltejs/kit').HandleClientError} */
 export function handleError({ error, event }) {
-  logger.error('Client error occurred', {
-    message: error.message,
-    stack: error.stack,
-    url: event.url?.pathname,
-    userAgent: navigator.userAgent
+  logger.error(error, { 
+    url: event.url?.pathname, 
+    userAgent: navigator.userAgent 
   });
 }
 
@@ -126,19 +124,12 @@ export function init() {
   
   // Log unhandled errors
   window.addEventListener('error', (event) => {
-    logger.error('Unhandled error', {
-      message: event.error?.message || event.message,
-      filename: event.filename,
-      lineno: event.lineno,
-      colno: event.colno
-    });
+    logger.error(event, { url: window.location.pathname });
   });
   
   // Log unhandled promise rejections
   window.addEventListener('unhandledrejection', (event) => {
-    logger.error('Unhandled promise rejection', {
-      reason: event.reason
-    });
+    logger.error(event, { url: window.location.pathname });
   });
 }
 

package/dist/logging/internal/logger/Logger.d.ts

@@ -49,12 +49,16 @@ export default class Logger extends EventEmitter {
     /**
      * Log an error message
      *
-     * @param {Error|string} originalErrorOrMessage
-     * @param {Error} [originalError]
+     * @param {Error|ErrorEvent|PromiseRejectionEvent|string}
+     *   originalErrorOrMessage
+     * @param {Error|Object} [originalErrorOrDetails]
+     *   Error object (when first param is string) or details object
+     * @param {Object} [details]
+     *   Additional context details (when using string + error pattern)
      *
      * @returns {boolean} True if the log was emitted
      */
-    error(originalErrorOrMessage: Error | string, originalError?: Error, ...args: any[]): boolean;
+    error(originalErrorOrMessage: Error | ErrorEvent | PromiseRejectionEvent | string, originalErrorOrDetails?: Error | any, details?: any, ...args: any[]): boolean;
     /**
      * Create a child logger with additional context
      *

package/dist/logging/internal/logger/Logger.js

@@ -48,6 +48,13 @@ import { LoggerError } from '../../errors.js';
 
 import { toArray } from '../../../util/array/index.js';
 
+import {
+  castErrorEventToDetailedError,
+  castPromiseRejectionToDetailedError
+} from './util.js';
+
+import * as is from '../../../util/is.js';
+
 /**
  * Logger class for consistent logging
  * @extends EventEmitter
@@ -126,41 +133,92 @@ export default class Logger extends EventEmitter {
   /**
    * Log an error message
    *
-   * @param {Error|string} originalErrorOrMessage
-   * @param {Error} [originalError]
+   * @param {Error|ErrorEvent|PromiseRejectionEvent|string}
+   *   originalErrorOrMessage
+   * @param {Error|Object} [originalErrorOrDetails]
+   *   Error object (when first param is string) or details object
+   * @param {Object} [details]
+   *   Additional context details (when using string + error pattern)
    *
    * @returns {boolean} True if the log was emitted
    */
-  error(originalErrorOrMessage, originalError) {
+  error(originalErrorOrMessage, originalErrorOrDetails, details) {
+    // Detection logic - set clear internal variables
+    let message;
+    let errorDetails;
+    let cause;
+
+    // Handle browser ErrorEvent
+    if (is.ErrorEvent(originalErrorOrMessage)) {
+      const errorEvent = /** @type {ErrorEvent} */ (originalErrorOrMessage);
+
+      message =
+        errorEvent.error?.message || errorEvent.message || 'Unknown error';
+
+      // Use provided details or auto-generate from event
+
+      errorDetails = originalErrorOrDetails || {
+        filename: errorEvent.filename,
+        lineno: errorEvent.lineno,
+        colno: errorEvent.colno,
+        type: 'ErrorEvent'
+      };
 
-    if( originalErrorOrMessage instanceof Error )
-    {
-      // params: {error} originalErrorOrMessage
-      const loggerError = new LoggerError(originalErrorOrMessage);
+      cause = errorEvent.error;
+    }
+    // Handle browser PromiseRejectionEvent
+    else if (is.PromiseRejectionEvent(originalErrorOrMessage)) {
+      const promiseRejectionEvent =
+        /** @type {PromiseRejectionEvent} */ (originalErrorOrMessage);
+
+      const reason = promiseRejectionEvent.reason;
 
-      const message = originalErrorOrMessage.message;
+      if (reason instanceof Error) {
+        message = reason.message;
+        cause = reason;
+      } else {
+        message = String(reason);
+        cause = null;
+      }
 
-      return this.#log(ERROR, message, loggerError);
+      // Use provided details or auto-generate from event
+      errorDetails = originalErrorOrDetails || {
+        type: 'PromiseRejectionEvent',
+        reasonType: typeof reason
+      };
+    }
+    // Handle regular Error
+    else if (originalErrorOrMessage instanceof Error) {
+      message = originalErrorOrMessage.message;
+      errorDetails = originalErrorOrDetails || null;
+      cause = originalErrorOrMessage;
+    }
+    // Handle string + Error pattern
+    else if (
+      typeof originalErrorOrMessage === 'string' &&
+      originalErrorOrDetails instanceof Error
+    ) {
+      message = originalErrorOrMessage;
+      errorDetails = details || null;
+      cause = originalErrorOrDetails;
     }
-    else if( typeof originalErrorOrMessage === 'string' && originalError instanceof Error ) {
-      // params: {string} message, {error} originalError
-      const detailedError = new DetailedError(
-        originalErrorOrMessage,
-        null,
-        originalError
-      );
-
-      return this.#log(ERROR, detailedError.message, detailedError);
+    // Handle string only
+    else if (typeof originalErrorOrMessage === 'string') {
+      message = originalErrorOrMessage;
+      errorDetails = originalErrorOrDetails || null;
+      cause = null;
     }
+    // Invalid parameters
     else {
-      // wrong params
-      const detailedError = new DetailedError(
-        'Invalid parameters supplied to Logger.error',
-        toArray(arguments)
-      );
-
-      return this.#log(ERROR, detailedError.message, detailedError);
+      message = 'Invalid parameters supplied to Logger.error';
+      errorDetails = toArray(arguments);
+      cause = null;
     }
+
+    // Create consistent DetailedError for all cases
+    const detailedError = new DetailedError(message, errorDetails, cause);
+
+    return this.#log(ERROR, detailedError.message, detailedError);
   }
 
   /**

package/dist/logging/internal/logger/util.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Cast ErrorEvent to DetailedError
+ * @param {ErrorEvent} errorEvent - Browser ErrorEvent object
+ * @returns {DetailedError}
+ */
+export function castErrorEventToDetailedError(errorEvent: ErrorEvent): DetailedError;
+/**
+ * Cast PromiseRejectionEvent to DetailedError
+ * @param {PromiseRejectionEvent} rejectionEvent - Browser promise rejection
+ * @returns {DetailedError}
+ */
+export function castPromiseRejectionToDetailedError(rejectionEvent: PromiseRejectionEvent): DetailedError;
+import { DetailedError } from '../../../generic/errors/generic.js';

package/dist/logging/internal/logger/util.js

@@ -0,0 +1,47 @@
+import { DetailedError } from '../../../generic/errors/generic.js';
+
+/**
+ * Cast ErrorEvent to DetailedError
+ * @param {ErrorEvent} errorEvent - Browser ErrorEvent object
+ * @returns {DetailedError}
+ */
+export function castErrorEventToDetailedError(errorEvent) {
+  const message = errorEvent.error?.message || 
+                  errorEvent.message || 
+                  'Unknown error';
+  
+  const details = {
+    filename: errorEvent.filename,
+    lineno: errorEvent.lineno,
+    colno: errorEvent.colno,
+    type: 'ErrorEvent'
+  };
+  
+  return new DetailedError(message, details, errorEvent.error);
+}
+
+/**
+ * Cast PromiseRejectionEvent to DetailedError  
+ * @param {PromiseRejectionEvent} rejectionEvent - Browser promise rejection
+ * @returns {DetailedError}
+ */
+export function castPromiseRejectionToDetailedError(rejectionEvent) {
+  const reason = rejectionEvent.reason;
+  let message, cause;
+  
+  if (reason instanceof Error) {
+    message = reason.message;
+    cause = reason;
+  } else {
+    message = String(reason);
+    cause = null;
+  }
+  
+  const details = {
+    type: 'PromiseRejectionEvent',
+    reasonType: typeof reason
+  };
+  
+  return new DetailedError(message, details, cause);
+}
+

package/dist/services/README.md

@@ -104,7 +104,7 @@ Manages multiple services with dependency resolution and coordinated lifecycle o
 ### Usage
 
 ```javascript
-import { ServiceManager } from '$lib/services/index.js';
+import { ServiceManager } from '$hklib-core/services/index.js';
 import DatabaseService from './services/DatabaseService.js';
 import AuthService from './services/AuthService.js';
 
@@ -197,4 +197,4 @@ Services include comprehensive test suites demonstrating:
 - Health monitoring
 - Event emission
 
-Run tests with your project's test command to ensure service reliability.
+Run tests with your project's test command to ensure service reliability.

package/dist/util/is/events.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Check if object is an ErrorEvent
+ *
+ * @param {any} obj
+ *
+ * @returns {boolean}
+ */
+export function ErrorEvent(obj: any): boolean;
+/**
+ * Check if object is a PromiseRejectionEvent
+ *
+ * @param {any} obj
+ *
+ * @returns {boolean}
+ */
+export function PromiseRejectionEvent(obj: any): boolean;

package/dist/util/is/events.js

@@ -0,0 +1,25 @@
+/**
+ * Check if object is an ErrorEvent
+ *
+ * @param {any} obj
+ *
+ * @returns {boolean}
+ */
+export function ErrorEvent(obj) {
+  return Boolean(obj && 
+                 typeof obj === 'object' && 
+                 obj.constructor?.name === 'ErrorEvent');
+}
+
+/**
+ * Check if object is a PromiseRejectionEvent
+ *
+ * @param {any} obj
+ *
+ * @returns {boolean}
+ */
+export function PromiseRejectionEvent(obj) {
+  return Boolean(obj && 
+                 typeof obj === 'object' && 
+                 obj.constructor?.name === 'PromiseRejectionEvent');
+}

package/dist/util/is/index.d.ts

@@ -68,3 +68,4 @@ export { argumentsCheck as arguments };
  * @returns {boolean} true if the value is an Arguments object
  */
 declare function argumentsCheck(value: any): boolean;
+export { ErrorEvent, PromiseRejectionEvent } from "./events.js";

package/dist/util/is/index.js

@@ -146,3 +146,5 @@ export function object(value) {
 
 	return true;
 }
+
+export { ErrorEvent, PromiseRejectionEvent } from './events.js';

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@hkdigital/lib-core",
-	"version": "0.4.15",
+	"version": "0.4.16",
 	"author": {
 		"name": "HKdigital",
 		"url": "https://hkdigital.nl"