@lppedd/di-wise-neo 0.13.0 → 0.14.1

package/dist/cjs/index.d.ts

@@ -1,5 +1,54 @@
+declare const Scope: {
+    /**
+     * Creates a new value every time the token is resolved.
+     */
+    readonly Transient: "Transient";
+    /**
+     * Creates and caches a single value per token resolution graph.
+     *
+     * The same value is reused during a single resolution request and is subsequently discarded.
+     */
+    readonly Resolution: "Resolution";
+    /**
+     * Creates and caches a single value per container.
+     *
+     * If the value is not found in the current container, it is looked up in the parent container,
+     * and so on. It effectively behaves like a _singleton_ scope but allows container-specific overrides.
+     */
+    readonly Container: "Container";
+};
+type Scope = (typeof Scope)[keyof typeof Scope];
+
+/**
+ * Token registration options.
+ */
+interface RegistrationOptions {
+    /**
+     * The scope of the registration.
+     */
+    readonly scope?: Scope;
+}
 /**
- * Type API.
+ * 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;
+ *     }),
+ *   );
+ * }
+ * ```
+ */
+declare function build<Value>(factory: (...args: []) => Value): Type<Value>;
+
+/**
+ * An injectable type `T`.
  */
 interface Type<T> {
     /**
@@ -9,11 +58,24 @@ interface Type<T> {
     /**
      * Ensures that different `Type<T>` types are not structurally compatible.
      *
-     * This property is never used at runtime.
+     * This property is always `undefined` and is never used at runtime.
      *
      * @private
      */
-    readonly __type?: T;
+    readonly __type: T | undefined;
+}
+/**
+ * An injectable type `T` with a default {@link Provider} and optional default registration options.
+ */
+interface ProviderType<T> extends Type<T> {
+    /**
+     * The type's default provider.
+     */
+    readonly provider: Provider<T>;
+    /**
+     * The type's default registration options.
+     */
+    readonly options?: RegistrationOptions;
 }
 /**
  * Constructor type.
@@ -25,7 +87,7 @@ interface Constructor<Instance extends object> {
 /**
  * Token type.
  */
-type Token<Value = any> = [Value] extends [object] ? Type<Value> | Constructor<Value> : Type<Value>;
+type Token<Value = any> = [Value] extends [object] ? Type<Value> | Constructor<Value & object> : Type<Value>;
 /**
  * Describes a {@link Token} array with at least one element.
  */
@@ -36,11 +98,26 @@ type Tokens<Value = any> = [Token<Value>, ...Token<Value>[]];
  * @example
  * ```ts
  * const ISpell = createType<Spell>("Spell");
+ * container.register(ISpell, {
+ *   useFactory: () => getDefaultSpell(),
+ * });
  * ```
- *
- * @__NO_SIDE_EFFECTS__
  */
 declare function createType<T>(typeName: string): Type<T>;
+/**
+ * Creates a type token with a default {@link Provider} and optional default registration options.
+ *
+ * @example
+ * ```ts
+ * // Notice how we pass in a Provider directly at type creation site
+ * const ISpell = createType<Spell>("Spell", {
+ *   useFactory: () => getDefaultSpell(),
+ * });
+ *
+ * container.register(ISpell);
+ * ```
+ */
+declare function createType<T>(typeName: string, provider: Provider<T>, options?: RegistrationOptions): ProviderType<T>;
 
 /**
  * Provides a class instance for a token via a class constructor.
@@ -166,55 +243,6 @@ interface ExistingProvider<Value> {
  */
 type Provider<Value = any> = ClassProvider<Value & object> | FactoryProvider<Value> | ValueProvider<Value> | ExistingProvider<Value>;
 
-declare const Scope: {
-    /**
-     * Creates a new value every time the token is resolved.
-     */
-    readonly Transient: "Transient";
-    /**
-     * Creates and caches a single value per token resolution graph.
-     *
-     * The same value is reused during a single resolution request and is subsequently discarded.
-     */
-    readonly Resolution: "Resolution";
-    /**
-     * Creates and caches a single value per container.
-     *
-     * If the value is not found in the current container, it is looked up in the parent container,
-     * and so on. It effectively behaves like a _singleton_ scope but allows container-specific overrides.
-     */
-    readonly Container: "Container";
-};
-type Scope = (typeof Scope)[keyof typeof Scope];
-
-/**
- * Token registration options.
- */
-interface RegistrationOptions {
-    /**
-     * The scope of the registration.
-     */
-    readonly scope?: Scope;
-}
-/**
- * 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;
- *     }),
- *   );
- * }
- * ```
- */
-declare function build<Value>(factory: (...args: []) => Value): Type<Value>;
-
 /**
  * Container creation options.
  */
@@ -308,6 +336,10 @@ interface Container {
      * or by the {@link ContainerOptions.defaultScope} value.
      */
     register<Instance extends object>(Class: Constructor<Instance>): Container;
+    /**
+     * Registers a token type with a default {@link Provider} and optional default registration options.
+     */
+    register<Value>(token: ProviderType<Value>): Container;
     /**
      * Registers a {@link ClassProvider} with a token.
      *
@@ -1056,4 +1088,4 @@ declare function optionalAll<Instance extends object>(Class: Constructor<Instanc
 declare function optionalAll<Value>(token: Token<Value>): Value[];
 
 export { AutoRegister, EagerInstantiate, Inject, InjectAll, Injectable, Injector, Named, Optional, OptionalAll, Scope, Scoped, applyMiddleware, build, createContainer, createType, forwardRef, inject, injectAll, injectBy, optional, optionalAll, optionalBy, setClassIdentityMapping };
-export type { ClassProvider, Constructor, Container, ContainerOptions, ExistingProvider, FactoryProvider, Middleware, MiddlewareComposer, Provider, RegistrationOptions, Token, TokenRef, Tokens, TokensRef, Type, ValueProvider };
+export type { ClassProvider, Constructor, Container, ContainerOptions, ExistingProvider, FactoryProvider, Middleware, MiddlewareComposer, Provider, ProviderType, RegistrationOptions, Token, TokenRef, Tokens, TokensRef, Type, ValueProvider };

package/dist/cjs/index.js

@@ -337,22 +337,20 @@ const Scope = {
    */ Container: "Container"
 };
 
-/**
- * Type API.
- */ /**
- * Creates a type token.
- *
- * @example
- * ```ts
- * const ISpell = createType<Spell>("Spell");
- * ```
- *
- * @__NO_SIDE_EFFECTS__
- */ function createType(typeName) {
+// @internal
+// @__NO_SIDE_EFFECTS__
+function createType(typeName, provider, options) {
     const name = `Type<${typeName}>`;
-    return {
-        name: name,
-        toString: ()=>name
+    const toString = ()=>name;
+    return provider //
+     ? {
+        name,
+        provider,
+        options,
+        toString
+    } : {
+        name,
+        toString
     };
 }
 // @internal
@@ -573,70 +571,14 @@ function isDisposable(value) {
     register(...args) {
         this.checkDisposed();
         if (args.length === 1) {
-            const Class = args[0];
-            const metadata = getMetadata(Class);
-            const name = metadata.name;
-            const registration = {
-                name: name,
-                // The provider is of type ClassProvider, initialized by getMetadata
-                provider: metadata.provider,
-                options: {
-                    scope: metadata.scope?.value ?? this.myOptions.defaultScope
-                },
-                dependencies: metadata.dependencies
-            };
-            // Register the class itself
-            this.myTokenRegistry.set(Class, registration);
-            // Register the additional tokens specified via class decorators.
-            // These tokens will point to the original Class token and will have the same scope.
-            for (const token of metadata.tokensRef.getRefTokens()){
-                this.myTokenRegistry.set(token, {
-                    name: name,
-                    provider: {
-                        useExisting: [
-                            Class,
-                            name
-                        ]
-                    }
-                });
-            }
-            // Eager-instantiate only if the class is container-scoped
-            if (metadata.eagerInstantiate && registration.options?.scope === Scope.Container) {
-                this.resolveProviderValue(Class, registration);
-            }
-        } else {
-            const [token, provider, options] = args;
-            const name = provider.name;
-            check(name === undefined || name.trim(), `name qualifier for token ${getTokenName(token)} must not be empty`);
-            if (isClassProvider(provider)) {
-                const metadata = getMetadata(provider.useClass);
-                const registration = {
-                    // An explicit provider name overrides what is specified via @Named
-                    name: metadata.name ?? name,
-                    provider: metadata.provider,
-                    options: {
-                        // Explicit registration options override what is specified via class decorators (e.g., @Scoped)
-                        scope: metadata.scope?.value ?? this.myOptions.defaultScope,
-                        ...options
-                    },
-                    dependencies: metadata.dependencies
-                };
-                this.myTokenRegistry.set(token, registration);
-                // Eager-instantiate only if the provided class is container-scoped
-                if (metadata.eagerInstantiate && registration.options?.scope === Scope.Container) {
-                    this.resolveProviderValue(token, registration);
-                }
+            const [token] = args;
+            if (isConstructor(token)) {
+                this.registerClass(token);
             } else {
-                if (isExistingProvider(provider)) {
-                    const [targetToken] = this.getTargetToken(provider);
-                    check(token !== targetToken, `token ${getTokenName(token)} cannot alias itself via useExisting`);
-                }
-                this.myTokenRegistry.set(token, {
-                    name: name,
-                    provider: provider,
-                    options: options
-                });
+                this.registerToken(token, token.provider, token.options);
             }
+        } else {
+            this.registerToken(...args);
         }
         return this;
     }
@@ -693,6 +635,71 @@ function isDisposable(value) {
         // Allow values to be GCed
         disposedRefs.clear();
     }
+    registerClass(Class) {
+        const metadata = getMetadata(Class);
+        const name = metadata.name;
+        const registration = {
+            name: name,
+            // The provider is of type ClassProvider, initialized by getMetadata
+            provider: metadata.provider,
+            options: {
+                scope: metadata.scope?.value ?? this.myOptions.defaultScope
+            },
+            dependencies: metadata.dependencies
+        };
+        // Register the class itself
+        this.myTokenRegistry.set(Class, registration);
+        // Register the additional tokens specified via class decorators.
+        // These tokens will point to the original Class token and will have the same scope.
+        for (const token of metadata.tokensRef.getRefTokens()){
+            this.myTokenRegistry.set(token, {
+                name: name,
+                provider: {
+                    useExisting: [
+                        Class,
+                        name
+                    ]
+                }
+            });
+        }
+        // Eager-instantiate only if the class is container-scoped
+        if (metadata.eagerInstantiate && registration.options?.scope === Scope.Container) {
+            this.resolveProviderValue(Class, registration);
+        }
+    }
+    registerToken(token, provider, options) {
+        const name = provider.name;
+        check(name === undefined || name.trim(), `name qualifier for token ${getTokenName(token)} must not be empty`);
+        if (isClassProvider(provider)) {
+            const metadata = getMetadata(provider.useClass);
+            const registration = {
+                // An explicit provider name overrides what is specified via @Named
+                name: metadata.name ?? name,
+                provider: metadata.provider,
+                options: {
+                    // Explicit registration options override what is specified via class decorators (e.g., @Scoped)
+                    scope: metadata.scope?.value ?? this.myOptions.defaultScope,
+                    ...options
+                },
+                dependencies: metadata.dependencies
+            };
+            this.myTokenRegistry.set(token, registration);
+            // Eager-instantiate only if the provided class is container-scoped
+            if (metadata.eagerInstantiate && registration.options?.scope === Scope.Container) {
+                this.resolveProviderValue(token, registration);
+            }
+        } else {
+            if (isExistingProvider(provider)) {
+                const [targetToken] = this.getTargetToken(provider);
+                check(token !== targetToken, `token ${getTokenName(token)} cannot alias itself via useExisting`);
+            }
+            this.myTokenRegistry.set(token, {
+                name: name,
+                provider: provider,
+                options: options
+            });
+        }
+    }
     resolveToken(token, name, optional) {
         let registration = this.myTokenRegistry.get(token, name);
         if (!registration && isConstructor(token)) {