@nmtjs/core 0.12.4 → 0.12.6

package/dist/registry.js

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

package/dist/types.d.ts

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

package/dist/types.js

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

package/dist/utils/functions.d.ts

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

package/dist/utils/functions.js

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

package/dist/utils/index.d.ts

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

package/dist/utils/index.js

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

package/dist/utils/pool.d.ts

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

package/dist/utils/pool.js

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

package/dist/utils/semaphore.d.ts

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

package/dist/utils/semaphore.js

@@ -1,48 +1,55 @@
-export class SemaphoreError extends Error {}
+export class SemaphoreError extends Error {
+}
+// Semaphore from https://github.com/metarhia/metautil
 export class Semaphore {
-	counter;
-	queue = [];
-	constructor(concurrency, size = 0, timeout = 0) {
-		this.size = size;
-		this.timeout = timeout;
-		this.counter = concurrency;
-	}
-	enter() {
-		if (this.counter > 0) {
-			this.counter--;
-			return Promise.resolve();
-		} else if (this.queue.length >= this.size) {
-			return Promise.reject(new SemaphoreError("Queue is full"));
-		} else {
-			return new Promise((resolve, reject) => {
-				const waiting = { resolve };
-				waiting.timer = setTimeout(() => {
-					waiting.resolve = undefined;
-					this.queue.shift();
-					reject(new SemaphoreError("Timeout"));
-				}, this.timeout);
-				this.queue.push(waiting);
-			});
-		}
-	}
-	leave() {
-		if (this.queue.length === 0) {
-			this.counter++;
-		} else {
-			const item = this.queue.shift();
-			if (item) {
-				const { resolve, timer } = item;
-				if (timer) clearTimeout(timer);
-				if (resolve) setTimeout(resolve, 0);
-			}
-		}
-	}
-	get isEmpty() {
-		return this.queue.length === 0;
-	}
-	get queueLength() {
-		return this.queue.length;
-	}
+    size;
+    timeout;
+    counter;
+    queue = [];
+    constructor(concurrency, size = 0, timeout = 0) {
+        this.size = size;
+        this.timeout = timeout;
+        this.counter = concurrency;
+    }
+    enter() {
+        if (this.counter > 0) {
+            this.counter--;
+            return Promise.resolve();
+        }
+        else if (this.queue.length >= this.size) {
+            return Promise.reject(new SemaphoreError('Queue is full'));
+        }
+        else {
+            return new Promise((resolve, reject) => {
+                const waiting = { resolve };
+                waiting.timer = setTimeout(() => {
+                    waiting.resolve = undefined;
+                    this.queue.shift();
+                    reject(new SemaphoreError('Timeout'));
+                }, this.timeout);
+                this.queue.push(waiting);
+            });
+        }
+    }
+    leave() {
+        if (this.queue.length === 0) {
+            this.counter++;
+        }
+        else {
+            const item = this.queue.shift();
+            if (item) {
+                const { resolve, timer } = item;
+                if (timer)
+                    clearTimeout(timer);
+                if (resolve)
+                    setTimeout(resolve, 0);
+            }
+        }
+    }
+    get isEmpty() {
+        return this.queue.length === 0;
+    }
+    get queueLength() {
+        return this.queue.length;
+    }
 }
-
-//# sourceMappingURL=semaphore.js.map

package/package.json

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

package/src/hooks.ts

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

package/src/index.ts

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

package/src/injectables.ts

@@ -304,8 +304,8 @@ export const createClassInjectable = <
 
     constructor(public $context: DependencyContext<D>) {}
 
-    protected async $onCreate() {}
-    protected async $onDispose() {}
+    async $onCreate() {}
+    async $onDispose() {}
   }
 
   InjectableClass.scope = resolveInjectableScope(

package/src/logger.ts

@@ -9,6 +9,7 @@ import {
 } from 'pino'
 import { build as pretty } from 'pino-pretty'
 
+export type { StreamEntry } from 'pino'
 export type Logger = PinoLogger
 export type LoggingOptions = {
   destinations?: Array<DestinationStream | StreamEntry<Level>>

package/src/plugin.ts

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

package/src/utils/pool.ts

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

package/src/utils/semaphore.ts

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

package/dist/constants.js.map

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