@digitaldefiance/i18n-lib 1.3.11 → 1.3.13

package/src/global-active-context.ts

@@ -0,0 +1,255 @@
+import { IActiveContext } from './active-context';
+import { ContextError } from './context-error';
+import { ContextErrorType } from './context-error-type';
+import { CurrencyCode } from './currency-code';
+import { DefaultLanguageCode } from './default-config';
+import { IGlobalActiveContext } from './i-global-active-context';
+import { Timezone } from './timezone';
+import {
+  DefaultCurrencyCode,
+  DefaultTimezone,
+  LanguageContextSpace,
+} from './types';
+
+export class GlobalActiveContext<TLanguage extends string, TActiveContext extends IActiveContext<TLanguage>> implements IGlobalActiveContext<TLanguage, TActiveContext> {
+  protected static _contextMap: Map<string, IActiveContext<any>> = new Map();
+  public static readonly defaultContextKey = 'default';
+  public static readonly defaultLanguage: DefaultLanguageCode = 'en-US';
+
+  private static _instance: GlobalActiveContext<any, any> | undefined;
+  public static get instance(): GlobalActiveContext<any, any> {
+    if (!this._instance) {
+      this._instance = new GlobalActiveContext<any, any>();
+      this._instance.createContext(this.defaultLanguage);
+    }
+    return this._instance;
+  }
+  public static getInstance<TLanguage extends string, TActiveContext extends IActiveContext<TLanguage>>(): GlobalActiveContext<TLanguage, TActiveContext> {
+    if (!this._instance) {
+      this._instance = new GlobalActiveContext<TLanguage, TActiveContext>();
+      this._instance.createContext(this.defaultLanguage);
+    }
+    return this._instance as GlobalActiveContext<TLanguage, TActiveContext>;
+  }
+  public static overrideInstance(instance: GlobalActiveContext<any, any>): void {
+    this._instance = instance;
+  }
+
+  public createContext(
+    defaultLanguage: TLanguage,
+    defaultAdminLanguage: TLanguage = defaultLanguage,
+    key: string = GlobalActiveContext.defaultContextKey,
+  ): TActiveContext {
+    const newContext: IActiveContext<TLanguage> = {
+      /**
+       * The language to use for translations in the user facing ui
+       */
+      language: defaultLanguage,
+      /**
+       * The language to use for console/admin logs
+       */
+      adminLanguage: defaultAdminLanguage,
+      currencyCode: new CurrencyCode(DefaultCurrencyCode),
+      /**
+       * The current default context for language translations
+       */
+      currentContext: 'user',
+      /**
+       * The timezone for the user facing UI
+       */
+      timezone: new Timezone(DefaultTimezone),
+      /**
+       * The timezone for the admin console
+       */
+      adminTimezone: new Timezone('UTC'),
+    };
+
+    GlobalActiveContext._contextMap.set(key, newContext);
+    return newContext as TActiveContext;
+  }
+
+  public getContext(
+    key: string = GlobalActiveContext.defaultContextKey,
+  ): TActiveContext {
+    const context = GlobalActiveContext._contextMap.get(
+      key,
+    ) as TActiveContext;
+    if (context) {
+      return context;
+    }
+    throw new ContextError(ContextErrorType.InvalidContext, key);
+  }
+
+  public get context(): TActiveContext {
+    return this.getContext(
+      GlobalActiveContext.defaultContextKey,
+    );
+  }
+
+  public set context(ctx: TActiveContext) {
+    GlobalActiveContext._contextMap.set(
+      GlobalActiveContext.defaultContextKey,
+      ctx,
+    );
+  }
+
+  public setUserLanguage(
+    language: TLanguage,
+    key: string = GlobalActiveContext.defaultContextKey,
+  ): void {
+    const context = GlobalActiveContext._contextMap.get(
+      key,
+    ) as IActiveContext<TLanguage>;
+    if (context) {
+      context.language = language;
+      return;
+    }
+    throw new ContextError(ContextErrorType.InvalidContext, key);
+  }
+
+  public get userLanguage(): TLanguage {
+    return this.context.language;
+  }
+
+  public set userLanguage(lang: TLanguage) {
+    this.context.language = lang;
+  }
+
+  public setCurrencyCode(
+    code: CurrencyCode,
+    key: string = GlobalActiveContext.defaultContextKey,
+  ): void {
+    const context = GlobalActiveContext._contextMap.get(
+      key,
+    ) as IActiveContext<TLanguage>;
+    if (context) {
+      context.currencyCode = code;
+      return;
+    }
+    throw new ContextError(ContextErrorType.InvalidContext, key);
+  }
+
+  public get currencyCode(): CurrencyCode {
+    return this.context.currencyCode;
+  }
+
+  public set currencyCode(code: CurrencyCode) {
+    this.context.currencyCode = code;
+  }
+
+  /**
+   * Sets the admin language for console operations
+   * @param language The language to set for admin operations
+   */
+  public setAdminLanguage(
+    language: TLanguage,
+    key: string = GlobalActiveContext.defaultContextKey,
+  ): void {
+    const context = GlobalActiveContext._contextMap.get(
+      key,
+    ) as IActiveContext<TLanguage>;
+    if (context) {
+      context.adminLanguage = language;
+      return;
+    }
+    throw new ContextError(ContextErrorType.InvalidContext, key);
+  }
+
+  public get adminLanguage(): TLanguage {
+    return this.context.adminLanguage;
+  }
+
+  public set adminLanguage(lang: TLanguage) {
+    this.context.adminLanguage = lang;
+  }
+
+  /**
+   * Sets the language context for the current context
+   * @param context The language context to set
+   */
+  public setLanguageContextSpace(
+    context: LanguageContextSpace,
+    key: string = GlobalActiveContext.defaultContextKey,
+  ): void {
+    const ctx = GlobalActiveContext._contextMap.get(
+      key,
+    ) as IActiveContext<TLanguage>;
+    if (ctx) {
+      ctx.currentContext = context;
+      return;
+    }
+    throw new ContextError(ContextErrorType.InvalidContext, key);
+  }
+
+  public getLanguageContextSpace(
+    key: string = GlobalActiveContext.defaultContextKey,
+  ): LanguageContextSpace {
+    const ctx = GlobalActiveContext._contextMap.get(
+      key,
+    ) as IActiveContext<TLanguage>;
+    if (ctx) {
+      return ctx.currentContext;
+    }
+    throw new ContextError(ContextErrorType.InvalidContext, key);
+  }
+
+  public get languageContextSpace(): LanguageContextSpace {
+    return this.context.currentContext;
+  }
+
+  public set languageContextSpace(context: LanguageContextSpace) {
+    this.context.currentContext = context;
+  }
+
+  public setUserTimezone(
+    tz: Timezone,
+    key: string = GlobalActiveContext.defaultContextKey,
+  ): void {
+    const ctx = GlobalActiveContext._contextMap.get(
+      key,
+    ) as IActiveContext<TLanguage>;
+    if (ctx) {
+      ctx.timezone = tz;
+      return;
+    }
+    throw new ContextError(ContextErrorType.InvalidContext, key);
+  }
+
+  public get userTimezone(): Timezone {
+    return this.context.timezone;
+  }
+
+  public set userTimezone(tz: Timezone) {
+    this.context.timezone = tz;
+  }
+
+  public setAdminTimezone(
+    tz: Timezone,
+    key: string = GlobalActiveContext.defaultContextKey,
+  ): void {
+    const ctx = GlobalActiveContext._contextMap.get(
+      key,
+    ) as IActiveContext<TLanguage>;
+    if (ctx) {
+      ctx.adminTimezone = tz;
+      return;
+    }
+    throw new ContextError(ContextErrorType.InvalidContext, key);
+  }
+
+  public get adminTimezone(): Timezone {
+    return this.context.adminTimezone;
+  }
+
+  public set adminTimezone(tz: Timezone) {
+    this.context.adminTimezone = tz;
+  }
+
+  /**
+   * Clear all contexts (useful for testing)
+   */
+  public static clearAll(): void {
+    GlobalActiveContext._contextMap.clear();
+    GlobalActiveContext._instance = undefined;
+  }
+}

package/src/handleable.ts

@@ -0,0 +1,79 @@
+import { IHandleable } from './i-handleable';
+import { HandleableErrorOptions } from './i-handleable-error-options';
+
+type ErrorConstructorWithStack = ErrorConstructor & {
+  captureStackTrace?: (target: Error, constructorOpt?: Function) => void;
+};
+
+export class HandleableError extends Error implements IHandleable {
+  public override readonly cause?: Error;
+  public readonly statusCode: number;
+  public readonly sourceData?: unknown;
+  private _handled: boolean;
+
+  constructor(source: Error, options?: HandleableErrorOptions) {
+    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 as ErrorConstructorWithStack).captureStackTrace) {
+      (Error as ErrorConstructorWithStack).captureStackTrace?.(
+        this,
+        this.constructor,
+      );
+    } else {
+      this.stack = new Error().stack;
+    }
+  }
+
+  public get handled(): boolean {
+    return this._handled;
+  }
+
+  public set handled(value: boolean) {
+    this._handled = value;
+  }
+
+  private serializeValue(value: unknown): unknown {
+    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;
+  }
+
+  public toJSON(): Record<string, unknown> {
+    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) }
+        : {}),
+    };
+  }
+}

package/src/i-global-active-context.ts

@@ -0,0 +1,59 @@
+import { IActiveContext } from './active-context';
+import { CurrencyCode } from './currency-code';
+import { DefaultLanguageCode } from './default-config';
+import { Timezone } from './timezone';
+import { LanguageContextSpace } from './types';
+
+export interface IGlobalActiveContext<TLanguage extends string, TActiveContext extends IActiveContext<TLanguage>> {
+  context: TActiveContext;
+  userLanguage: TLanguage;
+  currencyCode: CurrencyCode;
+  adminLanguage: TLanguage;
+  languageContextSpace: LanguageContextSpace;
+  userTimezone: Timezone;
+  adminTimezone: Timezone;
+
+  createContext(
+    defaultLanguage: TLanguage,
+    defaultAdminLanguage?: TLanguage,
+    key?: string,
+  ): TActiveContext;
+
+  getContext(
+    key?: string,
+  ): TActiveContext;
+
+  setUserLanguage(
+    language: TLanguage,
+    key?: string,
+  ): void;
+
+  setCurrencyCode(
+    code: CurrencyCode,
+    key?: string,
+  ): void;
+
+  setAdminLanguage(
+    language: TLanguage,
+    key?: string,
+  ): void;
+
+  setLanguageContextSpace(
+    context: LanguageContextSpace,
+    key?: string,
+  ): void;
+
+  getLanguageContextSpace(
+    key?: string,
+  ): LanguageContextSpace;
+
+  setUserTimezone(
+    tz: Timezone,
+    key?: string,
+  ): void;
+
+  setAdminTimezone(
+    tz: Timezone,
+    key?: string,
+  ): void;
+}

package/src/i-handleable-error-options.ts

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

package/src/i-handleable.ts

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

package/src/i18n-config.ts

@@ -0,0 +1,29 @@
+import { CurrencyCode } from './currency-code';
+import { Timezone } from './timezone';
+import {
+  LanguageCodeCollection,
+  LanguageContextSpace,
+  MasterStringsCollection,
+} from './types';
+
+/**
+ * I18n configuration interface
+ */
+export interface I18nConfig<
+  TStringKey extends string,
+  TLanguage extends string,
+  TConstants extends Record<string, any> = Record<string, any>,
+> {
+  stringNames: TStringKey[];
+  strings: MasterStringsCollection<TStringKey, TLanguage>;
+  defaultLanguage: TLanguage;
+  defaultTranslationContext: LanguageContextSpace;
+  defaultCurrencyCode: CurrencyCode;
+  languageCodes: LanguageCodeCollection<TLanguage>;
+  languages: TLanguage[];
+  constants?: TConstants;
+  enumName?: string;
+  enumObj?: Record<string, TStringKey>;
+  timezone: Timezone;
+  adminTimezone: Timezone;
+}

package/{dist/i18n-context.d.ts → src/i18n-context.ts}

@@ -1,14 +1,15 @@
 import { CurrencyCode } from './currency-code';
 import { Timezone } from './timezone';
 import { LanguageContextSpace } from './types';
+
 /**
  * I18n context interface
  */
 export interface I18nContext<TLanguage extends string> {
-    language: TLanguage;
-    adminLanguage: TLanguage;
-    currencyCode: CurrencyCode;
-    currentContext: LanguageContextSpace;
-    timezone: Timezone;
-    adminTimezone: Timezone;
+  language: TLanguage;
+  adminLanguage: TLanguage;
+  currencyCode: CurrencyCode;
+  currentContext: LanguageContextSpace;
+  timezone: Timezone;
+  adminTimezone: Timezone;
 }