nfkit 1.0.35 → 1.0.37

package/dist/index.mjs

@@ -1201,11 +1201,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;
@@ -1249,6 +1249,7 @@ var getMethodDescriptor = (cls, key) => {
   }
   return void 0;
 };
+var isPromiseLike = (value) => !!value && typeof value.then === "function";
 var AppContextCore = class {
   constructor() {
     this.provideRecords = [];
@@ -1256,22 +1257,98 @@ var AppContextCore = class {
     this.objectSteps = [];
     this.started = false;
     this.starting = false;
-    this.startingEntries = null;
-    this.createdRecords = null;
-    this.createdEntries = null;
+    this.settleCursor = 0;
+    this.recordEntries = /* @__PURE__ */ new Map();
+    this.pendingInitQueue = [];
+    this.pendingInitSet = /* @__PURE__ */ new Set();
+    this.initializedEntries = /* @__PURE__ */ new Set();
     this.loadingRecords = /* @__PURE__ */ new Set();
+    this.settlementChain = Promise.resolve();
+    this.settlementError = null;
+    this.settling = false;
+  }
+  assertSettlementHealthy() {
+    if (this.settlementError) {
+      throw this.settlementError;
+    }
+  }
+  enqueueInit(entry) {
+    if (this.initializedEntries.has(entry) || this.pendingInitSet.has(entry)) {
+      return;
+    }
+    this.pendingInitSet.add(entry);
+    this.pendingInitQueue.push(entry);
+  }
+  sortInitQueueByDeclarationOrder() {
+    if (this.pendingInitQueue.length <= 1) return;
+    const order = /* @__PURE__ */ new Map();
+    let idx = 0;
+    for (const record of this.provideRecords) {
+      const entry = this.recordEntries.get(record);
+      if (entry) order.set(entry, idx++);
+    }
+    this.pendingInitQueue.sort(
+      (a, b) => (order.get(a) ?? Infinity) - (order.get(b) ?? Infinity)
+    );
+  }
+  async constructPendingRecords() {
+    while (this.settleCursor < this.provideRecords.length) {
+      const record = this.provideRecords[this.settleCursor];
+      this.settleCursor += 1;
+      await this.createEntryFromRecord(record);
+    }
+    this.sortInitQueueByDeclarationOrder();
+  }
+  async settlePending() {
+    await this.constructPendingRecords();
+    while (this.pendingInitQueue.length > 0) {
+      const entry = this.pendingInitQueue.shift();
+      this.pendingInitSet.delete(entry);
+      if (this.initializedEntries.has(entry)) {
+        continue;
+      }
+      const inst = await entry.inst;
+      entry.inst = inst;
+      if (inst && typeof inst.init === "function") {
+        await inst.init();
+      }
+      this.initializedEntries.add(entry);
+      const remaining = this.pendingInitQueue.splice(0);
+      await this.constructPendingRecords();
+      this.pendingInitQueue.push(...remaining);
+    }
+  }
+  scheduleSettlement() {
+    const run = async () => {
+      this.assertSettlementHealthy();
+      this.settling = true;
+      try {
+        await this.settlePending();
+      } catch (error) {
+        this.settlementError = error;
+        throw error;
+      } finally {
+        this.settling = false;
+      }
+    };
+    const task = this.settlementChain.then(run, run);
+    this.settlementChain = task.catch(() => void 0);
+    return task;
+  }
+  triggerSettlement() {
+    void this.scheduleSettlement();
   }
   findProvideRecord(key) {
     for (let i = 0; i < this.provideRecords.length; i += 1) {
       const record = this.provideRecords[i];
-      if (record.classRef === key && (!this.createdRecords || !this.createdRecords.has(record))) {
+      if (record.classRef === key && !this.recordEntries.has(record)) {
         return record;
       }
     }
     return void 0;
   }
   createEntryFromRecord(record) {
-    const existing = this.createdEntries?.get(record);
+    const existing = this.recordEntries.get(record);
     if (existing) {
       return existing;
     }
@@ -1286,11 +1363,10 @@ var AppContextCore = class {
         classRef: record.classRef,
         inst: record.factory(this)
       };
-      this.createdRecords?.add(record);
-      this.createdEntries?.set(record, entry);
+      this.recordEntries.set(record, entry);
       this.registry.set(record.classRef, entry);
-      this.startingEntries?.push(entry);
-      if (entry.inst?.then && typeof entry.inst.then === "function") {
+      this.enqueueInit(entry);
+      if (isPromiseLike(entry.inst)) {
         return entry.inst.then((resolvedInst) => {
           entry.inst = resolvedInst;
           return entry;
@@ -1302,6 +1378,7 @@ var AppContextCore = class {
     }
   }
   provide(cls, ...args) {
+    this.assertSettlementHealthy();
     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;
@@ -1366,11 +1443,12 @@ var AppContextCore = class {
     return this;
   }
   get(cls) {
+    this.assertSettlementHealthy();
     let key = cls;
     if (!this.registry.has(key) && typeof cls === "function" && !cls.prototype) {
       key = cls();
     }
-    if (!this.registry.has(key) && this.starting) {
+    if (!this.registry.has(key) && (this.starting || this.settling)) {
       const record = this.findProvideRecord(key);
       if (record) {
         this.createEntryFromRecord(record);
@@ -1386,14 +1464,10 @@ var AppContextCore = class {
     return await this.get(cls);
   }
   use(...ctxes) {
+    this.assertSettlementHealthy();
     for (const ctx of ctxes) {
       const other = ctx;
-      if (this.started && !other?.started) {
-        throw new Error(
-          "Cannot use an unstarted context into a started context."
-        );
-      }
-      if (Array.isArray(other?.provideRecords)) {
+      if (Array.isArray(other?.provideRecords) && !other?.started) {
         this.provideRecords.push(...other.provideRecords);
       }
       if (Array.isArray(other?.objectSteps)) {
@@ -1413,37 +1487,23 @@ var AppContextCore = class {
     return this;
   }
   define() {
+    this.assertSettlementHealthy();
+    if (this.started && !this.starting) {
+      this.triggerSettlement();
+    }
     return this;
   }
   async start() {
     if (this.started) {
       return this;
     }
-    const startedEntries = [];
-    const preloadedKeys = new Set(this.registry.keys());
+    this.assertSettlementHealthy();
     this.starting = true;
-    this.startingEntries = startedEntries;
-    this.createdRecords = /* @__PURE__ */ new Set();
-    this.createdEntries = /* @__PURE__ */ new Map();
     try {
-      for (const record of this.provideRecords) {
-        if (preloadedKeys.has(record.classRef)) {
-          continue;
-        }
-        await this.createEntryFromRecord(record);
-      }
-      for (const entry of startedEntries) {
-        const inst = entry.inst;
-        if (inst && typeof inst.init === "function") {
-          await inst.init();
-        }
-      }
+      await this.scheduleSettlement();
       this.started = true;
       return this;
     } finally {
-      this.createdEntries = null;
-      this.createdRecords = null;
-      this.startingEntries = null;
       this.starting = false;
     }
   }