@rocketmakers/ioc 0.2.4 → 0.3.5

package/README.md

@@ -14,7 +14,11 @@ You should first create a type that describes your Container items, then create
 
 `service/admin.ts`
 ```TypeScript
-export class AdminService {}
+export class AdminService {
+  doSomething(value: number) {
+    return Math.round(value);
+  }
+}
 
 ```
 
@@ -30,27 +34,32 @@ export class AdminController {
 
 `service/external-api.ts`
 ```TypeScript
-import { fetchUser, IUser } from './external';
+import { fetchUserData, IUser } from './external';
 
 // NOTE: we want the apiKey param to be provided (curried) from the container - so we never need to explicitly pass this when consuming this function!
-export function getExternalData(apiKey: string, id: number): IUser {
-  return fetchUser(apiKey, id);
+export function getExternalUserData(apiKey: string, id: number): IUser {
+  return fetchUserData(apiKey, id);
 }
 
 ```
 `ioc/types.ts`
 ```TypeScript
-import { Curried1 } from '@rocketmakers/ioc';
+import { Curried1, Curried2 } from '@rocketmakers/ioc';
 
+// Application Types
 import type { AdminController } from '../controller/admin';
 import type { AdminService } from '../service/admin';
-import type { getExternalData } from '../service/external-api';
+import type { getExternalUserData } from '../service/external-api';
 
+/** Define the types registered within the container */
 export type ControllerContainerTypes = {
+  id: number;
+  apiKey: string;
   adminService: AdminService;
   adminController: AdminController;
-  apiKey: string;
-  getExternalData: Curried1<typeof getExternalData>;
+  getExternalUserData: typeof getExternalUserData;
+  getExternalUserData1: Curried1<typeof getExternalUserData>;
+  getExternalUserData2: Curried2<typeof getExternalUserData>;
 };
 
 ```
@@ -61,40 +70,83 @@ export type ControllerContainerTypes = {
 
 `ioc/register.ts`
 ```TypeScript
-import { containerRegisterFunctionResolver, IContainer, register } from '@rocketmakers/ioc';
+import { IContainer, register } from '@rocketmakers/ioc';
 
 import { AdminController } from '../controller/admin';
 import { AdminService } from '../service/admin';
-import { getExternalData } from '../service/external-api';
+import { getExternalUserData } from '../service/external-api';
 import { ControllerContainerTypes } from './types';
 
-export const functionResolver = containerRegisterFunctionResolver<ControllerContainerTypes>();
-
 export function makeContainer(): IContainer<ControllerContainerTypes> {
+  // Register all the keys of the 'ControllerContainerTypes'
   return register<ControllerContainerTypes>({
-    adminController: b => b.class(AdminController).construct(['adminService']),
-    adminService: b => b.class(AdminService).construct([]),
+    id: b => b.constant(31313),
     apiKey: b => b.constant('xyz...'),
-    getExternalData: b => b.functionResolver(functionResolver.curry1(getExternalData, 'apiKey')),
+    adminService: b => b.class(AdminService, []),
+    adminController: b => b.class(AdminController, ['adminService']),
+    getExternalUserData: b => b.function(getExternalUserData),
+    getExternalUserData1: b => b.functionCurry(getExternalUserData, ['apiKey']),
+    getExternalUserData2: b => b.functionCurry(getExternalUserData, ['apiKey', 'id']),
+  });
+}
+
+```
+
+`ioc/register-with-prefix.ts`
+```TypeScript
+import { registerWithPrefix } from '@rocketmakers/ioc';
+
+import { AdminController } from '../controller/admin';
+import { AdminService } from '../service/admin';
+import { getExternalUserData } from '../service/external-api';
+import { ControllerContainerTypes } from './types';
+
+export function makeContainerPrefixed<TPrefix extends string>(prefix: TPrefix, id: number, apiKey: string) {
+  // Register all the keys of the 'ControllerContainerTypes'
+  return registerWithPrefix<TPrefix, ControllerContainerTypes>('none', prefix, {
+    id: b => b.constant(id),
+    apiKey: b => b.constant(apiKey),
+    adminService: b => b.class(AdminService, []),
+    adminController: b => b.class(AdminController, ['adminService']),
+    getExternalUserData: b => b.function(getExternalUserData),
+    getExternalUserData1: b => b.functionCurry(getExternalUserData, ['apiKey']),
+    getExternalUserData2: b => b.functionCurry(getExternalUserData, ['apiKey', 'id']),
   });
 }
 
+const v1 = makeContainerPrefixed('this-', 31313, 'xyz...');
+v1.get('this-id');
+v1.get('this-apiKey');
+v1.get('this-adminService');
+v1.get('this-adminController');
+v1.get('this-getExternalUserData');
+v1.get('this-getExternalUserData1');
+v1.get('this-getExternalUserData2');
+
+const v2 = makeContainerPrefixed('that-', 13131, 'abc...');
+v2.get('that-id');
+v2.get('that-apiKey');
+v2.get('that-adminService');
+v2.get('that-adminController');
+v2.get('that-getExternalUserData');
+v2.get('that-getExternalUserData1');
+v2.get('that-getExternalUserData2');
+
 ```
 
 ### Resolving with the container
 
 ```TypeScript
-import { makeContainer } from './ioc/register-new';
+import { makeContainer } from './ioc/register';
 
 export function boot() {
   // Register the container
   const container = makeContainer();
 
-  //  fn has type "(id: number): number" as we curried out the apiKey param
-  const fn = container.get('getExternalData');
-
-  // extData is a "number"
-  const extData = fn(23);
+  //  getExternalUserData1 has type "(id: number): IUser" as we curried out the apiKey param
+  const getExternalUserData1 = container.get('getExternalUserData1');
+  const userData = getExternalUserData1(23);
+  return userData;
 }
 
 boot();
@@ -110,22 +162,28 @@ boot();
 ```TypeScript
 import { containerFactory, containerRegister, containerRegisterFunctionResolver } from '@rocketmakers/ioc';
 
+// Application Types
 import { AdminController } from '../controller/admin';
 import { AdminService } from '../service/admin';
-import { getExternalData } from '../service/external-api';
+import { getExternalUserData } from '../service/external-api';
 import { ControllerContainerTypes } from './types';
 
+/** @deprecated LEGACY: Create register helper  */
 export const register = containerRegister<ControllerContainerTypes>();
+/** @deprecated LEGACY: Create function resolver  */
 export const functionResolver = containerRegisterFunctionResolver<ControllerContainerTypes>();
+/** @deprecated LEGACY: Create register container  */
 export const container = containerFactory<ControllerContainerTypes>();
 
 export function registerIoC(): void {
+  // Register all the keys of the 'ControllerContainerTypes'
+  register.constant('id', 31313);
+  register.constant('apiKey', 'xyz...');
   register.class('adminService', AdminService).construct([]).inSingletonScope();
   register.class('adminController', AdminController).construct(['adminService']).inSingletonScope();
-
-  register.constant('apiKey', 'xyz...');
-
-  register.function('getExternalData', functionResolver.curry1(getExternalData, 'apiKey'));
+  register.function('getExternalUserData', getExternalUserData);
+  register.function('getExternalUserData1', functionResolver.curry1(getExternalUserData, 'apiKey'));
+  register.function('getExternalUserData2', functionResolver.curry2(getExternalUserData, 'apiKey', 'id'));
 }
 
 ```
@@ -133,17 +191,17 @@ export function registerIoC(): void {
 ### Resolving with the container
 
 ```TypeScript
-import { container, registerIoC } from './ioc/register';
+import { container, registerIoC } from './ioc/register-legacy';
 
 export function boot() {
   // Register the container
   registerIoC();
 
-  //  fn has type "(id: number): number" as we curried out the apiKey param
-  const fn = container.get('getExternalData');
+  //  getExternalUserData has type "(id: number): IUser" as we curried out the apiKey param
+  const getExternalUserData1 = container.get('getExternalUserData1');
 
-  // extData is a "number"
-  const extData = fn(23);
+  const userData = getExternalUserData1(23);
+  return userData;
 }
 
 boot();

package/lib/binder-legacy.d.ts

@@ -0,0 +1,9 @@
+import { Binder } from './binder';
+import { NewableOf, TupleToKeysOfMapped } from './types';
+/** @deprecated LEGACY: Using older method of class binding */
+export declare class LegacyBinder<T, TItem, TDep> extends Binder<T, TItem, TDep> {
+    /** Register a class */
+    classOld<C extends NewableOf<TItem>>(cls: C): {
+        construct(keys: TupleToKeysOfMapped<ConstructorParameters<C>, T & TDep>): import("./inversify").BindingInWhenOnSyntax<InstanceType<C>>;
+    };
+}

package/lib/binder-legacy.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LegacyBinder = void 0;
+var tslib_1 = require("tslib");
+var binder_1 = require("./binder");
+var inversify_1 = require("./inversify");
+/** @deprecated LEGACY: Using older method of class binding */
+var LegacyBinder = /** @class */ (function (_super) {
+    tslib_1.__extends(LegacyBinder, _super);
+    function LegacyBinder() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    /** Register a class */
+    LegacyBinder.prototype.classOld = function (cls) {
+        var k = this.key;
+        var t = this.keyTransformer;
+        return {
+            construct: function (keys) {
+                var keys1 = keys;
+                return (0, inversify_1.registerClass)(k, cls, keys1.map(t));
+            },
+        };
+    };
+    return LegacyBinder;
+}(binder_1.Binder));
+exports.LegacyBinder = LegacyBinder;

package/lib/binder.d.ts

@@ -0,0 +1,22 @@
+import { Curried1, Param1 } from './curry.generated';
+import { Func, IFunctionResolver } from './tail.generated';
+import { NewableOf, TupleToKeysOfMapped } from './types';
+declare type CollectCurriedParams<TOriginal extends Func, TCurried, TCollect extends any[] = []> = TOriginal extends TCurried ? TCollect : CollectCurriedParams<Curried1<TOriginal>, TCurried, [...TCollect, Param1<Parameters<TOriginal>>]>;
+export declare class Binder<T, TItem, TDep> {
+    protected key: string;
+    protected keyTransformer: (keyName: string) => string;
+    constructor(key: string, keyTransformer: (keyName: string) => string);
+    /** Gets the underlying container binding to the specified key */
+    get binding(): import("inversify/dts/interfaces/interfaces").interfaces.BindingToSyntax<TItem>;
+    /** Register a function */
+    function(item: TItem): import("inversify/dts/interfaces/interfaces").interfaces.BindingWhenOnSyntax<TItem>;
+    /** Register a function resolver */
+    functionResolver(item: IFunctionResolver<TItem>): import("inversify/dts/interfaces/interfaces").interfaces.BindingWhenOnSyntax<TItem>;
+    /** Register a constant */
+    constant(item: TItem): import("inversify/dts/interfaces/interfaces").interfaces.BindingWhenOnSyntax<TItem>;
+    /** Register a curried function */
+    functionCurry<TFn extends Func>(item: TFn, params: TupleToKeysOfMapped<CollectCurriedParams<TFn, TItem>, T & TDep>): import("inversify/dts/interfaces/interfaces").interfaces.BindingWhenOnSyntax<TItem>;
+    /** Register a class */
+    class<C extends NewableOf<TItem>>(cls: C, params: TupleToKeysOfMapped<ConstructorParameters<C>, T & TDep>): import("./inversify").BindingInWhenOnSyntax<InstanceType<C>>;
+}
+export {};

package/lib/binder.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Binder = void 0;
+var tslib_1 = require("tslib");
+var curry_1 = require("./curry");
+var inversify_1 = require("./inversify");
+var internalContainer = (0, inversify_1.getGlobalContainer)();
+var Binder = /** @class */ (function () {
+    function Binder(key, keyTransformer) {
+        this.key = key;
+        this.keyTransformer = keyTransformer;
+    }
+    Object.defineProperty(Binder.prototype, "binding", {
+        /** Gets the underlying container binding to the specified key */
+        get: function () {
+            return internalContainer.bind(this.key);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /** Register a function */
+    Binder.prototype.function = function (item) {
+        return this.binding.toFunction(item);
+    };
+    /** Register a function resolver */
+    Binder.prototype.functionResolver = function (item) {
+        return this.binding.toFactory(function () { return item.resolved(); });
+    };
+    /** Register a constant */
+    Binder.prototype.constant = function (item) {
+        return this.binding.toConstantValue(item);
+    };
+    /** Register a curried function */
+    Binder.prototype.functionCurry = function (item, params) {
+        var keys = params;
+        return this.functionResolver(curry_1.curryInner.apply(void 0, tslib_1.__spreadArray([item], keys.map(this.keyTransformer), false)));
+    };
+    /** Register a class */
+    Binder.prototype.class = function (cls, params) {
+        var keys = params;
+        return (0, inversify_1.registerClass)(this.key, cls, keys.map(this.keyTransformer));
+    };
+    return Binder;
+}());
+exports.Binder = Binder;

package/lib/curry.d.ts

@@ -0,0 +1,2 @@
+import { Func, IFunctionResolver } from './tail.generated';
+export declare function curryInner<TFn extends Func>(fn: TFn, ...keys: PropertyKey[]): IFunctionResolver<any>;

package/lib/curry.generated.d.ts

@@ -1,83 +1,143 @@
+/** Returns a mapped type that removes the first element from the type array */
 export declare type Tail1<T extends any[]> = ((...t: T) => any) extends (_1: any, ...tail: infer TTail) => any ? TTail : [
 ];
+/** Returns a mapped type that removes the first 2 elements from the type array */
 export declare type Tail2<T extends any[]> = ((...t: T) => any) extends (_1: any, _2: any, ...tail: infer TTail) => any ? TTail : [
 ];
+/** Returns a mapped type that removes the first 3 elements from the type array */
 export declare type Tail3<T extends any[]> = ((...t: T) => any) extends (_1: any, _2: any, _3: any, ...tail: infer TTail) => any ? TTail : [
 ];
+/** Returns a mapped type that removes the first 4 elements from the type array */
 export declare type Tail4<T extends any[]> = ((...t: T) => any) extends (_1: any, _2: any, _3: any, _4: any, ...tail: infer TTail) => any ? TTail : [
 ];
+/** Returns a mapped type that removes the first 5 elements from the type array */
 export declare type Tail5<T extends any[]> = ((...t: T) => any) extends (_1: any, _2: any, _3: any, _4: any, _5: any, ...tail: infer TTail) => any ? TTail : [
 ];
+/** Returns a mapped type that removes the first 6 elements from the type array */
 export declare type Tail6<T extends any[]> = ((...t: T) => any) extends (_1: any, _2: any, _3: any, _4: any, _5: any, _6: any, ...tail: infer TTail) => any ? TTail : [
 ];
+/** Returns a mapped type that removes the first 7 elements from the type array */
 export declare type Tail7<T extends any[]> = ((...t: T) => any) extends (_1: any, _2: any, _3: any, _4: any, _5: any, _6: any, _7: any, ...tail: infer TTail) => any ? TTail : [
 ];
+/** Returns a mapped type that removes the first 8 elements from the type array */
 export declare type Tail8<T extends any[]> = ((...t: T) => any) extends (_1: any, _2: any, _3: any, _4: any, _5: any, _6: any, _7: any, _8: any, ...tail: infer TTail) => any ? TTail : [
 ];
+/** Returns a mapped type that removes the first 9 elements from the type array */
 export declare type Tail9<T extends any[]> = ((...t: T) => any) extends (_1: any, _2: any, _3: any, _4: any, _5: any, _6: any, _7: any, _8: any, _9: any, ...tail: infer TTail) => any ? TTail : [
 ];
+/** Returns a mapped type that removes the first 10 elements from the type array */
 export declare type Tail10<T extends any[]> = ((...t: T) => any) extends (_1: any, _2: any, _3: any, _4: any, _5: any, _6: any, _7: any, _8: any, _9: any, _10: any, ...tail: infer TTail) => any ? TTail : [
 ];
+/** Returns a mapped type that removes the first 11 elements from the type array */
 export declare type Tail11<T extends any[]> = ((...t: T) => any) extends (_1: any, _2: any, _3: any, _4: any, _5: any, _6: any, _7: any, _8: any, _9: any, _10: any, _11: any, ...tail: infer TTail) => any ? TTail : [
 ];
+/** Returns a mapped type that removes the first 12 elements from the type array */
 export declare type Tail12<T extends any[]> = ((...t: T) => any) extends (_1: any, _2: any, _3: any, _4: any, _5: any, _6: any, _7: any, _8: any, _9: any, _10: any, _11: any, _12: any, ...tail: infer TTail) => any ? TTail : [
 ];
+/** Returns a mapped type that removes the first 13 elements from the type array */
 export declare type Tail13<T extends any[]> = ((...t: T) => any) extends (_1: any, _2: any, _3: any, _4: any, _5: any, _6: any, _7: any, _8: any, _9: any, _10: any, _11: any, _12: any, _13: any, ...tail: infer TTail) => any ? TTail : [
 ];
+/** Returns a mapped type that removes the first 14 elements from the type array */
 export declare type Tail14<T extends any[]> = ((...t: T) => any) extends (_1: any, _2: any, _3: any, _4: any, _5: any, _6: any, _7: any, _8: any, _9: any, _10: any, _11: any, _12: any, _13: any, _14: any, ...tail: infer TTail) => any ? TTail : [
 ];
+/** Returns a mapped type that removes the first 15 elements from the type array */
 export declare type Tail15<T extends any[]> = ((...t: T) => any) extends (_1: any, _2: any, _3: any, _4: any, _5: any, _6: any, _7: any, _8: any, _9: any, _10: any, _11: any, _12: any, _13: any, _14: any, _15: any, ...tail: infer TTail) => any ? TTail : [
 ];
+/** Returns a mapped type that removes the first 16 elements from the type array */
 export declare type Tail16<T extends any[]> = ((...t: T) => any) extends (_1: any, _2: any, _3: any, _4: any, _5: any, _6: any, _7: any, _8: any, _9: any, _10: any, _11: any, _12: any, _13: any, _14: any, _15: any, _16: any, ...tail: infer TTail) => any ? TTail : [
 ];
+/** Returns a mapped type that removes the first 17 elements from the type array */
 export declare type Tail17<T extends any[]> = ((...t: T) => any) extends (_1: any, _2: any, _3: any, _4: any, _5: any, _6: any, _7: any, _8: any, _9: any, _10: any, _11: any, _12: any, _13: any, _14: any, _15: any, _16: any, _17: any, ...tail: infer TTail) => any ? TTail : [
 ];
+/** Returns a mapped type that removes the first 18 elements from the type array */
 export declare type Tail18<T extends any[]> = ((...t: T) => any) extends (_1: any, _2: any, _3: any, _4: any, _5: any, _6: any, _7: any, _8: any, _9: any, _10: any, _11: any, _12: any, _13: any, _14: any, _15: any, _16: any, _17: any, _18: any, ...tail: infer TTail) => any ? TTail : [
 ];
+/** Returns a mapped type that removes the first 19 elements from the type array */
 export declare type Tail19<T extends any[]> = ((...t: T) => any) extends (_1: any, _2: any, _3: any, _4: any, _5: any, _6: any, _7: any, _8: any, _9: any, _10: any, _11: any, _12: any, _13: any, _14: any, _15: any, _16: any, _17: any, _18: any, _19: any, ...tail: infer TTail) => any ? TTail : [
 ];
+/** Returns a mapped type that removes the first 20 elements from the type array */
 export declare type Tail20<T extends any[]> = ((...t: T) => any) extends (_1: any, _2: any, _3: any, _4: any, _5: any, _6: any, _7: any, _8: any, _9: any, _10: any, _11: any, _12: any, _13: any, _14: any, _15: any, _16: any, _17: any, _18: any, _19: any, _20: any, ...tail: infer TTail) => any ? TTail : [
 ];
+/** Returns a mapped type of the function that removes the first parameter from the method */
 export declare type Curried1<T extends (...args: any[]) => any> = (...tail: Tail1<Parameters<T>>) => ReturnType<T>;
+/** Returns a mapped type of the function that removes the first 2 parameters from the method */
 export declare type Curried2<T extends (...args: any[]) => any> = (...tail: Tail2<Parameters<T>>) => ReturnType<T>;
+/** Returns a mapped type of the function that removes the first 3 parameters from the method */
 export declare type Curried3<T extends (...args: any[]) => any> = (...tail: Tail3<Parameters<T>>) => ReturnType<T>;
+/** Returns a mapped type of the function that removes the first 4 parameters from the method */
 export declare type Curried4<T extends (...args: any[]) => any> = (...tail: Tail4<Parameters<T>>) => ReturnType<T>;
+/** Returns a mapped type of the function that removes the first 5 parameters from the method */
 export declare type Curried5<T extends (...args: any[]) => any> = (...tail: Tail5<Parameters<T>>) => ReturnType<T>;
+/** Returns a mapped type of the function that removes the first 6 parameters from the method */
 export declare type Curried6<T extends (...args: any[]) => any> = (...tail: Tail6<Parameters<T>>) => ReturnType<T>;
+/** Returns a mapped type of the function that removes the first 7 parameters from the method */
 export declare type Curried7<T extends (...args: any[]) => any> = (...tail: Tail7<Parameters<T>>) => ReturnType<T>;
+/** Returns a mapped type of the function that removes the first 8 parameters from the method */
 export declare type Curried8<T extends (...args: any[]) => any> = (...tail: Tail8<Parameters<T>>) => ReturnType<T>;
+/** Returns a mapped type of the function that removes the first 9 parameters from the method */
 export declare type Curried9<T extends (...args: any[]) => any> = (...tail: Tail9<Parameters<T>>) => ReturnType<T>;
+/** Returns a mapped type of the function that removes the first 10 parameters from the method */
 export declare type Curried10<T extends (...args: any[]) => any> = (...tail: Tail10<Parameters<T>>) => ReturnType<T>;
+/** Returns a mapped type of the function that removes the first 11 parameters from the method */
 export declare type Curried11<T extends (...args: any[]) => any> = (...tail: Tail11<Parameters<T>>) => ReturnType<T>;
+/** Returns a mapped type of the function that removes the first 12 parameters from the method */
 export declare type Curried12<T extends (...args: any[]) => any> = (...tail: Tail12<Parameters<T>>) => ReturnType<T>;
+/** Returns a mapped type of the function that removes the first 13 parameters from the method */
 export declare type Curried13<T extends (...args: any[]) => any> = (...tail: Tail13<Parameters<T>>) => ReturnType<T>;
+/** Returns a mapped type of the function that removes the first 14 parameters from the method */
 export declare type Curried14<T extends (...args: any[]) => any> = (...tail: Tail14<Parameters<T>>) => ReturnType<T>;
+/** Returns a mapped type of the function that removes the first 15 parameters from the method */
 export declare type Curried15<T extends (...args: any[]) => any> = (...tail: Tail15<Parameters<T>>) => ReturnType<T>;
+/** Returns a mapped type of the function that removes the first 16 parameters from the method */
 export declare type Curried16<T extends (...args: any[]) => any> = (...tail: Tail16<Parameters<T>>) => ReturnType<T>;
+/** Returns a mapped type of the function that removes the first 17 parameters from the method */
 export declare type Curried17<T extends (...args: any[]) => any> = (...tail: Tail17<Parameters<T>>) => ReturnType<T>;
+/** Returns a mapped type of the function that removes the first 18 parameters from the method */
 export declare type Curried18<T extends (...args: any[]) => any> = (...tail: Tail18<Parameters<T>>) => ReturnType<T>;
+/** Returns a mapped type of the function that removes the first 19 parameters from the method */
 export declare type Curried19<T extends (...args: any[]) => any> = (...tail: Tail19<Parameters<T>>) => ReturnType<T>;
+/** Returns a mapped type of the function that removes the first 20 parameters from the method */
 export declare type Curried20<T extends (...args: any[]) => any> = (...tail: Tail20<Parameters<T>>) => ReturnType<T>;
+/** Returns the type in position 1 of the type array */
 export declare type Param1<T extends any[]> = T extends [
     any,
     ...any[]
 ] ? T[0] : never;
+/** Returns the type in position 2 of the type array */
 export declare type Param2<T extends any[]> = Param1<Tail1<T>>;
+/** Returns the type in position 3 of the type array */
 export declare type Param3<T extends any[]> = Param1<Tail2<T>>;
+/** Returns the type in position 4 of the type array */
 export declare type Param4<T extends any[]> = Param1<Tail3<T>>;
+/** Returns the type in position 5 of the type array */
 export declare type Param5<T extends any[]> = Param1<Tail4<T>>;
+/** Returns the type in position 6 of the type array */
 export declare type Param6<T extends any[]> = Param1<Tail5<T>>;
+/** Returns the type in position 7 of the type array */
 export declare type Param7<T extends any[]> = Param1<Tail6<T>>;
+/** Returns the type in position 8 of the type array */
 export declare type Param8<T extends any[]> = Param1<Tail7<T>>;
+/** Returns the type in position 9 of the type array */
 export declare type Param9<T extends any[]> = Param1<Tail8<T>>;
+/** Returns the type in position 10 of the type array */
 export declare type Param10<T extends any[]> = Param1<Tail9<T>>;
+/** Returns the type in position 11 of the type array */
 export declare type Param11<T extends any[]> = Param1<Tail10<T>>;
+/** Returns the type in position 12 of the type array */
 export declare type Param12<T extends any[]> = Param1<Tail11<T>>;
+/** Returns the type in position 13 of the type array */
 export declare type Param13<T extends any[]> = Param1<Tail12<T>>;
+/** Returns the type in position 14 of the type array */
 export declare type Param14<T extends any[]> = Param1<Tail13<T>>;
+/** Returns the type in position 15 of the type array */
 export declare type Param15<T extends any[]> = Param1<Tail14<T>>;
+/** Returns the type in position 16 of the type array */
 export declare type Param16<T extends any[]> = Param1<Tail15<T>>;
+/** Returns the type in position 17 of the type array */
 export declare type Param17<T extends any[]> = Param1<Tail16<T>>;
+/** Returns the type in position 18 of the type array */
 export declare type Param18<T extends any[]> = Param1<Tail17<T>>;
+/** Returns the type in position 19 of the type array */
 export declare type Param19<T extends any[]> = Param1<Tail18<T>>;
+/** Returns the type in position 20 of the type array */
 export declare type Param20<T extends any[]> = Param1<Tail19<T>>;

package/lib/curry.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.curryInner = void 0;
+var tslib_1 = require("tslib");
+var inversify_1 = require("./inversify");
+var internalContainer = (0, inversify_1.getGlobalContainer)();
+function curryInner(fn) {
+    var keys = [];
+    for (var _i = 1; _i < arguments.length; _i++) {
+        keys[_i - 1] = arguments[_i];
+    }
+    var curried;
+    return {
+        resolved: function () {
+            if (!curried) {
+                var values_1 = keys.map(function (k) { return internalContainer.get(k); });
+                curried = function () {
+                    var p = [];
+                    for (var _i = 0; _i < arguments.length; _i++) {
+                        p[_i] = arguments[_i];
+                    }
+                    return fn.apply(fn, tslib_1.__spreadArray(tslib_1.__spreadArray([], values_1, true), p, true));
+                };
+            }
+            return curried;
+        },
+    };
+}
+exports.curryInner = curryInner;

package/lib/error.d.ts

@@ -0,0 +1,4 @@
+export declare class IocDuplicateKeyError extends Error {
+    duplicateKeys: string[];
+    constructor(duplicateKeys: string[]);
+}

package/lib/error.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IocDuplicateKeyError = void 0;
+var tslib_1 = require("tslib");
+var IocDuplicateKeyError = /** @class */ (function (_super) {
+    tslib_1.__extends(IocDuplicateKeyError, _super);
+    function IocDuplicateKeyError(duplicateKeys) {
+        var _newTarget = this.constructor;
+        var _this = _super.call(this) || this;
+        _this.duplicateKeys = duplicateKeys;
+        Object.setPrototypeOf(_this, _newTarget.prototype);
+        _this.message = "Duplicate keys found\n".concat(duplicateKeys.join("\n"));
+        if (Error.captureStackTrace !== undefined) {
+            Error.captureStackTrace(_this, _this.constructor);
+        }
+        return _this;
+    }
+    return IocDuplicateKeyError;
+}(Error));
+exports.IocDuplicateKeyError = IocDuplicateKeyError;