@nmtjs/core 0.14.4 → 0.15.0-beta.1

package/dist/injectables.d.ts

@@ -1,119 +0,0 @@
-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;
-};
-export type Depedency = DependencyOptional | AnyInjectable;
-export type Dependencies = Record<string, Depedency>;
-export type ResolveInjectableType<T extends AnyInjectable> = T extends Injectable<infer Type, any, any> ? Type : never;
-export interface Dependant<Deps extends Dependencies = Dependencies> {
-    dependencies: Deps;
-    label?: string;
-    stack?: string;
-}
-export type DependencyInjectable<T extends Depedency> = T extends AnyInjectable ? T : T extends DependencyOptional ? T['injectable'] : never;
-export type DependencyContext<Deps extends Dependencies> = {
-    readonly [K in keyof Deps as Deps[K] extends AnyInjectable ? K : never]: Deps[K] extends AnyInjectable ? ResolveInjectableType<Deps[K]> : never;
-} & {
-    readonly [K in keyof Deps as Deps[K] extends DependencyOptional ? K : never]?: Deps[K] extends DependencyOptional ? ResolveInjectableType<Deps[K]['injectable']> : never;
-};
-export type InjectableFactoryType<InjectableType, InjectableDeps extends Dependencies> = (context: DependencyContext<InjectableDeps>) => Async<InjectableType>;
-export type InjectablePickType<Input, Output> = (injectable: Input) => Output;
-export type InjectableDisposeType<InjectableType, InjectableDeps extends Dependencies> = (instance: InjectableType, context: DependencyContext<InjectableDeps>) => any;
-export interface LazyInjectable<T, S extends Scope = Scope.Global> extends Dependant<{}> {
-    scope: S;
-    [kInjectable]: any;
-    [kLazyInjectable]: T;
-}
-export interface ValueInjectable<T> extends Dependant<{}> {
-    scope: Scope.Global;
-    value: T;
-    [kInjectable]: any;
-    [kValueInjectable]: any;
-}
-export interface FactoryInjectable<T, D extends Dependencies = {}, S extends Scope = Scope.Global, P = T> extends Dependant<D> {
-    scope: S;
-    factory: InjectableFactoryType<P, D>;
-    pick: InjectablePickType<P, T>;
-    dispose?: InjectableDisposeType<P, D>;
-    [kInjectable]: any;
-    [kFactoryInjectable]: any;
-}
-export interface BaseClassInjectable<T, D extends Dependencies = {}, S extends Scope = Scope.Global> extends Dependant<D> {
-    new (...args: any[]): T;
-    scope: S;
-    [kInjectable]: any;
-    [kClassInjectable]: any;
-}
-export interface ClassInjectable<T, D extends Dependencies = {}, S extends Scope = Scope.Global, A extends any[] = []> extends Dependant<D> {
-    new ($context: DependencyContext<D>, ...args: A): T & {
-        $context: DependencyContext<D>;
-        [kClassInjectableCreate]?: () => Promise<void>;
-        [kClassInjectableDispose]?: () => Promise<void>;
-    };
-    scope: S;
-    [kInjectable]: any;
-    [kClassInjectable]: any;
-}
-export type Injectable<V = any, D extends Dependencies = {}, S extends Scope = Scope> = LazyInjectable<V, S> | ValueInjectable<V> | FactoryInjectable<V, D, S, any> | BaseClassInjectable<V, D, S>;
-export type AnyInjectable<T = any, S extends Scope = Scope> = Injectable<T, any, S>;
-export declare const isLazyInjectable: (injectable: any) => injectable is LazyInjectable<any>;
-export declare const isFactoryInjectable: (injectable: any) => injectable is FactoryInjectable<any>;
-export declare const isClassInjectable: (injectable: any) => injectable is ClassInjectable<any>;
-export declare const isValueInjectable: (injectable: any) => injectable is ValueInjectable<any>;
-export declare const isInjectable: (injectable: any) => injectable is AnyInjectable<any>;
-export declare const isOptionalInjectable: (injectable: any) => injectable is DependencyOptional<any>;
-export declare function getInjectableScope(injectable: AnyInjectable): Scope;
-export declare function getDepedencencyInjectable(dependency: Depedency): AnyInjectable;
-export declare function createOptionalInjectable<T extends AnyInjectable>(injectable: T): DependencyOptional<T>;
-export declare function createLazyInjectable<T, S extends Scope = Scope.Global>(scope?: S, label?: string, stackTraceDepth?: number): LazyInjectable<T, S>;
-export declare function createValueInjectable<T>(value: T, label?: string, stackTraceDepth?: number): ValueInjectable<T>;
-export declare function createFactoryInjectable<T, D extends Dependencies = {}, S extends Scope = Scope.Global, P = T>(paramsOrFactory: {
-    dependencies?: D;
-    scope?: S;
-    pick?: InjectablePickType<P, T>;
-    factory: InjectableFactoryType<P, D>;
-    dispose?: InjectableDisposeType<P, D>;
-} | InjectableFactoryType<P, D>, label?: string, stackTraceDepth?: number): FactoryInjectable<null extends T ? P : T, D, S, P>;
-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>;
-        [kClassInjectableCreate](): Promise<void>;
-        [kClassInjectableDispose](): Promise<void>;
-    };
-    dependencies: D;
-    scope: S;
-    stack: string | undefined;
-    get label(): string;
-    [kInjectable]: boolean;
-    [kClassInjectable]: boolean;
-}>, D, S>;
-export declare function createExtendableClassInjectable<B extends ClassConstructor<any>, D extends Dependencies = {}, S extends Scope = Scope.Global>(baseClass: B, dependencies?: D, scope?: S, stackTraceDepth?: number): B extends ClassInjectable<any> ? ClassInjectable<ClassInstance<B>, D, S> : ClassInjectable<ClassInstance<B>, D, S, ClassConstructorArgs<B, []>>;
-export type DependenciesSubstitution<T extends Dependencies> = {
-    [K in keyof T]?: T[K] extends AnyInjectable<infer Type> ? AnyInjectable<Type> | DependenciesSubstitution<T[K]['dependencies']> : never;
-};
-export declare function substitute<T extends FactoryInjectable<any, any, Scope> | BaseClassInjectable<any, any, Scope>>(injectable: T, substitution: DependenciesSubstitution<T['dependencies']>, stackTraceDepth?: number): T;
-export declare function compareScope(left: Scope, operator: '>' | '<' | '>=' | '<=' | '=' | '!=', right: Scope): boolean;
-export declare const CoreInjectables: {
-    logger: LazyInjectable<Logger, Scope.Global>;
-    registry: LazyInjectable<Registry, Scope.Global>;
-    inject: LazyInjectable<(<T extends AnyInjectable>(injectable: T, context: { [K in keyof T["dependencies"]]?: ResolveInjectableType<T["dependencies"][K]> | AnyInjectable<ResolveInjectableType<T["dependencies"][K]>> | undefined; }) => Promise<ResolveInjectableType<T>>) & {
-        explicit: <T extends AnyInjectable>(injectable: T, context: { [K in keyof T["dependencies"]]?: ResolveInjectableType<T["dependencies"][K]> | AnyInjectable<ResolveInjectableType<T["dependencies"][K]>> | undefined; }) => Promise<Awaited<ResolveInjectableType<T>> & {
-            [Symbol.asyncDispose]: () => Promise<void>;
-        }>;
-    }, Scope.Global>;
-    dispose: LazyInjectable<(<T extends AnyInjectable>(injectable: T, instance?: any) => Promise<void>), Scope.Global>;
-    hook: FactoryInjectable<(<T extends Hook>(name: T, callback: HookType[T]) => () => void), {
-        registry: LazyInjectable<Registry, Scope.Global>;
-    }, Scope.Transient, {
-        hooks: Hooks;
-        on: <T extends Hook>(name: T, callback: HookType[T]) => () => void;
-    }>;
-};

package/dist/injectables.js

@@ -1,221 +0,0 @@
-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 = {
-    [Scope.Transient]: Number.NaN, // this should make it always fail to compare with other scopes
-    [Scope.Global]: 1,
-    [Scope.Connection]: 2,
-    [Scope.Call]: 3,
-};
-export const isLazyInjectable = (injectable) => injectable[kLazyInjectable];
-export const isFactoryInjectable = (injectable) => injectable[kFactoryInjectable];
-export const isClassInjectable = (injectable) => injectable[kClassInjectable];
-export const isValueInjectable = (injectable) => injectable[kValueInjectable];
-export const isInjectable = (injectable) => injectable[kInjectable];
-export const isOptionalInjectable = (injectable) => injectable[kOptionalDependency];
-export function getInjectableScope(injectable) {
-    let scope = injectable.scope;
-    const deps = injectable.dependencies;
-    for (const key in deps) {
-        const dependency = deps[key];
-        const injectable = getDepedencencyInjectable(dependency);
-        const dependencyScope = getInjectableScope(injectable);
-        if (dependencyScope !== Scope.Transient &&
-            scope !== Scope.Transient &&
-            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 Object.freeze({
-        [kOptionalDependency]: true,
-        injectable,
-    });
-}
-export function createLazyInjectable(scope = Scope.Global, label, stackTraceDepth = 0) {
-    return Object.freeze({
-        scope,
-        dependencies: {},
-        label,
-        stack: tryCaptureStackTrace(stackTraceDepth),
-        [kInjectable]: true,
-        [kLazyInjectable]: true,
-    });
-}
-export function createValueInjectable(value, label, stackTraceDepth = 0) {
-    return Object.freeze({
-        value,
-        scope: Scope.Global,
-        dependencies: {},
-        label,
-        stack: tryCaptureStackTrace(stackTraceDepth),
-        [kInjectable]: true,
-        [kValueInjectable]: true,
-    });
-}
-export function createFactoryInjectable(paramsOrFactory, label, stackTraceDepth = 0) {
-    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(stackTraceDepth),
-        [kInjectable]: true,
-        [kFactoryInjectable]: true,
-    };
-    injectable.scope = resolveInjectableScope(typeof params.scope === 'undefined', injectable);
-    return Object.freeze(injectable);
-}
-export const createClassInjectable = (dependencies = {}, scope, stackTraceDepth = 0) => {
-    const InjectableClass = class {
-        $context;
-        static dependencies = dependencies;
-        static scope = (scope ?? Scope.Global);
-        static stack = tryCaptureStackTrace(stackTraceDepth + 2);
-        static [kInjectable] = true;
-        static [kClassInjectable] = true;
-        static get label() {
-            // biome-ignore lint/complexity/noThisInStatic: ok
-            return this.name;
-        }
-        constructor($context) {
-            this.$context = $context;
-        }
-        async [kClassInjectableCreate]() { }
-        async [kClassInjectableDispose]() { }
-    };
-    InjectableClass.scope = resolveInjectableScope(typeof scope === 'undefined', InjectableClass);
-    return InjectableClass;
-};
-export function createExtendableClassInjectable(baseClass, dependencies = {}, scope, stackTraceDepth = 0) {
-    if (isClassInjectable(baseClass)) {
-        if (scope && compareScope(baseClass.scope, '>', scope)) {
-            throw new Error(`Invalid scope ${scope} for an extendable class injectable: base class have stricter scope - ${baseClass.scope}`);
-        }
-        else {
-            scope = scope ?? baseClass.scope;
-        }
-        dependencies = Object.assign({}, baseClass.dependencies, dependencies);
-    }
-    const InjectableClass = class extends baseClass {
-        static dependencies = dependencies;
-        static scope = (scope ?? Scope.Global);
-        static stack = tryCaptureStackTrace(stackTraceDepth);
-        static [kInjectable] = true;
-        static [kClassInjectable] = true;
-        static get label() {
-            // biome-ignore lint/complexity/noThisInStatic: ok
-            return this.name;
-        }
-        $context;
-        constructor(...args) {
-            const [$context, ...baseClassArgs] = args;
-            if (isClassInjectable(baseClass)) {
-                super($context);
-            }
-            else {
-                super(...baseClassArgs);
-            }
-            this.$context = $context;
-        }
-        async $onCreate() {
-            await super.$onCreate?.();
-        }
-        async $onDispose() {
-            await super.$onDispose?.();
-        }
-    };
-    InjectableClass.scope = resolveInjectableScope(typeof scope === 'undefined', InjectableClass);
-    // @ts-expect-error
-    return InjectableClass;
-}
-export function substitute(injectable, substitution, stackTraceDepth = 0) {
-    const dependencies = { ...injectable.dependencies };
-    const depth = stackTraceDepth + 1;
-    for (const key in substitution) {
-        const value = substitution[key];
-        if (key in dependencies) {
-            const original = dependencies[key];
-            if (isInjectable(value)) {
-                dependencies[key] = value;
-            }
-            else if (isClassInjectable(original) || isFactoryInjectable(original)) {
-                dependencies[key] = substitute(original, value, depth);
-            }
-        }
-    }
-    if (isClassInjectable(injectable)) {
-        // @ts-expect-error
-        return createExtendableClassInjectable(injectable, dependencies, injectable.scope, depth);
-    }
-    else if (isFactoryInjectable(injectable)) {
-        // @ts-expect-error
-        return createFactoryInjectable({ ...injectable, dependencies }, injectable.label, depth);
-    }
-    throw new Error('Invalid injectable type');
-}
-export 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');
-    }
-}
-const logger = createLazyInjectable(Scope.Global, 'Logger');
-const registry = createLazyInjectable(Scope.Global, 'Registry');
-const inject = createLazyInjectable(Scope.Global, 'Inject function');
-const dispose = createLazyInjectable(Scope.Global, 'Dispose function');
-const hook = createFactoryInjectable({
-    scope: Scope.Transient,
-    dependencies: { registry },
-    factory: ({ registry }) => {
-        const hooks = new Hooks();
-        const on = (name, callback) => {
-            hooks.add(name, callback);
-            return registry.hooks.add(name, callback);
-        };
-        return { hooks, on };
-    },
-    pick: ({ on }) => on,
-    dispose: ({ hooks }, { registry }) => {
-        for (const [hook, callbacks] of hooks[kHookCollection].entries()) {
-            for (const callback of callbacks) {
-                registry.hooks.remove(hook, callback);
-            }
-        }
-        hooks.clear();
-    },
-});
-function resolveInjectableScope(isDefaultScope, injectable) {
-    const actualScope = getInjectableScope(injectable);
-    if (!isDefaultScope && compareScope(actualScope, '>', injectable.scope))
-        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 };

package/dist/logger.d.ts

@@ -1,10 +0,0 @@
-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 = {
-    destinations?: Array<DestinationStream | StreamEntry<Level>>;
-    pinoOptions?: LoggerOptions;
-};
-export declare const createLogger: (options: LoggingOptions | undefined, $group: string) => pino.Logger<never, boolean>;
-export declare const createConsolePrettyDestination: (level: Level, sync?: boolean) => StreamEntry;

package/dist/logger.js

@@ -1,62 +0,0 @@
-import { threadId } from 'node:worker_threads';
-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`;
-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/metadata.d.ts

@@ -1,13 +0,0 @@
-import { kMetadata } from './constants.ts';
-export type Metadata<T = any> = {
-    key: MetadataKey<T>;
-    value: T;
-};
-export type MetadataKey<T = any> = {
-    [kMetadata]: string;
-    as(value: T): Metadata<T>;
-};
-export declare const createMetadataKey: <T>(key: string) => MetadataKey<T>;
-export declare class MetadataStore extends Map<MetadataKey, Metadata> {
-    get<T>(key: MetadataKey<T>): T | undefined;
-}

package/dist/metadata.js

@@ -1,15 +0,0 @@
-import { kMetadata } from "./constants.js";
-export const createMetadataKey = (key) => {
-    const metadataKey = {
-        [kMetadata]: key,
-        as(value) {
-            return { key: metadataKey, value };
-        },
-    };
-    return metadataKey;
-};
-export class MetadataStore extends Map {
-    get(key) {
-        return super.get(key);
-    }
-}

package/dist/plugin.d.ts

@@ -1,12 +0,0 @@
-import type { Async } from '@nmtjs/common';
-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>;
-}
-export interface Plugin<Type = void, Options = unknown, Context extends PluginContext = PluginContext> extends BasePlugin<Type, Options, Context> {
-    [kPlugin]: any;
-}
-export declare const createPlugin: <Options = unknown, Type = void>(name: string, init: Plugin<Type, Options>["init"]) => Plugin<Type, Options>;
-export declare const isPlugin: (value: any) => value is Plugin;

package/dist/plugin.js

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

package/dist/registry.d.ts

@@ -1,21 +0,0 @@
-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;
-    };
-    readonly hooks: Hooks;
-    constructor(application: {
-        logger: Logger;
-    });
-    registerHooks<T extends Hooks>(hooks: T): void;
-    registerHook<T extends Hook>(name: T, callback: HookType[T]): void;
-    getDependants(): Generator<Dependant>;
-    clear(): void;
-}
-export declare const scopeErrorMessage: (name: any, scope?: Scope) => string;
-export declare function hasInvalidScopeDeps(injectables: AnyInjectable[], scope?: Scope): boolean;

package/dist/registry.js

@@ -1,24 +0,0 @@
-import { Scope } from "./enums.js";
-import { Hooks } from "./hooks.js";
-import { getInjectableScope } from "./injectables.js";
-export class Registry {
-    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);
-}

package/dist/types.d.ts

@@ -1,11 +0,0 @@
-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 +0,0 @@
-export {};

package/dist/utils/functions.d.ts

@@ -1,6 +0,0 @@
-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,35 +0,0 @@
-/**
- * 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/index.d.ts

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

package/dist/utils/index.js

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

package/dist/utils/pool.d.ts

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