@lppedd/di-wise-neo 0.21.0 → 0.22.0

package/dist/cjs/index.d.ts

@@ -29,7 +29,7 @@ interface RegistrationOptions {
     /**
      * The scope of the registration.
      */
-    readonly scope?: Scope;
+    readonly scope?: Scope | undefined;
 }
 /**
  * Create a one-off type token from a factory function.
@@ -82,7 +82,7 @@ interface ProviderType<T> extends Type<T> {
     /**
      * The type's default registration options.
      */
-    readonly options?: RegistrationOptions;
+    readonly options?: RegistrationOptions | undefined;
 }
 /**
  * Constructor type.
@@ -168,7 +168,7 @@ interface ClassProvider<Instance extends object> {
      * }
      * ```
      */
-    readonly name?: string;
+    readonly name?: string | undefined;
 }
 /**
  * Provides a value for a token via a factory function.
@@ -196,7 +196,7 @@ interface FactoryProvider<Value> {
      * }
      * ```
      */
-    readonly name?: string;
+    readonly name?: string | undefined;
 }
 /**
  * Provides a static - already constructed - value for a token.
@@ -221,7 +221,7 @@ interface ValueProvider<Value> {
      * }
      * ```
      */
-    readonly name?: string;
+    readonly name?: string | undefined;
 }
 /**
  * Aliases another registered token.
@@ -244,7 +244,7 @@ interface ExistingProvider<Value> {
      * });
      * ```
      */
-    readonly useExisting: Token<Value> | [Token<Value>, string?];
+    readonly useExisting: Token<Value> | [Token<Value>, (string | undefined)?];
     /**
      * An optional name to qualify this provider.
      * If specified, the token must be resolved using the same name.
@@ -260,13 +260,19 @@ interface ExistingProvider<Value> {
      * }
      * ```
      */
-    readonly name?: string;
+    readonly name?: string | undefined;
 }
 /**
  * A token provider.
  */
 type Provider<Value> = ClassProvider<Value & object> | FactoryProvider<Value> | ValueProvider<Value> | ExistingProvider<Value>;
 
+type RequiredNonNullable<T> = {
+    [P in keyof T]-?: NonNullable<T[P]>;
+};
+
+type ProviderFor<V> = V extends object ? Provider<V> : Exclude<Provider<V>, ClassProvider<any>>;
+type RegistrationOptionsFor<P> = P extends ValueProvider<any> ? never : RegistrationOptions;
 /**
  * Container creation options.
  */
@@ -276,20 +282,20 @@ interface ContainerOptions {
      *
      * @defaultValue Transient
      */
-    readonly defaultScope: Scope;
+    readonly defaultScope?: Scope | undefined;
     /**
      * Whether to automatically register an unregistered class when resolving it as a token.
      *
      * @defaultValue false
      */
-    readonly autoRegister: boolean;
+    readonly autoRegister?: boolean | undefined;
     /**
      * Whether to also dispose values provided via {@link ValueProvider}, which are not
      * created or managed by the container, when the container itself is disposed.
      *
      * @defaultValue false
      */
-    readonly disposeUnmanaged: boolean;
+    readonly disposeUnmanaged?: boolean | undefined;
 }
 /**
  * Child container creation options.
@@ -300,7 +306,7 @@ interface ChildContainerOptions extends ContainerOptions {
      *
      * @defaultValue true
      */
-    readonly copyHooks: boolean;
+    readonly copyHooks?: boolean | undefined;
 }
 /**
  * A hook into the lifecycle of a {@link Container}.
@@ -316,14 +322,14 @@ interface ContainerHook {
      * @param value - The provided value.
      * @param scope - The {@link Scope} of the provided value.
      */
-    readonly onProvide?: (value: unknown, scope: Scope) => void;
+    readonly onProvide?: ((value: unknown, scope: Scope) => void) | undefined;
     /**
      * Called after the container has been disposed.
      *
      * @param values - All distinct values that were cached by the disposed container.
      *   Currently, only **Container**-scoped token values are cached.
      */
-    readonly onDispose?: (values: unknown[]) => void;
+    readonly onDispose?: ((values: unknown[]) => void) | undefined;
 }
 /**
  * A Dependency Injection container.
@@ -332,7 +338,7 @@ interface Container {
     /**
      * The options used to create this container.
      */
-    readonly options: ContainerOptions;
+    readonly options: RequiredNonNullable<ContainerOptions>;
     /**
      * The parent container, or `undefined` if this is the root container.
      */
@@ -346,7 +352,7 @@ interface Container {
      *
      * You can pass specific options to override the inherited ones.
      */
-    createChild(options?: Partial<ChildContainerOptions>): Container;
+    createChild(options?: ChildContainerOptions): Container;
     /**
      * Clears and returns all distinct values cached by this container.
      * Values from {@link ValueProvider} registrations are not included, as they are never cached.
@@ -406,6 +412,23 @@ interface Container {
      * Registers a token type with a default {@link Provider} and optional default registration options.
      */
     register<Value>(token: ProviderType<Value>): Container;
+    /**
+     * Registers a {@link Provider} with a token or class.
+     *
+     * The provider must be one of:
+     * - {@link ClassProvider} via `useClass`
+     * - {@link FactoryProvider} via `useFactory`
+     * - {@link ValueProvider} via `useValue`
+     * - {@link ExistingProvider} via `useExisting`
+     *
+     * For {@link ClassProvider} registrations, the default scope is determined by the {@link Scoped}
+     * decorator applied to the provided class - if present - or by the {@link ContainerOptions.defaultScope}
+     * value, but it can be overridden by passing explicit registration options.
+     *
+     * For {@link ValueProvider} registrations, the provided value is returned as-is and never cached,
+     * and registration options do not apply.
+     */
+    register<Value, ProviderValue extends Value, Provider extends ProviderFor<ProviderValue>>(token: Token<Value>, provider: ProviderFor<ProviderValue> & Provider, options?: RegistrationOptionsFor<Provider>): Container;
     /**
      * Registers a {@link ClassProvider} with a token.
      *
@@ -638,7 +661,7 @@ interface Container {
 /**
  * Creates a new container.
  */
-declare function createContainer(options?: Partial<ContainerOptions>): Container;
+declare function createContainer(options?: ContainerOptions): Container;
 
 /**
  * Class decorator that enables auto-registration of an unregistered class

package/dist/cjs/index.js

@@ -1,6 +1,5 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
-// @internal
 function check(condition, message) {
     if (!condition) {
         throw new Error(tag(typeof message === "string" ? message : message()));
@@ -104,7 +103,7 @@ class KeyedStack {
         return this.myEntries.at(-1)?.value;
     }
     push(key, value) {
-        check(!this.has(key), "invariant violation");
+        check(!this.has(key), "internal: invariant violation");
         this.myKeys.add(key);
         this.myEntries.push({
             key,
@@ -135,7 +134,7 @@ class WeakRefMap {
         return undefined;
     }
     set(key, value) {
-        check(!this.get(key), "invariant violation");
+        check(!this.get(key), "internal: invariant violation");
         this.myMap.set(key, new WeakRef(value));
         return ()=>{
             this.myMap.delete(key);
@@ -230,7 +229,7 @@ function tokenRef(token) {
     return {
         getRefToken: ()=>{
             const tokenOrTokens = token();
-            check(!Array.isArray(tokenOrTokens), "internal error: single token expected");
+            check(!Array.isArray(tokenOrTokens), "internal: unexpected array of tokens");
             return tokenOrTokens;
         },
         getRefTokens: ()=>{
@@ -260,10 +259,7 @@ class Metadata {
             methods: new Map()
         };
         this.tokenRef = {
-            // prettier-ignore
-            getRefToken: ()=>{
-                check(false, "internal error: unexpected call");
-            },
+            getRefToken: ()=>check(false, "internal: unexpected getRefToken call"),
             getRefTokens: ()=>new Set()
         };
         this.provider = {
@@ -471,6 +467,7 @@ function isConstructor(token) {
 
 // @internal
 function getTypeName(value) {
+    // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check
     switch(typeof value){
         case "string":
             return `"${value}"`;
@@ -511,7 +508,7 @@ class TokenRegistry {
         ] || this.getAllFromParent(token, name);
     }
     put(token, registration) {
-        check(!internals.has(token), `cannot register reserved token ${token.name}`);
+        check(!internals.has(token), `internal: cannot register reserved token ${token.name}`);
         let registrations = this.myRegistrations.get(token);
         if (registrations) {
             const name = registration.name;
@@ -575,7 +572,7 @@ class TokenRegistry {
         let registrations = this.myRegistrations.get(token) || this.myParent?.getAllFromParent(token, name);
         if (registrations && name !== undefined) {
             registrations = registrations.filter((r)=>r.name === name);
-            check(registrations.length < 2, `internal error: more than one registration named '${name}'`);
+            check(registrations.length < 2, `internal: multiple registrations with name '${name}'`);
         }
         return registrations ?? [];
     }
@@ -644,7 +641,7 @@ function isDisposable(value) {
             defaultScope: options?.defaultScope ?? this.myOptions.defaultScope,
             autoRegister: options?.autoRegister ?? this.myOptions.autoRegister,
             disposeUnmanaged: options?.disposeUnmanaged ?? this.myOptions.disposeUnmanaged,
-            copyHooks: options?.copyHooks
+            copyHooks: options?.copyHooks ?? true
         });
         this.myChildren.add(container);
         return container;
@@ -732,9 +729,11 @@ function isDisposable(value) {
         return this.resolveAllToken(token, true);
     }
     addHook(hook) {
+        this.checkDisposed();
         this.myHookRegistry.add(hook);
     }
     removeHook(hook) {
+        this.checkDisposed();
         this.myHookRegistry.delete(hook);
     }
     dispose() {
@@ -948,7 +947,7 @@ function isDisposable(value) {
         if (isValueProvider(provider)) {
             return provider.useValue;
         }
-        check(false, "internal error: unexpected ExistingProvider");
+        check(false, "internal: unexpected ExistingProvider");
     }
     resolveScopedValue(token, registration, factory) {
         let context = useInjectionContext();
@@ -1024,7 +1023,7 @@ function isDisposable(value) {
     resolveCtorDependencies(registration) {
         const dependencies = registration.dependencies;
         if (dependencies) {
-            check(isClassProvider(registration.provider), `internal error: not a ClassProvider`);
+            check(isClassProvider(registration.provider), `internal: expected a ClassProvider`);
             const ctorDeps = dependencies.ctor.filter((d)=>d.appliedBy);
             if (ctorDeps.length > 0) {
                 // Let's check if all necessary constructor parameters are decorated.
@@ -1043,7 +1042,7 @@ function isDisposable(value) {
     injectMethodDependencies(registration, instance) {
         const dependencies = registration.dependencies;
         if (dependencies) {
-            check(isClassProvider(registration.provider), `internal error: not a ClassProvider`);
+            check(isClassProvider(registration.provider), `internal: expected a ClassProvider`);
             const ctor = registration.provider.useClass;
             // Perform method injection
             for (const entry of dependencies.methods){
@@ -1090,6 +1089,8 @@ function isDisposable(value) {
                 return instance ? optionalBy(instance, token, name) : this.tryResolve(token, name);
             case "OptionalAll":
                 return instance ? optionalAll(token) : this.tryResolveAll(token);
+            case undefined:
+                check(false, "internal: unexpected undefined appliedBy");
         }
     }
     notifyProvideHooks(value, scope) {