ts-ioc-container 70.0.0 → 70.1.0

package/cjm/token/ClassToken.js

@@ -6,8 +6,8 @@ class ClassToken extends InjectionToken_1.InjectionToken {
     target;
     _getArgsFn;
     _isLazy;
-    constructor(target, { getArgsFn = InjectionToken_1.forwardArgs, isLazy = false } = {}) {
-        super();
+    constructor(target, { getArgsFn = InjectionToken_1.forwardArgs, isLazy = false, tags = [], } = {}) {
+        super(tags);
         this.target = target;
         this._getArgsFn = getArgsFn;
         this._isLazy = isLazy;
@@ -26,6 +26,7 @@ class ClassToken extends InjectionToken_1.InjectionToken {
         return new ClassToken(this.target, {
             getArgsFn: (s, opts) => [...parentFn(s, opts), ...newArgs],
             isLazy: this._isLazy,
+            tags: this.getTags(),
         });
     }
     argsFn(fn) {
@@ -33,12 +34,21 @@ class ClassToken extends InjectionToken_1.InjectionToken {
         return new ClassToken(this.target, {
             getArgsFn: (s, opts) => [...parentFn(s, opts), ...fn(s)],
             isLazy: this._isLazy,
+            tags: this.getTags(),
         });
     }
     lazy() {
         return new ClassToken(this.target, {
             getArgsFn: this._getArgsFn,
             isLazy: true,
+            tags: this.getTags(),
+        });
+    }
+    addTags(...tags) {
+        return new ClassToken(this.target, {
+            getArgsFn: this._getArgsFn,
+            isLazy: this._isLazy,
+            tags: [...this.getTags(), ...tags],
         });
     }
     toString() {

package/cjm/token/ConstantToken.js

@@ -5,8 +5,8 @@ const InjectionToken_1 = require("./InjectionToken");
 const MethodNotImplementedError_1 = require("../errors/MethodNotImplementedError");
 class ConstantToken extends InjectionToken_1.InjectionToken {
     token;
-    constructor(token) {
-        super();
+    constructor(token, { tags = [] } = {}) {
+        super(tags);
         this.token = token;
     }
     resolve(s) {
@@ -21,6 +21,9 @@ class ConstantToken extends InjectionToken_1.InjectionToken {
     lazy() {
         throw new MethodNotImplementedError_1.MethodNotImplementedError('not implemented');
     }
+    addTags(...tags) {
+        return new ConstantToken(this.token, { tags: [...this.getTags(), ...tags] });
+    }
     toString() {
         throw new MethodNotImplementedError_1.MethodNotImplementedError('not implemented');
     }

package/cjm/token/FunctionToken.js

@@ -7,8 +7,8 @@ class FunctionToken extends InjectionToken_1.InjectionToken {
     fn;
     _getArgsFn;
     _isLazy;
-    constructor(fn, { getArgsFn = InjectionToken_1.forwardArgs, isLazy = false } = {}) {
-        super();
+    constructor(fn, { getArgsFn = InjectionToken_1.forwardArgs, isLazy = false, tags = [], } = {}) {
+        super(tags);
         this.fn = fn;
         this._getArgsFn = getArgsFn;
         this._isLazy = isLazy;
@@ -24,6 +24,7 @@ class FunctionToken extends InjectionToken_1.InjectionToken {
         return new FunctionToken(this.fn, {
             getArgsFn: (s, opts) => [...parentFn(s, opts), ...newArgs],
             isLazy: this._isLazy,
+            tags: this.getTags(),
         });
     }
     argsFn(fn) {
@@ -31,12 +32,21 @@ class FunctionToken extends InjectionToken_1.InjectionToken {
         return new FunctionToken(this.fn, {
             getArgsFn: (s, opts) => [...parentFn(s, opts), ...fn(s)],
             isLazy: this._isLazy,
+            tags: this.getTags(),
         });
     }
     lazy() {
         return new FunctionToken(this.fn, {
             getArgsFn: this._getArgsFn,
             isLazy: true,
+            tags: this.getTags(),
+        });
+    }
+    addTags(...tags) {
+        return new FunctionToken(this.fn, {
+            getArgsFn: this._getArgsFn,
+            isLazy: this._isLazy,
+            tags: [...this.getTags(), ...tags],
         });
     }
     toString() {

package/cjm/token/GroupAliasToken.js

@@ -6,8 +6,8 @@ class GroupAliasToken extends InjectionToken_1.InjectionToken {
     token;
     _getArgsFn;
     _isLazy;
-    constructor(token, { getArgsFn = InjectionToken_1.forwardArgs, isLazy = false } = {}) {
-        super();
+    constructor(token, { getArgsFn = InjectionToken_1.forwardArgs, isLazy = false, tags = [], } = {}) {
+        super(tags);
         this.token = token;
         this._getArgsFn = getArgsFn;
         this._isLazy = isLazy;
@@ -29,6 +29,7 @@ class GroupAliasToken extends InjectionToken_1.InjectionToken {
         return new GroupAliasToken(this.token, {
             getArgsFn: (s, opts) => [...parentFn(s, opts), ...newArgs],
             isLazy: this._isLazy,
+            tags: this.getTags(),
         });
     }
     argsFn(fn) {
@@ -36,12 +37,21 @@ class GroupAliasToken extends InjectionToken_1.InjectionToken {
         return new GroupAliasToken(this.token, {
             getArgsFn: (s, opts) => [...parentFn(s, opts), ...fn(s)],
             isLazy: this._isLazy,
+            tags: this.getTags(),
         });
     }
     lazy() {
         return new GroupAliasToken(this.token, {
             getArgsFn: this._getArgsFn,
             isLazy: true,
+            tags: this.getTags(),
+        });
+    }
+    addTags(...tags) {
+        return new GroupAliasToken(this.token, {
+            getArgsFn: this._getArgsFn,
+            isLazy: this._isLazy,
+            tags: [...this.getTags(), ...tags],
         });
     }
     toString() {

package/cjm/token/GroupInstanceToken.js

@@ -5,10 +5,11 @@ const InjectionToken_1 = require("./InjectionToken");
 const MethodNotImplementedError_1 = require("../errors/MethodNotImplementedError");
 class GroupInstanceToken extends InjectionToken_1.InjectionToken {
     predicate;
-    isCascade = true;
-    constructor(predicate) {
-        super();
+    isCascade;
+    constructor(predicate, { tags = [], isCascade = true } = {}) {
+        super(tags);
         this.predicate = predicate;
+        this.isCascade = isCascade;
     }
     select(fn) {
         return (s) => this.resolve(s).map(fn);
@@ -29,6 +30,9 @@ class GroupInstanceToken extends InjectionToken_1.InjectionToken {
     resolve(c) {
         return c.getInstances(this.isCascade).filter(this.predicate);
     }
+    addTags(...tags) {
+        return new GroupInstanceToken(this.predicate, { tags: [...this.getTags(), ...tags], isCascade: this.isCascade });
+    }
     toString() {
         throw new MethodNotImplementedError_1.MethodNotImplementedError('not implemented');
     }

package/cjm/token/InjectionToken.js

@@ -6,8 +6,24 @@ const basic_1 = require("../utils/basic");
 const forwardArgs = (_, { args = [] } = {}) => args;
 exports.forwardArgs = forwardArgs;
 class InjectionToken {
+    tags;
+    constructor(tags = []) {
+        this.tags = new Set(tags);
+    }
+    hasTag(tag) {
+        return this.tags.has(tag);
+    }
+    getTags() {
+        return [...this.tags];
+    }
 }
 exports.InjectionToken = InjectionToken;
 function isInjectionToken(target) {
-    return basic_1.Is.object(target) && 'resolve' in target && 'args' in target && 'argsFn' in target && 'lazy' in target;
+    return (basic_1.Is.object(target) &&
+        'resolve' in target &&
+        'args' in target &&
+        'argsFn' in target &&
+        'lazy' in target &&
+        'hasTag' in target &&
+        'addTags' in target);
 }

package/cjm/token/SingleAliasToken.js

@@ -6,8 +6,8 @@ class SingleAliasToken extends InjectionToken_1.InjectionToken {
     token;
     _getArgsFn;
     _isLazy;
-    constructor(token, { getArgsFn = InjectionToken_1.forwardArgs, isLazy = false } = {}) {
-        super();
+    constructor(token, { getArgsFn = InjectionToken_1.forwardArgs, isLazy = false, tags = [], } = {}) {
+        super(tags);
         this.token = token;
         this._getArgsFn = getArgsFn;
         this._isLazy = isLazy;
@@ -29,6 +29,7 @@ class SingleAliasToken extends InjectionToken_1.InjectionToken {
         return new SingleAliasToken(this.token, {
             getArgsFn: (s, opts) => [...parentFn(s, opts), ...newArgs],
             isLazy: this._isLazy,
+            tags: this.getTags(),
         });
     }
     argsFn(fn) {
@@ -36,12 +37,21 @@ class SingleAliasToken extends InjectionToken_1.InjectionToken {
         return new SingleAliasToken(this.token, {
             getArgsFn: (s, opts) => [...parentFn(s, opts), ...fn(s)],
             isLazy: this._isLazy,
+            tags: this.getTags(),
         });
     }
     lazy() {
         return new SingleAliasToken(this.token, {
             getArgsFn: this._getArgsFn,
             isLazy: true,
+            tags: this.getTags(),
+        });
+    }
+    addTags(...tags) {
+        return new SingleAliasToken(this.token, {
+            getArgsFn: this._getArgsFn,
+            isLazy: this._isLazy,
+            tags: [...this.getTags(), ...tags],
         });
     }
     toString() {

package/cjm/token/SingleToken.js

@@ -6,8 +6,8 @@ class SingleToken extends InjectionToken_1.InjectionToken {
     token;
     _getArgsFn;
     _isLazy;
-    constructor(token, { getArgsFn = InjectionToken_1.forwardArgs, isLazy = false } = {}) {
-        super();
+    constructor(token, { getArgsFn = InjectionToken_1.forwardArgs, isLazy = false, tags = [], } = {}) {
+        super(tags);
         this.token = token;
         this._getArgsFn = getArgsFn;
         this._isLazy = isLazy;
@@ -29,6 +29,7 @@ class SingleToken extends InjectionToken_1.InjectionToken {
         return new SingleToken(this.token, {
             getArgsFn: (s, opts) => [...parentFn(s, opts), ...newArgs],
             isLazy: this._isLazy,
+            tags: this.getTags(),
         });
     }
     argsFn(fn) {
@@ -36,12 +37,21 @@ class SingleToken extends InjectionToken_1.InjectionToken {
         return new SingleToken(this.token, {
             getArgsFn: (s, opts) => [...parentFn(s, opts), ...fn(s)],
             isLazy: this._isLazy,
+            tags: this.getTags(),
         });
     }
     lazy() {
         return new SingleToken(this.token, {
             getArgsFn: this._getArgsFn,
             isLazy: true,
+            tags: this.getTags(),
+        });
+    }
+    addTags(...tags) {
+        return new SingleToken(this.token, {
+            getArgsFn: this._getArgsFn,
+            isLazy: this._isLazy,
+            tags: [...this.getTags(), ...tags],
         });
     }
     toString() {

package/esm/token/ClassToken.js

@@ -3,8 +3,8 @@ export class ClassToken extends InjectionToken {
     target;
     _getArgsFn;
     _isLazy;
-    constructor(target, { getArgsFn = forwardArgs, isLazy = false } = {}) {
-        super();
+    constructor(target, { getArgsFn = forwardArgs, isLazy = false, tags = [], } = {}) {
+        super(tags);
         this.target = target;
         this._getArgsFn = getArgsFn;
         this._isLazy = isLazy;
@@ -23,6 +23,7 @@ export class ClassToken extends InjectionToken {
         return new ClassToken(this.target, {
             getArgsFn: (s, opts) => [...parentFn(s, opts), ...newArgs],
             isLazy: this._isLazy,
+            tags: this.getTags(),
         });
     }
     argsFn(fn) {
@@ -30,12 +31,21 @@ export class ClassToken extends InjectionToken {
         return new ClassToken(this.target, {
             getArgsFn: (s, opts) => [...parentFn(s, opts), ...fn(s)],
             isLazy: this._isLazy,
+            tags: this.getTags(),
         });
     }
     lazy() {
         return new ClassToken(this.target, {
             getArgsFn: this._getArgsFn,
             isLazy: true,
+            tags: this.getTags(),
+        });
+    }
+    addTags(...tags) {
+        return new ClassToken(this.target, {
+            getArgsFn: this._getArgsFn,
+            isLazy: this._isLazy,
+            tags: [...this.getTags(), ...tags],
         });
     }
     toString() {

package/esm/token/ConstantToken.js

@@ -2,8 +2,8 @@ import { InjectionToken } from './InjectionToken.js';
 import { MethodNotImplementedError } from '../errors/MethodNotImplementedError.js';
 export class ConstantToken extends InjectionToken {
     token;
-    constructor(token) {
-        super();
+    constructor(token, { tags = [] } = {}) {
+        super(tags);
         this.token = token;
     }
     resolve(s) {
@@ -18,6 +18,9 @@ export class ConstantToken extends InjectionToken {
     lazy() {
         throw new MethodNotImplementedError('not implemented');
     }
+    addTags(...tags) {
+        return new ConstantToken(this.token, { tags: [...this.getTags(), ...tags] });
+    }
     toString() {
         throw new MethodNotImplementedError('not implemented');
     }

package/esm/token/FunctionToken.js

@@ -4,8 +4,8 @@ export class FunctionToken extends InjectionToken {
     fn;
     _getArgsFn;
     _isLazy;
-    constructor(fn, { getArgsFn = forwardArgs, isLazy = false } = {}) {
-        super();
+    constructor(fn, { getArgsFn = forwardArgs, isLazy = false, tags = [], } = {}) {
+        super(tags);
         this.fn = fn;
         this._getArgsFn = getArgsFn;
         this._isLazy = isLazy;
@@ -21,6 +21,7 @@ export class FunctionToken extends InjectionToken {
         return new FunctionToken(this.fn, {
             getArgsFn: (s, opts) => [...parentFn(s, opts), ...newArgs],
             isLazy: this._isLazy,
+            tags: this.getTags(),
         });
     }
     argsFn(fn) {
@@ -28,12 +29,21 @@ export class FunctionToken extends InjectionToken {
         return new FunctionToken(this.fn, {
             getArgsFn: (s, opts) => [...parentFn(s, opts), ...fn(s)],
             isLazy: this._isLazy,
+            tags: this.getTags(),
         });
     }
     lazy() {
         return new FunctionToken(this.fn, {
             getArgsFn: this._getArgsFn,
             isLazy: true,
+            tags: this.getTags(),
+        });
+    }
+    addTags(...tags) {
+        return new FunctionToken(this.fn, {
+            getArgsFn: this._getArgsFn,
+            isLazy: this._isLazy,
+            tags: [...this.getTags(), ...tags],
         });
     }
     toString() {

package/esm/token/GroupAliasToken.js

@@ -3,8 +3,8 @@ export class GroupAliasToken extends InjectionToken {
     token;
     _getArgsFn;
     _isLazy;
-    constructor(token, { getArgsFn = forwardArgs, isLazy = false } = {}) {
-        super();
+    constructor(token, { getArgsFn = forwardArgs, isLazy = false, tags = [], } = {}) {
+        super(tags);
         this.token = token;
         this._getArgsFn = getArgsFn;
         this._isLazy = isLazy;
@@ -26,6 +26,7 @@ export class GroupAliasToken extends InjectionToken {
         return new GroupAliasToken(this.token, {
             getArgsFn: (s, opts) => [...parentFn(s, opts), ...newArgs],
             isLazy: this._isLazy,
+            tags: this.getTags(),
         });
     }
     argsFn(fn) {
@@ -33,12 +34,21 @@ export class GroupAliasToken extends InjectionToken {
         return new GroupAliasToken(this.token, {
             getArgsFn: (s, opts) => [...parentFn(s, opts), ...fn(s)],
             isLazy: this._isLazy,
+            tags: this.getTags(),
         });
     }
     lazy() {
         return new GroupAliasToken(this.token, {
             getArgsFn: this._getArgsFn,
             isLazy: true,
+            tags: this.getTags(),
+        });
+    }
+    addTags(...tags) {
+        return new GroupAliasToken(this.token, {
+            getArgsFn: this._getArgsFn,
+            isLazy: this._isLazy,
+            tags: [...this.getTags(), ...tags],
         });
     }
     toString() {

package/esm/token/GroupInstanceToken.js

@@ -2,10 +2,11 @@ import { InjectionToken } from './InjectionToken.js';
 import { MethodNotImplementedError } from '../errors/MethodNotImplementedError.js';
 export class GroupInstanceToken extends InjectionToken {
     predicate;
-    isCascade = true;
-    constructor(predicate) {
-        super();
+    isCascade;
+    constructor(predicate, { tags = [], isCascade = true } = {}) {
+        super(tags);
         this.predicate = predicate;
+        this.isCascade = isCascade;
     }
     select(fn) {
         return (s) => this.resolve(s).map(fn);
@@ -26,6 +27,9 @@ export class GroupInstanceToken extends InjectionToken {
     resolve(c) {
         return c.getInstances(this.isCascade).filter(this.predicate);
     }
+    addTags(...tags) {
+        return new GroupInstanceToken(this.predicate, { tags: [...this.getTags(), ...tags], isCascade: this.isCascade });
+    }
     toString() {
         throw new MethodNotImplementedError('not implemented');
     }

package/esm/token/InjectionToken.js

@@ -1,7 +1,23 @@
 import { Is } from '../utils/basic.js';
 export const forwardArgs = (_, { args = [] } = {}) => args;
 export class InjectionToken {
+    tags;
+    constructor(tags = []) {
+        this.tags = new Set(tags);
+    }
+    hasTag(tag) {
+        return this.tags.has(tag);
+    }
+    getTags() {
+        return [...this.tags];
+    }
 }
 export function isInjectionToken(target) {
-    return Is.object(target) && 'resolve' in target && 'args' in target && 'argsFn' in target && 'lazy' in target;
+    return (Is.object(target) &&
+        'resolve' in target &&
+        'args' in target &&
+        'argsFn' in target &&
+        'lazy' in target &&
+        'hasTag' in target &&
+        'addTags' in target);
 }

package/esm/token/SingleAliasToken.js

@@ -3,8 +3,8 @@ export class SingleAliasToken extends InjectionToken {
     token;
     _getArgsFn;
     _isLazy;
-    constructor(token, { getArgsFn = forwardArgs, isLazy = false } = {}) {
-        super();
+    constructor(token, { getArgsFn = forwardArgs, isLazy = false, tags = [], } = {}) {
+        super(tags);
         this.token = token;
         this._getArgsFn = getArgsFn;
         this._isLazy = isLazy;
@@ -26,6 +26,7 @@ export class SingleAliasToken extends InjectionToken {
         return new SingleAliasToken(this.token, {
             getArgsFn: (s, opts) => [...parentFn(s, opts), ...newArgs],
             isLazy: this._isLazy,
+            tags: this.getTags(),
         });
     }
     argsFn(fn) {
@@ -33,12 +34,21 @@ export class SingleAliasToken extends InjectionToken {
         return new SingleAliasToken(this.token, {
             getArgsFn: (s, opts) => [...parentFn(s, opts), ...fn(s)],
             isLazy: this._isLazy,
+            tags: this.getTags(),
         });
     }
     lazy() {
         return new SingleAliasToken(this.token, {
             getArgsFn: this._getArgsFn,
             isLazy: true,
+            tags: this.getTags(),
+        });
+    }
+    addTags(...tags) {
+        return new SingleAliasToken(this.token, {
+            getArgsFn: this._getArgsFn,
+            isLazy: this._isLazy,
+            tags: [...this.getTags(), ...tags],
         });
     }
     toString() {

package/esm/token/SingleToken.js

@@ -3,8 +3,8 @@ export class SingleToken extends InjectionToken {
     token;
     _getArgsFn;
     _isLazy;
-    constructor(token, { getArgsFn = forwardArgs, isLazy = false } = {}) {
-        super();
+    constructor(token, { getArgsFn = forwardArgs, isLazy = false, tags = [], } = {}) {
+        super(tags);
         this.token = token;
         this._getArgsFn = getArgsFn;
         this._isLazy = isLazy;
@@ -26,6 +26,7 @@ export class SingleToken extends InjectionToken {
         return new SingleToken(this.token, {
             getArgsFn: (s, opts) => [...parentFn(s, opts), ...newArgs],
             isLazy: this._isLazy,
+            tags: this.getTags(),
         });
     }
     argsFn(fn) {
@@ -33,12 +34,21 @@ export class SingleToken extends InjectionToken {
         return new SingleToken(this.token, {
             getArgsFn: (s, opts) => [...parentFn(s, opts), ...fn(s)],
             isLazy: this._isLazy,
+            tags: this.getTags(),
         });
     }
     lazy() {
         return new SingleToken(this.token, {
             getArgsFn: this._getArgsFn,
             isLazy: true,
+            tags: this.getTags(),
+        });
+    }
+    addTags(...tags) {
+        return new SingleToken(this.token, {
+            getArgsFn: this._getArgsFn,
+            isLazy: this._isLazy,
+            tags: [...this.getTags(), ...tags],
         });
     }
     toString() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-ioc-container",
-  "version": "70.0.0",
+  "version": "70.1.0",
   "description": "Fast, lightweight TypeScript dependency injection container with a clean API, scoped lifecycles, decorators, tokens, hooks, lazy injection, customizable providers, and no global container objects.",
   "publishConfig": {
     "access": "public",

package/typings/token/ClassToken.d.ts

@@ -6,14 +6,16 @@ export declare class ClassToken<T = any> extends InjectionToken<T> implements Se
     private readonly target;
     private readonly _getArgsFn;
     private readonly _isLazy;
-    constructor(target: constructor<T>, { getArgsFn, isLazy }?: {
+    constructor(target: constructor<T>, { getArgsFn, isLazy, tags, }?: {
         getArgsFn?: ArgsFn;
         isLazy?: boolean;
+        tags?: string[];
     });
     select<R>(fn: (target: T) => R): (s: IContainer) => R;
     resolve(s: IContainer, { args, lazy }?: ProviderOptions): T;
     args(...newArgs: unknown[]): ClassToken<T>;
     argsFn(fn: (s: IContainer) => unknown[]): ClassToken<T>;
     lazy(): ClassToken<T>;
+    addTags(...tags: string[]): ClassToken<T>;
     toString(): string;
 }

package/typings/token/ConstantToken.d.ts

@@ -3,10 +3,13 @@ import { InjectionToken } from './InjectionToken.js';
 import { Serializable } from '../utils/basic.js';
 export declare class ConstantToken<T = any> extends InjectionToken<T> implements Serializable {
     private readonly token;
-    constructor(token: T);
+    constructor(token: T, { tags }?: {
+        tags?: string[];
+    });
     resolve(s: IContainer): T;
     args(...deps: unknown[]): InjectionToken<T>;
     argsFn(getArgsFn: (s: IContainer) => unknown[]): InjectionToken<T>;
     lazy(): InjectionToken<T>;
+    addTags(...tags: string[]): ConstantToken<T>;
     toString(): string;
 }

package/typings/token/FunctionToken.d.ts

@@ -7,13 +7,15 @@ export declare class FunctionToken<T = any> extends InjectionToken<T> implements
     private readonly fn;
     private readonly _getArgsFn;
     private readonly _isLazy;
-    constructor(fn: InjectFn<T>, { getArgsFn, isLazy }?: {
+    constructor(fn: InjectFn<T>, { getArgsFn, isLazy, tags, }?: {
         getArgsFn?: ArgsFn;
         isLazy?: boolean;
+        tags?: string[];
     });
     resolve(s: IContainer, { args, lazy }?: ProviderOptions): T;
     args(...newArgs: unknown[]): InjectionToken<T>;
     argsFn(fn: (s: IContainer) => unknown[]): InjectionToken<T>;
     lazy(): InjectionToken<T>;
+    addTags(...tags: string[]): FunctionToken<T>;
     toString(): string;
 }

package/typings/token/GroupAliasToken.d.ts

@@ -8,9 +8,10 @@ export declare class GroupAliasToken<T = any> extends InjectionToken<T[]> implem
     readonly token: DependencyKey;
     private readonly _getArgsFn;
     private readonly _isLazy;
-    constructor(token: DependencyKey, { getArgsFn, isLazy }?: {
+    constructor(token: DependencyKey, { getArgsFn, isLazy, tags, }?: {
         getArgsFn?: ArgsFn;
         isLazy?: boolean;
+        tags?: string[];
     });
     select<R>(fn: (target: T[]) => R[]): (s: IContainer) => R[];
     resolve(s: IContainer, { args, lazy }?: ProviderOptions): T[];
@@ -18,6 +19,7 @@ export declare class GroupAliasToken<T = any> extends InjectionToken<T[]> implem
     args(...newArgs: unknown[]): GroupAliasToken<T>;
     argsFn(fn: (s: IContainer) => unknown[]): GroupAliasToken<T>;
     lazy(): GroupAliasToken<T>;
+    addTags(...tags: string[]): GroupAliasToken<T>;
     toString(): string;
 }
 export declare const toGroupAlias: <T>(token: DependencyKey) => GroupAliasToken<T>;

package/typings/token/GroupInstanceToken.d.ts

@@ -5,12 +5,16 @@ export type InstancePredicate = (dep: unknown) => boolean;
 export declare class GroupInstanceToken extends InjectionToken<Instance[]> implements Serializable {
     private predicate;
     private isCascade;
-    constructor(predicate: InstancePredicate);
+    constructor(predicate: InstancePredicate, { tags, isCascade }?: {
+        tags?: string[];
+        isCascade?: boolean;
+    });
     select<R>(fn: (target: Instance) => R): (s: IContainer) => R[];
     args(...deps: unknown[]): this;
     argsFn(getArgsFn: (s: IContainer) => unknown[]): InjectionToken<Instance[]>;
     lazy(): InjectionToken<Instance[]>;
     cascade(isTrue: boolean): this;
     resolve(c: IContainer): Instance[];
+    addTags(...tags: string[]): GroupInstanceToken;
     toString(): string;
 }

package/typings/token/InjectionToken.d.ts

@@ -1,10 +1,15 @@
-import { type IContainer } from '../container/IContainer.js';
+import { type IContainer, type Tag } from '../container/IContainer.js';
 import { ArgsFn, ProviderOptions } from '../provider/IProvider.js';
 export declare const forwardArgs: ArgsFn;
 export declare abstract class InjectionToken<T = any> {
+    private readonly tags;
+    protected constructor(tags?: Tag[]);
     abstract resolve(s: IContainer, options?: ProviderOptions): T;
     abstract args(...deps: unknown[]): InjectionToken<T>;
     abstract argsFn(getArgsFn: (s: IContainer) => unknown[]): InjectionToken<T>;
     abstract lazy(): InjectionToken<T>;
+    abstract addTags(...tags: Tag[]): InjectionToken<T>;
+    hasTag(tag: Tag): boolean;
+    protected getTags(): Tag[];
 }
 export declare function isInjectionToken(target: unknown): target is InjectionToken;

package/typings/token/SingleAliasToken.d.ts

@@ -8,9 +8,10 @@ export declare class SingleAliasToken<T = any> extends InjectionToken<T> impleme
     readonly token: DependencyKey;
     private readonly _getArgsFn;
     private readonly _isLazy;
-    constructor(token: DependencyKey, { getArgsFn, isLazy }?: {
+    constructor(token: DependencyKey, { getArgsFn, isLazy, tags, }?: {
         getArgsFn?: ArgsFn;
         isLazy?: boolean;
+        tags?: string[];
     });
     select<R>(fn: (target: T) => R): (s: IContainer) => R;
     resolve(s: IContainer, { args, lazy }?: ResolveOneOptions): T;
@@ -18,6 +19,7 @@ export declare class SingleAliasToken<T = any> extends InjectionToken<T> impleme
     args(...newArgs: unknown[]): SingleAliasToken<T>;
     argsFn(fn: (s: IContainer) => unknown[]): SingleAliasToken<T>;
     lazy(): SingleAliasToken<T>;
+    addTags(...tags: string[]): SingleAliasToken<T>;
     toString(): string;
 }
 export declare const toSingleAlias: <T>(token: DependencyKey) => SingleAliasToken<T>;

package/typings/token/SingleToken.d.ts

@@ -7,9 +7,10 @@ export declare class SingleToken<T = any> extends InjectionToken<T> implements S
     token: DependencyKey;
     private readonly _getArgsFn;
     private readonly _isLazy;
-    constructor(token: DependencyKey, { getArgsFn, isLazy }?: {
+    constructor(token: DependencyKey, { getArgsFn, isLazy, tags, }?: {
         getArgsFn?: ArgsFn;
         isLazy?: boolean;
+        tags?: string[];
     });
     select<R>(fn: (target: T) => R): (s: IContainer) => R;
     resolve(s: IContainer, { args, lazy }?: ProviderOptions): T;
@@ -17,5 +18,6 @@ export declare class SingleToken<T = any> extends InjectionToken<T> implements S
     args(...newArgs: unknown[]): SingleToken<T>;
     argsFn(fn: (s: IContainer) => unknown[]): SingleToken<T>;
     lazy(): SingleToken<T>;
+    addTags(...tags: string[]): SingleToken<T>;
     toString(): string;
 }