nano-injector 1.0.1 → 1.0.4

package/LICENSE

@@ -1,21 +1,21 @@
-MIT License
-
-Copyright (c) 2021 Roman Pukhalskyi
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+MIT License
+
+Copyright (c) 2021 Roman Pukhalskyi
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,221 +1,221 @@
-# Nano-injector
-
-Miniature dependency injection library for TypeScript and JavaScript.
-
-# Motivation
-
-There is a myriad of dependency injection libraries in typescript ecosystem. Most of them are built around decorators.
-Decorators are an obvious solution for such kinds of tasks. But in terms of dependency injection, they have its
-drawbacks - they are not type safe, which means that theoretically, it is possible to bind any value to the required type,
-and they don't work well with interfaces and primitives, therefore some workaround solutions are required to overcome
-this limitation.
-Typically, injecting of an interface, using these libraries, looks like as follows:
-```typescript
-// binding value
-injector.bind('IStorage').toValue(new DefStorage())
-
-// injecting it
-@Inject('IStorage')
-private storage: IStorage
-```
-where string IStorage should be passed to Inject decorator in order to let the injector know which value should be injected
-to the required property. Since it is just a string, any string can be passed, therefore any type can be injected,
-and the compiler won't warn you about that. Also, there is type duplication, therefore the whole usage looks a bit ugly.
-
-**Nano-injector** is addressing these issues, by doing dependency injection in a little bit different way - instead of using
-decorators, it uses plain functions as dependencies providers. By doing so, the same workflow, using Nano-injector,
-looks as follows:
-
-```typescript
-// defining provider
-const $IStorage = createProvider<IStorage>()
-
-// binding it to the value
-injector.bindProvider($IStorage).toValue(new DefStorage())
-
-// injecting it
-private storage = $IStorage()
-```
-Here _**$IStorage**_ is the provider, which basically is a plain function, and which should be bound to desired value through
-injector. Type of storage property compiler infers automatically, which reduces unneeded code duplication. Also, you can bind only
-value of the type specified during provider creation, if not to do so, the compiler will warn you about that.
-
-Also, unlike other libraries, Nano-injector is very small, with a very concise API.
-More usage details you can find below, and in the example directory.
-
-# Features
-
-- Very simple
-- Ultra lightweight
-- Zero dependencies
-- No decorators
-- Type safe
-- Injectable interfaces and primitives
-
-# Installation
-```bash
-npm i nano-injector
-```
-# Usage
-Importing dependencies:
-```typescript
-import { Injector, createProvider } from 'nano-injector'
-```
-Defining types and providers:
-```typescript
-// to distinguish providers from any other entities $ sign is used
-const $Clock = createProvider<(cb: () => void, time: number) => number>()
-const $ClockRate = createProvider<number>()
-
-const $CPU = createProvider<CPU>()
-interface CPU {
-  readonly model: string
-  readonly numCores: number
-  readonly frequency: number
-}
-
-const $GPU = createProvider<GPU>()
-interface GPU {
-  readonly model: string
-  readonly numRayTracingCores: number
-  readonly memorySize: number
-}
-
-const $RAM = createProvider<RAM>()
-interface RAM {
-  readonly capacity: number
-}
-
-const $Motherboard = createProvider<Motherboard>()
-interface Motherboard {
-  readonly cpu: CPU
-  readonly gpu: GPU
-  readonly ram: RAM
-}
-
-class GeForce911 implements GPU {
-  model = 'GeForce911'
-  numRayTracingCores = 100
-  memorySize = 2048
-}
-
-class DefMotherboard implements Motherboard {
-  constructor(
-    readonly model: string,
-    public cpu = $CPU(),
-    public gpu = $GPU(),
-    public ram = $RAM()
-  ) {}
-}
-
-class PC {
-  constructor(private name: string, private motherboard = $Motherboard()) {}
-}
-```
-Defining injector through which injection occurs:
-```typescript
-const injector = new Injector()
-```
-Binding providers:
-```typescript
-// binding $CPU provider to exact value
-injector.bindProvider($CPU).toValue({ numCores: 4, model: 't7', frequency: 2000 })
-
-// binding $GPU provider to class which conforms to provider's returning type
-// calling asSingleton specifies that value should be created only once
-injector.bindProvider($GPU).toConstructor(GeForce911).asSingleton()
-
-// binding $RAM provider to the factory which creates value conforming to
-// provider's returning type
-injector.bindProvider($RAM).toFactory(() => ({
-  capacity: Math.floor(Math.random() * 1024),
-}))
-
-injector
-  .bindProvider($Motherboard)
-  .toFactory(
-    () =>
-      // only one required parameter is passed, the rest are initialized
-      // automatically through providers
-      new DefMotherboard('Asus ABC-123')
-  )
-  .asSingleton()
-
-// without ignoring compiler would tell you about wrong value's type
-// @ts-expect-error
-injector.bindProvider($ClockRate).toValue('asd')
-
-injector.bindProvider($ClockRate).toValue(1000)
-
-injector.bindProvider($Clock).toValue(setTimeout)
-```
-Creating instances with all dependencies injected:
-```typescript
-// the first parameter of PC constructor is required, so it is passed into the
-// construction method
-injector.createInstance(PC, 'My pc')
-```
-Directly getting the bound to the providers values:
-```typescript
-injector.getValue($CPU)
-injector.getValue($GPU)
-injector.getValue($RAM)
-
-injector.getValue($Clock)(() => console.log('Tick!'), 1000)
-```
-Manually creating instance with all its dependencies:
-```typescript
-new DefMotherboard(
-  'Asus xyz',
-  { frequency: 123, model: 'Intel xyz', numCores: 1 },
-  { model: '', memorySize: 0, numRayTracingCores: 1 },
-  { capacity: 123 },
-)
-```
-Calling function through injector:
-```typescript
-injector.callFunc(() => {
-  // inside function all providers return bound to them values
-  console.log('Inside function')
-  console.log('CPU:', $CPU())
-  console.log('GPU:', $GPU())
-  console.log('RAM:', $RAM())
-})
-```
-It's also possible to bind few providers to the same value. The bound value should conform to
-intersection of all providers' types:
-```typescript
-injector.bindProvider($RAM, $CPU, $GPU).toValue({
-  capacity: 10,
-  frequency: 100,
-  memorySize: 200,
-  model: 'ATB-21',
-  numCores: 2,
-  numRayTracingCores: 60,
-})
-```
-Creating composition of injectors:
-```typescript
-const childInjector = new Injector({ parent: injector })
-```
-Overriding $CPU binding of parent injector inside child injector:
-```typescript
-childInjector.bindProvider($CPU).toValue({ numCores: 1, model: 'z2', frequency: 999 })
-```
-Injecting value to the existing instance:
-```typescript
-const newMotherboard = new class {
-  gpu: GPU
-  cpu: CPU
-}
-injector.injectValues(newMotherboard, { cpu: $CPU, gpu: $GPU })
-```
-# [Docs](https://protoukr.github.io/nano-injector/)
-
-# Contributing
-Pull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.
-
-Please make sure to update tests as appropriate.
-
-## License
-[MIT](https://choosealicense.com/licenses/mit/)
+# Nano-injector
+
+Miniature dependency injection library for TypeScript and JavaScript.
+
+# Motivation
+
+There is a myriad of dependency injection libraries in typescript ecosystem. Most of them are built around decorators.
+Decorators are an obvious solution for such kinds of tasks. But in terms of dependency injection, they have its
+drawbacks - they are not type safe, which means that theoretically, it is possible to bind any value to the required type,
+and they don't work well with interfaces and primitives, therefore some workaround solutions are required to overcome
+this limitation.
+Typically, injecting of an interface, using these libraries, looks like as follows:
+```typescript
+// binding value
+injector.bind('IStorage').toValue(new DefStorage())
+
+// injecting it
+@Inject('IStorage')
+private storage: IStorage
+```
+where string IStorage should be passed to Inject decorator in order to let the injector know which value should be injected
+to the required property. Since it is just a string, any string can be passed, therefore any type can be injected,
+and the compiler won't warn you about that. Also, there is type duplication, therefore the whole usage looks a bit ugly.
+
+**Nano-injector** is addressing these issues, by doing dependency injection in a little bit different way - instead of using
+decorators, it uses plain functions as dependencies providers. By doing so, the same workflow, using Nano-injector,
+looks as follows:
+
+```typescript
+// defining provider
+const $IStorage = createProvider<IStorage>()
+
+// binding it to the value
+injector.bindProvider($IStorage).toValue(new DefStorage())
+
+// injecting it
+private storage = $IStorage()
+```
+Here _**$IStorage**_ is the provider, which basically is a plain function, and which should be bound to desired value through
+injector. Type of storage property compiler infers automatically, which reduces unneeded code duplication. Also, you can bind only
+value of the type specified during provider creation, if not to do so, the compiler will warn you about that.
+
+Also, unlike other libraries, Nano-injector is very small, with a very concise API.
+More usage details you can find below, and in the example directory.
+
+# Features
+
+- Very simple
+- Ultra lightweight
+- Zero dependencies
+- No decorators
+- Type safe
+- Injectable interfaces and primitives
+
+# Installation
+```bash
+npm i nano-injector
+```
+# Usage
+Importing dependencies:
+```typescript
+import { Injector, createProvider } from 'nano-injector'
+```
+Defining types and providers:
+```typescript
+// to distinguish providers from any other entities $ sign is used
+const $Clock = createProvider<(cb: () => void, time: number) => number>()
+const $ClockRate = createProvider<number>()
+
+const $CPU = createProvider<CPU>()
+interface CPU {
+  readonly model: string
+  readonly numCores: number
+  readonly frequency: number
+}
+
+const $GPU = createProvider<GPU>()
+interface GPU {
+  readonly model: string
+  readonly numRayTracingCores: number
+  readonly memorySize: number
+}
+
+const $RAM = createProvider<RAM>()
+interface RAM {
+  readonly capacity: number
+}
+
+const $Motherboard = createProvider<Motherboard>()
+interface Motherboard {
+  readonly cpu: CPU
+  readonly gpu: GPU
+  readonly ram: RAM
+}
+
+class GeForce911 implements GPU {
+  model = 'GeForce911'
+  numRayTracingCores = 100
+  memorySize = 2048
+}
+
+class DefMotherboard implements Motherboard {
+  constructor(
+    readonly model: string,
+    public cpu = $CPU(),
+    public gpu = $GPU(),
+    public ram = $RAM()
+  ) {}
+}
+
+class PC {
+  constructor(private name: string, private motherboard = $Motherboard()) {}
+}
+```
+Defining injector through which injection occurs:
+```typescript
+const injector = new Injector()
+```
+Binding providers:
+```typescript
+// binding $CPU provider to exact value
+injector.bindProvider($CPU).toValue({ numCores: 4, model: 't7', frequency: 2000 })
+
+// binding $GPU provider to class which conforms to provider's returning type
+// calling asSingleton specifies that value should be created only once
+injector.bindProvider($GPU).toConstructor(GeForce911).asSingleton()
+
+// binding $RAM provider to the factory which creates value conforming to
+// provider's returning type
+injector.bindProvider($RAM).toFactory(() => ({
+  capacity: Math.floor(Math.random() * 1024),
+}))
+
+injector
+  .bindProvider($Motherboard)
+  .toFactory(
+    () =>
+      // only one required parameter is passed, the rest are initialized
+      // automatically through providers
+      new DefMotherboard('Asus ABC-123')
+  )
+  .asSingleton()
+
+// without ignoring compiler would tell you about wrong value's type
+// @ts-expect-error
+injector.bindProvider($ClockRate).toValue('asd')
+
+injector.bindProvider($ClockRate).toValue(1000)
+
+injector.bindProvider($Clock).toValue(setTimeout)
+```
+Creating instances with all dependencies injected:
+```typescript
+// the first parameter of PC constructor is required, so it is passed into the
+// construction method
+injector.createInstance(PC, 'My pc')
+```
+Directly getting the bound to the providers values:
+```typescript
+injector.getValue($CPU)
+injector.getValue($GPU)
+injector.getValue($RAM)
+
+injector.getValue($Clock)(() => console.log('Tick!'), 1000)
+```
+Manually creating instance with all its dependencies:
+```typescript
+new DefMotherboard(
+  'Asus xyz',
+  { frequency: 123, model: 'Intel xyz', numCores: 1 },
+  { model: '', memorySize: 0, numRayTracingCores: 1 },
+  { capacity: 123 },
+)
+```
+Calling function through injector:
+```typescript
+injector.callFunc(() => {
+  // inside function all providers return bound to them values
+  console.log('Inside function')
+  console.log('CPU:', $CPU())
+  console.log('GPU:', $GPU())
+  console.log('RAM:', $RAM())
+})
+```
+It's also possible to bind few providers to the same value. The bound value should conform to
+intersection of all providers' types:
+```typescript
+injector.bindProvider($RAM, $CPU, $GPU).toValue({
+  capacity: 10,
+  frequency: 100,
+  memorySize: 200,
+  model: 'ATB-21',
+  numCores: 2,
+  numRayTracingCores: 60,
+})
+```
+Creating composition of injectors:
+```typescript
+const childInjector = new Injector({ parent: injector })
+```
+Overriding $CPU binding of parent injector inside child injector:
+```typescript
+childInjector.bindProvider($CPU).toValue({ numCores: 1, model: 'z2', frequency: 999 })
+```
+Injecting value to the existing instance:
+```typescript
+const newMotherboard = new class {
+  gpu: GPU
+  cpu: CPU
+}
+injector.injectValues(newMotherboard, { cpu: $CPU, gpu: $GPU })
+```
+# [Docs](https://protoukr.github.io/nano-injector/)
+
+# Contributing
+Pull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.
+
+Please make sure to update tests as appropriate.
+
+## License
+[MIT](https://choosealicense.com/licenses/mit/)

package/lib/Binder.js

@@ -1,7 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Binder = void 0;
-const InjectingError_1 = require("./InjectingError");
+exports.Binder = exports.NoCreationMethodSpecifiedError = void 0;
+class NoCreationMethodSpecifiedError extends Error {
+    constructor() {
+        super('No creation method specified');
+    }
+}
+exports.NoCreationMethodSpecifiedError = NoCreationMethodSpecifiedError;
 /**
  * Class through which is defined how to create value for this binder
  */
@@ -75,7 +80,7 @@ class Binder {
         if (this.factory != null) {
             return this.factory(this.injector);
         }
-        throw new InjectingError_1.InjectingError('Creation method isn\'t specified');
+        throw new NoCreationMethodSpecifiedError();
     }
 }
 exports.Binder = Binder;

package/lib/Injector.js

@@ -1,10 +1,28 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Injector = exports.$Injector = void 0;
+exports.Injector = exports.$Injector = exports.NoBinderError = exports.CircularDependencyError = void 0;
 const Binder_1 = require("./Binder");
 const Provider_1 = require("./Provider");
 const InjectorsStack_1 = require("./InjectorsStack");
-const InjectingError_1 = require("./InjectingError");
+/**
+ * Thrown when circular dependency is detected
+ */
+class CircularDependencyError extends Error {
+    constructor(providers) {
+        const providerNames = providers.map(Provider_1.getProviderName)
+            .map((name) => name !== null && name !== void 0 ? name : '?');
+        super(`Circular dependency detected: ${providerNames.join('->')}`);
+    }
+}
+exports.CircularDependencyError = CircularDependencyError;
+class NoBinderError extends Error {
+    constructor(provider) {
+        var _a;
+        const providerName = (_a = (0, Provider_1.getProviderName)(provider)) !== null && _a !== void 0 ? _a : 'unknown';
+        super(`Value of ${providerName} provider is not found`);
+    }
+}
+exports.NoBinderError = NoBinderError;
 /**
  * Provider which every injector binds itself to
  */
@@ -70,31 +88,49 @@ class Injector {
     }
     /**
      * Returns bound to the specified provider value. If the value is not found
-     * undefined is returned
+     * exception is thrown
      * @param provider
      */
     getValue(provider) {
         const binder = this.getBinder(provider);
-        if (binder == null) {
-            return undefined;
+        this.pushResolvingProvider(provider);
+        const value = this.activateAndCall(() => binder.getValue());
+        this.popResolvingProvder();
+        return value;
+    }
+    tryGetValue(provider, defValue) {
+        try {
+            return this.getValue(provider);
+        }
+        catch (err) {
+            if (err instanceof NoBinderError) {
+                return defValue;
+            }
+            throw err;
         }
+    }
+    pushResolvingProvider(provider) {
         this.checkCircularDependency(provider);
         this.resolvingProviders.push(provider);
-        const value = this.activateAndCall(() => binder.getValue());
+    }
+    popResolvingProvder() {
         this.resolvingProviders.pop();
-        return value;
+    }
+    getBinder(provider) {
+        const binder = this.tryGetBinderRecursively(provider);
+        if (binder == null) {
+            throw new NoBinderError(provider);
+        }
+        return binder;
     }
     /**
      * Finds binder for the specified provider recursively up to the root injector
      * @param provider
      * @private
      */
-    getBinder(provider) {
-        const binder = this.binders.get(provider);
-        if (binder == null && this.parent != null) {
-            return this.parent.getBinder(provider);
-        }
-        return binder;
+    tryGetBinderRecursively(provider) {
+        var _a, _b;
+        return ((_a = this.binders.get(provider)) !== null && _a !== void 0 ? _a : (_b = this.parent) === null || _b === void 0 ? void 0 : _b.tryGetBinderRecursively(provider));
     }
     /**
      * Checks is there circular dependency and throws error if so
@@ -103,13 +139,10 @@ class Injector {
      */
     checkCircularDependency(provider) {
         const i = this.resolvingProviders.indexOf(provider);
-        if (i === -1) {
-            return;
+        if (i !== -1) {
+            const providers = [...this.resolvingProviders.slice(i), provider];
+            throw new CircularDependencyError(providers);
         }
-        const providers = [...this.resolvingProviders.slice(i), provider]
-            .map(Provider_1.getProviderName)
-            .map((name) => name !== null && name !== void 0 ? name : '?');
-        throw new InjectingError_1.InjectingError(`Circular dependency detected: ${providers.join('->')}`);
     }
     /**
      * Temporary activates this injector calls provided function and returns its value

package/lib/InjectorsStack.js

@@ -1,6 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.InjectorsStack = void 0;
+exports.InjectorsStack = exports.NoActiveInjectorError = void 0;
+class NoActiveInjectorError extends Error {
+    constructor() {
+        super('No active injector found');
+    }
+}
+exports.NoActiveInjectorError = NoActiveInjectorError;
 /**
  * Private class for holding current active injector
  */
@@ -8,18 +14,20 @@ class _InjectorsStack {
     constructor() {
         this.injectors = [];
     }
-    get(provider) {
-        var _a;
-        return (_a = this.activeInjector) === null || _a === void 0 ? void 0 : _a.getValue(provider);
+    get activeInjector() {
+        if (this._activeInjector == null) {
+            throw new NoActiveInjectorError();
+        }
+        return this._activeInjector;
     }
     push(injector) {
-        if (this.activeInjector != null) {
-            this.injectors.push(this.activeInjector);
+        if (this._activeInjector != null) {
+            this.injectors.push(this._activeInjector);
         }
-        this.activeInjector = injector;
+        this._activeInjector = injector;
     }
     pop() {
-        this.activeInjector = this.injectors.pop();
+        this._activeInjector = this.injectors.pop();
     }
 }
 exports.InjectorsStack = new _InjectorsStack();

package/lib/Provider.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getProviderName = exports.getProviderID = exports.isProvider = exports.createProvider = void 0;
 const InjectorsStack_1 = require("./InjectorsStack");
-const InjectingError_1 = require("./InjectingError");
 /**
  * Symbol used for storing the id of a provider
  */
@@ -17,15 +16,13 @@ let PROVIDER_ID = 0;
  * @param name name for this provider used mainly for debugging purposes
  */
 function createProvider(name) {
-    function provider(...args) {
-        const value = InjectorsStack_1.InjectorsStack.get(provider);
-        if (value !== undefined) {
-            return value;
+    function provider(defValue) {
+        const hasDefaultValue = arguments.length > 0;
+        const { activeInjector } = InjectorsStack_1.InjectorsStack;
+        if (hasDefaultValue) {
+            return activeInjector.tryGetValue(provider, defValue);
         }
-        if (args.length !== 0) {
-            return args[0];
-        }
-        throw new InjectingError_1.InjectingError(`Value of ${name !== null && name !== void 0 ? name : 'unknown'} provider is not found`);
+        return activeInjector.getValue(provider);
     }
     provider[NAME_SYMBOL] = name;
     provider[ID_SYMBOL] = PROVIDER_ID++;

package/lib/index.js

@@ -12,4 +12,3 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./Injector"), exports);
 __exportStar(require("./Provider"), exports);
-__exportStar(require("./InjectingError"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nano-injector",
-  "version": "1.0.1",
+  "version": "1.0.4",
   "description": "Miniature dependency injection library for TypeScript and JavaScript",
   "main": "./lib/index.js",
   "types": "./typings/index.d.ts",

package/typings/Binder.d.ts

@@ -1,4 +1,7 @@
 import { Injector } from './Injector';
+export declare class NoCreationMethodSpecifiedError extends Error {
+    constructor();
+}
 /**
  * Class through which is defined how to create value for this binder
  */
@@ -29,7 +32,7 @@ export declare class Binder<T> {
      * will be ignored
      * @param factory
      */
-    toFactory(factory: (injector?: Injector) => T): Binder<T>;
+    toFactory(factory: (injector: Injector) => T): Binder<T>;
     /**
      * Defines whether value should be a singleton. If yes the value will be created only once
      * and the same instance will be returned forever

package/typings/Injector.d.ts

@@ -1,5 +1,14 @@
 import { Binder } from './Binder';
-import { Provider } from './Provider';
+import { Provider, ProviderValueType } from './Provider';
+/**
+ * Thrown when circular dependency is detected
+ */
+export declare class CircularDependencyError extends Error {
+    constructor(providers: Array<Provider<unknown>>);
+}
+export declare class NoBinderError extends Error {
+    constructor(provider: Provider<unknown>);
+}
 declare type UnionToIntersection<T> = (T extends any ? (k: T) => void : never) extends (k: infer R) => void ? R : never;
 /**
  * Provider which every injector binds itself to
@@ -42,25 +51,35 @@ export declare class Injector {
      * @param type
      * @param args
      */
-    createInstance<ClassT extends new (...args: unknown[]) => unknown, CtorParamsT extends ConstructorParameters<ClassT>, InstT extends InstanceType<ClassT>>(type: ClassT, ...args: CtorParamsT): InstT;
+    createInstance<ClassT extends new (...args: any[]) => unknown>(type: ClassT, ...args: ConstructorParameters<ClassT>): InstanceType<ClassT>;
     /**
      * Activates this injector and calls the function with provided arguments
      * @param func function which should be called
      * @param args args which should be passed to the called function
      */
-    callFunc<FuncT extends (...args: unknown[]) => unknown, ParamsT extends Parameters<FuncT>, ReturnT extends ReturnType<FuncT>>(func: FuncT, ...args: ParamsT): ReturnT;
+    callFunc<FuncT extends (...args: any[]) => unknown>(func: FuncT, ...args: Parameters<FuncT>): ReturnType<FuncT>;
+    /**
+     * Returns bound to the specified provider value. If the value is not found
+     * exception is thrown
+     * @param provider
+     */
+    getValue<ProviderT extends Provider<unknown>>(provider: ProviderT): ProviderValueType<ProviderT>;
     /**
      * Returns bound to the specified provider value. If the value is not found
-     * undefined is returned
+     * default value is returned
      * @param provider
      */
-    getValue<ProviderT extends Provider<unknown>, ValueT extends ProviderT extends Provider<infer R> ? R : never>(provider: ProviderT): ValueT | undefined;
+    tryGetValue<ProviderT extends Provider<unknown>>(provider: ProviderT): ProviderValueType<ProviderT> | undefined;
+    tryGetValue<ProviderT extends Provider<unknown>, DefValT>(provider: ProviderT, defVal: DefValT): ProviderValueType<ProviderT> | DefValT;
+    private pushResolvingProvider;
+    private popResolvingProvder;
+    private getBinder;
     /**
      * Finds binder for the specified provider recursively up to the root injector
      * @param provider
      * @private
      */
-    private getBinder;
+    private tryGetBinderRecursively;
     /**
      * Checks is there circular dependency and throws error if so
      * @param provider

package/typings/InjectorsStack.d.ts

@@ -1,12 +1,14 @@
 import { Injector } from './Injector';
-import { Provider } from './Provider';
+export declare class NoActiveInjectorError extends Error {
+    constructor();
+}
 /**
  * Private class for holding current active injector
  */
 declare class _InjectorsStack {
     private readonly injectors;
-    private activeInjector;
-    get<ProviderT extends Provider<unknown>, ValueT extends ProviderT extends Provider<infer R> ? R : never>(provider: ProviderT): ValueT | undefined;
+    private _activeInjector?;
+    get activeInjector(): Injector;
     push(injector: Injector): void;
     pop(): void;
 }

package/typings/Provider.d.ts

@@ -1,3 +1,4 @@
+export declare type ProviderValueType<T extends Provider<any>> = T extends Provider<infer R> ? R : never;
 /**
  * Symbol used for storing the id of a provider
  */
@@ -45,5 +46,5 @@ export declare function getProviderID(provider: Provider<unknown>): number;
  * Returns the name of the specified provider
  * @param provider
  */
-export declare function getProviderName(provider: Provider<unknown>): string;
+export declare function getProviderName(provider: Provider<unknown>): string | undefined;
 export {};

package/typings/index.d.ts

@@ -1,3 +1,2 @@
 export * from './Injector';
 export * from './Provider';
-export * from './InjectingError';

package/lib/InjectingError.js

@@ -1,9 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.InjectingError = void 0;
-/**
- * Just an error class, an instance of which is fired in some cases
- */
-class InjectingError extends Error {
-}
-exports.InjectingError = InjectingError;

package/typings/InjectingError.d.ts

@@ -1,5 +0,0 @@
-/**
- * Just an error class, an instance of which is fired in some cases
- */
-export declare class InjectingError extends Error {
-}