@nmtjs/common 0.12.6 → 0.12.8

package/package.json

@@ -9,12 +9,11 @@
     }
   },
   "files": [
-    "src",
     "dist",
     "LICENSE.md",
     "README.md"
   ],
-  "version": "0.12.6",
+  "version": "0.12.8",
   "scripts": {
     "build": "tsc",
     "type-check": "tsc --noEmit"

package/src/index.ts

@@ -1,2 +0,0 @@
-export * from './types.ts'
-export * from './utils.ts'

package/src/types.ts

@@ -1,72 +0,0 @@
-export interface TypeProvider {
-  readonly input: unknown
-  readonly output: unknown
-}
-
-export type CallTypeProvider<T extends TypeProvider, V> = (T & {
-  input: V
-})['output']
-
-export type ClassConstructor<T = any, A extends any[] = any[]> =
-  | (abstract new (
-      ...args: A
-    ) => T)
-  | (new (
-      ...args: A
-    ) => T)
-
-export type ClassInstance<T> = T extends ClassConstructor<infer U> ? U : never
-export type ClassConstructorArgs<T, A = never> = T extends ClassConstructor<
-  any,
-  infer U
->
-  ? U
-  : A
-
-export type Callback<T extends any[] = any[], R = any> = (...args: T) => R
-export type OmitFirstItem<T extends any[]> = T extends [any, ...infer U]
-  ? U
-  : []
-export type ErrorClass = new (...args: any[]) => Error
-export type Extra = Record<string, any>
-export type Async<T> = T | Promise<T>
-
-export type ArrayMap<T extends readonly any[], K extends keyof T[number]> = {
-  [I in keyof T]: T[I][K]
-}
-
-export type UnionToIntersection<U> = (
-  U extends any
-    ? (k: U) => void
-    : never
-) extends (k: infer I) => void
-  ? I
-  : never
-
-export type Merge<
-  T1 extends Record<string, any>,
-  T2 extends Record<string, any>,
-> = {
-  [K in keyof T1 | keyof T2]: K extends keyof T2
-    ? T2[K]
-    : K extends keyof T1
-      ? T1[K]
-      : never
-}
-
-export type OneOf<
-  TypesArray extends any[],
-  Res = never,
-  AllProperties = MergeTypes<TypesArray>,
-> = TypesArray extends [infer Head, ...infer Rem]
-  ? OneOf<Rem, Res | OnlyFirst<Head, AllProperties>, AllProperties>
-  : Res
-
-type MergeTypes<TypesArray extends any[], Res = {}> = TypesArray extends [
-  infer Head,
-  ...infer Rem,
-]
-  ? MergeTypes<Rem, Res & Head>
-  : Res
-
-type OnlyFirst<F, S> = F & { [Key in keyof Omit<S, keyof F>]?: never }

package/src/utils.ts

@@ -1,139 +0,0 @@
-import type { Callback } from './types.ts'
-
-export const noopFn = () => {}
-
-export function merge<T extends any[]>(...objects: T) {
-  return Object.assign({}, ...objects)
-}
-
-export function defer<T extends Callback>(
-  cb: T,
-  ms = 1,
-  ...args: Parameters<T>
-): Promise<Awaited<ReturnType<T>>> {
-  return new Promise((resolve, reject) =>
-    setTimeout(async () => {
-      try {
-        resolve(await cb(...args))
-      } catch (error) {
-        reject(error)
-      }
-    }, ms),
-  )
-}
-
-export function range(count: number, start = 0) {
-  let current = start
-  return {
-    [Symbol.iterator]() {
-      return {
-        next() {
-          if (current < count) {
-            return { done: false, value: current++ }
-          } else {
-            return { done: true, value: current }
-          }
-        },
-      }
-    },
-  }
-}
-
-export function debounce(cb: Callback, delay: number) {
-  let timer: any
-  const clear = () => timer && clearTimeout(timer)
-  const fn = (...args: any[]) => {
-    clear()
-    timer = setTimeout(cb, delay, ...args)
-  }
-  return Object.assign(fn, { clear })
-}
-
-// TODO: Promise.withResolvers?
-export interface InteractivePromise<T = any> {
-  promise: Promise<T>
-  resolve: (value: T) => void
-  reject: (error: any) => void
-  toArgs: () => [resolve: this['resolve'], reject: this['reject']]
-}
-// TODO: Promise.withResolvers?
-export function createPromise<T>(): InteractivePromise<T> {
-  let resolve: InteractivePromise<T>['resolve']
-  let reject: InteractivePromise<T>['reject']
-  const promise = new Promise<T>((res, rej) => {
-    resolve = res
-    reject = rej
-  })
-  // @ts-expect-error
-  return { resolve, reject, promise, toArgs: () => [resolve, reject] }
-}
-
-export function onAbort<T extends Callback>(
-  signal: AbortSignal,
-  cb: T,
-  reason?: any,
-) {
-  const listener = () => cb(reason ?? signal.reason)
-  signal.addEventListener('abort', listener, { once: true })
-  return () => signal.removeEventListener('abort', listener)
-}
-
-export function withTimeout(
-  value: Promise<any>,
-  timeout: number,
-  timeoutError: Error,
-  controller?: AbortController,
-) {
-  return new Promise((resolve, reject) => {
-    const timer = setTimeout(reject, timeout, timeoutError)
-    const clearTimer = () => clearTimeout(timer)
-    const rejectWithTimeout = (error: any) => {
-      reject(error)
-      controller?.abort(error)
-    }
-    value.then(resolve).catch(rejectWithTimeout).finally(clearTimer)
-  })
-}
-
-export function tryCaptureStackTrace(depth = 0) {
-  return (
-    new Error().stack
-      ?.split('\n')
-      .slice(4 + depth)
-      .join('\n') ?? undefined
-  )
-}
-
-export function isGeneratorFunction(value: any): value is GeneratorFunction {
-  return (
-    typeof value === 'function' &&
-    value.constructor.name === 'GeneratorFunction'
-  )
-}
-
-export function isAsyncGeneratorFunction(
-  value: any,
-): value is AsyncGeneratorFunction {
-  return (
-    typeof value === 'function' &&
-    value.constructor.name === 'AsyncGeneratorFunction'
-  )
-}
-
-export function throwError(message: string, ErrorClass = Error): never {
-  throw new ErrorClass(message)
-}
-
-export function once(target: EventTarget, event: string) {
-  return new Promise<void>((resolve) => {
-    target.addEventListener(event, () => resolve(), { once: true })
-  })
-}
-
-export function onceAborted(signal: AbortSignal) {
-  return once(signal, 'abort')
-}
-
-export function isAbortError(error: any): boolean {
-  return error.name === 'AbortError' || error.code === DOMException.ABORT_ERR
-}