nfkit 1.0.19 → 1.0.21

package/dist/index.cjs

@@ -20,6 +20,9 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var index_exports = {};
 __export(index_exports, {
   AbortedError: () => AbortedError,
+  AppContextCore: () => AppContextCore,
+  AppServiceBase: () => AppServiceBase,
+  DUAL_PENDING: () => DUAL_PENDING,
   DynamicMiddlewareDispatcher: () => DynamicMiddlewareDispatcher,
   I18n: () => I18n,
   I18nLookupMiddleware: () => I18nLookupMiddleware,
@@ -30,11 +33,13 @@ __export(index_exports, {
   WF_NODE: () => WF_NODE,
   WorkflowDispatcher: () => WorkflowDispatcher,
   abortable: () => abortable,
+  createAppContext: () => createAppContext,
   createI18nLookupMiddleware: () => createI18nLookupMiddleware,
   dualizeAny: () => dualizeAny,
   makeArray: () => makeArray,
   observeDiff: () => observeDiff,
   patchStringInObject: () => patchStringInObject,
+  throwDualPending: () => throwDualPending,
   workflow: () => workflow
 });
 module.exports = __toCommonJS(index_exports);
@@ -130,6 +135,10 @@ function makeProxy(node) {
 }
 
 // src/dual-object.ts
+var DUAL_PENDING = Symbol("dual.pending");
+var throwDualPending = () => {
+  throw DUAL_PENDING;
+};
 var isThenKey = (k) => k === "then" || k === "catch" || k === "finally";
 function dualizeAny(sync, asyncFn, options) {
   let state = "undecided";
@@ -163,6 +172,10 @@ function dualizeAny(sync, asyncFn, options) {
         value = sync();
         state = "fulfilled";
       } catch (e) {
+        if (e === DUAL_PENDING) {
+          startAsync();
+          return;
+        }
         reason = e;
         state = "rejected";
       }
@@ -221,6 +234,9 @@ function dualizeAny(sync, asyncFn, options) {
         case "undecided": {
           ensureSync();
           if (state === "fulfilled") return getFrom(value, prop);
+          if (state === "pending") {
+            throw new TypeError("Value is not ready yet. Please await it first.");
+          }
           if (state === "rejected") throw reason;
           throw new TypeError("Invalid state transition");
         }
@@ -1043,36 +1059,44 @@ var patchStringInObject = async (obj, cb) => {
 };
 
 // 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({
+var I18nMiddlewareDispatcher = class extends DynamicMiddlewareDispatcher {
+  constructor() {
+    super({
       acceptResult: (res) => res != null,
       errorHandler: (e) => {
         throw e;
       }
     });
-    this.shadowMiddlewares = [];
+    this.middlewares = [];
+  }
+  async buildMiddlewares() {
+    return this.middlewares.map(
+      (mw) => (locale, text, ...args) => {
+        const ex = args.slice(0, -1);
+        const next = args[args.length - 1];
+        return mw(locale, text, next, ...ex);
+      }
+    );
+  }
+};
+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 I18nMiddlewareDispatcher();
   }
   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);
+      this.mw.middlewares.unshift(mw);
     } else {
-      this.shadowMiddlewares.push(mw);
+      this.mw.middlewares.push(mw);
     }
     return this;
   }
   removeMiddleware(mw) {
-    const idx = this.shadowMiddlewares.indexOf(mw);
+    const idx = this.mw.middlewares.indexOf(mw);
     if (idx >= 0) {
-      this.shadowMiddlewares.splice(idx, 1);
       this.mw.middlewares.splice(idx, 1);
     }
     return this;
@@ -1223,11 +1247,11 @@ var observeDiff = (obj, cb) => {
 // src/memorize.ts
 var Memorize = () => {
   const cache = /* @__PURE__ */ new WeakMap();
-  const isPromiseLike = (v) => v != null && typeof v.then === "function" && typeof v.catch === "function";
+  const isPromiseLike2 = (v) => v != null && typeof v.then === "function" && typeof v.catch === "function";
   const getOrSet = (instance, compute) => {
     if (cache.has(instance)) return cache.get(instance);
     const result = compute();
-    if (isPromiseLike(result)) {
+    if (isPromiseLike2(result)) {
       const wrapped = result.catch((err) => {
         cache.delete(instance);
         throw err;
@@ -1260,9 +1284,272 @@ var Memorize = () => {
 var makeArray = (value) => {
   return Array.isArray(value) ? value : [value];
 };
+
+// src/app-context/promise-utils.ts
+var promiseStates = /* @__PURE__ */ new WeakMap();
+var isPromiseLike = (value) => !!value && typeof value.then === "function";
+var trackPromise = (promise) => {
+  const existing = promiseStates.get(promise);
+  if (existing) return existing;
+  const state = { status: "pending" };
+  promiseStates.set(promise, state);
+  promise.then(
+    (value) => {
+      state.status = "fulfilled";
+      state.value = value;
+    },
+    (error) => {
+      state.status = "rejected";
+      state.error = error;
+    }
+  );
+  return state;
+};
+var wrapMaybePromise = (value, options) => {
+  if (!isPromiseLike(value)) return value;
+  const promise = Promise.resolve(value);
+  const state = trackPromise(promise);
+  if (state.status === "fulfilled") return state.value;
+  if (state.status === "rejected") throw state.error;
+  return dualizeAny(
+    () => {
+      const current = trackPromise(promise);
+      if (current.status === "fulfilled") return current.value;
+      if (current.status === "rejected") throw current.error;
+      throwDualPending();
+    },
+    () => promise,
+    {
+      // Intentionally hide strict method return type here.
+      asyncMethods: Array.from(options?.methodKeys ?? [])
+    }
+  );
+};
+var createAsyncMethod = (inst, key) => (...args) => Promise.resolve(inst).then((resolved) => {
+  const fn = resolved?.[key];
+  if (typeof fn !== "function") {
+    throw new TypeError("Target method is not a function");
+  }
+  return fn.apply(resolved, args);
+});
+
+// src/app-context/app-context.ts
+var ProvidePrefix = "provide:";
+var getMethodDescriptor = (cls, key) => {
+  let proto = cls.prototype;
+  while (proto && proto !== Object.prototype) {
+    const desc = Object.getOwnPropertyDescriptor(proto, key);
+    if (desc) return desc;
+    proto = Object.getPrototypeOf(proto);
+  }
+  return void 0;
+};
+var flushPendingSets = (entry) => {
+  if (isPromiseLike(entry.inst)) return;
+  if (!entry.pendingSets.length) return;
+  for (const item of entry.pendingSets) {
+    entry.inst[item.key] = item.value;
+  }
+  entry.pendingSets.length = 0;
+};
+var resolveEntryIfNeeded = async (entry) => {
+  if (isPromiseLike(entry.inst)) {
+    entry.inst = await entry.inst;
+  }
+  flushPendingSets(entry);
+  return entry.inst;
+};
+var AppContextCore = class {
+  constructor() {
+    this.registry = /* @__PURE__ */ new Map();
+    this.loadSeq = [];
+    this.objectSteps = [];
+  }
+  provide(cls, ...args) {
+    const last = args[args.length - 1];
+    const hasOptions = !!last && typeof last === "object" && ("provide" in last || "merge" in last || "useValue" in last || "useFactory" in last || "useClass" in last);
+    const options = hasOptions ? last : void 0;
+    const _args = hasOptions ? args.slice(0, -1) : args;
+    const inst = options?.useValue ?? (options?.useFactory ? options.useFactory(this, ..._args) : new (options?.useClass ?? cls)(this, ..._args));
+    const classRef = cls;
+    const provideKey = options?.provide ? ProvidePrefix + String(options.provide) : void 0;
+    const methodKeys = /* @__PURE__ */ new Set();
+    for (const name of Object.getOwnPropertyNames(cls.prototype)) {
+      if (name === "constructor") continue;
+      const desc = Object.getOwnPropertyDescriptor(cls.prototype, name);
+      if (desc && typeof desc.value === "function") {
+        methodKeys.add(name);
+      }
+    }
+    const entry = {
+      classRef,
+      inst,
+      methodKeys,
+      pendingSets: []
+    };
+    this.registry.set(classRef, entry);
+    if (provideKey) this.registry.set(provideKey, entry);
+    this.loadSeq.push(entry);
+    if (options?.provide) {
+      const prop = options.provide;
+      const step = (ctx) => {
+        Object.defineProperty(ctx, prop, {
+          enumerable: true,
+          configurable: true,
+          get: () => {
+            const currentEntry = ctx.registry.get(classRef);
+            return wrapMaybePromise(currentEntry?.inst, { methodKeys });
+          }
+        });
+      };
+      step(this);
+      this.objectSteps.push(step);
+    }
+    if (options?.merge?.length) {
+      for (const key of options.merge) {
+        const desc = getMethodDescriptor(cls, key);
+        const isMethod = !!desc && typeof desc.value === "function";
+        const step = (ctx) => {
+          if (isMethod) {
+            Object.defineProperty(ctx, key, {
+              enumerable: true,
+              configurable: true,
+              get: () => {
+                const currentEntry = ctx.registry.get(classRef);
+                const currentInst = currentEntry?.inst;
+                if (isPromiseLike(currentInst))
+                  return createAsyncMethod(currentInst, key);
+                const fn = currentInst?.[key];
+                return typeof fn === "function" ? fn.bind(currentInst) : fn;
+              }
+            });
+            return;
+          }
+          Object.defineProperty(ctx, key, {
+            enumerable: true,
+            configurable: true,
+            get: () => {
+              const currentEntry = ctx.registry.get(classRef);
+              const target = wrapMaybePromise(currentEntry?.inst);
+              return target?.[key];
+            },
+            set: (value) => {
+              const currentEntry = ctx.registry.get(classRef);
+              if (!currentEntry) return;
+              if (!isPromiseLike(currentEntry.inst)) {
+                currentEntry.inst[key] = value;
+                return;
+              }
+              const state = trackPromise(currentEntry.inst);
+              if (state.status === "fulfilled") {
+                currentEntry.inst = state.value;
+                flushPendingSets(currentEntry);
+                currentEntry.inst[key] = value;
+                return;
+              }
+              if (state.status === "rejected") throw state.error;
+              currentEntry.pendingSets.push({ key, value });
+            }
+          });
+        };
+        step(this);
+        this.objectSteps.push(step);
+      }
+    }
+    return this;
+  }
+  get(cls) {
+    const key = cls;
+    if (!this.registry.has(key)) {
+      throw new Error(`Service not provided: ${cls.name}`);
+    }
+    const entry = this.registry.get(key);
+    const inst = entry.inst;
+    if (isPromiseLike(inst)) {
+      const state = trackPromise(inst);
+      if (state.status === "fulfilled") {
+        entry.inst = state.value;
+        flushPendingSets(entry);
+        return state.value;
+      }
+      if (state.status === "rejected") throw state.error;
+      return wrapMaybePromise(inst, {
+        methodKeys: entry.methodKeys
+      });
+    }
+    flushPendingSets(entry);
+    return inst;
+  }
+  async getAsync(cls) {
+    const key = cls;
+    if (!this.registry.has(key)) {
+      throw new Error(`Service not provided: ${cls.name}`);
+    }
+    const entry = this.registry.get(key);
+    const resolved = await resolveEntryIfNeeded(entry);
+    return resolved;
+  }
+  use(...ctxes) {
+    for (const ctx of ctxes) {
+      const other = ctx;
+      const entryMap = /* @__PURE__ */ new Map();
+      if (Array.isArray(other?.loadSeq)) {
+        const copiedSeq = other.loadSeq.map((item) => ({
+          ...item,
+          methodKeys: new Set(item.methodKeys ?? []),
+          pendingSets: [...item.pendingSets ?? []]
+        }));
+        other.loadSeq.forEach((item, index) => {
+          entryMap.set(item, copiedSeq[index]);
+        });
+        this.loadSeq.push(...copiedSeq);
+      }
+      if (other?.registry instanceof Map) {
+        for (const [key, value] of other.registry.entries()) {
+          this.registry.set(key, entryMap.get(value) ?? value);
+        }
+      }
+      if (Array.isArray(other?.objectSteps)) {
+        this.objectSteps.push(...other.objectSteps);
+        for (const step of other.objectSteps) {
+          step(this);
+        }
+      }
+    }
+    return this;
+  }
+  define() {
+    return this;
+  }
+  async start() {
+    for (const entry of this.loadSeq) {
+      await resolveEntryIfNeeded(entry);
+    }
+    for (const entry of this.loadSeq) {
+      const inst = entry.inst;
+      if (inst && typeof inst.init === "function") {
+        await inst.init();
+      }
+    }
+    return this;
+  }
+};
+var createAppContext = () => new AppContextCore();
+
+// src/app-context/app-service-base.ts
+var AppServiceBase = class {
+  constructor(ctx, ...args) {
+    this.ctx = ctx;
+  }
+  async init() {
+  }
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AbortedError,
+  AppContextCore,
+  AppServiceBase,
+  DUAL_PENDING,
   DynamicMiddlewareDispatcher,
   I18n,
   I18nLookupMiddleware,
@@ -1273,11 +1560,13 @@ var makeArray = (value) => {
   WF_NODE,
   WorkflowDispatcher,
   abortable,
+  createAppContext,
   createI18nLookupMiddleware,
   dualizeAny,
   makeArray,
   observeDiff,
   patchStringInObject,
+  throwDualPending,
   workflow
 });
 //# sourceMappingURL=index.cjs.map