@hkdigital/lib-core 0.4.16 → 0.4.17

package/dist/generic/errors/generic.d.ts

@@ -6,15 +6,11 @@ export class InternalEventOrLogError extends Error {
 }
 export class DetailedError extends Error {
     /**
-     * @param {string} message - Error message
-     * @param {string|{[key: string]: any}|null} [details] - Additional details
-     * @param {Error|string} [cause] - Original error
+     * @param {string} [message]
+     * @param {import('./typedef.js').ErrorDetails} [details] - Additional details
+     * @param {Error|null} [cause] - Original error
      */
-    constructor(message: string, details?: string | {
-        [key: string]: any;
-    } | null, cause?: Error | string);
-    details: string | {
-        [key: string]: any;
-    };
-    cause: string | Error;
+    constructor(message?: string, details?: import("./typedef.js").ErrorDetails, cause?: Error | null);
+    details: import("./typedef.js").ErrorDetails;
+    cause: unknown;
 }

package/dist/generic/errors/generic.js

@@ -7,14 +7,24 @@ export class InternalEventOrLogError extends Error {}
 export class DetailedError extends Error
 {
   /**
-   * @param {string} message - Error message
-   * @param {string|{[key: string]: any}|null} [details] - Additional details
-   * @param {Error|string} [cause] - Original error
+   * @param {string} [message]
+   * @param {import('./typedef.js').ErrorDetails} [details] - Additional details
+   * @param {Error|null} [cause] - Original error
    */
   constructor(message, details, cause ) {
     super(message);
     this.name = 'DetailedError';
     this.details = details ?? null;
-    this.cause = cause;
+
+    if( cause )
+    {
+      if( cause instanceof Error )
+      {
+        this.cause = cause;
+      }
+      else {
+        throw new Error('Parameter [cause] should be an Error');
+      }
+    }
   }
 }

package/dist/generic/errors/typedef.d.ts

@@ -0,0 +1,5 @@
+declare const _default: {};
+export default _default;
+export type ErrorDetails = string | {
+    [key: string]: any;
+} | null;

package/dist/generic/errors/typedef.js

@@ -0,0 +1,3 @@
+/** @typedef {string|{[key: string]: any}|null} ErrorDetails */
+
+export default {};

package/dist/generic/typedef.d.ts

@@ -1,3 +1,4 @@
 export * from "./data/typedef.js";
+export * from "./errors/typedef.js";
 declare const _default: {};
 export default _default;

package/dist/generic/typedef.js

@@ -1,3 +1,4 @@
 export * from './data/typedef.js';
+export * from './errors/typedef.js';
 
 export default {};

package/dist/logging/errors.js

@@ -6,6 +6,13 @@ export class LoggerError extends Error
   constructor( originalError ) {
     super('LoggerError');
     this.name = 'LoggerError';
-    this.cause = originalError;
+
+    if( originalError instanceof Error )
+    {
+      this.cause = originalError;
+    }
+    else {
+      throw new Error('Parameter [originalError] should be an Error');
+    }
   }
 }

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

@@ -360,8 +360,6 @@ export class ConsoleAdapter {
 
       let cleaned = trimmed;
 
-      console.log(123, cleaned);
-
       // Convert Chrome format to Firefox format for consistency
       if (isChromeFormat) {
         // "at functionName (url:line:col)" -> "functionName@url:line:col"

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

@@ -50,15 +50,17 @@ export default class Logger extends EventEmitter {
      * Log an error message
      *
      * @param {Error|ErrorEvent|PromiseRejectionEvent|string}
-     *   originalErrorOrMessage
-     * @param {Error|Object} [originalErrorOrDetails]
+     *   errorOrMessage
+     *
+     * @param {Error|ErrorDetails} [errorOrDetails]
      *   Error object (when first param is string) or details object
-     * @param {Object} [details]
+     *
+     * @param {ErrorDetails} [details]
      *   Additional context details (when using string + error pattern)
      *
      * @returns {boolean} True if the log was emitted
      */
-    error(originalErrorOrMessage: Error | ErrorEvent | PromiseRejectionEvent | string, originalErrorOrDetails?: Error | any, details?: any, ...args: any[]): boolean;
+    error(errorOrMessage: Error | ErrorEvent | PromiseRejectionEvent | string, errorOrDetails?: Error | ErrorDetails, details?: ErrorDetails, ...args: any[]): boolean;
     /**
      * Create a child logger with additional context
      *
@@ -81,4 +83,5 @@ export default class Logger extends EventEmitter {
     logFromEvent(eventName: string, eventData: import("../../typedef.js").LogEventData): boolean;
     #private;
 }
+export type ErrorDetails = import("../../../generic/typedef.js").ErrorDetails;
 import { EventEmitter } from '../../../generic/events.js';

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

@@ -32,6 +32,8 @@
  * logger.setLevel(DEBUG); // Now debug messages will also be logged
  */
 
+/** @typedef {import('../../../generic/typedef.js').ErrorDetails} ErrorDetails */
+
 import { EventEmitter } from '../../../generic/events.js';
 
 import {
@@ -44,14 +46,15 @@ import {
 } from '../../constants.js';
 
 import { DetailedError } from '../../../generic/errors.js';
-import { LoggerError } from '../../errors.js';
+// import { LoggerError } from '../../errors.js';
 
-import { toArray } from '../../../util/array/index.js';
+import { toArray } from '../../../util/array.js';
+import { exportNotNullish } from '../../../util/object.js';
 
-import {
-  castErrorEventToDetailedError,
-  castPromiseRejectionToDetailedError
-} from './util.js';
+// import {
+//   castErrorEventToDetailedError,
+//   castPromiseRejectionToDetailedError
+// } from './util.js';
 
 import * as is from '../../../util/is.js';
 
@@ -134,91 +137,77 @@ export default class Logger extends EventEmitter {
    * Log an error message
    *
    * @param {Error|ErrorEvent|PromiseRejectionEvent|string}
-   *   originalErrorOrMessage
-   * @param {Error|Object} [originalErrorOrDetails]
+   *   errorOrMessage
+   *
+   * @param {Error|ErrorDetails} [errorOrDetails]
    *   Error object (when first param is string) or details object
-   * @param {Object} [details]
+   *
+   * @param {ErrorDetails} [details]
    *   Additional context details (when using string + error pattern)
    *
    * @returns {boolean} True if the log was emitted
    */
-  error(originalErrorOrMessage, originalErrorOrDetails, details) {
-    // Detection logic - set clear internal variables
-    let message;
-    let errorDetails;
-    let cause;
+  error(errorOrMessage, errorOrDetails, details) {
+    let errorObject = null;
 
-    // Handle browser ErrorEvent
-    if (is.ErrorEvent(originalErrorOrMessage)) {
-      const errorEvent = /** @type {ErrorEvent} */ (originalErrorOrMessage);
+    let message;
 
-      message =
-        errorEvent.error?.message || errorEvent.message || 'Unknown error';
+    if( typeof errorOrMessage === 'string' )
+    {
+      message = errorOrMessage;
+    }
 
-      // Use provided details or auto-generate from event
+    if (message) {
 
-      errorDetails = originalErrorOrDetails || {
-        filename: errorEvent.filename,
-        lineno: errorEvent.lineno,
-        colno: errorEvent.colno,
-        type: 'ErrorEvent'
-      };
+      // First param is a string (message)
+      // => Second param might be the error (string + error pattern)
 
-      cause = errorEvent.error;
-    }
-    // Handle browser PromiseRejectionEvent
-    else if (is.PromiseRejectionEvent(originalErrorOrMessage)) {
-      const promiseRejectionEvent =
-        /** @type {PromiseRejectionEvent} */ (originalErrorOrMessage);
+      if (this.#isErrorLike(errorOrDetails)) {
+        let errorLike = errorOrDetails;
+        errorObject = this.#toError(errorLike);
+      }
+    } else {
 
-      const reason = promiseRejectionEvent.reason;
+      // First param is not an (not empty) string
+      // => First param should be the error
 
-      if (reason instanceof Error) {
-        message = reason.message;
-        cause = reason;
-      } else {
-        message = String(reason);
-        cause = null;
+      if (this.#isErrorLike(errorOrMessage)) {
+        let errorLike = errorOrMessage;
+        errorObject = this.#toError(errorLike);
       }
 
-      // Use provided details or auto-generate from event
-      errorDetails = originalErrorOrDetails || {
-        type: 'PromiseRejectionEvent',
-        reasonType: typeof reason
-      };
+      // Second parameter could be the details
+      // Third parameter will be ignored (overwritten)
+      details = errorOrDetails;
     }
-    // Handle regular Error
-    else if (originalErrorOrMessage instanceof Error) {
-      message = originalErrorOrMessage.message;
-      errorDetails = originalErrorOrDetails || null;
-      cause = originalErrorOrMessage;
+
+    if( errorObject && details )
+    {
+      // Additional Details supplied
+      // => Prepend additional DetailedError to chain
+      errorObject = new DetailedError(message, details, errorObject );
     }
-    // Handle string + Error pattern
-    else if (
-      typeof originalErrorOrMessage === 'string' &&
-      originalErrorOrDetails instanceof Error
-    ) {
-      message = originalErrorOrMessage;
-      errorDetails = details || null;
-      cause = originalErrorOrDetails;
+
+    if( message && errorObject )
+    {
+      // Log with message
+      return this.#log(ERROR, message, errorObject);
     }
-    // Handle string only
-    else if (typeof originalErrorOrMessage === 'string') {
-      message = originalErrorOrMessage;
-      errorDetails = originalErrorOrDetails || null;
-      cause = null;
+    else if (errorObject) {
+      // Log without message
+      return this.#log(ERROR, errorObject.message, errorObject);
     }
-    // Invalid parameters
     else {
-      message = 'Invalid parameters supplied to Logger.error';
-      errorDetails = toArray(arguments);
-      cause = null;
-    }
+      // Missing error like object
+      // => invalid parameters supplied to logger.error
 
-    // Create consistent DetailedError for all cases
-    const detailedError = new DetailedError(message, errorDetails, cause);
+      const detailedError = new DetailedError(
+        'Missing error like object in Logger.error parameters',
+        toArray(arguments)
+      );
 
-    return this.#log(ERROR, detailedError.message, detailedError);
+      return this.#log(ERROR, detailedError.message, detailedError);
+    }
   }
 
   /**
@@ -307,4 +296,84 @@ export default class Logger extends EventEmitter {
 
     return true;
   }
+
+  /**
+   * Returns true is the supplied parameter is loggable as error
+   *
+   * @param {any} thing
+   *
+   * @returns {boolean}
+   */
+  #isErrorLike(thing) {
+    return (
+      thing instanceof Error ||
+      is.ErrorEvent(thing) ||
+      is.PromiseRejectionEvent(thing)
+    );
+  }
+
+  /**
+   * Convert an Error like object (Error, ErrorEvent, PromiseRejectionEvent)
+   * to a DetailedError
+   *
+   * @param {any} errorLike
+   *
+   * @returns {Error}
+   */
+  #toError( errorLike ) {
+    if (is.ErrorEvent(errorLike)) {
+      // errorLike is an ErrorEvent
+      // => convert to DetailedError
+      const errorEvent = /** @type {ErrorEvent} */ (errorLike);
+
+      let errorEventDetails = exportNotNullish( errorEvent, [
+        'message',
+        'filename',
+        'lineno',
+        'colno'
+      ]);
+
+      errorEventDetails.type = 'ErrorEvent';
+
+      let cause = errorEvent.error;
+
+      return new DetailedError(
+        errorEvent.message,
+        errorEventDetails,
+        cause
+      );
+
+    } else if (is.PromiseRejectionEvent(errorLike)) {
+      // errorLike is a PromiseRejectionEvent
+      // => convert to DetailedError
+      const rejectionEvent = /** @type {PromiseRejectionEvent} */ (errorLike);
+
+      const reason = rejectionEvent.reason;
+
+      if (reason instanceof Error) {
+        return reason;
+      }
+      else if ( is.object(reason) && reason?.message ) {
+        // reason is  an object with message property
+        return new DetailedError(reason?.message, reason);
+      }
+      else if ( typeof reason === "string" ) {
+        // reason is a string
+        return new DetailedError(reason);
+      }
+      else {
+        // reason is not an Error or string
+        return new DetailedError('Promise rejected', reason);
+      }
+    } else if (errorLike instanceof Error) {
+      // errorLike is a plain Error
+      // => return it
+      return errorLike;
+    }
+
+    // errorLike cannot be converted to an Error
+    // => return logging error
+
+    return new DetailedError('Cannot convert to Error', errorLike);
+  }
 }

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

@@ -4,13 +4,13 @@
  * - The originating Error is set as `cause` property
  *
  * @param {string} message - New error message
- * @param {Error|string} originalError
+ * @param {Error|string} originalErrorOrMessage
  * @param {string|Object.<string, any>|null} [details]
  *   New error details (a DetailError will be thrown)
  *
  * @throws {DetailedError}
  * @returns {never} This function never returns
  */
-export function rethrow(message: string, originalError: Error | string, details?: string | {
+export function rethrow(message: string, originalErrorOrMessage: Error | string, details?: string | {
     [x: string]: any;
 } | null): never;

package/dist/util/exceptions/index.js

@@ -7,20 +7,23 @@ import { DetailedError } from "../../generic/errors.js";
  * - The originating Error is set as `cause` property
  *
  * @param {string} message - New error message
- * @param {Error|string} originalError
+ * @param {Error|string} originalErrorOrMessage
  * @param {string|Object.<string, any>|null} [details]
  *   New error details (a DetailError will be thrown)
  *
  * @throws {DetailedError}
  * @returns {never} This function never returns
  */
-export function rethrow(message, originalError, details ) {
+export function rethrow(message, originalErrorOrMessage, details ) {
   let error;
 
-  if (!(originalError instanceof Error)) {
+  if ( typeof originalErrorOrMessage === 'string' ) {
     // Convert non-Error values to Error objects
-    error = new Error(String(originalError));
+    error = new Error( originalErrorOrMessage );
+  }
+  else {
+    error = originalErrorOrMessage;
   }
 
-  throw new DetailedError(message, details, error ?? originalError );
+  throw new DetailedError(message, details, error );
 }

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

@@ -29,7 +29,7 @@ export function size(obj: object): number;
  *
  * @returns {object} new object without the null properties
  */
-export function exportNotNull(obj: object, onlyKeys?: string[]): object;
+export function exportNotNullish(obj: object, onlyKeys?: string[]): object;
 /**
  * Create a shallow copy of the object's public properties. Properties that
  * start with an underscore are considered 'internal' properties and are not

package/dist/util/object/index.js

@@ -90,7 +90,7 @@ export function size(obj) {
  *
  * @returns {object} new object without the null properties
  */
-export function exportNotNull(obj, onlyKeys) {
+export function exportNotNullish(obj, onlyKeys) {
 	expect.object(obj);
 
 	const onlyKeysSet = onlyKeys ? new Set(onlyKeys) : null;

package/package.json

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

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

@@ -1,13 +0,0 @@
-/**
- * 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

@@ -1,47 +0,0 @@
-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);
-}
-