@tempots/std 0.9.5 → 0.9.7

package/src/async-result.ts

@@ -1,103 +0,0 @@
-export interface Idle {
-  type: 'idle'
-}
-export interface Loading {
-  type: 'loading'
-}
-export interface Success<V> {
-  type: 'success'
-  value: V
-}
-export interface Failure<E> {
-  type: 'failure'
-  error: E
-}
-
-export type AsyncResult<V, E> = Idle | Loading | Success<V> | Failure<E>
-
-// eslint-disable-next-line @typescript-eslint/no-redeclare
-export const AsyncResult = {
-  idle: { type: 'idle' } satisfies AsyncResult<never, never>,
-  loading: { type: 'loading' } satisfies AsyncResult<never, never>,
-  success<V>(value: V): AsyncResult<V, never> {
-    return { type: 'success', value }
-  },
-  failure<E>(error: E): AsyncResult<never, E> {
-    return { type: 'failure', error }
-  },
-  isSuccess<V, E>(r: AsyncResult<V, E>): r is Success<V> {
-    return r.type === 'success'
-  },
-  isFailure<V, E>(r: AsyncResult<V, E>): r is Failure<E> {
-    return r.type === 'failure'
-  },
-  isIdle<V, E>(r: AsyncResult<V, E>): r is Idle {
-    return r.type === 'idle'
-  },
-  isLoading<V, E>(r: AsyncResult<V, E>): r is Loading {
-    return r.type === 'loading'
-  },
-  getOrElse<V, E>(r: AsyncResult<V, E>, alt: V): V {
-    return AsyncResult.isSuccess(r) ? r.value : alt
-  },
-  getOrElseLazy<V, E>(r: AsyncResult<V, E>, altf: () => V): V {
-    return AsyncResult.isSuccess(r) ? r.value : altf()
-  },
-  getOrNull<V, E>(r: AsyncResult<V, E>): V | null {
-    return AsyncResult.isSuccess(r) ? r.value : null
-  },
-  getOrUndefined<V, E>(r: AsyncResult<V, E>): V | undefined {
-    return AsyncResult.isSuccess(r) ? r.value : undefined
-  },
-  cmatch:
-    <V1, V2, E>(
-    success: (value: V1) => V2,
-    failure: (error: E) => V2,
-    loading: () => V2,
-    idle: () => V2 = loading
-  ) =>
-    (r: AsyncResult<V1, E>): V2 => {
-      if (AsyncResult.isSuccess(r)) {
-        return success(r.value)
-      } else if (AsyncResult.isFailure(r)) {
-        return failure(r.error)
-      } else if (AsyncResult.isIdle(r)) {
-        return idle()
-      } else {
-        return loading()
-      }
-    },
-  match: <V1, V2, E>(
-    r: AsyncResult<V1, E>,
-    success: (value: V1) => V2,
-    failure: (error: E) => V2,
-    loading: () => V2,
-    idle: () => V2 = loading
-  ): V2 => {
-    if (AsyncResult.isSuccess(r)) {
-      return success(r.value)
-    } else if (AsyncResult.isFailure(r)) {
-      return failure(r.error)
-    } else if (AsyncResult.isIdle(r)) {
-      return idle()
-    } else {
-      return loading()
-    }
-  },
-  whenSuccess:
-    <V, E>(apply: (v: V) => void) =>
-    (r: AsyncResult<V, E>): AsyncResult<V, E> => {
-      if (AsyncResult.isSuccess(r)) {
-        apply(r.value)
-      }
-      return r
-    },
-  whenFailure:
-    <V, E>(apply: (e: E) => void) =>
-    (r: AsyncResult<V, E>): AsyncResult<V, E> => {
-      if (AsyncResult.isFailure(r)) {
-        apply(r.error)
-      }
-      return r
-    }
-}

package/src/bigint.ts

@@ -1,111 +0,0 @@
-export function ceilDiv (x: bigint, y: bigint): bigint {
-  if (y < 0n) {
-    x = -x
-    y = -y
-  }
-  return x <= 0n ? x / y : (x - 1n) / y + 1n
-}
-
-export function floorDiv (x: bigint, y: bigint): bigint {
-  if (y < 0n) {
-    x = -x
-    y = -y
-  }
-  return x >= 0n ? x / y : (x + 1n) / y - 1n
-}
-
-export function compare (x: bigint, y: bigint): number {
-  return x < y ? -1 : x > y ? 1 : 0
-}
-
-export function abs (x: bigint): bigint {
-  return x < 0n ? -x : x
-}
-
-export function min (x: bigint, y: bigint): bigint {
-  return x < y ? x : y
-}
-
-export function max (x: bigint, y: bigint): bigint {
-  return x > y ? x : y
-}
-
-export function pow (x: bigint, y: bigint): bigint {
-  if (y < 0n) throw new Error('negative exponent')
-  let result = 1n
-  while (y > 0n) {
-    if ((y & 1n) !== 0n) result *= x
-    y >>= 1n
-    x *= x
-  }
-  return result
-}
-
-export function gcd (x: bigint, y: bigint): bigint {
-  x = abs(x)
-  y = abs(y)
-  while (y > 0n) {
-    const t = y
-    y = x % y
-    x = t
-  }
-  return x
-}
-
-export function lcm (x: bigint, y: bigint): bigint {
-  return abs(x * y) / gcd(x, y)
-}
-
-export function isPrime (x: bigint): boolean {
-  if (x < 2n) return false
-  if (x === 2n || x === 3n) return true
-  if (x % 2n === 0n || x % 3n === 0n) return false
-  let i = 5n
-  while (i * i <= x) {
-    if (x % i === 0n || x % (i + 2n) === 0n) return false
-    i += 6n
-  }
-  return true
-}
-
-export function nextPrime (x: bigint): bigint {
-  if (x < 2n) return 2n
-  if (x === 2n) return 3n
-  if (x % 2n === 0n) x++
-  else x += 2n
-  while (!isPrime(x)) x += 2n
-  return x
-}
-
-export function prevPrime (x: bigint): bigint {
-  if (x <= 2n) throw new Error('no previous prime')
-  if (x === 3n) return 2n
-  if (x % 2n === 0n) x--
-  else x -= 2n
-  while (!isPrime(x)) x -= 2n
-  return x
-}
-
-export function isEven (x: bigint): boolean {
-  return x % 2n === 0n
-}
-
-export function isOdd (x: bigint): boolean {
-  return x % 2n !== 0n
-}
-
-export function isZero (x: bigint): boolean {
-  return x === 0n
-}
-
-export function isOne (x: bigint): boolean {
-  return x === 1n
-}
-
-export function isNegative (x: bigint): boolean {
-  return x < 0n
-}
-
-export function isPositive (x: bigint): boolean {
-  return x > 0n
-}

package/src/colors/cmyk.ts

@@ -1,84 +0,0 @@
-import { clamp, nearEquals } from '../numbers'
-
-const TOLLERANCE = 0.0001
-
-export class CMYK {
-  static fromString (s: string): CMYK {
-    const m = s.match(
-      /^cmyk\((\d+(?:\.\d+)?)%, ?(\d+(?:\.\d+)?)%, ?(\d+(?:\.\d+)?)%, ?(\d+(?:\.\d+)?)%\)$/
-    )
-    if (m != null) {
-      const [, cyan, magenta, y, k] = m
-      return new CMYK(
-        parseFloat(cyan),
-        parseFloat(magenta),
-        parseFloat(y),
-        parseFloat(k)
-      )
-    }
-    throw new Error(`Invalid CMYK string: ${s}`)
-  }
-
-  static ofChannels ([cyan, magenta, yellow, black]: [
-    cyan: number,
-    magenta: number,
-    yellow: number,
-    black: number
-  ]): CMYK {
-    return new CMYK(
-      clamp(cyan * 100, 0, 100),
-      clamp(magenta * 100, 0, 100),
-      clamp(yellow * 100, 0, 100),
-      clamp(black * 100, 0, 100)
-    )
-  }
-
-  readonly cyan: number
-  readonly magenta: number
-  readonly yellow: number
-  readonly black: number
-  constructor (cyan: number, magenta: number, yellow: number, black: number) {
-    this.cyan = clamp(cyan, 0, 100)
-    this.magenta = clamp(magenta, 0, 100)
-    this.yellow = clamp(yellow, 0, 100)
-    this.black = clamp(black, 0, 100)
-  }
-
-  withCyan (cyan: number): CMYK {
-    return new CMYK(cyan, this.magenta, this.yellow, this.black)
-  }
-
-  withMagenta (magenta: number): CMYK {
-    return new CMYK(this.cyan, magenta, this.yellow, this.black)
-  }
-
-  withYellow (yellow: number): CMYK {
-    return new CMYK(this.cyan, this.magenta, yellow, this.black)
-  }
-
-  withBlack (black: number): CMYK {
-    return new CMYK(this.cyan, this.magenta, this.yellow, black)
-  }
-
-  toChannels (): [number, number, number, number] {
-    return [
-      this.cyan / 100,
-      this.magenta / 100,
-      this.yellow / 100,
-      this.black / 100
-    ]
-  }
-
-  toString (): string {
-    return `cmyk(${this.cyan}%, ${this.magenta}%, ${this.yellow}%, ${this.black}%)`
-  }
-
-  equals (other: CMYK, tollerance = TOLLERANCE): boolean {
-    return (
-      nearEquals(this.cyan, other.cyan, tollerance) &&
-      nearEquals(this.magenta, other.magenta, tollerance) &&
-      nearEquals(this.yellow, other.yellow, tollerance) &&
-      nearEquals(this.black, other.black, tollerance)
-    )
-  }
-}