@nmtjs/core 0.6.0

package/LICENSE.md

@@ -0,0 +1,7 @@
+Copyright (c) 2024 Denis Ilchyshyn
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,9 @@
+# NeemataJS - RPC application server for real-time applications (proof of concept)
+
+### Built with following in mind:
+- transport-agnostic (like WebSockets, WebTransport, .etc)
+- format-agnostic (like JSON, MessagePack, BSON, .etc)
+- binary data streaming and event subscriptions
+- contract-based API
+- end-to-end type safety
+- CPU-intensive task execution on separate workers

package/dist/index.js

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

package/dist/index.js.map

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

package/dist/lib/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/lib/constants.js.map

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

@@ -0,0 +1,275 @@
+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,
+            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).instance);
+            } 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 })=>{
+                    if (compareScope(this.scope, '>=', scope)) this.instances.set(injectable, {
+                        instance,
+                        context
+                    });
+                    if (scope !== Scope.Transient) this.resolvers.delete(injectable);
+                    return instance;
+                });
+                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 markOptional(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,
+        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

@@ -0,0 +1 @@
+{"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 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> extends Dependant<D> {\n  scope: S\n  factory(context: DependencyContext<D>): Async<T>\n  dispose?(instance: T, context: DependencyContext<D>): any\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<AnyInjectable, { instance: any; context: any }>()\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, { instance, context: undefined })\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)!.instance)\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            if (compareScope(this.scope, '>=', scope))\n              this.instances.set(injectable, { instance, context })\n            if (scope !== Scope.Transient) this.resolvers.delete(injectable)\n            return instance\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 markOptional<T extends AnyInjectable>(injectable: T) {\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>(\n  paramsOrFactory:\n    | {\n        dependencies?: D\n        scope?: S\n        factory: InjectableFactoryType<T, D>\n        dispose?: InjectableDisposeType<T, D>\n      }\n    | InjectableFactoryType<T, D>,\n  label?: string,\n): FactoryInjectable<T, D, S> {\n  const isFactory = typeof paramsOrFactory === 'function'\n  const params = isFactory\n    ? {\n        factory: paramsOrFactory,\n      }\n    : 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    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)\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","context","undefined","satisfies","checkIsValueInjectable","stack","label","isLazy","checkIsLazyInjectable","isOptional","checkIsOptional","reject","checkIsFactoryInjectable","resolution","factory","cause","error","left","operator","right","leftScope","rightScope","checkIsInjectable","getInjectableScope","dependencyScope","markOptional","createLazyInjectable","createValueInjectable","createFactoryInjectable","paramsOrFactory","isFactory","params","actualScope"],"mappings":"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"}

package/dist/lib/enums.js

@@ -0,0 +1,20 @@
+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

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

package/dist/lib/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/lib/hooks.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../lib/hooks.ts"],"sourcesContent":["import type { Callback } from '@nmtjs/common'\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"],"names":["kHookCollection","Hooks","merge","from","to","name","callbacks","callback","add","Map","hooks","get","set","Set","remove","delete","call","options","args","concurrent","reverse","hooksArr","Array","Promise","all","map","hook","clear","createErrForHook"],"mappings":"AACA,SAASA,eAAe,QAAQ,iBAAgB;AAsBhD,OAAO,MAAMC;IACX,OAAOC,MAAMC,IAAW,EAAEC,EAAS,EAAE;QACnC,KAAK,MAAM,CAACC,MAAMC,UAAU,IAAIH,IAAI,CAACH,gBAAgB,CAAE;YACrD,KAAK,MAAMO,YAAYD,UAAW;gBAChCF,GAAGI,GAAG,CAACH,MAAME;YACf;QACF;IACF;IAEA,CAACP,gBAAgB,GAAG,IAAIS,MAA4B;IAEpDD,IAAIH,IAAY,EAAEE,QAAkB,EAAE;QACpC,IAAIG,QAAQ,IAAI,CAACV,gBAAgB,CAACW,GAAG,CAACN;QACtC,IAAI,CAACK,OAAO,IAAI,CAACV,gBAAgB,CAACY,GAAG,CAACP,MAAOK,QAAQ,IAAIG;QACzDH,MAAMF,GAAG,CAACD;QACV,OAAO,IAAM,IAAI,CAACO,MAAM,CAACT,MAAME;IACjC;IAEAO,OAAOT,IAAY,EAAEE,QAAkB,EAAE;QACvC,MAAMG,QAAQ,IAAI,CAACV,gBAAgB,CAACW,GAAG,CAACN;QACxC,IAAIK,OAAOA,MAAMK,MAAM,CAACR;IAC1B;IAEA,MAAMS,KACJX,IAAO,EACPY,OAAgE,EAChE,GAAGC,IAAsD,EACzD;QACA,MAAM,EAAEC,aAAa,IAAI,EAAEC,UAAU,KAAK,EAAE,GAAGH,WAAW,CAAC;QAC3D,MAAMP,QAAQ,IAAI,CAACV,gBAAgB,CAACW,GAAG,CAACN;QACxC,IAAI,CAACK,OAAO;QACZ,MAAMW,WAAWC,MAAMnB,IAAI,CAACO;QAC5B,IAAIS,YAAY;YACd,MAAMI,QAAQC,GAAG,CAACH,SAASI,GAAG,CAAC,CAACC,OAASA,QAAQR;QACnD,OAAO;YACL,IAAIE,SAASC,SAASD,OAAO;YAC7B,KAAK,MAAMM,QAAQL,SAAU,MAAMK,QAAQR;QAC7C;IACF;IAEAS,QAAQ;QACN,IAAI,CAAC3B,gBAAgB,CAAC2B,KAAK;IAC7B;AACF;AAEA,OAAO,MAAMC,mBAAmB,CAACF,OAC/B,CAAC,cAAc,EAAEA,KAAK,MAAM,CAAC,CAAA"}

package/dist/lib/injectables.js

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

package/dist/lib/injectables.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../lib/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"],"names":["createLazyInjectable","Scope","logger","Global","CoreInjectables"],"mappings":"AAAA,SAASA,oBAAoB,QAAQ,iBAAgB;AACrD,SAASC,KAAK,QAAQ,aAAY;AAGlC,MAAMC,SAASF,qBAA6BC,MAAME,MAAM,EAAE;AAE1D,OAAO,MAAMC,kBAAkB;IAAEF;AAAO,EAAC"}

package/dist/lib/logger.js

@@ -0,0 +1,72 @@
+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/lib/logger.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../lib/logger.ts"],"sourcesContent":["import { threadId } from 'node:worker_threads'\nimport {\n  type DestinationStream,\n  type Level,\n  type Logger as PinoLogger,\n  type StreamEntry,\n  pino,\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"],"names":["threadId","pino","stdTimeFunctions","build","pretty","bg","value","color","fg","levelColors","Number","POSITIVE_INFINITY","messageColors","levelLabels","createLogger","options","$group","destinations","pinoOptions","length","createConsolePrettyDestination","lowestLevelValue","reduce","acc","destination","Math","min","levels","values","level","labels","timestamp","isoTime","multistream","child","$threadId","sync","stream","colorize","ignore","errorLikeObjectKeys","messageFormat","log","messageKey","group","msg","thread","customPrettifiers"],"mappings":"AAAA,SAASA,QAAQ,QAAQ,sBAAqB;AAC9C,SAKEC,IAAI,EACJC,gBAAgB,QACX,OAAM;AACb,SAASC,SAASC,MAAM,QAAQ,cAAa;AAS7C,MAAMC,KAAK,CAACC,OAAOC,QAAU,CAAC,KAAK,EAAEA,MAAM,CAAC,EAAED,MAAM,OAAO,CAAC;AAC5D,MAAME,KAAK,CAACF,OAAOC,QAAU,CAAC,UAAU,EAAEA,MAAM,CAAC,EAAED,MAAM,OAAO,CAAC;AAEjE,MAAMG,cAAc;IAClB,IAAI;IACJ,IAAI;IACJ,IAAI;IACJ,IAAI;IACJ,IAAI;IACJ,IAAI;IACJ,CAACC,OAAOC,iBAAiB,CAAC,EAAE;AAC9B;AACA,MAAMC,gBAAgB;IACpB,IAAI;IACJ,IAAI;IACJ,IAAI;IACJ,IAAI;IACJ,IAAI;IACJ,IAAI;IACJ,CAACF,OAAOC,iBAAiB,CAAC,EAAE;AAC9B;AAEA,MAAME,cAAc;IAClB,IAAI;IACJ,IAAI;IACJ,IAAI;IACJ,IAAI;IACJ,IAAI;IACJ,IAAI;IACJ,CAACH,OAAOC,iBAAiB,CAAC,EAAE;AAC9B;AAEA,OAAO,MAAMG,eAAe,CAACC,UAA0B,CAAC,CAAC,EAAEC;IACzD,IAAI,EAAEC,YAAY,EAAEC,WAAW,EAAE,GAAGH;IAEpC,IAAI,CAACE,gBAAgB,CAACA,cAAcE,QAAQ;QAC1CF,eAAe;YAACG,+BAA+B;SAAQ;IACzD;IAEA,MAAMC,mBAAmBJ,aAAcK,MAAM,CAC3C,CAACC,KAAKC,cACJC,KAAKC,GAAG,CACNH,KACA,YAAYC,cACRvB,KAAK0B,MAAM,CAACC,MAAM,CAACJ,YAAYK,KAAK,CAAE,GACtCnB,OAAOC,iBAAiB,GAEhCD,OAAOC,iBAAiB;IAE1B,MAAMkB,QAAQ5B,KAAK0B,MAAM,CAACG,MAAM,CAACT,iBAAiB;IAClD,OAAOpB,KACL;QACE8B,WAAW7B,iBAAiB8B,OAAO;QACnC,GAAGd,WAAW;QACdW;IACF,GACA5B,KAAKgC,WAAW,CAAChB,eACjBiB,KAAK,CAAC;QAAElB;QAAQmB,WAAWnC;IAAS;AACxC,EAAC;AAED,OAAO,MAAMoB,iCAAiC,CAC5CS,OACAO,OAAO,IAAI,GACM,CAAA;QACjBP;QACAQ,QAAQjC,OAAO;YACbkC,UAAU;YACVC,QAAQ;YACRC,qBAAqB;gBAAC;gBAAO;gBAAS;aAAQ;YAC9CC,eAAe,CAACC,KAAKC;gBACnB,MAAMC,QAAQpC,GAAG,CAAC,CAAC,EAAEkC,IAAI1B,MAAM,CAAC,CAAC,CAAC,EAAE;gBACpC,MAAM6B,MAAMrC,GAAGkC,GAAG,CAACC,WAAW,EAAE/B,aAAa,CAAC8B,IAAIb,KAAK,CAAW;gBAClE,MAAMiB,SAAStC,GAAG,CAAC,QAAQ,EAAEkC,IAAIP,SAAS,CAAC,CAAC,CAAC,EAAE;gBAC/C,OAAO,CAAC,OAAO,EAAEW,OAAO,CAAC,EAAEF,MAAM,CAAC,EAAEC,IAAI,CAAC;YAC3C;YACAE,mBAAmB;gBACjBlB,OAAO,CAACA,QAAexB,GAAGQ,WAAW,CAACgB,MAAM,EAAEpB,WAAW,CAACoB,MAAM;YAClE;YACAO;QACF;IACF,CAAA,EAAE"}

package/dist/lib/plugin.js

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

package/dist/lib/plugin.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../lib/plugin.ts"],"sourcesContent":["import type { Async } from '@nmtjs/common'\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"],"names":["kPlugin","createPlugin","name","init"],"mappings":"AACA,SAASA,OAAO,QAAQ,iBAAgB;AAoBxC,OAAO,MAAMC,eAAe,CAC1BC,MACAC,OAC2B,CAAA;QAAED;QAAMC;QAAM,CAACH,QAAQ,EAAE;IAAK,CAAA,EAAE"}

package/dist/lib/registry.js

@@ -0,0 +1,25 @@
+import { getInjectableScope } from "./container.js";
+import { Scope } from "./enums.js";
+import { Hooks } from "./hooks.js";
+export class Registry {
+    application;
+    hooks;
+    constructor(application){
+        this.application = application;
+        this.hooks = new Hooks();
+    }
+    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/lib/registry.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../lib/registry.ts"],"sourcesContent":["import {\n  type AnyInjectable,\n  type Dependant,\n  getInjectableScope,\n} from './container.ts'\nimport { type Hook, Scope } from './enums.ts'\nimport { type HookType, Hooks } 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"],"names":["getInjectableScope","Scope","Hooks","Registry","hooks","constructor","application","registerHooks","merge","registerHook","name","callback","add","getDependants","clear","scopeErrorMessage","scope","Global","hasInvalidScopeDeps","injectables","some","injectable"],"mappings":"AAAA,SAGEA,kBAAkB,QACb,iBAAgB;AACvB,SAAoBC,KAAK,QAAQ,aAAY;AAC7C,SAAwBC,KAAK,QAAQ,aAAY;AAGjD,OAAO,MAAMC;;IACFC,MAAmB;IAE5BC,YACE,AAAmBC,WAElB,CACD;aAHmBA,cAAAA;aAHZF,QAAQ,IAAIF;IAMlB;IAEHK,cAA+BH,KAAQ,EAAE;QACvCF,MAAMM,KAAK,CAACJ,OAAO,IAAI,CAACA,KAAK;IAC/B;IAEAK,aAA6BC,IAAO,EAAEC,QAAqB,EAAE;QAC3D,IAAI,CAACP,KAAK,CAACQ,GAAG,CAACF,MAAMC;IACvB;IAEA,CAACE,gBAAsC,CAAC;IAExCC,QAAQ;QACN,IAAI,CAACV,KAAK,CAACU,KAAK;IAClB;AACF;AAEA,OAAO,MAAMC,oBAAoB,CAACL,MAAMM,QAAQf,MAAMgB,MAAM,GAC1D,CAAC,EAAEP,KAAK,WAAW,EAAEM,MAAM,0CAA0C,CAAC,CAAA;AAExE,OAAO,SAASE,oBACdC,WAA4B,EAC5BH,QAAQf,MAAMgB,MAAM;IAEpB,OAAOE,YAAYC,IAAI,CACrB,CAACC,aAAerB,mBAAmBqB,gBAAgBL;AAEvD"}

package/dist/lib/types.js

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

package/dist/lib/types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../lib/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"],"names":[],"mappings":"AAYA,WAAoE"}

package/dist/lib/utils/functions.js

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