@k8slens/injectable 26.0.0 → 26.2.0

package/index.d.ts

@@ -430,7 +430,13 @@ export const lifecycleEnum: {
   };
 };
 
-type RegistrationCallback = (injectable: Injectable<any, any, any>) => void;
+// Called with what was (de)registered and the token it was registered under:
+// the resolved one when `injectionToken` was given as a function, which the
+// injectable alone would not reveal.
+type RegistrationCallback = (
+  injectable: Injectable<any, any, any> | Injectable2<any>,
+  injectionToken: InjectionToken<any, any, any> | Token2<Factory, any, any> | undefined,
+) => void;
 
 // --- injectionDecoratorToken ---
 //
@@ -681,6 +687,20 @@ export function getTypedSpecifier
 
 // ---- Injectable2 / InjectionToken2 ----
 
+// The scope an injectable is being registered under, as handed to an
+// `injectionToken` given as a function: the ids of the scopes, outermost first
+// and the immediate owner last — what the injectable's own `di.scopeIds` will
+// read as. Resolved once per registration, so the same injectable registered
+// by two scopes ends up under two tokens.
+export interface RegistrationScope {
+  readonly scopeIds: string[];
+}
+
+// An `injectionToken` is a token, or a function of the registration's scope
+// producing one — for token families keyed by something only the registration
+// knows, `({ scopeIds }) => someToken.for(...)`.
+export type InjectionTokenOf<T> = T | ((scope: RegistrationScope) => T);
+
 export interface Injectable2<F extends Factory = Factory> {
   readonly aliasType: 'injectable2';
   readonly id: string;
@@ -690,7 +710,7 @@ export interface Injectable2<F extends Factory = Factory> {
   // `getInjectable2` keeps the relationship sound; precise per-injectable
   // token typing isn't observably useful here (runtime reads only token-level
   // fields like `.id`, `.abstract`, `.maxCacheSize`).
-  readonly injectionToken?: Token2<Factory, any, any>;
+  readonly injectionToken?: InjectionTokenOf<Token2<Factory, any, any>>;
   readonly consumptions?: ReadonlyArray<Consumption>;
   readonly transient?: boolean;
   readonly causesSideEffects?: boolean;
@@ -716,8 +736,10 @@ export type Consumption =
 
 // The `.for()` derivatives of a declared token are covered by declaring the
 // token itself — otherwise a specifier only known at runtime could not be
-// declared at all. One level suffices: the default `.for()` factory is
-// self-similar, so a child's own `for` yields the same shape again.
+// declared at all. Families nest (`token.for(kind).for(scopeIds)`), so the
+// descendants are walked a few levels down; the walk is bounded because the
+// default `.for()` factory is self-similar, and a child's own `for` yields
+// the same shape again, which an unbounded walk would never finish.
 type NotAny<T> = 0 extends 1 & T ? never : T;
 
 export type ConsumptionChildOf<C> = C extends {
@@ -728,9 +750,14 @@ export type ConsumptionChildOf<C> = C extends {
     : never
   : never;
 
+type ConsumptionDescendantOf<C, Depth extends unknown[] = [0, 0, 0, 0]> =
+  Depth extends [unknown, ...infer Shallower]
+    ? ConsumptionChildOf<C> | ConsumptionDescendantOf<ConsumptionChildOf<C>, Shallower>
+    : never;
+
 type Consumable<Cons extends Consumption> =
   | Cons
-  | ConsumptionChildOf<Cons>;
+  | ConsumptionDescendantOf<Cons>;
 
 // The injection surface of `instantiate`'s `di`: the same cardinality gating as
 // the container's, narrowed to what the injectable declared. Injectables pass
@@ -843,7 +870,7 @@ export function getInjectable2<
   readonly id: string;
   readonly consumptions?: ReadonlyArray<Cons>;
   readonly instantiate: (di: ConsumptionDi<Cons>) => F;
-  readonly injectionToken: Token2<TF, any, undefined, any>;
+  readonly injectionToken: InjectionTokenOf<Token2<TF, any, undefined, any>>;
   readonly transient?: boolean;
   readonly causesSideEffects?: boolean;
   readonly tags?: string[];
@@ -1580,6 +1607,26 @@ export interface DiContainerForInjection2 {
   injectManyWithMeta: InjectManyWithMeta2;
   injectMaybeWithMeta: InjectMaybeWithMeta2;
 
+  // ---- Identity of the injectable being instantiated ----
+  //
+  // For instantiate-code shared across injectables: decorators, and
+  // factories producing many injectables from one `instantiate`. An
+  // imperative override sees the identity of the injectable it stands in
+  // for, since that is what was registered.
+
+  // The injectable's own id, as given to `getInjectable2`.
+  readonly id: string;
+
+  // The ids of the scopes the injectable was registered under, outermost
+  // first and the immediate owner last — the segments of its namespaced id
+  // minus its own; empty at container level. Each read walks the
+  // registration tree and returns a fresh array.
+  readonly scopeIds: string[];
+
+  // `scopeIds` followed by `id`: the segments of the namespaced id. Each read
+  // walks the registration tree and returns a fresh array.
+  readonly scopedId: string[];
+
   register(...injectables: (Alias | InjectableBunch)[]): void;
 
   deregister(...injectables: (Alias | InjectableBunch)[]): void;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@k8slens/injectable",
   "private": false,
-  "version": "26.0.0",
+  "version": "26.2.0",
   "description": "A brutal dependency injection container",
   "lens": {
     "env": "agnostic",