@tempots/std 0.9.6 → 0.9.7

package/src/edit.ts

@@ -1,29 +0,0 @@
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-export abstract class Edit<V, I, E> {
-  abstract readonly type: 'Input' | 'Error' | 'Value'
-}
-
-export class Input<I> extends Edit<never, I, never> {
-  override readonly type = 'Input' as const
-  constructor (readonly input: I) {
-    super()
-  }
-}
-
-export class Error<I, E> extends Edit<never, I, E> {
-  override readonly type = 'Error' as const
-  constructor (readonly input: I, readonly error: E) {
-    super()
-  }
-}
-
-export class Value<V> extends Edit<V, never, never> {
-  override readonly type = 'Value' as const
-  constructor (readonly value: V) {
-    super()
-  }
-}
-
-export type Validate<V, I, E> = (
-  input: Input<I> | Error<I, E>
-) => Error<I, E> | Value<V>

package/src/equals.ts

@@ -1,116 +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 function strictEqual<A> (a: A, b: A): boolean {
-  // eslint-disable-next-line no-self-compare
-  return a === b || (a !== a && b !== b)
-}
-
-export function deepEqual<A> (a: A, b: A): boolean {
-  if (strictEqual(a, b)) return true
-  if (a == null || b == null) return false
-  const aIsArr = Array.isArray(a)
-  const bIsArr = Array.isArray(b)
-
-  if (aIsArr !== bIsArr) return false
-  if (aIsArr) {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const aArr: never[] = a as any
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const bArr: never[] = b as any
-    const aLength = aArr.length
-    if (aLength !== bArr.length) return false
-    for (let i = 0; i < aLength; i++) {
-      if (!deepEqual(aArr[i], bArr[i])) return false
-    }
-    return true
-  }
-
-  const aIsDate = a instanceof Date
-  const bIsDate = b instanceof Date
-  if (aIsDate !== bIsDate) return false
-  if (aIsDate) {
-    const aDate: Date = a as never
-    const bDate: Date = b as never
-    return +aDate === +bDate
-  }
-
-  const aIsSet = a instanceof Set
-  const bIsSet = b instanceof Set
-  if (aIsSet !== bIsSet) return false
-  if (aIsSet) {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const aSet: Set<any> = a as never
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const bSet: Set<any> = b as never
-    if (aSet.size !== bSet.size) return false
-    const it = aSet.keys()
-    // eslint-disable-next-line no-constant-condition
-    while (true) {
-      const curr = it.next()
-      if (curr.done ?? false) break
-      if (!bSet.has(curr.value)) return false
-    }
-    return true
-  }
-
-  const aIsMap = a instanceof Map
-  const bIsMap = b instanceof Map
-  if (aIsMap !== bIsMap) return false
-  if (aIsMap) {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const aMap: Map<any, any> = a as never
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const bMap: Map<any, any> = b as never
-    const aMapLength = aMap.size
-    if (aMapLength !== bMap.size) return false
-    const it = aMap.keys()
-    // eslint-disable-next-line no-constant-condition
-    while (true) {
-      const curr = it.next()
-      if (curr.done ?? false) break
-      if (!deepEqual(aMap.get(curr.value), bMap.get(curr.value))) return false
-    }
-    return true
-  }
-
-  const aIsObj = typeof a === 'object'
-  const bIsObj = typeof b === 'object'
-  if (aIsObj !== bIsObj) return false
-  if (aIsObj) {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const aObj: any = a
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const bObj: any = b
-    const aFields = Object.keys(aObj)
-    const bFields = Object.keys(bObj)
-    const aLength = aFields.length
-
-    if (aLength !== bFields.length) return false
-
-    for (let i = 0; i < aLength; i++) {
-      const field = aFields[i]
-      if (!Object.prototype.hasOwnProperty.call(bObj, field)) return false
-      if (!deepEqual(aObj[field], bObj[field])) return false
-    }
-
-    return true
-  }
-
-  return false
-}
-
-export function looseEqual<T> (a: T, b: T): boolean {
-  // eslint-disable-next-line eqeqeq
-  return a == b
-}

package/src/functions.ts

@@ -1,108 +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.
-*/
-
-import { type Fun1, type FirstArgument } from './types/functions'
-
-export function compose<A> (): (a: A) => A
-export function compose<A, B> (f1: (a: A) => B): (a: A) => B
-export function compose<A, B, C> (f1: (a: A) => B, f2: (b: B) => C): (a: A) => C
-export function compose<A, B, C, D> (
-  f1: (a: A) => B,
-  f2: (b: B) => C,
-  f3: (c: C) => D
-): (a: A) => D
-export function compose<A, B, C, D, E> (
-  f1: (a: A) => B,
-  f2: (b: B) => C,
-  f3: (c: C) => D,
-  f4: (d: D) => E
-): (a: A) => E
-export function compose<A, B, C, D, E, F> (
-  f1: (a: A) => B,
-  f2: (b: B) => C,
-  f3: (c: C) => D,
-  f4: (d: D) => E,
-  f5: (e: E) => F
-): (a: A) => F
-export function compose<A, B, C, D, E, F, G> (
-  f1: (a: A) => B,
-  f2: (b: B) => C,
-  f3: (c: C) => D,
-  f4: (d: D) => E,
-  f5: (e: E) => F,
-  f6: (f: F) => G
-): (a: A) => G
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export function compose<Args extends Array<Fun1<any, any>>> (...args: Args) {
-  return (a: FirstArgument<Args[0]>) => args.reduce((acc, f) => f(acc), a)
-}
-
-export function identity<T> (v: T): T {
-  return v
-}
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export function curryLeft<A, Rest extends any[], Ret> (
-  f: (a: A, ...rest: Rest) => Ret
-) {
-  return (a: A) =>
-    (...rest: Rest): Ret =>
-      f(a, ...rest)
-}
-
-export function curryRight<A, B, C, D> (
-  f: (a: A, b: B, c: C) => D
-): (a: A, b: B) => (c: C) => D
-export function curryRight<A, B, C, D, E> (
-  f: (a: A, b: B, c: C, d: D) => E
-): (a: A, b: B, c: C) => (d: D) => E
-export function curryRight<A, B, C, D, E, F> (
-  f: (a: A, b: B, c: C, d: D, e: E) => F
-): (a: A, b: B, c: C, d: D) => (e: E) => F
-export function curryRight<A, B, C, D, E, F, G> (
-  f: (a: A, b: B, c: C, d: D, e: E, f: F) => G
-): (a: A, b: B, c: C, d: D, e: E) => (f: F) => G
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export function curryRight<Ret> (f: (...rest: any[]) => Ret) {
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  return (...args: any[]) =>
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    (a: any): Ret =>
-      f(...args.concat([a]))
-}
-
-export function flip<A, B, C> (f: (a: A, b: B) => C): (b: B, a: A) => C
-export function flip<A, B, C, D> (
-  f: (a: A, b: B, c: C) => D
-): (c: C, b: B, a: A) => D
-export function flip<A, B, C, D, E> (
-  f: (a: A, b: B, c: C, d: D) => E
-): (d: D, c: C, b: B, a: A) => E
-export function flip<A, B, C, D, E> (
-  f: (a: A, b: B, c: C, d: D) => E
-): (d: D, c: C, b: B, a: A) => E
-export function flip<A, B, C, D, E, F> (
-  f: (a: A, b: B, c: C, d: D, e: E) => F
-): (e: E, d: D, c: C, b: B, a: A) => F
-export function flip<A, B, C, D, E, F, G> (
-  f: (a: A, b: B, c: C, d: D, e: E, f: F) => G
-): (f: F, e: E, d: D, c: C, b: B, a: A) => G
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export function flip<Ret> (f: (...rest: any[]) => Ret) {
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  return (...args: any[]) => f(...args.reverse())
-}
-
-export function id<T> (v: T): T {
-  return v
-}

package/src/json.ts

@@ -1,52 +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.
-*/
-
-import { Result } from './result'
-
-export type JSONPrimitive = string | boolean | number | null
-// eslint-disable-next-line @typescript-eslint/consistent-indexed-object-style
-export interface JSONObject {
-  [k: string]: JSONValue
-}
-export type JSONArray = JSONValue[]
-export type JSONValue = JSONPrimitive | JSONObject | JSONArray
-
-export function deserialize (s: string): Result<JSONValue, string> {
-  try {
-    return Result.success(JSON.parse(s))
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  } catch (e: any) {
-    return Result.failure(e.message)
-  }
-}
-
-export function makeSerializer (options: {
-  minified?: boolean
-  whitelist?: string[]
-}) {
-  return function serialize (v: JSONValue): string {
-    return JSON.stringify(
-      v,
-      options.whitelist,
-      options.minified === false ? undefined : 2
-    )
-  }
-}
-
-export function serialize (v: JSONValue): string {
-  return JSON.stringify(v, null, 2)
-}
-
-export function serializeMinified (v: JSONValue): string {
-  return JSON.stringify(v)
-}

package/src/match.ts

@@ -1,88 +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.
-*/
-
-import { type Differentiate, type DifferentiateAt } from './types/differentiate'
-import { type AnyKey } from './types/utility'
-import { type ObjectWithField, type ObjectWithPath, type TypeAtPath } from './types/objects'
-
-export function matchLiteral<A extends AnyKey, B> (
-  input: A,
-  matcher: { [k in A]: B }
-): B {
-  return matcher[input]
-}
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export function match<F extends AnyKey, T extends ObjectWithField<F, any>, B> (
-  input: T,
-  field: F,
-  matcher: { [k in T[F]]: (arg: Differentiate<F, T, k>) => B }
-): B {
-  const k = input[field]
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  return matcher[k](input as any)
-}
-
-export function deepMatch<
-  Path extends AnyKey[],
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  T extends ObjectWithPath<Path, any>,
-  B
-> (
-  input: T,
-  path: Path,
-  matcher: {
-    [k in TypeAtPath<Path, T>]: (arg: DifferentiateAt<Path, T, k>) => B
-  }
-): B {
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  const k = path.reduce((res: any, key) => res[key], input) as TypeAtPath<
-  Path,
-  T
-  >
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  return matcher[k](input as any)
-}
-
-export function createMatch<F extends AnyKey> (field: F) {
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  return <T extends ObjectWithField<F, any>, B>(
-    input: T,
-    matcher: { [k in T[F]]: (arg: Differentiate<F, T, k>) => B }
-  ): B => {
-    const k = input[field]
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    return matcher[k](input as any)
-  }
-}
-
-export const createDeepMatch =
-  <Path extends AnyKey[]>(...path: Path) =>
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  <T extends ObjectWithPath<Path, any>, B>(
-      input: T,
-      matcher: {
-        [k in TypeAtPath<Path, T>]: (arg: DifferentiateAt<Path, T, k>) => B
-      }
-    ): B => {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const k = path.reduce((res: any, key) => res[key], input) as TypeAtPath<
-    Path,
-    T
-    >
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    return matcher[k](input as any)
-  }
-
-export const matchKind = createMatch('kind')
-export const matchType = createMatch('type')

package/src/memoize.ts

@@ -1,9 +0,0 @@
-export function memoize<T> (f: () => T): () => T {
-  let value: T | undefined
-  return () => {
-    if (value === undefined) {
-      value = f()
-    }
-    return value
-  }
-}

package/src/newtype.ts

@@ -1,59 +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.
-*/
-
-/**
- * Usage:
- *
- * ```ts
- * export interface Int extends Newtype<
- *   number,
- *   { readonly Int: unique symbol }
- * > {}
- *
- * export const Int = new class extends NewtypeClass<Int> {
- *   isValid(v: number) { return Number.isInteger(v) }
- * }()
- * ```
- */
-
-import { type Maybe } from './maybe'
-
-export type TypeOfN<T extends Newtype<unknown, unknown>> = T['_T']
-
-export interface Newtype<V, S> {
-  readonly _T: V
-  readonly _S: S
-}
-
-export abstract class NewtypeClass<T extends Newtype<unknown, unknown>> {
-  abstract isValid (v: TypeOfN<T>): boolean
-  unsafeOf (v: TypeOfN<T>): T {
-    return v as unknown as T
-  }
-
-  of (v: TypeOfN<T>): Maybe<T> {
-    return this.isValid(v) ? (v as unknown as T) : undefined
-  }
-
-  get (v: T): TypeOfN<T> {
-    return v as unknown as TypeOfN<T>
-  }
-
-  modify (f: (v: TypeOfN<T>) => TypeOfN<T>): (value: T) => Maybe<T> {
-    return (value: T) => this.of(f(this.get(value)))
-  }
-
-  unsafeModify (f: (v: TypeOfN<T>) => TypeOfN<T>): (value: T) => T {
-    return (value: T) => this.unsafeOf(f(this.get(value)))
-  }
-}

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