@digitaldefiance/i18n-lib 3.8.1 → 3.8.3

package/src/global-active-context.ts

@@ -1,266 +0,0 @@
-import { ContextErrorType } from './context-error-type';
-import { ContextError } from './errors/context-error';
-import type { IActiveContext } from './interfaces/active-context.interface';
-import type { IGlobalActiveContext } from './interfaces/global-active-context';
-import {
-  DefaultCurrencyCode,
-  DefaultTimezone,
-  LanguageContextSpace,
-} from './types';
-import { CurrencyCode } from './utils/currency';
-import { Timezone } from './utils/timezone';
-
-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: string = '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;
-  }
-
-  // Register in globalThis for cross-module access
-  static {
-    if (typeof globalThis !== 'undefined') {
-      globalThis.GlobalActiveContext = GlobalActiveContext;
-    }
-  }
-  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/icu/ast.ts

@@ -1,56 +0,0 @@
-/**
- * ICU MessageFormat Abstract Syntax Tree (AST) types
- */
-
-export enum NodeType {
-  MESSAGE = 'MESSAGE',
-  LITERAL = 'LITERAL',
-  ARGUMENT = 'ARGUMENT',
-  PLURAL = 'PLURAL',
-  SELECT = 'SELECT',
-  SELECTORDINAL = 'SELECTORDINAL',
-}
-
-export interface BaseNode {
-  type: NodeType;
-}
-
-export interface MessageNode extends BaseNode {
-  type: NodeType.MESSAGE;
-  elements: Array<LiteralNode | ArgumentNode | PluralNode | SelectNode | SelectOrdinalNode>;
-}
-
-export interface LiteralNode extends BaseNode {
-  type: NodeType.LITERAL;
-  value: string;
-}
-
-export interface ArgumentNode extends BaseNode {
-  type: NodeType.ARGUMENT;
-  name: string;
-  format?: string;
-  style?: string;
-}
-
-export interface PluralNode extends BaseNode {
-  type: NodeType.PLURAL;
-  name: string;
-  offset?: number;
-  cases: Record<string, MessageNode>;
-}
-
-export interface SelectNode extends BaseNode {
-  type: NodeType.SELECT;
-  name: string;
-  cases: Record<string, MessageNode>;
-}
-
-export interface SelectOrdinalNode extends BaseNode {
-  type: NodeType.SELECTORDINAL;
-  name: string;
-  offset?: number;
-  cases: Record<string, MessageNode>;
-}
-
-export type ASTNode = LiteralNode | ArgumentNode | PluralNode | SelectNode | SelectOrdinalNode;
-export type ASTNodeOrMessage = MessageNode | ASTNode;

package/src/icu/compiler.ts

@@ -1,96 +0,0 @@
-import { MessageNode, NodeType, LiteralNode, ArgumentNode, PluralNode, SelectNode, SelectOrdinalNode } from './ast';
-import { FormatterRegistry } from './formatter-registry';
-import { FormatterContext } from './formatters/base-formatter';
-
-export type CompiledMessage = (values: Record<string, any>, context: FormatterContext) => string;
-
-export class Compiler {
-  private registry: FormatterRegistry;
-
-  constructor(registry?: FormatterRegistry) {
-    this.registry = registry || new FormatterRegistry();
-  }
-
-  compile(ast: MessageNode): CompiledMessage {
-    return (values: Record<string, any>, context: FormatterContext) => {
-      return this.compileMessage(ast, values, context);
-    };
-  }
-
-  private compileMessage(node: MessageNode, values: Record<string, any>, context: FormatterContext): string {
-    return node.elements.map(el => this.compileNode(el, values, context)).join('');
-  }
-
-  private compileNode(node: any, values: Record<string, any>, context: FormatterContext): string {
-    switch (node.type) {
-      case NodeType.LITERAL:
-        return (node as LiteralNode).value;
-      case NodeType.ARGUMENT:
-        return this.compileArgument(node as ArgumentNode, values, context);
-      case NodeType.PLURAL:
-        return this.compilePlural(node as PluralNode, values, context);
-      case NodeType.SELECT:
-        return this.compileSelect(node as SelectNode, values, context);
-      case NodeType.SELECTORDINAL:
-        return this.compileSelectOrdinal(node as SelectOrdinalNode, values, context);
-      default:
-        return '';
-    }
-  }
-
-  private compileArgument(node: ArgumentNode, values: Record<string, any>, context: FormatterContext): string {
-    const value = values[node.name];
-    if (value === undefined) return `{${node.name}}`;
-
-    if (!node.format) return String(value);
-
-    const formatter = this.registry.get(node.format);
-    if (!formatter) return String(value);
-
-    return formatter.format(value, node.style, context);
-  }
-
-  private compilePlural(node: PluralNode, values: Record<string, any>, context: FormatterContext): string {
-    const value = values[node.name];
-    const num = Number(value);
-    if (isNaN(num)) return this.compileMessage(node.cases.other || node.cases.one, values, context);
-
-    const formatter = this.registry.get('plural');
-    const category = formatter ? formatter.format(num, undefined, context) : 'other';
-    const caseNode = node.cases[category] || node.cases.other;
-    
-    if (!caseNode) return '';
-    
-    const result = this.compileMessage(caseNode, values, context);
-    // Format number with thousand separators using Intl.NumberFormat
-    const locale = context.locale || 'en-US';
-    const formattedNum = new Intl.NumberFormat(locale, { maximumFractionDigits: 0 }).format(num);
-    return result.replace(/#/g, formattedNum);
-  }
-
-  private compileSelect(node: SelectNode, values: Record<string, any>, context: FormatterContext): string {
-    const value = String(values[node.name] || '');
-    const caseNode = node.cases[value] || node.cases.other;
-    
-    if (!caseNode) return '';
-    return this.compileMessage(caseNode, values, context);
-  }
-
-  private compileSelectOrdinal(node: SelectOrdinalNode, values: Record<string, any>, context: FormatterContext): string {
-    const value = values[node.name];
-    const num = Number(value);
-    if (isNaN(num)) return this.compileMessage(node.cases.other, values, context);
-
-    const formatter = this.registry.get('selectordinal');
-    const category = formatter ? formatter.format(num, undefined, context) : 'other';
-    const caseNode = node.cases[category] || node.cases.other;
-    
-    if (!caseNode) return '';
-    
-    const result = this.compileMessage(caseNode, values, context);
-    // Format number with thousand separators using Intl.NumberFormat
-    const locale = context.locale || 'en-US';
-    const formattedNum = new Intl.NumberFormat(locale, { maximumFractionDigits: 0 }).format(num);
-    return result.replace(/#/g, formattedNum);
-  }
-}

package/src/icu/formatter-registry.ts

@@ -1,36 +0,0 @@
-import { Formatter } from './formatters/base-formatter';
-import { NumberFormatter } from './formatters/number-formatter';
-import { DateFormatter } from './formatters/date-formatter';
-import { TimeFormatter } from './formatters/time-formatter';
-import { PluralFormatter } from './formatters/plural-formatter';
-import { SelectFormatter } from './formatters/select-formatter';
-import { SelectOrdinalFormatter } from './formatters/selectordinal-formatter';
-
-export class FormatterRegistry {
-  private formatters = new Map<string, Formatter>();
-
-  constructor() {
-    this.registerDefaults();
-  }
-
-  private registerDefaults(): void {
-    this.register('number', new NumberFormatter());
-    this.register('date', new DateFormatter());
-    this.register('time', new TimeFormatter());
-    this.register('plural', new PluralFormatter());
-    this.register('select', new SelectFormatter());
-    this.register('selectordinal', new SelectOrdinalFormatter());
-  }
-
-  register(type: string, formatter: Formatter): void {
-    this.formatters.set(type, formatter);
-  }
-
-  get(type: string): Formatter | undefined {
-    return this.formatters.get(type);
-  }
-
-  has(type: string): boolean {
-    return this.formatters.has(type);
-  }
-}

package/src/icu/formatters/base-formatter.ts

@@ -1,8 +0,0 @@
-export interface FormatterContext {
-  locale: string;
-  [key: string]: any;
-}
-
-export interface Formatter {
-  format(value: any, style?: string, context?: FormatterContext): string;
-}

package/src/icu/formatters/date-formatter.ts

@@ -1,30 +0,0 @@
-import { Formatter, FormatterContext } from './base-formatter';
-
-export class DateFormatter implements Formatter {
-  format(value: any, style?: string, context?: FormatterContext): string {
-    const date = value instanceof Date ? value : new Date(value);
-    if (isNaN(date.getTime())) return String(value);
-
-    const locale = context?.locale || 'en-US';
-    const options: Intl.DateTimeFormatOptions = {};
-
-    switch (style) {
-      case 'short':
-        options.dateStyle = 'short';
-        break;
-      case 'medium':
-        options.dateStyle = 'medium';
-        break;
-      case 'long':
-        options.dateStyle = 'long';
-        break;
-      case 'full':
-        options.dateStyle = 'full';
-        break;
-      default:
-        options.dateStyle = 'medium';
-    }
-
-    return new Intl.DateTimeFormat(locale, options).format(date);
-  }
-}

package/src/icu/formatters/number-formatter.ts

@@ -1,32 +0,0 @@
-import { Formatter, FormatterContext } from './base-formatter';
-
-export class NumberFormatter implements Formatter {
-  format(value: any, style?: string, context?: FormatterContext): string {
-    const num = Number(value);
-    if (isNaN(num)) return String(value);
-
-    const locale = context?.locale || 'en-US';
-    const options: Intl.NumberFormatOptions = {};
-
-    switch (style) {
-      case 'integer':
-        options.maximumFractionDigits = 0;
-        break;
-      case 'currency':
-        options.style = 'currency';
-        options.currency = context?.currency || 'USD';
-        break;
-      case 'percent':
-        options.style = 'percent';
-        // Show up to 2 decimal places for percent, but don't force trailing zeros
-        options.minimumFractionDigits = 0;
-        options.maximumFractionDigits = 2;
-        break;
-      case 'decimal':
-      default:
-        break;
-    }
-
-    return new Intl.NumberFormat(locale, options).format(num);
-  }
-}

package/src/icu/formatters/plural-formatter.ts

@@ -1,12 +0,0 @@
-import { Formatter, FormatterContext } from './base-formatter';
-import { getPluralCategory } from '../../pluralization/language-plural-map';
-
-export class PluralFormatter implements Formatter {
-  format(value: any, style?: string, context?: FormatterContext): string {
-    const num = Number(value);
-    if (isNaN(num)) return 'other';
-
-    const locale = context?.locale || 'en-US';
-    return getPluralCategory(locale, num);
-  }
-}

package/src/icu/formatters/select-formatter.ts

@@ -1,7 +0,0 @@
-import { Formatter, FormatterContext } from './base-formatter';
-
-export class SelectFormatter implements Formatter {
-  format(value: any, style?: string, context?: FormatterContext): string {
-    return String(value);
-  }
-}

package/src/icu/formatters/selectordinal-formatter.ts

@@ -1,17 +0,0 @@
-import { Formatter, FormatterContext } from './base-formatter';
-
-export class SelectOrdinalFormatter implements Formatter {
-  format(value: any, style?: string, context?: FormatterContext): string {
-    const num = Number(value);
-    if (isNaN(num)) return 'other';
-
-    // English ordinal rules (1st, 2nd, 3rd, 4th, etc.)
-    const mod10 = num % 10;
-    const mod100 = num % 100;
-
-    if (mod10 === 1 && mod100 !== 11) return 'one';
-    if (mod10 === 2 && mod100 !== 12) return 'two';
-    if (mod10 === 3 && mod100 !== 13) return 'few';
-    return 'other';
-  }
-}

package/src/icu/formatters/time-formatter.ts

@@ -1,30 +0,0 @@
-import { Formatter, FormatterContext } from './base-formatter';
-
-export class TimeFormatter implements Formatter {
-  format(value: any, style?: string, context?: FormatterContext): string {
-    const date = value instanceof Date ? value : new Date(value);
-    if (isNaN(date.getTime())) return String(value);
-
-    const locale = context?.locale || 'en-US';
-    const options: Intl.DateTimeFormatOptions = {};
-
-    switch (style) {
-      case 'short':
-        options.timeStyle = 'short';
-        break;
-      case 'medium':
-        options.timeStyle = 'medium';
-        break;
-      case 'long':
-        options.timeStyle = 'long';
-        break;
-      case 'full':
-        options.timeStyle = 'full';
-        break;
-      default:
-        options.timeStyle = 'medium';
-    }
-
-    return new Intl.DateTimeFormat(locale, options).format(date);
-  }
-}

package/src/icu/helpers.ts

@@ -1,34 +0,0 @@
-import { parse } from './parser';
-import { validate, ValidationOptions } from './validator';
-import { Compiler } from './compiler';
-import { Runtime } from './runtime';
-import { MessageNode } from './ast';
-
-const defaultRuntime = new Runtime();
-
-export function isICUMessage(message: string): boolean {
-  return /\{[^}]{1,100}\}/.test(message);
-}
-
-export function parseICUMessage(message: string): MessageNode {
-  return parse(message);
-}
-
-export function compileICUMessage(message: string): ReturnType<Compiler['compile']> {
-  const ast = parse(message);
-  const compiler = new Compiler();
-  return compiler.compile(ast);
-}
-
-export function formatICUMessage(
-  message: string,
-  values: Record<string, any>,
-  locale: string = 'en-US'
-): string {
-  return defaultRuntime.format(message, values, { locale });
-}
-
-export function validateICUMessage(message: string, options?: ValidationOptions): void {
-  const ast = parse(message);
-  validate(ast, options);
-}