@fnioc/di 2.0.0 → 4.0.0

package/dist/index.js

@@ -1,26 +1,54 @@
 // ../core/src/store.ts
-var hole = null;
 var GLOBAL_KEY = Symbol.for("fnioc:deps");
 var globals = globalThis;
 var store = globals[GLOBAL_KEY] ??= new Map;
+
 // ../core/src/defineDeps.ts
 function isFactoryRef(slot) {
-  return typeof slot === "object" && slot !== null && typeof slot.factory === "string";
+  return typeof slot === "object" && slot !== null && typeof slot.type === "string";
 }
 function isScopeRef(slot) {
   return typeof slot === "object" && slot !== null && slot.scope === true;
 }
+function isUnionSlot(slot) {
+  return typeof slot === "object" && slot !== null && Array.isArray(slot.union);
+}
 function slotsEqual(a, b) {
   const aIsRef = isFactoryRef(a);
   const bIsRef = isFactoryRef(b);
   if (aIsRef || bIsRef) {
-    return aIsRef && bIsRef && a.factory === b.factory;
+    if (!aIsRef || !bIsRef)
+      return false;
+    if (a.type !== b.type)
+      return false;
+    const aParams = a.params ?? [];
+    const bParams = b.params ?? [];
+    if (aParams.length !== bParams.length)
+      return false;
+    for (let i = 0;i < aParams.length; i++) {
+      if (aParams[i] !== bParams[i])
+        return false;
+    }
+    return true;
   }
   const aIsScope = isScopeRef(a);
   const bIsScope = isScopeRef(b);
   if (aIsScope || bIsScope) {
     return aIsScope && bIsScope;
   }
+  const aIsUnion = isUnionSlot(a);
+  const bIsUnion = isUnionSlot(b);
+  if (aIsUnion || bIsUnion) {
+    if (!aIsUnion || !bIsUnion)
+      return false;
+    if (a.union.length !== b.union.length)
+      return false;
+    for (let i = 0;i < a.union.length; i++) {
+      if (!slotsEqual(a.union[i], b.union[i]))
+        return false;
+    }
+    return true;
+  }
   return a === b;
 }
 function signaturesEqual(a, b) {
@@ -65,6 +93,12 @@ function forCtor(ctor) {
   };
   return builder;
 }
+
+// ../core/src/index.ts
+function union(...slots) {
+  return { union: slots };
+}
+
 // src/errors.ts
 class DiError extends Error {
   constructor(message) {
@@ -134,6 +168,15 @@ class FactoryTargetError extends DiError {
   }
 }
 
+class NoSatisfiableUnionError extends DiError {
+  members;
+  constructor(members) {
+    const memberList = members.map((m) => typeof m === "string" ? `"${m}"` : JSON.stringify(m)).join(", ");
+    super(`No satisfiable union member found. Tried: [${memberList}]. ` + `Register at least one of the union members before resolving.`);
+    this.members = members;
+  }
+}
+
 class AsyncDisposalRequiredError extends DiError {
   constructor() {
     super(`Cannot dispose synchronously: this scope owns a Promise-valued ` + `instance (an async useFactory result). Awaiting it is required ` + `before disposal — call disposeAsync() instead of dispose().`);
@@ -150,108 +193,72 @@ function isAsyncDisposable(value) {
 function isThenable(value) {
   return value != null && (typeof value === "object" || typeof value === "function") && typeof value.then === "function";
 }
-function isFactoryRef2(slot) {
-  return slot !== null && typeof slot === "object" && typeof slot.factory === "string";
-}
-function isScopeRef2(slot) {
-  return slot !== null && typeof slot === "object" && slot.scope === true;
-}
+var isFactoryRef2 = isFactoryRef;
+var isScopeRef2 = isScopeRef;
+var isUnion = isUnionSlot;
 
 class Scope {
   name;
   parent;
-  baseRegistrations;
-  localRegistrations = new Map;
-  instances = new Map;
-  ownedOrder = [];
-  disposed = false;
-  constructor(name, parent, baseRegistrations) {
+  cache = new Map;
+  owned = [];
+  constructor(name, parent) {
     this.name = name;
     this.parent = parent;
-    this.baseRegistrations = baseRegistrations;
   }
-  static appendTo(map, token, registration) {
-    const existing = map.get(token);
-    if (existing === undefined) {
-      map.set(token, [registration]);
-    } else {
-      existing.push(registration);
+}
+
+class ServiceProvider {
+  registrations;
+  disposed = false;
+  frame;
+  constructor(registrations, frame) {
+    this.registrations = registrations;
+    this.frame = frame;
+  }
+  get name() {
+    if (this.frame === undefined) {
+      throw new TypeError("This ServiceProvider has no scope frame (unscoped root).");
     }
+    return this.frame.name;
   }
-  createScope(childName) {
-    return new Scope(childName, this, this.baseRegistrations);
-  }
-  appendScopedLocal(token, base) {
-    Scope.appendTo(this.localRegistrations, token, base);
-    const map = this.localRegistrations;
-    return {
-      as(scope) {
-        if (scope === undefined)
-          return;
-        Scope.appendTo(map, token, { ...base, scope });
-      }
-    };
-  }
-  add(token, ctor) {
-    return this.appendScopedLocal(token, {
-      kind: "class",
-      ctor,
-      scope: undefined
-    });
-  }
-  addFactory(token, factory) {
-    return this.appendScopedLocal(token, {
-      kind: "factory",
-      factory,
-      scope: undefined
-    });
-  }
-  addValue(token, value) {
-    Scope.appendTo(this.localRegistrations, token, {
-      kind: "value",
-      useValue: value
-    });
-    return this;
+  createScope(...args) {
+    const name = args[0] ?? "scoped";
+    const childFrame = new Scope(name, this.frame);
+    return new ServiceProvider(this.registrations, childFrame);
   }
   resolve(token) {
     if (token === undefined) {
       throw new TypeError("resolve<T>() requires the @fnioc/transformer plugin (no token at " + "runtime). Without it, resolve with an explicit token: " + 'resolve<T>("my:token").');
     }
-    return this.resolveWith(token, []);
+    return this.resolveWith(token, this.frame, []);
   }
-  resolveFactory(token) {
-    return this.makeFactory({ factory: token });
+  resolveFactory(type, params) {
+    return this.makeFactory({ type, params }, this.frame);
   }
   lookup(token) {
-    let node = this;
-    while (node !== undefined) {
-      const local = node.localRegistrations.get(token);
-      if (local !== undefined && local.length > 0)
-        return local[local.length - 1];
-      node = node.parent;
-    }
-    const base = this.baseRegistrations.get(token);
-    return base !== undefined && base.length > 0 ? base[base.length - 1] : undefined;
+    const list = this.registrations.get(token);
+    return list !== undefined && list.length > 0 ? list[list.length - 1] : undefined;
   }
-  findOwner(scope) {
-    let node = this;
+  static findOwner(vantage, scopeName) {
+    let node = vantage;
     while (node !== undefined) {
-      if (node.name === scope)
+      if (node.name === scopeName)
         return node;
       node = node.parent;
     }
     return;
   }
-  chainNames() {
+  static chainNames(vantage) {
     const names = [];
-    let node = this;
+    let node = vantage;
     while (node !== undefined) {
       names.push(node.name);
       node = node.parent;
     }
     return names;
   }
-  resolveWith(token, stack) {
+  resolveWith(token, vantage, stack) {
     if (stack.includes(token)) {
       throw new CircularDependencyError([...stack, token]);
     }
@@ -265,65 +272,70 @@ class Scope {
     if (registration.scope === undefined) {
       stack.push(token);
       try {
-        return this.instantiate(token, registration, this, stack);
+        return this.instantiate(token, registration, vantage, stack);
       } finally {
         stack.pop();
       }
     }
-    const owner = this.findOwner(registration.scope);
+    const owner = ServiceProvider.findOwner(vantage, registration.scope);
     if (owner === undefined) {
-      throw new MissingScopeError(token, registration.scope, this.chainNames());
+      throw new MissingScopeError(token, registration.scope, ServiceProvider.chainNames(vantage));
     }
-    if (owner.instances.has(token)) {
-      return owner.instances.get(token);
+    if (owner.cache.has(token)) {
+      return owner.cache.get(token);
     }
     stack.push(token);
     try {
-      const instance = owner.instantiate(token, registration, owner, stack);
-      owner.instances.set(token, instance);
-      owner.ownedOrder.push(instance);
+      const instance = this.instantiate(token, registration, owner, stack);
+      owner.cache.set(token, instance);
+      owner.owned.push(instance);
       return instance;
     } finally {
       stack.pop();
     }
   }
-  instantiate(token, registration, owningScope, stack) {
+  instantiate(token, registration, owningFrame, stack) {
     if (registration.kind === "factory") {
-      return owningScope.invokeFactory(token, registration.factory, stack);
+      return this.invokeFactory(token, registration.factory, owningFrame, stack);
     }
-    return owningScope.construct(token, registration.ctor, stack);
+    return this.construct(token, registration.ctor, owningFrame, stack);
   }
-  makeScopeView(stack) {
-    const owner = this;
-    const view = {
+  makeProviderView(owningFrame, stack) {
+    const sp = this;
+    return {
       resolve: (depToken) => {
         if (depToken === undefined) {
           throw new TypeError("resolve<T>() requires the @fnioc/transformer plugin (no token at " + "runtime).");
         }
-        return owner.resolveWith(depToken, stack);
+        return sp.resolveWith(depToken, owningFrame, stack);
       },
-      resolveFactory: (depToken) => owner.makeFactory({ factory: depToken }),
-      createScope: (name) => owner.createScope(name)
+      resolveFactory: (depToken, depParams) => sp.makeFactory({ type: depToken, params: depParams }, owningFrame),
+      createScope: (...args) => {
+        const name = args[0] ?? "scoped";
+        const childFrame = new Scope(name, owningFrame);
+        return new ServiceProvider(sp.registrations, childFrame);
+      }
     };
-    return view;
   }
-  invokeFactory(token, factory, stack) {
-    const scopeView = this.makeScopeView(stack);
+  invokeFactory(token, factory, owningFrame, stack) {
+    const providerView = this.makeProviderView(owningFrame, stack);
     const record = getDeps(factory);
     if (record === undefined || record.signatures.length === 0) {
-      return factory(scopeView);
+      return factory(providerView);
     }
-    const signature2 = this.selectSignature(token, factory.name, record.signatures);
+    const signature2 = this.selectSignature(token, factory.name, record.signatures, owningFrame);
     const args = signature2.map((slot) => {
       if (isScopeRef2(slot))
-        return scopeView;
+        return providerView;
       if (isFactoryRef2(slot))
-        return this.makeFactory(slot);
-      return this.resolveWith(slot, stack);
+        return this.makeFactory(slot, owningFrame);
+      if (isUnion(slot))
+        return this.resolveUnion(slot, owningFrame, stack);
+      return this.resolveWith(slot, owningFrame, stack);
     });
     return factory(...args);
   }
-  construct(token, ctor, stack) {
+  construct(token, ctor, owningFrame, stack) {
     const record = getDeps(ctor);
     if (record === undefined || record.signatures.length === 0) {
       if (ctor.length > 0) {
@@ -331,52 +343,69 @@ class Scope {
       }
       return new ctor;
     }
-    const signature2 = this.selectSignature(token, ctor.name, record.signatures);
+    const signature2 = this.selectSignature(token, ctor.name, record.signatures, owningFrame);
+    const providerView = this.makeProviderView(owningFrame, stack);
     const args = signature2.map((slot) => {
       if (isScopeRef2(slot)) {
-        return this.makeScopeView(stack);
+        return providerView;
       }
       if (isFactoryRef2(slot)) {
-        return this.makeFactory(slot);
+        return this.makeFactory(slot, owningFrame);
+      }
+      if (isUnion(slot)) {
+        return this.resolveUnion(slot, owningFrame, stack);
       }
-      return this.resolveWith(slot, stack);
+      return this.resolveWith(slot, owningFrame, stack);
     });
     return new ctor(...args);
   }
-  makeFactory(ref) {
-    const owningScope = this;
-    const target = this.lookup(ref.factory);
+  makeFactory(ref, owningFrame) {
+    const sp = this;
+    const target = this.lookup(ref.type);
     if (target === undefined) {
-      throw new FactoryTargetError(ref.factory, "unregistered");
+      throw new FactoryTargetError(ref.type, "unregistered");
     }
     if (target.kind === "value") {
-      return () => owningScope.resolveWith(ref.factory, []);
+      return () => sp.resolveWith(ref.type, owningFrame, []);
+    }
+    const callerParams = ref.params !== undefined && ref.params.length > 0 ? ref.params : undefined;
+    if (callerParams === undefined) {
+      return () => sp.resolveWith(ref.type, owningFrame, []);
     }
     const depTarget = target.kind === "class" ? target.ctor : target.factory;
     const record = getDeps(depTarget);
-    const targetSignature = record === undefined || record.signatures.length === 0 ? undefined : owningScope.selectTargetSignature(record.signatures);
-    const parameterized = targetSignature !== undefined && targetSignature.some((slot) => !isFactoryRef2(slot) && !isScopeRef2(slot) && !owningScope.isResolvable(slot));
-    if (!parameterized) {
-      return () => owningScope.resolveWith(ref.factory, []);
-    }
-    return (...callArgs) => owningScope.buildPartitioned(target, targetSignature, callArgs);
+    const targetSignature = record === undefined || record.signatures.length === 0 ? undefined : sp.selectTargetSignature(record.signatures);
+    return (...callArgs) => sp.buildPartitioned(target, targetSignature, callerParams, callArgs, owningFrame);
   }
-  buildPartitioned(target, signature2, callerArgs) {
+  buildPartitioned(target, signature2, callerParams, callArgs, owningFrame) {
     const stack = [];
-    let nextCallerArg = 0;
+    const providerView = this.makeProviderView(owningFrame, stack);
+    if (signature2 === undefined || signature2.length === 0) {
+      return target.kind === "class" ? new target.ctor : target.factory(providerView);
+    }
+    const remainingParamIndices = callerParams.map((_, i) => i);
     const args = signature2.map((slot) => {
       if (isScopeRef2(slot))
-        return this.makeScopeView(stack);
+        return providerView;
       if (isFactoryRef2(slot))
-        return this.makeFactory(slot);
-      if (!this.isResolvable(slot)) {
-        return callerArgs[nextCallerArg++];
+        return this.makeFactory(slot, owningFrame);
+      if (isUnion(slot))
+        return this.resolveUnion(slot, owningFrame, stack);
+      const token = slot;
+      const matchIdx = remainingParamIndices.findIndex((pi) => callerParams[pi] === token);
+      if (matchIdx !== -1) {
+        const paramIdx = remainingParamIndices[matchIdx];
+        remainingParamIndices.splice(matchIdx, 1);
+        return callArgs[paramIdx];
+      }
+      if (!this.isResolvable(token)) {
+        throw new NoSatisfiableSignatureError(token, token, [token]);
       }
-      return this.resolveWith(slot, stack);
+      return this.resolveWith(token, owningFrame, stack);
     });
     return target.kind === "class" ? new target.ctor(...args) : target.factory(...args);
   }
-  selectSignature(token, targetName, signatures) {
+  selectSignature(token, targetName, signatures, _owningFrame) {
     const ordered = signatures.map((sig, index) => ({ sig, index })).sort((a, b) => b.sig.length !== a.sig.length ? b.sig.length - a.sig.length : a.index - b.index);
     const unsatisfiable = new Set;
     for (const { sig } of ordered) {
@@ -384,6 +413,12 @@ class Scope {
       for (const slot of sig) {
         if (isFactoryRef2(slot) || isScopeRef2(slot))
           continue;
+        if (isUnion(slot)) {
+          if (!this.isResolvableSlot(slot)) {
+            satisfiable = false;
+          }
+          continue;
+        }
         if (!this.isResolvable(slot)) {
           satisfiable = false;
           if (typeof slot === "string")
@@ -401,17 +436,43 @@ class Scope {
   isResolvable(slot) {
     return typeof slot === "string" && this.lookup(slot) !== undefined;
   }
+  isResolvableSlot(slot) {
+    if (isFactoryRef2(slot) || isScopeRef2(slot))
+      return true;
+    if (isUnion(slot)) {
+      return slot.union.some((member) => this.isResolvableSlot(member));
+    }
+    return this.isResolvable(slot);
+  }
+  resolveUnion(slot, owningFrame, stack) {
+    for (const member of slot.union) {
+      if (this.isResolvableSlot(member)) {
+        return this.resolveSlot(member, owningFrame, stack);
+      }
+    }
+    throw new NoSatisfiableUnionError(slot.union);
+  }
+  resolveSlot(slot, owningFrame, stack) {
+    if (isScopeRef2(slot))
+      return this.makeProviderView(owningFrame, stack);
+    if (isFactoryRef2(slot))
+      return this.makeFactory(slot, owningFrame);
+    if (isUnion(slot))
+      return this.resolveUnion(slot, owningFrame, stack);
+    return this.resolveWith(slot, owningFrame, stack);
+  }
   dispose() {
     if (this.disposed)
       return;
-    for (const instance of this.ownedOrder) {
+    const owned = this.frame?.owned ?? [];
+    for (const instance of owned) {
       if (isThenable(instance)) {
         throw new AsyncDisposalRequiredError;
       }
     }
     this.disposed = true;
-    for (let i = this.ownedOrder.length - 1;i >= 0; i--) {
-      const instance = this.ownedOrder[i];
+    for (let i = owned.length - 1;i >= 0; i--) {
+      const instance = owned[i];
       if (isDisposable(instance)) {
         instance[Symbol.dispose]();
       }
@@ -422,8 +483,9 @@ class Scope {
     if (this.disposed)
       return;
     this.disposed = true;
+    const owned = this.frame?.owned ?? [];
     const settled = [];
-    for (const instance of this.ownedOrder) {
+    for (const instance of owned) {
       settled.push(isThenable(instance) ? await instance : instance);
     }
     for (let i = settled.length - 1;i >= 0; i--) {
@@ -437,8 +499,10 @@ class Scope {
     this.clear();
   }
   clear() {
-    this.instances.clear();
-    this.ownedOrder.length = 0;
+    if (this.frame) {
+      this.frame.cache.clear();
+      this.frame.owned.length = 0;
+    }
   }
   [Symbol.dispose]() {
     this.dispose();
@@ -500,16 +564,24 @@ class DiBuilder {
     this.append(token, { kind: "value", useValue: value });
   }
   build() {
-    return new Scope(this.rootName, undefined, this.registrations);
+    const sealed = new Map;
+    for (const [token, list] of this.registrations) {
+      sealed.set(token, Object.freeze([...list]));
+    }
+    Object.freeze(sealed);
+    const rootFrame = new Scope(this.rootName);
+    return new ServiceProvider(sealed, rootFrame);
   }
 }
 export {
+  union,
   signature,
-  hole,
   forCtor,
   defineDeps,
   UnregisteredTokenError,
+  ServiceProvider,
   Scope,
+  NoSatisfiableUnionError,
   NoSatisfiableSignatureError,
   MissingScopeError,
   MissingMetadataError,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fnioc/di",
-  "version": "2.0.0",
+  "version": "4.0.0",
   "description": "The ioc runtime engine: DiBuilder, scopes, resolution, captive-dependency protection, factories, and native disposal.",
   "keywords": [
     "dependency-injection",