@nmtjs/core 0.6.4 → 0.7.0

package/dist/constants.js

@@ -0,0 +1,9 @@
+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/constants.js.map

@@ -0,0 +1 @@
+{"mappings":"AAEA,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,YAA2B,OAAO,IAAI,sBAAsB;AAGzE,OAAO,MAAMC,kBAAiC,OAAO,IACnD,4BACD;AAGD,OAAO,MAAMC,UAAyB,OAAO,IAAI,oBAAoB;AAErE,OAAO,MAAM,WAAW,CAACC,UAAgC,WAAW","names":["kOptionalDependency: unique symbol","kInjectable: unique symbol","kLazyInjectable: unique symbol","kValueInjectable: unique symbol","kFactoryInjectable: unique symbol","kProvider: unique symbol","kHookCollection: unique symbol","kPlugin: unique symbol","value: any"],"sources":["src/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"],"version":3}

package/dist/container.js

@@ -0,0 +1,261 @@
+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 {
+	instances = new Map();
+	resolvers = new Map();
+	injectables = new Set();
+	dependants = new Map();
+	constructor(application, scope = Scope.Global, parent) {
+		this.application = application;
+		this.scope = scope;
+		this.parent = parent;
+		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/container.js.map

@@ -0,0 +1 @@
+{"mappings":"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","names":["application: {\n      registry: Registry\n      logger: Logger\n    }","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>","left: Scope","operator: '>' | '<' | '>=' | '<=' | '=' | '!='","right: Scope","injectable: any","dependency: Depedency","label?: string","value: T","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>","instance: P"],"sources":["src/container.ts"],"sourcesContent":["import { type Async, 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, any>\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      // TODO: more informative error\n      throw new Error('Invalid scope: dependant is looser than injectable')\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"],"version":3}

package/dist/enums.js

@@ -0,0 +1,20 @@
+export let Scope = /* @__PURE__ */ function(Scope) {
+	Scope["Global"] = "Global";
+	Scope["Connection"] = "Connection";
+	Scope["Call"] = "Call";
+	Scope["Transient"] = "Transient";
+	return Scope;
+}({});
+export let Hook = /* @__PURE__ */ 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";
+	return Hook;
+}({});

package/dist/enums.js.map

@@ -0,0 +1 @@
+{"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}

package/dist/hooks.js

@@ -0,0 +1,37 @@
+import { kHookCollection } from "./constants.js";
+export class Hooks {
+	static merge(from, to) {
+		for (const [name, callbacks] of from[kHookCollection]) {
+			for (const callback of callbacks) {
+				to.add(name, callback);
+			}
+		}
+	}
+	[kHookCollection] = new Map();
+	add(name, callback) {
+		let hooks = this[kHookCollection].get(name);
+		if (!hooks) this[kHookCollection].set(name, hooks = new Set());
+		hooks.add(callback);
+		return () => this.remove(name, callback);
+	}
+	remove(name, callback) {
+		const hooks = this[kHookCollection].get(name);
+		if (hooks) hooks.delete(callback);
+	}
+	async call(name, options, ...args) {
+		const { concurrent = true, reverse = false } = options ?? {};
+		const hooks = this[kHookCollection].get(name);
+		if (!hooks) return;
+		const hooksArr = Array.from(hooks);
+		if (concurrent) {
+			await Promise.all(hooksArr.map((hook) => hook(...args)));
+		} else {
+			if (reverse) hooksArr.reverse();
+			for (const hook of hooksArr) await hook(...args);
+		}
+	}
+	clear() {
+		this[kHookCollection].clear();
+	}
+}
+export const createErrForHook = (hook) => `Error during [${hook}] hook`;

package/dist/hooks.js.map

@@ -0,0 +1 @@
+{"mappings":"AACA,SAAS,uBAAuB,gBAAgB;AAsBhD,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// 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}

package/dist/index.js

@@ -1,11 +1,11 @@
-export * from "./lib/constants.js";
-export * from "./lib/container.js";
-export * from "./lib/enums.js";
-export * from "./lib/hooks.js";
-export * from "./lib/injectables.js";
-export * from "./lib/logger.js";
-export * from "./lib/plugin.js";
-export * from "./lib/registry.js";
-export * from "./lib/types.js";
-export * from "./lib/types.js";
-export * from "./lib/utils/index.js";
+export * from "./constants.js";
+export * from "./container.js";
+export * from "./enums.js";
+export * from "./hooks.js";
+export * from "./injectables.js";
+export * from "./logger.js";
+export * from "./plugin.js";
+export * from "./registry.js";
+export * from "./types.js";
+export * from "./types.js";
+export * from "./utils/index.js";

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../index.ts"],"sourcesContent":["export * from './lib/constants.ts'\nexport * from './lib/container.ts'\nexport * from './lib/enums.ts'\nexport * from './lib/hooks.ts'\nexport * from './lib/injectables.ts'\nexport * from './lib/logger.ts'\nexport * from './lib/plugin.ts'\nexport * from './lib/registry.ts'\nexport * from './lib/types.ts'\nexport * from './lib/types.ts'\nexport * from './lib/utils/index.ts'\n"],"names":[],"mappings":"AAAA,cAAc,qBAAoB;AAClC,cAAc,qBAAoB;AAClC,cAAc,iBAAgB;AAC9B,cAAc,iBAAgB;AAC9B,cAAc,uBAAsB;AACpC,cAAc,kBAAiB;AAC/B,cAAc,kBAAiB;AAC/B,cAAc,oBAAmB;AACjC,cAAc,iBAAgB;AAC9B,cAAc,iBAAgB;AAC9B,cAAc,uBAAsB"}
+{"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 './plugin.ts'\nexport * from './registry.ts'\nexport * from './types.ts'\nexport * from './types.ts'\nexport * from './utils/index.ts'\n"],"version":3}

package/dist/injectables.js

@@ -0,0 +1,4 @@
+import { createLazyInjectable } from "./container.js";
+import { Scope } from "./enums.js";
+const logger = createLazyInjectable(Scope.Global, "Logger");
+export const CoreInjectables = { logger };

package/dist/injectables.js.map

@@ -0,0 +1 @@
+{"mappings":"AAAA,SAAS,4BAA4B,gBAAgB;AACrD,SAAS,aAAa,YAAY;AAGlC,MAAM,SAAS,qBAA6B,MAAM,QAAQ,SAAS;AAEnE,OAAO,MAAM,kBAAkB,EAAE,OAAQ","names":[],"sources":["src/injectables.ts"],"sourcesContent":["import { createLazyInjectable } from './container.ts'\nimport { Scope } from './enums.ts'\nimport type { Logger } from './logger.ts'\n\nconst logger = createLazyInjectable<Logger>(Scope.Global, 'Logger')\n\nexport const CoreInjectables = { logger }\n"],"version":3}

package/dist/logger.js

@@ -0,0 +1,68 @@
+import { threadId } from "node:worker_threads";
+import { pino, stdTimeFunctions } from "pino";
+import { build as pretty } from "pino-pretty";
+const bg = (value, color) => `\x1b[${color}m${value}\x1b[0m`;
+const fg = (value, color) => `\x1b[38;5;${color}m${value}\x1b[0m`;
+const levelColors = {
+	10: 100,
+	20: 102,
+	30: 106,
+	40: 104,
+	50: 101,
+	60: 105,
+	[Number.POSITIVE_INFINITY]: 0
+};
+const messageColors = {
+	10: 0,
+	20: 2,
+	30: 6,
+	40: 4,
+	50: 1,
+	60: 5,
+	[Number.POSITIVE_INFINITY]: 0
+};
+const levelLabels = {
+	10: " TRACE ",
+	20: " DEBUG ",
+	30: " INFO  ",
+	40: " WARN  ",
+	50: " ERROR ",
+	60: " FATAL ",
+	[Number.POSITIVE_INFINITY]: "SILENT"
+};
+export const createLogger = (options = {}, $group) => {
+	let { destinations, pinoOptions } = options;
+	if (!destinations || !destinations?.length) {
+		destinations = [createConsolePrettyDestination("info")];
+	}
+	const lowestLevelValue = destinations.reduce((acc, destination) => Math.min(acc, "stream" in destination ? pino.levels.values[destination.level] : Number.POSITIVE_INFINITY), Number.POSITIVE_INFINITY);
+	const level = pino.levels.labels[lowestLevelValue];
+	return pino({
+		timestamp: stdTimeFunctions.isoTime,
+		...pinoOptions,
+		level
+	}, pino.multistream(destinations)).child({
+		$group,
+		$threadId: threadId
+	});
+};
+export const createConsolePrettyDestination = (level, sync = true) => ({
+	level,
+	stream: pretty({
+		colorize: true,
+		ignore: "hostname,$group,$threadId",
+		errorLikeObjectKeys: [
+			"err",
+			"error",
+			"cause"
+		],
+		messageFormat: (log, messageKey) => {
+			const group = fg(`[${log.$group}]`, 11);
+			const msg = fg(log[messageKey], messageColors[log.level]);
+			const thread = fg(`(Thread-${log.$threadId})`, 89);
+			return `\x1b[0m${thread} ${group} ${msg}`;
+		},
+		customPrettifiers: { level: (level) => bg(levelLabels[level], levelColors[level]) },
+		sync
+	})
+});

package/dist/logger.js.map

@@ -0,0 +1 @@
+{"mappings":"AAAA,SAAS,gBAAgB,qBAAqB;AAC9C,SAIE,MAEA,wBACK,MAAM;AACb,SAAS,SAAS,cAAc,aAAa;AAS7C,MAAM,KAAK,CAAC,OAAO,WAAW,OAAO,MAAM,GAAG,MAAM;AACpD,MAAM,KAAK,CAAC,OAAO,WAAW,YAAY,MAAM,GAAG,MAAM;AAEzD,MAAM,cAAc;CAClB,IAAI;CACJ,IAAI;CACJ,IAAI;CACJ,IAAI;CACJ,IAAI;CACJ,IAAI;EACH,OAAO,oBAAoB;AAC7B;AACD,MAAM,gBAAgB;CACpB,IAAI;CACJ,IAAI;CACJ,IAAI;CACJ,IAAI;CACJ,IAAI;CACJ,IAAI;EACH,OAAO,oBAAoB;AAC7B;AAED,MAAM,cAAc;CAClB,IAAI;CACJ,IAAI;CACJ,IAAI;CACJ,IAAI;CACJ,IAAI;CACJ,IAAI;EACH,OAAO,oBAAoB;AAC7B;AAED,OAAO,MAAM,eAAe,CAACA,UAA0B,CAAE,GAAEC,WAAmB;CAC5E,IAAI,EAAE,cAAc,aAAa,GAAG;AAEpC,MAAK,iBAAiB,cAAc,QAAQ;AAC1C,iBAAe,CAAC,+BAA+B,OAAO,AAAC;CACxD;CAED,MAAM,mBAAmB,aAAc,OACrC,CAAC,KAAK,gBACJ,KAAK,IACH,KACA,YAAY,cACR,KAAK,OAAO,OAAO,YAAY,SAC/B,OAAO,kBACZ,EACH,OAAO,kBACR;CACD,MAAM,QAAQ,KAAK,OAAO,OAAO;AACjC,QAAO,KACL;EACE,WAAW,iBAAiB;EAC5B,GAAG;EACH;CACD,GACD,KAAK,YAAY,aAAc,CAChC,CAAC,MAAM;EAAE;EAAQ,WAAW;CAAU,EAAC;AACzC;AAED,OAAO,MAAM,iCAAiC,CAC5CC,OACA,OAAO,UACU;CACjB;CACA,QAAQ,OAAO;EACb,UAAU;EACV,QAAQ;EACR,qBAAqB;GAAC;GAAO;GAAS;EAAQ;EAC9C,eAAe,CAAC,KAAK,eAAe;GAClC,MAAM,QAAQ,IAAI,GAAG,IAAI,OAAO,IAAI,GAAG;GACvC,MAAM,MAAM,GAAG,IAAI,aAAa,cAAc,IAAI,OAAiB;GACnE,MAAM,SAAS,IAAI,UAAU,IAAI,UAAU,IAAI,GAAG;AAClD,WAAQ,SAAS,OAAO,GAAG,MAAM,GAAG,IAAI;EACzC;EACD,mBAAmB,EACjB,OAAO,CAACC,UAAe,GAAG,YAAY,QAAQ,YAAY,OAAO,CAClE;EACD;CACD,EAAC;AACH","names":["options: LoggingOptions","$group: string","level: Level","level: any"],"sources":["src/logger.ts"],"sourcesContent":["import { threadId } from 'node:worker_threads'\nimport {\n  type DestinationStream,\n  type Level,\n  type Logger as PinoLogger,\n  pino,\n  type StreamEntry,\n  stdTimeFunctions,\n} from 'pino'\nimport { build as pretty } from 'pino-pretty'\n\nexport type Logger = PinoLogger\nexport type LoggingOptions = {\n  destinations?: Array<DestinationStream | StreamEntry<Level>>\n  pinoOptions?: any\n}\n\n// TODO: use node:util inspect\nconst bg = (value, color) => `\\x1b[${color}m${value}\\x1b[0m`\nconst fg = (value, color) => `\\x1b[38;5;${color}m${value}\\x1b[0m`\n\nconst levelColors = {\n  10: 100,\n  20: 102,\n  30: 106,\n  40: 104,\n  50: 101,\n  60: 105,\n  [Number.POSITIVE_INFINITY]: 0,\n}\nconst messageColors = {\n  10: 0,\n  20: 2,\n  30: 6,\n  40: 4,\n  50: 1,\n  60: 5,\n  [Number.POSITIVE_INFINITY]: 0,\n}\n\nconst levelLabels = {\n  10: ' TRACE ',\n  20: ' DEBUG ',\n  30: ' INFO  ',\n  40: ' WARN  ',\n  50: ' ERROR ',\n  60: ' FATAL ',\n  [Number.POSITIVE_INFINITY]: 'SILENT',\n}\n\nexport const createLogger = (options: LoggingOptions = {}, $group: string) => {\n  let { destinations, pinoOptions } = options\n\n  if (!destinations || !destinations?.length) {\n    destinations = [createConsolePrettyDestination('info')]\n  }\n\n  const lowestLevelValue = destinations!.reduce(\n    (acc, destination) =>\n      Math.min(\n        acc,\n        'stream' in destination\n          ? pino.levels.values[destination.level!]\n          : Number.POSITIVE_INFINITY,\n      ),\n    Number.POSITIVE_INFINITY,\n  )\n  const level = pino.levels.labels[lowestLevelValue]\n  return pino(\n    {\n      timestamp: stdTimeFunctions.isoTime,\n      ...pinoOptions,\n      level,\n    },\n    pino.multistream(destinations!),\n  ).child({ $group, $threadId: threadId })\n}\n\nexport const createConsolePrettyDestination = (\n  level: Level,\n  sync = true,\n): StreamEntry => ({\n  level,\n  stream: pretty({\n    colorize: true,\n    ignore: 'hostname,$group,$threadId',\n    errorLikeObjectKeys: ['err', 'error', 'cause'],\n    messageFormat: (log, messageKey) => {\n      const group = fg(`[${log.$group}]`, 11)\n      const msg = fg(log[messageKey], messageColors[log.level as number])\n      const thread = fg(`(Thread-${log.$threadId})`, 89)\n      return `\\x1b[0m${thread} ${group} ${msg}`\n    },\n    customPrettifiers: {\n      level: (level: any) => bg(levelLabels[level], levelColors[level]),\n    },\n    sync,\n  }),\n})\n"],"version":3}

package/dist/plugin.js

@@ -0,0 +1,6 @@
+import { kPlugin } from "./constants.js";
+export const createPlugin = (name, init) => ({
+	name,
+	init,
+	[kPlugin]: true
+});

package/dist/plugin.js.map

@@ -0,0 +1 @@
+{"mappings":"AACA,SAAS,eAAe,gBAAgB;AAoBxC,OAAO,MAAM,eAAe,CAC1BA,MACAC,UAC2B;CAAE;CAAM;EAAO,UAAU;AAAM","names":["name: string","init: Plugin<Type, Options>['init']"],"sources":["src/plugin.ts"],"sourcesContent":["import type { Async } from '../../common/src/index.ts'\nimport { kPlugin } from './constants.ts'\nimport type { PluginContext } from './types.ts'\n\nexport interface BasePlugin<\n  Type = any,\n  Options = unknown,\n  Context extends PluginContext = PluginContext,\n> {\n  name: string\n  init: (context: Context, options: Options) => Async<Type>\n}\n\nexport interface Plugin<\n  Type = void,\n  Options = unknown,\n  Context extends PluginContext = PluginContext,\n> extends BasePlugin<Type, Options, Context> {\n  [kPlugin]: any\n}\n\nexport const createPlugin = <Options = unknown, Type = void>(\n  name: string,\n  init: Plugin<Type, Options>['init'],\n): Plugin<Type, Options> => ({ name, init, [kPlugin]: true })\n"],"version":3}

package/dist/registry.js

@@ -0,0 +1,23 @@
+import { getInjectableScope } from "./container.js";
+import { Scope } from "./enums.js";
+import { Hooks } from "./hooks.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();
+	}
+}
+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);
+}

package/dist/registry.js.map

@@ -0,0 +1 @@
+{"mappings":"AAAA,SAGE,0BACK,gBAAgB;AACvB,SAAoB,aAAa,YAAY;AAC7C,SAAS,aAA4B,YAAY;AAGjD,OAAO,MAAM,SAAS;CACpB,AAAS,QAAQ,IAAI;CAErB,YACqBA,aAGnB;OAHmB;CAGjB;CAEJ,cAA+BC,OAAU;AACvC,QAAM,MAAM,OAAO,KAAK,MAAM;CAC/B;CAED,aAA6BC,MAASC,UAAuB;AAC3D,OAAK,MAAM,IAAI,MAAM,SAAS;CAC/B;CAED,CAAC,gBAAsC,CAAE;CAEzC,QAAQ;AACN,OAAK,MAAM,OAAO;CACnB;AACF;AAED,OAAO,MAAM,oBAAoB,CAAC,MAAM,QAAQ,MAAM,YACnD,EAAE,KAAK,aAAa,MAAM;AAE7B,OAAO,SAAS,oBACdC,aACA,QAAQ,MAAM,QACd;AACA,QAAO,YAAY,KACjB,CAAC,eAAe,mBAAmB,WAAW,KAAK,MACpD;AACF","names":["application: {\n      logger: Logger\n    }","hooks: T","name: T","callback: HookType[T]","injectables: AnyInjectable[]"],"sources":["src/registry.ts"],"sourcesContent":["import {\n  type AnyInjectable,\n  type Dependant,\n  getInjectableScope,\n} from './container.ts'\nimport { type Hook, Scope } from './enums.ts'\nimport { Hooks, type HookType } from './hooks.ts'\nimport type { Logger } from './logger.ts'\n\nexport class Registry {\n  readonly hooks = new Hooks()\n\n  constructor(\n    protected readonly application: {\n      logger: Logger\n    },\n  ) {}\n\n  registerHooks<T extends Hooks>(hooks: T) {\n    Hooks.merge(hooks, this.hooks)\n  }\n\n  registerHook<T extends Hook>(name: T, callback: HookType[T]) {\n    this.hooks.add(name, callback)\n  }\n\n  *getDependants(): Generator<Dependant> {}\n\n  clear() {\n    this.hooks.clear()\n  }\n}\n\nexport const scopeErrorMessage = (name, scope = Scope.Global) =>\n  `${name} must be a ${scope} scope (including all nested dependencies)`\n\nexport function hasInvalidScopeDeps(\n  injectables: AnyInjectable[],\n  scope = Scope.Global,\n) {\n  return injectables.some(\n    (injectable) => getInjectableScope(injectable) !== scope,\n  )\n}\n"],"version":3}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/dist/types.js.map

@@ -0,0 +1 @@
+{"mappings":"","names":[],"sources":["src/types.ts"],"sourcesContent":["import type { Container } from './container.ts'\nimport type { Hooks } from './hooks.ts'\nimport type { Logger } from './logger.ts'\nimport type { Registry } from './registry.ts'\n\nexport interface PluginContext {\n  logger: Logger\n  registry: Registry\n  hooks: Hooks\n  container: Container\n}\n\nexport type Pattern = RegExp | string | ((value: string) => boolean)\n"],"version":3}

package/dist/utils/functions.js

@@ -0,0 +1,35 @@
+/**
+* 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);
+	}
+}
+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);
+}

package/dist/utils/functions.js.map

@@ -0,0 +1 @@
+{"mappings":";;;AAKA,OAAO,SAAS,MAAMA,OAAeC,SAAkB;AACrD,YAAW,YAAY,YAAY;AACjC,SAAO,QAAQ,MAAM;CACtB,kBAAiB,YAAY,UAAU;AACtC,MAAI,YAAY,OAAO,YAAY,MAAM;AACvC,UAAO;EACR,WAAU,QAAQ,GAAG,EAAE,KAAK,OAAO,QAAQ,IAAI,EAAE,KAAK,KAAK;AAC1D,UAAO,MAAM,SAAS,QAAQ,MAAM,IAAI,EAAE,CAAC;EAC5C,WAAU,QAAQ,IAAI,EAAE,KAAK,KAAK;AACjC,UAAO,MAAM,WAAW,QAAQ,MAAM,IAAI,EAAE,CAAC;EAC9C,WAAU,QAAQ,GAAG,EAAE,KAAK,KAAK;AAChC,UAAO,MAAM,SAAS,QAAQ,MAAM,EAAE,CAAC;EACxC,OAAM;AACL,UAAO,UAAU;EAClB;CACF,OAAM;AACL,SAAO,QAAQ,KAAK,MAAM;CAC3B;AACF;AAED,OAAO,SAAS,SAASC,MAAc;AACrC,KAAI,KAAK,SAAS,QAAQ,CAAE,QAAO;CACnC,MAAM,UAAU,KAAK,MAAM,IAAI,CAAC,MAAM,EAAE;CACxC,MAAM,MAAM,QAAQ,KAAK,IAAI;AAC7B,QAAO;EAAC;EAAM;EAAO;EAAO;EAAM;EAAO;CAAM,EAAC,SAAS,IAAI;AAC9D","names":["value: string","pattern: Pattern","name: string"],"sources":["src/utils/functions.ts"],"sourcesContent":["import type { Pattern } from '../types.ts'\n\n/**\n * Very simple pattern matching function.\n */\nexport function match(value: string, pattern: Pattern) {\n  if (typeof pattern === 'function') {\n    return pattern(value)\n  } else if (typeof pattern === 'string') {\n    if (pattern === '*' || pattern === '**') {\n      return true\n    } else if (pattern.at(0) === '*' && pattern.at(-1) === '*') {\n      return value.includes(pattern.slice(1, -1))\n    } else if (pattern.at(-1) === '*') {\n      return value.startsWith(pattern.slice(0, -1))\n    } else if (pattern.at(0) === '*') {\n      return value.endsWith(pattern.slice(1))\n    } else {\n      return value === pattern\n    }\n  } else {\n    return pattern.test(value)\n  }\n}\n\nexport function isJsFile(name: string) {\n  if (name.endsWith('.d.ts')) return false\n  const leading = name.split('.').slice(1)\n  const ext = leading.join('.')\n  return ['js', 'mjs', 'cjs', 'ts', 'mts', 'cts'].includes(ext)\n}\n"],"version":3}

package/dist/utils/index.js.map

@@ -0,0 +1 @@
+{"mappings":"AAAA,cAAc;AACd,cAAc;AACd,cAAc","names":[],"sources":["src/utils/index.ts"],"sourcesContent":["export * from './functions.ts'\nexport * from './pool.ts'\nexport * from './semaphore.ts'\n"],"version":3}