toosoon-utils 2.1.0 → 2.3.0

package/lib/dom.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Find the closest parent that matches a selector
+ *
+ * @param {Element}          element  Target element
+ * @param {(Element|string)} selector Selector or parent to match
+ * @returns {Element|null}
+ */
+export declare function closest(element: Element, selector: Element | string): Element | null;
+/**
+ * Create a canvas and 2d context
+ *
+ * @param {Number} width  Width of the canvas
+ * @param {Number} height Height of the canvas
+ * @returns {{ canvas: HTMLCanvasElement, ctx: CanvasRenderingContext2D }}
+ */
+export declare function createCanvas(width: number, height: number): {
+    canvas: HTMLCanvasElement;
+    ctx: CanvasRenderingContext2D;
+};
+/**
+ * Inject CSS styles in `document.head`
+ *
+ * @param {string} styles CSS styles to inject
+ */
+export declare function injectStyles(styles: string): void;

package/lib/dom.js

@@ -0,0 +1,47 @@
+var DOCUMENT_NODE_TYPE = 9;
+/**
+ * Find the closest parent that matches a selector
+ *
+ * @param {Element}          element  Target element
+ * @param {(Element|string)} selector Selector or parent to match
+ * @returns {Element|null}
+ */
+export function closest(element, selector) {
+    var current = element;
+    while (current && current.nodeType !== DOCUMENT_NODE_TYPE) {
+        if ((typeof selector === 'string' && current.matches(selector)) || current === selector) {
+            return current;
+        }
+        current = element.parentNode;
+    }
+    return current;
+}
+/**
+ * Create a canvas and 2d context
+ *
+ * @param {Number} width  Width of the canvas
+ * @param {Number} height Height of the canvas
+ * @returns {{ canvas: HTMLCanvasElement, ctx: CanvasRenderingContext2D }}
+ */
+export function createCanvas(width, height) {
+    var _a;
+    var canvas = document.createElement('canvas');
+    canvas.width = width;
+    canvas.height = height;
+    var ctx = (_a = canvas.getContext('2d')) !== null && _a !== void 0 ? _a : new CanvasRenderingContext2D();
+    return { canvas: canvas, ctx: ctx };
+}
+/**
+ * Inject CSS styles in `document.head`
+ *
+ * @param {string} styles CSS styles to inject
+ */
+export function injectStyles(styles) {
+    var $style = document.createElement('style');
+    $style.innerHTML = styles;
+    var $before = document.querySelector('head link[rel=stylesheet], head style');
+    if ($before)
+        document.head.insertBefore($style, $before);
+    else
+        document.head.appendChild($style);
+}

package/lib/files.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Download a Blob object into user files
+ *
+ * @param {Blob} blob       Blob object to download
+ * @param {string} filename Downloaded file name
+ */
+export declare function download(blob: Blob, filename: string): void;
+/**
+ * Upload a file from user files
+ *
+ * @param {Function} onLoad    Callback called once the file is loaded
+ * @param {string} [accept=''] MIME type the file input should accept
+ */
+export declare function upload(onLoad: (dataUrl: string) => void, accept?: string): void;

package/lib/files.js

@@ -0,0 +1,38 @@
+/**
+ * Download a Blob object into user files
+ *
+ * @param {Blob} blob       Blob object to download
+ * @param {string} filename Downloaded file name
+ */
+export function download(blob, filename) {
+    var link = document.createElement('a');
+    link.setAttribute('href', URL.createObjectURL(blob));
+    link.setAttribute('download', filename);
+    document.body.appendChild(link);
+    link.click();
+    document.body.removeChild(link);
+}
+/**
+ * Upload a file from user files
+ *
+ * @param {Function} onLoad    Callback called once the file is loaded
+ * @param {string} [accept=''] MIME type the file input should accept
+ */
+export function upload(onLoad, accept) {
+    if (accept === void 0) { accept = ''; }
+    var input = document.createElement('input');
+    input.setAttribute('type', 'file');
+    input.setAttribute('accept', accept);
+    input.addEventListener('change', function (event) {
+        var _a, _b;
+        var file = (_b = (_a = event.target) === null || _a === void 0 ? void 0 : _a.files) === null || _b === void 0 ? void 0 : _b[0];
+        if (file) {
+            var fileReader = new FileReader();
+            fileReader.addEventListener('load', function () { return onLoad(URL.createObjectURL(file)); });
+            fileReader.readAsDataURL(file);
+        }
+    });
+    document.body.appendChild(input);
+    input.click();
+    document.body.removeChild(input);
+}

package/lib/functions.d.ts

@@ -0,0 +1,22 @@
+import { Deferred } from './types';
+/**
+ * No-op function
+ */
+export declare const noop: () => void;
+/**
+ * Promise wrapped setTimeout
+ *
+ * @param {number} [timeout=0] Time to wait (in milliseconds)
+ * @returns {Promise}
+ */
+export declare function wait(timeout?: number): Promise<void>;
+/**
+ * Deferred promise implementation
+ *
+ * @returns {Deferred}
+ */
+export declare function defer<T = void>(): Deferred<T>;
+/**
+ * Polyfill for `now()` functions
+ */
+export declare let now: () => number;

package/lib/functions.js

@@ -0,0 +1,53 @@
+/**
+ * No-op function
+ */
+export var noop = function () { };
+/**
+ * Promise wrapped setTimeout
+ *
+ * @param {number} [timeout=0] Time to wait (in milliseconds)
+ * @returns {Promise}
+ */
+export function wait(timeout) {
+    if (timeout === void 0) { timeout = 0; }
+    return new Promise(function (resolve) { return setTimeout(resolve, timeout); });
+}
+/**
+ * Deferred promise implementation
+ *
+ * @returns {Deferred}
+ */
+export function defer() {
+    var resolve;
+    var reject;
+    var promise = new Promise(function (_resolve, _reject) {
+        resolve = _resolve;
+        reject = _reject;
+    });
+    return { promise: promise, resolve: resolve, reject: reject };
+}
+/**
+ * Polyfill for `now()` functions
+ */
+export 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();
+    };
+}

package/lib/geometry.d.ts

@@ -0,0 +1,89 @@
+import { Vector3 } from './types';
+/**
+ * Convert a radians value into degrees
+ *
+ * @param {number} radians Angle in radians
+ * @returns {number} Angle in degrees
+ */
+export declare function toDegrees(radians: number): number;
+/**
+ * Convert a degrees value into radians
+ *
+ * @param {number} degrees Angle in degrees
+ * @returns {number} Angle in radians
+ */
+export declare function toRadians(degrees: number): number;
+/**
+ * Calculate the angle from a point to another
+ *
+ * @param  {number} x1 X value of the first point
+ * @param  {number} y1 Y value of the first point
+ * @param  {number} x2 X value of the second point
+ * @param  {number} y2 Y value of the second point
+ * @returns {number} Angle
+ */
+export declare function angle(x1: number, y1: number, x2: number, y2: number): number;
+/**
+ * Find the closest angle between to angles
+ *
+ * @param {number} source Source angle in radians
+ * @param {number} target Target angle in radians
+ * @returns {number} Closest angle
+ */
+export declare function closestAngle(source: number, target: number): number;
+/**
+ * Calculate the distance between two points
+ *
+ * @param {number} x1 X coord of the first point
+ * @param {number} y1 Y coord of the first point
+ * @param {number} x2 X coord of the second point
+ * @param {number} y2 Y coord of the second point
+ * @returns {number} Computed distance
+ */
+export declare function distance(x1: number, y1: number, x2: number, y2: number): number;
+/**
+ * Calculate the length of the diagonal of a rectangle
+ *
+ * @param {number} width  Width of the rectangle
+ * @param {number} height Height of the rectangle
+ * @returns {number} Diagonal length
+ */
+export declare function diagonal(width: number, height: number): number;
+/**
+ * Convert radians to a 3D point on the surface of a unit sphere
+ *
+ * @param  {number} radius  Radius of the sphere
+ * @param  {number} phi     Polar angle from the y (up) axis     : [0, PI]
+ * @param  {number} theta   Equator angle around the y (up) axis : [0, 2*PI]
+ * @param  {Vector3} target Target vector
+ * @returns {Vector3}
+ */
+export declare function radToSphere(radius: number, phi: number, theta: number, target?: Vector3): Vector3;
+interface FitInput {
+    width: number;
+    height: number;
+}
+interface 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}
+ */
+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}
+ */
+export declare function contain(target: FitInput, container: FitInput): FitOutput;
+export {};

package/lib/geometry.js

@@ -0,0 +1,128 @@
+import { PI } from './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;
+}
+/**
+ * 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;
+}
+/**
+ * Calculate the angle from a point to another
+ *
+ * @param  {number} x1 X value of the first point
+ * @param  {number} y1 Y value of the first point
+ * @param  {number} x2 X value of the second point
+ * @param  {number} y2 Y value of the second point
+ * @returns {number} Angle
+ */
+export function angle(x1, y1, x2, y2) {
+    return Math.atan2(y2 - y1, x2 - x1);
+}
+/**
+ * Find the closest angle between to angles
+ *
+ * @param {number} source Source angle in radians
+ * @param {number} target Target angle in radians
+ * @returns {number} Closest angle
+ */
+export function closestAngle(source, target) {
+    var delta = target - source;
+    return delta > PI ? target - 2 * PI : target < -PI ? delta + 2 * PI : target;
+}
+/**
+ * Calculate the distance between two points
+ *
+ * @param {number} x1 X coord of the first point
+ * @param {number} y1 Y coord of the first point
+ * @param {number} x2 X coord of the second point
+ * @param {number} y2 Y coord of the second point
+ * @returns {number} Computed distance
+ */
+export function distance(x1, y1, x2, y2) {
+    var dx = x1 - x2;
+    var dy = y1 - y2;
+    return Math.sqrt(dx * dx + dy * dy);
+}
+/**
+ * Calculate the length of the diagonal of a rectangle
+ *
+ * @param {number} width  Width of the rectangle
+ * @param {number} height Height of the rectangle
+ * @returns {number} Diagonal length
+ */
+export function diagonal(width, height) {
+    return Math.sqrt(width * width + height * height);
+}
+/**
+ * Convert radians to a 3D point on the surface of a unit sphere
+ *
+ * @param  {number} radius  Radius of the sphere
+ * @param  {number} phi     Polar angle from the y (up) axis     : [0, PI]
+ * @param  {number} theta   Equator angle around the y (up) axis : [0, 2*PI]
+ * @param  {Vector3} target Target vector
+ * @returns {Vector3}
+ */
+export 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;
+}
+/**
+ * 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}
+ */
+function fit(target, container, mode) {
+    var ratioWidth = container.width / target.width;
+    var ratioHeight = container.height / target.height;
+    var scale;
+    if (mode === 'contain') {
+        scale = ratioWidth < ratioHeight ? ratioWidth : ratioHeight;
+    }
+    else {
+        scale = ratioWidth > ratioHeight ? ratioWidth : ratioHeight;
+    }
+    return {
+        left: (container.width - target.width * scale) >> 1,
+        top: (container.height - target.height * scale) >> 1,
+        width: target.width * scale,
+        height: target.height * 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}
+ */
+export function cover(target, container) {
+    return fit(target, container, '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}
+ */
+export function contain(target, container) {
+    return fit(target, container, 'contain');
+}

package/lib/maths.d.ts

@@ -0,0 +1,161 @@
+/**
+ * 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;