@lppedd/di-wise-neo 0.24.0 → 0.25.0

package/dist/es/index.d.mts

@@ -658,22 +658,6 @@ declare function createContainer(options?: ContainerOptions): Container;
  * ```
  */
 declare function AutoRegister<This extends object, Ctor extends Constructor<This>>(target: Ctor): void;
-/**
- * Class decorator that enables auto-registration of an unregistered class
- * when the class is first resolved from the container.
- *
- * Example:
- * ```ts
- * @AutoRegister()
- * class Wizard {}
- *
- * const wizard = container.resolve(Wizard);
- * container.isRegistered(Wizard); // => true
- * ```
- *
- * @deprecated Use `@AutoRegister` instead of `AutoRegister()`.
- */
-declare function AutoRegister<This extends object>(): ClassDecorator<This>;
 
 /**
  * Class decorator that sets the class scope to **Container** and enables
@@ -695,28 +679,6 @@ declare function AutoRegister<This extends object>(): ClassDecorator<This>;
  * ```
  */
 declare function EagerInstantiate<This extends object, Ctor extends Constructor<This>>(target: Ctor): void;
-/**
- * Class decorator that sets the class scope to **Container** and enables
- * eager instantiation when the class is registered in the container.
- *
- * This causes the container to create and cache the instance of the class
- * immediately, instead of deferring it until the first resolution.
- *
- * If the class cannot be resolved at registration time, registration fails.
- *
- * Example:
- * ```ts
- * @EagerInstantiate()
- * class Wizard {}
- *
- * // Wizard is registered with Container scope, and an instance
- * // is created and cached immediately by the container
- * container.register(Wizard);
- * ```
- *
- * @deprecated Use `@EagerInstantiate` instead of `@EagerInstantiate()`.
- */
-declare function EagerInstantiate<This extends object>(): ClassDecorator<This>;
 
 /**
  * Parameter decorator that injects the instance associated with the given class.
@@ -964,23 +926,6 @@ declare function OptionalAll<Value>(tokens: TokenRef<Value>): ParameterDecorator
  * ```
  */
 declare function ContainerScoped<This extends object, Ctor extends Constructor<This>>(target: Ctor): void;
-/**
- * Class decorator that registers the decorated type with the **Container** scope.
- *
- * Use this scope when you want one cached instance per container,
- * with parent-container lookup fallback.
- *
- * Example:
- * ```ts
- * @ContainerScoped()
- * class Wizard {
- *   // ...
- * }
- * ```
- *
- * @deprecated Use `@ContainerScoped` instead of `@ContainerScoped()`.
- */
-declare function ContainerScoped<This extends object>(): ClassDecorator<This>;
 /**
  * Class decorator that registers the decorated type with the **Resolution** scope.
  *
@@ -996,23 +941,6 @@ declare function ContainerScoped<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 **Resolution** scope.
- *
- * Use this scope when you want one cached instance per resolution graph,
- * so repeated resolutions within the same request reuse the same value.
- *
- * Example:
- * ```ts
- * @ResolutionScoped()
- * class Wand {
- *   // ...
- * }
- * ```
- *
- * @deprecated Use `@ResolutionScoped` instead of `@ResolutionScoped()`.
- */
-declare function ResolutionScoped<This extends object>(): ClassDecorator<This>;
 /**
  * Class decorator that registers the decorated type with the **Transient** scope.
  *
@@ -1027,22 +955,6 @@ declare function ResolutionScoped<This extends object>(): ClassDecorator<This>;
  * ```
  */
 declare function TransientScoped<This extends object, Ctor extends Constructor<This>>(target: Ctor): void;
-/**
- * Class decorator that registers the decorated type with the **Transient** scope.
- *
- * Use this scope when you want a fresh instance every time the class is resolved.
- *
- * Example:
- * ```ts
- * @TransientScoped()
- * class Wand {
- *   // ...
- * }
- * ```
- *
- * @deprecated Use `@TransientScoped` instead of `@TransientScoped()`.
- */
-declare function TransientScoped<This extends object>(): ClassDecorator<This>;
 /**
  * Class decorator for setting the scope of the decorated type when registering it.
  *

package/dist/es/index.mjs

@@ -1113,33 +1113,57 @@ function isDisposable(value) {
     return new ContainerImpl(undefined, options);
 }
 
-// @__NO_SIDE_EFFECTS__
+/**
+ * Class decorator that enables auto-registration of an unregistered class
+ * when the class is first resolved from the container.
+ *
+ * Example:
+ * ```ts
+ * @AutoRegister
+ * class Wizard {}
+ *
+ * const wizard = container.resolve(Wizard);
+ * container.isRegistered(Wizard); // => true
+ * ```
+ */ // @__NO_SIDE_EFFECTS__
 function AutoRegister(target) {
-    const decorator = (Class)=>{
-        const metadata = getMetadata(Class);
-        metadata.autoRegister = true;
-    };
-    return target === undefined ? decorator : decorator(target);
+    const metadata = getMetadata(target);
+    metadata.autoRegister = true;
 }
 
-// @__NO_SIDE_EFFECTS__
+/**
+ * Class decorator that sets the class scope to **Container** and enables
+ * eager instantiation when the class is registered in the container.
+ *
+ * This causes the container to create and cache the instance of the class
+ * immediately, instead of deferring it until the first resolution.
+ *
+ * If the class cannot be resolved at registration time, registration fails.
+ *
+ * Example:
+ * ```ts
+ * @EagerInstantiate
+ * class Wizard {}
+ *
+ * // Wizard is registered with Container scope, and an instance
+ * // is created and cached immediately by the container
+ * container.register(Wizard);
+ * ```
+ */ // @__NO_SIDE_EFFECTS__
 function EagerInstantiate(target) {
-    const decorator = (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"
-        };
+    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"
     };
-    return target === undefined ? decorator : decorator(target);
 }
 
 // @__NO_SIDE_EFFECTS__
@@ -1155,8 +1179,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;
@@ -1249,20 +1273,55 @@ function OptionalAll(token) {
     };
 }
 
-// @__NO_SIDE_EFFECTS__
+/**
+ * Class decorator that registers the decorated type with the **Container** scope.
+ *
+ * Use this scope when you want one cached instance per container,
+ * with parent-container lookup fallback.
+ *
+ * Example:
+ * ```ts
+ * @ContainerScoped
+ * class Wizard {
+ *   // ...
+ * }
+ * ```
+ */ // @__NO_SIDE_EFFECTS__
 function ContainerScoped(target) {
-    const decorator = scoped("Container", "ContainerScoped");
-    return target === undefined ? decorator : decorator(target);
+    scoped(target, "Container", "ContainerScoped");
 }
-// @__NO_SIDE_EFFECTS__
+/**
+ * Class decorator that registers the decorated type with the **Resolution** scope.
+ *
+ * Use this scope when you want one cached instance per resolution graph,
+ * so repeated resolutions within the same request reuse the same value.
+ *
+ * Example:
+ * ```ts
+ * @ResolutionScoped
+ * class Wand {
+ *   // ...
+ * }
+ * ```
+ */ // @__NO_SIDE_EFFECTS__
 function ResolutionScoped(target) {
-    const decorator = scoped("Resolution", "ResolutionScoped");
-    return target === undefined ? decorator : decorator(target);
+    scoped(target, "Resolution", "ResolutionScoped");
 }
-// @__NO_SIDE_EFFECTS__
+/**
+ * Class decorator that registers the decorated type with the **Transient** scope.
+ *
+ * Use this scope when you want a fresh instance every time the class is resolved.
+ *
+ * Example:
+ * ```ts
+ * @TransientScoped
+ * class Wand {
+ *   // ...
+ * }
+ * ```
+ */ // @__NO_SIDE_EFFECTS__
 function TransientScoped(target) {
-    const decorator = scoped("Transient", "TransientScoped");
-    return target === undefined ? decorator : decorator(target);
+    scoped(target, "Transient", "TransientScoped");
 }
 /**
  * Class decorator for setting the scope of the decorated type when registering it.
@@ -1285,22 +1344,20 @@ function TransientScoped(target) {
  * ```
  */ // @__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
     };
 }