@nmtjs/core 0.16.1 → 0.17.0-beta.1

package/src/utils/functions.ts

@@ -1,31 +0,0 @@
-export { match } from '@nmtjs/common'
-
-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)
-}
-
-export function pick<
-  T extends object,
-  K extends {
-    [KK in keyof T as T[KK] extends (...args: any[]) => any ? never : KK]?: true
-  },
->(
-  obj: T,
-  keys: K,
-): Pick<
-  T,
-  keyof {
-    [KK in keyof K as K[KK] extends true ? KK : never]: K[KK]
-  }
-> {
-  const result = {} as any
-  for (const key in keys) {
-    if (key in obj) {
-      result[key] = obj[key as unknown as keyof typeof obj]
-    }
-  }
-  return result
-}

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
-  }
-}