@nmtjs/core 0.12.5 → 0.12.7

package/src/plugin.ts

@@ -1,27 +0,0 @@
-import type { Async } from '../../common/src/index.ts'
-import { kPlugin } from './constants.ts'
-import type { PluginContext } from './types.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 const createPlugin = <Options = unknown, Type = void>(
-  name: string,
-  init: Plugin<Type, Options>['init'],
-): Plugin<Type, Options> => ({ name, init, [kPlugin]: true })
-
-export const isPlugin = (value: any): value is Plugin => kPlugin in value

package/src/registry.ts

@@ -1,44 +0,0 @@
-import { type Hook, Scope } from './enums.ts'
-import { Hooks, type HookType } from './hooks.ts'
-import {
-  type AnyInjectable,
-  type Dependant,
-  getInjectableScope,
-} from './injectables.ts'
-import type { Logger } from './logger.ts'
-
-export class Registry {
-  readonly hooks = new Hooks()
-
-  constructor(
-    protected readonly application: {
-      logger: Logger
-    },
-  ) {}
-
-  registerHooks<T extends Hooks>(hooks: T) {
-    Hooks.merge(hooks, this.hooks)
-  }
-
-  registerHook<T extends Hook>(name: T, callback: HookType[T]) {
-    this.hooks.add(name, callback)
-  }
-
-  *getDependants(): Generator<Dependant> {}
-
-  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: AnyInjectable[],
-  scope = Scope.Global,
-) {
-  return injectables.some(
-    (injectable) => getInjectableScope(injectable) !== scope,
-  )
-}

package/src/types.ts

@@ -1,13 +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/src/utils/functions.ts

@@ -1,31 +0,0 @@
-import type { Pattern } from '../types.ts'
-
-/**
- * Very simple pattern matching function.
- */
-export function match(value: string, pattern: 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: string) {
-  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/src/utils/index.ts

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

package/src/utils/pool.ts

@@ -1,111 +0,0 @@
-import type { Callback } from '../../../common/src/index.ts'
-
-interface PoolOptions {
-  timeout?: number
-}
-
-interface PoolQueueItem {
-  resolve?: Callback
-  timer?: ReturnType<typeof setTimeout>
-}
-
-export class PoolError extends Error {}
-
-// Fixed pool from https://github.com/metarhia/metautil
-export class Pool<T = unknown> {
-  #items: Array<T> = []
-  #free: Array<boolean> = []
-  #queue: PoolQueueItem[] = []
-  #current: number = 0
-  #size: number = 0
-  #available: number = 0
-
-  constructor(private readonly options: PoolOptions = {}) {}
-
-  add(item: T) {
-    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: T) {
-    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): Promise<T> {
-    if (this.#size === 0) throw new PoolError('Pool is empty')
-    if (this.#available === 0) {
-      return new Promise((resolve, reject) => {
-        const waiting: PoolQueueItem = {
-          resolve: (item: T) => {
-            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: T | undefined
-    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: T) {
-    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: T) {
-    const index = this.#items.indexOf(item)
-    if (index < 0) return false
-    return this.#free[index]
-  }
-
-  get items() {
-    return [...this.#items]
-  }
-
-  #capture(item: T) {
-    const index = this.#items.indexOf(item)
-    this.#free[index] = false
-    this.#available--
-  }
-}

package/src/utils/semaphore.ts

@@ -1,63 +0,0 @@
-import type { Callback } from '../../../common/src/index.ts'
-
-interface SemaphoreQueueItem {
-  resolve?: Callback
-  timer?: ReturnType<typeof setTimeout>
-}
-
-export class SemaphoreError extends Error {}
-
-// Semaphore from https://github.com/metarhia/metautil
-export class Semaphore {
-  private counter: number
-
-  private readonly queue: SemaphoreQueueItem[] = []
-
-  constructor(
-    concurrency: number,
-    private readonly size: number = 0,
-    private readonly timeout: number = 0,
-  ) {
-    this.counter = concurrency
-  }
-
-  enter(): Promise<void> {
-    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: SemaphoreQueueItem = { 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
-  }
-}