@nmtjs/core 0.12.5 → 0.12.7

package/dist/registry.js

@@ -1,25 +1,24 @@
 import { Scope } from "./enums.js";
 import { Hooks } from "./hooks.js";
-import { getInjectableScope } from "./injectables.js";
+import { getInjectableScope, } from "./injectables.js";
 export class Registry {
-	hooks = new Hooks();
-	constructor(application) {
-		this.application = application;
-	}
-	registerHooks(hooks) {
-		Hooks.merge(hooks, this.hooks);
-	}
-	registerHook(name, callback) {
-		this.hooks.add(name, callback);
-	}
-	*getDependants() {}
-	clear() {
-		this.hooks.clear();
-	}
+    application;
+    hooks = new Hooks();
+    constructor(application) {
+        this.application = application;
+    }
+    registerHooks(hooks) {
+        Hooks.merge(hooks, this.hooks);
+    }
+    registerHook(name, callback) {
+        this.hooks.add(name, callback);
+    }
+    *getDependants() { }
+    clear() {
+        this.hooks.clear();
+    }
 }
 export const scopeErrorMessage = (name, scope = Scope.Global) => `${name} must be a ${scope} scope (including all nested dependencies)`;
 export function hasInvalidScopeDeps(injectables, scope = Scope.Global) {
-	return injectables.some((injectable) => getInjectableScope(injectable) !== scope);
+    return injectables.some((injectable) => getInjectableScope(injectable) !== scope);
 }
-
-//# sourceMappingURL=registry.js.map

package/dist/types.d.ts

@@ -0,0 +1,11 @@
+import type { Container } from './container.ts';
+import type { Hooks } from './hooks.ts';
+import type { Logger } from './logger.ts';
+import type { Registry } from './registry.ts';
+export interface PluginContext {
+    logger: Logger;
+    registry: Registry;
+    hooks: Hooks;
+    container: Container;
+}
+export type Pattern = RegExp | string | ((value: string) => boolean);

package/dist/types.js

@@ -1,3 +1 @@
 export {};
-
-//# sourceMappingURL=types.js.map

package/dist/utils/functions.d.ts

@@ -0,0 +1,6 @@
+import type { Pattern } from '../types.ts';
+/**
+ * Very simple pattern matching function.
+ */
+export declare function match(value: string, pattern: Pattern): boolean;
+export declare function isJsFile(name: string): boolean;

package/dist/utils/functions.js

@@ -1,37 +1,35 @@
 /**
-* Very simple pattern matching function.
-*/
+ * Very simple pattern matching function.
+ */
 export function match(value, pattern) {
-	if (typeof pattern === "function") {
-		return pattern(value);
-	} else if (typeof pattern === "string") {
-		if (pattern === "*" || pattern === "**") {
-			return true;
-		} else if (pattern.at(0) === "*" && pattern.at(-1) === "*") {
-			return value.includes(pattern.slice(1, -1));
-		} else if (pattern.at(-1) === "*") {
-			return value.startsWith(pattern.slice(0, -1));
-		} else if (pattern.at(0) === "*") {
-			return value.endsWith(pattern.slice(1));
-		} else {
-			return value === pattern;
-		}
-	} else {
-		return pattern.test(value);
-	}
+    if (typeof pattern === 'function') {
+        return pattern(value);
+    }
+    else if (typeof pattern === 'string') {
+        if (pattern === '*' || pattern === '**') {
+            return true;
+        }
+        else if (pattern.at(0) === '*' && pattern.at(-1) === '*') {
+            return value.includes(pattern.slice(1, -1));
+        }
+        else if (pattern.at(-1) === '*') {
+            return value.startsWith(pattern.slice(0, -1));
+        }
+        else if (pattern.at(0) === '*') {
+            return value.endsWith(pattern.slice(1));
+        }
+        else {
+            return value === pattern;
+        }
+    }
+    else {
+        return pattern.test(value);
+    }
 }
 export function isJsFile(name) {
-	if (name.endsWith(".d.ts")) return false;
-	const leading = name.split(".").slice(1);
-	const ext = leading.join(".");
-	return [
-		"js",
-		"mjs",
-		"cjs",
-		"ts",
-		"mts",
-		"cts"
-	].includes(ext);
+    if (name.endsWith('.d.ts'))
+        return false;
+    const leading = name.split('.').slice(1);
+    const ext = leading.join('.');
+    return ['js', 'mjs', 'cjs', 'ts', 'mts', 'cts'].includes(ext);
 }
-
-//# sourceMappingURL=functions.js.map

package/dist/utils/index.d.ts

@@ -0,0 +1,3 @@
+export * from './functions.ts';
+export * from './pool.ts';
+export * from './semaphore.ts';

package/dist/utils/index.js

@@ -1,5 +1,3 @@
 export * from "./functions.js";
 export * from "./pool.js";
 export * from "./semaphore.js";
-
-//# sourceMappingURL=index.js.map

package/dist/utils/pool.d.ts

@@ -0,0 +1,18 @@
+interface PoolOptions {
+    timeout?: number;
+}
+export declare class PoolError extends Error {
+}
+export declare class Pool<T = unknown> {
+    #private;
+    private readonly options;
+    constructor(options?: PoolOptions);
+    add(item: T): void;
+    remove(item: T): void;
+    capture(timeout?: number | undefined): Promise<T>;
+    next(exclusive?: boolean, timeout?: number | undefined): Promise<T>;
+    release(item: T): void;
+    isFree(item: T): boolean;
+    get items(): T[];
+}
+export {};

package/dist/utils/pool.js

@@ -1,92 +1,105 @@
-export class PoolError extends Error {}
+export class PoolError extends Error {
+}
+// Fixed pool from https://github.com/metarhia/metautil
 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;
-		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--;
-	}
+    options;
+    #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;
+        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--;
+    }
 }
-
-//# sourceMappingURL=pool.js.map

package/dist/utils/semaphore.d.ts

@@ -0,0 +1,13 @@
+export declare class SemaphoreError extends Error {
+}
+export declare class Semaphore {
+    private readonly size;
+    private readonly timeout;
+    private counter;
+    private readonly queue;
+    constructor(concurrency: number, size?: number, timeout?: number);
+    enter(): Promise<void>;
+    leave(): void;
+    get isEmpty(): boolean;
+    get queueLength(): number;
+}

package/dist/utils/semaphore.js

@@ -1,48 +1,55 @@
-export class SemaphoreError extends Error {}
+export class SemaphoreError extends Error {
+}
+// Semaphore from https://github.com/metarhia/metautil
 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;
-	}
+    size;
+    timeout;
+    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;
+    }
 }
-
-//# sourceMappingURL=semaphore.js.map

package/package.json

@@ -3,32 +3,32 @@
   "type": "module",
   "exports": {
     ".": {
-      "types": "./src/index.ts",
-      "import": "./dist/index.js"
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "module-sync": "./dist/index.js"
     }
   },
   "peerDependencies": {
     "pino": "^9.6.0",
     "pino-pretty": "^13.0.0",
-    "@nmtjs/common": "0.12.5",
-    "@nmtjs/type": "0.12.5"
+    "@nmtjs/common": "0.12.7",
+    "@nmtjs/type": "0.12.7"
   },
   "devDependencies": {
     "@types/node": "^20",
     "pino": "^9.6.0",
     "pino-pretty": "^13.0.0",
-    "@nmtjs/type": "0.12.5",
-    "@nmtjs/common": "0.12.5"
+    "@nmtjs/common": "0.12.7",
+    "@nmtjs/type": "0.12.7"
   },
   "files": [
-    "src",
     "dist",
     "LICENSE.md",
     "README.md"
   ],
-  "version": "0.12.5",
+  "version": "0.12.7",
   "scripts": {
-    "build": "neemata-build --root=./src './**/*.ts'",
+    "build": "tsc",
     "type-check": "tsc --noEmit"
   }
 }

package/dist/constants.js.map

@@ -1 +0,0 @@
-{"mappings":"AAAA,OAAO,MAAMA,sBAAqC,OAAO,IACvD,gCACD;AAGD,OAAO,MAAMC,cAA6B,OAAO,IAAI,wBAAwB;AAG7E,OAAO,MAAMC,kBAAiC,OAAO,IACnD,4BACD;AAGD,OAAO,MAAMC,mBAAkC,OAAO,IACpD,6BACD;AAGD,OAAO,MAAMC,qBAAoC,OAAO,IACtD,+BACD;AAGD,OAAO,MAAMC,mBAAkC,OAAO,IACpD,6BACD;AAGD,OAAO,MAAMC,YAA2B,OAAO,IAAI,sBAAsB;AAGzE,OAAO,MAAMC,kBAAiC,OAAO,IACnD,4BACD;AAGD,OAAO,MAAMC,UAAyB,OAAO,IAAI,oBAAoB;AAGrE,OAAO,MAAMC,YAA2B,OAAO,IAAI,sBAAsB","names":["kOptionalDependency: unique symbol","kInjectable: unique symbol","kLazyInjectable: unique symbol","kValueInjectable: unique symbol","kFactoryInjectable: unique symbol","kClassInjectable: unique symbol","kProvider: unique symbol","kHookCollection: unique symbol","kPlugin: unique symbol","kMetadata: unique symbol"],"sources":["../src/constants.ts"],"sourcesContent":["export 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 kClassInjectable: unique symbol = Symbol.for(\n  'neemata:ClassInjectableKey',\n)\nexport type kClassInjectable = typeof kClassInjectable\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\n\nexport const kMetadata: unique symbol = Symbol.for('neemata:MetadataKey')\nexport type kMetadata = typeof kMetadata\n"],"version":3,"file":"constants.js"}

package/dist/container.js.map

@@ -1 +0,0 @@
-{"mappings":"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","names":["application: ContainerOptions","scope: Exclude<Scope, Scope.Transient>","parent?: Container","dependencies: Dependencies","injectable: AnyInjectable","injectable: T","dependencies: T","dependant?: AnyInjectable","injections: Record<string, any>","resolvers: Promise<any>[]","instance: ResolveInjectableType<T>","context: InlineInjectionDependencies<T>","instance?: any","result: AnyInjectable[]","instance: any","context: any"],"sources":["../src/container.ts"],"sourcesContent":["import assert from 'node:assert'\nimport { tryCaptureStackTrace } from '@nmtjs/common'\nimport { Scope } from './enums.ts'\nimport {\n  type AnyInjectable,\n  CoreInjectables,\n  compareScope,\n  createExtendableClassInjectable,\n  createValueInjectable,\n  type Dependencies,\n  type DependencyContext,\n  getDepedencencyInjectable,\n  isClassInjectable,\n  isFactoryInjectable,\n  isInjectable,\n  isLazyInjectable,\n  isOptionalInjectable,\n  isValueInjectable,\n  type ResolveInjectableType,\n} from './injectables.ts'\nimport type { Logger } from './logger.ts'\nimport type { Registry } from './registry.ts'\n\ntype InstanceWrapper = { private: any; public: any; context: any }\n\ntype ContainerOptions = {\n  registry: Registry\n  logger: Logger\n}\n\nexport class Container {\n  readonly instances = new Map<AnyInjectable, InstanceWrapper[]>()\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  // private readonly transients = new Map<any, any>()\n  private disposing = false\n\n  constructor(\n    private readonly application: ContainerOptions,\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    this.provide(CoreInjectables.inject, this.createInjectFunction())\n    this.provide(CoreInjectables.dispose, this.createDisposeFunction())\n    this.provide(CoreInjectables.registry, application.registry)\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    // Prevent new resolutions during disposal\n    this.disposing = true\n\n    // Get proper disposal order using topological sort\n    const disposalOrder = this.getDisposalOrder()\n\n    // Dispose in the correct order\n    for (const injectable of disposalOrder) {\n      if (this.instances.has(injectable)) {\n        await this.disposeInjectableInstances(injectable)\n      }\n    }\n\n    this.instances.clear()\n    this.injectables.clear()\n    this.resolvers.clear()\n    this.dependants.clear()\n\n    this.disposing = false\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 (injectable.scope === Scope.Transient) {\n      throw new Error('Cannot get transient injectable directly')\n    }\n\n    if (this.instances.has(injectable)) {\n      return this.instances.get(injectable)!.at(0)!.public\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\n    this.instances.set(injectable, [\n      {\n        private: instance,\n        public: instance,\n        context: undefined,\n      },\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 (this.disposing) {\n      return Promise.reject(new Error('Cannot resolve during disposal'))\n    }\n\n    if (dependant && compareScope(dependant.scope, '<', injectable.scope)) {\n      // TODO: more informative error\n      return Promise.reject(\n        new Error('Invalid scope: dependant is looser than injectable'),\n      )\n    }\n\n    if (isValueInjectable(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 { stack, label } = injectable\n\n      if (dependant) {\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      const isTransient = injectable.scope === Scope.Transient\n\n      if (!isTransient && this.instances.has(injectable)) {\n        return Promise.resolve(this.instances.get(injectable)!.at(0)!.public)\n      } else if (!isTransient && this.resolvers.has(injectable)) {\n        return this.resolvers.get(injectable)!\n      } else {\n        const isLazy = isLazyInjectable(injectable)\n\n        if (isLazy) {\n          const isOptional = isOptionalInjectable(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 {\n          const resolution = this.createResolution(injectable).finally(() => {\n            this.resolvers.delete(injectable)\n          })\n          if (injectable.scope !== Scope.Transient) {\n            this.resolvers.set(injectable, resolution)\n          }\n          return resolution\n        }\n      }\n    }\n  }\n\n  private async createResolution<T extends AnyInjectable>(\n    injectable: T,\n  ): Promise<ResolveInjectableType<T>> {\n    const { dependencies } = injectable\n    const context = await this.createInjectableContext(dependencies, injectable)\n    const wrapper = {\n      private: null as any,\n      public: null as ResolveInjectableType<T>,\n      context,\n    }\n    if (isFactoryInjectable(injectable)) {\n      wrapper.private = await Promise.resolve(\n        injectable.factory(wrapper.context),\n      )\n      wrapper.public = injectable.pick(wrapper.private)\n    } else if (isClassInjectable(injectable)) {\n      wrapper.private = new injectable(context)\n      wrapper.public = wrapper.private\n      await wrapper.private.$onCreate()\n    } else {\n      throw new Error('Invalid injectable type')\n    }\n\n    let instances = this.instances.get(injectable)\n\n    if (!instances) {\n      instances = []\n      this.instances.set(injectable, instances)\n    }\n    instances.push(wrapper)\n\n    return wrapper.public\n  }\n\n  private createInjectFunction() {\n    const inject = <T extends AnyInjectable>(\n      injectable: T,\n      context: InlineInjectionDependencies<T>,\n    ) => {\n      const dependencies: Dependencies = {\n        ...injectable.dependencies,\n      }\n\n      for (const key in context) {\n        const dep = context[key]\n        if (isInjectable(dep) || isOptionalInjectable(dep)) {\n          dependencies[key] = dep\n        } else {\n          dependencies[key] = createValueInjectable(dep)\n        }\n      }\n\n      const newInjectable = isClassInjectable(injectable)\n        ? createExtendableClassInjectable(\n            injectable,\n            dependencies,\n            Scope.Transient,\n            1,\n          )\n        : {\n            ...injectable,\n            dependencies,\n            scope: Scope.Transient,\n            stack: tryCaptureStackTrace(1),\n          }\n\n      return this.resolve(newInjectable) as Promise<ResolveInjectableType<T>>\n    }\n\n    const explicit = async <T extends AnyInjectable>(\n      injectable: T,\n      context: InlineInjectionDependencies<T>,\n    ) => {\n      if ('asyncDispose' in Symbol === false) {\n        throw new Error(\n          'Symbol.asyncDispose is not supported in this environment',\n        )\n      }\n      const instance = await inject(injectable, context)\n      const dispose = this.createDisposeFunction()\n      return Object.assign(instance, {\n        [Symbol.asyncDispose]: async () => {\n          await dispose(injectable, instance)\n        },\n      })\n    }\n\n    return Object.assign(inject, { explicit })\n  }\n\n  private createDisposeFunction() {\n    return async <T extends AnyInjectable>(injectable: T, instance?: any) => {\n      if (injectable.scope === Scope.Transient) {\n        assert(\n          instance,\n          'Instance is required for transient injectable disposal',\n        )\n        const wrappers = this.instances.get(injectable)\n        if (wrappers) {\n          for (const wrapper of wrappers) {\n            if (wrapper.public === instance) {\n              await this.disposeInjectableInstance(\n                injectable,\n                wrapper.private,\n                wrapper.context,\n              )\n              const index = wrappers.indexOf(wrapper)\n              wrappers.splice(index, 1)\n            }\n          }\n\n          if (wrappers.length === 0) {\n            this.instances.delete(injectable)\n          }\n        }\n      } else {\n        await this.disposeInjectableInstances(injectable)\n      }\n    }\n  }\n\n  private getDisposalOrder(): AnyInjectable[] {\n    const visited = new Set<AnyInjectable>()\n    const result: AnyInjectable[] = []\n\n    const visit = (injectable: AnyInjectable) => {\n      if (visited.has(injectable)) return\n      visited.add(injectable)\n\n      const dependants = this.dependants.get(injectable)\n      if (dependants) {\n        for (const dependant of dependants) {\n          if (this.instances.has(dependant)) {\n            visit(dependant)\n          }\n        }\n      }\n\n      // Only add to result if this container owns the instance\n      if (this.instances.has(injectable)) {\n        result.push(injectable)\n      }\n    }\n\n    for (const injectable of this.instances.keys()) {\n      visit(injectable)\n    }\n\n    return result\n  }\n\n  private async disposeInjectableInstances(injectable: AnyInjectable) {\n    try {\n      if (this.instances.has(injectable)) {\n        const wrappers = this.instances.get(injectable)!\n        await Promise.all(\n          wrappers.map((wrapper) =>\n            this.disposeInjectableInstance(\n              injectable,\n              wrapper.private,\n              wrapper.context,\n            ),\n          ),\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  private async disposeInjectableInstance(\n    injectable: AnyInjectable,\n    instance: any,\n    context: any,\n  ) {\n    if (isFactoryInjectable(injectable)) {\n      const { dispose } = injectable\n      if (dispose) await dispose(instance, context)\n    } else if (isClassInjectable(injectable)) {\n      await instance.$onDispose()\n    }\n  }\n}\n\ntype InlineInjectionDependencies<T extends AnyInjectable> = {\n  [K in keyof T['dependencies']]?:\n    | ResolveInjectableType<T['dependencies'][K]>\n    | AnyInjectable<ResolveInjectableType<T['dependencies'][K]>>\n}\n\nexport type InjectFn = ReturnType<Container['createInjectFunction']>\nexport type DisposeFn = ReturnType<Container['createDisposeFunction']>\n"],"version":3,"file":"container.js"}

package/dist/enums.js.map

@@ -1 +0,0 @@
-{"mappings":"AAAA,OAAO,IAAK,wCAAL;AACL;AACA;AACA;AACA;;AACD;AAED,OAAO,IAAK,sCAAL;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AACD","names":[],"sources":["../src/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"],"version":3,"file":"enums.js"}

package/dist/hooks.js.map

@@ -1 +0,0 @@
-{"mappings":"AACA,SAAS,uBAAuB,gBAAgB;AAuBhD,OAAO,MAAM,MAAM;CACjB,OAAO,MAAMA,MAAaC,IAAW;AACnC,OAAK,MAAM,CAAC,MAAM,UAAU,IAAI,KAAK,kBAAkB;AACrD,QAAK,MAAM,YAAY,WAAW;AAChC,OAAG,IAAI,MAAM,SAAS;GACvB;EACF;CACF;CAED,CAAC,mBAAmB,IAAI;CAExB,IAAIC,MAAcC,UAAoB;EACpC,IAAI,QAAQ,KAAK,iBAAiB,IAAI,KAAK;AAC3C,OAAK,MAAO,MAAK,iBAAiB,IAAI,MAAO,QAAQ,IAAI,MAAO;AAChE,QAAM,IAAI,SAAS;AACnB,SAAO,MAAM,KAAK,OAAO,MAAM,SAAS;CACzC;CAED,OAAOD,MAAcC,UAAoB;EACvC,MAAM,QAAQ,KAAK,iBAAiB,IAAI,KAAK;AAC7C,MAAI,MAAO,OAAM,OAAO,SAAS;CAClC;CAED,MAAM,KACJC,MACAC,SACA,GAAG,MACH;EACA,MAAM,EAAE,aAAa,MAAM,UAAU,OAAO,GAAG,WAAW,CAAE;EAC5D,MAAM,QAAQ,KAAK,iBAAiB,IAAI,KAAK;AAC7C,OAAK,MAAO;EACZ,MAAM,WAAW,MAAM,KAAK,MAAM;AAClC,MAAI,YAAY;AACd,SAAM,QAAQ,IAAI,SAAS,IAAI,CAAC,SAAS,KAAK,GAAG,KAAK,CAAC,CAAC;EACzD,OAAM;AACL,OAAI,QAAS,UAAS,SAAS;AAC/B,QAAK,MAAM,QAAQ,SAAU,OAAM,KAAK,GAAG,KAAK;EACjD;CACF;CAED,QAAQ;AACN,OAAK,iBAAiB,OAAO;CAC9B;AACF;AAED,OAAO,MAAM,mBAAmB,CAACC,UAC9B,gBAAgB,KAAK","names":["from: Hooks","to: Hooks","name: string","callback: Callback","name: T","options: { concurrent?: boolean; reverse?: boolean } | undefined","hook: Hook | (object & string)"],"sources":["../src/hooks.ts"],"sourcesContent":["import type { Callback } from '../../common/src/index.ts'\nimport { kHookCollection } from './constants.ts'\nimport type { Hook } from './enums.ts'\n\n// import type { HookType } from './types.ts'\n\nexport interface HookType {\n  [key: string]: (...args: any[]) => any\n  // [Hook.AfterInitialize]: () => any\n  // [Hook.BeforeStart]: () => any\n  // [Hook.AfterStart]: () => any\n  // [Hook.BeforeStop]: () => any\n  // [Hook.AfterStop]: () => any\n  // [Hook.BeforeTerminate]: () => any\n  // [Hook.AfterTerminate]: () => any\n  // [Hook.OnConnect]: (...args: any[]) => any\n  // [Hook.OnDisconnect]: (...args: any[]) => any\n}\n\nexport type CallHook<T extends string> = (\n  hook: T,\n  ...args: T extends keyof HookType ? Parameters<HookType[T]> : any[]\n) => Promise<void>\n\nexport class Hooks {\n  static merge(from: Hooks, to: Hooks) {\n    for (const [name, callbacks] of from[kHookCollection]) {\n      for (const callback of callbacks) {\n        to.add(name, callback)\n      }\n    }\n  }\n\n  [kHookCollection] = new Map<string, Set<Callback>>()\n\n  add(name: string, callback: Callback) {\n    let hooks = this[kHookCollection].get(name)\n    if (!hooks) this[kHookCollection].set(name, (hooks = new Set()))\n    hooks.add(callback)\n    return () => this.remove(name, callback)\n  }\n\n  remove(name: string, callback: Callback) {\n    const hooks = this[kHookCollection].get(name)\n    if (hooks) hooks.delete(callback)\n  }\n\n  async call<T extends string | Hook>(\n    name: T,\n    options: { concurrent?: boolean; reverse?: boolean } | undefined,\n    ...args: T extends Hook ? Parameters<HookType[T]> : any[]\n  ) {\n    const { concurrent = true, reverse = false } = options ?? {}\n    const hooks = this[kHookCollection].get(name)\n    if (!hooks) return\n    const hooksArr = Array.from(hooks)\n    if (concurrent) {\n      await Promise.all(hooksArr.map((hook) => hook(...args)))\n    } else {\n      if (reverse) hooksArr.reverse()\n      for (const hook of hooksArr) await hook(...args)\n    }\n  }\n\n  clear() {\n    this[kHookCollection].clear()\n  }\n}\n\nexport const createErrForHook = (hook: Hook | (object & string)) =>\n  `Error during [${hook}] hook`\n"],"version":3,"file":"hooks.js"}

package/dist/index.js.map

@@ -1 +0,0 @@
-{"mappings":"AAAA,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc","names":[],"sources":["../src/index.ts"],"sourcesContent":["export * from './constants.ts'\nexport * from './container.ts'\nexport * from './enums.ts'\nexport * from './hooks.ts'\nexport * from './injectables.ts'\nexport * from './logger.ts'\nexport * from './metadata.ts'\nexport * from './plugin.ts'\nexport * from './registry.ts'\nexport * from './types.ts'\nexport * from './utils/index.ts'\n"],"version":3,"file":"index.js"}