monorepon't

packages/helpers/deferred.test.ts

@@ -1,16 +0,0 @@
-import { expect, test } from "vitest"
-import { createDeferred } from "./deferred.js"
-
-test("resolve", async () => {
-  const deferred = createDeferred<string>()
-  setTimeout(() => deferred.resolve("hi"))
-  expect(await deferred).toBe("hi")
-})
-
-test("reject", async () => {
-  const deferred = createDeferred()
-  const error = new Error("oops")
-  setTimeout(() => deferred.reject(error))
-  const caught = await Promise.resolve(deferred).catch((error) => error)
-  expect(caught).toBe(error)
-})

packages/helpers/deferred.ts

@@ -1,21 +0,0 @@
-// eslint-disable-next-line import/no-unused-modules
-export type Deferred<T> = PromiseLike<T> & {
-  resolve: (value: T | PromiseLike<T>) => void
-  reject: (reason?: unknown) => void
-}
-
-export function createDeferred<T = void>(): Deferred<T> {
-  let resolve: (value: T | PromiseLike<T>) => void
-  let reject: (reason?: unknown) => void
-
-  const promise = new Promise<T>((_resolve, _reject) => {
-    resolve = _resolve
-    reject = _reject
-  })
-
-  return {
-    then: promise.then.bind(promise),
-    resolve: (value) => resolve(value),
-    reject: (reason) => reject(reason),
-  }
-}

packages/helpers/package.json

@@ -1,7 +0,0 @@
-{
-  "name": "reacord-helpers",
-  "private": true,
-  "devDependencies": {
-    "@types/node": "^16.11.14"
-  }
-}

packages/helpers/pick.ts

@@ -1,13 +0,0 @@
-export function pick<T, K extends keyof T>(
-  object: T,
-  ...keys: K[]
-): Pick<T, K> {
-  const result: any = {}
-  for (const key of keys) {
-    const value = object[key]
-    if (value !== undefined) {
-      result[key] = value
-    }
-  }
-  return result
-}

packages/helpers/raise.ts

@@ -1,5 +0,0 @@
-import { toError } from "./to-error.js"
-
-export function raise(error: unknown): never {
-  throw toError(error)
-}

packages/helpers/reject-after.ts

@@ -1,10 +0,0 @@
-import { setTimeout } from "node:timers/promises"
-import { toError } from "./to-error.js"
-
-export async function rejectAfter(
-  timeMs: number,
-  error: unknown = `rejected after ${timeMs}ms`,
-): Promise<never> {
-  await setTimeout(timeMs)
-  return Promise.reject(toError(error))
-}

packages/helpers/to-error.ts

@@ -1,3 +0,0 @@
-export function toError(value: unknown) {
-  return value instanceof Error ? value : new Error(String(value))
-}

packages/helpers/types.ts

@@ -1,5 +0,0 @@
-export type MaybePromise<T> = T | Promise<T>
-
-export type ValueOf<Type> = Type extends ReadonlyArray<infer Value>
-  ? Value
-  : Type[keyof Type]

packages/helpers/wait-for-with-timeout.ts

@@ -1,11 +0,0 @@
-import { rejectAfter } from "./reject-after.js"
-import type { MaybePromise } from "./types.js"
-import { waitFor } from "./wait-for.js"
-
-export function waitForWithTimeout(
-  condition: () => MaybePromise<boolean>,
-  timeout = 1000,
-  errorMessage = `timed out after ${timeout}ms`,
-) {
-  return Promise.race([waitFor(condition), rejectAfter(timeout, errorMessage)])
-}

packages/helpers/wait-for.ts

@@ -1,8 +0,0 @@
-import { setTimeout } from "node:timers/promises"
-import type { MaybePromise } from "./types.js"
-
-export async function waitFor(condition: () => MaybePromise<boolean>) {
-  while (!(await condition())) {
-    await setTimeout(100)
-  }
-}

packages/helpers/with-logged-method-calls.ts

@@ -1,20 +0,0 @@
-import { inspect } from "node:util"
-
-export function withLoggedMethodCalls<T extends object>(value: T) {
-  return new Proxy(value as Record<string | symbol, unknown>, {
-    get(target, property) {
-      const value = target[property]
-      if (typeof value !== "function") {
-        return value
-      }
-      return (...values: any[]) => {
-        console.log(
-          `${String(property)}(${values
-            .map((value) => inspect(value, { depth: 1 }))
-            .join(", ")})`,
-        )
-        return value.apply(target, values)
-      }
-    },
-  }) as T
-}