@mediaclip/dependency-injection - npm Package Compare versions

Comparing version 1.0.0 to 1.0.1

dist/index.d.ts

		@@ -22,3 +22,2 @@ type Prettify<T> = T extends infer U ? {
		createScope(): IScopedDiContainer;
		[Symbol.dispose](): void;
		private saveScopeInstances;
		@@ -29,3 +28,3 @@ }
		type TypedInstanceFactory<T> = (container: IDiContainer) => T;
		interface IDiContainer extends Disposable {
		interface IDiContainer {
		registerSingleton<T>(token: DiToken<T>, valueOrFactory: TypedInstanceFactory<T> \| T): void;
		@@ -58,3 +57,2 @@ registerScoped<T>(token: DiToken<T>, factory: TypedInstanceFactory<T>): void;
		createScope(): IScopedDiContainer;
		[Symbol.dispose](): void;
		protected tryResolveFrom<T>(token: DiToken<T>, registrations: Map<symbol, Array<T>>): T \| undefined;
		@@ -66,4 +64,3 @@ protected tryResolveFromFactory<T>(token: DiToken<T>, registrations: Map<symbol, Array<InstanceFactory>>): T \| undefined;
		declare function isFunction<T>(valueOrFactory: T \| ((container: IDiContainer) => T)): valueOrFactory is (container: IDiContainer) => T;
		declare function disposeIfDisposable(instance: any): void;

		export { DiContainer, type DiContainerOption, DiToken, type IDiContainer, type IScopedDiContainer, type Prettify, ScopedDiContainer, disposeIfDisposable, isFunction };
		export { DiContainer, type DiContainerOption, DiToken, type IDiContainer, type IScopedDiContainer, type Prettify, ScopedDiContainer, isFunction };

dist/index.js

		@@ -5,9 +5,2 @@ // src/utils.ts
		}
		function disposeIfDisposable(instance) {
		if (typeof instance === "object" \|\| typeof instance === "function") {
		if (typeof instance[Symbol.dispose] === "function") {
		instance[Symbol.dispose]();
		}
		}
		}

		@@ -52,8 +45,2 @@ // src/scoped-di-container.ts
		}
		[Symbol.dispose]() {
		for (const instance of Object.values(this.scopedInstances)) {
		disposeIfDisposable(instance);
		}
		super[Symbol.dispose]();
		}
		saveScopeInstances(token, value) {
		@@ -143,7 +130,2 @@ let scopedInstances = this.scopedInstances.get(token.symbol);
		}
		[Symbol.dispose]() {
		for (const instance of Object.values(this.singletonInstances)) {
		disposeIfDisposable(instance);
		}
		}
		tryResolveFrom(token, registrations) {
		@@ -200,5 +182,4 @@ const registeredElements = registrations.get(token.symbol);
		ScopedDiContainer,
		disposeIfDisposable,
		isFunction
		};
		//# sourceMappingURL=index.js.map

package.json

		@@ -7,3 +7,3 @@ {
		"name": "@mediaclip/dependency-injection",
		"version": "1.0.0",
		"version": "1.0.1",
		"main": "./dist/index.js",
		@@ -10,0 +10,0 @@ "keywords": [

README.md

		@@ -5,2 +5,47 @@ # Dependency injection

		It supports Singleton and Scoped registrations and guarantee at compile time that everything as been registered.

		## Example

		Simple example with singletons only. You need to create a token to register a service in the container, and then you can use this token to resolve the service.
		You can register a service with it's instance directly or with a factory.
		The first parameter of the factory is the `IDiContainer` so you can use this to resolve other services if you have a service depending on naother one.

		```ts
		import {DiContainer, DiToken} from "@mediaclip/dependency-injection";

		interface IService1 {}
		class Service1 implements IService1 {}
		interface IService2 {}
		class Service2 implements IService2 {}
		interface IService3 {}
		class Service3 implements IService3 {
		constructor(
		private readonly service1: IService1,
		private readonly service2: IService2
		) {
		}
		}

		let tokenService1 = DiToken.create<IService1>('Service1')
		let tokenService2 = DiToken.create<IService2>('Service2')
		let tokenService3 = DiToken.create<IService3>('Service3')

		let container = new DiContainer();
		container.registerSingleton(tokenService1, new Service1());
		container.registerSingleton(tokenService2, new Service2());
		container.registerSingleton(tokenService3, c => new Service3(
		c.resolve(tokenService1),
		c.resolve(tokenService2)
		));

		const service3 = container.resolve(tokenService3)
		```

		## Scoped vs Singleton

		When registering a service on the container you can either register it as `singleton` or as `scoped`.
		A singleton service will only be instantiated once, and a scoped service will have one instance of each scope.
		A scope is created by calling `container.createScope()`

tsconfig.tsbuildinfo

.idea/http-pipeline.iml