@nmtjs/core 0.6.4 → 0.7.0

package/dist/utils/pool.js

@@ -0,0 +1,90 @@
+export class PoolError extends Error {}
+export class Pool {
+	#items = [];
+	#free = [];
+	#queue = [];
+	#current = 0;
+	#size = 0;
+	#available = 0;
+	constructor(options = {}) {
+		this.options = options;
+	}
+	add(item) {
+		if (this.#items.includes(item)) throw new PoolError("Item already exists");
+		this.#size++;
+		this.#available++;
+		this.#items.push(item);
+		this.#free.push(true);
+	}
+	remove(item) {
+		if (this.#size === 0) throw new PoolError("Pool is empty");
+		const index = this.#items.indexOf(item);
+		if (index < 0) throw new PoolError("Item is not in the pool");
+		const isCaptured = this.isFree(item);
+		if (isCaptured) this.#available--;
+		this.#size--;
+		this.#current--;
+		this.#items.splice(index, 1);
+		this.#free.splice(index, 1);
+	}
+	capture(timeout = this.options.timeout) {
+		return this.next(true, timeout);
+	}
+	async next(exclusive = false, timeout = this.options.timeout) {
+		if (this.#size === 0) throw new PoolError("Pool is empty");
+		if (this.#available === 0) {
+			return new Promise((resolve, reject) => {
+				const waiting = {
+					resolve: (item) => {
+						if (exclusive) this.#capture(item);
+						resolve(item);
+					},
+					timer: undefined
+				};
+				if (timeout) {
+					waiting.timer = setTimeout(() => {
+						waiting.resolve = undefined;
+						this.#queue.shift();
+						reject(new PoolError("Next item timeout"));
+					}, timeout);
+				}
+				this.#queue.push(waiting);
+			});
+		}
+		let item = undefined;
+		let free = false;
+		do {
+			item = this.#items[this.#current];
+			free = this.#free[this.#current];
+			this.#current++;
+			if (this.#current >= this.#size) this.#current = 0;
+		} while (typeof item === "undefined" || !free);
+		if (exclusive) this.#capture(item);
+		return item;
+	}
+	release(item) {
+		const index = this.#items.indexOf(item);
+		if (index < 0) throw new PoolError("Unexpected item");
+		if (this.#free[index]) throw new PoolError("Unable to release not captured item");
+		this.#free[index] = true;
+		this.#available++;
+		if (this.#queue.length > 0) {
+			const { resolve, timer } = this.#queue.shift();
+			clearTimeout(timer);
+			if (resolve) setTimeout(resolve, 0, item);
+		}
+	}
+	isFree(item) {
+		const index = this.#items.indexOf(item);
+		if (index < 0) return false;
+		return this.#free[index];
+	}
+	get items() {
+		return [...this.#items];
+	}
+	#capture(item) {
+		const index = this.#items.indexOf(item);
+		this.#free[index] = false;
+		this.#available--;
+	}
+}

package/dist/utils/pool.js.map

@@ -0,0 +1 @@
+{"mappings":"AAWA,OAAO,MAAM,kBAAkB,MAAM,CAAE;AAGvC,OAAO,MAAM,KAAkB;CAC7B,SAAmB,CAAE;CACrB,QAAwB,CAAE;CAC1B,SAA0B,CAAE;CAC5B,WAAmB;CACnB,QAAgB;CAChB,aAAqB;CAErB,YAA6BA,UAAuB,CAAE,GAAE;OAA3B;CAA6B;CAE1D,IAAIC,MAAS;AACX,MAAI,KAAKC,OAAO,SAAS,KAAK,CAAE,OAAM,IAAI,UAAU;AACpD,OAAKC;AACL,OAAKC;AACL,OAAKF,OAAO,KAAK,KAAK;AACtB,OAAKG,MAAM,KAAK,KAAK;CACtB;CAED,OAAOJ,MAAS;AACd,MAAI,KAAKE,UAAU,EAAG,OAAM,IAAI,UAAU;EAC1C,MAAM,QAAQ,KAAKD,OAAO,QAAQ,KAAK;AACvC,MAAI,QAAQ,EAAG,OAAM,IAAI,UAAU;EACnC,MAAM,aAAa,KAAK,OAAO,KAAK;AACpC,MAAI,WAAY,MAAKE;AACrB,OAAKD;AACL,OAAKG;AACL,OAAKJ,OAAO,OAAO,OAAO,EAAE;AAC5B,OAAKG,MAAM,OAAO,OAAO,EAAE;CAC5B;CAED,QAAQ,UAAU,KAAK,QAAQ,SAAS;AACtC,SAAO,KAAK,KAAK,MAAM,QAAQ;CAChC;CAED,MAAM,KAAK,YAAY,OAAO,UAAU,KAAK,QAAQ,SAAqB;AACxE,MAAI,KAAKF,UAAU,EAAG,OAAM,IAAI,UAAU;AAC1C,MAAI,KAAKC,eAAe,GAAG;AACzB,UAAO,IAAI,QAAQ,CAAC,SAAS,WAAW;IACtC,MAAMG,UAAyB;KAC7B,SAAS,CAACN,SAAY;AACpB,UAAI,UAAW,MAAKO,SAAS,KAAK;AAClC,cAAQ,KAAK;KACd;KACD,OAAO;IACR;AACD,QAAI,SAAS;AACX,aAAQ,QAAQ,WAAW,MAAM;AAC/B,cAAQ,UAAU;AAClB,WAAKC,OAAO,OAAO;AACnB,aAAO,IAAI,UAAU,qBAAqB;KAC3C,GAAE,QAAQ;IACZ;AACD,SAAKA,OAAO,KAAK,QAAQ;GAC1B;EACF;EACD,IAAIC,OAAsB;EAC1B,IAAI,OAAO;AACX,KAAG;AACD,UAAO,KAAKR,OAAO,KAAKI;AACxB,UAAO,KAAKD,MAAM,KAAKC;AACvB,QAAKA;AACL,OAAI,KAAKA,YAAY,KAAKH,MAAO,MAAKG,WAAW;EAClD,gBAAe,SAAS,gBAAgB;AACzC,MAAI,UAAW,MAAKE,SAAS,KAAK;AAClC,SAAO;CACR;CAED,QAAQP,MAAS;EACf,MAAM,QAAQ,KAAKC,OAAO,QAAQ,KAAK;AACvC,MAAI,QAAQ,EAAG,OAAM,IAAI,UAAU;AACnC,MAAI,KAAKG,MAAM,OACb,OAAM,IAAI,UAAU;AACtB,OAAKA,MAAM,SAAS;AACpB,OAAKD;AACL,MAAI,KAAKK,OAAO,SAAS,GAAG;GAC1B,MAAM,EAAE,SAAS,OAAO,GAAG,KAAKA,OAAO,OAAO;AAC9C,gBAAa,MAAM;AACnB,OAAI,QAAS,YAAW,SAAS,GAAG,KAAK;EAC1C;CACF;CAED,OAAOR,MAAS;EACd,MAAM,QAAQ,KAAKC,OAAO,QAAQ,KAAK;AACvC,MAAI,QAAQ,EAAG,QAAO;AACtB,SAAO,KAAKG,MAAM;CACnB;CAED,IAAI,QAAQ;AACV,SAAO,CAAC,GAAG,KAAKH,MAAO;CACxB;CAED,SAASD,MAAS;EAChB,MAAM,QAAQ,KAAKC,OAAO,QAAQ,KAAK;AACvC,OAAKG,MAAM,SAAS;AACpB,OAAKD;CACN;AACF","names":["options: PoolOptions","item: T","#items","#size","#available","#free","#current","waiting: PoolQueueItem","#capture","#queue","item: T | undefined"],"sources":["src/utils/pool.ts"],"sourcesContent":["import type { Callback } from '../../../common/src/index.ts'\n\ninterface PoolOptions {\n  timeout?: number\n}\n\ninterface PoolQueueItem {\n  resolve?: Callback\n  timer?: ReturnType<typeof setTimeout>\n}\n\nexport class PoolError extends Error {}\n\n// Fixed pool from https://github.com/metarhia/metautil\nexport class Pool<T = unknown> {\n  #items: Array<T> = []\n  #free: Array<boolean> = []\n  #queue: PoolQueueItem[] = []\n  #current: number = 0\n  #size: number = 0\n  #available: number = 0\n\n  constructor(private readonly options: PoolOptions = {}) {}\n\n  add(item: T) {\n    if (this.#items.includes(item)) throw new PoolError('Item already exists')\n    this.#size++\n    this.#available++\n    this.#items.push(item)\n    this.#free.push(true)\n  }\n\n  remove(item: T) {\n    if (this.#size === 0) throw new PoolError('Pool is empty')\n    const index = this.#items.indexOf(item)\n    if (index < 0) throw new PoolError('Item is not in the pool')\n    const isCaptured = this.isFree(item)\n    if (isCaptured) this.#available--\n    this.#size--\n    this.#current--\n    this.#items.splice(index, 1)\n    this.#free.splice(index, 1)\n  }\n\n  capture(timeout = this.options.timeout) {\n    return this.next(true, timeout)\n  }\n\n  async next(exclusive = false, timeout = this.options.timeout): Promise<T> {\n    if (this.#size === 0) throw new PoolError('Pool is empty')\n    if (this.#available === 0) {\n      return new Promise((resolve, reject) => {\n        const waiting: PoolQueueItem = {\n          resolve: (item: T) => {\n            if (exclusive) this.#capture(item)\n            resolve(item)\n          },\n          timer: undefined,\n        }\n        if (timeout) {\n          waiting.timer = setTimeout(() => {\n            waiting.resolve = undefined\n            this.#queue.shift()\n            reject(new PoolError('Next item timeout'))\n          }, timeout)\n        }\n        this.#queue.push(waiting)\n      })\n    }\n    let item: T | undefined = undefined\n    let free = false\n    do {\n      item = this.#items[this.#current]\n      free = this.#free[this.#current]\n      this.#current++\n      if (this.#current >= this.#size) this.#current = 0\n    } while (typeof item === 'undefined' || !free)\n    if (exclusive) this.#capture(item)\n    return item\n  }\n\n  release(item: T) {\n    const index = this.#items.indexOf(item)\n    if (index < 0) throw new PoolError('Unexpected item')\n    if (this.#free[index])\n      throw new PoolError('Unable to release not captured item')\n    this.#free[index] = true\n    this.#available++\n    if (this.#queue.length > 0) {\n      const { resolve, timer } = this.#queue.shift()!\n      clearTimeout(timer)\n      if (resolve) setTimeout(resolve, 0, item)\n    }\n  }\n\n  isFree(item: T) {\n    const index = this.#items.indexOf(item)\n    if (index < 0) return false\n    return this.#free[index]\n  }\n\n  get items() {\n    return [...this.#items]\n  }\n\n  #capture(item: T) {\n    const index = this.#items.indexOf(item)\n    this.#free[index] = false\n    this.#available--\n  }\n}\n"],"version":3}

package/dist/utils/semaphore.js

@@ -0,0 +1,46 @@
+export class SemaphoreError extends Error {}
+export class Semaphore {
+	counter;
+	queue = [];
+	constructor(concurrency, size = 0, timeout = 0) {
+		this.size = size;
+		this.timeout = timeout;
+		this.counter = concurrency;
+	}
+	enter() {
+		if (this.counter > 0) {
+			this.counter--;
+			return Promise.resolve();
+		} else if (this.queue.length >= this.size) {
+			return Promise.reject(new SemaphoreError("Queue is full"));
+		} else {
+			return new Promise((resolve, reject) => {
+				const waiting = { resolve };
+				waiting.timer = setTimeout(() => {
+					waiting.resolve = undefined;
+					this.queue.shift();
+					reject(new SemaphoreError("Timeout"));
+				}, this.timeout);
+				this.queue.push(waiting);
+			});
+		}
+	}
+	leave() {
+		if (this.queue.length === 0) {
+			this.counter++;
+		} else {
+			const item = this.queue.shift();
+			if (item) {
+				const { resolve, timer } = item;
+				if (timer) clearTimeout(timer);
+				if (resolve) setTimeout(resolve, 0);
+			}
+		}
+	}
+	get isEmpty() {
+		return this.queue.length === 0;
+	}
+	get queueLength() {
+		return this.queue.length;
+	}
+}

package/dist/utils/semaphore.js.map

@@ -0,0 +1 @@
+{"mappings":"AAOA,OAAO,MAAM,uBAAuB,MAAM,CAAE;AAG5C,OAAO,MAAM,UAAU;CACrB,AAAQ;CAER,AAAiB,QAA8B,CAAE;CAEjD,YACEA,aACiBC,OAAe,GACfC,UAAkB,GACnC;OAFiB;OACA;AAEjB,OAAK,UAAU;CAChB;CAED,QAAuB;AACrB,MAAI,KAAK,UAAU,GAAG;AACpB,QAAK;AACL,UAAO,QAAQ,SAAS;EACzB,WAAU,KAAK,MAAM,UAAU,KAAK,MAAM;AACzC,UAAO,QAAQ,OAAO,IAAI,eAAe,iBAAiB;EAC3D,OAAM;AACL,UAAO,IAAI,QAAQ,CAAC,SAAS,WAAW;IACtC,MAAMC,UAA8B,EAAE,QAAS;AAC/C,YAAQ,QAAQ,WAAW,MAAM;AAC/B,aAAQ,UAAU;AAClB,UAAK,MAAM,OAAO;AAClB,YAAO,IAAI,eAAe,WAAW;IACtC,GAAE,KAAK,QAAQ;AAChB,SAAK,MAAM,KAAK,QAAQ;GACzB;EACF;CACF;CAED,QAAQ;AACN,MAAI,KAAK,MAAM,WAAW,GAAG;AAC3B,QAAK;EACN,OAAM;GACL,MAAM,OAAO,KAAK,MAAM,OAAO;AAC/B,OAAI,MAAM;IACR,MAAM,EAAE,SAAS,OAAO,GAAG;AAC3B,QAAI,MAAO,cAAa,MAAM;AAC9B,QAAI,QAAS,YAAW,SAAS,EAAE;GACpC;EACF;CACF;CAED,IAAI,UAAU;AACZ,SAAO,KAAK,MAAM,WAAW;CAC9B;CAED,IAAI,cAAc;AAChB,SAAO,KAAK,MAAM;CACnB;AACF","names":["concurrency: number","size: number","timeout: number","waiting: SemaphoreQueueItem"],"sources":["src/utils/semaphore.ts"],"sourcesContent":["import type { Callback } from '../../../common/src/index.ts'\n\ninterface SemaphoreQueueItem {\n  resolve?: Callback\n  timer?: ReturnType<typeof setTimeout>\n}\n\nexport class SemaphoreError extends Error {}\n\n// Semaphore from https://github.com/metarhia/metautil\nexport class Semaphore {\n  private counter: number\n\n  private readonly queue: SemaphoreQueueItem[] = []\n\n  constructor(\n    concurrency: number,\n    private readonly size: number = 0,\n    private readonly timeout: number = 0,\n  ) {\n    this.counter = concurrency\n  }\n\n  enter(): Promise<void> {\n    if (this.counter > 0) {\n      this.counter--\n      return Promise.resolve()\n    } else if (this.queue.length >= this.size) {\n      return Promise.reject(new SemaphoreError('Queue is full'))\n    } else {\n      return new Promise((resolve, reject) => {\n        const waiting: SemaphoreQueueItem = { resolve }\n        waiting.timer = setTimeout(() => {\n          waiting.resolve = undefined\n          this.queue.shift()\n          reject(new SemaphoreError('Timeout'))\n        }, this.timeout)\n        this.queue.push(waiting)\n      })\n    }\n  }\n\n  leave() {\n    if (this.queue.length === 0) {\n      this.counter++\n    } else {\n      const item = this.queue.shift()\n      if (item) {\n        const { resolve, timer } = item\n        if (timer) clearTimeout(timer)\n        if (resolve) setTimeout(resolve, 0)\n      }\n    }\n  }\n\n  get isEmpty() {\n    return this.queue.length === 0\n  }\n\n  get queueLength() {\n    return this.queue.length\n  }\n}\n"],"version":3}

package/package.json

@@ -3,30 +3,28 @@
   "type": "module",
   "exports": {
     ".": {
-      "bun": "./index.ts",
-      "default": "./dist/index.js",
-      "types": "./index.ts"
+      "types": "./src/index.ts",
+      "import": "./dist/index.js"
     }
   },
   "dependencies": {
-    "pino": "^9.0.0",
-    "pino-pretty": "^11.0.0",
-    "@nmtjs/common": "0.6.4",
-    "@nmtjs/type": "0.6.4"
+    "pino": "^9.6.0",
+    "pino-pretty": "^11.3.0",
+    "@nmtjs/common": "0.7.0",
+    "@nmtjs/type": "0.7.0"
   },
   "devDependencies": {
-    "@types/node": "^20"
+    "@types/node": "^20.17.30"
   },
   "files": [
-    "index.ts",
-    "lib",
+    "src",
     "dist",
     "LICENSE.md",
     "README.md"
   ],
-  "version": "0.6.4",
+  "version": "0.7.0",
   "scripts": {
-    "build": "neemata-build ./index.ts './lib/**/*.ts'",
+    "build": "neemata-build --root=./src './**/*.ts'",
     "type-check": "tsc --noEmit"
   }
 }

package/{lib → src}/container.ts

@@ -1,5 +1,4 @@
-import type { Async } from '@nmtjs/common'
-import { tryCaptureStackTrace } from '@nmtjs/common'
+import { type Async, tryCaptureStackTrace } from '@nmtjs/common'
 import {
   kFactoryInjectable,
   kInjectable,
@@ -106,7 +105,7 @@ export type Injectable<
 > =
   | LazyInjectable<InjectableValue, InjectableScope>
   | ValueInjectable<InjectableValue>
-  | FactoryInjectable<InjectableValue, InjectableDeps, InjectableScope>
+  | FactoryInjectable<InjectableValue, InjectableDeps, InjectableScope, any>
 
 export type AnyInjectable<T = any, S extends Scope = Scope> = Injectable<
   T,
@@ -264,7 +263,8 @@ export class Container {
     dependant?: AnyInjectable,
   ): Promise<ResolveInjectableType<T>> {
     if (dependant && compareScope(dependant.scope, '<', injectable.scope)) {
-      throw new Error('Invalid scope: dependant is looser than injectable') // TODO: more informative error
+      // TODO: more informative error
+      throw new Error('Invalid scope: dependant is looser than injectable')
     }
 
     if (checkIsValueInjectable(injectable)) {

package/{lib → src}/hooks.ts

@@ -1,4 +1,4 @@
-import type { Callback } from '@nmtjs/common'
+import type { Callback } from '../../common/src/index.ts'
 import { kHookCollection } from './constants.ts'
 import type { Hook } from './enums.ts'
 // import type { HookType } from './types.ts'

package/src/index.ts

@@ -0,0 +1,11 @@
+export * from './constants.ts'
+export * from './container.ts'
+export * from './enums.ts'
+export * from './hooks.ts'
+export * from './injectables.ts'
+export * from './logger.ts'
+export * from './plugin.ts'
+export * from './registry.ts'
+export * from './types.ts'
+export * from './types.ts'
+export * from './utils/index.ts'

package/{lib → src}/plugin.ts

@@ -1,4 +1,4 @@
-import type { Async } from '@nmtjs/common'
+import type { Async } from '../../common/src/index.ts'
 import { kPlugin } from './constants.ts'
 import type { PluginContext } from './types.ts'
 

package/{lib → src}/utils/pool.ts

@@ -1,4 +1,4 @@
-import type { Callback } from '@nmtjs/common'
+import type { Callback } from '../../../common/src/index.ts'
 
 interface PoolOptions {
   timeout?: number

package/{lib → src}/utils/semaphore.ts

@@ -1,4 +1,4 @@
-import type { Callback } from '@nmtjs/common'
+import type { Callback } from '../../../common/src/index.ts'
 
 interface SemaphoreQueueItem {
   resolve?: Callback

package/dist/lib/constants.js

@@ -1,9 +0,0 @@
-export const kOptionalDependency = Symbol.for('neemata:OptionalDependencyKey');
-export const kInjectable = Symbol.for('neemata:InjectableKey');
-export const kLazyInjectable = Symbol.for('neemata:LazyInjectableKey');
-export const kValueInjectable = Symbol.for('neemata:ValueInjectableKey');
-export const kFactoryInjectable = Symbol.for('neemata:FactoryInjectableKey');
-export const kProvider = Symbol.for('neemata:ProviderKey');
-export const kHookCollection = Symbol.for('neemata:HookCollectionKey');
-export const kPlugin = Symbol.for('neemata:PluginKey');
-export const isPlugin = (value)=>kPlugin in value;

package/dist/lib/constants.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../lib/constants.ts"],"sourcesContent":["import type { Plugin } from './plugin.ts'\n\nexport const kOptionalDependency: unique symbol = Symbol.for(\n  'neemata:OptionalDependencyKey',\n)\nexport type kOptionalDependency = typeof kOptionalDependency\n\nexport const kInjectable: unique symbol = Symbol.for('neemata:InjectableKey')\nexport type kInjectable = typeof kInjectable\n\nexport const kLazyInjectable: unique symbol = Symbol.for(\n  'neemata:LazyInjectableKey',\n)\nexport type kLazyInjectable = typeof kLazyInjectable\n\nexport const kValueInjectable: unique symbol = Symbol.for(\n  'neemata:ValueInjectableKey',\n)\nexport type kValueInjectable = typeof kValueInjectable\n\nexport const kFactoryInjectable: unique symbol = Symbol.for(\n  'neemata:FactoryInjectableKey',\n)\nexport type kFactoryInjectable = typeof kFactoryInjectable\n\nexport const kProvider: unique symbol = Symbol.for('neemata:ProviderKey')\nexport type kProvider = typeof kProvider\n\nexport const kHookCollection: unique symbol = Symbol.for(\n  'neemata:HookCollectionKey',\n)\nexport type kHookCollection = typeof kHookCollection\n\nexport const kPlugin: unique symbol = Symbol.for('neemata:PluginKey')\nexport type kPlugin = typeof kPlugin\nexport const isPlugin = (value: any): value is Plugin => kPlugin in value\n"],"names":["kOptionalDependency","Symbol","for","kInjectable","kLazyInjectable","kValueInjectable","kFactoryInjectable","kProvider","kHookCollection","kPlugin","isPlugin","value"],"mappings":"AAEA,OAAO,MAAMA,sBAAqCC,OAAOC,GAAG,CAC1D,iCACD;AAGD,OAAO,MAAMC,cAA6BF,OAAOC,GAAG,CAAC,yBAAwB;AAG7E,OAAO,MAAME,kBAAiCH,OAAOC,GAAG,CACtD,6BACD;AAGD,OAAO,MAAMG,mBAAkCJ,OAAOC,GAAG,CACvD,8BACD;AAGD,OAAO,MAAMI,qBAAoCL,OAAOC,GAAG,CACzD,gCACD;AAGD,OAAO,MAAMK,YAA2BN,OAAOC,GAAG,CAAC,uBAAsB;AAGzE,OAAO,MAAMM,kBAAiCP,OAAOC,GAAG,CACtD,6BACD;AAGD,OAAO,MAAMO,UAAyBR,OAAOC,GAAG,CAAC,qBAAoB;AAErE,OAAO,MAAMQ,WAAW,CAACC,QAAgCF,WAAWE,MAAK"}

package/dist/lib/container.js

@@ -1,279 +0,0 @@
-import { tryCaptureStackTrace } from '@nmtjs/common';
-import { kFactoryInjectable, kInjectable, kLazyInjectable, kOptionalDependency, kValueInjectable } from "./constants.js";
-import { Scope } from "./enums.js";
-const ScopeStrictness = {
-    [Scope.Global]: 0,
-    [Scope.Connection]: 1,
-    [Scope.Call]: 2,
-    [Scope.Transient]: 3
-};
-export class Container {
-    application;
-    scope;
-    parent;
-    instances;
-    resolvers;
-    injectables;
-    dependants;
-    constructor(application, scope = Scope.Global, parent){
-        this.application = application;
-        this.scope = scope;
-        this.parent = parent;
-        this.instances = new Map();
-        this.resolvers = new Map();
-        this.injectables = new Set();
-        this.dependants = new Map();
-        if (scope === Scope.Transient) {
-            throw new Error('Invalid scope');
-        }
-    }
-    async load() {
-        const traverse = (dependencies)=>{
-            for(const key in dependencies){
-                const dependency = dependencies[key];
-                const injectable = getDepedencencyInjectable(dependency);
-                this.injectables.add(injectable);
-                traverse(injectable.dependencies);
-            }
-        };
-        for (const dependant of this.application.registry.getDependants()){
-            traverse(dependant.dependencies);
-        }
-        const injectables = Array.from(this.findCurrentScopeInjectables());
-        await Promise.all(injectables.map((injectable)=>this.resolve(injectable)));
-    }
-    fork(scope) {
-        return new Container(this.application, scope, this);
-    }
-    async dispose() {
-        this.application.logger.trace('Disposing [%s] scope context...', this.scope);
-        while(this.instances.size){
-            for (const injectable of this.instances.keys()){
-                const dependants = this.dependants.get(injectable);
-                if (!dependants?.size) {
-                    await this.disposeInjectable(injectable);
-                    for (const dependants of this.dependants.values()){
-                        if (dependants.has(injectable)) {
-                            dependants.delete(injectable);
-                        }
-                    }
-                }
-            }
-        }
-        this.instances.clear();
-        this.injectables.clear();
-        this.resolvers.clear();
-        this.dependants.clear();
-    }
-    containsWithinSelf(injectable) {
-        return this.instances.has(injectable) || this.resolvers.has(injectable);
-    }
-    contains(injectable) {
-        return this.containsWithinSelf(injectable) || (this.parent?.contains(injectable) ?? false);
-    }
-    get(injectable) {
-        if (this.instances.has(injectable)) {
-            return this.instances.get(injectable).instance;
-        }
-        if (this.parent?.contains(injectable)) {
-            return this.parent.get(injectable);
-        }
-        throw new Error('No instance found');
-    }
-    resolve(injectable) {
-        return this.resolveInjectable(injectable);
-    }
-    async createContext(dependencies) {
-        return this.createInjectableContext(dependencies);
-    }
-    async createInjectableContext(dependencies, dependant) {
-        const injections = {};
-        const deps = Object.entries(dependencies);
-        const resolvers = Array(deps.length);
-        for(let i = 0; i < deps.length; i++){
-            const [key, dependency] = deps[i];
-            const injectable = getDepedencencyInjectable(dependency);
-            const resolver = this.resolveInjectable(injectable, dependant);
-            resolvers[i] = resolver.then((value)=>injections[key] = value);
-        }
-        await Promise.all(resolvers);
-        return Object.freeze(injections);
-    }
-    async provide(injectable, instance) {
-        if (compareScope(injectable.scope, '>', this.scope)) {
-            throw new Error('Invalid scope');
-        }
-        this.instances.set(injectable, {
-            instance,
-            picked: instance,
-            context: undefined
-        });
-    }
-    satisfies(injectable) {
-        return compareScope(injectable.scope, '<=', this.scope);
-    }
-    *findCurrentScopeInjectables() {
-        for (const injectable of this.injectables){
-            if (injectable.scope === this.scope) {
-                yield injectable;
-            }
-        }
-    }
-    resolveInjectable(injectable, dependant) {
-        if (dependant && compareScope(dependant.scope, '<', injectable.scope)) {
-            throw new Error('Invalid scope: dependant is looser than injectable');
-        }
-        if (checkIsValueInjectable(injectable)) {
-            return Promise.resolve(injectable.value);
-        } else if (this.parent?.contains(injectable) || this.parent?.satisfies(injectable) && compareScope(this.parent.scope, '<', this.scope)) {
-            return this.parent.resolveInjectable(injectable, dependant);
-        } else {
-            const { scope, dependencies, stack, label } = injectable;
-            if (dependant && compareScope(scope, '=', dependant.scope)) {
-                let dependants = this.dependants.get(injectable);
-                if (!dependants) {
-                    this.dependants.set(injectable, dependants = new Set());
-                }
-                dependants.add(dependant);
-            }
-            if (this.instances.has(injectable)) {
-                return Promise.resolve(this.instances.get(injectable).picked);
-            } else if (this.resolvers.has(injectable)) {
-                return this.resolvers.get(injectable);
-            } else {
-                const isLazy = checkIsLazyInjectable(injectable);
-                if (isLazy) {
-                    const isOptional = checkIsOptional(injectable);
-                    if (isOptional) return Promise.resolve(undefined);
-                    return Promise.reject(new Error(`No instance provided for ${label || 'an'} injectable:\n${stack}`));
-                } else if (!checkIsFactoryInjectable(injectable)) {
-                    throw new Error('Invalid injectable');
-                }
-                const resolution = this.createInjectableContext(dependencies, injectable).then((context)=>Promise.resolve(injectable.factory(context)).then((instance)=>({
-                            instance,
-                            context
-                        }))).then(({ instance, context })=>{
-                    const picked = injectable.pick(instance);
-                    if (compareScope(this.scope, '>=', scope)) this.instances.set(injectable, {
-                        instance,
-                        picked,
-                        context
-                    });
-                    if (scope !== Scope.Transient) this.resolvers.delete(injectable);
-                    return picked;
-                });
-                if (scope !== Scope.Transient) this.resolvers.set(injectable, resolution);
-                return resolution;
-            }
-        }
-    }
-    async disposeInjectable(injectable) {
-        try {
-            if (kFactoryInjectable in injectable) {
-                const { dispose } = injectable;
-                if (dispose) {
-                    const { instance, context } = this.instances.get(injectable);
-                    await dispose(instance, context);
-                }
-            }
-        } catch (cause) {
-            const error = new Error('Injectable disposal error. Potential memory leak', {
-                cause
-            });
-            this.application.logger.error(error);
-        } finally{
-            this.instances.delete(injectable);
-        }
-    }
-}
-function compareScope(left, operator, right) {
-    const leftScope = ScopeStrictness[left];
-    const rightScope = ScopeStrictness[right];
-    switch(operator){
-        case '=':
-            return leftScope === rightScope;
-        case '!=':
-            return leftScope !== rightScope;
-        case '>':
-            return leftScope > rightScope;
-        case '<':
-            return leftScope < rightScope;
-        case '>=':
-            return leftScope >= rightScope;
-        case '<=':
-            return leftScope <= rightScope;
-        default:
-            throw new Error('Invalid operator');
-    }
-}
-export const checkIsLazyInjectable = (injectable)=>kLazyInjectable in injectable;
-export const checkIsFactoryInjectable = (injectable)=>kFactoryInjectable in injectable;
-export const checkIsValueInjectable = (injectable)=>kValueInjectable in injectable;
-export const checkIsInjectable = (injectable)=>kInjectable in injectable;
-export const checkIsOptional = (injectable)=>kOptionalDependency in injectable;
-export function getInjectableScope(injectable) {
-    let scope = injectable.scope;
-    const deps = Object.values(injectable.dependencies);
-    for (const dependency of deps){
-        const injectable = getDepedencencyInjectable(dependency);
-        const dependencyScope = getInjectableScope(injectable);
-        if (compareScope(dependencyScope, '>', scope)) {
-            scope = dependencyScope;
-        }
-    }
-    return scope;
-}
-export function getDepedencencyInjectable(dependency) {
-    if (kOptionalDependency in dependency) {
-        return dependency.injectable;
-    }
-    return dependency;
-}
-export function createOptionalInjectable(injectable) {
-    return {
-        [kOptionalDependency]: true,
-        injectable
-    };
-}
-export function createLazyInjectable(scope = Scope.Global, label) {
-    return Object.freeze({
-        scope,
-        dependencies: {},
-        label,
-        stack: tryCaptureStackTrace(),
-        [kInjectable]: true,
-        [kLazyInjectable]: true
-    });
-}
-export function createValueInjectable(value, label) {
-    return Object.freeze({
-        value,
-        scope: Scope.Global,
-        dependencies: {},
-        label,
-        stack: tryCaptureStackTrace(),
-        [kInjectable]: true,
-        [kValueInjectable]: true
-    });
-}
-export function createFactoryInjectable(paramsOrFactory, label) {
-    const isFactory = typeof paramsOrFactory === 'function';
-    const params = isFactory ? {
-        factory: paramsOrFactory
-    } : paramsOrFactory;
-    const injectable = {
-        dependencies: params.dependencies ?? {},
-        scope: params.scope ?? Scope.Global,
-        factory: params.factory,
-        dispose: params.dispose,
-        pick: params.pick ?? ((instance)=>instance),
-        label,
-        stack: tryCaptureStackTrace(),
-        [kInjectable]: true,
-        [kFactoryInjectable]: true
-    };
-    const actualScope = getInjectableScope(injectable);
-    if (!isFactory && params.scope && ScopeStrictness[actualScope] > ScopeStrictness[params.scope]) throw new Error(`Invalid scope ${params.scope} for factory injectable: dependencies have stricter scope - ${actualScope}`);
-    injectable.scope = actualScope;
-    return Object.freeze(injectable);
-}

package/dist/lib/container.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../lib/container.ts"],"sourcesContent":["import type { Async } from '@nmtjs/common'\nimport { tryCaptureStackTrace } from '@nmtjs/common'\nimport {\n  kFactoryInjectable,\n  kInjectable,\n  kLazyInjectable,\n  kOptionalDependency,\n  kValueInjectable,\n} from './constants.ts'\nimport { Scope } from './enums.ts'\nimport type { Logger } from './logger.ts'\nimport type { Registry } from './registry.ts'\n\nconst ScopeStrictness = {\n  [Scope.Global]: 0,\n  [Scope.Connection]: 1,\n  [Scope.Call]: 2,\n  [Scope.Transient]: 3,\n}\n\nexport type DependencyOptional<T extends AnyInjectable = AnyInjectable> = {\n  [kOptionalDependency]: any\n  injectable: T\n}\n\nexport type Depedency = DependencyOptional | AnyInjectable\n\nexport type Dependencies = Record<string, Depedency>\n\nexport type ResolveInjectableType<T extends AnyInjectable> =\n  T extends Injectable<infer Type, any, any> ? Type : never\n\nexport interface Dependant<Deps extends Dependencies = Dependencies> {\n  dependencies: Deps\n  label?: string\n  stack?: string\n}\n\nexport type DependencyInjectable<T extends Depedency> = T extends AnyInjectable\n  ? T\n  : T extends DependencyOptional\n    ? T['injectable']\n    : never\n\nexport type DependencyContext<Deps extends Dependencies> = {\n  readonly [K in keyof Deps as Deps[K] extends AnyInjectable\n    ? K\n    : never]: Deps[K] extends AnyInjectable\n    ? ResolveInjectableType<Deps[K]>\n    : never\n} & {\n  readonly [K in keyof Deps as Deps[K] extends DependencyOptional\n    ? K\n    : never]?: Deps[K] extends DependencyOptional\n    ? ResolveInjectableType<Deps[K]['injectable']>\n    : never\n}\n\nexport type InjectableFactoryType<\n  InjectableType,\n  InjectableDeps extends Dependencies,\n> = (context: DependencyContext<InjectableDeps>) => Async<InjectableType>\n\nexport type InjectablePickType<Input, Output> = (injectable: Input) => Output\n\nexport type InjectableDisposeType<\n  InjectableType,\n  InjectableDeps extends Dependencies,\n> = (\n  instance: InjectableType,\n  context: DependencyContext<InjectableDeps>,\n) => any\n\nexport interface LazyInjectable<T, S extends Scope = Scope.Global>\n  extends Dependant<{}> {\n  scope: S\n  [kInjectable]: any\n  [kLazyInjectable]: T\n}\n\nexport interface ValueInjectable<T> extends Dependant<{}> {\n  scope: Scope.Global\n  value: T\n  [kInjectable]: any\n  [kValueInjectable]: any\n}\n\nexport interface FactoryInjectable<\n  T,\n  D extends Dependencies = {},\n  S extends Scope = Scope.Global,\n  P = T,\n> extends Dependant<D> {\n  scope: S\n  factory: InjectableFactoryType<P, D>\n  pick: InjectablePickType<P, T>\n  dispose?: InjectableDisposeType<P, D>\n  [kInjectable]: any\n  [kFactoryInjectable]: any\n}\n\nexport type Injectable<\n  InjectableValue = any,\n  InjectableDeps extends Dependencies = {},\n  InjectableScope extends Scope = Scope,\n> =\n  | LazyInjectable<InjectableValue, InjectableScope>\n  | ValueInjectable<InjectableValue>\n  | FactoryInjectable<InjectableValue, InjectableDeps, InjectableScope>\n\nexport type AnyInjectable<T = any, S extends Scope = Scope> = Injectable<\n  T,\n  any,\n  S\n>\n\nexport class Container {\n  readonly instances = new Map<\n    AnyInjectable,\n    { instance: any; picked: any; context: any }\n  >()\n  private readonly resolvers = new Map<AnyInjectable, Promise<any>>()\n  private readonly injectables = new Set<AnyInjectable>()\n  private readonly dependants = new Map<AnyInjectable, Set<AnyInjectable>>()\n\n  constructor(\n    private readonly application: {\n      registry: Registry\n      logger: Logger\n    },\n    public readonly scope: Exclude<Scope, Scope.Transient> = Scope.Global,\n    private readonly parent?: Container,\n  ) {\n    if ((scope as any) === Scope.Transient) {\n      throw new Error('Invalid scope')\n    }\n  }\n\n  async load() {\n    const traverse = (dependencies: Dependencies) => {\n      for (const key in dependencies) {\n        const dependency = dependencies[key]\n        const injectable = getDepedencencyInjectable(dependency)\n        this.injectables.add(injectable)\n        traverse(injectable.dependencies)\n      }\n    }\n\n    for (const dependant of this.application.registry.getDependants()) {\n      traverse(dependant.dependencies)\n    }\n\n    const injectables = Array.from(this.findCurrentScopeInjectables())\n    await Promise.all(injectables.map((injectable) => this.resolve(injectable)))\n  }\n\n  fork(scope: Exclude<Scope, Scope.Transient>) {\n    return new Container(this.application, scope, this)\n  }\n\n  async dispose() {\n    this.application.logger.trace('Disposing [%s] scope context...', this.scope)\n\n    // Loop through all instances and dispose them,\n    // until there are no more instances left\n    while (this.instances.size) {\n      for (const injectable of this.instances.keys()) {\n        const dependants = this.dependants.get(injectable)\n        // Firstly, dispose instances that other injectables don't depend on\n        if (!dependants?.size) {\n          await this.disposeInjectable(injectable)\n          for (const dependants of this.dependants.values()) {\n            // Clear current istances as a dependant for other injectables\n            if (dependants.has(injectable)) {\n              dependants.delete(injectable)\n            }\n          }\n        }\n      }\n    }\n\n    this.instances.clear()\n    this.injectables.clear()\n    this.resolvers.clear()\n    this.dependants.clear()\n  }\n\n  containsWithinSelf(injectable: AnyInjectable) {\n    return this.instances.has(injectable) || this.resolvers.has(injectable)\n  }\n\n  contains(injectable: AnyInjectable): boolean {\n    return (\n      this.containsWithinSelf(injectable) ||\n      (this.parent?.contains(injectable) ?? false)\n    )\n  }\n\n  get<T extends AnyInjectable>(injectable: T): ResolveInjectableType<T> {\n    if (this.instances.has(injectable)) {\n      return this.instances.get(injectable)!.instance\n    }\n\n    if (this.parent?.contains(injectable)) {\n      return this.parent.get(injectable)\n    }\n\n    throw new Error('No instance found')\n  }\n\n  resolve<T extends AnyInjectable>(injectable: T) {\n    return this.resolveInjectable(injectable)\n  }\n\n  async createContext<T extends Dependencies>(dependencies: T) {\n    return this.createInjectableContext(dependencies)\n  }\n\n  private async createInjectableContext<T extends Dependencies>(\n    dependencies: T,\n    dependant?: AnyInjectable,\n  ) {\n    const injections: Record<string, any> = {}\n    const deps = Object.entries(dependencies)\n    const resolvers: Promise<any>[] = Array(deps.length)\n    for (let i = 0; i < deps.length; i++) {\n      const [key, dependency] = deps[i]\n      const injectable = getDepedencencyInjectable(dependency)\n      const resolver = this.resolveInjectable(injectable, dependant)\n      resolvers[i] = resolver.then((value) => (injections[key] = value))\n    }\n    await Promise.all(resolvers)\n    return Object.freeze(injections) as DependencyContext<T>\n  }\n\n  async provide<T extends AnyInjectable>(\n    injectable: T,\n    instance: ResolveInjectableType<T>,\n  ) {\n    if (compareScope(injectable.scope, '>', this.scope)) {\n      throw new Error('Invalid scope') // TODO: more informative error\n    }\n    this.instances.set(injectable, {\n      instance,\n      picked: instance,\n      context: undefined,\n    })\n  }\n\n  satisfies(injectable: AnyInjectable) {\n    return compareScope(injectable.scope, '<=', this.scope)\n  }\n\n  private *findCurrentScopeInjectables() {\n    for (const injectable of this.injectables) {\n      if (injectable.scope === this.scope) {\n        yield injectable\n      }\n    }\n  }\n\n  private resolveInjectable<T extends AnyInjectable>(\n    injectable: T,\n    dependant?: AnyInjectable,\n  ): Promise<ResolveInjectableType<T>> {\n    if (dependant && compareScope(dependant.scope, '<', injectable.scope)) {\n      throw new Error('Invalid scope: dependant is looser than injectable') // TODO: more informative error\n    }\n\n    if (checkIsValueInjectable(injectable)) {\n      return Promise.resolve(injectable.value)\n    } else if (\n      this.parent?.contains(injectable) ||\n      (this.parent?.satisfies(injectable) &&\n        compareScope(this.parent.scope, '<', this.scope))\n    ) {\n      return this.parent.resolveInjectable(injectable, dependant)\n    } else {\n      const { scope, dependencies, stack, label } = injectable\n\n      if (dependant && compareScope(scope, '=', dependant.scope)) {\n        let dependants = this.dependants.get(injectable)\n        if (!dependants) {\n          this.dependants.set(injectable, (dependants = new Set()))\n        }\n        dependants.add(dependant)\n      }\n\n      if (this.instances.has(injectable)) {\n        return Promise.resolve(this.instances.get(injectable)!.picked)\n      } else if (this.resolvers.has(injectable)) {\n        return this.resolvers.get(injectable)!\n      } else {\n        const isLazy = checkIsLazyInjectable(injectable)\n\n        if (isLazy) {\n          const isOptional = checkIsOptional(injectable)\n          if (isOptional) return Promise.resolve(undefined as any)\n          return Promise.reject(\n            new Error(\n              `No instance provided for ${label || 'an'} injectable:\\n${stack}`,\n            ),\n          )\n        } else if (!checkIsFactoryInjectable(injectable)) {\n          throw new Error('Invalid injectable')\n        }\n\n        const resolution = this.createInjectableContext(\n          dependencies,\n          injectable,\n        )\n          .then((context) =>\n            Promise.resolve(injectable.factory(context)).then((instance) => ({\n              instance,\n              context,\n            })),\n          )\n          .then(({ instance, context }) => {\n            const picked = injectable.pick(instance)\n            if (compareScope(this.scope, '>=', scope))\n              this.instances.set(injectable, { instance, picked, context })\n            if (scope !== Scope.Transient) this.resolvers.delete(injectable)\n            return picked\n          })\n        if (scope !== Scope.Transient)\n          this.resolvers.set(injectable, resolution)\n        return resolution\n      }\n    }\n  }\n\n  private async disposeInjectable(injectable: AnyInjectable) {\n    try {\n      if (kFactoryInjectable in injectable) {\n        const { dispose } = injectable\n        if (dispose) {\n          const { instance, context } = this.instances.get(injectable)!\n          await dispose(instance, context)\n        }\n      }\n    } catch (cause) {\n      const error = new Error(\n        'Injectable disposal error. Potential memory leak',\n        { cause },\n      )\n      this.application.logger.error(error)\n    } finally {\n      this.instances.delete(injectable)\n    }\n  }\n}\n\nfunction compareScope(\n  left: Scope,\n  operator: '>' | '<' | '>=' | '<=' | '=' | '!=',\n  right: Scope,\n) {\n  const leftScope = ScopeStrictness[left]\n  const rightScope = ScopeStrictness[right]\n  switch (operator) {\n    case '=':\n      return leftScope === rightScope\n    case '!=':\n      return leftScope !== rightScope\n    case '>':\n      return leftScope > rightScope\n    case '<':\n      return leftScope < rightScope\n    case '>=':\n      return leftScope >= rightScope\n    case '<=':\n      return leftScope <= rightScope\n    default:\n      throw new Error('Invalid operator')\n  }\n}\n\nexport const checkIsLazyInjectable = (\n  injectable: any,\n): injectable is LazyInjectable<any> => kLazyInjectable in injectable\nexport const checkIsFactoryInjectable = (\n  injectable: any,\n): injectable is FactoryInjectable<any> => kFactoryInjectable in injectable\nexport const checkIsValueInjectable = (\n  injectable: any,\n): injectable is ValueInjectable<any> => kValueInjectable in injectable\nexport const checkIsInjectable = (\n  injectable: any,\n): injectable is AnyInjectable<any> => kInjectable in injectable\nexport const checkIsOptional = (\n  injectable: any,\n): injectable is DependencyOptional<any> => kOptionalDependency in injectable\n\nexport function getInjectableScope(injectable: AnyInjectable) {\n  let scope = injectable.scope\n  const deps = Object.values(injectable.dependencies as Dependencies)\n  for (const dependency of deps) {\n    const injectable = getDepedencencyInjectable(dependency)\n    const dependencyScope = getInjectableScope(injectable)\n    if (compareScope(dependencyScope, '>', scope)) {\n      scope = dependencyScope\n    }\n  }\n  return scope\n}\n\nexport function getDepedencencyInjectable(\n  dependency: Depedency,\n): AnyInjectable {\n  if (kOptionalDependency in dependency) {\n    return dependency.injectable\n  }\n  return dependency\n}\n\nexport function createOptionalInjectable<T extends AnyInjectable>(\n  injectable: T,\n) {\n  return {\n    [kOptionalDependency]: true,\n    injectable,\n  } as DependencyOptional<T>\n}\n\nexport function createLazyInjectable<T, S extends Scope = Scope.Global>(\n  scope = Scope.Global as S,\n  label?: string,\n): LazyInjectable<T, S> {\n  return Object.freeze({\n    scope,\n    dependencies: {},\n    label,\n    stack: tryCaptureStackTrace(),\n    [kInjectable]: true,\n    [kLazyInjectable]: true as unknown as T,\n  })\n}\n\nexport function createValueInjectable<T>(\n  value: T,\n  label?: string,\n): ValueInjectable<T> {\n  return Object.freeze({\n    value,\n    scope: Scope.Global,\n    dependencies: {},\n    label,\n    stack: tryCaptureStackTrace(),\n    [kInjectable]: true,\n    [kValueInjectable]: true,\n  })\n}\n\nexport function createFactoryInjectable<\n  T,\n  D extends Dependencies = {},\n  S extends Scope = Scope.Global,\n  P = T,\n>(\n  paramsOrFactory:\n    | {\n        dependencies?: D\n        scope?: S\n        pick?: InjectablePickType<P, T>\n        factory: InjectableFactoryType<P, D>\n        dispose?: InjectableDisposeType<P, D>\n      }\n    | InjectableFactoryType<P, D>,\n  label?: string,\n): FactoryInjectable<null extends T ? P : T, D, S, P> {\n  const isFactory = typeof paramsOrFactory === 'function'\n  const params = isFactory ? { factory: paramsOrFactory } : paramsOrFactory\n  const injectable = {\n    dependencies: (params.dependencies ?? {}) as D,\n    scope: (params.scope ?? Scope.Global) as S,\n    factory: params.factory,\n    dispose: params.dispose,\n    pick: params.pick ?? ((instance: P) => instance as unknown as T),\n    label,\n    stack: tryCaptureStackTrace(),\n    [kInjectable]: true,\n    [kFactoryInjectable]: true,\n  }\n  const actualScope = getInjectableScope(injectable)\n  if (\n    !isFactory &&\n    params.scope &&\n    ScopeStrictness[actualScope] > ScopeStrictness[params.scope]\n  )\n    throw new Error(\n      `Invalid scope ${params.scope} for factory injectable: dependencies have stricter scope - ${actualScope}`,\n    )\n  injectable.scope = actualScope as unknown as S\n  return Object.freeze(injectable) as any\n}\n"],"names":["tryCaptureStackTrace","kFactoryInjectable","kInjectable","kLazyInjectable","kOptionalDependency","kValueInjectable","Scope","ScopeStrictness","Global","Connection","Call","Transient","Container","instances","resolvers","injectables","dependants","constructor","application","scope","parent","Map","Set","Error","load","traverse","dependencies","key","dependency","injectable","getDepedencencyInjectable","add","dependant","registry","getDependants","Array","from","findCurrentScopeInjectables","Promise","all","map","resolve","fork","dispose","logger","trace","size","keys","get","disposeInjectable","values","has","delete","clear","containsWithinSelf","contains","instance","resolveInjectable","createContext","createInjectableContext","injections","deps","Object","entries","length","i","resolver","then","value","freeze","provide","compareScope","set","picked","context","undefined","satisfies","checkIsValueInjectable","stack","label","isLazy","checkIsLazyInjectable","isOptional","checkIsOptional","reject","checkIsFactoryInjectable","resolution","factory","pick","cause","error","left","operator","right","leftScope","rightScope","checkIsInjectable","getInjectableScope","dependencyScope","createOptionalInjectable","createLazyInjectable","createValueInjectable","createFactoryInjectable","paramsOrFactory","isFactory","params","actualScope"],"mappings":"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"}

package/dist/lib/enums.js

@@ -1,20 +0,0 @@
-export var Scope;
-(function(Scope) {
-    Scope["Global"] = "Global";
-    Scope["Connection"] = "Connection";
-    Scope["Call"] = "Call";
-    Scope["Transient"] = "Transient";
-})(Scope || (Scope = {}));
-export var Hook;
-(function(Hook) {
-    Hook["BeforeInitialize"] = "BeforeInitialize";
-    Hook["AfterInitialize"] = "AfterInitialize";
-    Hook["BeforeStart"] = "BeforeStart";
-    Hook["AfterStart"] = "AfterStart";
-    Hook["BeforeStop"] = "BeforeStop";
-    Hook["AfterStop"] = "AfterStop";
-    Hook["BeforeTerminate"] = "BeforeTerminate";
-    Hook["AfterTerminate"] = "AfterTerminate";
-    Hook["OnConnect"] = "OnConnect";
-    Hook["OnDisconnect"] = "OnDisconnect";
-})(Hook || (Hook = {}));

package/dist/lib/enums.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../lib/enums.ts"],"sourcesContent":["export enum Scope {\n  Global = 'Global',\n  Connection = 'Connection',\n  Call = 'Call',\n  Transient = 'Transient',\n}\n\nexport enum Hook {\n  BeforeInitialize = 'BeforeInitialize',\n  AfterInitialize = 'AfterInitialize',\n  BeforeStart = 'BeforeStart',\n  AfterStart = 'AfterStart',\n  BeforeStop = 'BeforeStop',\n  AfterStop = 'AfterStop',\n  BeforeTerminate = 'BeforeTerminate',\n  AfterTerminate = 'AfterTerminate',\n  OnConnect = 'OnConnect',\n  OnDisconnect = 'OnDisconnect',\n}\n"],"names":["Scope","Hook"],"mappings":";UAAYA;;;;;GAAAA,UAAAA;;UAOAC;;;;;;;;;;;GAAAA,SAAAA"}