@tempots/std 0.9.2 → 0.9.5

package/dist/numbers.d.ts

@@ -1,104 +0,0 @@
-export declare const TOLERANCE = 0.0001;
-/**
-  Constant value employed to see if two `number` values are very close.
-**/
-export declare const EPSILON = 1e-9;
-/**
-Returns the angular distance between 2 angles.
-**/
-export declare function angleDifference(a: number, b: number, turn?: number): number;
-/**
-Rounds a number up to the specified number of decimals.
-**/
-export declare function ceilTo(v: number, decimals: number): number;
-/**
-`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 declare function clamp(value: number, min: number, max: number): number;
-export declare function clampInt(value: number, min: number, max: number): number;
-/**
-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 declare function clampSym(v: number, max: number): number;
-/**
-It returns the comparison value (an integer number) between two `float` values.
-**/
-export declare function compare(a: number, b: number): number;
-/**
-Rounds a number down to the specified number of decimals.
-**/
-export declare function floorTo(v: number, decimals: number): number;
-/**
-`normalize` clamps the passwed value between 0 and 1.
-**/
-export declare function normalize(value: number): number;
-export declare function toHex(num: number, length?: number): string;
-/**
-`interpolate` returns a value between `a` and `b` for any value of `t` (normally between 0 and 1).
-**/
-export declare function interpolate(a: number, b: number, t: number): number;
-/**
-Interpolates values in a polar coordinate system looking for the narrowest delta angle.
-It can be either clock-wise or counter-clock-wise.
-**/
-export declare function interpolateAngle(a: number, b: number, t: number, turn?: number): number;
-/**
-Interpolates values in a polar coordinate system looking for the wideset delta angle.
-It can be either clock-wise or counter-clock-wise.
-**/
-export declare function interpolateAngleWidest(a: number, b: number, t: number, turn?: number): number;
-/**
-Interpolates values in a polar coordinate system always in clock-wise direction.
-**/
-export declare function interpolateAngleCW(a: number, b: number, t: number, turn?: number): number;
-/**
-Interpolates values in a polar coordinate system always in counter-clock-wise direction.
-**/
-export declare function interpolateAngleCCW(a: number, b: number, t: number, turn?: number): number;
-/**
-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 declare function nearEquals(a: number, b: number, tollerance?: number): boolean;
-/**
-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 declare function nearEqualAngles(a: number, b: number, turn?: number, tollerance?: number): boolean;
-/**
-`nearZero` finds if the passed number is zero or very close to it. By default
-`EPSILON` is used as the tollerance value.
-**/
-export declare function nearZero(n: number, tollerance?: number): boolean;
-/**
-Computes the nth root (`index`) of `base`.
-**/
-export declare function root(base: number, index: number): number;
-/**
-Rounds a number to the specified number of decimals.
-**/
-export declare function roundTo(f: number, decimals: number): number;
-/**
-`sign` returns `-1` if `value` is a negative number, `1` otherwise.
-*/
-export declare function sign<T extends number>(value: T): number;
-/**
-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 declare function wrap(v: number, min: number, max: number): number;
-/**
-Similar to `wrap`, it works for numbers between 0 and `max`.
-**/
-export declare function wrapCircular(v: number, max: number): number;

package/dist/numbers.js

@@ -1,183 +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, b, turn = 360.0) {
-    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, decimals) {
-    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, min, max) {
-    return Math.min(Math.max(value, min), max);
-}
-export function clampInt(value, min, max) {
-    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, max) {
-    return clamp(v, -max, max);
-}
-/**
-It returns the comparison value (an integer number) between two `float` values.
-**/
-export function compare(a, b) {
-    return a < b ? -1 : a > b ? 1 : 0;
-}
-/**
-Rounds a number down to the specified number of decimals.
-**/
-export function floorTo(v, decimals) {
-    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) {
-    return clamp(value, 0, 1);
-}
-export function toHex(num, length = 0) {
-    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, b, t) {
-    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, b, t, turn = 360.0) {
-    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, b, t, turn = 360) {
-    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, b, t, turn = 360) {
-    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, b, t, turn = 360) {
-    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, b, tollerance = EPSILON) {
-    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, b, turn = 360.0, tollerance = EPSILON) {
-    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, tollerance = EPSILON) {
-    return Math.abs(n) <= tollerance;
-}
-/**
-Computes the nth root (`index`) of `base`.
-**/
-export function root(base, index) {
-    return Math.pow(base, 1 / index);
-}
-/**
-Rounds a number to the specified number of decimals.
-**/
-export function roundTo(f, decimals) {
-    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(value) {
-    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, min, max) {
-    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, max) {
-    v = v % max;
-    if (v < 0)
-        v += max;
-    return v;
-}

package/dist/objects.d.ts

@@ -1,9 +0,0 @@
-import { type TupleToUnion } from './types/tuples';
-import { type Merge } from './types/objects';
-import { type AnyKey } from './types/utility';
-export declare function keys<T extends object>(obj: T): Array<keyof T>;
-export declare function sameKeys<T extends object>(a: T, b: T): boolean;
-export declare function isObject(obj: unknown): obj is Record<AnyKey, unknown>;
-export declare function removeFields<T extends object, F extends Array<keyof T>>(ob: T, ...fields: F): Omit<T, TupleToUnion<F>>;
-export declare function merge<A extends Record<AnyKey, unknown>, B extends Record<AnyKey, unknown>>(a: A, b: B): Merge<A, B>;
-export declare function isEmpty(obj: object): boolean;

package/dist/objects.js

@@ -1,33 +0,0 @@
-export function keys(obj) {
-    return Object.keys(obj);
-}
-export function sameKeys(a, b) {
-    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) {
-    return Object.prototype.toString.call(obj) === '[object Object]';
-}
-export function removeFields(ob, ...fields) {
-    const ks = keys(ob);
-    return ks.reduce((acc, key) => {
-        if (!fields.includes(key))
-            acc[key] = ob[key];
-        return acc;
-    }, {});
-}
-export function merge(a, b) {
-    return Object.assign({}, a, b);
-}
-export function isEmpty(obj) {
-    return (obj != null &&
-        Object.keys(obj).length === 0 &&
-        Object.getPrototypeOf(obj) === Object.prototype);
-}

package/dist/ord.d.ts

@@ -1,19 +0,0 @@
-export declare 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 declare class Ord<T> {
-    readonly compare: CompareOrd<T>;
-    static fromNumberComparison<T>(compare: (a: T, b: T) => number): Ord<T>;
-    constructor(compare: CompareOrd<T>);
-    max(a: T, b: T): T;
-    min(a: T, b: T): T;
-    equals(a: T, b: T): boolean;
-    contramap<B>(f: (b: B) => T): Ord<B>;
-    inverse(): Ord<T>;
-    numberComparison(a0: T, a1: T): number;
-}
-export declare function fromNumberComparison<A>(f: (a: A, b: A) => number): (a: A, b: A) => Ordering;

package/dist/ord.js

@@ -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.
-*/
-export var Ordering;
-(function (Ordering) {
-    Ordering[Ordering["LT"] = -1] = "LT";
-    Ordering[Ordering["EQ"] = 0] = "EQ";
-    Ordering[Ordering["GT"] = 1] = "GT";
-})(Ordering || (Ordering = {}));
-export class Ord {
-    compare;
-    static fromNumberComparison(compare) {
-        return new Ord(fromNumberComparison(compare));
-    }
-    constructor(compare) {
-        this.compare = compare;
-    }
-    max(a, b) {
-        switch (this.compare(a, b)) {
-            case Ordering.LT:
-            case Ordering.EQ:
-                return a;
-            case Ordering.GT:
-                return b;
-        }
-    }
-    min(a, b) {
-        switch (this.compare(a, b)) {
-            case Ordering.GT:
-            case Ordering.EQ:
-                return a;
-            case Ordering.LT:
-                return b;
-        }
-    }
-    equals(a, b) {
-        switch (this.compare(a, b)) {
-            case Ordering.EQ:
-                return true;
-            default:
-                return false;
-        }
-    }
-    contramap(f) {
-        return new Ord((b0, b1) => this.compare(f(b0), f(b1)));
-    }
-    inverse() {
-        return new Ord((a0, a1) => this.compare(a1, a0));
-    }
-    numberComparison(a0, a1) {
-        return this.compare(a0, a1);
-    }
-}
-export function fromNumberComparison(f) {
-    return function compare(a, b) {
-        const r = f(a, b);
-        if (r < 0)
-            return Ordering.LT;
-        else if (r === 0)
-            return Ordering.EQ;
-        else
-            return Ordering.GT;
-    };
-}

package/dist/reg-exps.d.ts

@@ -1,10 +0,0 @@
-/**
- * Utility module to manipulate `RegExp` instances.
- */
-/**
- * Map the function `f` on each occurance matched by the pattern.
- * @param f
- * @param pattern
- * @param subject
- */
-export declare function map(subject: string, pattern: RegExp, f: (...s: string[]) => string): string;

package/dist/reg-exps.js

@@ -1,43 +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, pattern, f) {
-    const buff = [];
-    let pos = 0;
-    let result;
-    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/dist/result.d.ts

@@ -1,31 +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>>;
-export declare const Result: {
-    success<V>(value: V): Result<V, any>;
-    failure<E>(error: E): Result<any, E>;
-    cmap: <V1, V2, E_1>(f: (value: V1) => V2) => (r: Result<V1, E_1>) => Result<V2, E_1>;
-    map: <V1_1, V2_1, E_2>(r: Result<V1_1, E_2>, f: (value: V1_1) => V2_1) => Result<V2_1, E_2>;
-    cflatMap: <V1_2, V2_2, E_3>(f: (value: V1_2) => Result<V2_2, E_3>) => (r: Result<V1_2, E_3>) => Result<V2_2, E_3>;
-    flatMap: <V1_3, V2_3, E_4>(r: Result<V1_3, E_4>, f: (value: V1_3) => Result<V2_3, E_4>) => Result<V2_3, E_4>;
-    toAsync<V_1, E_5>(r: Result<V_1, E_5>): AsyncResult<V_1, E_5>;
-    isSuccess<V_2, E_6>(r: Result<V_2, E_6>): r is Success<V_2>;
-    isFailure<V_3, E_7>(r: Result<V_3, E_7>): r is Failure<E_7>;
-    getOrElse<V_4, E_8>(r: Result<V_4, E_8>, alt: V_4): V_4;
-    getOrElseLazy<V_5, E_9>(r: Result<V_5, E_9>, altf: () => V_5): V_5;
-    getOrNull<V_6, E_10>(r: Result<V_6, E_10>): V_6 | null;
-    getOrUndefined<V_7, E_11>(r: Result<V_7, E_11>): V_7 | undefined;
-    cmatch: <V1_4, V2_4, E_12>(success: (value: V1_4) => V2_4, failure: (error: E_12) => V2_4) => (r: Result<V1_4, E_12>) => V2_4;
-    match: <V1_5, V2_5, E_13>(r: Result<V1_5, E_13>, success: (value: V1_5) => V2_5, failure: (error: E_13) => V2_5) => V2_5;
-    whenSuccess: <V_8, E_14>(apply: (v: V_8) => void) => (r: Result<V_8, E_14>) => Result<V_8, E_14>;
-    whenFailure: <V_9, E_15>(apply: (e: E_15) => void) => (r: Result<V_9, E_15>) => Result<V_9, E_15>;
-    combine: <V_10, E_16>(r1: Result<V_10, E_16>, r2: Result<V_10, E_16>, combineV: (v1: V_10, v2: V_10) => V_10, combineE: (e1: E_16, e2: E_16) => E_16) => Result<V_10, E_16>;
-};

package/dist/result.js

@@ -1,95 +0,0 @@
-// eslint-disable-next-line @typescript-eslint/no-redeclare
-export const Result = {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    success(value) {
-        return { type: 'success', value };
-    },
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    failure(error) {
-        return { type: 'failure', error };
-    },
-    cmap: (f) => (r) => {
-        if (r.type === 'success') {
-            return Result.success(f(r.value));
-        }
-        else {
-            return r;
-        }
-    },
-    map: (r, f) => {
-        if (r.type === 'success') {
-            return Result.success(f(r.value));
-        }
-        else {
-            return r;
-        }
-    },
-    cflatMap: (f) => (r) => {
-        if (r.type === 'success') {
-            return f(r.value);
-        }
-        else {
-            return r;
-        }
-    },
-    flatMap: (r, f) => {
-        if (r.type === 'success') {
-            return f(r.value);
-        }
-        else {
-            return r;
-        }
-    },
-    toAsync(r) {
-        return r;
-    },
-    isSuccess(r) {
-        return r.type === 'success';
-    },
-    isFailure(r) {
-        return r.type === 'failure';
-    },
-    getOrElse(r, alt) {
-        return Result.isSuccess(r) ? r.value : alt;
-    },
-    getOrElseLazy(r, altf) {
-        return Result.isSuccess(r) ? r.value : altf();
-    },
-    getOrNull(r) {
-        return Result.isSuccess(r) ? r.value : null;
-    },
-    getOrUndefined(r) {
-        return Result.isSuccess(r) ? r.value : undefined;
-    },
-    cmatch: (success, failure) => (r) => {
-        if (Result.isSuccess(r)) {
-            return success(r.value);
-        }
-        else {
-            return failure(r.error);
-        }
-    },
-    match: (r, success, failure) => {
-        if (Result.isSuccess(r)) {
-            return success(r.value);
-        }
-        else {
-            return failure(r.error);
-        }
-    },
-    whenSuccess: (apply) => (r) => {
-        if (Result.isSuccess(r)) {
-            apply(r.value);
-        }
-        return r;
-    },
-    whenFailure: (apply) => (r) => {
-        if (Result.isFailure(r)) {
-            apply(r.error);
-        }
-        return r;
-    },
-    combine: (r1, r2, combineV, combineE) => Result.match(r1, (v1) => Result.match(r2, (v2) => Result.success(combineV(v1, v2)), (e2) => Result.failure(e2)), (e1) => Result.match(r2, 
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    (_) => Result.failure(e1), (e2) => Result.failure(combineE(e1, e2))))
-};