toosoon-utils 2.4.2 → 3.0.1

package/lib/geometry.js

@@ -1,22 +1,27 @@
-import { PI } from './constants';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.contain = exports.cover = exports.radToSphere = exports.diagonal = exports.distance = exports.closestAngle = exports.angle = exports.toRadians = exports.toDegrees = void 0;
+var constants_1 = require("./constants");
 /**
  * Convert a radians value into degrees
  *
  * @param {number} radians Angle in radians
  * @returns {number} Angle in degrees
  */
-export function toDegrees(radians) {
-    return (radians * 180) / PI;
+function toDegrees(radians) {
+    return (radians * 180) / constants_1.PI;
 }
+exports.toDegrees = toDegrees;
 /**
  * Convert a degrees value into radians
  *
  * @param {number} degrees Angle in degrees
  * @returns {number} Angle in radians
  */
-export function toRadians(degrees) {
-    return (degrees * PI) / 180;
+function toRadians(degrees) {
+    return (degrees * constants_1.PI) / 180;
 }
+exports.toRadians = toRadians;
 /**
  * Calculate the angle from a point to another
  *
@@ -26,9 +31,10 @@ export function toRadians(degrees) {
  * @param  {number} y2 Y value of the second point
  * @returns {number} Angle
  */
-export function angle(x1, y1, x2, y2) {
+function angle(x1, y1, x2, y2) {
     return Math.atan2(y2 - y1, x2 - x1);
 }
+exports.angle = angle;
 /**
  * Find the closest angle between to angles
  *
@@ -36,10 +42,11 @@ export function angle(x1, y1, x2, y2) {
  * @param {number} target Target angle in radians
  * @returns {number} Closest angle
  */
-export function closestAngle(source, target) {
-    const delta = target - source;
-    return delta > PI ? target - 2 * PI : target < -PI ? delta + 2 * PI : target;
+function closestAngle(source, target) {
+    var delta = target - source;
+    return delta > constants_1.PI ? target - 2 * constants_1.PI : target < -constants_1.PI ? delta + 2 * constants_1.PI : target;
 }
+exports.closestAngle = closestAngle;
 /**
  * Calculate the distance between two points
  *
@@ -49,11 +56,12 @@ export function closestAngle(source, target) {
  * @param {number} y2 Y coord of the second point
  * @returns {number} Computed distance
  */
-export function distance(x1, y1, x2, y2) {
-    const dx = x1 - x2;
-    const dy = y1 - y2;
+function distance(x1, y1, x2, y2) {
+    var dx = x1 - x2;
+    var dy = y1 - y2;
     return Math.sqrt(dx * dx + dy * dy);
 }
+exports.distance = distance;
 /**
  * Calculate the length of the diagonal of a rectangle
  *
@@ -61,9 +69,10 @@ export function distance(x1, y1, x2, y2) {
  * @param {number} height Height of the rectangle
  * @returns {number} Diagonal length
  */
-export function diagonal(width, height) {
+function diagonal(width, height) {
     return Math.sqrt(width * width + height * height);
 }
+exports.diagonal = diagonal;
 /**
  * Convert radians to a 3D point on the surface of a unit sphere
  *
@@ -73,12 +82,14 @@ export function diagonal(width, height) {
  * @param  {Vector3} target Target vector
  * @returns {Vector3}
  */
-export function radToSphere(radius, phi, theta, target = { x: 0, y: 0, z: 0 }) {
+function radToSphere(radius, phi, theta, target) {
+    if (target === void 0) { target = { x: 0, y: 0, z: 0 }; }
     target.x = radius * Math.sin(phi) * Math.sin(theta);
     target.y = radius * Math.cos(phi);
     target.z = radius * Math.sin(phi) * Math.cos(theta);
     return target;
 }
+exports.radToSphere = radToSphere;
 /**
  * Make a target fit a container
  *
@@ -88,9 +99,9 @@ export function radToSphere(radius, phi, theta, target = { x: 0, y: 0, z: 0 }) {
  * @returns {FitOutput}
  */
 function fit(target, container, mode) {
-    const ratioWidth = container.width / target.width;
-    const ratioHeight = container.height / target.height;
-    let scale;
+    var ratioWidth = container.width / target.width;
+    var ratioHeight = container.height / target.height;
+    var scale;
     if (mode === 'contain') {
         scale = ratioWidth < ratioHeight ? ratioWidth : ratioHeight;
     }
@@ -102,7 +113,7 @@ function fit(target, container, mode) {
         top: (container.height - target.height * scale) >> 1,
         width: target.width * scale,
         height: target.height * scale,
-        scale
+        scale: scale
     };
 }
 /**
@@ -112,9 +123,10 @@ function fit(target, container, mode) {
  * @param {FitInput} container Dimension of the container
  * @returns {FitOutput}
  */
-export function cover(target, container) {
+function cover(target, container) {
     return fit(target, container, 'cover');
 }
+exports.cover = cover;
 /**
  * Make a target fit a container (contain mode)
  *
@@ -122,6 +134,7 @@ export function cover(target, container) {
  * @param {FitInput} container Dimension of the container
  * @returns {FitOutput}
  */
-export function contain(target, container) {
+function contain(target, container) {
     return fit(target, container, 'contain');
 }
+exports.contain = contain;

package/lib/maths.js

@@ -1,30 +1,36 @@
+"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
  */
-export function isEven(value) {
+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
  */
-export function isOdd(value) {
+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
  */
-export function isPowerOf2(value) {
+function isPowerOf2(value) {
     return (value & (value - 1)) === 0;
 }
+exports.isPowerOf2 = isPowerOf2;
 /**
  * Find closest power of 2 that fits a number
  *
@@ -32,22 +38,25 @@ export function isPowerOf2(value) {
  * @param {string} [mode='ceil'] Can be 'floor' | 'ceil' | 'round'
  * @returns {number} Power of 2
  */
-export function toPowerOf2(value, mode = 'ceil') {
+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} value Value to check
  * @returns {number} 1 if the given number is positive, -1 if it is negative, otherwise 0
  */
-export function sign(value) {
+function sign(value) {
     if (value > 0)
         return 1;
     else if (value < 0)
         return -1;
     return 0;
 }
+exports.sign = sign;
 /**
  * Clamp a value between two bounds
  *
@@ -56,9 +65,12 @@ export function sign(value) {
  * @param {number} [max=1] Maximum boundary
  * @returns {number} Clamped value
  */
-export function clamp(value, min = 0, max = 1) {
+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)
  *
@@ -67,9 +79,10 @@ export function clamp(value, min = 0, max = 1) {
  * @param {number} max   Maximum value
  * @returns {number} Lerped value
  */
-export function lerp(value, min, max) {
+function lerp(value, min, max) {
     return min + (max - min) * value;
 }
+exports.lerp = lerp;
 /**
  * Triangular interpolation between two values
  *
@@ -79,10 +92,11 @@ export function lerp(value, min, max) {
  * @param {number} target Triangle target value
  * @returns {number} Interpolated value
  */
-export function triLerp(value, min, max, target) {
-    const x = Math.pow(1 + Math.abs(target - max) / Math.abs(target - min), -1);
+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
  *
@@ -93,10 +107,11 @@ export function triLerp(value, min, max, target) {
  * @param {number} targetMax  Upper bound of the value's target range
  * @returns {number} Interpolated value
  */
-export function expLerp(value, currentMin, currentMax, targetMin, targetMax) {
+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
  *
@@ -105,9 +120,10 @@ export function expLerp(value, currentMin, currentMax, targetMin, targetMax) {
  * @param {number} max   Maximum boundary
  * @returns {number} Normalized value
  */
-export function normalize(value, min, max) {
+function normalize(value, min, max) {
     return (value - min) / (max - min);
 }
+exports.normalize = normalize;
 /**
  * Re-map a number from one range to another
  *
@@ -118,9 +134,10 @@ export function normalize(value, min, max) {
  * @param {number} targetMax  Upper bound of the value's target range
  * @returns {number} Re-mapped value
  */
-export function map(value, currentMin, currentMax, targetMin, targetMax) {
+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
  *
@@ -128,11 +145,13 @@ export function map(value, currentMin, currentMax, targetMin, targetMax) {
  * @param {number} [multiple=1] Multiple to round to
  * @returns {number} Closest multiple
  */
-export function roundTo(value, multiple = 1) {
+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
  *
@@ -140,12 +159,13 @@ export function roundTo(value, multiple = 1) {
  * @param {number} length Total length
  * @returns {number} Modulated value
  */
-export function modAbs(value, length) {
+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
  *
@@ -153,10 +173,11 @@ export function modAbs(value, length) {
  * @param {number} length Total length
  * @returns {number} PingPonged value
  */
-export function pingPong(value, length) {
+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
  *
@@ -165,10 +186,13 @@ export function pingPong(value, length) {
  * @param {number} [max=1] Maximum boundary
  * @returns {number} Normalized smoothed value
  */
-export function smoothstep(value, min = 0, max = 1) {
-    const x = clamp(normalize(value, min, max));
+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
@@ -177,27 +201,31 @@ export function smoothstep(value, min = 0, max = 1) {
  * @param {number} [power=1] Parabola power
  * @returns {number} Normalized re-mapped value
  */
-export function parabola(x, power = 1) {
+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 numbers
  * @returns {number} Total sum
  */
-export function sum(array) {
-    return array.reduce((previous, current) => previous + current);
+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 numbers
  * @returns {number} Total average
  */
-export function average(array) {
+function average(array) {
     return sum(array) / array.length;
 }
+exports.average = average;
 /**
  * Smoothly interpolate a number toward another
  *
@@ -207,6 +235,7 @@ export function average(array) {
  * @param {number} delta   Delta time (in seconds)
  * @returns {number} Interpolated number
  */
-export function damp(value, target, damping, delta) {
+function damp(value, target, damping, delta) {
     return lerp(1 - Math.exp(-damping * delta), value, target);
 }
+exports.damp = damp;

package/lib/prng.js

@@ -1,15 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.randomIndex = exports.randomObjectProperty = exports.randomItem = exports.randomHexColor = exports.randomInt = exports.randomFloat = exports.randomSign = exports.randomBoolean = exports.random = exports.xoshiro128ss = exports.jsf32 = exports.mulberry32 = exports.splitmix32 = exports.sfc32 = exports.cyrb128 = void 0;
 /**
  * Produce a 128-bit hash value from a seed
  *
  * @param {string} seed Initial seed state
  * @returns {[number, number, number, number]} Hash numbers
  */
-export function cyrb128(seed) {
-    let h1 = 1779033703;
-    let h2 = 3144134277;
-    let h3 = 1013904242;
-    let h4 = 2773480762;
-    for (let i = 0, k; i < seed.length; i++) {
+function cyrb128(seed) {
+    var h1 = 1779033703;
+    var h2 = 3144134277;
+    var h3 = 1013904242;
+    var h4 = 2773480762;
+    for (var i = 0, k = void 0; i < seed.length; i++) {
         k = seed.charCodeAt(i);
         h1 = h2 ^ Math.imul(h1 ^ k, 597399067);
         h2 = h3 ^ Math.imul(h2 ^ k, 2869860233);
@@ -22,6 +25,7 @@ export function cyrb128(seed) {
     h4 = Math.imul(h2 ^ (h4 >>> 19), 2716044179);
     return [(h1 ^ h2 ^ h3 ^ h4) >>> 0, (h2 ^ h1) >>> 0, (h3 ^ h1) >>> 0, (h4 ^ h1) >>> 0];
 }
+exports.cyrb128 = cyrb128;
 // *********************
 // PRNG Algorithms
 // *********************
@@ -34,12 +38,12 @@ export function cyrb128(seed) {
  * @param {number} d
  * @returns {number} Pseudo-random number
  */
-export function sfc32(a, b, c, d) {
+function sfc32(a, b, c, d) {
     a >>>= 0;
     b >>>= 0;
     c >>>= 0;
     d >>>= 0;
-    let t = (a + b) | 0;
+    var t = (a + b) | 0;
     a = b ^ (b >>> 9);
     b = (c + (c << 3)) | 0;
     c = (c << 21) | (c >>> 11);
@@ -48,13 +52,14 @@ export function sfc32(a, b, c, d) {
     c = (c + t) | 0;
     return (t >>> 0) / 4294967296;
 }
+exports.sfc32 = sfc32;
 /**
  * SplitMix32, Generator with a 32-bit state
  *
  * @param {number} a
  * @returns {number} Pseudo-random number
  */
-export function splitmix32(a) {
+function splitmix32(a) {
     a |= 0;
     a = (a + 0x9e3779b9) | 0;
     var t = a ^ (a >>> 16);
@@ -63,45 +68,48 @@ export function splitmix32(a) {
     t = Math.imul(t, 0x735a2d97);
     return ((t = t ^ (t >>> 15)) >>> 0) / 4294967296;
 }
+exports.splitmix32 = splitmix32;
 /**
  * Mulberry32, Generator with a 32-bit state
  *
  * @param {number} a
  * @returns {number} Pseudo-random number
  */
-export function mulberry32(a) {
-    let t = (a += 0x6d2b79f5);
+function mulberry32(a) {
+    var t = (a += 0x6d2b79f5);
     t = Math.imul(t ^ (t >>> 15), t | 1);
     t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
     return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
 }
+exports.mulberry32 = mulberry32;
 /**
  * Jenkins' Small Fast, Generator with a 32-bit state
  *
  * @param {number} a
  * @returns {number} Pseudo-random number
  */
-export function jsf32(a, b, c, d) {
+function jsf32(a, b, c, d) {
     a |= 0;
     b |= 0;
     c |= 0;
     d |= 0;
-    let t = (a - ((b << 27) | (b >>> 5))) | 0;
+    var t = (a - ((b << 27) | (b >>> 5))) | 0;
     a = b ^ ((c << 17) | (c >>> 15));
     b = (c + d) | 0;
     c = (d + t) | 0;
     d = (a + t) | 0;
     return (d >>> 0) / 4294967296;
 }
+exports.jsf32 = jsf32;
 /**
  * xoshiro128**, Generator with a 128-bit state
  *
  * @param {number} a
  * @returns {number} Pseudo-random number
  */
-export function xoshiro128ss(a, b, c, d) {
-    let t = b << 9;
-    let r = a * 5;
+function xoshiro128ss(a, b, c, d) {
+    var t = b << 9;
+    var r = a * 5;
     r = ((r << 7) | (r >>> 25)) * 9;
     c ^= a;
     d ^= b;
@@ -111,6 +119,7 @@ export function xoshiro128ss(a, b, c, d) {
     d = (d << 11) | (d >>> 21);
     return (r >>> 0) / 4294967296;
 }
+exports.xoshiro128ss = xoshiro128ss;
 /**
  * Generate a pseudo-random number in the interval [0, 1]
  * PRNG equivalent of `Math.random()`
@@ -118,12 +127,13 @@ export function xoshiro128ss(a, b, c, d) {
  * @param {PRNGParameters} prng PRNG parameters
  * @returns {number} Pseudo-random number
  */
-export function random(prng) {
-    const seed = typeof prng === 'string' ? prng : prng.seed;
-    const algorithm = typeof prng === 'string' ? splitmix32 : prng.algorithm;
-    const hashes = cyrb128(seed);
-    return algorithm(...hashes);
+function random(prng) {
+    var seed = typeof prng === 'string' ? prng : prng.seed;
+    var algorithm = typeof prng === 'string' ? splitmix32 : prng.algorithm;
+    var hashes = cyrb128(seed);
+    return algorithm.apply(void 0, hashes);
 }
+exports.random = random;
 /**
  * Generate a pseudo-random boolean (true or false)
  *
@@ -131,9 +141,11 @@ export function random(prng) {
  * @param {number} [probability=0.5] Probability to get true
  * @returns {boolean} Either `true` or `false`
  */
-export function randomBoolean(prng, probability = 0.5) {
+function randomBoolean(prng, probability) {
+    if (probability === void 0) { probability = 0.5; }
     return random(prng) < probability;
 }
+exports.randomBoolean = randomBoolean;
 /**
  * Generate a pseudo-random sign (1 or -1)
  *
@@ -141,9 +153,11 @@ export function randomBoolean(prng, probability = 0.5) {
  * @param {number} [probability=0.5] Probability to get 1
  * @returns {number} Either 1 or -1
  */
-export function randomSign(prng, probability = 0.5) {
+function randomSign(prng, probability) {
+    if (probability === void 0) { probability = 0.5; }
     return randomBoolean(prng, probability) ? 1 : -1;
 }
+exports.randomSign = randomSign;
 /**
  * Generate a pseudo-random floating-point number within a specified range
  *
@@ -153,9 +167,13 @@ export function randomSign(prng, probability = 0.5) {
  * @param {number} [precision=2] Number of digits after the decimal point
  * @returns {number} Generated float
  */
-export function randomFloat(prng, min = 0, max = 1, precision = 2) {
+function randomFloat(prng, 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 + random(prng) * (max - min), max).toFixed(precision));
 }
+exports.randomFloat = randomFloat;
 /**
  * Generate a pseudo-random integer number within a specified range
  *
@@ -164,18 +182,20 @@ export function randomFloat(prng, min = 0, max = 1, precision = 2) {
  * @param {number} max          Maximum boundary
  * @returns {number} Generated integer
  */
-export function randomInt(prng, min, max) {
+function randomInt(prng, min, max) {
     return Math.floor(random(prng) * (max - min + 1) + min);
 }
+exports.randomInt = randomInt;
 /**
  * Generate a pseudo-random hexadecimal color
  *
  * @param {PRNGParameters} prng PRNG parameters
  * @returns {string} Generated hexadecimal color
  */
-export function randomHexColor(prng) {
+function randomHexColor(prng) {
     return '#' + ('00000' + ((random(prng) * (1 << 24)) | 0).toString(16)).slice(-6);
 }
+exports.randomHexColor = randomHexColor;
 /**
  * Pick a pseudo-random item from a given array
  *
@@ -183,11 +203,12 @@ export function randomHexColor(prng) {
  * @param {T[]} array           Array to pick the item from
  * @returns {T|undefined} Random item picked
  */
-export function randomItem(prng, array) {
+function randomItem(prng, array) {
     if (array.length === 0)
         return undefined;
     return array[randomInt(prng, 0, array.length - 1)];
 }
+exports.randomItem = randomItem;
 /**
  * Pick a pseudo-random property value from a given object
  *
@@ -195,13 +216,14 @@ export function randomItem(prng, array) {
  * @param {object} object       Object to pick the property from
  * @returns {T|undefined} Random item picked
  */
-export function randomObjectProperty(prng, object) {
-    const keys = Object.keys(object);
-    const key = randomItem(prng, keys);
+function randomObjectProperty(prng, object) {
+    var keys = Object.keys(object);
+    var key = randomItem(prng, keys);
     if (key && object.hasOwnProperty(key)) {
         return object[key];
     }
 }
+exports.randomObjectProperty = randomObjectProperty;
 /**
  * Select a pseudo-random index from an array of weighted items
  *
@@ -209,20 +231,22 @@ export function randomObjectProperty(prng, object) {
  * @param {number[]} weights    Array of weights
  * @returns {number} Random index based on weights
  */
-export function randomIndex(prng, weights) {
+function randomIndex(prng, weights) {
     if (weights.length === 0)
         return -1;
-    let totalWeight = 0;
-    for (let weight of weights) {
-        totalWeight += weight;
+    var totalWeight = 0;
+    for (var _i = 0, weights_1 = weights; _i < weights_1.length; _i++) {
+        var weight_1 = weights_1[_i];
+        totalWeight += weight_1;
     }
     if (totalWeight <= 0)
         console.warn('PRNG randomIndex()', 'Weights must sum to > 0', totalWeight);
-    let weight = random(prng) * totalWeight;
-    for (let i = 0; i < weights.length; i++) {
+    var weight = random(prng) * totalWeight;
+    for (var i = 0; i < weights.length; i++) {
         if (weight < weights[i])
             return i;
         weight -= weights[i];
     }
     return 0;
 }
+exports.randomIndex = randomIndex;