@tempots/std 0.9.6 → 0.10.3

package/src/arrays.ts

@@ -1,296 +0,0 @@
-/*
-Copyright 2019 Google LLC
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-    https://www.apache.org/licenses/LICENSE-2.0
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-/**
- * Utility functions to manipulate `Array` values.
- */
-
-import { Maybe } from './maybe'
-import { type Ordering, type Compare } from './ord'
-import { type Primitive } from './types/utility'
-import { keys } from './objects'
-
-export function map<A, B> (arr: A[], f: (a: A, index: number) => B): B[] {
-  return Array.from({ length: arr.length }, (_, i) => f(arr[i], i))
-}
-
-export function mapNotNull<A, B> (
-  arr: A[],
-  f: (a: A, index: number) => B | null | undefined
-): B[] {
-  const buff = [] as B[]
-  for (let i = 0; i < arr.length; i++) {
-    const v = f(arr[i], i)
-    if (v != null) {
-      buff.push(v)
-    }
-  }
-  return buff
-}
-
-export function flatMap<A, B> (arr: A[], f: (a: A) => B[]): B[] {
-  const buff = []
-  for (const el of arr) {
-    buff.push(...f(el))
-  }
-  return buff
-}
-
-export function head<A> (arr: A[]): Maybe<A> {
-  return arr.length > 0 ? arr[0] : Maybe.nothing
-}
-
-export function tail<A> (arr: A[]): A[] {
-  return arr.slice(1)
-}
-
-export function equals<T> (a: T[], b: T[], equality: (a: T, b: T) => boolean): boolean {
-  if (a.length !== b.length) return false
-  else {
-    for (let i = 0; i < a.length; i++) {
-      if (!equality(a[i], b[i])) return false
-    }
-    return true
-  }
-}
-
-export function makeEquals<T> (equality: (a: T, b: T) => boolean) {
-  return function (a: T[], b: T[]) {
-    return equals(a, b, equality)
-  }
-}
-
-export function isEmpty<T> (arr: T[]): arr is [] {
-  return arr.length === 0
-}
-
-export function hasValues<T> (arr: T[]): arr is [T, ...T[]] {
-  return arr.length > 0
-}
-
-export function filter<T> (arr: T[], predicate: (v: T) => boolean): T[] {
-  const buff = [] as T[]
-  for (const a of arr) if (predicate(a)) buff.push(a)
-  return buff
-}
-
-export function filterNulls<T> (arr: Array<T | null | undefined>): T[] {
-  return filter(arr, v => v != null) as T[]
-}
-
-export function flatten<T> (arr: T[][]): T[] {
-  return ([] as T[]).concat(...arr)
-}
-
-export function foldLeft<T, B> (arr: T[], f: (acc: B, curr: T) => B, b: B): B {
-  for (const a of arr) {
-    b = f(b, a)
-  }
-  return b
-}
-
-export function all<T> (arr: T[], predicate: (v: T) => boolean): boolean {
-  for (const a of arr) {
-    if (!predicate(a)) {
-      return false
-    }
-  }
-  return true
-}
-
-export function any<T> (arr: T[], predicate: (v: T) => boolean): boolean {
-  for (const a of arr) {
-    if (predicate(a)) {
-      return true
-    }
-  }
-  return false
-}
-
-export function each<T> (arr: T[], f: (v: T) => void): void {
-  for (const a of arr) f(a)
-}
-
-export function concat<A> (...arrs: A[][]): A[] {
-  return ([] as A[]).concat(...arrs)
-}
-
-export function makeCompare<A> (comparef: Compare<A>, shorterFirst = true) {
-  return function (a: A[], b: A[]) {
-    if (a.length < b.length) {
-      return -1 * (shorterFirst ? 1 : -1)
-    } else if (a.length > b.length) {
-      return 1 * (shorterFirst ? 1 : -1)
-    }
-    for (let i = 0; i < a.length; i++) {
-      const ord = comparef(a[i], b[i])
-      if (ord !== 0) return ord
-    }
-    return 0
-  }
-}
-
-export function sort<A> (compare: (a: A, b: A) => Ordering, arr: A[]): A[] {
-  return arr.slice().sort(compare)
-}
-
-export function range<A> (length: number, f: (index: number) => A): A[] {
-  return Array.from({ length }, (_, i) => f(i))
-}
-
-export function numbersRange (length: number, startAt = 0): number[] {
-  return range(length, i => startAt + i)
-}
-
-export function fill<A> (length: number, value: A): A[] {
-  return range(length, () => value)
-}
-
-export function distinctPrimitive<T extends Primitive> (values: T[]): T[] {
-  return Array.from(new Set(values))
-}
-
-export function distinctByPredicate<T> (
-  values: T[],
-  predicate: (a: T) => string
-): T[] {
-  const map: Record<string, T> = {}
-  values.forEach(v => {
-    map[predicate(v)] = v
-  })
-  return keys(map).map(k => map[k])
-}
-
-export function remove<A> (
-  arr: A[],
-  item: A,
-  predicate?: (a: A) => boolean
-): boolean {
-  let index
-  if (predicate !== undefined) {
-    index = arr.findIndex(predicate)
-  } else {
-    index = arr.indexOf(item)
-  }
-  if (index < 0) {
-    return false
-  } else {
-    arr.splice(index, 1)
-    return true
-  }
-}
-
-export function ofIterableIterator<A> (it: IterableIterator<A>): A[] {
-  const buff = [] as A[]
-  for (let r = it.next(); !(r.done ?? false); r = it.next()) {
-    buff.push(r.value)
-  }
-  return buff
-}
-
-export interface DiffOperations<T> {
-  removals: Array<{ at: number, qt: number }>
-  swaps: Array<{ from: number, to: number }>
-  inserts: Array<{ at: number, values: T[] }>
-}
-
-export function diffOperations<T, K> (
-  from: T[],
-  to: T[],
-  getKey: (v: T) => K
-): DiffOperations<T> {
-  const ops: DiffOperations<T> = {
-    removals: [],
-    swaps: [],
-    inserts: []
-  }
-  const { removals, inserts, swaps } = ops
-  const mapB = new Map<K, number>()
-  to.forEach((v, i) => mapB.set(getKey(v), i))
-
-  const indexesOfAThatDoNotExistInB = from
-    .map((v, i) => [v, i] as const)
-    .filter(([v]) => !mapB.has(getKey(v)))
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    .map(([_, i]) => i)
-  for (let i = indexesOfAThatDoNotExistInB.length - 1; i >= 0; i--) {
-    const p = indexesOfAThatDoNotExistInB[i]
-    const last = removals.length > 0 ? removals[removals.length - 1] : undefined
-    if ((last != null) && last.at === p + 1) {
-      last.at--
-      last.qt++
-    } else {
-      removals.push({ at: p, qt: 1 })
-    }
-  }
-
-  const mapA = new Map<K, number>()
-  from.forEach((v, i) => mapA.set(getKey(v), i))
-
-  const indexesOfBThatDoNotExistInA = to
-    .map((v, i) => [v, i] as const)
-    .filter(([v]) => !mapA.has(getKey(v)))
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    .map(([_, i]) => i)
-  for (const p of indexesOfBThatDoNotExistInA) {
-    const last = inserts.length > 0 ? inserts[inserts.length - 1] : undefined
-    if ((last != null) && last.at + last.values.length === p) {
-      last.values.push(to[p])
-    } else {
-      inserts.push({ at: p, values: [to[p]] })
-    }
-  }
-
-  const ra = from.filter((_, i) => !indexesOfAThatDoNotExistInB.includes(i))
-  const mapRA = new Map<K, number>()
-  for (let i = 0; i < ra.length; i++) {
-    mapRA.set(getKey(ra[i]), i)
-  }
-
-  const rb = to.filter((_, i) => !indexesOfBThatDoNotExistInA.includes(i))
-  for (let i = 0; i < rb.length; i++) {
-    const bk = getKey(rb[i])
-    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-    const ai = mapRA.get(bk)!
-    if (ai == null || i === ai) continue
-    const ak = getKey(ra[i])
-    mapRA.delete(ak)
-    swaps.push({ from: i, to: ai })
-  }
-  return ops
-}
-
-export function applyOperations<T> (
-  operations: DiffOperations<T>,
-  start: T[]
-): T[] {
-  const buff = [...start]
-  for (const { at, qt } of operations.removals) {
-    buff.splice(at, qt)
-  }
-  for (const { from, to } of operations.swaps) {
-    const t = buff[to]
-    buff[to] = buff[from]
-    buff[from] = t
-  }
-  for (const op of operations.inserts) {
-    buff.splice(op.at, 0, ...op.values)
-  }
-  return buff
-}
-
-export function joinWithConjunction<A> (arr: A[], conjunction = ' and ', separator = ', '): string {
-  if (arr.length === 0) return ''
-  if (arr.length === 1) return String(arr[0])
-  return `${arr.slice(0, -1).join(separator)}${conjunction}${String(arr[arr.length - 1])}`
-}

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/booleans.ts

@@ -1,73 +0,0 @@
-/*
-Copyright 2019 Google LLC
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-    https://www.apache.org/licenses/LICENSE-2.0
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-/**
- * Utility functions to manipulate `boolean` values.
- */
-
-/**
- * Returns a comparison value (`Int`) from two boolean values.
- */
-export function compare (a: boolean, b: boolean): number {
-  return a === b ? 0 : a ? -1 : 1
-}
-
-/**
- * Converts a boolean to an integer value (`true` => `1`, `false` => `0`).
- */
-export function toInt (v: boolean): number {
-  return v ? 1 : 0
-}
-
-/**
- * Returns `true` if the passed value is either `true` or `false` (case insensitive).
- */
-export function canParse (v: string): boolean {
-  if (v == null) return false
-  switch (v.toLowerCase()) {
-    case 'true':
-    case 'false':
-    case '0':
-    case '1':
-    case 'on':
-    case 'off':
-      return true
-    default:
-      return false
-  }
-}
-
-/**
- * Returns `true`/`false` if the passed value is `true`/`false` (case insensitive) with any other value it will return null.
- */
-export function parse (v: string): boolean {
-  switch (v.toLowerCase()) {
-    case 'true':
-    case '1':
-    case 'on':
-      return true
-    case 'false':
-    case '0':
-    case 'off':
-      return false
-    default:
-      throw new Error(`unable to parse '${v}'`)
-  }
-}
-
-/**
- * Returns `true` when arguments are different.
- */
-export function xor (a: boolean, b: boolean): boolean {
-  return a !== b
-}

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