nfkit 1.0.25 → 1.0.27

package/dist/index.mjs

@@ -1201,11 +1201,11 @@ var observeDiff = (obj, cb) => {
 // src/memorize.ts
 var Memorize = () => {
   const cache = /* @__PURE__ */ new WeakMap();
-  const isPromiseLike2 = (v) => v != null && typeof v.then === "function" && typeof v.catch === "function";
+  const isPromiseLike = (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 (isPromiseLike2(result)) {
+    if (isPromiseLike(result)) {
       const wrapped = result.catch((err) => {
         cache.delete(instance);
         throw err;
@@ -1239,56 +1239,7 @@ 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) {
@@ -1298,52 +1249,24 @@ var getMethodDescriptor = (cls, key) => {
   }
   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.provideRecords = [];
     this.registry = /* @__PURE__ */ new Map();
-    this.loadSeq = [];
     this.objectSteps = [];
+    this.started = false;
   }
   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 = {
+    const factory = (ctx) => options?.useValue ?? (options?.useFactory ? options.useFactory(ctx, ..._args) : new (options?.useClass ?? cls)(ctx, ..._args));
+    this.provideRecords.push({
       classRef,
-      inst,
-      methodKeys,
-      pendingSets: []
-    };
-    this.registry.set(classRef, entry);
-    if (provideKey) this.registry.set(provideKey, entry);
-    this.loadSeq.push(entry);
+      factory
+    });
     if (options?.provide) {
       const prop = options.provide;
       const step = (ctx) => {
@@ -1352,7 +1275,7 @@ var AppContextCore = class {
           configurable: true,
           get: () => {
             const currentEntry = ctx.registry.get(classRef);
-            return wrapMaybePromise(currentEntry?.inst, { methodKeys });
+            return currentEntry?.inst;
           }
         });
       };
@@ -1371,8 +1294,6 @@ var AppContextCore = class {
               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;
               }
@@ -1384,25 +1305,12 @@ var AppContextCore = class {
             configurable: true,
             get: () => {
               const currentEntry = ctx.registry.get(classRef);
-              const target = wrapMaybePromise(currentEntry?.inst);
-              return target?.[key];
+              return currentEntry?.inst?.[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 });
+              currentEntry.inst[key] = value;
             }
           });
         };
@@ -1421,53 +1329,24 @@ var AppContextCore = class {
       throw new Error(`Service not provided: ${key?.name ?? 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;
+    return entry.inst;
   }
+  /**
+   * @deprecated Use get() instead. getAsync() is no longer needed as all services are loaded synchronously during start().
+   */
   async getAsync(cls) {
-    let key = cls;
-    if (!this.registry.has(key) && typeof cls === "function" && !cls.prototype) {
-      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;
+    return this.get(cls);
   }
   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 (this.started && !other?.started) {
+        throw new Error(
+          "Cannot use an unstarted context into a started context."
+        );
       }
-      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?.provideRecords)) {
+        this.provideRecords.push(...other.provideRecords);
       }
       if (Array.isArray(other?.objectSteps)) {
         this.objectSteps.push(...other.objectSteps);
@@ -1475,6 +1354,13 @@ var AppContextCore = class {
           step(this);
         }
       }
+      if (other?.started) {
+        if (other?.registry instanceof Map) {
+          for (const [key, value] of other.registry.entries()) {
+            this.registry.set(key, value);
+          }
+        }
+      }
     }
     return this;
   }
@@ -1482,15 +1368,35 @@ var AppContextCore = class {
     return this;
   }
   async start() {
-    for (const entry of this.loadSeq) {
-      await resolveEntryIfNeeded(entry);
+    if (this.started) {
+      return this;
+    }
+    const startedEntries = [];
+    const preloadedKeys = new Set(this.registry.keys());
+    for (const record of this.provideRecords) {
+      if (preloadedKeys.has(record.classRef)) {
+        continue;
+      }
+      const inst = record.factory(this);
+      const entry = {
+        classRef: record.classRef,
+        inst
+      };
+      this.registry.set(record.classRef, entry);
+      startedEntries.push(entry);
+    }
+    for (const entry of startedEntries) {
+      if (entry.inst && typeof entry.inst.then === "function") {
+        entry.inst = await entry.inst;
+      }
     }
-    for (const entry of this.loadSeq) {
+    for (const entry of startedEntries) {
       const inst = entry.inst;
       if (inst && typeof inst.init === "function") {
         await inst.init();
       }
     }
+    this.started = true;
     return this;
   }
 };