@owja/ioc - npm Package Compare versions

Comparing version 2.0.0-alpha.6 to 2.0.0-alpha.7

dist/index.d.ts

 export { Container } from "./ioc/container";
-export type { Plugin, Factory, Item, NewAble, Token, Value } from "./ioc/types";
+export type { Plugin, Factory, RegItem, NewAble, Token, Value } from "./ioc/types";
 export { createDecorator } from "./ioc/createDecorator";
@@ -4,0 +4,0 @@ export { createWire } from "./ioc/createWire";

dist/ioc.js

@@ -1,2 +0,2 @@
-class t{constructor(t){this.t=void 0,this.t=t}withPlugin(t){return this.t.plugins.push(t),this}}class n extends t{inSingletonScope(){return this.t.singleton=!0,this}}class i{constructor(t){this.t=void 0,this.t=t}to(t){return this.t.injected=function(){return new t(...[].slice.call(arguments))},new n(this.t)}toFactory(t){return this.t.injected=t,new n(this.t)}toValue(n){if(void 0===n)throw"cannot bind a value of type undefined";return this.t.injected=n,new t(this.t)}}const o=t=>"symbol"==typeof t,e=t=>o(t)?[t]:t,r=t=>o(t)?t.toString():`Token(${t.type.toString()})`,s=t=>o(t)?t:t.type,u=Symbol("NOCACHE"),h=Symbol("NOPLUGINS");function c(t,n,i,o,r){var s=[].slice.call(arguments,5);Object.defineProperty(t,n,{get:function(){const t=i.get(o,r,this,s);return-1===e(r).indexOf(u)&&Object.defineProperty(this,n,{value:t,enumerable:!0}),t},configurable:!0,enumerable:!0})}exports.Container=class{constructor(){this.i=new Map,this.o=[],this.u=[]}bind(t){return new i(this.h(t))}rebind(t){return this.remove(t).bind(t)}remove(t){if(void 0===this.i.get(s(t)))throw`${r(t)} was never bound`;return this.i.delete(s(t)),this}get(t,n,i,o){void 0===n&&(n=[]),void 0===o&&(o=[]);const u=this.i.get(s(t));if(void 0===u||void 0===u.injected)throw`nothing bound to ${r(t)}`;const c="function"==typeof u.injected?u.singleton?u.cache=u.cache||u.injected():u.injected(...o):u.injected,d=e(n);return-1===d.indexOf(h)&&u.plugins.concat(this.u).forEach(n=>{n(c,i,d,t,this)}),c}addPlugin(t){return this.u.push(t),this}snapshot(){return this.o.push(new Map(this.i)),this}restore(){return this.i=this.o.pop()||this.i,this}h(t){if(void 0!==this.i.get(s(t)))throw`object can only bound once: ${r(t)}`;const n={plugins:[]};return this.i.set(s(t),n),n}},exports.NOCACHE=u,exports.NOPLUGINS=h,exports.createDecorator=function(t){return function(n,i){void 0===i&&(i=[]);var o=[].slice.call(arguments,2);return function(e,r){c(e,r,t,n,i,...o)}}},exports.createResolve=function(t){return function(n,i){let o;return void 0===i&&(i=[]),function(){return-1===e(i).indexOf(u)&&void 0!==o||(o=t.get(n,i,this,[].slice.call(arguments))),o}}},exports.createWire=function(t){return function(n,i,o,e){void 0===e&&(e=[]),c(n,i,t,o,e,...[].slice.call(arguments,4))}},exports.token=t=>({type:Symbol(t)});
+class t{constructor(t){this.t=void 0,this.t=t}withPlugin(t){return this.t.plugins.push(t),this}}class n extends t{inSingletonScope(){return this.t.singleton=!0,this}}class i{constructor(t){this.t=void 0,this.t=t}to(t){return this.t.factory=function(){return new t(...[].slice.call(arguments))},new n(this.t)}toFactory(t){return this.t.factory=t,new n(this.t)}toValue(n){if(void 0===n)throw"cannot bind a value of type undefined";return this.t.value=n,new t(this.t)}}const o=t=>"symbol"==typeof t,e=t=>o(t)?[t]:t,r=t=>o(t)?t.toString():`Token(${t.type.toString()})`,s=t=>o(t)?t:t.type,u=Symbol("NOCACHE"),h=Symbol("NOPLUGINS");function c(t,n,i,o,r,s){Object.defineProperty(t,n,{get:function(){const t=i.get(o,r,this,s);return-1===e(r).indexOf(u)&&Object.defineProperty(this,n,{value:t,enumerable:!0}),t},configurable:!0,enumerable:!0})}exports.Container=class{constructor(){this.i=new Map,this.o=[],this.u=[]}bind(t){return new i(this.h(t))}rebind(t){return this.remove(t).bind(t)}remove(t){if(void 0===this.i.get(s(t)))throw`${r(t)} was never bound`;return this.i.delete(s(t)),this}get(t,n,i,o){void 0===n&&(n=[]);const u=this.i.get(s(t));if(!u||!u.factory&&void 0===u.value)throw`nothing bound to ${r(t)}`;const c=u.factory?u.singleton?u.cache=u.cache||u.factory(...o||[]):u.factory(...o||[]):u.value,d=e(n);if(-1===d.indexOf(h))for(const n of u.plugins.concat(this.u))n(c,i,d,t,this);return c}addPlugin(t){return this.u.push(t),this}snapshot(){return this.o.push(new Map(this.i)),this}restore(){return this.i=this.o.pop()||this.i,this}h(t){if(void 0!==this.i.get(s(t)))throw`object can only bound once: ${r(t)}`;const n={plugins:[]};return this.i.set(s(t),n),n}},exports.NOCACHE=u,exports.NOPLUGINS=h,exports.createDecorator=function(t){return function(n,i){void 0===i&&(i=[]);var o=[].slice.call(arguments,2);return function(e,r){c(e,r,t,n,i,o)}}},exports.createResolve=function(t){return function(n,i){let o;return void 0===i&&(i=[]),function(){return-1===e(i).indexOf(u)&&void 0!==o||(o=t.get(n,i,this,[].slice.call(arguments))),o}}},exports.createWire=function(t){return function(n,i,o,e){void 0===e&&(e=[]),c(n,i,t,o,e,[].slice.call(arguments,4))}},exports.token=t=>({type:Symbol(t)});
 //# sourceMappingURL=ioc.js.map

dist/ioc/bind.d.ts

@@ -1,10 +0,10 @@
-import type { Item, NewAble, Factory, Value } from "./types";
+import type { RegItem, NewAble, Factory, Value } from "./types";
 import { Options } from "./options";
 import { PluginOptions } from "./pluginOptions";
-export declare class Bind<T, U extends Array<unknown>> {
-    private _target;
-    constructor(_target: Item<T>);
-    to<O extends NewAble<T>>(object: O): Options<T>;
-    toFactory(factory: Factory<T, U>): Options<T>;
-    toValue(value: Value<T>): PluginOptions<T>;
+export declare class Bind<Dep, Args extends Array<unknown>> {
+    private _regItem;
+    constructor(_regItem: RegItem<Dep, Args>);
+    to<Obj extends NewAble<Dep, Args>>(object: Obj): Options<Dep, Args>;
+    toFactory(factory: Factory<Dep, Args>): Options<Dep, Args>;
+    toValue(value: Value<Dep>): PluginOptions<Dep, never>;
 }

dist/ioc/container.d.ts

@@ -7,6 +7,7 @@ import type { Token, MaybeToken, Plugin } from "./types";
     private _plugins;
-    bind<T = never, U extends Array<unknown> = never>(token: MaybeToken<T>): Bind<T, U>;
-    rebind<T = never, U extends Array<unknown> = never>(token: MaybeToken<T>): Bind<T, U>;
+    bind<Dep = never, Args extends Array<unknown> = never>(token: MaybeToken<Dep>): Bind<Dep, Args>;
+    rebind<Dep = never, Args extends Array<unknown> = never>(token: MaybeToken<Dep>): Bind<Dep, Args>;
     remove(token: MaybeToken): Container;
-    get<T, U extends Array<unknown> = never>(token: Token<T, U> | MaybeToken<T>, tags?: symbol[] | symbol, target?: unknown, injectedArgs?: Array<unknown>): T;
+    get<Dep>(token: Token<Dep> | MaybeToken<Dep>, tags?: symbol[] | symbol, target?: unknown): Dep;
+    get<Dep, Args extends Array<unknown>>(token: Token<Dep, Args> | MaybeToken<Dep>, tags: symbol[] | symbol, target: unknown, args: Args): Dep;
     addPlugin(plugin: Plugin): Container;
@@ -13,0 +14,0 @@ snapshot(): Container;

dist/ioc/createDecorator.d.ts

 import type { Token, MaybeToken } from "./types";
 import type { Container } from "./container";
-export declare function createDecorator(container: Container): <T, K extends unknown[]>(token: Token<T, K> | MaybeToken<T, unknown[]>, tags?: symbol[] | symbol, ...injectedArgs: K) => <Target extends { [key in Prop]: T; }, Prop extends keyof Target>(target: Target, property: Prop) => void;
+export declare function createDecorator(container: Container): <Dep, Args extends unknown[]>(token: Token<Dep, Args> | MaybeToken<Dep>, tags?: symbol[] | symbol, ...args: Args) => <Target extends { [key in Prop]: Dep; }, Prop extends keyof Target>(target: Target, property: Prop) => void;

dist/ioc/createResolve.d.ts

 import type { Token, MaybeToken } from "./types";
 import type { Container } from "./container";
-export declare function createResolve(container: Container): <T, U extends unknown[]>(token: Token<T, U> | MaybeToken<T, unknown[]>, tags?: symbol[] | symbol) => <R>(this: R, ...injectedArgs: U) => T;
+export declare function createResolve(container: Container): <Dep, Args extends unknown[]>(token: Token<Dep, Args> | MaybeToken<Dep>, tags?: symbol[] | symbol) => <R>(this: R, ...args: Args) => Dep;

dist/ioc/createWire.d.ts

 import type { Token, MaybeToken } from "./types";
 import type { Container } from "./container";
-export declare function createWire(container: Container): <Value, Target extends { [key in Prop]: Value; }, Prop extends keyof Target, K extends unknown[]>(target: Target, property: Prop, token: Token<Value, K> | MaybeToken<Value, unknown[]>, tags?: symbol[] | symbol, ...injectedArgs: K) => void;
+export declare function createWire(container: Container): <Dep, Target extends { [key in Prop]: Dep; }, Prop extends keyof Target, Args extends unknown[]>(target: Target, property: Prop, token: Token<Dep, Args> | MaybeToken<Dep>, tags?: symbol[] | symbol, ...args: Args) => void;

dist/ioc/define.d.ts

 import type { Token, MaybeToken } from "./types";
 import { Container } from "./container";
-export declare function define<T, Target extends {
-    [key in Prop]: T;
-}, Prop extends keyof Target, K extends Array<unknown>>(target: Target, property: Prop, container: Container, token: Token<T, K> | MaybeToken<T>, tags: symbol[] | symbol, ...injectedArgs: K): void;
+export declare function define<Dep, Target extends {
+    [key in Prop]: Dep;
+}, Prop extends keyof Target, Args extends Array<unknown>>(target: Target, property: Prop, container: Container, token: Token<Dep, Args> | MaybeToken<Dep>, tags: symbol[] | symbol, args: Args): void;

dist/ioc/options.d.ts

 import { PluginOptions } from "./pluginOptions";
-export declare class Options<T> extends PluginOptions<T> {
-    inSingletonScope(): PluginOptions<T>;
+export declare class Options<Dep, Args extends Array<unknown>> extends PluginOptions<Dep, Args> {
+    inSingletonScope(): PluginOptions<Dep, Args>;
 }

dist/ioc/pluginOptions.d.ts

@@ -1,6 +0,6 @@
-import type { Item, Plugin } from "./types";
-export declare class PluginOptions<T> {
-    protected _target: Item<T>;
-    constructor(_target: Item<T>);
-    withPlugin(plugin: Plugin<T>): PluginOptions<T>;
+import type { RegItem, Plugin } from "./types";
+export declare class PluginOptions<Dep, Args extends Array<unknown>> {
+    protected _regItem: RegItem<Dep, Args>;
+    constructor(_regItem: RegItem<Dep, Args>);
+    withPlugin(plugin: Plugin<Dep>): PluginOptions<Dep, Args>;
 }

dist/ioc/tags.d.ts

 export declare const NOCACHE: unique symbol;
 export declare const NOPLUGINS: unique symbol;

dist/ioc/token.d.ts

 import type { MaybeToken, Token } from "./types";
-export declare const token: <T, U extends unknown[] = unknown[]>(name: string) => Token<T, U>;
+export declare const token: <Dep, Args extends unknown[] = unknown[]>(name: string) => Token<Dep, Args>;
 export declare const stringifyToken: (token: MaybeToken) => string;
 export declare const getType: (token: MaybeToken) => symbol;

dist/ioc/types.d.ts

 import type { Container } from "./container";
-export declare type Injected<T> = Factory<T> | Value<T>;
-export interface Item<T> {
-    injected?: Injected<T>;
-    cache?: T;
+export interface RegItem<Dep = unknown, Args extends Array<unknown> = []> {
+    value?: Value<Dep>;
+    factory?: Factory<Dep, Args>;
+    cache?: Dep;
     singleton?: boolean;
-    plugins: Plugin<T>[];
+    plugins: Plugin<Dep>[];
 }
-export declare type Plugin<Dependency = unknown> = (dependency: Dependency, target: unknown, tags: symbol[], token: MaybeToken<Dependency>, container: Container) => void;
-export interface NewAble<T> {
-    new (...ctorArgs: any[]): T;
+export type Plugin<Dep = unknown> = (dependency: Dep, target: unknown, tags: symbol[], token: MaybeToken<Dep>, container: Container) => void;
+export interface NewAble<Dep, Args extends Array<unknown>> {
+    new (...args: Args): Dep;
 }
-export declare type Factory<T, U extends Array<unknown> = any> = (...factoryArgs: U) => T;
-export declare type Value<T> = T;
-export declare type MaybeToken<T = unknown, U extends Array<unknown> = unknown[]> = Token<T, U> | symbol;
-declare const typeMarker: unique symbol;
-declare const bindedArguments: unique symbol;
-export interface Token<T, U extends Array<unknown>> {
+export type Factory<Dep, Args extends Array<unknown>> = (...args: Args) => Dep;
+export type Value<Dependency> = Dependency;
+export type MaybeToken<Dep = unknown, Args extends Array<unknown> = unknown[]> = Token<Dep, Args> | symbol;
+declare const dependencyMarker: unique symbol;
+declare const argumentsMarker: unique symbol;
+export interface Token<Dep, Args extends Array<unknown> = never> {
     type: symbol;
-    [typeMarker]: T;
-    [bindedArguments]: U;
+    [dependencyMarker]: Dep;
+    [argumentsMarker]: Args;
 }
 export {};

dist/ioc/utils.d.ts

 export declare const isSymbol: (t: unknown) => t is symbol;
 export declare const valueOrArrayToArray: (smt: symbol[] | symbol) => symbol[];

package.json

 {
   "name": "@owja/ioc",
-  "version": "2.0.0-alpha.6",
+  "version": "2.0.0-alpha.7",
   "description": "dependency injection for javascript",
@@ -5,0 +5,0 @@ "main": "dist/ioc.js",

src/index.ts

 export {Container} from "./ioc/container";
-export type {Plugin, Factory, Item, NewAble, Token, Value} from "./ioc/types";
+export type {Plugin, Factory, RegItem, NewAble, Token, Value} from "./ioc/types";
 export {createDecorator} from "./ioc/createDecorator";
@@ -4,0 +4,0 @@ export {createWire} from "./ioc/createWire";

src/ioc/bind.ts

@@ -1,23 +0,23 @@
-import type {Item, NewAble, Factory, Value} from "./types";
+import type {RegItem, NewAble, Factory, Value} from "./types";
 import {Options} from "./options";
 import {PluginOptions} from "./pluginOptions";
 
-export class Bind<T, U extends Array<unknown>> {
-    constructor(private _target: Item<T>) {}
+export class Bind<Dep, Args extends Array<unknown>> {
+    constructor(private _regItem: RegItem<Dep, Args>) {}
 
-    to<O extends NewAble<T>>(object: O): Options<T> {
-        this._target.injected = (...ctorArgs: U): T => new object(...ctorArgs);
-        return new Options<T>(this._target);
+    to<Obj extends NewAble<Dep, Args>>(object: Obj): Options<Dep, Args> {
+        this._regItem.factory = (...args: Args): Dep => new object(...args);
+        return new Options<Dep, Args>(this._regItem);
     }
 
-    toFactory(factory: Factory<T, U>): Options<T> {
-        this._target.injected = factory;
-        return new Options<T>(this._target);
+    toFactory(factory: Factory<Dep, Args>): Options<Dep, Args> {
+        this._regItem.factory = factory;
+        return new Options<Dep, Args>(this._regItem);
     }
 
-    toValue(value: Value<T>): PluginOptions<T> {
+    toValue(value: Value<Dep>): PluginOptions<Dep, never> {
         if (typeof value === "undefined") throw "cannot bind a value of type undefined";
-        this._target.injected = value;
-        return new PluginOptions<T>(this._target);
+        this._regItem.value = value;
+        return new PluginOptions<Dep, never>(this._regItem);
     }
 }

src/ioc/container.ts

@@ -1,2 +0,2 @@
-import type {Factory, Injected, Item, Token, MaybeToken, Plugin} from "./types";
+import type {RegItem, Token, MaybeToken, Plugin} from "./types";
 import {Bind} from "./bind";
@@ -7,15 +7,15 @@ import {getType, stringifyToken} from "./token";
 
-const isFactory = <T>(i: Injected<T>): i is Factory<T> => typeof i === "function";
+type Registry = Map<symbol, RegItem>;
 
 export class Container {
-    private _registry = new Map<symbol, Item<unknown>>();
-    private _snapshots: typeof this._registry[] = [];
+    private _registry: Registry = new Map<symbol, RegItem>();
+    private _snapshots: Registry[] = [];
     private _plugins: Plugin[] = [];
 
-    bind<T = never, U extends Array<unknown> = never>(token: MaybeToken<T>): Bind<T, U> {
-        return new Bind<T, U>(this._createItem<T>(token));
+    bind<Dep = never, Args extends Array<unknown> = never>(token: MaybeToken<Dep>): Bind<Dep, Args> {
+        return new Bind<Dep, Args>(this._createItem<Dep, Args>(token));
     }
 
-    rebind<T = never, U extends Array<unknown> = never>(token: MaybeToken<T>): Bind<T, U> {
-        return this.remove(token).bind<T, U>(token);
+    rebind<Dep = never, Args extends Array<unknown> = never>(token: MaybeToken<Dep>): Bind<Dep, Args> {
+        return this.remove(token).bind<Dep, Args>(token);
     }
@@ -31,24 +31,32 @@
 
-    get<T, U extends Array<unknown> = never>(
-        token: Token<T, U> | MaybeToken<T>,
+    get<Dep>(token: Token<Dep> | MaybeToken<Dep>, tags?: symbol[] | symbol, target?: unknown): Dep;
+    get<Dep, Args extends Array<unknown>>(
+        token: Token<Dep, Args> | MaybeToken<Dep>,
+        tags: symbol[] | symbol,
+        target: unknown,
+        args: Args,
+    ): Dep;
+    get<Dep, Args extends Array<unknown>>(
+        token: Token<Dep, Args> | MaybeToken<Dep>,
         tags: symbol[] | symbol = [],
         target?: unknown,
-        injectedArgs: Array<unknown> = [],
-    ): T {
-        const item = <Item<T> | undefined>this._registry.get(getType(token));
+        args?: Args,
+    ): Dep {
+        const item = <RegItem<Dep, Args> | undefined>this._registry.get(getType(token));
 
-        if (item === undefined || item.injected === undefined) throw `nothing bound to ${stringifyToken(token)}`;
+        if (!item || (!item.factory && item.value === undefined)) throw `nothing bound to ${stringifyToken(token)}`;
 
-        const value = isFactory(item.injected)
+        const value: Dep = item.factory
             ? !item.singleton
-                ? item.injected(...injectedArgs)
-                : (item.cache = item.cache || item.injected())
-            : item.injected;
+                ? item.factory(...((args || []) as any))
+                : (item.cache = item.cache || item.factory(...((args || []) as any)))
+            : item.value!; // eslint-disable-line
 
         const tagsArr = valueOrArrayToArray(tags);
 
-        if (tagsArr.indexOf(NOPLUGINS) === -1)
-            item.plugins.concat(this._plugins).forEach((plugin) => {
+        if (tagsArr.indexOf(NOPLUGINS) === -1) {
+            for (const plugin of item.plugins.concat(this._plugins)) {
                 plugin(value, target, tagsArr, token, this);
-            });
+            }
+        }
 
@@ -74,3 +82,5 @@ return value;
     /* Item related */
-    private _createItem<T>(token: MaybeToken<T>): Item<T> {
+    private _createItem<Dep, Args extends Array<unknown> = []>(
+        token: Token<Dep, Args> | MaybeToken<Dep>,
+    ): RegItem<Dep, Args> {
         if (this._registry.get(getType(token)) !== undefined)
@@ -77,0 +87,0 @@ throw `object can only bound once: ${stringifyToken(token)}`;

src/ioc/createDecorator.ts

@@ -6,14 +6,14 @@ import type {Token, MaybeToken} from "./types";
 export function createDecorator(container: Container) {
-    return <T, K extends Array<unknown>>(
-        token: Token<T, K> | MaybeToken<T>,
+    return <Dep, Args extends Array<unknown>>(
+        token: Token<Dep, Args> | MaybeToken<Dep>,
         tags: symbol[] | symbol = [],
-        ...injectedArgs: K
+        ...args: Args
     ) => {
-        return function <Target extends {[key in Prop]: T}, Prop extends keyof Target>(
+        return function <Target extends {[key in Prop]: Dep}, Prop extends keyof Target>(
             target: Target,
             property: Prop,
         ): void {
-            define(target, property, container, token, tags, ...injectedArgs);
+            define(target, property, container, token, tags, args);
         };
     };
 }

src/ioc/createResolve.ts

@@ -7,7 +7,10 @@ import type {Token, MaybeToken} from "./types";
 export function createResolve(container: Container) {
-    return <T, U extends Array<unknown>>(token: Token<T, U> | MaybeToken<T>, tags: symbol[] | symbol = []) => {
-        let value: T;
-        return function <R>(this: R, ...injectedArgs: U): T {
+    return <Dep, Args extends Array<unknown>>(
+        token: Token<Dep, Args> | MaybeToken<Dep>,
+        tags: symbol[] | symbol = [],
+    ) => {
+        let value: Dep;
+        return function <R>(this: R, ...args: Args): Dep {
             if (valueOrArrayToArray(tags).indexOf(NOCACHE) !== -1 || value === undefined) {
-                value = container.get(token, tags, this, injectedArgs);
+                value = container.get(token, tags, this, args);
             }
@@ -14,0 +17,0 @@ return value;

src/ioc/createWire.ts

@@ -6,11 +6,11 @@ import type {Token, MaybeToken} from "./types";
 export function createWire(container: Container) {
-    return <Value, Target extends {[key in Prop]: Value}, Prop extends keyof Target, K extends Array<unknown>>(
+    return <Dep, Target extends {[key in Prop]: Dep}, Prop extends keyof Target, Args extends Array<unknown>>(
         target: Target,
         property: Prop,
-        token: Token<Value, K> | MaybeToken<Value>,
+        token: Token<Dep, Args> | MaybeToken<Dep>,
         tags: symbol[] | symbol = [],
-        ...injectedArgs: K
+        ...args: Args
     ) => {
-        define(target, property, container, token, tags, ...injectedArgs);
+        define(target, property, container, token, tags, args);
     };
 }

src/ioc/define.ts

@@ -6,13 +6,18 @@ import type {Token, MaybeToken} from "./types";
 
-export function define<T, Target extends {[key in Prop]: T}, Prop extends keyof Target, K extends Array<unknown>>(
+export function define<
+    Dep,
+    Target extends {[key in Prop]: Dep},
+    Prop extends keyof Target,
+    Args extends Array<unknown>,
+>(
     target: Target,
     property: Prop,
     container: Container,
-    token: Token<T, K> | MaybeToken<T>,
+    token: Token<Dep, Args> | MaybeToken<Dep>,
     tags: symbol[] | symbol,
-    ...injectedArgs: K
+    args: Args,
 ) {
     Object.defineProperty(target, property, {
-        get: function <R>(this: R): T {
-            const value = container.get(token, tags, this, injectedArgs);
+        get: function <R>(this: R): Dep {
+            const value = container.get(token, tags, this, args);
             if (valueOrArrayToArray(tags).indexOf(NOCACHE) === -1)
@@ -19,0 +24,0 @@ Object.defineProperty(this, property, {

src/ioc/options.ts

 import {PluginOptions} from "./pluginOptions";
 
-export class Options<T> extends PluginOptions<T> {
-    inSingletonScope(): PluginOptions<T> {
-        this._target.singleton = true;
+export class Options<Dep, Args extends Array<unknown>> extends PluginOptions<Dep, Args> {
+    inSingletonScope(): PluginOptions<Dep, Args> {
+        this._regItem.singleton = true;
         return this;
     }
 }

src/ioc/pluginOptions.ts

@@ -1,10 +0,10 @@
-import type {Item, Plugin} from "./types";
+import type {RegItem, Plugin} from "./types";
 
-export class PluginOptions<T> {
-    constructor(protected _target: Item<T>) {}
+export class PluginOptions<Dep, Args extends Array<unknown>> {
+    constructor(protected _regItem: RegItem<Dep, Args>) {}
 
-    withPlugin(plugin: Plugin<T>): PluginOptions<T> {
-        this._target.plugins.push(plugin);
+    withPlugin(plugin: Plugin<Dep>): PluginOptions<Dep, Args> {
+        this._regItem.plugins.push(plugin);
         return this;
     }
 }

src/ioc/token.ts

 import type {MaybeToken, Token} from "./types";
 import {isSymbol} from "./utils";
 
-export const token = <T, U extends Array<unknown> = unknown[]>(name: string) => ({type: Symbol(name)} as Token<T, U>);
+export const token = <Dep, Args extends Array<unknown> = unknown[]>(name: string) =>
+    ({type: Symbol(name)} as Token<Dep, Args>);
 
@@ -6,0 +7,0 @@ export const stringifyToken = (token: MaybeToken): string =>

src/ioc/types.ts

 import type {Container} from "./container";
 
-// container
-export type Injected<T> = Factory<T> | Value<T>;
-export interface Item<T> {
-    injected?: Injected<T>;
-    cache?: T;
+export interface RegItem<Dep = unknown, Args extends Array<unknown> = []> {
+    value?: Value<Dep>;
+    factory?: Factory<Dep, Args>;
+    cache?: Dep;
     singleton?: boolean;
-    plugins: Plugin<T>[];
+    plugins: Plugin<Dep>[];
 }
 
-export type Plugin<Dependency = unknown> = (
-    dependency: Dependency,
+export type Plugin<Dep = unknown> = (
+    dependency: Dep,
     target: unknown,
     tags: symbol[],
-    token: MaybeToken<Dependency>,
+    token: MaybeToken<Dep>,
     container: Container,
 ) => void;
 
-export interface NewAble<T> {
-    new (...ctorArgs: any[]): T;
+export interface NewAble<Dep, Args extends Array<unknown>> {
+    new (...args: Args): Dep;
 }
 
-export type Factory<T, U extends Array<unknown> = any> = (...factoryArgs: U) => T;
-export type Value<T> = T;
+export type Factory<Dep, Args extends Array<unknown>> = (...args: Args) => Dep;
+export type Value<Dependency> = Dependency;
 
 // tokens
-export type MaybeToken<T = unknown, U extends Array<unknown> = unknown[]> = Token<T, U> | symbol;
+export type MaybeToken<Dep = unknown, Args extends Array<unknown> = unknown[]> = Token<Dep, Args> | symbol;
 
-declare const typeMarker: unique symbol;
-declare const bindedArguments: unique symbol;
-export interface Token<T, U extends Array<unknown>> {
+declare const dependencyMarker: unique symbol;
+declare const argumentsMarker: unique symbol;
+export interface Token<Dep, Args extends Array<unknown> = never> {
     type: symbol;
-    [typeMarker]: T;
-    [bindedArguments]: U;
+    [dependencyMarker]: Dep;
+    [argumentsMarker]: Args;
 }

No alert changes

Improved metrics

Total package byte prevSize

62277

increased by3.57%

Lines of code

341

increased by5.57%

No dependency changes