nano-injector 1.0.1

package/LICENSE

@@ -0,0 +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.

package/README.md

@@ -0,0 +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/)

package/lib/Binder.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Binder = void 0;
+const InjectingError_1 = require("./InjectingError");
+/**
+ * Class through which is defined how to create value for this binder
+ */
+class Binder {
+    constructor(injector) {
+        this.injector = injector;
+    }
+    /**
+     * Creates the new value if needed through previously defined method, and returns it
+     */
+    getValue() {
+        if (this.value !== undefined) {
+            return this.value;
+        }
+        if (this.isSingleton) {
+            this.value = this.createValue();
+            return this.value;
+        }
+        return this.createValue();
+    }
+    /**
+     * Directly defines value for this binder
+     * @param value
+     */
+    toValue(value) {
+        this.value = value;
+        this.factory = undefined;
+        this.ctor = undefined;
+        return this;
+    }
+    /**
+     * Defines constructor as a method for creating value. All previously defined methods
+     * will be ignored
+     * @param ctor
+     */
+    toConstructor(ctor) {
+        this.ctor = ctor;
+        this.factory = undefined;
+        this.value = undefined;
+        return this;
+    }
+    /**
+     * Defines factory as a method for creating value. All previously defined methods
+     * will be ignored
+     * @param factory
+     */
+    toFactory(factory) {
+        this.factory = factory;
+        this.ctor = undefined;
+        this.value = undefined;
+        return this;
+    }
+    /**
+     * Defines whether value should be a singleton. If yes the value will be created only once
+     * and the same instance will be returned forever
+     * @param value
+     */
+    asSingleton(value = true) {
+        this.isSingleton = value;
+        return this;
+    }
+    /**
+     * Creates value through previously defined method
+     * @private
+     */
+    createValue() {
+        if (this.ctor != null) {
+            // eslint-disable-next-line new-cap
+            return new this.ctor();
+        }
+        if (this.factory != null) {
+            return this.factory(this.injector);
+        }
+        throw new InjectingError_1.InjectingError('Creation method isn\'t specified');
+    }
+}
+exports.Binder = Binder;

package/lib/InjectingError.js

@@ -0,0 +1,9 @@
+"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/lib/Injector.js

@@ -0,0 +1,126 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Injector = exports.$Injector = void 0;
+const Binder_1 = require("./Binder");
+const Provider_1 = require("./Provider");
+const InjectorsStack_1 = require("./InjectorsStack");
+const InjectingError_1 = require("./InjectingError");
+/**
+ * Provider which every injector binds itself to
+ */
+exports.$Injector = (0, Provider_1.createProvider)();
+/**
+ * Main entity in the library, which holds provider's bindings and through which
+ * dependencies are resolved
+ */
+class Injector {
+    /**
+     * @param params.name name of the injector which can be useful mainly for debugging purposes
+     * @param params.parent parent injector for the composition of injectors
+     * @param params.logger specific log function if the custom output is required
+     */
+    constructor(params = {}) {
+        this.binders = new Map();
+        this.resolvingProviders = [];
+        const { name, parent, logger = console.warn } = params;
+        this.name = name;
+        this.parent = parent;
+        this.logger = logger;
+        this.bindProvider(exports.$Injector).toValue(this);
+    }
+    /**
+     * Creates new binder and joins it to the specified providers. If the provider
+     * is already bound, then overriding occurs
+     * @param providers providers which the binder should be joined to
+     */
+    bindProvider(...providers) {
+        const binder = new Binder_1.Binder(this);
+        providers.forEach((provider) => this.binders.set(provider, binder));
+        return binder;
+    }
+    /**
+     * Resolves all providers to their values and assigns them to the specified instance
+     * @param instance
+     * @param providers
+     */
+    injectValues(instance, providers) {
+        Object.entries(providers)
+            .filter(([, value]) => (0, Provider_1.isProvider)(value))
+            .forEach(([name, provider]) => {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+            instance[name] = this.getValue(provider);
+        });
+    }
+    /**
+     * Activates this injector and creates new instance of the type with the provided arguments
+     * @param type
+     * @param args
+     */
+    createInstance(type, ...args) {
+        // eslint-disable-next-line new-cap
+        return this.activateAndCall(() => new type(...args));
+    }
+    /**
+     * 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(func, ...args) {
+        return this.activateAndCall(() => func(...args));
+    }
+    /**
+     * Returns bound to the specified provider value. If the value is not found
+     * undefined is returned
+     * @param provider
+     */
+    getValue(provider) {
+        const binder = this.getBinder(provider);
+        if (binder == null) {
+            return undefined;
+        }
+        this.checkCircularDependency(provider);
+        this.resolvingProviders.push(provider);
+        const value = this.activateAndCall(() => binder.getValue());
+        this.resolvingProviders.pop();
+        return value;
+    }
+    /**
+     * 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;
+    }
+    /**
+     * Checks is there circular dependency and throws error if so
+     * @param provider
+     * @private
+     */
+    checkCircularDependency(provider) {
+        const i = this.resolvingProviders.indexOf(provider);
+        if (i === -1) {
+            return;
+        }
+        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
+     * @param func
+     * @private
+     */
+    activateAndCall(func) {
+        InjectorsStack_1.InjectorsStack.push(this);
+        const value = func();
+        InjectorsStack_1.InjectorsStack.pop();
+        return value;
+    }
+}
+exports.Injector = Injector;

package/lib/InjectorsStack.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InjectorsStack = void 0;
+/**
+ * Private class for holding current active injector
+ */
+class _InjectorsStack {
+    constructor() {
+        this.injectors = [];
+    }
+    get(provider) {
+        var _a;
+        return (_a = this.activeInjector) === null || _a === void 0 ? void 0 : _a.getValue(provider);
+    }
+    push(injector) {
+        if (this.activeInjector != null) {
+            this.injectors.push(this.activeInjector);
+        }
+        this.activeInjector = injector;
+    }
+    pop() {
+        this.activeInjector = this.injectors.pop();
+    }
+}
+exports.InjectorsStack = new _InjectorsStack();

package/lib/Provider.js

@@ -0,0 +1,62 @@
+"use strict";
+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
+ */
+const ID_SYMBOL = Symbol('id');
+/**
+ * Symbol used for storing the name of a provider
+ */
+const NAME_SYMBOL = Symbol('name');
+let PROVIDER_ID = 0;
+/**
+ * Creates the new provider for some value with a specific type
+ * @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;
+        }
+        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`);
+    }
+    provider[NAME_SYMBOL] = name;
+    provider[ID_SYMBOL] = PROVIDER_ID++;
+    return provider;
+}
+exports.createProvider = createProvider;
+/**
+ * Determines whether the received value is a provider
+ * @param value value which should be tested
+ */
+function isProvider(value) {
+    if (typeof value !== 'function') {
+        return false;
+    }
+    const provider = value;
+    return typeof provider[ID_SYMBOL] !== 'undefined';
+}
+exports.isProvider = isProvider;
+/**
+ * Returns the id of the specified provider
+ * @param provider
+ */
+function getProviderID(provider) {
+    return provider[ID_SYMBOL];
+}
+exports.getProviderID = getProviderID;
+/**
+ * Returns the name of the specified provider
+ * @param provider
+ */
+function getProviderName(provider) {
+    return provider[NAME_SYMBOL];
+}
+exports.getProviderName = getProviderName;

package/lib/index.js

@@ -0,0 +1,15 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./Injector"), exports);
+__exportStar(require("./Provider"), exports);
+__exportStar(require("./InjectingError"), exports);

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "nano-injector",
+  "version": "1.0.1",
+  "description": "Miniature dependency injection library for TypeScript and JavaScript",
+  "main": "./lib/index.js",
+  "types": "./typings/index.d.ts",
+  "scripts": {
+    "clear": "rimraf typings docs lib",
+    "prepublishOnly": "npm run clear && npm test && npm run build",
+    "precommit": "npm run clear && npm run lint  && npm test && npm run build && npm run docs",
+    "lint": "ts-standard",
+    "lintfix": "ts-standard --fix",
+    "build": "tsc",
+    "docs": "typedoc src/index.ts",
+    "test": "ts-mocha -p ./tsconfig.json ./test/*.test.ts"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/protoukr/nano-injector"
+  },
+  "files": [
+    "lib",
+    "typings"
+  ],
+  "keywords": [
+    "typescript",
+    "dependency injection",
+    "di",
+    "ioc",
+    "inversion of control"
+  ],
+  "author": "Roman Pukhalskyi",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/protoukr/nano-injector/issues"
+  },
+  "homepage": "https://github.com/protoukr/nano-injector",
+  "ts-standard": {
+    "ignore": [
+      "lib",
+      "docs",
+      "typings"
+    ]
+  },
+  "devDependencies": {
+    "@types/chai": "^4.2.22",
+    "@types/mocha": "^8.2.3",
+    "chai": "^4.3.4",
+    "mocha": "^8.4.0",
+    "rimraf": "^3.0.2",
+    "ts-mocha": "^8.0.0",
+    "ts-node": "^10.4.0",
+    "ts-standard": "^11.0.0",
+    "typedoc": "^0.22.10",
+    "typescript": "^4.4.3"
+  }
+}

package/typings/Binder.d.ts

@@ -0,0 +1,44 @@
+import { Injector } from './Injector';
+/**
+ * Class through which is defined how to create value for this binder
+ */
+export declare class Binder<T> {
+    private readonly injector;
+    private value;
+    private ctor;
+    private factory;
+    private isSingleton;
+    constructor(injector: Injector);
+    /**
+     * Creates the new value if needed through previously defined method, and returns it
+     */
+    getValue(): T;
+    /**
+     * Directly defines value for this binder
+     * @param value
+     */
+    toValue(value: T): Binder<T>;
+    /**
+     * Defines constructor as a method for creating value. All previously defined methods
+     * will be ignored
+     * @param ctor
+     */
+    toConstructor(ctor: new () => T): Binder<T>;
+    /**
+     * Defines factory as a method for creating value. All previously defined methods
+     * will be ignored
+     * @param factory
+     */
+    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
+     * @param value
+     */
+    asSingleton(value?: boolean): Binder<T>;
+    /**
+     * Creates value through previously defined method
+     * @private
+     */
+    private createValue;
+}

package/typings/InjectingError.d.ts

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

package/typings/Injector.d.ts

@@ -0,0 +1,77 @@
+import { Binder } from './Binder';
+import { Provider } from './Provider';
+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
+ */
+export declare const $Injector: Provider<Injector>;
+/**
+ * Main entity in the library, which holds provider's bindings and through which
+ * dependencies are resolved
+ */
+export declare class Injector {
+    private readonly binders;
+    private readonly resolvingProviders;
+    private readonly name;
+    private readonly parent;
+    private readonly logger;
+    /**
+     * @param params.name name of the injector which can be useful mainly for debugging purposes
+     * @param params.parent parent injector for the composition of injectors
+     * @param params.logger specific log function if the custom output is required
+     */
+    constructor(params?: {
+        name?: string;
+        parent?: Injector;
+        logger?: (msg: string) => unknown;
+    });
+    /**
+     * Creates new binder and joins it to the specified providers. If the provider
+     * is already bound, then overriding occurs
+     * @param providers providers which the binder should be joined to
+     */
+    bindProvider<ProviderT extends Array<Provider<unknown>>, ValueT extends UnionToIntersection<ProviderT extends Array<Provider<infer R>> ? R : never>>(...providers: ProviderT): Binder<ValueT>;
+    /**
+     * Resolves all providers to their values and assigns them to the specified instance
+     * @param instance
+     * @param providers
+     */
+    injectValues<T extends object, K extends keyof T>(instance: T, providers: Record<K, Provider<T[K]>>): void;
+    /**
+     * Activates this injector and creates new instance of the type with the provided arguments
+     * @param type
+     * @param args
+     */
+    createInstance<ClassT extends new (...args: unknown[]) => unknown, CtorParamsT extends ConstructorParameters<ClassT>, InstT extends InstanceType<ClassT>>(type: ClassT, ...args: CtorParamsT): InstT;
+    /**
+     * 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;
+    /**
+     * Returns bound to the specified provider value. If the value is not found
+     * undefined is returned
+     * @param provider
+     */
+    getValue<ProviderT extends Provider<unknown>, ValueT extends ProviderT extends Provider<infer R> ? R : never>(provider: ProviderT): ValueT | undefined;
+    /**
+     * Finds binder for the specified provider recursively up to the root injector
+     * @param provider
+     * @private
+     */
+    private getBinder;
+    /**
+     * Checks is there circular dependency and throws error if so
+     * @param provider
+     * @private
+     */
+    private checkCircularDependency;
+    /**
+     * Temporary activates this injector calls provided function and returns its value
+     * @param func
+     * @private
+     */
+    private activateAndCall;
+}
+export {};

package/typings/InjectorsStack.d.ts

@@ -0,0 +1,14 @@
+import { Injector } from './Injector';
+import { Provider } from './Provider';
+/**
+ * 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;
+    push(injector: Injector): void;
+    pop(): void;
+}
+export declare const InjectorsStack: _InjectorsStack;
+export {};

package/typings/Provider.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Symbol used for storing the id of a provider
+ */
+declare const ID_SYMBOL: unique symbol;
+/**
+ * Symbol used for storing the name of a provider
+ */
+declare const NAME_SYMBOL: unique symbol;
+/**
+ * Provider is a second main concept in the library. Basically just it is just a function
+ * through which binding with the specific value occurs.
+ */
+export interface Provider<T> {
+    readonly [ID_SYMBOL]: number;
+    readonly [NAME_SYMBOL]: string;
+    /**
+     * Returns bound to this provider value. Throws the exception if it's not found.
+     * If throwing the exception is not desired any value to the provider should
+     * be passed
+     */
+    (): T;
+    /**
+     * Returns bound to this provider value. Returns default one if the bound value
+     * is not found
+     * @param defValue
+     */
+    <DefValT>(defValue: DefValT): T | DefValT;
+}
+/**
+ * Creates the new provider for some value with a specific type
+ * @param name name for this provider used mainly for debugging purposes
+ */
+export declare function createProvider<T>(name?: string): Provider<T>;
+/**
+ * Determines whether the received value is a provider
+ * @param value value which should be tested
+ */
+export declare function isProvider<T = unknown>(value: unknown): value is Provider<T>;
+/**
+ * Returns the id of the specified provider
+ * @param provider
+ */
+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 {};

package/typings/index.d.ts

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