toosoon-utils 1.4.0 → 2.0.0

package/lib/maths.d.ts

@@ -1,161 +0,0 @@
-/**
- * Check if a number is even
- *
- * @param {number} value Value to check
- * @returns {boolean} True if the given number is even, false otherwise
- */
-export declare function isEven(value: number): boolean;
-/**
- * Check if a number is odd
- *
- * @param {number} value Value to check
- * @returns {boolean} True if the given number is odd, false otherwise
- */
-export declare function isOdd(value: number): boolean;
-/**
- * Check if a number is a power of 2
- *
- * @param {number} value Value to check
- * @returns {boolean} True if the given number is a power of 2, false otherwise
- */
-export declare function isPowerOf2(value: number): boolean;
-/**
- * Find closest power of 2 that fits a number
- *
- * @param {number} value         Incoming value
- * @param {string} [mode='ceil'] Can be 'floor' | 'ceil' | 'round'
- * @returns {number} Power of 2
- */
-export declare function toPowerOf2(value: number, mode?: 'floor' | 'ceil' | 'round'): number;
-/**
- * Return the sign (positive or negative) of a number
- *
- * @param {number} value Value to check
- * @returns {number} 1 if the given number is positive, -1 if it is negative, otherwise 0
- */
-export declare function sign(value: number): number;
-/**
- * Clamp a value between two bounds
- *
- * @param {number} value   Value to clamp
- * @param {number} [min=0] Minimum boundary
- * @param {number} [max=1] Maximum boundary
- * @returns {number} Clamped value
- */
-export declare function clamp(value: number, min?: number, max?: number): number;
-/**
- * Linear interpolation between two values (lerping)
- *
- * @param {number} value Normalized value to interpolate
- * @param {number} min   Minimum value
- * @param {number} max   Maximum value
- * @returns {number} Lerped value
- */
-export declare function lerp(value: number, min: number, max: number): number;
-/**
- * Triangular interpolation between two values
- *
- * @param {number} value  Normalized value to interpolate
- * @param {number} min    Minimum value
- * @param {number} max    Maximum value
- * @param {number} target Triangle target value
- * @returns {number} Interpolated value
- */
-export declare function triLerp(value: number, min: number, max: number, target: number): number;
-/**
- * Exponential interpolation between two values
- *
- * @param {number} value      Value to interpolate
- * @param {number} currentMin Lower bound of the value's current range
- * @param {number} currentMax Upper bound of the value's current range
- * @param {number} targetMin  Lower bound of the value's target range
- * @param {number} targetMax  Upper bound of the value's target range
- * @returns {number} Interpolated value
- */
-export declare function expLerp(value: number, currentMin: number, currentMax: number, targetMin: number, targetMax: number): number;
-/**
- * Normalize a value between two bounds
- *
- * @param {number} value Value to normalize
- * @param {number} min   Minimum boundary
- * @param {number} max   Maximum boundary
- * @returns {number} Normalized value
- */
-export declare function normalize(value: number, min: number, max: number): number;
-/**
- * Re-map a number from one range to another
- *
- * @param {number} value      Value to re-map
- * @param {number} currentMin Lower bound of the value's current range
- * @param {number} currentMax Upper bound of the value's current range
- * @param {number} targetMin  Lower bound of the value's target range
- * @param {number} targetMax  Upper bound of the value's target range
- * @returns {number} Re-mapped value
- */
-export declare function map(value: number, currentMin: number, currentMax: number, targetMin: number, targetMax: number): number;
-/**
- * Round a number up to a nearest multiple
- *
- * @param {number} value        Value to round
- * @param {number} [multiple=1] Multiple to round to
- * @returns {number} Closest multiple
- */
-export declare function roundTo(value: number, multiple?: number): number;
-/**
- * Modulo absolute a value based on a length
- *
- * @param {number} value  Value to modulate
- * @param {number} length Total length
- * @returns {number} Modulated value
- */
-export declare function modAbs(value: number, length: number): number;
-/**
- * Move back and forth a value between 0 and length, so that it is never larger than length and never smaller than 0
- *
- * @param {number} value  Value to modulate
- * @param {number} length Total length
- * @returns {number} PingPonged value
- */
-export declare function pingPong(value: number, length: number): number;
-/**
- * Smooth a value using cubic Hermite interpolation
- *
- * @param {number} value   Value to smooth
- * @param {number} [min=0] Minimum boundary
- * @param {number} [max=1] Maximum boundary
- * @returns {number} Normalized smoothed value
- */
-export declare function smoothstep(value: number, min?: number, max?: number): number;
-/**
- * Re-map the [0, 1] interval into [0, 1] parabola, such that corners are remaped to 0 and the center to 1
- * -> parabola(0) = parabola(1) = 0, and parabola(0.5) = 1
- *
- * @param {number} x         Normalized coordinate on X axis
- * @param {number} [power=1] Parabola power
- * @returns {number} Normalized re-mapped value
- */
-export declare function parabola(x: number, power?: number): number;
-/**
- * Return the sum of numbers
- *
- * @param {number[]} array Array of numbers
- * @returns {number} Total sum
- */
-export declare function sum(array: number[]): number;
-/**
- * Return the average of numbers
- *
- * @param {number[]} array Array of numbers
- * @returns {number} Total average
- */
-export declare function average(array: number[]): number;
-/**
- * Smoothly interpolate a number toward another
- *
- * @param {number} value   Value to interpolate
- * @param {number} target  Destination of the interpolation
- * @param {number} damping A higher value will make the movement more sudden, and a lower value will make the movement more gradual
- * @param {number} delta   Delta time (in seconds)
- * @returns {number} Interpolated number
- */
-export declare function damp(value: number, target: number, damping: number, delta: number): number;

package/lib/maths.js

@@ -1,219 +0,0 @@
-/**
- * Check if a number is even
- *
- * @param {number} value Value to check
- * @returns {boolean} True if the given number is even, false otherwise
- */
-export function isEven(value) {
-    return !(value & 1);
-}
-/**
- * Check if a number is odd
- *
- * @param {number} value Value to check
- * @returns {boolean} True if the given number is odd, false otherwise
- */
-export function isOdd(value) {
-    return !!(value & 1);
-}
-/**
- * Check if a number is a power of 2
- *
- * @param {number} value Value to check
- * @returns {boolean} True if the given number is a power of 2, false otherwise
- */
-export function isPowerOf2(value) {
-    return (value & (value - 1)) === 0;
-}
-/**
- * Find closest power of 2 that fits a number
- *
- * @param {number} value         Incoming value
- * @param {string} [mode='ceil'] Can be 'floor' | 'ceil' | 'round'
- * @returns {number} Power of 2
- */
-export function toPowerOf2(value, mode) {
-    if (mode === void 0) { mode = 'ceil'; }
-    return Math.pow(2, Math[mode](Math.log(value) / Math.log(2)));
-}
-/**
- * Return the sign (positive or negative) of a number
- *
- * @param {number} value Value to check
- * @returns {number} 1 if the given number is positive, -1 if it is negative, otherwise 0
- */
-export function sign(value) {
-    if (value > 0)
-        return 1;
-    else if (value < 0)
-        return -1;
-    return 0;
-}
-/**
- * Clamp a value between two bounds
- *
- * @param {number} value   Value to clamp
- * @param {number} [min=0] Minimum boundary
- * @param {number} [max=1] Maximum boundary
- * @returns {number} Clamped value
- */
-export function clamp(value, min, max) {
-    if (min === void 0) { min = 0; }
-    if (max === void 0) { max = 1; }
-    return Math.min(max, Math.max(min, value));
-}
-/**
- * Linear interpolation between two values (lerping)
- *
- * @param {number} value Normalized value to interpolate
- * @param {number} min   Minimum value
- * @param {number} max   Maximum value
- * @returns {number} Lerped value
- */
-export function lerp(value, min, max) {
-    return min + (max - min) * value;
-}
-/**
- * Triangular interpolation between two values
- *
- * @param {number} value  Normalized value to interpolate
- * @param {number} min    Minimum value
- * @param {number} max    Maximum value
- * @param {number} target Triangle target value
- * @returns {number} Interpolated value
- */
-export function triLerp(value, min, max, target) {
-    var x = Math.pow(1 + Math.abs(target - max) / Math.abs(target - min), -1);
-    return value <= x ? min - (min - target) * (value / x) : target - (target - max) * ((value - x) / (1 - x));
-}
-/**
- * Exponential interpolation between two values
- *
- * @param {number} value      Value to interpolate
- * @param {number} currentMin Lower bound of the value's current range
- * @param {number} currentMax Upper bound of the value's current range
- * @param {number} targetMin  Lower bound of the value's target range
- * @param {number} targetMax  Upper bound of the value's target range
- * @returns {number} Interpolated value
- */
-export function expLerp(value, currentMin, currentMax, targetMin, targetMax) {
-    return (targetMin *
-        Math.pow(targetMax / targetMin, (clamp(value, currentMin, currentMax) - currentMin) / (currentMax - currentMin)));
-}
-/**
- * Normalize a value between two bounds
- *
- * @param {number} value Value to normalize
- * @param {number} min   Minimum boundary
- * @param {number} max   Maximum boundary
- * @returns {number} Normalized value
- */
-export function normalize(value, min, max) {
-    return (value - min) / (max - min);
-}
-/**
- * Re-map a number from one range to another
- *
- * @param {number} value      Value to re-map
- * @param {number} currentMin Lower bound of the value's current range
- * @param {number} currentMax Upper bound of the value's current range
- * @param {number} targetMin  Lower bound of the value's target range
- * @param {number} targetMax  Upper bound of the value's target range
- * @returns {number} Re-mapped value
- */
-export function map(value, currentMin, currentMax, targetMin, targetMax) {
-    return ((value - currentMin) / (currentMax - currentMin)) * (targetMax - targetMin) + targetMin;
-}
-/**
- * Round a number up to a nearest multiple
- *
- * @param {number} value        Value to round
- * @param {number} [multiple=1] Multiple to round to
- * @returns {number} Closest multiple
- */
-export function roundTo(value, multiple) {
-    if (multiple === void 0) { multiple = 1; }
-    if (multiple === 0)
-        return value;
-    return Math.round(value / multiple) * multiple;
-}
-/**
- * Modulo absolute a value based on a length
- *
- * @param {number} value  Value to modulate
- * @param {number} length Total length
- * @returns {number} Modulated value
- */
-export function modAbs(value, length) {
-    if (value < 0) {
-        return length + (value % length);
-    }
-    return value % length;
-}
-/**
- * Move back and forth a value between 0 and length, so that it is never larger than length and never smaller than 0
- *
- * @param {number} value  Value to modulate
- * @param {number} length Total length
- * @returns {number} PingPonged value
- */
-export function pingPong(value, length) {
-    value = modAbs(value, length * 2);
-    return length - Math.abs(value - length);
-}
-/**
- * Smooth a value using cubic Hermite interpolation
- *
- * @param {number} value   Value to smooth
- * @param {number} [min=0] Minimum boundary
- * @param {number} [max=1] Maximum boundary
- * @returns {number} Normalized smoothed value
- */
-export function smoothstep(value, min, max) {
-    if (min === void 0) { min = 0; }
-    if (max === void 0) { max = 1; }
-    var x = clamp(normalize(value, min, max));
-    return x * x * (3 - 2 * x);
-}
-/**
- * Re-map the [0, 1] interval into [0, 1] parabola, such that corners are remaped to 0 and the center to 1
- * -> parabola(0) = parabola(1) = 0, and parabola(0.5) = 1
- *
- * @param {number} x         Normalized coordinate on X axis
- * @param {number} [power=1] Parabola power
- * @returns {number} Normalized re-mapped value
- */
-export function parabola(x, power) {
-    if (power === void 0) { power = 1; }
-    return Math.pow(4 * x * (1 - x), power);
-}
-/**
- * Return the sum of numbers
- *
- * @param {number[]} array Array of numbers
- * @returns {number} Total sum
- */
-export function sum(array) {
-    return array.reduce(function (previous, current) { return previous + current; });
-}
-/**
- * Return the average of numbers
- *
- * @param {number[]} array Array of numbers
- * @returns {number} Total average
- */
-export function average(array) {
-    return sum(array) / array.length;
-}
-/**
- * Smoothly interpolate a number toward another
- *
- * @param {number} value   Value to interpolate
- * @param {number} target  Destination of the interpolation
- * @param {number} damping A higher value will make the movement more sudden, and a lower value will make the movement more gradual
- * @param {number} delta   Delta time (in seconds)
- * @returns {number} Interpolated number
- */
-export function damp(value, target, damping, delta) {
-    return lerp(1 - Math.exp(-damping * delta), value, target);
-}

package/lib/now.d.ts

@@ -1,5 +0,0 @@
-/**
- * Polyfill for "now()" functions
- */
-declare let now: () => number;
-export default now;

package/lib/now.js

@@ -1,28 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-/**
- * Polyfill for "now()" functions
- */
-var now;
-// In node.js, use process.hrtime
-if (typeof process !== 'undefined' && process.hrtime) {
-    now = function () {
-        // Convert [seconds, nanoseconds] to milliseconds
-        var time = process.hrtime();
-        return time[0] * 1000 + time[1] / 1000000;
-    };
-}
-// In a browser use performance or Date
-else if (typeof performance !== 'undefined') {
-    // This must be bound, because directly assigning this function leads to an invocation exception in Chrome
-    now = performance.now.bind(performance);
-}
-else if (typeof Date.now !== 'undefined') {
-    now = Date.now;
-}
-else {
-    now = function () {
-        return new Date().getTime();
-    };
-}
-exports.default = now;

package/lib/prng.d.ts

@@ -1,124 +0,0 @@
-/**
- * Produce a 128-bit hash value from a seed
- *
- * @param {string} seed Initial seed state
- * @returns {[number, number, number, number]} Hash numbers
- */
-export declare function cyrb128(seed: string): [number, number, number, number];
-/**
- * Simple Fast Counter, Generator with a 128-bit state
- *
- * @param {number} a
- * @param {number} b
- * @param {number} c
- * @param {number} d
- * @returns {number} Pseudo-random number
- */
-export declare function sfc32(a: number, b: number, c: number, d: number): number;
-/**
- * SplitMix32, Generator with a 32-bit state
- *
- * @param {number} a
- * @returns {number} Pseudo-random number
- */
-export declare function splitmix32(a: number): number;
-/**
- * Mulberry32, Generator with a 32-bit state
- *
- * @param {number} a
- * @returns {number} Pseudo-random number
- */
-export declare function mulberry32(a: number): number;
-/**
- * Jenkins' Small Fast, Generator with a 32-bit state
- *
- * @param {number} a
- * @returns {number} Pseudo-random number
- */
-export declare function jsf32(a: number, b: number, c: number, d: number): number;
-/**
- * xoshiro128**, Generator with a 128-bit state
- *
- * @param {number} a
- * @returns {number} Pseudo-random number
- */
-export declare function xoshiro128ss(a: number, b: number, c: number, d: number): number;
-type PRNGParameters = string | {
-    seed: string;
-    algorithm: (...args: number[]) => number;
-};
-/**
- * Generate a pseudo-random number in the interval [0, 1]
- * PRNG equivalent of `Math.random()`
- *
- * @param {string|object} prng
- * @returns {number} Pseudo-random number
- */
-export declare function random(prng: PRNGParameters): number;
-/**
- * Generate a pseudo-random boolean (true or false)
- *
- * @param {string|object} prng
- * @param {number} [probability=0.5] Probability to get true
- * @returns {boolean} Either `true` or `false`
- */
-export declare function randomBoolean(prng: PRNGParameters, probability?: number): boolean;
-/**
- * Generate a pseudo-random sign (1 or -1)
- *
- * @param {string|object} prng
- * @param {number} [probability=0.5] Probability to get 1
- * @returns {number} Either 1 or -1
- */
-export declare function randomSign(prng: PRNGParameters, probability?: number): number;
-/**
- * Generate a pseudo-random floating-point number within a specified range
- *
- * @param {string|object} prng
- * @param {number} [min=0]       Minimum boundary
- * @param {number} [max=1]       Maximum boundary
- * @param {number} [precision=2] Number of digits after the decimal point
- * @returns {number} Generated float
- */
-export declare function randomFloat(prng: PRNGParameters, min?: number, max?: number, precision?: number): number;
-/**
- * Generate a pseudo-random integer number within a specified range
- *
- * @param {string|object} prng
- * @param {number} min Minimum boundary
- * @param {number} max Maximum boundary
- * @returns {number} Generated integer
- */
-export declare function randomInt(prng: PRNGParameters, min: number, max: number): number;
-/**
- * Generate a pseudo-random hexadecimal color
- *
- * @param {string|object} prng
- * @returns {string} Generated hexadecimal color
- */
-export declare function randomHexColor(prng: PRNGParameters): string;
-/**
- * Pick a pseudo-random item from a given array
- *
- * @param {string|object} prng
- * @param {T[]} array Array to pick the item from
- * @returns {T|undefined} Random item picked
- */
-export declare function randomItem<T = unknown>(prng: PRNGParameters, array: T[]): T | undefined;
-/**
- * Pick a pseudo-random property value from a given object
- *
- * @param {string|object} prng
- * @param {object} object Object to pick the property from
- * @returns {T|undefined} Random item picked
- */
-export declare function randomObjectProperty<T = unknown>(prng: PRNGParameters, object: Record<string, T>): T | undefined;
-/**
- * Select a pseudo-random index from an array of weighted items
- *
- * @param {string|object} prng
- * @param {number[]} weights Array of weights
- * @returns {number} Random index based on weights
- */
-export declare function randomIndex(prng: PRNGParameters, weights: number[]): number;
-export {};