@tempots/std 0.9.6 → 0.10.3

package/src/numbers.ts

@@ -1,222 +0,0 @@
-import { lpad } from './strings'
-
-export const TOLERANCE = 10e-5
-
-/**
-  Constant value employed to see if two `number` values are very close.
-**/
-export const EPSILON = 1e-9
-
-/**
-Returns the angular distance between 2 angles.
-**/
-export function angleDifference (a: number, b: number, turn = 360.0): number {
-  let r = (b - a) % turn
-  if (r < 0) r += turn
-  if (r > turn / 2) r -= turn
-  return r
-}
-
-/**
-Rounds a number up to the specified number of decimals.
-**/
-export function ceilTo (v: number, decimals: number): number {
-  const p = Math.pow(10, decimals)
-  return Math.ceil(v * p) / p
-}
-
-/**
-`clamp` restricts a value within the specified range.
-```ts
-log(clamp(1.3, 0, 1)) // prints 1
-log(clamp(0.8, 0, 1)) // prints 0.8
-log(clamp(-0.5, 0, 1)) // prints 0.0
-```
-**/
-export function clamp (value: number, min: number, max: number): number {
-  return Math.min(Math.max(value, min), max)
-}
-
-export function clampInt (value: number, min: number, max: number): number {
-  return Math.trunc(clamp(value, min, max))
-}
-
-/**
-Like clamp but you only pass one argument (`max`) that is used as the upper limit
-and the opposite (additive inverse or `-max`) as the lower limit.
-**/
-export function clampSym (v: number, max: number): number {
-  return clamp(v, -max, max)
-}
-
-/**
-It returns the comparison value (an integer number) between two `float` values.
-**/
-export function compare (a: number, b: number): number {
-  return a < b ? -1 : a > b ? 1 : 0
-}
-
-/**
-Rounds a number down to the specified number of decimals.
-**/
-export function floorTo (v: number, decimals: number): number {
-  const p = Math.pow(10, decimals)
-  return Math.floor(v * p) / p
-}
-
-/**
-`normalize` clamps the passwed value between 0 and 1.
-**/
-export function normalize (value: number): number {
-  return clamp(value, 0, 1)
-}
-
-export function toHex (num: number, length = 0): string {
-  return lpad(num.toString(16), '0', length)
-}
-
-/**
-`interpolate` returns a value between `a` and `b` for any value of `t` (normally between 0 and 1).
-**/
-export function interpolate (a: number, b: number, t: number): number {
-  return (b - a) * t + a
-}
-
-/**
-Interpolates values in a polar coordinate system looking for the narrowest delta angle.
-It can be either clock-wise or counter-clock-wise.
-**/
-export function interpolateAngle (
-  a: number,
-  b: number,
-  t: number,
-  turn = 360.0
-): number {
-  return wrapCircular(interpolate(a, a + angleDifference(a, b, turn), t), turn)
-}
-
-/**
-Interpolates values in a polar coordinate system looking for the wideset delta angle.
-It can be either clock-wise or counter-clock-wise.
-**/
-export function interpolateAngleWidest (
-  a: number,
-  b: number,
-  t: number,
-  turn = 360
-): number {
-  return wrapCircular(interpolateAngle(a, b, t, turn) - turn / 2, turn)
-}
-
-/**
-Interpolates values in a polar coordinate system always in clock-wise direction.
-**/
-export function interpolateAngleCW (
-  a: number,
-  b: number,
-  t: number,
-  turn = 360
-): number {
-  a = wrapCircular(a, turn)
-  b = wrapCircular(b, turn)
-  if (b < a) b += turn
-  return wrapCircular(interpolate(a, b, t), turn)
-}
-
-/**
-Interpolates values in a polar coordinate system always in counter-clock-wise direction.
-**/
-export function interpolateAngleCCW (
-  a: number,
-  b: number,
-  t: number,
-  turn = 360
-): number {
-  a = wrapCircular(a, turn)
-  b = wrapCircular(b, turn)
-  if (b > a) b -= turn
-  return wrapCircular(interpolate(a, b, t), turn)
-}
-
-/**
-number numbers can sometime introduce tiny errors even for simple operations.
-`nearEquals` compares two floats using a tiny tollerance (last optional
-argument). By default it is defined as `EPSILON`.
-**/
-export function nearEquals (a: number, b: number, tollerance = EPSILON): boolean {
-  if (isFinite(a)) {
-    if (!isFinite(b)) return false
-    return Math.abs(a - b) <= tollerance
-  }
-  if (isNaN(a)) return isNaN(b)
-  if (isNaN(b)) return false
-  if (!isFinite(b)) return (a > 0) === (b > 0)
-  // a is Infinity and b is finite
-  return false
-}
-
-/**
-number numbers can sometime introduce tiny errors even for simple operations.
-`nearEqualAngles` compares two angles (default is 360deg) using a tiny
-tollerance (last optional argument). By default the tollerance is defined as
-`EPSILON`.
-**/
-export function nearEqualAngles (
-  a: number,
-  b: number,
-  turn = 360.0,
-  tollerance = EPSILON
-): boolean {
-  return Math.abs(angleDifference(a, b, turn)) <= tollerance
-}
-
-/**
-`nearZero` finds if the passed number is zero or very close to it. By default
-`EPSILON` is used as the tollerance value.
-**/
-export function nearZero (n: number, tollerance = EPSILON): boolean {
-  return Math.abs(n) <= tollerance
-}
-
-/**
-Computes the nth root (`index`) of `base`.
-**/
-export function root (base: number, index: number): number {
-  return Math.pow(base, 1 / index)
-}
-
-/**
-Rounds a number to the specified number of decimals.
-**/
-export function roundTo (f: number, decimals: number): number {
-  const p = Math.pow(10, decimals)
-  return Math.fround(f * p) / p
-}
-
-/**
-`sign` returns `-1` if `value` is a negative number, `1` otherwise.
-*/
-export function sign<T extends number> (value: T): number {
-  return value < 0 ? -1 : 1
-}
-
-/**
-Passed two boundaries values (`min`, `max`), `wrap` ensures that the passed value `v` will
-be included in the boundaries. If the value exceeds `max`, the value is reduced by `min`
-repeatedely until it falls within the range. Similar and inverted treatment is performed if
-the value is below `min`.
-**/
-export function wrap (v: number, min: number, max: number): number {
-  const range = max - min + 1
-  if (v < min) v += range * ((min - v) / range + 1)
-  return min + ((v - min) % range)
-}
-
-/**
-Similar to `wrap`, it works for numbers between 0 and `max`.
-**/
-export function wrapCircular (v: number, max: number): number {
-  v = v % max
-  if (v < 0) v += max
-  return v
-}

package/src/objects.ts

@@ -1,47 +0,0 @@
-import { type TupleToUnion } from './types/tuples'
-import { type Merge } from './types/objects'
-import { type AnyKey } from './types/utility'
-
-export function keys<T extends object> (obj: T): Array<keyof T> {
-  return Object.keys(obj) as Array<keyof T>
-}
-
-export function sameKeys<T extends object> (a: T, b: T): boolean {
-  const ak = keys(a)
-  const bk = keys(b)
-  if (ak.length !== bk.length) return false
-  for (const k of ak) {
-    if (!(k in b)) return false
-  }
-  return true
-}
-
-export function isObject (obj: unknown): obj is Record<AnyKey, unknown> {
-  return Object.prototype.toString.call(obj) === '[object Object]'
-}
-
-export function removeFields<T extends object, F extends Array<keyof T>> (
-  ob: T,
-  ...fields: F
-): Omit<T, TupleToUnion<F>> {
-  const ks = keys(ob)
-  return ks.reduce((acc: Record<AnyKey, unknown>, key) => {
-    if (!fields.includes(key)) acc[key] = ob[key]
-    return acc
-  }, {}) as Omit<T, TupleToUnion<F>>
-}
-
-export function merge<
-  A extends Record<AnyKey, unknown>,
-  B extends Record<AnyKey, unknown>
-> (a: A, b: B): Merge<A, B> {
-  return Object.assign({}, a, b) as Merge<A, B>
-}
-
-export function isEmpty (obj: object): boolean {
-  return (
-    obj != null &&
-    Object.keys(obj).length === 0 &&
-    Object.getPrototypeOf(obj) === Object.prototype
-  )
-}

package/src/ord.ts

@@ -1,79 +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.
-*/
-
-export enum Ordering {
-  LT = -1,
-  EQ = 0,
-  GT = 1
-}
-
-export type CompareOrd<T> = (a: T, b: T) => Ordering
-export type Compare<T> = (a: T, b: T) => number
-
-export class Ord<T> {
-  static fromNumberComparison<T>(compare: (a: T, b: T) => number): Ord<T> {
-    return new Ord<T>(fromNumberComparison(compare))
-  }
-
-  constructor (readonly compare: CompareOrd<T>) {}
-
-  max (a: T, b: T): T {
-    switch (this.compare(a, b)) {
-      case Ordering.LT:
-      case Ordering.EQ:
-        return a
-      case Ordering.GT:
-        return b
-    }
-  }
-
-  min (a: T, b: T): T {
-    switch (this.compare(a, b)) {
-      case Ordering.GT:
-      case Ordering.EQ:
-        return a
-      case Ordering.LT:
-        return b
-    }
-  }
-
-  equals (a: T, b: T): boolean {
-    switch (this.compare(a, b)) {
-      case Ordering.EQ:
-        return true
-      default:
-        return false
-    }
-  }
-
-  contramap<B>(f: (b: B) => T): Ord<B> {
-    return new Ord((b0: B, b1: B) => this.compare(f(b0), f(b1)))
-  }
-
-  inverse (): Ord<T> {
-    return new Ord((a0: T, a1: T) => this.compare(a1, a0))
-  }
-
-  numberComparison (a0: T, a1: T): number {
-    return this.compare(a0, a1)
-  }
-}
-
-export function fromNumberComparison<A> (f: (a: A, b: A) => number) {
-  return function compare (a: A, b: A) {
-    const r = f(a, b)
-    if (r < 0) return Ordering.LT
-    else if (r === 0) return Ordering.EQ
-    else return Ordering.GT
-  }
-}

package/src/reg-exps.ts

@@ -1,48 +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 module to manipulate `RegExp` instances.
- */
-
-/**
- * Map the function `f` on each occurance matched by the pattern.
- * @param f
- * @param pattern
- * @param subject
- */
-export function map (
-  subject: string,
-  pattern: RegExp,
-  f: (...s: string[]) => string
-): string {
-  const buff = [] as string[]
-  let pos = 0
-  let result: RegExpExecArray | null
-  if (pattern.global) {
-    pattern.lastIndex = 0
-    while ((result = pattern.exec(subject)) !== null) {
-      buff.push(subject.substring(pos, result.index))
-      buff.push(f(...result))
-      pos = result.index + result[0].length
-    }
-  } else {
-    while ((result = pattern.exec(subject.substring(pos))) !== null) {
-      buff.push(subject.substring(pos, pos + result.index))
-      buff.push(f(...result))
-      pos += result.index + result[0].length
-    }
-  }
-  buff.push(subject.substring(pos))
-  return buff.join('')
-}

package/src/result.ts

@@ -1,140 +0,0 @@
-import { type AsyncResult } from './async-result'
-
-export interface Success<V> {
-  type: 'success'
-  value: V
-}
-export interface Failure<E> {
-  type: 'failure'
-  error: E
-}
-
-export type Result<V, E> = Success<V> | Failure<E>
-
-export type PromiseResult<V, E> = PromiseLike<Result<V, E>>
-
-// eslint-disable-next-line @typescript-eslint/no-redeclare
-export const Result = {
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  success<V>(value: V): Result<V, any> {
-    return { type: 'success', value }
-  },
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  failure<E>(error: E): Result<any, E> {
-    return { type: 'failure', error }
-  },
-  cmap:
-    <V1, V2, E>(f: (value: V1) => V2) =>
-    (r: Result<V1, E>): Result<V2, E> => {
-      if (r.type === 'success') {
-        return Result.success(f(r.value))
-      } else {
-        return r
-      }
-    },
-  map: <V1, V2, E>(r: Result<V1, E>, f: (value: V1) => V2): Result<V2, E> => {
-    if (r.type === 'success') {
-      return Result.success(f(r.value))
-    } else {
-      return r
-    }
-  },
-  cflatMap:
-    <V1, V2, E>(f: (value: V1) => Result<V2, E>) =>
-    (r: Result<V1, E>): Result<V2, E> => {
-      if (r.type === 'success') {
-        return f(r.value)
-      } else {
-        return r
-      }
-    },
-  flatMap: <V1, V2, E>(
-    r: Result<V1, E>,
-    f: (value: V1) => Result<V2, E>
-  ): Result<V2, E> => {
-    if (r.type === 'success') {
-      return f(r.value)
-    } else {
-      return r
-    }
-  },
-  toAsync<V, E>(r: Result<V, E>): AsyncResult<V, E> {
-    return r
-  },
-  isSuccess<V, E>(r: Result<V, E>): r is Success<V> {
-    return r.type === 'success'
-  },
-  isFailure<V, E>(r: Result<V, E>): r is Failure<E> {
-    return r.type === 'failure'
-  },
-  getOrElse<V, E>(r: Result<V, E>, alt: V): V {
-    return Result.isSuccess(r) ? r.value : alt
-  },
-  getOrElseLazy<V, E>(r: Result<V, E>, altf: () => V): V {
-    return Result.isSuccess(r) ? r.value : altf()
-  },
-  getOrNull<V, E>(r: Result<V, E>): V | null {
-    return Result.isSuccess(r) ? r.value : null
-  },
-  getOrUndefined<V, E>(r: Result<V, E>): V | undefined {
-    return Result.isSuccess(r) ? r.value : undefined
-  },
-  cmatch:
-    <V1, V2, E>(success: (value: V1) => V2, failure: (error: E) => V2) =>
-    (r: Result<V1, E>): V2 => {
-      if (Result.isSuccess(r)) {
-        return success(r.value)
-      } else {
-        return failure(r.error)
-      }
-    },
-  match: <V1, V2, E>(
-    r: Result<V1, E>,
-    success: (value: V1) => V2,
-    failure: (error: E) => V2
-  ): V2 => {
-    if (Result.isSuccess(r)) {
-      return success(r.value)
-    } else {
-      return failure(r.error)
-    }
-  },
-  whenSuccess:
-    <V, E>(apply: (v: V) => void) =>
-    (r: Result<V, E>): Result<V, E> => {
-      if (Result.isSuccess(r)) {
-        apply(r.value)
-      }
-      return r
-    },
-  whenFailure:
-    <V, E>(apply: (e: E) => void) =>
-    (r: Result<V, E>): Result<V, E> => {
-      if (Result.isFailure(r)) {
-        apply(r.error)
-      }
-      return r
-    },
-  combine: <V, E>(
-    r1: Result<V, E>,
-    r2: Result<V, E>,
-    combineV: (v1: V, v2: V) => V,
-    combineE: (e1: E, e2: E) => E
-  ): Result<V, E> =>
-    Result.match<V, Result<V, E>, E>(
-      r1,
-      (v1: V) =>
-        Result.match<V, Result<V, E>, E>(
-          r2,
-          (v2: V) => Result.success<V>(combineV(v1, v2)),
-          (e2: E) => Result.failure<E>(e2)
-        ),
-      (e1: E) =>
-        Result.match<V, Result<V, E>, E>(
-          r2,
-          // eslint-disable-next-line @typescript-eslint/no-unused-vars
-          (_: V) => Result.failure<E>(e1),
-          (e2: E) => Result.failure<E>(combineE(e1, e2))
-        )
-    )
-}