@nmtjs/core 0.13.0 → 0.14.0

package/dist/constants.d.ts

@@ -10,6 +10,10 @@ export declare const kFactoryInjectable: unique symbol;
 export type kFactoryInjectable = typeof kFactoryInjectable;
 export declare const kClassInjectable: unique symbol;
 export type kClassInjectable = typeof kClassInjectable;
+export declare const kClassInjectableCreate: unique symbol;
+export type kClassInjectableCreate = typeof kClassInjectableCreate;
+export declare const kClassInjectableDispose: unique symbol;
+export type kClassInjectableDispose = typeof kClassInjectableDispose;
 export declare const kProvider: unique symbol;
 export type kProvider = typeof kProvider;
 export declare const kHookCollection: unique symbol;

package/dist/constants.js

@@ -4,6 +4,8 @@ export const kLazyInjectable = Symbol.for('neemata:LazyInjectableKey');
 export const kValueInjectable = Symbol.for('neemata:ValueInjectableKey');
 export const kFactoryInjectable = Symbol.for('neemata:FactoryInjectableKey');
 export const kClassInjectable = Symbol.for('neemata:ClassInjectableKey');
+export const kClassInjectableCreate = Symbol.for('neemata:ClassInjectableCreateKey');
+export const kClassInjectableDispose = Symbol.for('neemata:ClassInjectableDisposeKey');
 export const kProvider = Symbol.for('neemata:ProviderKey');
 export const kHookCollection = Symbol.for('neemata:HookCollectionKey');
 export const kPlugin = Symbol.for('neemata:PluginKey');

package/dist/container.d.ts

@@ -1,7 +1,7 @@
-import { Scope } from './enums.ts';
-import { type AnyInjectable, type Dependencies, type DependencyContext, type ResolveInjectableType } from './injectables.ts';
+import type { AnyInjectable, Dependencies, DependencyContext, ResolveInjectableType } from './injectables.ts';
 import type { Logger } from './logger.ts';
 import type { Registry } from './registry.ts';
+import { Scope } from './enums.ts';
 type InstanceWrapper = {
     private: any;
     public: any;

package/dist/container.js

@@ -1,5 +1,6 @@
 import assert from 'node:assert';
 import { tryCaptureStackTrace } from '@nmtjs/common';
+import { kClassInjectableCreate, kClassInjectableDispose } from "./constants.js";
 import { Scope } from "./enums.js";
 import { CoreInjectables, compareScope, createExtendableClassInjectable, createValueInjectable, getDepedencencyInjectable, isClassInjectable, isFactoryInjectable, isInjectable, isLazyInjectable, isOptionalInjectable, isValueInjectable, } from "./injectables.js";
 export class Container {
@@ -102,11 +103,7 @@ export class Container {
             throw new Error('Invalid scope'); // TODO: more informative error
         }
         this.instances.set(injectable, [
-            {
-                private: instance,
-                public: instance,
-                context: undefined,
-            },
+            { private: instance, public: instance, context: undefined },
         ]);
     }
     satisfies(injectable) {
@@ -186,7 +183,7 @@ export class Container {
         else if (isClassInjectable(injectable)) {
             wrapper.private = new injectable(context);
             wrapper.public = wrapper.private;
-            await wrapper.private.$onCreate();
+            await wrapper.private[kClassInjectableCreate]();
         }
         else {
             throw new Error('Invalid injectable type');
@@ -201,9 +198,7 @@ export class Container {
     }
     createInjectFunction() {
         const inject = (injectable, context) => {
-            const dependencies = {
-                ...injectable.dependencies,
-            };
+            const dependencies = { ...injectable.dependencies };
             for (const key in context) {
                 const dep = context[key];
                 if (isInjectable(dep) || isOptionalInjectable(dep)) {
@@ -307,7 +302,7 @@ export class Container {
                 await dispose(instance, context);
         }
         else if (isClassInjectable(injectable)) {
-            await instance.$onDispose();
+            await instance[kClassInjectableDispose]();
         }
     }
 }

package/dist/hooks.d.ts

@@ -1,6 +1,6 @@
 import type { Callback } from '@nmtjs/common';
-import { kHookCollection } from './constants.ts';
 import type { Hook } from './enums.ts';
+import { kHookCollection } from './constants.ts';
 export interface HookType {
     [key: string]: (...args: any[]) => any;
 }

package/dist/index.js

@@ -1,6 +1,6 @@
-// biome-ignore lint/correctness/noUnusedImports: TSC wants it
-// biome-ignore assist/source/organizeImports: TSC wants it
-import {} from 'pino';
+// // biome-ignore lint/correctness/noUnusedImports: TSC wants it
+// // biome-ignore assist/source/organizeImports: TSC wants it
+// import {} from 'pino'
 export * from "./constants.js";
 export * from "./container.js";
 export * from "./enums.js";

package/dist/injectables.d.ts

@@ -1,9 +1,11 @@
-import { type Async, type ClassConstructor, type ClassConstructorArgs, type ClassInstance } from '@nmtjs/common';
-import { kClassInjectable, kFactoryInjectable, kInjectable, kLazyInjectable, kOptionalDependency, kValueInjectable } from './constants.ts';
-import { type Hook, Scope } from './enums.ts';
-import { Hooks, type HookType } from './hooks.ts';
+import type { Async, ClassConstructor, ClassConstructorArgs, ClassInstance } from '@nmtjs/common';
+import type { Hook } from './enums.ts';
+import type { HookType } from './hooks.ts';
 import type { Logger } from './logger.ts';
 import type { Registry } from './registry.ts';
+import { kClassInjectable, kClassInjectableCreate, kClassInjectableDispose, kFactoryInjectable, kInjectable, kLazyInjectable, kOptionalDependency, kValueInjectable } from './constants.ts';
+import { Scope } from './enums.ts';
+import { Hooks } from './hooks.ts';
 export type DependencyOptional<T extends AnyInjectable = AnyInjectable> = {
     [kOptionalDependency]: any;
     injectable: T;
@@ -81,8 +83,8 @@ export declare function createFactoryInjectable<T, D extends Dependencies = {},
 export declare const createClassInjectable: <D extends Dependencies = {}, S extends Scope = Scope.Global>(dependencies?: D, scope?: S, stackTraceDepth?: number) => ClassInjectable<ClassInstance<{
     new ($context: DependencyContext<D>): {
         $context: DependencyContext<D>;
-        $onCreate(): Promise<void>;
-        $onDispose(): Promise<void>;
+        [kClassInjectableCreate](): Promise<void>;
+        [kClassInjectableDispose](): Promise<void>;
     };
     dependencies: D;
     scope: S;

package/dist/injectables.js

@@ -1,5 +1,5 @@
-import { tryCaptureStackTrace, } from '@nmtjs/common';
-import { kClassInjectable, kFactoryInjectable, kHookCollection, kInjectable, kLazyInjectable, kOptionalDependency, kValueInjectable, } from "./constants.js";
+import { tryCaptureStackTrace } from '@nmtjs/common';
+import { kClassInjectable, kClassInjectableCreate, kClassInjectableDispose, kFactoryInjectable, kHookCollection, kInjectable, kLazyInjectable, kOptionalDependency, kValueInjectable, } from "./constants.js";
 import { Scope } from "./enums.js";
 import { Hooks } from "./hooks.js";
 const ScopeStrictness = {
@@ -94,8 +94,8 @@ export const createClassInjectable = (dependencies = {}, scope, stackTraceDepth
         constructor($context) {
             this.$context = $context;
         }
-        async $onCreate() { }
-        async $onDispose() { }
+        async [kClassInjectableCreate]() { }
+        async [kClassInjectableDispose]() { }
     };
     InjectableClass.scope = resolveInjectableScope(typeof scope === 'undefined', InjectableClass);
     return InjectableClass;
@@ -163,10 +163,7 @@ export function substitute(injectable, substitution, stackTraceDepth = 0) {
     }
     else if (isFactoryInjectable(injectable)) {
         // @ts-expect-error
-        return createFactoryInjectable({
-            ...injectable,
-            dependencies,
-        }, injectable.label, depth);
+        return createFactoryInjectable({ ...injectable, dependencies }, injectable.label, depth);
     }
     throw new Error('Invalid injectable type');
 }
@@ -221,10 +218,4 @@ function resolveInjectableScope(isDefaultScope, injectable) {
         throw new Error(`Invalid scope ${injectable.scope} for an injectable: dependencies have stricter scope - ${actualScope}`);
     return actualScope;
 }
-export const CoreInjectables = {
-    logger,
-    registry,
-    inject,
-    dispose,
-    hook,
-};
+export const CoreInjectables = { logger, registry, inject, dispose, hook };

package/dist/logger.d.ts

@@ -1,4 +1,5 @@
-import { type DestinationStream, type Level, type LoggerOptions, type Logger as PinoLogger, pino, type StreamEntry } from 'pino';
+import type { DestinationStream, Level, LoggerOptions, Logger as PinoLogger, StreamEntry } from 'pino';
+import { pino } from 'pino';
 export type { StreamEntry } from 'pino';
 export type Logger = PinoLogger;
 export type LoggingOptions = {

package/dist/logger.js

@@ -1,5 +1,5 @@
 import { threadId } from 'node:worker_threads';
-import { pino, stdTimeFunctions, } from 'pino';
+import { pino, stdTimeFunctions } from 'pino';
 import { build as pretty } from 'pino-pretty';
 // TODO: use node:util inspect
 const bg = (value, color) => `\x1b[${color}m${value}\x1b[0m`;
@@ -40,11 +40,7 @@ export const createLogger = (options = {}, $group) => {
         ? 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 });
+    return pino({ timestamp: stdTimeFunctions.isoTime, ...pinoOptions, level }, pino.multistream(destinations)).child({ $group, $threadId: threadId });
 };
 export const createConsolePrettyDestination = (level, sync = true) => ({
     level,

package/dist/plugin.d.ts

@@ -1,6 +1,6 @@
 import type { Async } from '@nmtjs/common';
-import { kPlugin } from './constants.ts';
 import type { PluginContext } from './types.ts';
+import { kPlugin } from './constants.ts';
 export interface BasePlugin<Type = any, Options = unknown, Context extends PluginContext = PluginContext> {
     name: string;
     init: (context: Context, options: Options) => Async<Type>;

package/dist/registry.d.ts

@@ -1,7 +1,9 @@
-import { type Hook, Scope } from './enums.ts';
-import { Hooks, type HookType } from './hooks.ts';
-import { type AnyInjectable, type Dependant } from './injectables.ts';
+import type { Hook } from './enums.ts';
+import type { HookType } from './hooks.ts';
+import type { AnyInjectable, Dependant } from './injectables.ts';
 import type { Logger } from './logger.ts';
+import { Scope } from './enums.ts';
+import { Hooks } from './hooks.ts';
 export declare class Registry {
     protected readonly application: {
         logger: Logger;

package/dist/registry.js

@@ -1,6 +1,6 @@
 import { Scope } from "./enums.js";
 import { Hooks } from "./hooks.js";
-import { getInjectableScope, } from "./injectables.js";
+import { getInjectableScope } from "./injectables.js";
 export class Registry {
     application;
     hooks = new Hooks();

package/package.json

@@ -6,27 +6,32 @@
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js",
       "module-sync": "./dist/index.js"
+    },
+    "./constants": {
+      "types": "./dist/constants.d.ts",
+      "import": "./dist/constants.js",
+      "module-sync": "./dist/constants.js"
     }
   },
   "peerDependencies": {
     "pino": "^9.6.0",
     "pino-pretty": "^13.0.0",
-    "@nmtjs/common": "0.13.0",
-    "@nmtjs/type": "0.13.0"
+    "@nmtjs/common": "0.14.0",
+    "@nmtjs/type": "0.14.0"
   },
   "devDependencies": {
     "@types/node": "^20",
     "pino": "^9.6.0",
     "pino-pretty": "^13.0.0",
-    "@nmtjs/common": "0.13.0",
-    "@nmtjs/type": "0.13.0"
+    "@nmtjs/common": "0.14.0",
+    "@nmtjs/type": "0.14.0"
   },
   "files": [
     "dist",
     "LICENSE.md",
     "README.md"
   ],
-  "version": "0.13.0",
+  "version": "0.14.0",
   "scripts": {
     "build": "tsc",
     "type-check": "tsc --noEmit"