@digitaldefiance/i18n-lib 1.3.6 → 1.3.8

package/README.md

@@ -2274,6 +2274,15 @@ For issues, questions, or contributions:
 
 ## ChangeLog
 
+### Version 1.3.8
+
+- Add TypedHandleable
+
+### Version 1.3.7
+
+- Add handleable at i18n level
+- Add TranslatableGenericHandleable at i18n level
+
 ### Version 1.3.6
 
 - Simplify LanguageContextSpace and generics related to it

package/dist/handleable.d.ts

@@ -0,0 +1,13 @@
+import { HandleableErrorOptions } from './i-handleable-error-options';
+import { IHandleable } from './i-handleable';
+export declare class HandleableError extends Error implements IHandleable {
+    readonly cause?: Error;
+    readonly statusCode: number;
+    readonly sourceData?: unknown;
+    private _handled;
+    constructor(source: Error, options?: HandleableErrorOptions);
+    get handled(): boolean;
+    set handled(value: boolean);
+    private serializeValue;
+    toJSON(): Record<string, unknown>;
+}

package/dist/handleable.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HandleableError = void 0;
+class HandleableError extends Error {
+    constructor(source, options) {
+        super(source.message);
+        this.name = this.constructor.name;
+        this.cause = options?.cause ?? source;
+        this.statusCode = options?.statusCode ?? 500;
+        this._handled = options?.handled ?? false;
+        this.sourceData = options?.sourceData;
+        // Capture stack trace - prioritize source stack, then capture new one
+        if (source.stack) {
+            this.stack = source.stack;
+        }
+        else if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, this.constructor);
+        }
+        else {
+            this.stack = new Error().stack;
+        }
+    }
+    get handled() {
+        return this._handled;
+    }
+    set handled(value) {
+        this._handled = value;
+    }
+    serializeValue(value) {
+        if (value && typeof value === 'object' && 'toJSON' in value && typeof value.toJSON === 'function') {
+            return value.toJSON();
+        }
+        if (value instanceof Error) {
+            return value.message;
+        }
+        if (Array.isArray(value)) {
+            return value.map(item => this.serializeValue(item));
+        }
+        if (value && typeof value === 'object') {
+            return Object.fromEntries(Object.entries(value).map(([k, v]) => [k, this.serializeValue(v)]));
+        }
+        return value;
+    }
+    toJSON() {
+        return {
+            name: this.name,
+            message: this.message,
+            statusCode: this.statusCode,
+            handled: this.handled,
+            stack: this.stack,
+            cause: this.serializeValue(this.cause),
+            ...(this.sourceData ? { sourceData: this.serializeValue(this.sourceData) } : {}),
+        };
+    }
+}
+exports.HandleableError = HandleableError;

package/dist/i-handleable-error-options.d.ts

@@ -0,0 +1,6 @@
+export interface HandleableErrorOptions {
+    cause?: Error;
+    handled?: boolean;
+    statusCode?: number;
+    sourceData?: unknown;
+}

package/dist/i-handleable-error-options.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/i-handleable.d.ts

@@ -0,0 +1,5 @@
+export interface IHandleable {
+    toJSON(): Record<string, unknown>;
+    get handled(): boolean;
+    set handled(value: boolean);
+}

package/dist/i-handleable.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/index.d.ts

@@ -12,6 +12,9 @@ export * from './currency-format';
 export * from './default-config';
 export * from './enum-registry';
 export * from './global-active-context';
+export * from './handleable';
+export * from './i-handleable';
+export * from './i-handleable-error-options';
 export * from './i-global-active-context';
 export * from './i18n-context';
 export * from './i18n-engine';
@@ -20,6 +23,7 @@ export * from './template';
 export * from './timezone';
 export * from './translatable-generic-error';
 export * from './typed-error';
+export * from './typed-handleable';
 export * from './types';
 export * from './utils';
 export * from './validation-config';

package/dist/index.js

@@ -31,6 +31,9 @@ __exportStar(require("./currency-format"), exports);
 __exportStar(require("./default-config"), exports);
 __exportStar(require("./enum-registry"), exports);
 __exportStar(require("./global-active-context"), exports);
+__exportStar(require("./handleable"), exports);
+__exportStar(require("./i-handleable"), exports);
+__exportStar(require("./i-handleable-error-options"), exports);
 __exportStar(require("./i-global-active-context"), exports);
 __exportStar(require("./i18n-context"), exports);
 __exportStar(require("./i18n-engine"), exports);
@@ -39,6 +42,7 @@ __exportStar(require("./template"), exports);
 __exportStar(require("./timezone"), exports);
 __exportStar(require("./translatable-generic-error"), exports);
 __exportStar(require("./typed-error"), exports);
+__exportStar(require("./typed-handleable"), exports);
 __exportStar(require("./types"), exports);
 __exportStar(require("./utils"), exports);
 __exportStar(require("./validation-config"), exports);

package/dist/translatable-handleable-generic.d.ts

@@ -0,0 +1,28 @@
+import { IHandleable } from './i-handleable';
+import { TranslatableGenericError } from './translatable-generic-error';
+/**
+ * Generic translatable error that works with any plugin engine and component
+ */
+export declare class TranslatableHandleableGenericError<TStringKey extends string = string, TLanguage extends string = string> extends TranslatableGenericError<TStringKey, TLanguage> implements IHandleable {
+    private _handled;
+    readonly cause?: Error;
+    readonly statusCode: number;
+    readonly sourceData?: unknown;
+    /**
+     * Create a translatable error
+     * @param componentId - The component ID to translate from
+     * @param stringKey - The translation key
+     * @param variables - Variables for interpolation
+     * @param language - Optional language override
+     * @param metadata - Additional error metadata
+     * @param instanceKey - Optional engine instance key
+     */
+    constructor(componentId: string, stringKey: TStringKey, variables?: Record<string, string | number>, language?: TLanguage, metadata?: Record<string, any>, instanceKey?: string, handleableOptions?: {
+        statusCode?: number;
+        cause?: Error;
+        sourceData?: unknown;
+    });
+    get handled(): boolean;
+    set handled(value: boolean);
+    toJSON(): Record<string, unknown>;
+}

package/dist/translatable-handleable-generic.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TranslatableHandleableGenericError = void 0;
+const translatable_generic_error_1 = require("./translatable-generic-error");
+/**
+ * Generic translatable error that works with any plugin engine and component
+ */
+class TranslatableHandleableGenericError extends translatable_generic_error_1.TranslatableGenericError {
+    /**
+     * Create a translatable error
+     * @param componentId - The component ID to translate from
+     * @param stringKey - The translation key
+     * @param variables - Variables for interpolation
+     * @param language - Optional language override
+     * @param metadata - Additional error metadata
+     * @param instanceKey - Optional engine instance key
+     */
+    constructor(componentId, stringKey, variables, language, metadata, instanceKey, handleableOptions) {
+        super(componentId, stringKey, variables, language, metadata, instanceKey);
+        this._handled = false;
+        this.statusCode = handleableOptions?.statusCode ?? 500;
+        this.cause = handleableOptions?.cause;
+        this.sourceData = handleableOptions?.sourceData;
+    }
+    get handled() {
+        return this._handled;
+    }
+    set handled(value) {
+        this._handled = value;
+    }
+    toJSON() {
+        return {
+            statusCode: this.statusCode,
+            message: this.message,
+            cause: this.cause,
+            sourceData: this.sourceData,
+        };
+    }
+}
+exports.TranslatableHandleableGenericError = TranslatableHandleableGenericError;

package/dist/typed-handleable.d.ts

@@ -0,0 +1,14 @@
+import { HandleableErrorOptions } from './i-handleable-error-options';
+import { IHandleable } from './i-handleable';
+import { HandleableError } from './handleable';
+import { CompleteReasonMap, TranslationEngine } from './typed-error';
+import { Language } from './default-config';
+export declare class TypedHandleableError<TEnum extends Record<string, string>, TStringKey extends string> extends HandleableError implements IHandleable {
+    readonly type: TEnum[keyof TEnum];
+    readonly reasonMap: CompleteReasonMap<TEnum, TStringKey>;
+    readonly engine: TranslationEngine<TStringKey>;
+    readonly language?: Language;
+    readonly otherVars?: Record<string, string | number>;
+    constructor(type: TEnum[keyof TEnum], reasonMap: CompleteReasonMap<TEnum, TStringKey>, engine: TranslationEngine<TStringKey>, language?: Language, otherVars?: Record<string, string | number>, options?: HandleableErrorOptions);
+    toJSON(): Record<string, unknown>;
+}

package/dist/typed-handleable.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypedHandleableError = void 0;
+const handleable_1 = require("./handleable");
+const i18n_engine_1 = require("./i18n-engine");
+const core_string_key_1 = require("./core-string-key");
+class TypedHandleableError extends handleable_1.HandleableError {
+    constructor(type, reasonMap, engine, language, otherVars, options) {
+        const key = reasonMap[type];
+        if (!key) {
+            const coreEngine = i18n_engine_1.I18nEngine.getInstance();
+            throw new Error(coreEngine.translate(core_string_key_1.CoreStringKey.Error_MissingTranslationKeyTemplate, {
+                stringKey: key,
+            }));
+        }
+        let message = String(type);
+        try {
+            const keyString = key;
+            const translated = engine.translate(keyString, otherVars, language);
+            message = String(translated || type);
+        }
+        catch (error) {
+            message = String(type);
+        }
+        super(new Error(message), options);
+        this.type = type;
+        this.reasonMap = reasonMap;
+        this.language = language;
+        this.otherVars = otherVars;
+        this.engine = engine;
+    }
+    toJSON() {
+        const baseJson = super.toJSON();
+        return {
+            ...baseJson,
+            type: this.type,
+        };
+    }
+}
+exports.TypedHandleableError = TypedHandleableError;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@digitaldefiance/i18n-lib",
-  "version": "1.3.6",
+  "version": "1.3.8",
   "description": "Generic i18n library with enum translation support",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",