@codefast/di 0.10.0 → 0.11.0

package/dist/container/binding-builders.js

@@ -1,21 +1,9 @@
-import { clearBindingFrame, createBindingSlot, DEFAULT_BINDING_SLOT, generateBindingId, NO_INSTANCE, } from "#/core/binding";
-import { mergingConstraintRequirements } from "#/core/constraint-requirement";
-import { slotName } from "#/core/tag";
-import { tokenName } from "#/core/token";
-import { ChainAlreadyRegisteredError, ChainNotRegisteredError, ManyBindingSlotError, SelfBindingRequiresClassError, } from "#/errors/errors";
-import { normalizeToDescriptor } from "#/injection/descriptor";
-/** One criterion per key: re-tagging the same key replaces it rather than asking for both values. */
-function updateSlotTag(slot, criterion) {
-    const tags = [...slot.tags];
-    const existingIndex = tags.findIndex((existing) => existing.key === criterion.key);
-    if (existingIndex === -1) {
-        tags.push(criterion);
-    }
-    else {
-        tags[existingIndex] = criterion;
-    }
-    return createBindingSlot(tags);
-}
+import { clearBindingFrame, NO_ACTIVATION_STAMP, DEFAULT_BINDING_SLOT, generateBindingId, NO_INSTANCE, UNREGISTERED_ORDER, withSlotCriterion, } from "#core/binding";
+import { mergingConstraintRequirements } from "#core/constraint-requirement";
+import { slotName } from "#core/tag";
+import { tokenName } from "#core/token";
+import { ChainAlreadyRegisteredError, ChainNotRegisteredError, ManyBindingSlotError, SelfBindingRequiresClassError, } from "#errors/errors";
+import { normalizeToDescriptor } from "#injection/descriptor";
 // ── BindingChain ─────────────────────────────────────────────────────────────────────────────────────────────────────
 /**
  * The one builder behind `bind()` and every `to*()` return type — and the binding it registers.
@@ -33,6 +21,9 @@ export class BindingChain {
     identifier = generateBindingId();
     inFlight = false;
     frame = undefined;
+    rootContext = undefined;
+    activationStamp = NO_ACTIVATION_STAMP;
+    registrationOrder = UNREGISTERED_ORDER;
     instance = NO_INSTANCE;
     token;
     slot = DEFAULT_BINDING_SLOT;
@@ -76,9 +67,70 @@ export class BindingChain {
         this.kind = kind;
         this.scope = scope;
         this.#isRegistered = true;
-        this.#commit(undefined);
+        // A fresh registration parks nothing yet and restores nothing: one add, then the version.
+        const registration = this.#registration;
+        const registry = registration.registry;
+        const displaced = registry.add(this.#binding);
+        if (displaced !== undefined) {
+            if (registration.deactivateDisplaced !== undefined) {
+                registration.deactivateDisplaced(displaced);
+            }
+            else {
+                this.#displacedByChain = [displaced];
+                registration.onDisplaced?.(displaced);
+            }
+        }
+        if (registration.moduleBindingIds !== undefined) {
+            registration.moduleBindingIds.push(this.identifier);
+        }
+        this.#versionAfterLastWrite = registry.version;
         return this;
     }
+    /**
+     * Registers a declared module's bindings in list order, each a chain of its own that no step
+     * will ever refine.
+     *
+     * @remarks A displaced binding is handled as `to*()` handles it, never parked: nothing refines the
+     * chain, so nothing could restore it.
+     */
+    static registerDeclared(declarations, registration) {
+        const { registry, moduleBindingIds, deactivateDisplaced, onDisplaced } = registration;
+        for (let index = 0; index < declarations.length; index += 1) {
+            const declaration = declarations[index];
+            const binding = BindingChain.#fromDeclaration(declaration, registration);
+            const displaced = registry.add(binding);
+            if (displaced !== undefined) {
+                if (deactivateDisplaced === undefined) {
+                    onDisplaced?.(displaced);
+                }
+                else {
+                    deactivateDisplaced(displaced);
+                }
+            }
+            moduleBindingIds?.push(binding.identifier);
+        }
+    }
+    /**
+     * A registered chain in the shape a declaration's steps would have left.
+     *
+     * @remarks Typed `unknown` like the declaration it copies, so the value type is never asserted here.
+     */
+    static #fromDeclaration(declaration, registration) {
+        const chain = new BindingChain(declaration.token, registration);
+        chain.kind = declaration.kind;
+        chain.slot = declaration.slot;
+        chain.predicate = declaration.predicate;
+        chain.isMany = declaration.isMany;
+        chain.scope = declaration.scope;
+        chain.target = declaration.target;
+        chain.factory = declaration.factory;
+        chain.deps = declaration.deps;
+        chain.value = declaration.value;
+        chain.activationHook = declaration.activationHook;
+        chain.deactivationHook = declaration.deactivationHook;
+        chain.#isRegistered = true;
+        return chain.#binding;
+    }
     // ── Registration ───────────────────────────────────────────────────────────────────────────────────────────────────
     to(type) {
         this.#requireUnregistered();
@@ -126,6 +178,24 @@ export class BindingChain {
         return this.#register("alias", "transient");
     }
     // ── Refinement ─────────────────────────────────────────────────────────────────────────────────────────────────────
+    /**
+     * Whether this chain provably still owns the registry's last write with nothing parked.
+     *
+     * @remarks When it does, a refinement rewrites the live binding in place; otherwise `#reslot`
+     * re-checks liveness and restores what the new shape frees.
+     */
+    get #isProvablyLive() {
+        return this.#registration.registry.version === this.#versionAfterLastWrite && this.#displacedByChain === undefined;
+    }
+    /** Stamps this chain's last-write version after a mutation it made in place. */
+    #recordWrite() {
+        this.#versionAfterLastWrite = this.#registration.registry.version;
+    }
+    /** Bumps the registry for an index-neutral mutation (scope, hook) and records this chain's write. */
+    #touchAndRecordWrite() {
+        this.#registration.registry.touch();
+        this.#recordWrite();
+    }
     // Slot and predicate are what the registry indexes on, so a re-slot takes the binding out of the
     // registry, rewrites the two fields while it is out, and registers it again — same object, same id.
     #reslot(slot, predicate) {
@@ -149,8 +219,7 @@ export class BindingChain {
         }
         // The frame reports the scope, so a resolve before this call memoized the previous one.
         clearBindingFrame(this.#binding);
-        this.#registration.registry.touch();
-        this.#versionAfterLastWrite = this.#registration.registry.version;
+        this.#touchAndRecordWrite();
         return this;
     }
     // SPEC calls a candidate a binding that passes *all* of a chain's predicates, and the chain type
@@ -162,13 +231,10 @@ export class BindingChain {
         const narrowed = previous === undefined
             ? predicate
             : mergingConstraintRequirements((ctx) => previous(ctx) && predicate(ctx), previous, predicate);
-        const { registry } = this.#registration;
-        // The slot is unchanged, so nothing has to be re-indexed or displaced. With the last registry
-        // write this chain's own and nothing parked, the binding is provably live and is rewritten in
-        // place; otherwise the re-slot path re-checks liveness and restores what the shape frees.
-        if (registry.version === this.#versionAfterLastWrite && this.#displacedByChain === undefined) {
-            registry.setPredicate(this.#binding, narrowed);
-            this.#versionAfterLastWrite = registry.version;
+        // The slot is unchanged, so a provably-live binding just takes the predicate in place.
+        if (this.#isProvablyLive) {
+            this.#registration.registry.setPredicate(this.#binding, narrowed);
+            this.#recordWrite();
             return this;
         }
         return this.#reslot(this.slot, narrowed);
@@ -181,7 +247,7 @@ export class BindingChain {
         if (this.isMany) {
             throw new ManyBindingSlotError(tokenName(this.token));
         }
-        return this.#reslot(updateSlotTag(this.slot, criterion), this.predicate);
+        return this.#reslot(withSlotCriterion(this.slot, criterion), this.predicate);
     }
     many() {
         this.#requireRegistered();
@@ -191,14 +257,11 @@ export class BindingChain {
         if (this.isMany) {
             return this;
         }
-        const { registry } = this.#registration;
-        // With the last registry write this chain's own and nothing parked, the binding is provably live
-        // and displaced nobody, so membership is written in place and the registry only moves it out of
-        // the lone map. Otherwise it goes through the re-slot path, which re-checks liveness and restores
-        // an ordinary binding this chain's `to*()` displaced, now that the member frees its slot.
-        if (registry.version === this.#versionAfterLastWrite && this.#displacedByChain === undefined) {
-            registry.setMany(this.#binding);
-            this.#versionAfterLastWrite = registry.version;
+        // A provably-live binding takes membership in place; the registry only moves it out of the lone
+        // map. Otherwise `#commit` re-checks liveness and restores what the freed slot lets back in.
+        if (this.#isProvablyLive) {
+            this.#registration.registry.setMany(this.#binding);
+            this.#recordWrite();
             return this;
         }
         this.#commit(() => {
@@ -224,15 +287,13 @@ export class BindingChain {
     onActivation(fn) {
         this.#requireRegistered();
         this.activationHook = fn;
-        this.#registration.registry.touch();
-        this.#versionAfterLastWrite = this.#registration.registry.version;
+        this.#touchAndRecordWrite();
         return this;
     }
     onDeactivation(fn) {
         this.#requireRegistered();
         this.deactivationHook = fn;
-        this.#registration.registry.touch();
-        this.#versionAfterLastWrite = this.#registration.registry.version;
+        this.#touchAndRecordWrite();
         return this;
     }
     id() {
@@ -272,7 +333,13 @@ export class BindingChain {
         }
         const displaced = registry.add(registered);
         if (displaced !== undefined) {
-            (this.#displacedByChain ??= []).push(displaced);
+            if (this.#registration.deactivateDisplaced !== undefined && rewrite === undefined) {
+                this.#registration.deactivateDisplaced(displaced);
+            }
+            else {
+                (this.#displacedByChain ??= []).push(displaced);
+                this.#registration.onDisplaced?.(displaced);
+            }
         }
         if (rewrite !== undefined && this.#displacedByChain !== undefined) {
             this.#restoreNonConflicting(this.#displacedByChain);
@@ -289,6 +356,7 @@ export class BindingChain {
             // the candidate stays parked.
             if (!this.#registration.registry.hasSlotOccupant(candidate)) {
                 this.#registration.registry.add(candidate);
+                this.#registration.onRestored?.(candidate);
                 displaced.splice(index, 1);
             }
         }

package/dist/container/container.d.ts

@@ -1,11 +1,11 @@
-import type { BindToBuilder } from "#/core/binding";
-import type { AsyncModule, SyncModule } from "#/core/module";
-import type { Token } from "#/core/token";
-import type { ActivationHandler, BindingIdentifier, Constructor, DeactivationHandler, ResolveOptions } from "#/core/types";
-import type { AutoRegisterRegistry } from "#/decorators/injectable";
-import type { ContainerGraphJson, GraphOptions } from "#/introspection/dependency-graph";
-import type { BindingSnapshot, ContainerSnapshot } from "#/introspection/inspector";
-import type { MetadataReader } from "#/metadata/metadata-types";
+import type { BindToBuilder } from "#core/binding";
+import type { AsyncModule, SyncModule } from "#core/module";
+import type { Token } from "#core/token";
+import type { ActivationHandler, BindingIdentifier, Constructor, DeactivationHandler, ResolveOptions } from "#core/types";
+import type { AutoRegisterRegistry } from "#decorators/injectable";
+import type { ContainerGraphJson, GraphOptions } from "#introspection/dependency-graph";
+import type { BindingSnapshot, ContainerSnapshot } from "#introspection/inspector";
+import type { MetadataReader } from "#metadata/metadata-types";
 /**
  * The public surface: binding, resolving, modules, lifecycle hooks, child scopes, and disposal.
  *