toosoon-utils 1.1.0 → 1.2.0

package/lib/maths.d.ts

@@ -30,10 +30,10 @@ export declare function toPowerOf2(value: number, mode?: 'floor' | 'ceil' | 'rou
 /**
  * Return the sign (positive or negative) of a number
  *
- * @param {number} number Value to check
+ * @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(number: number): number;
+export declare function sign(value: number): number;
 /**
  * Clamp a value between two bounds
  *
@@ -65,12 +65,14 @@ export declare function triLerp(value: number, min: number, max: number, target:
 /**
  * Exponential interpolation between two values
  *
- * @param {number} value Normalized value to interpolate
- * @param {number} min   Minimum value
- * @param {number} max   Maximum value
+ * @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, min: number, max: number): number;
+export declare function expLerp(value: number, currentMin: number, currentMax: number, targetMin: number, targetMax: number): number;
 /**
  * Normalize a value between two bounds
  *
@@ -95,7 +97,7 @@ export declare function map(value: number, currentMin: number, currentMax: numbe
  * Round a number up to a nearest multiple
  *
  * @param {number} value        Value to round
- * @param {number} [multiple=1] Multiple
+ * @param {number} [multiple=1] Multiple to round to
  * @returns {number} Closest multiple
  */
 export declare function roundTo(value: number, multiple?: number): number;
@@ -136,14 +138,14 @@ export declare function parabola(x: number, power?: number): number;
 /**
  * Return the sum of numbers
  *
- * @param {number[]} array Array of number
+ * @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 number
+ * @param {number[]} array Array of numbers
  * @returns {number} Total average
  */
 export declare function average(array: number[]): number;

package/lib/maths.js

@@ -1,36 +1,30 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.damp = exports.average = exports.sum = exports.parabola = exports.smoothstep = exports.pingPong = exports.modAbs = exports.roundTo = exports.map = exports.normalize = exports.expLerp = exports.triLerp = exports.lerp = exports.clamp = exports.sign = exports.toPowerOf2 = exports.isPowerOf2 = exports.isOdd = exports.isEven = void 0;
 /**
  * Check if a number is even
  *
  * @param {number} value Value to check
  * @returns {boolean} True if the given number is even, false otherwise
  */
-function isEven(value) {
+export function isEven(value) {
     return !(value & 1);
 }
-exports.isEven = isEven;
 /**
  * Check if a number is odd
  *
  * @param {number} value Value to check
  * @returns {boolean} True if the given number is odd, false otherwise
  */
-function isOdd(value) {
+export function isOdd(value) {
     return !!(value & 1);
 }
-exports.isOdd = isOdd;
 /**
  * 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
  */
-function isPowerOf2(value) {
+export function isPowerOf2(value) {
     return (value & (value - 1)) === 0;
 }
-exports.isPowerOf2 = isPowerOf2;
 /**
  * Find closest power of 2 that fits a number
  *
@@ -38,25 +32,23 @@ exports.isPowerOf2 = isPowerOf2;
  * @param {string} [mode='ceil'] Can be 'floor' | 'ceil' | 'round'
  * @returns {number} Power of 2
  */
-function toPowerOf2(value, mode) {
+export function toPowerOf2(value, mode) {
     if (mode === void 0) { mode = 'ceil'; }
     return Math.pow(2, Math[mode](Math.log(value) / Math.log(2)));
 }
-exports.toPowerOf2 = toPowerOf2;
 /**
  * Return the sign (positive or negative) of a number
  *
- * @param {number} number Value to check
+ * @param {number} value Value to check
  * @returns {number} 1 if the given number is positive, -1 if it is negative, otherwise 0
  */
-function sign(number) {
-    if (number > 0)
+export function sign(value) {
+    if (value > 0)
         return 1;
-    else if (number < 0)
+    else if (value < 0)
         return -1;
     return 0;
 }
-exports.sign = sign;
 /**
  * Clamp a value between two bounds
  *
@@ -65,12 +57,11 @@ exports.sign = sign;
  * @param {number} [max=1] Maximum boundary
  * @returns {number} Clamped value
  */
-function clamp(value, min, max) {
+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));
 }
-exports.clamp = clamp;
 /**
  * Linear interpolation between two values (lerping)
  *
@@ -79,10 +70,9 @@ exports.clamp = clamp;
  * @param {number} max   Maximum value
  * @returns {number} Lerped value
  */
-function lerp(value, min, max) {
+export function lerp(value, min, max) {
     return min + (max - min) * value;
 }
-exports.lerp = lerp;
 /**
  * Triangular interpolation between two values
  *
@@ -92,23 +82,24 @@ exports.lerp = lerp;
  * @param {number} target Triangle target value
  * @returns {number} Interpolated value
  */
-function triLerp(value, min, max, target) {
+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));
 }
-exports.triLerp = triLerp;
 /**
  * Exponential interpolation between two values
  *
- * @param {number} value Normalized value to interpolate
- * @param {number} min   Minimum value
- * @param {number} max   Maximum value
+ * @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
  */
-function expLerp(value, min, max) {
-    return Math.pow(min, 1 - value) * Math.pow(max, value);
+export function expLerp(value, currentMin, currentMax, targetMin, targetMax) {
+    return (targetMin *
+        Math.pow(targetMax / targetMin, (clamp(value, currentMin, currentMax) - currentMin) / (currentMax - currentMin)));
 }
-exports.expLerp = expLerp;
 /**
  * Normalize a value between two bounds
  *
@@ -117,10 +108,9 @@ exports.expLerp = expLerp;
  * @param {number} max   Maximum boundary
  * @returns {number} Normalized value
  */
-function normalize(value, min, max) {
+export function normalize(value, min, max) {
     return (value - min) / (max - min);
 }
-exports.normalize = normalize;
 /**
  * Re-map a number from one range to another
  *
@@ -131,24 +121,22 @@ exports.normalize = normalize;
  * @param {number} targetMax  Upper bound of the value's target range
  * @returns {number} Re-mapped value
  */
-function map(value, currentMin, currentMax, targetMin, targetMax) {
+export function map(value, currentMin, currentMax, targetMin, targetMax) {
     return ((value - currentMin) / (currentMax - currentMin)) * (targetMax - targetMin) + targetMin;
 }
-exports.map = map;
 /**
  * Round a number up to a nearest multiple
  *
  * @param {number} value        Value to round
- * @param {number} [multiple=1] Multiple
+ * @param {number} [multiple=1] Multiple to round to
  * @returns {number} Closest multiple
  */
-function roundTo(value, multiple) {
+export function roundTo(value, multiple) {
     if (multiple === void 0) { multiple = 1; }
     if (multiple === 0)
         return value;
     return Math.round(value / multiple) * multiple;
 }
-exports.roundTo = roundTo;
 /**
  * Modulo absolute a value based on a length
  *
@@ -156,13 +144,12 @@ exports.roundTo = roundTo;
  * @param {number} length Total length
  * @returns {number} Modulated value
  */
-function modAbs(value, length) {
+export function modAbs(value, length) {
     if (value < 0) {
         return length + (value % length);
     }
     return value % length;
 }
-exports.modAbs = modAbs;
 /**
  * Move back and forth a value between 0 and length, so that it is never larger than length and never smaller than 0
  *
@@ -170,11 +157,10 @@ exports.modAbs = modAbs;
  * @param {number} length Total length
  * @returns {number} PingPonged value
  */
-function pingPong(value, length) {
+export function pingPong(value, length) {
     value = modAbs(value, length * 2);
     return length - Math.abs(value - length);
 }
-exports.pingPong = pingPong;
 /**
  * Smooth a value using cubic Hermite interpolation
  *
@@ -183,13 +169,12 @@ exports.pingPong = pingPong;
  * @param {number} [max=1] Maximum boundary
  * @returns {number} Normalized smoothed value
  */
-function smoothstep(value, min, max) {
+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);
 }
-exports.smoothstep = smoothstep;
 /**
  * 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
@@ -198,31 +183,28 @@ exports.smoothstep = smoothstep;
  * @param {number} [power=1] Parabola power
  * @returns {number} Normalized re-mapped value
  */
-function parabola(x, power) {
+export function parabola(x, power) {
     if (power === void 0) { power = 1; }
     return Math.pow(4 * x * (1 - x), power);
 }
-exports.parabola = parabola;
 /**
  * Return the sum of numbers
  *
- * @param {number[]} array Array of number
+ * @param {number[]} array Array of numbers
  * @returns {number} Total sum
  */
-function sum(array) {
+export function sum(array) {
     return array.reduce(function (previous, current) { return previous + current; });
 }
-exports.sum = sum;
 /**
  * Return the average of numbers
  *
- * @param {number[]} array Array of number
+ * @param {number[]} array Array of numbers
  * @returns {number} Total average
  */
-function average(array) {
+export function average(array) {
     return sum(array) / array.length;
 }
-exports.average = average;
 /**
  * Smoothly interpolate a number toward another
  *
@@ -232,7 +214,6 @@ exports.average = average;
  * @param {number} delta   Delta time (in seconds)
  * @returns {number} Interpolated number
  */
-function damp(value, target, damping, delta) {
+export function damp(value, target, damping, delta) {
     return lerp(1 - Math.exp(-damping * delta), value, target);
 }
-exports.damp = damp;

package/lib/random.d.ts

@@ -1,9 +1,9 @@
 import { Vector2, Vector3 } from './types';
 /**
- * Generate a random boolean (true or false)
+ * Generate a random boolean (`true` or `false`)
  *
- * @param {number} [probability=0.5] Probability to get true
- * @returns {boolean} Either true or false
+ * @param {number} [probability=0.5] Probability to get `true`
+ * @returns {boolean} Either `true` or `false`
  */
 export declare function randomBoolean(probability?: number): boolean;
 /**
@@ -14,16 +14,16 @@ export declare function randomBoolean(probability?: number): boolean;
  */
 export declare function randomSign(probability?: number): number;
 /**
- * Generate a random float number
+ * Generate a random floating-point number within a specified range
  *
- * @param  {number} [min=0]       Minimum boundary
- * @param  {number} [max=1]       Maximum boundary
- * @param  {number} [precision=2] Number of digits after the decimal point
+ * @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(min?: number, max?: number, precision?: number): number;
 /**
- * Generate a random integer number
+ * Generate a random integer number within a specified range
  *
  * @param {number} min Minimum boundary
  * @param {number} max Maximum boundary
@@ -33,61 +33,61 @@ export declare function randomInt(min: number, max: number): number;
 /**
  * Generate a random hexadecimal color
  *
- * @returns {string} Hexadecimal color
+ * @returns {string} Generated hexadecimal color
  */
 export declare function randomHexColor(): string;
 /**
- * Pick a random item from an array
+ * Pick a random item from a given array
  *
- * @param {T[]} [array=[]] Array to pick the item from
+ * @param {T[]} array Array to pick the item from
  * @returns {T|undefined} Random item picked
  */
-export declare function randomItem<T = unknown>(array?: T[]): T | undefined;
+export declare function randomItem<T = unknown>(array: T[]): T | undefined;
 /**
- * Pick a random property from an object
+ * Pick a random property value from a given object
  *
  * @param {object} object Object to pick the property from
- * @returns {unknown|undefined} Random item picked
+ * @returns {T|undefined} Random item picked
  */
 export declare function randomObjectProperty<T = unknown>(object: {
     [key: string]: T;
 }): T | undefined;
 /**
- * Return a random index from an array of weights
+ * Select a random index from an array of weighted items
  *
  * @param {number[]} weights Array of weights
  * @returns {number} Random index based on weights
  */
-export declare function randomIndex(weights?: number[]): number;
+export declare function randomIndex(weights: number[]): number;
 /**
  * Produce a random 2D point around the perimiter of a unit circle
  *
- * @param  {number} [radius=1] Radius of the circle
- * @param  {Vector2} target    Target vector
+ * @param  {number} [radius=1]        Radius of the circle
+ * @param  {Vector2} [target] Target vector
  * @returns {Vector2} Random 2D point on circle
  */
 export declare function onCircle(radius?: number, target?: Vector2): Vector2;
 /**
  * Produce a random 2D point inside a unit circle
  *
- * @param  {number} [radius=1] Radius of the circle
- * @param  {Vector2} target    Target vector
+ * @param  {number} [radius=1]        Radius of the circle
+ * @param  {Vector2} [target] Target vector
  * @returns {Vector2} Random 2D point inside circle
  */
 export declare function insideCircle(radius?: number, target?: Vector2): Vector2;
 /**
  * Produce a random 3D point on the surface of a unit sphere
  *
- * @param  {number} [radius=1] Radius of the sphere
- * @param  {Vector3} target    Target vector
+ * @param  {number} [radius=1]        Radius of the sphere
+ * @param  {Vector3} [target] Target vector
  * @returns {Vector3} Random 3D point on sphere
  */
 export declare function onSphere(radius?: number, target?: Vector3): Vector3;
 /**
  * Produce a random 3D point inside a unit sphere
  *
- * @param  {number} [radius=1] Radius of the sphere
- * @param  {Vector3} target    Target vector
+ * @param  {number} [radius=1]        Radius of the sphere
+ * @param  {Vector3} [target] Target vector
  * @returns {Vector3} Random 3D point inside sphere
  */
 export declare function insideSphere(radius?: number, target?: Vector3): Vector3;

package/lib/random.js

@@ -1,99 +1,87 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.insideSphere = exports.onSphere = exports.insideCircle = exports.onCircle = exports.randomIndex = exports.randomObjectProperty = exports.randomItem = exports.randomHexColor = exports.randomInt = exports.randomFloat = exports.randomSign = exports.randomBoolean = void 0;
-var geometry_1 = require("./geometry");
+import { radToSphere } from './geometry';
 /**
- * Generate a random boolean (true or false)
+ * Generate a random boolean (`true` or `false`)
  *
- * @param {number} [probability=0.5] Probability to get true
- * @returns {boolean} Either true or false
+ * @param {number} [probability=0.5] Probability to get `true`
+ * @returns {boolean} Either `true` or `false`
  */
-function randomBoolean(probability) {
+export function randomBoolean(probability) {
     if (probability === void 0) { probability = 0.5; }
     return Math.random() < probability;
 }
-exports.randomBoolean = randomBoolean;
 /**
  * Generate a random sign (1 or -1)
  *
  * @param {number} [probability=0.5] Probability to get 1
  * @returns {number} Either 1 or -1
  */
-function randomSign(probability) {
+export function randomSign(probability) {
     if (probability === void 0) { probability = 0.5; }
     return randomBoolean(probability) ? 1 : -1;
 }
-exports.randomSign = randomSign;
 /**
- * Generate a random float number
+ * Generate a random floating-point number within a specified range
  *
- * @param  {number} [min=0]       Minimum boundary
- * @param  {number} [max=1]       Maximum boundary
- * @param  {number} [precision=2] Number of digits after the decimal point
+ * @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
  */
-function randomFloat(min, max, precision) {
+export function randomFloat(min, max, precision) {
     if (min === void 0) { min = 0; }
     if (max === void 0) { max = 1; }
     if (precision === void 0) { precision = 2; }
     return parseFloat(Math.min(min + Math.random() * (max - min), max).toFixed(precision));
 }
-exports.randomFloat = randomFloat;
 /**
- * Generate a random integer number
+ * Generate a random integer number within a specified range
  *
  * @param {number} min Minimum boundary
  * @param {number} max Maximum boundary
  * @returns {number} Generated integer
  */
-function randomInt(min, max) {
+export function randomInt(min, max) {
     return Math.floor(Math.random() * (max - min + 1) + min);
 }
-exports.randomInt = randomInt;
 /**
  * Generate a random hexadecimal color
  *
- * @returns {string} Hexadecimal color
+ * @returns {string} Generated hexadecimal color
  */
-function randomHexColor() {
+export function randomHexColor() {
     return '#' + ('00000' + ((Math.random() * (1 << 24)) | 0).toString(16)).slice(-6);
 }
-exports.randomHexColor = randomHexColor;
 /**
- * Pick a random item from an array
+ * Pick a random item from a given array
  *
- * @param {T[]} [array=[]] Array to pick the item from
+ * @param {T[]} array Array to pick the item from
  * @returns {T|undefined} Random item picked
  */
-function randomItem(array) {
-    if (array === void 0) { array = []; }
+export function randomItem(array) {
     if (array.length === 0)
         return undefined;
     return array[randomInt(0, array.length - 1)];
 }
-exports.randomItem = randomItem;
 /**
- * Pick a random property from an object
+ * Pick a random property value from a given object
  *
  * @param {object} object Object to pick the property from
- * @returns {unknown|undefined} Random item picked
+ * @returns {T|undefined} Random item picked
  */
-function randomObjectProperty(object) {
+export function randomObjectProperty(object) {
     var keys = Object.keys(object);
     var key = randomItem(keys);
     if (key && object.hasOwnProperty(key)) {
         return object[key];
     }
 }
-exports.randomObjectProperty = randomObjectProperty;
 /**
- * Return a random index from an array of weights
+ * Select a random index from an array of weighted items
  *
  * @param {number[]} weights Array of weights
  * @returns {number} Random index based on weights
  */
-function randomIndex(weights) {
-    if (weights === void 0) { weights = []; }
+export function randomIndex(weights) {
     if (weights.length === 0)
         return -1;
     var totalWeight = 0;
@@ -112,18 +100,17 @@ function randomIndex(weights) {
     }
     return 0;
 }
-exports.randomIndex = randomIndex;
 // *********************
 // Geometry
 // *********************
 /**
  * Produce a random 2D point around the perimiter of a unit circle
  *
- * @param  {number} [radius=1] Radius of the circle
- * @param  {Vector2} target    Target vector
+ * @param  {number} [radius=1]        Radius of the circle
+ * @param  {Vector2} [target] Target vector
  * @returns {Vector2} Random 2D point on circle
  */
-function onCircle(radius, target) {
+export function onCircle(radius, target) {
     if (radius === void 0) { radius = 1; }
     if (target === void 0) { target = { x: 0, y: 0 }; }
     var angle = Math.random() * 2.0 * Math.PI;
@@ -131,49 +118,45 @@ function onCircle(radius, target) {
     target.y = radius * Math.sin(angle);
     return target;
 }
-exports.onCircle = onCircle;
 /**
  * Produce a random 2D point inside a unit circle
  *
- * @param  {number} [radius=1] Radius of the circle
- * @param  {Vector2} target    Target vector
+ * @param  {number} [radius=1]        Radius of the circle
+ * @param  {Vector2} [target] Target vector
  * @returns {Vector2} Random 2D point inside circle
  */
-function insideCircle(radius, target) {
+export function insideCircle(radius, target) {
     if (radius === void 0) { radius = 1; }
     if (target === void 0) { target = { x: 0, y: 0 }; }
     radius *= Math.random();
     return onCircle(radius, target);
 }
-exports.insideCircle = insideCircle;
 /**
  * Produce a random 3D point on the surface of a unit sphere
  *
- * @param  {number} [radius=1] Radius of the sphere
- * @param  {Vector3} target    Target vector
+ * @param  {number} [radius=1]        Radius of the sphere
+ * @param  {Vector3} [target] Target vector
  * @returns {Vector3} Random 3D point on sphere
  */
-function onSphere(radius, target) {
+export function onSphere(radius, target) {
     if (radius === void 0) { radius = 1; }
     if (target === void 0) { target = { x: 0, y: 0, z: 0 }; }
     var u = Math.random() * Math.PI * 2;
     var v = Math.random() * 2 - 1;
     var phi = u;
     var theta = Math.acos(v);
-    return (0, geometry_1.radToSphere)(radius, phi, theta, target);
+    return radToSphere(radius, phi, theta, target);
 }
-exports.onSphere = onSphere;
 /**
  * Produce a random 3D point inside a unit sphere
  *
- * @param  {number} [radius=1] Radius of the sphere
- * @param  {Vector3} target    Target vector
+ * @param  {number} [radius=1]        Radius of the sphere
+ * @param  {Vector3} [target] Target vector
  * @returns {Vector3} Random 3D point inside sphere
  */
-function insideSphere(radius, target) {
+export function insideSphere(radius, target) {
     if (radius === void 0) { radius = 1; }
     if (target === void 0) { target = { x: 0, y: 0, z: 0 }; }
     radius *= Math.random();
     return onSphere(radius, target);
 }
-exports.insideSphere = insideSphere;

package/lib/strings.js

@@ -1,23 +1,18 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.cleanPath = exports.capitalize = void 0;
 /**
  * Capitalize a string
  *
  * @param  {string} string String to capitalize
  * @returns {string} Capitalized string
  */
-function capitalize(string) {
+export function capitalize(string) {
     return string.charAt(0).toUpperCase() + string.slice(1);
 }
-exports.capitalize = capitalize;
 /**
  * Clean a path by removing params
  *
  * @param  {string} path Path to clean
  * @returns {string} Cleaned path
  */
-function cleanPath(path) {
+export function cleanPath(path) {
     return path.split('#')[0].split('?')[0];
 }
-exports.cleanPath = cleanPath;