nfkit 1.0.29 → 1.0.31

package/dist/index.mjs

@@ -1254,7 +1254,84 @@ var AppContextCore = class {
     this.provideRecords = [];
     this.registry = /* @__PURE__ */ new Map();
     this.objectSteps = [];
+    this.parentContexts = /* @__PURE__ */ new Set();
     this.started = false;
+    this.starting = false;
+    this.startingEntries = null;
+    this.createdRecords = null;
+    this.createdEntries = null;
+    this.loadingRecords = /* @__PURE__ */ new Set();
+  }
+  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))) {
+        return record;
+      }
+    }
+    return void 0;
+  }
+  createEntryFromRecord(record) {
+    const existing = this.createdEntries?.get(record);
+    if (existing) {
+      return existing;
+    }
+    if (this.loadingRecords.has(record)) {
+      throw new Error(
+        `Circular dependency detected while providing: ${record.classRef?.name ?? "UnknownService"}`
+      );
+    }
+    this.loadingRecords.add(record);
+    try {
+      const entry = {
+        classRef: record.classRef,
+        inst: record.factory(this)
+      };
+      this.createdRecords?.add(record);
+      this.createdEntries?.set(record, entry);
+      this.registry.set(record.classRef, entry);
+      this.startingEntries?.push(entry);
+      return entry;
+    } finally {
+      this.loadingRecords.delete(record);
+    }
+  }
+  applyUsedContext(other) {
+    if (Array.isArray(other?.provideRecords)) {
+      this.provideRecords.push(...other.provideRecords);
+    }
+    if (Array.isArray(other?.objectSteps)) {
+      this.objectSteps.push(...other.objectSteps);
+      for (const step of other.objectSteps) {
+        step(this);
+      }
+    }
+    if (other?.started) {
+      if (other?.registry instanceof Map) {
+        for (const [key, value] of other.registry.entries()) {
+          this.registry.set(key, value);
+        }
+      }
+    }
+  }
+  hasStartedInParentChain(visited = /* @__PURE__ */ new Set()) {
+    if (visited.has(this)) return false;
+    visited.add(this);
+    if (this.started) return true;
+    for (const parent of this.parentContexts) {
+      if (parent.hasStartedInParentChain(visited)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  propagateUsedContextToParents(other, visited = /* @__PURE__ */ new Set()) {
+    if (visited.has(this)) return;
+    visited.add(this);
+    for (const parent of this.parentContexts) {
+      parent.applyUsedContext(other);
+      parent.propagateUsedContextToParents(other, visited);
+    }
   }
   provide(cls, ...args) {
     const last = args[args.length - 1];
@@ -1325,6 +1402,12 @@ var AppContextCore = class {
     if (!this.registry.has(key) && typeof cls === "function" && !cls.prototype) {
       key = cls();
     }
+    if (!this.registry.has(key) && this.starting) {
+      const record = this.findProvideRecord(key);
+      if (record) {
+        this.createEntryFromRecord(record);
+      }
+    }
     if (!this.registry.has(key)) {
       throw new Error(`Service not provided: ${key?.name ?? cls.name}`);
     }
@@ -1340,27 +1423,14 @@ var AppContextCore = class {
   use(...ctxes) {
     for (const ctx of ctxes) {
       const other = ctx;
-      if (this.started && !other?.started) {
+      if (this.hasStartedInParentChain() && !other?.started) {
         throw new Error(
           "Cannot use an unstarted context into a started context."
         );
       }
-      if (Array.isArray(other?.provideRecords)) {
-        this.provideRecords.push(...other.provideRecords);
-      }
-      if (Array.isArray(other?.objectSteps)) {
-        this.objectSteps.push(...other.objectSteps);
-        for (const step of other.objectSteps) {
-          step(this);
-        }
-      }
-      if (other?.started) {
-        if (other?.registry instanceof Map) {
-          for (const [key, value] of other.registry.entries()) {
-            this.registry.set(key, value);
-          }
-        }
-      }
+      this.applyUsedContext(other);
+      other.parentContexts.add(this);
+      this.propagateUsedContextToParents(other);
     }
     return this;
   }
@@ -1373,31 +1443,36 @@ var AppContextCore = class {
     }
     const startedEntries = [];
     const preloadedKeys = new Set(this.registry.keys());
-    for (const record of this.provideRecords) {
-      if (preloadedKeys.has(record.classRef)) {
-        continue;
+    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;
+        }
+        this.createEntryFromRecord(record);
       }
-      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 startedEntries) {
+        if (entry.inst && typeof entry.inst.then === "function") {
+          entry.inst = await entry.inst;
+        }
       }
-    }
-    for (const entry of startedEntries) {
-      const inst = entry.inst;
-      if (inst && typeof inst.init === "function") {
-        await inst.init();
+      for (const entry of startedEntries) {
+        const inst = entry.inst;
+        if (inst && typeof inst.init === "function") {
+          await inst.init();
+        }
       }
+      this.started = true;
+      return this;
+    } finally {
+      this.createdEntries = null;
+      this.createdRecords = null;
+      this.startingEntries = null;
+      this.starting = false;
     }
-    this.started = true;
-    return this;
   }
 };
 var createAppContext = () => new AppContextCore();