@kabyeon/nexusjs 0.6.5

package/dist/i18n/index.js

@@ -0,0 +1,589 @@
+// @bun
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toCommonJS = (from) => {
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __moduleCache;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __legacyDecorateClassTS = function(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;
+};
+var __legacyDecorateParamTS = (index, decorator) => (target, key) => decorator(target, key, index);
+var __legacyMetadataTS = (k, v) => {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = import.meta.require;
+
+// src/core/constants.ts
+var METADATA_KEY, PARAM_TYPES, HTTP_METHODS;
+var init_constants = __esm(() => {
+  METADATA_KEY = {
+    CONTROLLER: "nexus:controller",
+    INJECTABLE: "nexus:injectable",
+    REPOSITORY: "nexus:repository",
+    MODULE: "nexus:module",
+    ROUTES: "nexus:routes",
+    PARAMS: "nexus:params",
+    VALIDATE: "nexus:validate",
+    PARAMTYPES: "design:paramtypes",
+    TYPE: "design:type",
+    RETURNTYPE: "design:returntype",
+    INJECT: "nexus:inject"
+  };
+  PARAM_TYPES = {
+    REQUEST: 0,
+    RESPONSE: 1,
+    NEXT: 2,
+    BODY: 3,
+    QUERY: 4,
+    PARAM: 5,
+    HEADERS: 6,
+    CTX: 7,
+    USER: 8
+  };
+  HTTP_METHODS = [
+    "GET",
+    "POST",
+    "PUT",
+    "DELETE",
+    "PATCH",
+    "OPTIONS",
+    "HEAD"
+  ];
+});
+
+// src/core/decorators/params.ts
+import"reflect-metadata";
+function createParamDecorator(type, data) {
+  return (target, propertyKey, parameterIndex) => {
+    if (propertyKey !== undefined) {
+      const params = Reflect.getMetadata(METADATA_KEY.PARAMS, target, propertyKey) ?? [];
+      params.push({
+        index: parameterIndex,
+        type,
+        name: typeof data === "string" ? data : undefined,
+        data: typeof data === "object" ? data : undefined
+      });
+      Reflect.defineMetadata(METADATA_KEY.PARAMS, params, target, propertyKey);
+    } else {
+      const params = Reflect.getMetadata(METADATA_KEY.PARAMS, target) ?? [];
+      params.push({
+        index: parameterIndex,
+        type,
+        name: typeof data === "string" ? data : undefined,
+        data: typeof data === "object" ? data : undefined
+      });
+      Reflect.defineMetadata(METADATA_KEY.PARAMS, params, target);
+    }
+  };
+}
+function getParamMetadata(target, propertyKey) {
+  return Reflect.getMetadata(METADATA_KEY.PARAMS, target, propertyKey) ?? [];
+}
+var Req = () => createParamDecorator(PARAM_TYPES.REQUEST), Res = () => createParamDecorator(PARAM_TYPES.RESPONSE), Next = () => createParamDecorator(PARAM_TYPES.NEXT), Body = (key) => createParamDecorator(PARAM_TYPES.BODY, key), Query = (key) => createParamDecorator(PARAM_TYPES.QUERY, key), Param = (key) => createParamDecorator(PARAM_TYPES.PARAM, key), Headers = (key) => createParamDecorator(PARAM_TYPES.HEADERS, key), Ctx = () => createParamDecorator(PARAM_TYPES.CTX), User = () => createParamDecorator(PARAM_TYPES.USER);
+var init_params = __esm(() => {
+  init_constants();
+});
+
+// src/i18n/service.ts
+var I18N_SERVICE_TOKEN = Symbol.for("nexus:I18nService");
+
+class I18nService {
+  messages = {};
+  defaultLocale;
+  fallback;
+  fallbackToDefault;
+  supportedLocales = null;
+  pluralRulesCache = new Map;
+  dateFormatCache = new Map;
+  numberFormatCache = new Map;
+  collatorCache = new Map;
+  constructor(config = {}) {
+    this.defaultLocale = config.defaultLocale ?? "en";
+    this.fallback = config.fallback ?? true;
+    this.fallbackToDefault = config.fallbackToDefault ?? true;
+    if (config.supportedLocales && config.supportedLocales.length > 0) {
+      this.supportedLocales = new Set(config.supportedLocales);
+    }
+    if (config.messages) {
+      for (const [locale, dict] of Object.entries(config.messages)) {
+        this.addMessages(locale, dict);
+      }
+    }
+  }
+  addMessages(locale, dict) {
+    const existing = this.messages[locale] ?? {};
+    this.messages[locale] = mergeDict(existing, dict);
+  }
+  setMessages(catalog) {
+    this.messages = {};
+    for (const [locale, dict] of Object.entries(catalog)) {
+      this.addMessages(locale, dict);
+    }
+  }
+  hasMessage(key, locale = this.defaultLocale) {
+    return resolveKey(this.messages[locale], key) !== undefined;
+  }
+  getRaw(key, locale = this.defaultLocale) {
+    const value = resolveKey(this.messages[locale], key);
+    return typeof value === "string" ? value : undefined;
+  }
+  t(key, args, locale = this.defaultLocale) {
+    const raw = this.lookupRaw(key, locale);
+    if (raw === undefined) {
+      return key;
+    }
+    return this.format(raw, args, locale);
+  }
+  tOr(key, fallback, args, locale = this.defaultLocale) {
+    const raw = this.lookupRaw(key, locale);
+    if (raw === undefined)
+      return this.format(fallback, args, locale);
+    return this.format(raw, args, locale);
+  }
+  tChoice(key, count, args = {}, locale = this.defaultLocale) {
+    return this.t(key, { ...args, count }, locale);
+  }
+  format(template, args = {}, locale = this.defaultLocale) {
+    const selected = this.selectPluralForm(template, args, locale);
+    return this.interpolate(selected, args);
+  }
+  pluralCategory(count, locale = this.defaultLocale) {
+    const rules = this.getPluralRules(locale);
+    return rules.select(count);
+  }
+  formatDate(date, options = {}, locale) {
+    const useLocale = options.locale ?? locale ?? this.defaultLocale;
+    const key = `${useLocale}|${stableStringify(options)}`;
+    let fmt = this.dateFormatCache.get(key);
+    if (!fmt) {
+      fmt = new Intl.DateTimeFormat(useLocale, options);
+      this.dateFormatCache.set(key, fmt);
+    }
+    return fmt.format(typeof date === "string" ? new Date(date) : new Date(date));
+  }
+  formatNumber(value, options = {}, locale) {
+    const useLocale = options.locale ?? locale ?? this.defaultLocale;
+    const key = `${useLocale}|${stableStringify(options)}`;
+    let fmt = this.numberFormatCache.get(key);
+    if (!fmt) {
+      fmt = new Intl.NumberFormat(useLocale, options);
+      this.numberFormatCache.set(key, fmt);
+    }
+    return fmt.format(value);
+  }
+  formatCurrency(amount, options, locale) {
+    const useLocale = options.locale ?? locale ?? this.defaultLocale;
+    const { locale: _omit, ...opts } = options;
+    const key = `${useLocale}|${stableStringify(opts)}`;
+    let fmt = this.numberFormatCache.get(key);
+    if (!fmt) {
+      fmt = new Intl.NumberFormat(useLocale, { style: "currency", ...opts });
+      this.numberFormatCache.set(key, fmt);
+    }
+    return fmt.format(amount);
+  }
+  compare(a, b, locale = this.defaultLocale) {
+    let c = this.collatorCache.get(locale);
+    if (!c) {
+      c = new Intl.Collator(locale);
+      this.collatorCache.set(locale, c);
+    }
+    return c.compare(a, b);
+  }
+  getDefaultLocale() {
+    return this.defaultLocale;
+  }
+  getLocales() {
+    return Object.keys(this.messages);
+  }
+  isSupported(locale) {
+    if (!this.supportedLocales)
+      return true;
+    return this.supportedLocales.has(locale);
+  }
+  negotiateLocale(preferred = [], acceptLanguage) {
+    const candidates = [...preferred];
+    if (acceptLanguage) {
+      for (const tag of parseAcceptLanguage(acceptLanguage)) {
+        if (!candidates.includes(tag))
+          candidates.push(tag);
+      }
+    }
+    for (const cand of candidates) {
+      if (this.isSupported(cand) && this.messages[cand])
+        return cand;
+      if (this.fallback) {
+        const lang = cand.split("-")[0];
+        if (lang && lang !== cand && this.isSupported(lang) && this.messages[lang]) {
+          return lang;
+        }
+      }
+    }
+    return this.defaultLocale;
+  }
+  lookupRaw(key, locale) {
+    const v = resolveKey(this.messages[locale], key);
+    if (typeof v === "string")
+      return v;
+    if (this.fallback) {
+      const lang = locale.split("-")[0];
+      if (lang && lang !== locale) {
+        const v2 = resolveKey(this.messages[lang], key);
+        if (typeof v2 === "string")
+          return v2;
+      }
+    }
+    if (this.fallbackToDefault && locale !== this.defaultLocale) {
+      const v3 = resolveKey(this.messages[this.defaultLocale], key);
+      if (typeof v3 === "string")
+        return v3;
+    }
+    return;
+  }
+  selectPluralForm(template, args, locale) {
+    if (!template.includes("|"))
+      return template;
+    const segments = template.split("|");
+    if (segments.length === 1)
+      return template;
+    const count = pickCount(args);
+    if (count === undefined) {
+      return segments[segments.length - 1];
+    }
+    const category = this.pluralCategory(count, locale);
+    const idx = this.pluralIndex(category, segments.length);
+    return segments[idx];
+  }
+  pluralIndex(category, segmentCount) {
+    if (segmentCount <= 1)
+      return segmentCount - 1;
+    const table = {
+      2: ["one", "other"],
+      3: ["zero", "one", "other"],
+      4: ["zero", "one", "two", "other"],
+      5: ["zero", "one", "two", "few", "other"],
+      6: ["zero", "one", "two", "few", "many", "other"]
+    };
+    const cats = table[segmentCount] ?? ["other"];
+    const i = cats.indexOf(category);
+    if (i < 0)
+      return segmentCount - 1;
+    return i;
+  }
+  getPluralRules(locale) {
+    let r = this.pluralRulesCache.get(locale);
+    if (!r) {
+      try {
+        r = new Intl.PluralRules(locale);
+      } catch {
+        r = new Intl.PluralRules(this.defaultLocale);
+      }
+      this.pluralRulesCache.set(locale, r);
+    }
+    return r;
+  }
+  interpolate(template, args) {
+    if (Object.keys(args).length === 0)
+      return template;
+    return template.replace(/:([A-Za-z_][A-Za-z0-9_]*)/g, (match, name) => {
+      if (name in args) {
+        return String(args[name]);
+      }
+      return match;
+    });
+  }
+}
+function resolveKey(dict, key) {
+  if (!dict)
+    return;
+  const parts = key.split(".");
+  let cur = dict;
+  for (const p of parts) {
+    if (cur && typeof cur === "object" && p in cur) {
+      cur = cur[p];
+    } else {
+      return;
+    }
+  }
+  return cur;
+}
+function mergeDict(target, source) {
+  const out = { ...target };
+  for (const [k, v] of Object.entries(source)) {
+    const existing = out[k];
+    if (existing && typeof existing === "object" && !Array.isArray(existing) && v && typeof v === "object" && !Array.isArray(v)) {
+      out[k] = mergeDict(existing, v);
+    } else {
+      out[k] = v;
+    }
+  }
+  return out;
+}
+function pickCount(args) {
+  if ("count" in args && typeof args.count === "number")
+    return args.count;
+  for (const v of Object.values(args)) {
+    if (typeof v === "number")
+      return v;
+  }
+  return;
+}
+function parseAcceptLanguage(header) {
+  return header.split(",").map((part) => {
+    const [tag, qPart] = part.trim().split(";");
+    const q = qPart?.startsWith("q=") ? Number(qPart.slice(2)) : 1;
+    return { tag: tag?.trim() ?? "", q: isFinite(q) ? q : 1 };
+  }).filter((e) => e.tag.length > 0).sort((a, b) => b.q - a.q).map((e) => e.tag);
+}
+function stableStringify(obj) {
+  return JSON.stringify(obj, (_k, v) => {
+    if (v && typeof v === "object" && !Array.isArray(v)) {
+      const sorted = {};
+      for (const key of Object.keys(v).sort()) {
+        sorted[key] = v[key];
+      }
+      return sorted;
+    }
+    return v;
+  });
+}
+// src/core/decorators/module.ts
+init_constants();
+import"reflect-metadata";
+function Module(options = {}) {
+  return (target) => {
+    Reflect.defineMetadata(METADATA_KEY.MODULE, options, target);
+  };
+}
+function getModuleOptions(target) {
+  return Reflect.getMetadata(METADATA_KEY.MODULE, target) ?? {};
+}
+
+// src/core/decorators/injectable.ts
+init_constants();
+import"reflect-metadata";
+function Injectable(options = {}) {
+  return (target) => {
+    Reflect.defineMetadata(METADATA_KEY.INJECTABLE, true, target);
+    if (options.scope) {
+      Reflect.defineMetadata("nexus:di:scope", options.scope, target);
+    }
+  };
+}
+function isInjectable(target) {
+  return Reflect.hasMetadata(METADATA_KEY.INJECTABLE, target);
+}
+function getScope(target) {
+  return Reflect.getMetadata("nexus:di:scope", target);
+}
+function Inject(token) {
+  return (target, propertyKey, parameterIndex) => {
+    const existing = Reflect.getMetadata(METADATA_KEY.INJECT, target) ?? new Map;
+    existing.set(parameterIndex, token);
+    Reflect.defineMetadata(METADATA_KEY.INJECT, existing, target);
+  };
+}
+
+// src/i18n/module.ts
+import"reflect-metadata";
+
+// src/i18n/middleware.ts
+function i18nMiddleware(service, options = {}) {
+  const queryKey = options.queryKey ?? "lang";
+  const cookieKey = options.cookieKey ?? "lang";
+  const defaultLocale = options.defaultLocale ?? service.getDefaultLocale();
+  return async (c, next) => {
+    const fromQuery = c.req.query(queryKey);
+    const fromCookie = getCookie(c, cookieKey);
+    const acceptLanguage = c.req.header("accept-language");
+    const preferred = [];
+    if (fromQuery)
+      preferred.push(fromQuery);
+    if (fromCookie)
+      preferred.push(fromCookie);
+    if (acceptLanguage) {
+      preferred.push(...parseAcceptLanguage2(acceptLanguage));
+    }
+    preferred.push(defaultLocale);
+    const locale = service.negotiateLocale(preferred, acceptLanguage);
+    c.set("locale", locale);
+    c.set("i18n", service);
+    await next();
+  };
+}
+function getCookie(c, name) {
+  const raw = c.req.header("cookie");
+  if (!raw)
+    return;
+  for (const part of raw.split(";")) {
+    const [k, ...rest] = part.trim().split("=");
+    if (k === name)
+      return decodeURIComponent(rest.join("="));
+  }
+  return;
+}
+function parseAcceptLanguage2(header) {
+  return header.split(",").map((part) => {
+    const [tag, qPart] = part.trim().split(";");
+    const q = qPart?.startsWith("q=") ? Number(qPart.slice(2)) : 1;
+    return { tag: tag?.trim() ?? "", q: isFinite(q) ? q : 1 };
+  }).filter((e) => e.tag.length > 0).sort((a, b) => b.q - a.q).map((e) => e.tag);
+}
+
+// src/i18n/module.ts
+class I18nModule {
+  static forRoot(config = {}) {
+    const fullConfig = {
+      defaultLocale: config.defaultLocale ?? "en",
+      fallback: config.fallback ?? true,
+      fallbackToDefault: config.fallbackToDefault ?? true,
+      supportedLocales: config.supportedLocales ?? [],
+      messages: config.messages ?? {},
+      messagesDir: config.messagesDir ?? "",
+      detectQueryKey: config.detectQueryKey ?? "lang",
+      detectCookieKey: config.detectCookieKey ?? "lang"
+    };
+
+    class ConfiguredI18nModule {
+      service;
+      constructor(service) {
+        this.service = service;
+      }
+      middleware() {
+        return i18nMiddleware(this.service, {
+          queryKey: fullConfig.detectQueryKey,
+          cookieKey: fullConfig.detectCookieKey
+        });
+      }
+    }
+    ConfiguredI18nModule = __legacyDecorateClassTS([
+      Module({
+        providers: [
+          {
+            provide: I18nService,
+            useFactory: () => {
+              const svc = new I18nService({
+                defaultLocale: fullConfig.defaultLocale,
+                fallback: fullConfig.fallback,
+                fallbackToDefault: fullConfig.fallbackToDefault,
+                supportedLocales: fullConfig.supportedLocales
+              });
+              if (fullConfig.messages) {
+                svc.setMessages(fullConfig.messages);
+              }
+              if (fullConfig.messagesDir) {
+                loadFromDir(svc, fullConfig.messagesDir);
+              }
+              return svc;
+            }
+          },
+          { provide: I18N_SERVICE_TOKEN, useExisting: I18nService },
+          { provide: "I18N_CONFIG", useValue: fullConfig }
+        ],
+        exports: [I18nService, I18N_SERVICE_TOKEN, "I18N_CONFIG"]
+      }),
+      __legacyDecorateParamTS(0, Inject(I18N_SERVICE_TOKEN)),
+      __legacyMetadataTS("design:paramtypes", [
+        typeof I18nService === "undefined" ? Object : I18nService
+      ])
+    ], ConfiguredI18nModule);
+    Object.defineProperty(ConfiguredI18nModule, "name", {
+      value: "ConfiguredI18nModule"
+    });
+    ConfiguredI18nModule.install = (app) => {};
+    return ConfiguredI18nModule;
+  }
+}
+I18nModule = __legacyDecorateClassTS([
+  Module({
+    providers: [
+      I18nService,
+      { provide: I18N_SERVICE_TOKEN, useExisting: I18nService }
+    ],
+    exports: [I18nService, I18N_SERVICE_TOKEN]
+  })
+], I18nModule);
+function loadFromDir(svc, dir) {
+  let fs;
+  let path;
+  try {
+    fs = __require("fs");
+    path = __require("path");
+  } catch {
+    throw new Error("I18nModule messagesDir requires a Node-like runtime. " + "On Cloudflare Workers, register messages programmatically " + "via I18nModule.forRoot({ messages: {...} }).");
+  }
+  const stat = fs.statSync(dir);
+  if (!stat.isDirectory()) {
+    throw new Error(`I18nModule messagesDir is not a directory: ${dir}`);
+  }
+  for (const file of fs.readdirSync(dir)) {
+    if (!file.endsWith(".json"))
+      continue;
+    const locale = file.replace(/\.json$/, "");
+    const content = fs.readFileSync(path.join(dir, file), "utf8");
+    try {
+      const dict = JSON.parse(content);
+      svc.addMessages(locale, dict);
+    } catch (err) {
+      throw new Error(`I18nModule: failed to parse ${file}: ${err.message}`);
+    }
+  }
+}
+// src/i18n/decorators.ts
+init_params();
+init_constants();
+import"reflect-metadata";
+function CurrentLocale() {
+  return createParamDecorator(PARAM_TYPES.USER, {});
+}
+export {
+  i18nMiddleware,
+  I18nService,
+  I18nModule,
+  I18N_SERVICE_TOKEN,
+  CurrentLocale
+};
+
+//# debugId=1C79ABD6524A60BB64756E2164756E21
+//# sourceMappingURL=index.js.map