@lppedd/di-wise-neo 0.23.1 → 0.25.0

package/README.md

@@ -512,7 +512,7 @@ Enables automatic registration of the decorated class when it is resolved if it
 been registered beforehand.
 
 ```ts
-@AutoRegister()
+@AutoRegister
 export class ExtensionContext {
   /* ... */
 }
@@ -529,7 +529,7 @@ This causes the container to immediately create and cache the instance of the cl
 at registration time, instead of deferring instantiation until the first resolution.
 
 ```ts
-@EagerInstantiate()
+@EagerInstantiate
 export class ExtensionContext {
   /* ... */
 }

package/dist/cjs/index.d.ts

@@ -55,9 +55,13 @@ declare function build<Value>(factory: (...args: []) => Value): Type<Value>;
  */
 interface Type<T> extends ParameterDecorator {
     /**
-     * The name of the type.
+     * The type's presentable name, in the `Type<debugName>` format.
      */
     readonly name: string;
+    /**
+     * The type's debug name, as passed to {@link createType}.
+     */
+    readonly debugName: string;
     /**
      * Ensures that different `Type<T>` types are not structurally compatible.
      *
@@ -66,10 +70,6 @@ interface Type<T> extends ParameterDecorator {
      * @private
      */
     readonly __type: T | undefined;
-    /**
-     * Returns the type's {@link Type.name|name}.
-     */
-    readonly toString: () => string;
 }
 /**
  * An injectable type `T` with a default {@link Provider} and optional default registration options.
@@ -110,7 +110,7 @@ type Tokens<Value> = [Token<Value>, ...Token<Value>[]];
  * });
  * ```
  */
-declare function createType<T>(typeName: string): Type<T>;
+declare function createType<T>(debugName: string): Type<T>;
 /**
  * Creates a type token with a default {@link Provider} and optional default registration options.
  *
@@ -124,7 +124,7 @@ declare function createType<T>(typeName: string): Type<T>;
  * container.register(ISpell);
  * ```
  */
-declare function createType<T>(typeName: string, provider: Provider<T>, options?: RegistrationOptions): ProviderType<T>;
+declare function createType<T>(debugName: string, provider: Provider<T>, options?: RegistrationOptions): ProviderType<T>;
 
 interface ClassRef<Instance extends object> {
     readonly getRefClass: () => Constructor<Instance>;
@@ -271,8 +271,6 @@ 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.
  */
@@ -412,23 +410,6 @@ 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.
      *
@@ -669,14 +650,14 @@ declare function createContainer(options?: ContainerOptions): Container;
  *
  * Example:
  * ```ts
- * @AutoRegister()
+ * @AutoRegister
  * class Wizard {}
  *
  * const wizard = container.resolve(Wizard);
  * container.isRegistered(Wizard); // => true
  * ```
  */
-declare function AutoRegister<This extends object>(): ClassDecorator<This>;
+declare function AutoRegister<This extends object, Ctor extends Constructor<This>>(target: Ctor): void;
 
 /**
  * Class decorator that sets the class scope to **Container** and enables
@@ -689,7 +670,7 @@ declare function AutoRegister<This extends object>(): ClassDecorator<This>;
  *
  * Example:
  * ```ts
- * @EagerInstantiate()
+ * @EagerInstantiate
  * class Wizard {}
  *
  * // Wizard is registered with Container scope, and an instance
@@ -697,7 +678,7 @@ declare function AutoRegister<This extends object>(): ClassDecorator<This>;
  * container.register(Wizard);
  * ```
  */
-declare function EagerInstantiate<This extends object>(): ClassDecorator<This>;
+declare function EagerInstantiate<This extends object, Ctor extends Constructor<This>>(target: Ctor): void;
 
 /**
  * Parameter decorator that injects the instance associated with the given class.
@@ -938,13 +919,13 @@ declare function OptionalAll<Value>(tokens: TokenRef<Value>): ParameterDecorator
  *
  * Example:
  * ```ts
- * @ContainerScoped()
+ * @ContainerScoped
  * class Wizard {
  *   // ...
  * }
  * ```
  */
-declare function ContainerScoped<This extends object>(): ClassDecorator<This>;
+declare function ContainerScoped<This extends object, Ctor extends Constructor<This>>(target: Ctor): void;
 /**
  * Class decorator that registers the decorated type with the **Resolution** scope.
  *
@@ -953,13 +934,13 @@ declare function ContainerScoped<This extends object>(): ClassDecorator<This>;
  *
  * Example:
  * ```ts
- * @ResolutionScoped()
+ * @ResolutionScoped
  * class Wand {
  *   // ...
  * }
  * ```
  */
-declare function ResolutionScoped<This extends object>(): ClassDecorator<This>;
+declare function ResolutionScoped<This extends object, Ctor extends Constructor<This>>(target: Ctor): void;
 /**
  * Class decorator that registers the decorated type with the **Transient** scope.
  *
@@ -967,13 +948,13 @@ declare function ResolutionScoped<This extends object>(): ClassDecorator<This>;
  *
  * Example:
  * ```ts
- * @TransientScoped()
+ * @TransientScoped
  * class Wand {
  *   // ...
  * }
  * ```
  */
-declare function TransientScoped<This extends object>(): ClassDecorator<This>;
+declare function TransientScoped<This extends object, Ctor extends Constructor<This>>(target: Ctor): void;
 /**
  * Class decorator for setting the scope of the decorated type when registering it.
  *

package/dist/cjs/index.js

@@ -54,14 +54,12 @@ function getTokenPath(tokens) {
 function getTokenName(token) {
     return token.name || "<unnamed>";
 }
+// @internal
 function getFullTokenName([token, name]) {
     const tokenName = token ? token.name || "<unnamed>" : "<undefined token>";
-    return name !== undefined ? `${tokenName}["${name}"]` : tokenName;
+    return name !== undefined ? `${tokenName}['${name}']` : tokenName;
 }
 function getCause(error) {
-    if (!error) {
-        return "";
-    }
     const msg = isError(error) ? error.message : String(error);
     return `\n  [cause] ${untag(msg)}`;
 }
@@ -439,24 +437,25 @@ function describeParam(target, methodKey, parameterIndex) {
 }
 
 // @__NO_SIDE_EFFECTS__
-function createType(typeName, provider, options) {
-    const name = `Type<${typeName}>`;
+function createType(debugName, provider, options) {
     const type = (target, propertyKey, parameterIndex)=>{
-        updateParameterMetadata(name, target, propertyKey, parameterIndex, (dependency)=>{
+        updateParameterMetadata(debugName, target, propertyKey, parameterIndex, (dependency)=>{
             checkSingleDecorator(dependency, target, propertyKey, parameterIndex);
             dependency.appliedBy = "Inject";
             dependency.tokenRef = tokenRef(()=>type);
         });
     };
+    const name = `Type<${debugName}>`;
     Object.defineProperty(type, "name", {
         value: name
     });
+    type.debugName = debugName;
+    type.__type = undefined;
+    type.toString = ()=>name;
     if (provider) {
         type.provider = provider;
         type.options = options;
     }
-    type.__type = undefined;
-    type.toString = ()=>name;
     return type;
 }
 // @internal
@@ -513,7 +512,10 @@ class TokenRegistry {
             const name = registration.name;
             if (name !== undefined) {
                 const existing = registrations.filter((r)=>r.name === name);
-                check(existing.length === 0, `token ${getTokenName(token)} with name '${name}' is already registered`);
+                check(existing.length === 0, `token ${getFullTokenName([
+                    token,
+                    name
+                ])} is already registered`);
             }
         } else {
             this.myRegistrations.set(token, registrations = []);
@@ -581,8 +583,8 @@ function isBuilder(provider) {
     return builders.has(provider);
 }
 // @__NO_SIDE_EFFECTS__
-function build(factory, name) {
-    const token = createType(name ?? `Build<${getTypeName(factory)}>`);
+function build(factory, debugName) {
+    const token = createType(debugName ?? `Build<${getTypeName(factory)}>`);
     const provider = {
         useFactory: factory
     };
@@ -1119,18 +1121,16 @@ function isDisposable(value) {
  *
  * Example:
  * ```ts
- * @AutoRegister()
+ * @AutoRegister
  * class Wizard {}
  *
  * const wizard = container.resolve(Wizard);
  * container.isRegistered(Wizard); // => true
  * ```
  */ // @__NO_SIDE_EFFECTS__
-function AutoRegister() {
-    return (Class)=>{
-        const metadata = getMetadata(Class);
-        metadata.autoRegister = true;
-    };
+function AutoRegister(target) {
+    const metadata = getMetadata(target);
+    metadata.autoRegister = true;
 }
 
 /**
@@ -1144,7 +1144,7 @@ function AutoRegister() {
  *
  * Example:
  * ```ts
- * @EagerInstantiate()
+ * @EagerInstantiate
  * class Wizard {}
  *
  * // Wizard is registered with Container scope, and an instance
@@ -1152,21 +1152,19 @@ function AutoRegister() {
  * container.register(Wizard);
  * ```
  */ // @__NO_SIDE_EFFECTS__
-function EagerInstantiate() {
-    return (Class)=>{
-        const metadata = getMetadata(Class);
-        const currentScope = metadata.scope;
-        check(!currentScope || currentScope.value === "Container", ()=>{
-            const { value, appliedBy } = currentScope;
-            const by = appliedBy === "Scoped" ? `${appliedBy}(${value})` : appliedBy;
-            const className = getTokenName(Class);
-            return `class ${className}: scope ${value} was already set by @${by},\n  ` + `but @EagerInstantiate is trying to set a conflicting scope Container.\n  ` + `Only one decorator should set the class scope, or all must use the same value.`;
-        });
-        metadata.eagerInstantiate = true;
-        metadata.scope = {
-            value: "Container",
-            appliedBy: "EagerInstantiate"
-        };
+function EagerInstantiate(target) {
+    const metadata = getMetadata(target);
+    const currentScope = metadata.scope;
+    check(!currentScope || currentScope.value === "Container", ()=>{
+        const { value, appliedBy } = currentScope;
+        const by = appliedBy === "Scoped" ? `${appliedBy}(${value})` : appliedBy;
+        const className = getTokenName(target);
+        return `class ${className}: scope ${value} was already set by @${by},\n  ` + `but @EagerInstantiate is trying to set a conflicting scope Container.\n  ` + `Only one decorator should set the class scope, or all must use the same value.`;
+    });
+    metadata.eagerInstantiate = true;
+    metadata.scope = {
+        value: "Container",
+        appliedBy: "EagerInstantiate"
     };
 }
 
@@ -1183,8 +1181,8 @@ function Inject(token) {
 
 // @__NO_SIDE_EFFECTS__
 function Injectable(...args) {
-    return (Class)=>{
-        const metadata = getMetadata(Class);
+    return (target)=>{
+        const metadata = getMetadata(target);
         const arg0 = args[0];
         const ref = isTokenRef(arg0) ? arg0 : tokenRef(()=>args);
         const currentRef = metadata.tokenRef;
@@ -1285,14 +1283,14 @@ function OptionalAll(token) {
  *
  * Example:
  * ```ts
- * @ContainerScoped()
+ * @ContainerScoped
  * class Wizard {
  *   // ...
  * }
  * ```
  */ // @__NO_SIDE_EFFECTS__
-function ContainerScoped() {
-    return scoped("Container", "ContainerScoped");
+function ContainerScoped(target) {
+    scoped(target, "Container", "ContainerScoped");
 }
 /**
  * Class decorator that registers the decorated type with the **Resolution** scope.
@@ -1302,14 +1300,14 @@ function ContainerScoped() {
  *
  * Example:
  * ```ts
- * @ResolutionScoped()
+ * @ResolutionScoped
  * class Wand {
  *   // ...
  * }
  * ```
  */ // @__NO_SIDE_EFFECTS__
-function ResolutionScoped() {
-    return scoped("Resolution", "ResolutionScoped");
+function ResolutionScoped(target) {
+    scoped(target, "Resolution", "ResolutionScoped");
 }
 /**
  * Class decorator that registers the decorated type with the **Transient** scope.
@@ -1318,14 +1316,14 @@ function ResolutionScoped() {
  *
  * Example:
  * ```ts
- * @TransientScoped()
+ * @TransientScoped
  * class Wand {
  *   // ...
  * }
  * ```
  */ // @__NO_SIDE_EFFECTS__
-function TransientScoped() {
-    return scoped("Transient", "TransientScoped");
+function TransientScoped(target) {
+    scoped(target, "Transient", "TransientScoped");
 }
 /**
  * Class decorator for setting the scope of the decorated type when registering it.
@@ -1348,22 +1346,20 @@ function TransientScoped() {
  * ```
  */ // @__NO_SIDE_EFFECTS__
 function Scoped(scope) {
-    return scoped(scope, "Scoped");
-}
-function scoped(scope, decorator) {
-    return (Class)=>{
-        const metadata = getMetadata(Class);
-        const currentScope = metadata.scope;
-        check(!currentScope || currentScope.value === scope, ()=>{
-            const { value, appliedBy } = currentScope;
-            const by = appliedBy === "Scoped" ? `${appliedBy}(${value})` : appliedBy;
-            const className = getTokenName(Class);
-            return `class ${className}: scope ${value} was already set by @${by},\n  ` + `but @${decorator} is trying to set a conflicting scope ${scope}.\n  ` + `Only one decorator should set the class scope, or all must use the same value.`;
-        });
-        metadata.scope = {
-            value: scope,
-            appliedBy: decorator
-        };
+    return (target)=>scoped(target, scope, "Scoped");
+}
+function scoped(target, scope, decorator) {
+    const metadata = getMetadata(target);
+    const currentScope = metadata.scope;
+    check(!currentScope || currentScope.value === scope, ()=>{
+        const { value, appliedBy } = currentScope;
+        const by = appliedBy === "Scoped" ? `${appliedBy}(${value})` : appliedBy;
+        const className = getTokenName(target);
+        return `class ${className}: scope ${value} was already set by @${by},\n  ` + `but @${decorator} is trying to set a conflicting scope ${scope}.\n  ` + `Only one decorator should set the class scope, or all must use the same value.`;
+    });
+    metadata.scope = {
+        value: scope,
+        appliedBy: decorator
     };
 }