@codefast/di 0.8.1 → 0.10.0

package/dist/resolution/select/binding-select.js

@@ -7,7 +7,7 @@ import { AmbiguousBindingError } from "#/errors/errors";
  * @since 0.3.16-canary.0
  */
 export function selectBinding(bindings, options, ctx, tokenDisplayName) {
-    const candidates = filterBindings(bindings, options, ctx, true);
+    const candidates = filterBindings(bindings, options, ctx, true, false);
     if (candidates.length === 0) {
         return undefined;
     }
@@ -36,7 +36,7 @@ export function selectBinding(bindings, options, ctx, tokenDisplayName) {
     if (mostSpecific !== undefined) {
         return mostSpecific;
     }
-    throw new AmbiguousBindingError(tokenDisplayName, candidates.map((c) => c.id));
+    throw new AmbiguousBindingError(tokenDisplayName, candidates.map((c) => c.identifier));
 }
 /** The lone candidate declaring more criteria than every other, or `undefined` when that is a tie. */
 function mostSpecificByCriterionCount(candidates) {
@@ -64,7 +64,7 @@ function mostSpecificByCriterionCount(candidates) {
 export function selectAllBindings(bindings, options, ctx) {
     // `resolveAll` matches the slot only when the request carries a criterion; with none it takes
     // every binding, where `resolve` would read an absent criterion as "the default slot".
-    return filterBindings(bindings, options, ctx, options !== undefined && hasSlotCriterion(options));
+    return filterBindings(bindings, options, ctx, options !== undefined && hasSlotCriterion(options), true);
 }
 /**
  * @param bindings - the token's candidates, in registration order
@@ -72,13 +72,18 @@ export function selectAllBindings(bindings, options, ctx) {
  * @param ctx - what the constraint predicates read
  * @param requiresSlotMatch - `resolve` always matches the slot, where an absent criterion means
  * "the default slot"; `resolveAll` matches only when the request carries one
+ * @param includesMembers - `resolveAll` takes collection members; a single `resolve` never does
  */
-function filterBindings(bindings, options, ctx, requiresSlotMatch) {
+function filterBindings(bindings, options, ctx, requiresSlotMatch, includesMembers) {
     const result = [];
-    // A predicate is user code that may rebind the token mid-walk, but the registry replaces a
-    // token's list on mutation instead of splicing it, so this walk keeps its own list — no copy.
-    for (let index = 0; index < bindings.length; index += 1) {
+    // A predicate is user code that may rebind the token mid-walk. A removal replaces the list, and an
+    // append lands past the length read here, so the walk offers exactly the candidates it started with.
+    const length = bindings.length;
+    for (let index = 0; index < length; index += 1) {
         const binding = bindings[index];
+        if (!includesMembers && binding.isMany) {
+            continue;
+        }
         if (requiresSlotMatch && !matchesSlot(binding.slot, options)) {
             continue;
         }

package/dist/resolution/select/constraints.d.ts

@@ -26,17 +26,20 @@ export declare function whenAnyAncestorIs(token: Token<unknown> | Constructor):
  */
 export declare function whenNoAncestorIs(token: Token<unknown> | Constructor): BindingConstraint;
 /**
- * Matches when the direct parent slot carries the given name.
+ * Matches when the direct parent resolves the given token at the slot carrying the given name.
+ *
+ * @remarks A slot name is a label on one token's bindings, so the token is part of the question — and
+ * what types `name` to the names that token declares.
  *
  * @since 0.3.16-canary.0
  */
-export declare function whenParentNamed(name: string): BindingConstraint;
+export declare function whenParentNamed<Names extends string>(token: Token<unknown, Names> | Constructor, name: NoInfer<Names>): BindingConstraint;
 /**
- * Matches when at least one ancestor slot carries the given name.
+ * Matches when at least one ancestor resolves the given token at the slot carrying the given name.
  *
  * @since 0.3.16-canary.0
  */
-export declare function whenAnyAncestorNamed(name: string): BindingConstraint;
+export declare function whenAnyAncestorNamed<Names extends string>(token: Token<unknown, Names> | Constructor, name: NoInfer<Names>): BindingConstraint;
 /**
  * Matches when the direct parent slot carries the given tag pair.
  *

package/dist/resolution/select/constraints.js

@@ -1,5 +1,5 @@
-import { requiringAncestorSlotName } from "#/core/constraint-requirement";
-import { coversTagKeys, tagKeyMaskOf } from "#/core/tag";
+import { requiringAncestorSlotName, requiringAncestorSlotNames } from "#/core/constraint-requirement";
+import { coversTagKeys, slotName, tagKeyMaskOf } from "#/core/tag";
 import { tokenName } from "#/core/token";
 import { EmptyTagCriteriaError } from "#/errors/errors";
 /**
@@ -39,20 +39,27 @@ export function whenNoAncestorIs(token) {
     return (constraintContext) => constraintContext.ancestors.every((ancestorFrame) => ancestorFrame.tokenName !== tokenDisplayName);
 }
 /**
- * Matches when the direct parent slot carries the given name.
+ * Matches when the direct parent resolves the given token at the slot carrying the given name.
+ *
+ * @remarks A slot name is a label on one token's bindings, so the token is part of the question — and
+ * what types `name` to the names that token declares.
  *
  * @since 0.3.16-canary.0
  */
-export function whenParentNamed(name) {
-    return requiringAncestorSlotName((constraintContext) => constraintContext.parent !== undefined && constraintContext.parent.slot.name === name, name, "whenParentNamed");
+export function whenParentNamed(token, name) {
+    const parentTokenName = tokenName(token);
+    return requiringAncestorSlotName((constraintContext) => constraintContext.parent !== undefined &&
+        constraintContext.parent.tokenName === parentTokenName &&
+        constraintContext.parent.slot.name === name, { tokenName: parentTokenName, name, helperName: "whenParentNamed" });
 }
 /**
- * Matches when at least one ancestor slot carries the given name.
+ * Matches when at least one ancestor resolves the given token at the slot carrying the given name.
  *
  * @since 0.3.16-canary.0
  */
-export function whenAnyAncestorNamed(name) {
-    return requiringAncestorSlotName((constraintContext) => constraintContext.ancestors.some((ancestorFrame) => ancestorFrame.slot.name === name), name, "whenAnyAncestorNamed");
+export function whenAnyAncestorNamed(token, name) {
+    const ancestorTokenName = tokenName(token);
+    return requiringAncestorSlotName((constraintContext) => constraintContext.ancestors.some((ancestorFrame) => ancestorFrame.tokenName === ancestorTokenName && ancestorFrame.slot.name === name), { tokenName: ancestorTokenName, name, helperName: "whenAnyAncestorNamed" });
 }
 /**
  * Matches when the direct parent slot carries the given tag pair.
@@ -60,7 +67,7 @@ export function whenAnyAncestorNamed(name) {
  * @since 0.3.16-canary.0
  */
 export function whenParentTagged(criterion) {
-    return (constraintContext) => constraintContext.parent !== undefined && constraintContext.parent.slot.tags.includes(criterion);
+    return requiringReservedNamesAmong((constraintContext) => constraintContext.parent !== undefined && constraintContext.parent.slot.tags.includes(criterion), [criterion], "whenParentTagged");
 }
 /**
  * Matches when at least one ancestor slot carries the given tag pair.
@@ -68,7 +75,7 @@ export function whenParentTagged(criterion) {
  * @since 0.3.16-canary.0
  */
 export function whenAnyAncestorTagged(criterion) {
-    return (constraintContext) => constraintContext.ancestors.some((ancestorFrame) => ancestorFrame.slot.tags.includes(criterion));
+    return requiringReservedNamesAmong((constraintContext) => constraintContext.ancestors.some((ancestorFrame) => ancestorFrame.slot.tags.includes(criterion)), [criterion], "whenAnyAncestorTagged");
 }
 /**
  * Matches when the direct parent slot carries **all** of the given tag pairs.
@@ -80,13 +87,13 @@ export function whenAnyAncestorTagged(criterion) {
 export function whenParentTaggedAll(tags) {
     assertHasCriteria(tags, "whenParentTaggedAll");
     const wanted = tagKeyMaskOf(tags);
-    return (constraintContext) => {
+    return requiringReservedNamesAmong((constraintContext) => {
         const { parent } = constraintContext;
         if (parent === undefined || !coversTagKeys(parent.slot.keyMask, wanted)) {
             return false;
         }
         return tags.every((criterion) => parent.slot.tags.includes(criterion));
-    };
+    }, tags, "whenParentTaggedAll");
 }
 /**
  * Matches when at least one ancestor slot carries **all** of the given tag pairs.
@@ -98,7 +105,21 @@ export function whenParentTaggedAll(tags) {
 export function whenAnyAncestorTaggedAll(tags) {
     assertHasCriteria(tags, "whenAnyAncestorTaggedAll");
     const wanted = tagKeyMaskOf(tags);
-    return (constraintContext) => constraintContext.ancestors.some((frame) => coversTagKeys(frame.slot.keyMask, wanted) && tags.every((criterion) => frame.slot.tags.includes(criterion)));
+    return requiringReservedNamesAmong((constraintContext) => constraintContext.ancestors.some((frame) => coversTagKeys(frame.slot.keyMask, wanted) && tags.every((criterion) => frame.slot.tags.includes(criterion))), tags, "whenAnyAncestorTaggedAll");
+}
+/**
+ * Records a requirement for every reserved-key criterion in a list, so a name spelled through the tag
+ * lane is validated exactly as one spelled through `whenNamed`.
+ */
+function requiringReservedNamesAmong(predicate, tags, helperName) {
+    let requirements;
+    for (const criterion of tags) {
+        if (criterion.key === slotName) {
+            requirements ??= [];
+            requirements.push({ tokenName: undefined, name: criterion.value, helperName });
+        }
+    }
+    return requirements === undefined ? predicate : requiringAncestorSlotNames(predicate, requirements);
 }
 /**
  * Refuses a criteria list with nothing in it.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codefast/di",
-  "version": "0.8.1",
+  "version": "0.10.0",
   "description": "Lightweight dependency injection primitives for Codefast",
   "keywords": [
     "codefast",
@@ -9,8 +9,12 @@
     "inversion-of-control",
     "typescript"
   ],
+  "homepage": "https://github.com/codefastlabs/codefast/tree/main/packages/di#readme",
+  "bugs": {
+    "url": "https://github.com/codefastlabs/codefast/issues"
+  },
   "license": "MIT",
-  "author": "Vuong Phan <mr.thevuong@gmail.com>",
+  "author": "Vuong Phan <mr.thevuong@gmail.com> (https://github.com/thevuong)",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/codefastlabs/codefast.git",
@@ -28,20 +32,6 @@
   "module": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "imports": {
-    "#/tests/*": [
-      "./tests/*",
-      "./tests/*.ts",
-      "./tests/*.tsx",
-      "./tests/*/index.ts",
-      "./tests/*/index.tsx"
-    ],
-    "#/examples/*": [
-      "./examples/*",
-      "./examples/*.ts",
-      "./examples/*.tsx",
-      "./examples/*/index.ts",
-      "./examples/*/index.tsx"
-    ],
     "#/*": {
       "types": "./dist/*.d.ts",
       "default": "./dist/*.js"
@@ -92,6 +82,10 @@
       "types": "./dist/core/registry.d.ts",
       "import": "./dist/core/registry.js"
     },
+    "./core/state-epoch": {
+      "types": "./dist/core/state-epoch.d.ts",
+      "import": "./dist/core/state-epoch.js"
+    },
     "./core/tag": {
       "types": "./dist/core/tag.d.ts",
       "import": "./dist/core/tag.js"
@@ -208,6 +202,10 @@
       "types": "./dist/resolution/plan/instantiation-plan.d.ts",
       "import": "./dist/resolution/plan/instantiation-plan.js"
     },
+    "./resolution/plan/plan-codegen": {
+      "types": "./dist/resolution/plan/plan-codegen.d.ts",
+      "import": "./dist/resolution/plan/plan-codegen.js"
+    },
     "./resolution/resolver": {
       "types": "./dist/resolution/resolver.d.ts",
       "import": "./dist/resolution/resolver.js"
@@ -225,31 +223,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "devDependencies": {
-    "@babel/core": "^8.0.1",
-    "@babel/plugin-proposal-decorators": "8.0.2",
-    "@rolldown/plugin-babel": "^0.2.3",
-    "@types/node": "^26.4.1",
-    "@vitest/coverage-v8": "^5.0.0",
-    "tsx": "^4.23.13",
-    "typescript": "^7.0.2",
-    "vitest": "^5.0.0",
-    "@codefast/typescript-config": "0.9.0"
-  },
   "engines": {
     "node": ">=24.0.0"
-  },
-  "scripts": {
-    "build": "rm -rf dist && tsc -p tsconfig.build.json",
-    "check-types": "tsc --noEmit",
-    "clean": "rm -rf dist",
-    "examples": "node examples/run.mjs",
-    "test": "vitest run",
-    "test:coverage": "vitest run --coverage",
-    "test:e2e": "vitest run tests/e2e",
-    "test:integration": "vitest run tests/integration",
-    "test:type": "vitest run tests/types",
-    "test:unit": "vitest run tests/unit",
-    "test:watch": "vitest"
   }
 }