nfkit 1.0.9 → 1.0.11

package/dist/index.cjs

@@ -20,11 +20,16 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var index_exports = {};
 __export(index_exports, {
   AbortedError: () => AbortedError,
+  I18n: () => I18n,
+  I18nLookupMiddleware: () => I18nLookupMiddleware,
+  MiddlewareDispatcher: () => MiddlewareDispatcher,
   RoundRobin: () => RoundRobin,
   WF_NODE: () => WF_NODE,
   WorkflowDispatcher: () => WorkflowDispatcher,
   abortable: () => abortable,
+  createI18nLookupMiddleware: () => createI18nLookupMiddleware,
   dualizeAny: () => dualizeAny,
+  patchStringInObject: () => patchStringInObject,
   workflow: () => workflow
 });
 module.exports = __toCommonJS(index_exports);
@@ -775,14 +780,354 @@ function abortable(obj, signal, opts) {
   };
   return proxify(obj);
 }
+
+// src/middleware-dispatcher.ts
+var MiddlewareDispatcher = class {
+  constructor(options = {}) {
+    this.options = options;
+    this.middlewares = [];
+  }
+  middleware(mw, prior = false) {
+    if (prior) {
+      this.middlewares.unshift(mw);
+    } else {
+      this.middlewares.push(mw);
+    }
+    return this;
+  }
+  removeMiddleware(mw) {
+    const index = this.middlewares.indexOf(mw);
+    if (index >= 0) {
+      this.middlewares.splice(index, 1);
+    }
+    return this;
+  }
+  dispatch(...args) {
+    const mws = this.middlewares;
+    const acceptResult = this.options.acceptResult || ((res) => res != null);
+    const errorHandler = this.options.errorHandler || ((e, args2, next) => next());
+    const dispatch = async (i) => {
+      if (i >= mws.length) return void 0;
+      const mw = mws[i];
+      let nextCalled = false;
+      const next = async () => {
+        if (nextCalled) {
+          return void 0;
+        }
+        nextCalled = true;
+        return dispatch(i + 1);
+      };
+      const runMw = async (cb) => {
+        const res = await cb();
+        if (!nextCalled && !await acceptResult(res)) {
+          return dispatch(i + 1);
+        }
+        return res;
+      };
+      try {
+        return await runMw(() => mw(...args, next));
+      } catch (e) {
+        return await runMw(() => errorHandler(e, args, next));
+      }
+    };
+    return dispatch(0);
+  }
+};
+
+// src/utility/parse-i18n.ts
+var parseI18n = (text) => {
+  const pieces = [];
+  if (!text) return pieces;
+  let i = 0;
+  const n = text.length;
+  while (i < n) {
+    const start = text.indexOf("#{", i);
+    if (start === -1) {
+      if (i < n) pieces.push({ type: "raw", value: text.slice(i) });
+      break;
+    }
+    let j = start + 2;
+    let depth = 1;
+    while (j < n && depth > 0) {
+      const ch = text.charCodeAt(j);
+      if (ch === 123) depth++;
+      else if (ch === 125) depth--;
+      j++;
+    }
+    if (depth !== 0) {
+      pieces.push({ type: "raw", value: text.slice(i) });
+      break;
+    }
+    if (start > i) {
+      pieces.push({ type: "raw", value: text.slice(i, start) });
+    }
+    const rawInner = text.slice(start + 2, j - 1);
+    const key = rawInner.trim();
+    pieces.push({ type: "ph", rawInner, key });
+    i = j;
+  }
+  return pieces;
+};
+
+// src/patch-string-in-object.ts
+var patchStringInObject = async (obj, cb) => {
+  const visited = /* @__PURE__ */ new WeakSet();
+  const isSpecialObject = (v) => {
+    if (v == null || typeof v !== "object") return false;
+    if (v instanceof Date || v instanceof RegExp || v instanceof Map || v instanceof Set || v instanceof WeakMap || v instanceof WeakSet || v instanceof ArrayBuffer || v instanceof DataView || ArrayBuffer.isView(v)) {
+      return true;
+    }
+    const tag = Object.prototype.toString.call(v);
+    switch (tag) {
+      case "[object URL]":
+      case "[object URLSearchParams]":
+      case "[object Error]":
+      case "[object Blob]":
+      case "[object File]":
+      case "[object FormData]":
+        return true;
+      default:
+        return false;
+    }
+  };
+  const checkValue = (v) => {
+    if (!v) return { ok: false };
+    const t = typeof v;
+    if (t === "number" || t === "bigint" || t === "symbol" || t === "function") {
+      return { ok: false };
+    }
+    if (t === "string") return { ok: true, kind: "string" };
+    if (t === "object") return { ok: true, kind: "object" };
+    return { ok: false };
+  };
+  const rebuildObject = async (value) => {
+    const proto = Object.getPrototypeOf(value);
+    const out = Object.create(proto);
+    const keys = Reflect.ownKeys(value);
+    await Promise.all(
+      keys.map(async (key) => {
+        const desc = Object.getOwnPropertyDescriptor(value, key);
+        if (!desc) return;
+        if ("value" in desc) {
+          const newVal = await walk(desc.value);
+          Object.defineProperty(out, key, { ...desc, value: newVal });
+          return;
+        }
+        Object.defineProperty(out, key, desc);
+        let current = void 0;
+        if (typeof desc.get === "function") {
+          try {
+            current = desc.get.call(value);
+          } catch {
+          }
+        }
+        if (current === void 0) return;
+        try {
+          const newVal = await walk(current);
+          if (typeof desc.set === "function") {
+            try {
+              desc.set.call(out, newVal);
+            } catch {
+            }
+          }
+        } catch {
+        }
+      })
+    );
+    return out;
+  };
+  const walk = async (value) => {
+    const check = checkValue(value);
+    if (!check.ok) return value;
+    if (check.kind === "string") {
+      return cb(value);
+    }
+    if (value instanceof Promise) {
+      return value.then((resolved) => walk(resolved));
+    }
+    if (typeof value === "object") {
+      if (!Array.isArray(value) && isSpecialObject(value)) return value;
+      if (visited.has(value)) return value;
+      visited.add(value);
+      if (Array.isArray(value)) {
+        const out = await Promise.all(value.map((v) => walk(v)));
+        return out;
+      }
+      return rebuildObject(value);
+    }
+    return value;
+  };
+  return walk(obj);
+};
+
+// src/i18n/i18n.ts
+var I18n = class {
+  constructor(options) {
+    this.options = options;
+    this.locales = new Set(this.options.locales);
+    this.defaultLocale = this.options.defaultLocale ?? this.options.locales[0];
+    this.mw = new MiddlewareDispatcher({
+      acceptResult: (res) => res != null,
+      errorHandler: (e) => {
+        throw e;
+      }
+    });
+    this.shadowMiddlewares = [];
+  }
+  middleware(mw, prior = false) {
+    this.mw.middleware((locale, text, ...args) => {
+      const ex = args.slice(0, -1);
+      const next = args[args.length - 1];
+      return mw(locale, text, next, ...ex);
+    }, prior);
+    if (prior) {
+      this.shadowMiddlewares.unshift(mw);
+    } else {
+      this.shadowMiddlewares.push(mw);
+    }
+    return this;
+  }
+  removeMiddleware(mw) {
+    const idx = this.shadowMiddlewares.indexOf(mw);
+    if (idx >= 0) {
+      this.shadowMiddlewares.splice(idx, 1);
+      this.mw.middlewares.splice(idx, 1);
+    }
+    return this;
+  }
+  getExactLocale(locale) {
+    const input = (locale ?? "").trim();
+    if (!input) return this.defaultLocale;
+    if (this.locales.has(input)) return input;
+    const entries = Array.from(this.locales).map((l) => ({
+      orig: l,
+      lower: l.toLowerCase()
+    }));
+    const lower = input.toLowerCase();
+    const exact = entries.find((e) => e.lower === lower);
+    if (exact) return exact.orig;
+    const parts = lower.split("-");
+    while (parts.length > 1) {
+      parts.pop();
+      const candidate = parts.join("-");
+      const hit = entries.find((e) => e.lower === candidate);
+      if (hit) return hit.orig;
+    }
+    return this.defaultLocale;
+  }
+  buildFallbackChain(locale) {
+    const best = this.getExactLocale(locale);
+    const parts = [];
+    const segs = best.split("-");
+    for (let i = segs.length; i > 1; i--)
+      parts.push(segs.slice(0, i).join("-"));
+    parts.push(segs[0]);
+    if (!parts.includes(this.defaultLocale)) parts.push(this.defaultLocale);
+    return Array.from(new Set(parts)).filter((p) => this.locales.has(p));
+  }
+  async applyMiddlewares(locale, text, ...ex) {
+    const tryLocale = (locale2) => this.mw.dispatch(locale2, text, ...ex);
+    for (const loc of this.buildFallbackChain(locale)) {
+      const result = await tryLocale(loc);
+      if (result != null) {
+        return result;
+      }
+    }
+    return void 0;
+  }
+  async translateString(locale, text, ...ex) {
+    if (!text) return text;
+    locale = this.getExactLocale(locale);
+    const pieces = parseI18n(text);
+    if (!pieces.some((p) => p.type === "ph")) {
+      return pieces.map((p) => p.type === "raw" ? p.value : `#{${p.rawInner}}`).join("");
+    }
+    const promises = [];
+    for (const p of pieces) {
+      if (p.type === "ph") {
+        promises.push(this.applyMiddlewares(locale, p.key, ...ex));
+      }
+    }
+    const results = await Promise.all(promises);
+    let out = "";
+    let k = 0;
+    for (const p of pieces) {
+      if (p.type === "raw") {
+        out += p.value;
+      } else {
+        const r = results[k++];
+        out += r == null ? `#{${p.rawInner}}` : r;
+      }
+    }
+    return out;
+  }
+  async translate(locale, obj, ...ex) {
+    return patchStringInObject(
+      obj,
+      (s) => this.translateString(locale, s, ...ex)
+    );
+  }
+};
+
+// src/i18n/middlewares/lookup.ts
+var I18nLookupMiddleware = (dict, options) => {
+  const matchType = options?.matchType ?? "exact";
+  const dictFactory = typeof dict === "function" ? dict : () => dict;
+  const pickBestByHierarchy = (input, locales) => {
+    if (!input) return void 0;
+    const entries = locales.map((l) => ({ orig: l, lower: l.toLowerCase() }));
+    const lower = input.toLowerCase();
+    const exact = entries.find((e) => e.lower === lower);
+    if (exact) return exact.orig;
+    const parts = lower.split("-");
+    while (parts.length > 1) {
+      parts.pop();
+      const candidate = parts.join("-");
+      const hit = entries.find((e) => e.lower === candidate);
+      if (hit) return hit.orig;
+    }
+    return void 0;
+  };
+  return async (locale, key, next, ...ex) => {
+    const dictResolved = await dictFactory(locale, key, ...ex);
+    let dictionary = dictResolved[locale];
+    if (!dictionary) {
+      if (matchType === "hierarchy") {
+        const best = pickBestByHierarchy(locale, Object.keys(dictResolved));
+        if (best) dictionary = dictResolved[best];
+      } else if (matchType === "startsWith") {
+        const keys = Object.keys(dictResolved).filter(
+          (k) => locale.startsWith(k)
+        );
+        if (keys.length) {
+          const best = keys.reduce((a, b) => b.length > a.length ? b : a);
+          dictionary = dictResolved[best];
+        }
+      }
+    }
+    if (dictionary && Object.prototype.hasOwnProperty.call(dictionary, key)) {
+      const val = dictionary[key];
+      if (val != null) {
+        return val;
+      }
+    }
+    return next();
+  };
+};
+var createI18nLookupMiddleware = () => I18nLookupMiddleware;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AbortedError,
+  I18n,
+  I18nLookupMiddleware,
+  MiddlewareDispatcher,
   RoundRobin,
   WF_NODE,
   WorkflowDispatcher,
   abortable,
+  createI18nLookupMiddleware,
   dualizeAny,
+  patchStringInObject,
   workflow
 });
 //# sourceMappingURL=index.cjs.map