@nmtjs/core 0.12.6 → 0.12.7

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 '@nmtjs/common'
-
-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 '@nmtjs/common'
-
-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
-  }
-}