@nmtjs/common 0.15.0-beta.3 → 0.15.0-beta.5

package/package.json

@@ -6,10 +6,11 @@
   },
   "files": [
     "dist",
+    "src",
     "LICENSE.md",
     "README.md"
   ],
-  "version": "0.15.0-beta.3",
+  "version": "0.15.0-beta.5",
   "scripts": {
     "clean-build": "rm -rf ./dist",
     "build": "tsc --declaration --sourceMap",

package/src/abortSignal.ts

@@ -0,0 +1,61 @@
+/**
+ * Combines multiple AbortSignals into one that aborts when any of the source signals abort.
+ *
+ * This is a custom implementation to work around memory leaks in Node.js's AbortSignal.any().
+ * Bun's implementation is fine, so we use the native version there.
+ *
+ * @see https://github.com/nodejs/node/issues/54614
+ */
+export function anyAbortSignal(
+  ...signals: (AbortSignal | undefined)[]
+): AbortSignal {
+  const filtered = signals.filter(Boolean) as AbortSignal[]
+
+  if (filtered.length === 0) {
+    return new AbortController().signal
+  }
+
+  if (filtered.length === 1) {
+    return filtered[0]
+  }
+
+  // Use native implementation on Bun (no memory leak there)
+  if ('Bun' in globalThis) {
+    return AbortSignal.any(filtered)
+  }
+
+  // Custom implementation for Node.js to avoid memory leaks
+  const controller = new AbortController()
+
+  // Check if any signal is already aborted
+  for (const signal of filtered) {
+    if (signal.aborted) {
+      controller.abort()
+      return controller.signal
+    }
+  }
+
+  // Track cleanup functions
+  const cleanups: (() => void)[] = []
+
+  const onAbort = () => {
+    controller.abort()
+    // Clean up all listeners immediately after abort
+    cleanup()
+  }
+
+  const cleanup = () => {
+    for (const fn of cleanups) {
+      fn()
+    }
+    cleanups.length = 0
+  }
+
+  // Attach listeners to all signals
+  for (const signal of filtered) {
+    signal.addEventListener('abort', onAbort, { once: true })
+    cleanups.push(() => signal.removeEventListener('abort', onAbort))
+  }
+
+  return controller.signal
+}

package/src/constants.ts

@@ -0,0 +1,3 @@
+export const MAX_UINT32 = 2 ** 32 - 1
+export const MAX_UINT16 = 2 ** 16 - 1
+export const MAX_UINT8 = 2 ** 8 - 1

package/src/index.ts

@@ -0,0 +1,5 @@
+export * from './abortSignal.ts'
+export * from './constants.ts'
+export * from './streams.ts'
+export * from './types.ts'
+export * from './utils.ts'

package/src/streams.ts

@@ -0,0 +1,52 @@
+// TODO: add proper queueing/backpressure strategy support
+
+import type { Async } from './types.ts'
+
+export interface DuplexStreamOptions<O = unknown, I = O> {
+  start?: (controller: ReadableStreamDefaultController<O>) => void
+  pull?: (controller: ReadableStreamDefaultController<O>) => Async<void>
+  cancel?: (reason: unknown) => void
+  transform?: (chunk: I) => O
+  close?: () => void
+  readableStrategy?: QueuingStrategy<O>
+  writableStrategy?: QueuingStrategy<I>
+}
+
+export class DuplexStream<O = unknown, I = O> {
+  readonly readable: ReadableStream<O>
+  readonly writable!: WritableStream<I>
+
+  constructor(options: DuplexStreamOptions<O, I> = {}) {
+    this.readable = new ReadableStream<O>(
+      {
+        cancel: options.cancel,
+        start: (controller) => {
+          // @ts-expect-error
+          this.writable = new WritableStream<I>(
+            {
+              write: (_chunk) => {
+                const chunk = options?.transform
+                  ? options?.transform(_chunk)
+                  : _chunk
+                controller.enqueue(chunk as O)
+              },
+              abort: (reason) => controller.error(reason),
+              close: () => {
+                options?.close?.()
+                try {
+                  controller.close()
+                } catch {
+                  // Controller may already be closed (e.g., via cancel)
+                }
+              },
+            },
+            options.writableStrategy,
+          )
+          options.start?.(controller)
+        },
+        pull: options?.pull,
+      },
+      options.readableStrategy,
+    )
+  }
+}

package/src/types.ts

@@ -0,0 +1,80 @@
+const TSErrorSymbol: unique symbol = Symbol('TSError')
+
+export type TSError<T extends string = string> = `Error: ${T}` & {
+  [TSErrorSymbol]: true
+}
+
+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 }
+
+export type Pattern = RegExp | string | ((value: string) => boolean)

package/src/utils.ts

@@ -0,0 +1,174 @@
+import type { Callback, Pattern } from './types.ts'
+
+export const noopFn = () => {}
+
+export function merge<T extends any[]>(...objects: T) {
+  return Object.assign({}, ...objects)
+}
+
+export function unique<T>(array: Iterable<T>): Iterable<T> {
+  return new Set(array).values()
+}
+
+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 Future<T = any> {
+  promise: Promise<T>
+  resolve: (value: T) => void
+  reject: (error: any) => void
+}
+// TODO: Promise.withResolvers?
+export function createFuture<T>(): Future<T> {
+  let resolve: Future<T>['resolve']
+  let reject: Future<T>['reject']
+  const promise = new Promise<T>((res, rej) => {
+    resolve = res
+    reject = rej
+  })
+  // @ts-expect-error
+  return { resolve, reject, promise }
+}
+
+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,
+) {
+  return Promise.race([
+    value,
+    new Promise((_, reject) => setTimeout(reject, timeout, timeoutError)),
+  ])
+}
+
+export function tryCaptureStackTrace(depth = 0) {
+  const traceLines = new Error().stack?.split('\n')
+  if (traceLines) {
+    for (const traceLine of traceLines) {
+      const trimmed = traceLine.trim()
+
+      if (trimmed.startsWith('at eval (') && trimmed.endsWith(')')) {
+        const trace = trimmed.slice(9, -1)
+        return trace
+      }
+    }
+  }
+  return 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 isAsyncIterable(value: any): value is AsyncIterable<unknown> {
+  return value && typeof value === 'object' && Symbol.asyncIterator in value
+}
+
+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) {
+  return (
+    (error instanceof Error &&
+      error.name === 'AbortError' &&
+      'code' in error &&
+      (error.code === 20 || error.code === 'ABORT_ERR')) ||
+    (error instanceof Event && error.type === 'abort')
+  )
+}
+
+/**
+ * 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)
+  }
+}