nano-injector 1.0.3 → 1.0.5

package/lib/Provider.js

@@ -1,59 +1,60 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getProviderName = exports.getProviderID = exports.isProvider = exports.createProvider = void 0;
-const InjectorsStack_1 = require("./InjectorsStack");
-/**
- * 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(defValue) {
-        const hasDefaultValue = arguments.length > 0;
-        const { activeInjector } = InjectorsStack_1.InjectorsStack;
-        if (hasDefaultValue) {
-            return activeInjector.tryGetValue(provider, defValue);
-        }
-        return activeInjector.getValue(provider);
-    }
-    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;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createProvider = createProvider;
+exports.isProvider = isProvider;
+exports.getProviderID = getProviderID;
+exports.getProviderName = getProviderName;
+const InjectorsStack_1 = require("./InjectorsStack");
+/**
+ * Symbol used to store the unique 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 a new provider for a specific value type.
+ * @param name name for this provider used mainly for debugging purposes
+ */
+function createProvider(name) {
+    function callback(defValue) {
+        const hasDefaultValue = arguments.length > 0;
+        const { activeInjector } = InjectorsStack_1.InjectorsStack;
+        if (hasDefaultValue) {
+            return activeInjector.tryGetValue(provider, defValue);
+        }
+        return activeInjector.getValue(provider);
+    }
+    const provider = Object.assign(callback, {
+        [NAME_SYMBOL]: name,
+        [ID_SYMBOL]: PROVIDER_ID++,
+    });
+    return provider;
+}
+/**
+ * Determines whether the given 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';
+}
+/**
+ * Returns the unique ID of the specified provider.
+ * @param provider
+ */
+function getProviderID(provider) {
+    return provider[ID_SYMBOL];
+}
+/**
+ * Returns the name of the specified provider
+ * @param provider
+ */
+function getProviderName(provider) {
+    return provider[NAME_SYMBOL];
+}

package/lib/index.js

@@ -1,14 +1,18 @@
-"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);
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (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);

package/package.json

@@ -1,57 +1,52 @@
-{
-  "name": "nano-injector",
-  "version": "1.0.3",
-  "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"
-  }
-}
+{
+  "name": "nano-injector",
+  "version": "1.0.5",
+  "description": "Miniature dependency injection library for TypeScript and JavaScript",
+  "keywords": [
+    "typescript",
+    "dependency injection",
+    "di",
+    "ioc",
+    "inversion of control"
+  ],
+  "homepage": "https://github.com/protoukr/nano-injector",
+  "bugs": {
+    "url": "https://github.com/protoukr/nano-injector/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/protoukr/nano-injector"
+  },
+  "license": "MIT",
+  "author": "Roman Pukhalskyi",
+  "main": "./lib/index.js",
+  "types": "./typings/index.d.ts",
+  "files": [
+    "lib",
+    "typings"
+  ],
+  "scripts": {
+    "prebuild": "npm run clean",
+    "build": "tsc",
+    "clean": "rimraf typings docs lib",
+    "docs": "typedoc src/index.ts",
+    "example": "npx ts-node ./examples/index.ts",
+    "format:check": "prettier --check .",
+    "format:fix": "prettier --write .",
+    "prepublishOnly": "npm run verify",
+    "test": "jest",
+    "verify": "npm run format:check && npm test && npm run build"
+  },
+  "devDependencies": {
+    "@types/jest": "^30.0.0",
+    "@types/node": "^24.10.9",
+    "jest": "^30.2.0",
+    "prettier": "^3.8.1",
+    "prettier-plugin-packagejson": "^3.0.0",
+    "rimraf": "^3.0.2",
+    "ts-jest": "^29.4.6",
+    "ts-node": "^10.9.2",
+    "typedoc": "^0.28.16",
+    "typescript": "^5.9.3"
+  }
+}

package/typings/Binder.d.ts

@@ -1,47 +1,44 @@
-import { Injector } from './Injector';
-export declare class NoCreationMethodSpecifiedError extends Error {
-    constructor();
-}
-/**
- * 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;
-}
+import { Injector } from './Injector';
+export declare class NoCreationMethodSpecifiedError extends Error {
+    constructor();
+}
+/**
+ * A class that defines how to create a value for this binder.
+ */
+export declare class Binder<T> {
+    private readonly injector;
+    private value;
+    private ctor;
+    private factory;
+    private isSingleton;
+    constructor(injector: Injector);
+    /**
+     * Creates a new value (if needed) using the defined creation method, and returns it.
+     */
+    getValue(): T;
+    /**
+     * Sets a specific value for this binder.
+     * @param value
+     */
+    toValue(value: T): Binder<T>;
+    /**
+     * Use a class constructor to create the value. Previous creation methods are cleared.
+     * @param ctor
+     */
+    toConstructor(ctor: new () => T): Binder<T>;
+    /**
+     * Use a factory function to create the value. Previous creation methods are cleared.
+     * @param factory
+     */
+    toFactory(factory: (injector: Injector) => T): Binder<T>;
+    /**
+     * Configures whether the value should be a singleton. If true, the value is created once and reused for all subsequent requests.
+     * @param value
+     */
+    asSingleton(value?: boolean): Binder<T>;
+    /**
+     * Creates the value using the configured creation method.
+     * @private
+     */
+    private createValue;
+}

package/typings/Injector.d.ts

@@ -1,96 +1,93 @@
-import { Binder } from './Binder';
-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
- */
-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>(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>(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
-     * default value is returned
-     * @param provider
-     */
-    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 tryGetBinderRecursively;
-    /**
-     * 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 {};
+import { Binder } from './Binder';
+import { Provider, ProviderValueType } from './Provider';
+/**
+ * Error thrown when a 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>);
+}
+type UnionToIntersection<T> = (T extends any ? (k: T) => void : never) extends (k: infer R) => void ? R : never;
+/**
+ * The provider to which every injector binds itself.
+ */
+export declare const $Injector: Provider<Injector>;
+/**
+ * The central entity of the library. It holds provider bindings and resolves dependencies.
+ */
+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 (useful for debugging).
+     * @param params.parent Parent injector for composing injectors.
+     * @param params.logger Custom logger function.
+     */
+    constructor(params?: {
+        name?: string;
+        parent?: Injector;
+        logger?: (msg: string) => unknown;
+    });
+    /**
+     * Creates a new binder and links it to the specified providers.
+     * If a provider is already bound, the binding is overridden.
+     * @param providers The providers to bind.
+     */
+    bindProvider<ProviderT extends Array<Provider<unknown>>, ValueT extends UnionToIntersection<ProviderT extends Array<Provider<infer R>> ? R : never>>(...providers: ProviderT): Binder<ValueT>;
+    /**
+     * Resolves specific providers to their values and assigns them to the instance's properties.
+     * @param instance
+     * @param providers
+     */
+    injectValues<T extends object, K extends keyof T>(instance: T, providers: Record<K, Provider<T[K]>>): void;
+    /**
+     * Activates the injector and creates a new instance of the given class using the provided arguments.
+     * @param type
+     * @param args
+     */
+    createInstance<ClassT extends new (...args: any[]) => unknown>(type: ClassT, ...args: ConstructorParameters<ClassT>): InstanceType<ClassT>;
+    /**
+     * Activates the injector and calls the given function with the provided arguments.
+     * @param func function which should be called
+     * @param args args which should be passed to the called function
+     */
+    callFunc<FuncT extends (...args: any[]) => unknown>(func: FuncT, ...args: Parameters<FuncT>): ReturnType<FuncT>;
+    /**
+     * Returns the value bound to the specified provider. Throws an exception if the value is not found.
+     * @param provider
+     */
+    getValue<ProviderT extends Provider<unknown>>(provider: ProviderT): ProviderValueType<ProviderT>;
+    /**
+     * Returns the value bound to the specified provider, or the default value if the bound value is not found.
+     * @param provider
+     */
+    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;
+    /**
+     * Recursively looks up the binder for the specified provider, traversing up to the root injector.
+     * @param provider
+     * @private
+     */
+    private tryGetBinderRecursively;
+    /**
+     * Checks for circular dependencies and throws an error if one is detected.
+     * @param provider
+     * @private
+     */
+    private checkCircularDependency;
+    /**
+     * Temporarily activates this injector to execute the provided function and return its result.
+     * @param func
+     * @private
+     */
+    private activateAndCall;
+}
+export {};

package/typings/InjectorsStack.d.ts

@@ -1,16 +1,16 @@
-import { Injector } from './Injector';
-export declare class NoActiveInjectorError extends Error {
-    constructor();
-}
-/**
- * Private class for holding current active injector
- */
-declare class _InjectorsStack {
-    private readonly injectors;
-    private _activeInjector?;
-    get activeInjector(): Injector;
-    push(injector: Injector): void;
-    pop(): void;
-}
-export declare const InjectorsStack: _InjectorsStack;
-export {};
+import { Injector } from './Injector';
+export declare class NoActiveInjectorError extends Error {
+    constructor();
+}
+/**
+ * Private class to manage the stack of active injectors.
+ */
+declare class _InjectorsStack {
+    private readonly injectors;
+    private _activeInjector?;
+    get activeInjector(): Injector;
+    push(injector: Injector): void;
+    pop(): void;
+}
+export declare const InjectorsStack: _InjectorsStack;
+export {};