@zucker-framework/i18n 1.0.0

package/dist/index.mjs

@@ -0,0 +1,636 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// src/message-source.ts
+import { readFileSync, existsSync } from "fs";
+import { join } from "path";
+import { Logger } from "@nestjs/common";
+var FileMessageSource = class _FileMessageSource {
+  static {
+    __name(this, "FileMessageSource");
+  }
+  basePath;
+  logger = new Logger(_FileMessageSource.name);
+  messages = /* @__PURE__ */ new Map();
+  defaultLocale;
+  constructor(basePath, options) {
+    this.basePath = basePath;
+    this.defaultLocale = options?.defaultLocale ?? "en";
+  }
+  getMessage(code, args, defaultMessage, locale) {
+    const loc = locale ?? this.defaultLocale;
+    const messages = this.loadLocale(loc);
+    let message = messages[code];
+    if (message === void 0 && loc !== this.defaultLocale) {
+      const defaultMessages = this.loadLocale(this.defaultLocale);
+      message = defaultMessages[code];
+    }
+    if (message === void 0) {
+      return defaultMessage ?? code;
+    }
+    return this.interpolate(message, args);
+  }
+  loadLocale(locale) {
+    if (this.messages.has(locale)) {
+      return this.messages.get(locale);
+    }
+    const filePath = join(this.basePath, `${locale}.json`);
+    if (!existsSync(filePath)) {
+      this.messages.set(locale, {});
+      return {};
+    }
+    try {
+      const content = readFileSync(filePath, "utf-8");
+      const data = JSON.parse(content);
+      const flat = this.flatten(data);
+      this.messages.set(locale, flat);
+      return flat;
+    } catch (err) {
+      this.logger.warn(`Failed to load i18n messages for locale "${locale}": ${err instanceof Error ? err.message : String(err)}`);
+      this.messages.set(locale, {});
+      return {};
+    }
+  }
+  flatten(obj, prefix = "") {
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+      const fullKey = prefix ? `${prefix}.${key}` : key;
+      if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+        Object.assign(result, this.flatten(value, fullKey));
+      } else {
+        result[fullKey] = String(value);
+      }
+    }
+    return result;
+  }
+  interpolate(message, args) {
+    if (!args || args.length === 0) return message;
+    return message.replace(/\{(\d+)\}/g, (match, index) => {
+      const idx = parseInt(index, 10);
+      return idx < args.length ? String(args[idx]) : match;
+    });
+  }
+  clearCache() {
+    this.messages.clear();
+  }
+};
+var CompositeMessageSource = class {
+  static {
+    __name(this, "CompositeMessageSource");
+  }
+  sources;
+  constructor(sources) {
+    this.sources = sources;
+  }
+  getMessage(code, args, defaultMessage, locale) {
+    for (const source of this.sources) {
+      const message = source.getMessage(code, args, void 0, locale);
+      if (message !== code) {
+        return message;
+      }
+    }
+    return defaultMessage ?? code;
+  }
+  addSource(source) {
+    this.sources.push(source);
+  }
+  /**
+  * Add multiple sources at once.
+  */
+  addSources(sources) {
+    this.sources.push(...sources);
+  }
+  /**
+  * Get the number of registered sources.
+  */
+  getSourceCount() {
+    return this.sources.length;
+  }
+};
+
+// src/locale-context.ts
+import { AsyncLocalStorage } from "async_hooks";
+import { Injectable } from "@nestjs/common";
+import { Observable } from "rxjs";
+function _ts_decorate(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") {
+    r = Reflect.decorate(decorators, target, key, desc);
+  } else {
+    for (var i = decorators.length - 1; i >= 0; i--) {
+      if (d = decorators[i]) {
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+      }
+    }
+  }
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate, "_ts_decorate");
+function _ts_metadata(metadataKey, metadataValue) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") {
+    return Reflect.metadata(metadataKey, metadataValue);
+  }
+}
+__name(_ts_metadata, "_ts_metadata");
+var localeStorage = new AsyncLocalStorage();
+var LocaleContext = class {
+  static {
+    __name(this, "LocaleContext");
+  }
+  static defaultLocale = "en";
+  static setDefault(locale) {
+    this.defaultLocale = locale;
+  }
+  static getCurrent() {
+    return localeStorage.getStore() ?? this.defaultLocale;
+  }
+  static run(locale, fn) {
+    return localeStorage.run(locale, fn);
+  }
+  static runAsync(locale, fn) {
+    return localeStorage.run(locale, fn);
+  }
+};
+var LocaleInterceptor = class {
+  static {
+    __name(this, "LocaleInterceptor");
+  }
+  supportedLocales;
+  defaultLocale;
+  constructor(options) {
+    this.supportedLocales = new Set(options?.supportedLocales ?? [
+      "en",
+      "zh"
+    ]);
+    this.defaultLocale = options?.defaultLocale ?? "en";
+  }
+  intercept(context, next) {
+    const request = context.switchToHttp().getRequest();
+    const acceptLanguage = request.headers?.["accept-language"] ?? "";
+    const locale = this.parseLocale(acceptLanguage);
+    return new Observable((subscriber) => {
+      LocaleContext.runAsync(locale, async () => {
+        return new Promise((resolve, reject) => {
+          next.handle().subscribe({
+            next: /* @__PURE__ */ __name((value) => subscriber.next(value), "next"),
+            error: /* @__PURE__ */ __name((err) => {
+              subscriber.error(err);
+              reject(err);
+            }, "error"),
+            complete: /* @__PURE__ */ __name(() => {
+              subscriber.complete();
+              resolve();
+            }, "complete")
+          });
+        });
+      }).catch((err) => subscriber.error(err));
+    });
+  }
+  parseLocale(header) {
+    if (!header) return this.defaultLocale;
+    const parts = header.split(",").map((part) => {
+      const [lang, q] = part.trim().split(";q=");
+      return {
+        lang: lang.trim().split("-")[0].toLowerCase(),
+        quality: q ? parseFloat(q) : 1
+      };
+    });
+    parts.sort((a, b) => b.quality - a.quality);
+    for (const { lang } of parts) {
+      if (this.supportedLocales.has(lang)) {
+        return lang;
+      }
+    }
+    return this.defaultLocale;
+  }
+};
+LocaleInterceptor = _ts_decorate([
+  Injectable(),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    Object
+  ])
+], LocaleInterceptor);
+
+// src/i18n-exception.ts
+import { BusinessException } from "@zucker-framework/core";
+var I18nException = class extends BusinessException {
+  static {
+    __name(this, "I18nException");
+  }
+  i18nCode;
+  i18nArgs;
+  constructor(code, args = [], fallbackMessage) {
+    super(fallbackMessage ?? code, code);
+    this.i18nCode = code;
+    this.i18nArgs = args;
+  }
+};
+
+// src/i18n-spec.ts
+var I18nSpec = class _I18nSpec {
+  static {
+    __name(this, "I18nSpec");
+  }
+  /** i18n message code; if empty, defaultMessage is returned as-is */
+  code;
+  /** Fallback message when code is not found or not provided */
+  defaultMessage;
+  /** Nested i18n-aware arguments */
+  args;
+  constructor(code, defaultMessage, args = []) {
+    this.code = code;
+    this.defaultMessage = defaultMessage;
+    this.args = args;
+  }
+  /**
+  * Create an I18nSpec with optional nested args.
+  * Args can be strings (treated as plain defaults) or I18nSpec instances.
+  */
+  static of(code, defaultMessage, ...args) {
+    const specArgs = args.map((arg) => {
+      if (typeof arg === "string") {
+        return new _I18nSpec(void 0, arg);
+      }
+      return arg;
+    });
+    return new _I18nSpec(code, defaultMessage, specArgs);
+  }
+  /**
+  * Add a nested i18n argument.
+  */
+  withArg(code, defaultMessage, ...args) {
+    this.args.push(_I18nSpec.of(code, defaultMessage, ...args));
+    return this;
+  }
+  /**
+  * Add an existing I18nSpec as a nested argument.
+  */
+  withArgSpec(spec) {
+    this.args.push(spec);
+    return this;
+  }
+  /**
+  * Resolve this spec to a final message using the given MessageSource.
+  * Recursively resolves nested args first.
+  */
+  resolve(messageSource, locale) {
+    const currentLocale = locale ?? LocaleContext.getCurrent();
+    if (this.args.length === 0) {
+      return this.resolveMessage(messageSource, currentLocale);
+    }
+    const resolvedArgs = this.args.map((arg) => arg.resolve(messageSource, currentLocale));
+    return this.resolveMessage(messageSource, currentLocale, resolvedArgs);
+  }
+  /**
+  * Create a shallow copy of this spec.
+  */
+  copy() {
+    return new _I18nSpec(this.code, this.defaultMessage, this.args.map((a) => a.copy()));
+  }
+  resolveMessage(messageSource, locale, resolvedArgs) {
+    if (!this.code) {
+      return this.defaultMessage ?? "";
+    }
+    return messageSource.getMessage(this.code, resolvedArgs, this.defaultMessage, locale);
+  }
+};
+
+// src/locale-utils.ts
+function formatMessage(template, params) {
+  if (Array.isArray(params)) {
+    return template.replace(/\{(\d+)\}/g, (match, index) => {
+      const idx = parseInt(index, 10);
+      return idx < params.length ? String(params[idx]) : match;
+    });
+  }
+  return template.replace(/\{(\w+)\}/g, (match, key) => {
+    return key in params ? String(params[key]) : match;
+  });
+}
+__name(formatMessage, "formatMessage");
+function pluralize(count, forms, locale) {
+  let form;
+  if (count === 0 && forms.zero !== void 0) {
+    form = forms.zero;
+  } else if (count === 1 && forms.one !== void 0) {
+    form = forms.one;
+  } else {
+    form = forms.other;
+  }
+  const loc = locale ?? LocaleContext.getCurrent();
+  const formatted = new Intl.NumberFormat(loc).format(count);
+  return form.replace(/\{count\}/g, formatted);
+}
+__name(pluralize, "pluralize");
+function formatDate(date, style = "medium", locale) {
+  const loc = locale ?? LocaleContext.getCurrent();
+  const d = typeof date === "number" ? new Date(date) : date;
+  return new Intl.DateTimeFormat(loc, {
+    dateStyle: style
+  }).format(d);
+}
+__name(formatDate, "formatDate");
+function formatNumber(value, style = "decimal", options, locale) {
+  const loc = locale ?? LocaleContext.getCurrent();
+  const opts = {
+    style
+  };
+  if (style === "currency") {
+    opts.currency = options?.currency ?? "USD";
+  }
+  return new Intl.NumberFormat(loc, opts).format(value);
+}
+__name(formatNumber, "formatNumber");
+function formatRelativeTime(date, locale) {
+  const loc = locale ?? LocaleContext.getCurrent();
+  const d = typeof date === "number" ? new Date(date) : date;
+  const diffMs = d.getTime() - Date.now();
+  const units = [
+    [
+      "year",
+      365 * 24 * 60 * 60 * 1e3
+    ],
+    [
+      "month",
+      30 * 24 * 60 * 60 * 1e3
+    ],
+    [
+      "week",
+      7 * 24 * 60 * 60 * 1e3
+    ],
+    [
+      "day",
+      24 * 60 * 60 * 1e3
+    ],
+    [
+      "hour",
+      60 * 60 * 1e3
+    ],
+    [
+      "minute",
+      60 * 1e3
+    ],
+    [
+      "second",
+      1e3
+    ]
+  ];
+  const rtf = new Intl.RelativeTimeFormat(loc, {
+    numeric: "auto"
+  });
+  for (const [unit, ms] of units) {
+    if (Math.abs(diffMs) >= ms) {
+      const value = Math.round(diffMs / ms);
+      return rtf.format(value, unit);
+    }
+  }
+  return rtf.format(0, "second");
+}
+__name(formatRelativeTime, "formatRelativeTime");
+var LocaleUtils = class {
+  static {
+    __name(this, "LocaleUtils");
+  }
+  static messageSource = null;
+  /**
+  * Set the global message source used by resolve helpers.
+  */
+  static setMessageSource(source) {
+    this.messageSource = source;
+  }
+  /**
+  * Get the currently configured global message source.
+  */
+  static getMessageSource() {
+    return this.messageSource;
+  }
+  /**
+  * Resolve a message using the current locale context.
+  */
+  static resolveMessage(code, ...args) {
+    return this.resolveMessageWithDefault(code, code, ...args);
+  }
+  /**
+  * Resolve a message with a default fallback using the current locale context.
+  */
+  static resolveMessageWithDefault(code, defaultMessage, ...args) {
+    if (!this.messageSource) {
+      return defaultMessage;
+    }
+    const locale = LocaleContext.getCurrent();
+    return this.messageSource.getMessage(code, args, defaultMessage, locale);
+  }
+  /**
+  * Resolve a message using a specific MessageSource and the current locale.
+  */
+  static resolveMessageFrom(source, code, defaultMessage, ...args) {
+    const locale = LocaleContext.getCurrent();
+    return source.getMessage(code, args, defaultMessage, locale);
+  }
+  /**
+  * Resolve a message using a specific locale (ignoring the context locale).
+  */
+  static resolveMessageForLocale(code, locale, defaultMessage, ...args) {
+    if (!this.messageSource) {
+      return defaultMessage ?? code;
+    }
+    return this.messageSource.getMessage(code, args, defaultMessage, locale);
+  }
+  /**
+  * Execute a function within a specific locale context.
+  */
+  static doWith(locale, fn) {
+    return LocaleContext.run(locale, fn);
+  }
+  /**
+  * Execute an async function within a specific locale context.
+  */
+  static doWithAsync(locale, fn) {
+    return LocaleContext.runAsync(locale, fn);
+  }
+  /**
+  * Get the current locale.
+  */
+  static current() {
+    return LocaleContext.getCurrent();
+  }
+};
+
+// src/decorators.ts
+var i18nRegistry = /* @__PURE__ */ new Map();
+function makeKey(target, propertyKey) {
+  const ctorName = target.constructor?.name ?? "Unknown";
+  return `${ctorName}.${String(propertyKey)}`;
+}
+__name(makeKey, "makeKey");
+function I18n(code) {
+  return (target, propertyKey) => {
+    i18nRegistry.set(makeKey(target, propertyKey), code);
+  };
+}
+__name(I18n, "I18n");
+function getI18nCode(target, propertyKey) {
+  return i18nRegistry.get(makeKey(target, propertyKey));
+}
+__name(getI18nCode, "getI18nCode");
+function hasI18n(target, propertyKey) {
+  return i18nRegistry.has(makeKey(target, propertyKey));
+}
+__name(hasI18n, "hasI18n");
+
+// src/i18n.module.ts
+import { Module, Global } from "@nestjs/common";
+function _ts_decorate2(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") {
+    r = Reflect.decorate(decorators, target, key, desc);
+  } else {
+    for (var i = decorators.length - 1; i >= 0; i--) {
+      if (d = decorators[i]) {
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+      }
+    }
+  }
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate2, "_ts_decorate");
+var MESSAGE_SOURCE = "MESSAGE_SOURCE";
+var I18N_MODULE_OPTIONS = /* @__PURE__ */ Symbol("I18N_MODULE_OPTIONS");
+var ZuckerI18nModule = class _ZuckerI18nModule {
+  static {
+    __name(this, "ZuckerI18nModule");
+  }
+  static forRoot(options = {}) {
+    return {
+      module: _ZuckerI18nModule,
+      global: true,
+      providers: _ZuckerI18nModule.buildProviders(options),
+      exports: [
+        MESSAGE_SOURCE,
+        LocaleInterceptor
+      ]
+    };
+  }
+  static forRootAsync(options) {
+    const asyncProviders = this.createAsyncProviders(options);
+    return {
+      module: _ZuckerI18nModule,
+      global: true,
+      imports: options.imports ?? [],
+      providers: [
+        ...asyncProviders,
+        {
+          provide: MESSAGE_SOURCE,
+          useFactory: /* @__PURE__ */ __name((opts) => {
+            const sources = [];
+            if (opts.basePath) {
+              sources.push(new FileMessageSource(opts.basePath, {
+                defaultLocale: opts.defaultLocale
+              }));
+            }
+            if (opts.messageSources) {
+              sources.push(...opts.messageSources);
+            }
+            return sources.length === 1 ? sources[0] : new CompositeMessageSource(sources);
+          }, "useFactory"),
+          inject: [
+            I18N_MODULE_OPTIONS
+          ]
+        },
+        {
+          provide: LocaleInterceptor,
+          useFactory: /* @__PURE__ */ __name((opts) => new LocaleInterceptor({
+            supportedLocales: opts.supportedLocales,
+            defaultLocale: opts.defaultLocale
+          }), "useFactory"),
+          inject: [
+            I18N_MODULE_OPTIONS
+          ]
+        }
+      ],
+      exports: [
+        MESSAGE_SOURCE,
+        LocaleInterceptor
+      ]
+    };
+  }
+  static buildProviders(options) {
+    const providers = [];
+    const sources = [];
+    if (options.basePath) {
+      sources.push(new FileMessageSource(options.basePath, {
+        defaultLocale: options.defaultLocale
+      }));
+    }
+    if (options.messageSources) {
+      sources.push(...options.messageSources);
+    }
+    const messageSource = sources.length === 1 ? sources[0] : new CompositeMessageSource(sources);
+    providers.push({
+      provide: MESSAGE_SOURCE,
+      useValue: messageSource
+    });
+    providers.push({
+      provide: LocaleInterceptor,
+      useValue: new LocaleInterceptor({
+        supportedLocales: options.supportedLocales,
+        defaultLocale: options.defaultLocale
+      })
+    });
+    return providers;
+  }
+  static createAsyncProviders(options) {
+    if (options.useFactory) {
+      return [
+        {
+          provide: I18N_MODULE_OPTIONS,
+          useFactory: options.useFactory,
+          inject: options.inject ?? []
+        }
+      ];
+    }
+    const optionsProvider = {
+      provide: I18N_MODULE_OPTIONS,
+      useFactory: /* @__PURE__ */ __name(async (factory) => factory.createI18nOptions(), "useFactory"),
+      inject: [
+        options.useClass ?? options.useExisting
+      ]
+    };
+    if (options.useClass) {
+      return [
+        {
+          provide: options.useClass,
+          useClass: options.useClass
+        },
+        optionsProvider
+      ];
+    }
+    return [
+      optionsProvider
+    ];
+  }
+};
+ZuckerI18nModule = _ts_decorate2([
+  Global(),
+  Module({})
+], ZuckerI18nModule);
+export {
+  CompositeMessageSource,
+  FileMessageSource,
+  I18n,
+  I18nException,
+  I18nSpec,
+  LocaleContext,
+  LocaleInterceptor,
+  LocaleUtils,
+  MESSAGE_SOURCE,
+  ZuckerI18nModule,
+  formatDate,
+  formatMessage,
+  formatNumber,
+  formatRelativeTime,
+  getI18nCode,
+  hasI18n,
+  pluralize
+};

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@zucker-framework/i18n",
+  "version": "1.0.0",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "LICENSE",
+    "NOTICE",
+    "THIRD_PARTY_NOTICES"
+  ],
+  "dependencies": {
+    "@zucker-framework/core": "1.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.19.43"
+  },
+  "peerDependencies": {
+    "@nestjs/common": "^12.0.0",
+    "@nestjs/core": "^12.0.0",
+    "rxjs": "^7.0.0"
+  },
+  "license": "Apache-2.0",
+  "author": "Lind",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Lind-pro/zucker-framework.git",
+    "directory": "packages/i18n"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs,esm --dts",
+    "clean": "rm -rf dist",
+    "lint": "eslint src/"
+  }
+}