@lppedd/di-wise-neo 0.7.1 → 0.8.0

package/dist/es/index.d.mts

@@ -187,8 +187,6 @@ interface RegistrationOptions {
  *   );
  * }
  * ```
- *
- * @__NO_SIDE_EFFECTS__
  */
 declare function build<Value>(factory: (...args: []) => Value): Type<Value>;
 
@@ -811,6 +809,17 @@ interface Injector {
      * or an empty array if the token is not registered in the container.
      */
     optionalAll<Value>(token: Token<Value>): NonNullable<Value>[];
+    /**
+     * Runs a function inside the injection context of this injector.
+     *
+     * Note that injection functions (`inject`, `injectAll`, `optional`, `optionalAll`)
+     * are only usable synchronously: they cannot be called from asynchronous callbacks
+     * or after any `await` points.
+     *
+     * @param fn The function to be run in the context of this injector.
+     * @returns The return value of the function, if any.
+     */
+    runInContext<ReturnType>(fn: () => ReturnType): ReturnType;
 }
 /**
  * Injector token for dynamic injections.

package/dist/es/index.mjs

@@ -29,23 +29,6 @@ function untag(message) {
     return message.startsWith("[di-wise-neo]") ? message.substring(13).trimStart() : message;
 }
 
-// @internal
-function createInjectionContext() {
-    let current = null;
-    function provide(next) {
-        const prev = current;
-        current = next;
-        return ()=>current = prev;
-    }
-    function use() {
-        return current;
-    }
-    return [
-        provide,
-        use
-    ];
-}
-
 // @internal
 function invariant(condition) {
     if (!condition) {
@@ -115,18 +98,33 @@ function createResolution() {
 // @internal
 const [provideInjectionContext, useInjectionContext] = createInjectionContext();
 // @internal
-function ensureInjectionContext(fn) {
+function ensureInjectionContext(name) {
     const context = useInjectionContext();
-    assert(context, `${fn.name}() can only be invoked within an injection context`);
+    assert(context, `${name} can only be invoked within an injection context`);
     return context;
 }
+function createInjectionContext() {
+    let current = null;
+    function provide(next) {
+        const prev = current;
+        current = next;
+        return ()=>current = prev;
+    }
+    function use() {
+        return current;
+    }
+    return [
+        provide,
+        use
+    ];
+}
 
 function inject(token, name) {
-    const context = ensureInjectionContext(inject);
+    const context = ensureInjectionContext("inject()");
     return context.container.resolve(token, name);
 }
 function injectBy(thisArg, token, name) {
-    const context = ensureInjectionContext(injectBy);
+    const context = ensureInjectionContext("injectBy()");
     const resolution = context.resolution;
     const currentFrame = resolution.stack.peek();
     if (!currentFrame) {
@@ -144,7 +142,7 @@ function injectBy(thisArg, token, name) {
 }
 
 function injectAll(token) {
-    const context = ensureInjectionContext(injectAll);
+    const context = ensureInjectionContext("injectAll()");
     return context.container.resolveAll(token);
 }
 
@@ -240,11 +238,11 @@ const classIdentityMap = new WeakMap();
 const metadataMap = new WeakMap();
 
 function optional(token, name) {
-    const context = ensureInjectionContext(optional);
+    const context = ensureInjectionContext("optional()");
     return context.container.resolve(token, true, name);
 }
 function optionalBy(thisArg, token, name) {
-    const context = ensureInjectionContext(optionalBy);
+    const context = ensureInjectionContext("optionalBy()");
     const resolution = context.resolution;
     const currentFrame = resolution.stack.peek();
     if (!currentFrame) {
@@ -262,7 +260,7 @@ function optionalBy(thisArg, token, name) {
 }
 
 function optionalAll(token) {
-    const context = ensureInjectionContext(optionalAll);
+    const context = ensureInjectionContext("optionalAll()");
     return context.container.resolveAll(token, true);
 }
 
@@ -428,26 +426,9 @@ class TokenRegistry {
 function isBuilder(provider) {
     return builders.has(provider);
 }
-/**
- * Create a one-off type token from a factory function.
- *
- * @example
- * ```ts
- * class Wizard {
- *   wand = inject(
- *     build(() => {
- *       const wand = inject(Wand);
- *       wand.owner = this;
- *       // ...
- *       return wand;
- *     }),
- *   );
- * }
- * ```
- *
- * @__NO_SIDE_EFFECTS__
- */ function build(factory) {
-    const token = createType(`Build<${getTypeName(factory)}>`);
+// @__NO_SIDE_EFFECTS__
+function build(factory, name) {
+    const token = createType(name ?? `Build<${getTypeName(factory)}>`);
     const provider = {
         useFactory: factory
     };
@@ -575,6 +556,9 @@ function isDisposable(value) {
             }
         } else {
             const [token, provider, options] = args;
+            const existingProvider = isExistingProvider(provider);
+            const name = existingProvider ? undefined : provider.name;
+            assert(name === undefined || name.trim(), "the provider name qualifier cannot be empty or blank");
             if (isClassProvider(provider)) {
                 const metadata = getMetadata(provider.useClass);
                 const registration = {
@@ -594,12 +578,11 @@ function isDisposable(value) {
                     this.resolveProviderValue(registration, registration.provider);
                 }
             } else {
-                const existingProvider = isExistingProvider(provider);
                 if (existingProvider) {
                     assert(token !== provider.useExisting, `the useExisting token ${token.name} cannot be the same as the token being registered`);
                 }
                 this.myTokenRegistry.set(token, {
-                    name: existingProvider ? undefined : provider.name,
+                    name: name,
                     provider: provider,
                     options: options
                 });
@@ -1152,12 +1135,12 @@ function OptionalAll(token) {
  * const wizard = container.resolve(Wizard);
  * wizard.getWand(); // => Wand
  * ```
- */ const Injector = /*@__PURE__*/ build(function Injector() {
-    const context = ensureInjectionContext(Injector);
+ */ const Injector = /*@__PURE__*/ build(()=>{
+    const context = ensureInjectionContext("Injector factory");
     const resolution = context.resolution;
     const dependentFrame = resolution.stack.peek();
     const dependentRef = dependentFrame && resolution.dependents.get(dependentFrame.provider);
-    function withCurrentContext(fn) {
+    function withContext(fn) {
         if (useInjectionContext()) {
             return fn();
         }
@@ -1169,18 +1152,17 @@ function OptionalAll(token) {
         try {
             return fn();
         } finally{
-            for (const cleanup of cleanups){
-                cleanup?.();
-            }
+            cleanups.forEach((cleanup)=>cleanup?.());
         }
     }
     return {
-        inject: (token, name)=>withCurrentContext(()=>inject(token, name)),
-        injectAll: (token)=>withCurrentContext(()=>injectAll(token)),
-        optional: (token, name)=>withCurrentContext(()=>optional(token, name)),
-        optionalAll: (token)=>withCurrentContext(()=>optionalAll(token))
+        inject: (token, name)=>withContext(()=>inject(token, name)),
+        injectAll: (token)=>withContext(()=>injectAll(token)),
+        optional: (token, name)=>withContext(()=>optional(token, name)),
+        optionalAll: (token)=>withContext(()=>optionalAll(token)),
+        runInContext: withContext
     };
-});
+}, "Injector");
 
 /**
  * Applies middleware functions to a container.