@tempots/std 0.9.0

package/src/arrays.ts

@@ -0,0 +1,296 @@
+/*
+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

@@ -0,0 +1,103 @@
+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

@@ -0,0 +1,111 @@
+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

@@ -0,0 +1,73 @@
+/*
+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

@@ -0,0 +1,84 @@
+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)
+    )
+  }
+}