nfkit 1.0.8 → 1.0.10

package/dist/index.cjs

@@ -20,10 +20,14 @@ 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,
   workflow: () => workflow
 });
@@ -697,7 +701,7 @@ function abortable(obj, signal, opts) {
         shortCircuit = true;
       }
     }
-    if (typeof value.then === "function") {
+    if (typeof value?.then === "function") {
       return wrapNativePromise(value);
     }
     if (!isObjectLike(value)) {
@@ -775,13 +779,347 @@ 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/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) {
+    const visited = /* @__PURE__ */ new WeakSet();
+    const isBuiltInObject = (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 translateObjectPreservingProto = 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 visit(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 visit(current);
+            if (typeof desc.set === "function") {
+              try {
+                desc.set.call(out, newVal);
+              } catch {
+              }
+            }
+          } catch {
+          }
+        })
+      );
+      return out;
+    };
+    const isTranslatable = (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 visit = async (value) => {
+      const check = isTranslatable(value);
+      if (!check.ok) {
+        return value;
+      }
+      if (check.kind === "string") {
+        return this.translateString(locale, value, ...ex);
+      }
+      if (value instanceof Promise) {
+        return value.then((resolved) => visit(resolved));
+      }
+      if (typeof value === "object") {
+        if (!Array.isArray(value) && isBuiltInObject(value)) return value;
+        if (visited.has(value)) return value;
+        visited.add(value);
+        if (Array.isArray(value)) {
+          const out = await Promise.all(value.map((v) => visit(v)));
+          return out;
+        }
+        return translateObjectPreservingProto(value);
+      }
+      return value;
+    };
+    return visit(obj);
+  }
+};
+
+// 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,
   workflow
 });