ts-ioc-container 27.4.0 → 27.4.2

package/README.md

@@ -30,21 +30,20 @@
     - [Simple injector](#simple-injector)
     - [Proxy injector](#proxy-injector)
 - [Providers](#providers)
+    - [Registration module (Provider + DependencyKey)](#registration-and-providers) `@key`
     - [Provider](#provider) `@provider`
     - [Singleton provider](#singleton-provider)
     - [Tagged provider](#tagged-provider)
     - [Args provider](#args-provider)
     - [Aliases](#aliases) `alias`
 - [Container modules](#container-modules)
-    - [Basic usage](#basic-usage-1)
-    - [Registration module (Provider + DependencyKey)](#registration-module-provider--dependencykey) `@key`
 - [Hooks](#hooks) `@hook`
     - [OnConstruct](#onconstruct) `@onConstruct`
     - [OnDispose](#ondispose) `@onDispose`
 - [Tests and Mocks](#tests-and-mocks)
 - [Errors](#errors)
 
-## Setup
+## Setu
 
 ```shell script
 npm install ts-ioc-container reflect-metadata
@@ -78,16 +77,7 @@ And `tsconfig.json` should have next options:
 
 ```typescript
 import 'reflect-metadata';
-import {
-  IContainer,
-  by,
-  Container,
-  inject,
-  ReflectionInjector,
-  RegistrationConflictError,
-  Registration,
-  key,
-} from 'ts-ioc-container';
+import { IContainer, by, Container, inject, ReflectionInjector, Registration as R } from 'ts-ioc-container';
 
 describe('Basic usage', function () {
   class Logger {
@@ -99,7 +89,7 @@ describe('Basic usage', function () {
       constructor(@inject(by.key('ILogger')) public logger: Logger) {}
     }
 
-    const container = new Container(new ReflectionInjector()).use(Registration.fromClass(Logger).to('ILogger'));
+    const container = new Container(new ReflectionInjector()).use(R.fromClass(Logger).to('ILogger'));
 
     expect(container.resolve(App).logger.name).toBe('Logger');
   });
@@ -110,8 +100,8 @@ describe('Basic usage', function () {
     }
 
     const container = new Container(new ReflectionInjector())
-      .use(Registration.fromClass(Logger).to('ILogger1'))
-      .use(Registration.fromClass(Logger).to('ILogger2'));
+      .use(R.fromClass(Logger).to('ILogger1'))
+      .use(R.fromClass(Logger).to('ILogger2'));
 
     expect(container.resolve(App).loggers).toHaveLength(2);
   });
@@ -127,46 +117,6 @@ describe('Basic usage', function () {
 
     expect(app.scope).toBe(root);
   });
-
-  it('should not raise an error when key is busy', () => {
-    expect(() => {
-      new Container(new ReflectionInjector()).use(Registration.fromClass(Logger)).use(Registration.fromClass(Logger));
-    }).not.toThrowError(RegistrationConflictError);
-  });
-
-  it('registration -> should raise an error when key is busy', () => {
-    expect(() => {
-      new Container(new ReflectionInjector())
-        .use(Registration.fromClass(Logger))
-        .use(Registration.fromClass(Logger).throwErrorOnConflict());
-    }).toThrowError(RegistrationConflictError);
-  });
-
-  it('registration -> should not raise an error when key is busy', () => {
-    expect(() => {
-      new Container(new ReflectionInjector()).use(Registration.fromClass(Logger)).use(Registration.fromClass(Logger));
-    }).not.toThrowError(RegistrationConflictError);
-  });
-
-  it('@key -> should raise an error when key is busy', () => {
-    @key('Logger')
-    class Logger1 {}
-
-    @key('Logger')
-    class Logger2 {}
-
-    expect(() => {
-      new Container(new ReflectionInjector())
-        .use(Registration.fromClass(Logger1))
-        .use(Registration.fromClass(Logger2).throwErrorOnConflict());
-    }).toThrowError(RegistrationConflictError);
-  });
-
-  it('registration -> should not raise an error when key is busy', () => {
-    expect(() => {
-      new Container(new ReflectionInjector()).use(Registration.fromClass(Logger)).use(Registration.fromClass(Logger));
-    }).not.toThrowError(RegistrationConflictError);
-  });
 });
 
 ```
@@ -190,7 +140,7 @@ import {
   tags,
   provider,
   ReflectionInjector,
-  Registration,
+  Registration as R,
   by,
 } from 'ts-ioc-container';
 
@@ -200,7 +150,7 @@ class Logger {}
 
 describe('Scopes', function () {
   it('should resolve dependencies from scope', function () {
-    const root = new Container(new ReflectionInjector(), { tags: ['root'] }).use(Registration.fromClass(Logger));
+    const root = new Container(new ReflectionInjector(), { tags: ['root'] }).use(R.fromClass(Logger));
     const child = root.createScope('child');
 
     expect(child.resolve('ILogger')).toBe(child.resolve('ILogger'));
@@ -230,14 +180,14 @@ Sometimes you want to get all instances from container and its scopes. For examp
 
 ```typescript
 import 'reflect-metadata';
-import { inject, key, Registration, Container, ReflectionInjector, by } from 'ts-ioc-container';
+import { inject, key, Registration as R, Container, ReflectionInjector, by } from 'ts-ioc-container';
 
 describe('Instances', function () {
   @key('ILogger')
   class Logger {}
 
   it('should return injected instances', () => {
-    const container = new Container(new ReflectionInjector()).use(Registration.fromClass(Logger));
+    const container = new Container(new ReflectionInjector()).use(R.fromClass(Logger));
     const scope = container.createScope();
 
     const logger1 = container.resolve('ILogger');
@@ -254,7 +204,7 @@ describe('Instances', function () {
       constructor(@inject(by.instances(isLogger)) public loggers: Logger[]) {}
     }
 
-    const container = new Container(new ReflectionInjector()).use(Registration.fromClass(Logger));
+    const container = new Container(new ReflectionInjector()).use(R.fromClass(Logger));
 
     const logger0 = container.resolve('ILogger');
     const logger1 = container.resolve('ILogger');
@@ -277,15 +227,13 @@ Sometimes you want to dispose container and all its scopes. For example, when yo
 
 ```typescript
 import 'reflect-metadata';
-import { Container, ContainerDisposedError, ReflectionInjector, Registration } from 'ts-ioc-container';
+import { Container, ContainerDisposedError, ReflectionInjector, Registration as R } from 'ts-ioc-container';
 
 class Logger {}
 
 describe('Disposing', function () {
   it('should container and make it unavailable for the further usage', function () {
-    const root = new Container(new ReflectionInjector(), { tags: ['root'] }).use(
-      Registration.fromClass(Logger).to('ILogger'),
-    );
+    const root = new Container(new ReflectionInjector(), { tags: ['root'] }).use(R.fromClass(Logger).to('ILogger'));
     const child = root.createScope('child');
 
     const logger = child.resolve('ILogger');
@@ -311,7 +259,7 @@ This type of injector uses `@inject` decorator to mark where dependencies should
 
 ```typescript
 import 'reflect-metadata';
-import { by, Container, inject, ReflectionInjector, Registration } from 'ts-ioc-container';
+import { by, Container, inject, ReflectionInjector, Registration as R } from 'ts-ioc-container';
 
 class Logger {
   name = 'Logger';
@@ -331,7 +279,7 @@ class App {
 
 describe('Reflection Injector', function () {
   it('should inject dependencies by @inject decorator', function () {
-    const container = new Container(new ReflectionInjector()).use(Registration.fromClass(Logger).to('ILogger'));
+    const container = new Container(new ReflectionInjector()).use(R.fromClass(Logger).to('ILogger'));
 
     const app = container.resolve(App);
 
@@ -346,7 +294,7 @@ This type of injector just passes container to constructor with others arguments
 
 ```typescript
 import 'reflect-metadata';
-import { Container, IContainer, Registration, SimpleInjector } from 'ts-ioc-container';
+import { Container, IContainer, Registration as R, SimpleInjector } from 'ts-ioc-container';
 
 describe('SimpleInjector', function () {
   it('should pass container as first parameter', function () {
@@ -354,7 +302,7 @@ describe('SimpleInjector', function () {
       constructor(public container: IContainer) {}
     }
 
-    const container = new Container(new SimpleInjector()).use(Registration.fromClass(App).to('App'));
+    const container = new Container(new SimpleInjector()).use(R.fromClass(App).to('App'));
     const app = container.resolve<App>('App');
 
     expect(app.container).toBeInstanceOf(Container);
@@ -365,7 +313,7 @@ describe('SimpleInjector', function () {
       constructor(container: IContainer, public greeting: string) {}
     }
 
-    const container = new Container(new SimpleInjector()).use(Registration.fromClass(App).to('App'));
+    const container = new Container(new SimpleInjector()).use(R.fromClass(App).to('App'));
     const app = container.resolve<App>('App', 'Hello world');
 
     expect(app.greeting).toBe('Hello world');
@@ -379,7 +327,7 @@ This type of injector injects dependencies as dictionary `Record<string, unknown
 
 ```typescript
 import 'reflect-metadata';
-import { Container, ProxyInjector, args, Registration } from 'ts-ioc-container';
+import { Container, ProxyInjector, args, Registration as R } from 'ts-ioc-container';
 
 describe('ProxyInjector', function () {
   it('should pass dependency to constructor as dictionary', function () {
@@ -393,7 +341,7 @@ describe('ProxyInjector', function () {
       }
     }
 
-    const container = new Container(new ProxyInjector()).use(Registration.fromClass(Logger).to('logger'));
+    const container = new Container(new ProxyInjector()).use(R.fromClass(Logger).to('logger'));
 
     const app = container.resolve(App);
     expect(app.logger).toBeInstanceOf(Logger);
@@ -423,8 +371,8 @@ describe('ProxyInjector', function () {
     const greetingTemplate = (name: string) => `Hello ${name}`;
 
     const container = new Container(new ProxyInjector())
-      .use(Registration.fromClass(App).to('App').pipe(args({ greetingTemplate })))
-      .use(Registration.fromClass(Logger).to('logger'));
+      .use(R.fromClass(App).to('App').pipe(args({ greetingTemplate })))
+      .use(R.fromClass(Logger).to('logger'));
 
     const app = container.resolve<App>('App', { name: `world` });
     expect(app.greeting).toBe('Hello world');
@@ -433,7 +381,7 @@ describe('ProxyInjector', function () {
 
 ```
 
-## Providers
+## Registration and Providers
 `IProvider<T>` is used to describe how instances should be created. It has next basic methods:
 - `resolve` - creates instance with passed arguments
 - `clone` - we invoke it when we create a scope. It clones provider to new scope.
@@ -445,6 +393,58 @@ There are next types of providers:
 - `TaggedProvider` - provider that can be resolved only from container with certain tags and their sub scopes
 - `ArgsProvider` - provider that encapsulates arguments to pass it to constructor.
 
+`Registration` - just a helper to register provider with certain key. `(preferrably to use)`
+
+### Registration (Provider + DependencyKey)
+Sometimes you need to keep dependency key with class together. For example, you want to register class with key 'ILogger' and you want to keep this key with class. This is what `Registration` is for.
+
+```typescript
+import 'reflect-metadata';
+import { singleton, Container, tags, provider, ReflectionInjector, Registration as R, key } from 'ts-ioc-container';
+import { DependencyMissingKeyError } from '../../lib/errors/DependencyMissingKeyError';
+
+describe('Registration module', function () {
+  const createContainer = () => new Container(new ReflectionInjector(), { tags: ['root'] });
+
+  it('should register class', function () {
+    @key('ILogger')
+    @provider(singleton(), tags('root'))
+    class Logger {}
+
+    const root = createContainer().use(R.fromClass(Logger));
+
+    expect(root.resolve('ILogger')).toBeInstanceOf(Logger);
+  });
+
+  it('should register value', function () {
+    const root = createContainer().use(R.fromValue('smth').to('ISmth'));
+
+    expect(root.resolve('ISmth')).toBe('smth');
+  });
+
+  it('should register fn', function () {
+    const root = createContainer().use(R.fromFn(() => 'smth').to('ISmth'));
+
+    expect(root.resolve('ISmth')).toBe('smth');
+  });
+
+  it('should raise an error if key is not provider', () => {
+    expect(() => {
+      createContainer().use(R.fromValue('smth'));
+    }).toThrowError(DependencyMissingKeyError);
+  });
+
+  it('should register dependency by class name if @key is not provided', function () {
+    class FileLogger {}
+
+    const root = createContainer().use(R.fromClass(FileLogger));
+
+    expect(root.resolve('FileLogger')).toBeInstanceOf(FileLogger);
+  });
+});
+
+```
+
 ### Provider
 
 ```typescript
@@ -492,7 +492,7 @@ Sometimes you need to create only one instance of dependency per scope. For exam
 
 ```typescript
 import 'reflect-metadata';
-import { singleton, Container, key, provider, ReflectionInjector, Registration } from 'ts-ioc-container';
+import { singleton, Container, key, provider, ReflectionInjector, Registration as R } from 'ts-ioc-container';
 
 @key('logger')
 @provider(singleton())
@@ -504,20 +504,20 @@ describe('Singleton', function () {
   }
 
   it('should resolve the same container per every request', function () {
-    const container = createContainer().use(Registration.fromClass(Logger));
+    const container = createContainer().use(R.fromClass(Logger));
 
     expect(container.resolve('logger')).toBe(container.resolve('logger'));
   });
 
   it('should resolve different dependency per scope', function () {
-    const container = createContainer().use(Registration.fromClass(Logger));
+    const container = createContainer().use(R.fromClass(Logger));
     const child = container.createScope();
 
     expect(container.resolve('logger')).not.toBe(child.resolve('logger'));
   });
 
   it('should resolve the same dependency for scope', function () {
-    const container = createContainer().use(Registration.fromClass(Logger));
+    const container = createContainer().use(R.fromClass(Logger));
     const child = container.createScope();
 
     expect(child.resolve('logger')).toBe(child.resolve('logger'));
@@ -532,14 +532,14 @@ Sometimes you need to resolve provider only from container with certain tags and
 
 ```typescript
 import 'reflect-metadata';
-import { singleton, Container, key, tags, provider, ReflectionInjector, Registration } from 'ts-ioc-container';
+import { singleton, Container, key, tags, provider, ReflectionInjector, Registration as R } from 'ts-ioc-container';
 
 @key('ILogger')
 @provider(singleton(), tags('root')) // the same as .pipe(singleton(), tags('root'))
 class Logger {}
 describe('TaggedProvider', function () {
   it('should return the same instance', function () {
-    const root = new Container(new ReflectionInjector(), { tags: ['root'] }).use(Registration.fromClass(Logger));
+    const root = new Container(new ReflectionInjector(), { tags: ['root'] }).use(R.fromClass(Logger));
     const child = root.createScope();
     expect(root.resolve('ILogger')).toBe(child.resolve('ILogger'));
   });
@@ -553,7 +553,7 @@ Sometimes you want to bind some arguments to provider. This is what `ArgsProvide
 
 ```typescript
 import 'reflect-metadata';
-import { Container, key, argsFn, args, ReflectionInjector, Registration } from 'ts-ioc-container';
+import { Container, key, argsFn, args, ReflectionInjector, Registration as R } from 'ts-ioc-container';
 
 @key('logger')
 class Logger {
@@ -566,21 +566,21 @@ describe('ArgsProvider', function () {
   }
 
   it('can assign argument function to provider', function () {
-    const root = createContainer().use(Registration.fromClass(Logger).pipe(argsFn((container, ...args) => ['name'])));
+    const root = createContainer().use(R.fromClass(Logger).pipe(argsFn((container, ...args) => ['name'])));
 
     const logger = root.createScope().resolve<Logger>('logger');
     expect(logger.name).toBe('name');
   });
 
   it('can assign argument to provider', function () {
-    const root = createContainer().use(Registration.fromClass(Logger).pipe(args('name')));
+    const root = createContainer().use(R.fromClass(Logger).pipe(args('name')));
 
     const logger = root.resolve<Logger>('logger');
     expect(logger.name).toBe('name');
   });
 
   it('should set provider arguments with highest priority in compare to resolve arguments', function () {
-    const root = createContainer().use(Registration.fromClass(Logger).pipe(args('name')));
+    const root = createContainer().use(R.fromClass(Logger).pipe(args('name')));
 
     const logger = root.resolve<Logger>('logger', 'file');
 
@@ -599,7 +599,7 @@ Sometimes you want to register the same provider with different keys. This is wh
 
 ```typescript
 import 'reflect-metadata';
-import { alias, by, Container, inject, provider, ReflectionInjector, Registration } from 'ts-ioc-container';
+import { alias, by, Container, inject, provider, ReflectionInjector, Registration as R } from 'ts-ioc-container';
 
 describe('alias', () => {
   const IMiddlewareKey = Symbol('IMiddleware');
@@ -653,8 +653,8 @@ describe('alias', () => {
     }
 
     const container = new Container(new ReflectionInjector())
-      .use(Registration.fromClass(LoggerMiddleware))
-      .use(Registration.fromClass(ErrorHandlerMiddleware));
+      .use(R.fromClass(LoggerMiddleware))
+      .use(R.fromClass(ErrorHandlerMiddleware));
 
     const app = container.resolve(App);
     app.run();
@@ -669,11 +669,9 @@ describe('alias', () => {
 ## Container modules
 Sometimes you want to encapsulate registration logic in separate module. This is what `IContainerModule` is for.
 
-### Basic usage
-
 ```typescript
 import 'reflect-metadata';
-import { IContainerModule, Registration, IContainer, key, Container, ReflectionInjector } from 'ts-ioc-container';
+import { IContainerModule, Registration as R, IContainer, key, Container, ReflectionInjector } from 'ts-ioc-container';
 
 @key('ILogger')
 class Logger {}
@@ -683,13 +681,13 @@ class TestLogger {}
 
 class Production implements IContainerModule {
   applyTo(container: IContainer): void {
-    container.use(Registration.fromClass(Logger));
+    container.use(R.fromClass(Logger));
   }
 }
 
 class Development implements IContainerModule {
   applyTo(container: IContainer): void {
-    container.use(Registration.fromClass(TestLogger));
+    container.use(R.fromClass(TestLogger));
   }
 }
 
@@ -713,37 +711,6 @@ describe('Container Modules', function () {
 
 ```
 
-### Registration module (Provider + DependencyKey)
-Sometimes you need to keep dependency key with class together. For example, you want to register class with key 'ILogger' and you want to keep this key with class. This is what `Registration` is for.
-
-```typescript
-import 'reflect-metadata';
-import { singleton, Container, tags, provider, ReflectionInjector, Registration, key } from 'ts-ioc-container';
-
-describe('Registration module', function () {
-  const createContainer = () => new Container(new ReflectionInjector(), { tags: ['root'] });
-
-  it('should register dependency by @key', function () {
-    @key('ILogger')
-    @provider(singleton(), tags('root'))
-    class Logger {}
-
-    const root = createContainer().use(Registration.fromClass(Logger));
-
-    expect(root.resolve('ILogger')).toBeInstanceOf(Logger);
-  });
-
-  it('should register dependency by class name if @key is not provided', function () {
-    class FileLogger {}
-
-    const root = createContainer().use(Registration.fromClass(FileLogger));
-
-    expect(root.resolve('FileLogger')).toBeInstanceOf(FileLogger);
-  });
-});
-
-```
-
 ## Hooks
 Sometimes you need to invoke methods after construct or dispose of class. This is what hooks are for.
 
@@ -759,7 +726,7 @@ import {
   IContainer,
   IInjector,
   ReflectionInjector,
-  Registration,
+  Registration as R,
 } from 'ts-ioc-container';
 
 class MyInjector implements IInjector {
@@ -792,7 +759,7 @@ class Logger {
 
 describe('onConstruct', function () {
   it('should make logger be ready on resolve', function () {
-    const container = new Container(new MyInjector()).use(Registration.fromClass(Logger));
+    const container = new Container(new MyInjector()).use(R.fromClass(Logger));
 
     const logger = container.resolve<Logger>('logger');
 
@@ -814,7 +781,7 @@ import {
   hook,
   inject,
   provider,
-  Registration,
+  Registration as R,
   ReflectionInjector,
 } from 'ts-ioc-container';
 
@@ -847,9 +814,7 @@ class Logger {
 
 describe('onDispose', function () {
   it('should invoke hooks on all instances', async function () {
-    const container = new Container(new ReflectionInjector())
-      .use(Registration.fromClass(Logger))
-      .use(Registration.fromClass(LogsRepo));
+    const container = new Container(new ReflectionInjector()).use(R.fromClass(Logger)).use(R.fromClass(LogsRepo));
 
     const logger = container.resolve<Logger>('logger');
     logger.log('Hello');

package/cjm/container/Container.js

@@ -67,8 +67,10 @@ class Container {
     hasTag(tag) {
         return this.tags.includes(tag);
     }
-    use(module) {
-        module.applyTo(this);
+    use(...modules) {
+        for (const module of modules) {
+            module.applyTo(this);
+        }
         return this;
     }
     hasDependency(key) {

package/cjm/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getMetadata = exports.setMetadata = exports.by = exports.hook = exports.getHooks = exports.ProxyInjector = exports.SimpleInjector = exports.inject = exports.ReflectionInjector = exports.Registration = exports.key = exports.AutoMockedContainer = exports.TaggedProvider = exports.tags = exports.SingletonProvider = exports.singleton = exports.ArgsProvider = exports.args = exports.argsFn = exports.provider = exports.Provider = exports.ContainerDisposedError = exports.MethodNotImplementedError = exports.DependencyNotFoundError = exports.alias = exports.EmptyContainer = exports.Container = exports.isDependencyKey = void 0;
+exports.setParameterMetadata = exports.getMetadata = exports.setMetadata = exports.by = exports.hook = exports.getHooks = exports.ProxyInjector = exports.SimpleInjector = exports.inject = exports.ReflectionInjector = exports.Registration = exports.key = exports.AutoMockedContainer = exports.TaggedProvider = exports.tags = exports.SingletonProvider = exports.singleton = exports.ArgsProvider = exports.args = exports.argsFn = exports.provider = exports.Provider = exports.ContainerDisposedError = exports.MethodNotImplementedError = exports.DependencyNotFoundError = exports.alias = exports.EmptyContainer = exports.Container = exports.isDependencyKey = void 0;
 var IContainer_1 = require("./container/IContainer");
 Object.defineProperty(exports, "isDependencyKey", { enumerable: true, get: function () { return IContainer_1.isDependencyKey; } });
 var Container_1 = require("./container/Container");
@@ -48,3 +48,4 @@ Object.defineProperty(exports, "by", { enumerable: true, get: function () { retu
 var metadata_1 = require("./metadata");
 Object.defineProperty(exports, "setMetadata", { enumerable: true, get: function () { return metadata_1.setMetadata; } });
 Object.defineProperty(exports, "getMetadata", { enumerable: true, get: function () { return metadata_1.getMetadata; } });
+Object.defineProperty(exports, "setParameterMetadata", { enumerable: true, get: function () { return metadata_1.setParameterMetadata; } });

package/cjm/injector/ReflectionInjector.js

@@ -2,19 +2,15 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ReflectionInjector = exports.inject = void 0;
 const utils_1 = require("../utils");
+const metadata_1 = require("../metadata");
 const INJECT_KEY = 'INJECT_FN_LIST';
-const inject = (value) => (target, propertyKey, parameterIndex) => {
-    var _a;
-    const metadata = (_a = Reflect.getOwnMetadata(INJECT_KEY, target)) !== null && _a !== void 0 ? _a : [];
-    metadata[parameterIndex] = value;
-    Reflect.defineMetadata(INJECT_KEY, metadata, target);
-};
+const inject = (value) => (0, metadata_1.setParameterMetadata)(INJECT_KEY, value);
 exports.inject = inject;
 class ReflectionInjector {
     resolve(container, Target, ...deps) {
         var _a;
         const injectionFns = (_a = Reflect.getOwnMetadata(INJECT_KEY, Target)) !== null && _a !== void 0 ? _a : [];
-        const args = (0, utils_1.merge)(injectionFns, deps.map(utils_1.constant)).map((fn) => fn(container));
+        const args = (0, utils_1.fillEmptyIndexes)(injectionFns, deps.map(utils_1.constant)).map((fn) => fn(container));
         return new Target(...args);
     }
 }

package/cjm/metadata.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getMetadata = exports.setMetadata = void 0;
+exports.setParameterMetadata = exports.getMetadata = exports.setMetadata = void 0;
 const setMetadata = (key, value) => (target) => {
     Reflect.defineMetadata(key, value, target);
 };
@@ -10,3 +10,10 @@ function getMetadata(target, key) {
     return Reflect.getOwnMetadata(key, target);
 }
 exports.getMetadata = getMetadata;
+const setParameterMetadata = (key, value) => (target, propertyKey, parameterIndex) => {
+    var _a;
+    const metadata = (_a = Reflect.getOwnMetadata(key, target)) !== null && _a !== void 0 ? _a : [];
+    metadata[parameterIndex] = value;
+    Reflect.defineMetadata(key, metadata, target);
+};
+exports.setParameterMetadata = setParameterMetadata;

package/cjm/utils.js

@@ -1,23 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.constant = exports.merge = exports.pipe = void 0;
+exports.constant = exports.fillEmptyIndexes = exports.pipe = void 0;
 function pipe(...mappers) {
     return (value) => mappers.reduce((acc, current) => current(acc), value);
 }
 exports.pipe = pipe;
-function merge(baseArr, insertArr) {
-    if (baseArr.length === 0) {
-        return insertArr;
+function fillEmptyIndexes(baseArr, insertArr) {
+    const a = [...baseArr];
+    const b = [...insertArr];
+    for (let i = 0; i < a.length; i++) {
+        if (a[i] === undefined) {
+            a[i] = b.shift();
+        }
     }
-    if (insertArr.length === 0) {
-        return baseArr;
-    }
-    const [b1, ...restBaseArr] = baseArr;
-    const [i1, ...restInsertArr] = insertArr;
-    return b1 === undefined
-        ? [i1].concat(merge(restBaseArr, restInsertArr))
-        : [b1].concat(merge(restBaseArr, insertArr));
+    return a.concat(b);
 }
-exports.merge = merge;
+exports.fillEmptyIndexes = fillEmptyIndexes;
 const constant = (value) => () => value;
 exports.constant = constant;

package/esm/container/Container.js

@@ -64,8 +64,10 @@ export class Container {
     hasTag(tag) {
         return this.tags.includes(tag);
     }
-    use(module) {
-        module.applyTo(this);
+    use(...modules) {
+        for (const module of modules) {
+            module.applyTo(this);
+        }
         return this;
     }
     hasDependency(key) {

package/esm/index.js

@@ -16,4 +16,4 @@ export { SimpleInjector } from './injector/SimpleInjector';
 export { ProxyInjector } from './injector/ProxyInjector';
 export { getHooks, hook } from './hook';
 export { by } from './by';
-export { setMetadata, getMetadata } from './metadata';
+export { setMetadata, getMetadata, setParameterMetadata } from './metadata';

package/esm/injector/ReflectionInjector.js

@@ -1,16 +1,12 @@
-import { constant, merge } from '../utils';
+import { constant, fillEmptyIndexes } from '../utils';
+import { setParameterMetadata } from '../metadata';
 const INJECT_KEY = 'INJECT_FN_LIST';
-export const inject = (value) => (target, propertyKey, parameterIndex) => {
-    var _a;
-    const metadata = (_a = Reflect.getOwnMetadata(INJECT_KEY, target)) !== null && _a !== void 0 ? _a : [];
-    metadata[parameterIndex] = value;
-    Reflect.defineMetadata(INJECT_KEY, metadata, target);
-};
+export const inject = (value) => setParameterMetadata(INJECT_KEY, value);
 export class ReflectionInjector {
     resolve(container, Target, ...deps) {
         var _a;
         const injectionFns = (_a = Reflect.getOwnMetadata(INJECT_KEY, Target)) !== null && _a !== void 0 ? _a : [];
-        const args = merge(injectionFns, deps.map(constant)).map((fn) => fn(container));
+        const args = fillEmptyIndexes(injectionFns, deps.map(constant)).map((fn) => fn(container));
         return new Target(...args);
     }
 }

package/esm/metadata.js

@@ -5,3 +5,9 @@ export const setMetadata = (key, value) => (target) => {
 export function getMetadata(target, key) {
     return Reflect.getOwnMetadata(key, target);
 }
+export const setParameterMetadata = (key, value) => (target, propertyKey, parameterIndex) => {
+    var _a;
+    const metadata = (_a = Reflect.getOwnMetadata(key, target)) !== null && _a !== void 0 ? _a : [];
+    metadata[parameterIndex] = value;
+    Reflect.defineMetadata(key, metadata, target);
+};

package/esm/utils.js

@@ -1,17 +1,14 @@
 export function pipe(...mappers) {
     return (value) => mappers.reduce((acc, current) => current(acc), value);
 }
-export function merge(baseArr, insertArr) {
-    if (baseArr.length === 0) {
-        return insertArr;
+export function fillEmptyIndexes(baseArr, insertArr) {
+    const a = [...baseArr];
+    const b = [...insertArr];
+    for (let i = 0; i < a.length; i++) {
+        if (a[i] === undefined) {
+            a[i] = b.shift();
+        }
     }
-    if (insertArr.length === 0) {
-        return baseArr;
-    }
-    const [b1, ...restBaseArr] = baseArr;
-    const [i1, ...restInsertArr] = insertArr;
-    return b1 === undefined
-        ? [i1].concat(merge(restBaseArr, restInsertArr))
-        : [b1].concat(merge(restBaseArr, insertArr));
+    return a.concat(b);
 }
 export const constant = (value) => () => value;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-ioc-container",
-  "version": "27.4.0",
+  "version": "27.4.2",
   "description": "Typescript IoC container",
   "publishConfig": {
     "access": "public",
@@ -41,8 +41,8 @@
     "build:cjm": "rimraf cjm && tsc -p tsconfig.production.json --outDir cjm --module CommonJS",
     "build:esm": "rimraf esm && tsc -p tsconfig.production.json --outDir esm",
     "build:types": "rimraf typings && tsc -p tsconfig.production.json --outDir typings --emitDeclarationOnly --declaration",
-    "build:readme": "ts-node scripts/generateReadme/generateReadme.ts",
-    "build": "npm run build:cjm && npm run build:esm && npm run build:types && npm run build:readme",
+    "generate:docs": "ts-node scripts/generateReadme/generateReadme.ts && git add README.md",
+    "build": "npm run build:cjm && npm run build:esm && npm run build:types",
     "coverage": "coveralls",
     "watch": "nodemon --watch ./lib --exec npm run build",
     "test": "jest --coverage"
@@ -60,5 +60,5 @@
     "ts-node": "^10.9.1",
     "typescript": "4.4.3"
   },
-  "gitHead": "917c4879c7452ab78bb70482479e963e451361a3"
+  "gitHead": "f3cf3333af2a2182dcce507a564d30c9cbee2ace"
 }

package/typings/container/Container.d.ts

@@ -20,7 +20,7 @@ export declare class Container implements IContainer, Tagged {
     dispose(): void;
     getInstances(): unknown[];
     hasTag(tag: Tag): boolean;
-    use(module: IContainerModule): this;
+    use(...modules: IContainerModule[]): this;
     hasDependency(key: DependencyKey): boolean;
     /**
      * @private

package/typings/container/IContainer.d.ts

@@ -23,7 +23,7 @@ export interface IContainer extends Resolvable {
     removeScope(child: IContainer): void;
     getInstances(): unknown[];
     dispose(): void;
-    use(module: IContainerModule): this;
+    use(...modules: IContainerModule[]): this;
     hasTag(tag: Tag): boolean;
     getAllProviders(): Map<DependencyKey, IProvider>;
     getTokensByProvider(predicate: (provider: IProvider) => boolean): DependencyKey[];

package/typings/index.d.ts

@@ -18,4 +18,4 @@ export { SimpleInjector } from './injector/SimpleInjector';
 export { ProxyInjector } from './injector/ProxyInjector';
 export { getHooks, hook } from './hook';
 export { by, InstancePredicate } from './by';
-export { setMetadata, getMetadata } from './metadata';
+export { setMetadata, getMetadata, setParameterMetadata } from './metadata';

package/typings/metadata.d.ts

@@ -1,2 +1,3 @@
 export declare const setMetadata: <T>(key: string | symbol, value: T) => ClassDecorator;
 export declare function getMetadata<T>(target: Object, key: string | symbol): T | undefined;
+export declare const setParameterMetadata: <T>(key: string | symbol, value: T) => ParameterDecorator;

package/typings/utils.d.ts

@@ -1,5 +1,5 @@
 export declare type constructor<T> = new (...args: any[]) => T;
 export declare type MapFn<T> = (value: T) => T;
 export declare function pipe<T>(...mappers: MapFn<T>[]): MapFn<T>;
-export declare function merge<T>(baseArr: (T | undefined)[], insertArr: T[]): T[];
+export declare function fillEmptyIndexes<T>(baseArr: (T | undefined)[], insertArr: T[]): T[];
 export declare const constant: <T>(value: T) => () => T;