toosoon-utils 3.1.0 → 4.0.1

package/lib/functions.js

@@ -1,22 +1,16 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.now = exports.defer = exports.throttle = exports.debounce = exports.wait = exports.noop = void 0;
 /**
  * No-op function
  */
-var noop = function () { };
-exports.noop = noop;
+export const noop = () => { };
 /**
  * Promise wrapped setTimeout
  *
  * @param {number} [delay=0] Time to wait (in milliseconds)
  * @returns {Promise}
  */
-function wait(delay) {
-    if (delay === void 0) { delay = 0; }
-    return new Promise(function (resolve) { return setTimeout(resolve, delay); });
+export function wait(delay = 0) {
+    return new Promise((resolve) => setTimeout(resolve, delay));
 }
-exports.wait = wait;
 /**
  * Create a debounced function that delays the execution of `callback` until a specified `delay` time has passed since the last call
  *
@@ -24,19 +18,14 @@ exports.wait = wait;
  * @param {number} delay      Delay (in milliseconds)
  * @returns {Function} Debounced function
  */
-function debounce(callback, delay) {
-    var timeout = null;
-    return function () {
-        var args = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            args[_i] = arguments[_i];
-        }
+export function debounce(callback, delay) {
+    let timeout = null;
+    return (...args) => {
         if (timeout)
             clearTimeout(timeout);
-        timeout = setTimeout(function () { return callback.apply(void 0, args); }, delay);
+        timeout = setTimeout(() => callback(...args), delay);
     };
 }
-exports.debounce = debounce;
 /**
  * Create a throttled function that limits the execution of `callback` to once every `limit` time
  *
@@ -44,54 +33,52 @@ exports.debounce = debounce;
  * @param {number} limit      Minimum interval between two calls (in milliseconds)
  * @returns {Function} Throttled function
  */
-function throttle(callback, limit) {
-    var lastTime = 0;
-    return function () {
-        var args = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            args[_i] = arguments[_i];
-        }
-        var time = (0, exports.now)();
+export function throttle(callback, limit) {
+    let lastTime = 0;
+    return (...args) => {
+        const time = now();
         if (time - lastTime >= limit) {
             lastTime = time;
-            callback.apply(void 0, args);
+            callback(...args);
         }
     };
 }
-exports.throttle = throttle;
 /**
  * Deferred promise implementation
  *
- * @returns {Deferred}
+ * @returns {object}
  */
-function defer() {
-    var resolve;
-    var reject;
-    var promise = new Promise(function (_resolve, _reject) {
+export function defer() {
+    let resolve;
+    let reject;
+    const promise = new Promise((_resolve, _reject) => {
         resolve = _resolve;
         reject = _reject;
     });
-    return { promise: promise, resolve: resolve, reject: reject };
+    return { promise, resolve, reject };
 }
-exports.defer = defer;
+/**
+ * Polyfill for `now()` functions
+ */
+export let now;
 // In node.js, use `process.hrtime`
 if (typeof process !== 'undefined' && process.hrtime) {
-    exports.now = function () {
+    now = function () {
         // Convert [seconds, nanoseconds] to milliseconds
-        var time = process.hrtime();
+        const 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
-    exports.now = performance.now.bind(performance);
+    now = performance.now.bind(performance);
 }
 else if (typeof Date.now !== 'undefined') {
-    exports.now = Date.now;
+    now = Date.now;
 }
 else {
-    exports.now = function () {
+    now = function () {
         return new Date().getTime();
     };
 }

package/lib/geometry.d.ts

@@ -1,4 +1,4 @@
-import { Vector3 } from './types';
+import type { Vector3 } from './types';
 /**
  * Convert a radians value into degrees
  *
@@ -59,30 +59,30 @@ export declare function diagonal(width: number, height: number): number;
  * @returns {Vector3}
  */
 export declare function radToSphere(radius: number, phi: number, theta: number, target?: Vector3): Vector3;
-export interface FitInput {
+export type FitInput = {
     width: number;
     height: number;
-}
-export interface FitOutput {
+};
+export type FitOutput = {
     left: number;
     top: number;
     width: number;
     height: number;
     scale: number;
-}
+};
 /**
  * Make a target fit a container (cover mode)
  *
- * @param {FitInput} target    Dimension of the target
- * @param {FitInput} container Dimension of the container
- * @returns {FitOutput}
+ * @param {object} target    Dimensions of the target
+ * @param {object} container Dimensions of the container
+ * @returns {object}
  */
 export declare function cover(target: FitInput, container: FitInput): FitOutput;
 /**
  * Make a target fit a container (contain mode)
  *
- * @param {FitInput} target    Dimension of the target
- * @param {FitInput} container Dimension of the container
- * @returns {FitOutput}
+ * @param {object} target    Dimensions of the target
+ * @param {object} container Dimensions of the container
+ * @returns {object}
  */
 export declare function contain(target: FitInput, container: FitInput): FitOutput;

package/lib/geometry.js

@@ -1,27 +1,22 @@
-"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");
+import { PI } from './constants';
 /**
  * Convert a radians value into degrees
  *
  * @param {number} radians Angle in radians
  * @returns {number} Angle in degrees
  */
-function toDegrees(radians) {
-    return (radians * 180) / constants_1.PI;
+export function toDegrees(radians) {
+    return (radians * 180) / PI;
 }
-exports.toDegrees = toDegrees;
 /**
  * Convert a degrees value into radians
  *
  * @param {number} degrees Angle in degrees
  * @returns {number} Angle in radians
  */
-function toRadians(degrees) {
-    return (degrees * constants_1.PI) / 180;
+export function toRadians(degrees) {
+    return (degrees * PI) / 180;
 }
-exports.toRadians = toRadians;
 /**
  * Calculate the angle from a point to another
  *
@@ -31,10 +26,9 @@ exports.toRadians = toRadians;
  * @param  {number} y2 Y value of the second point
  * @returns {number} Angle
  */
-function angle(x1, y1, x2, y2) {
+export function angle(x1, y1, x2, y2) {
     return Math.atan2(y2 - y1, x2 - x1);
 }
-exports.angle = angle;
 /**
  * Find the closest angle between to angles
  *
@@ -42,11 +36,10 @@ exports.angle = angle;
  * @param {number} target Target angle in radians
  * @returns {number} Closest angle
  */
-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;
+export function closestAngle(source, target) {
+    const delta = target - source;
+    return delta > PI ? target - 2 * PI : target < -PI ? delta + 2 * PI : target;
 }
-exports.closestAngle = closestAngle;
 /**
  * Calculate the distance between two points
  *
@@ -56,12 +49,11 @@ exports.closestAngle = closestAngle;
  * @param {number} y2 Y coord of the second point
  * @returns {number} Computed distance
  */
-function distance(x1, y1, x2, y2) {
-    var dx = x1 - x2;
-    var dy = y1 - y2;
+export function distance(x1, y1, x2, y2) {
+    const dx = x1 - x2;
+    const dy = y1 - y2;
     return Math.sqrt(dx * dx + dy * dy);
 }
-exports.distance = distance;
 /**
  * Calculate the length of the diagonal of a rectangle
  *
@@ -69,10 +61,9 @@ exports.distance = distance;
  * @param {number} height Height of the rectangle
  * @returns {number} Diagonal length
  */
-function diagonal(width, height) {
+export 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
  *
@@ -82,26 +73,24 @@ exports.diagonal = diagonal;
  * @param  {Vector3} target Target vector
  * @returns {Vector3}
  */
-function radToSphere(radius, phi, theta, target) {
-    if (target === void 0) { target = { x: 0, y: 0, z: 0 }; }
+export function radToSphere(radius, phi, theta, 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
  *
- * @param {FitInput} target    Dimension of the target
- * @param {FitInput} container Dimension of the container
- * @param {string} mode        Can be 'contain' | 'cover'
- * @returns {FitOutput}
+ * @param {object} target    Dimensions of the target
+ * @param {object} container Dimensions of the container
+ * @param {string} mode      Can be 'contain' | 'cover'
+ * @returns {object}
  */
 function fit(target, container, mode) {
-    var ratioWidth = container.width / target.width;
-    var ratioHeight = container.height / target.height;
-    var scale;
+    const ratioWidth = container.width / target.width;
+    const ratioHeight = container.height / target.height;
+    let scale;
     if (mode === 'contain') {
         scale = ratioWidth < ratioHeight ? ratioWidth : ratioHeight;
     }
@@ -113,28 +102,26 @@ function fit(target, container, mode) {
         top: (container.height - target.height * scale) >> 1,
         width: target.width * scale,
         height: target.height * scale,
-        scale: scale
+        scale
     };
 }
 /**
  * Make a target fit a container (cover mode)
  *
- * @param {FitInput} target    Dimension of the target
- * @param {FitInput} container Dimension of the container
- * @returns {FitOutput}
+ * @param {object} target    Dimensions of the target
+ * @param {object} container Dimensions of the container
+ * @returns {object}
  */
-function cover(target, container) {
+export function cover(target, container) {
     return fit(target, container, 'cover');
 }
-exports.cover = cover;
 /**
  * Make a target fit a container (contain mode)
  *
- * @param {FitInput} target    Dimension of the target
- * @param {FitInput} container Dimension of the container
- * @returns {FitOutput}
+ * @param {object} target    Dimensions of the target
+ * @param {object} container Dimensions of the container
+ * @returns {object}
  */
-function contain(target, container) {
+export function contain(target, container) {
     return fit(target, container, 'contain');
 }
-exports.contain = contain;

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.snap = 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,22 @@ exports.isPowerOf2 = isPowerOf2;
  * @param {string} [mode='ceil'] Can be 'floor' | 'ceil' | 'round'
  * @returns {number} Power of 2
  */
-function toPowerOf2(value, mode) {
-    if (mode === void 0) { mode = 'ceil'; }
+export function toPowerOf2(value, 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
  */
-function sign(value) {
+export 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
  *
@@ -65,12 +56,9 @@ exports.sign = sign;
  * @param {number} [max=1] Maximum boundary
  * @returns {number} Clamped value
  */
-function clamp(value, min, max) {
-    if (min === void 0) { min = 0; }
-    if (max === void 0) { max = 1; }
+export function clamp(value, min = 0, max = 1) {
     return Math.min(max, Math.max(min, value));
 }
-exports.clamp = clamp;
 /**
  * Linear interpolation between two values (lerping)
  *
@@ -79,10 +67,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,11 +79,10 @@ exports.lerp = lerp;
  * @param {number} target Triangle target value
  * @returns {number} Interpolated value
  */
-function triLerp(value, min, max, target) {
-    var x = Math.pow(1 + Math.abs(target - max) / Math.abs(target - min), -1);
+export function triLerp(value, min, max, target) {
+    const 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
  *
@@ -107,11 +93,10 @@ exports.triLerp = triLerp;
  * @param {number} targetMax  Upper bound of the value's target range
  * @returns {number} Interpolated value
  */
-function expLerp(value, currentMin, currentMax, targetMin, targetMax) {
+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
  *
@@ -120,10 +105,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
  *
@@ -134,10 +118,9 @@ 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
  *
@@ -145,13 +128,11 @@ exports.map = map;
  * @param {number} [multiple=1] Multiple to round to
  * @returns {number} Closest multiple
  */
-function snap(value, multiple) {
-    if (multiple === void 0) { multiple = 1; }
+export function snap(value, multiple = 1) {
     if (multiple === 0)
         return value;
     return Math.round(value / multiple) * multiple;
 }
-exports.snap = snap;
 /**
  * Modulo absolute a value based on a length
  *
@@ -159,13 +140,12 @@ exports.snap = snap;
  * @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
  *
@@ -173,11 +153,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
  *
@@ -186,13 +165,10 @@ exports.pingPong = pingPong;
  * @param {number} [max=1] Maximum boundary
  * @returns {number} Normalized smoothed value
  */
-function smoothstep(value, min, max) {
-    if (min === void 0) { min = 0; }
-    if (max === void 0) { max = 1; }
-    var x = clamp(normalize(value, min, max));
+export function smoothstep(value, min = 0, max = 1) {
+    const 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
@@ -201,31 +177,27 @@ exports.smoothstep = smoothstep;
  * @param {number} [power=1] Parabola power
  * @returns {number} Normalized re-mapped value
  */
-function parabola(x, power) {
-    if (power === void 0) { power = 1; }
+export function parabola(x, 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
  */
-function sum(array) {
-    return array.reduce(function (previous, current) { return previous + current; });
+export function sum(array) {
+    return array.reduce((previous, current) => previous + current);
 }
-exports.sum = sum;
 /**
  * Return the average of numbers
  *
  * @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
  *
@@ -235,7 +207,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;