toosoon-utils 2.4.2 → 3.0.1

package/README.md

@@ -221,7 +221,7 @@ Find the closest parent that matches a selector.
 - `selector`: Selector or parent to match.
 
 ```ts
-closest(element: Element, selector: Element | string): Element | null;
+closest(element: Element | null, selector: Element | string): Element | null;
 ```
 
 ##### createCanvas(width, height)

package/lib/classes/_pool.js

@@ -1,7 +1,30 @@
+"use strict";
 // *********************
 // WIP
 // *********************
-export const defaultSettings = {
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultSettings = void 0;
+exports.defaultSettings = {
     max: Infinity
 };
 /**
@@ -10,11 +33,12 @@ export const defaultSettings = {
  * @exports
  * @class Pool
  */
-export default class Pool {
-    items = [];
-    pool = [];
-    settings = { ...defaultSettings };
-    constructor(settings = { ...defaultSettings }) {
+var Pool = /** @class */ (function () {
+    function Pool(settings) {
+        if (settings === void 0) { settings = __assign({}, exports.defaultSettings); }
+        this.items = [];
+        this.pool = [];
+        this.settings = __assign({}, exports.defaultSettings);
         this.settings = Object.assign(this.settings, settings);
     }
     /**
@@ -22,46 +46,50 @@ export default class Pool {
      *
      * @param {PoolItem} item Item to add to the active items
      */
-    add(item) {
+    Pool.prototype.add = function (item) {
         this.items.push(item);
-    }
+    };
     /**
      * Remove an item from the active items
      *
      * @param {PoolItem} item Item to remove from the active items
      */
-    remove(item) {
-        this.items = this.items.filter((_item) => _item !== item);
-    }
+    Pool.prototype.remove = function (item) {
+        this.items = this.items.filter(function (_item) { return _item !== item; });
+    };
     /**
      * Return an item from pool or create a new one
      *
      * @returns {PoolItem|undefined}
      */
-    get() {
+    Pool.prototype.get = function () {
+        var _a, _b;
         if (this.items.length >= this.settings.max)
             return;
-        const item = this.pool.pop() ?? this.create();
-        item.setup?.();
+        var item = (_a = this.pool.pop()) !== null && _a !== void 0 ? _a : this.create();
+        (_b = item.setup) === null || _b === void 0 ? void 0 : _b.call(item);
         this.add(item);
         return item;
-    }
+    };
     /**
      * Release an item from the active items and add it to the pool
      *
      * @param {PoolItem} item Item to release
      */
-    release(item) {
+    Pool.prototype.release = function (item) {
+        var _a;
         this.pool.push(item);
-        item.reset?.();
+        (_a = item.reset) === null || _a === void 0 ? void 0 : _a.call(item);
         this.remove(item);
-    }
+    };
     /**
      * Dispose all items
      */
-    dispose() {
-        [...this.items, ...this.pool].forEach((item) => item.dispose?.());
+    Pool.prototype.dispose = function () {
+        __spreadArray(__spreadArray([], this.items, true), this.pool, true).forEach(function (item) { var _a; return (_a = item.dispose) === null || _a === void 0 ? void 0 : _a.call(item); });
         this.items = [];
         this.pool = [];
-    }
-}
+    };
+    return Pool;
+}());
+exports.default = Pool;

package/lib/classes/color-scale.js

@@ -1,6 +1,20 @@
-import { lerp, triLerp } from '../maths';
-import { hclToRgb, hsbToRgb, hslToRgb, normalizeColor, rgbToHcl, rgbToHsb, rgbToHsl } from '../colors';
-export const defaultSettings = {
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultSettings = void 0;
+var maths_1 = require("../maths");
+var colors_1 = require("../colors");
+exports.defaultSettings = {
     colorSpace: 'rgb'
 };
 /**
@@ -9,18 +23,20 @@ export const defaultSettings = {
  * @exports
  * @class ColorScale
  */
-export default class ColorScale {
-    /**
-     * Array of colors composing the color scale
-     */
-    colors = [];
+var ColorScale = /** @class */ (function () {
     /**
      * @param {ColorRepresentation} input     Input color representation
      * @param {ColorRepresentation} target    Target color representation
      * @param {number} [length=5]             Amount of colors composing the color scale
      * @param {ColorScaleSettings} [settings] Color scale generation settings
      */
-    constructor(input, target, length = 5, settings = { ...defaultSettings }) {
+    function ColorScale(input, target, length, settings) {
+        if (length === void 0) { length = 5; }
+        if (settings === void 0) { settings = __assign({}, exports.defaultSettings); }
+        /**
+         * Array of colors composing the color scale
+         */
+        this.colors = [];
         this.colors = ColorScale.generate(input, target, length, settings);
     }
     /**
@@ -32,16 +48,17 @@ export default class ColorScale {
      * @param {ColorScaleSettings} [settings] Color scale generation settings
      * @returns {Array<[number, number, number]>} Color scale colors
      */
-    static generate(input, target, length, settings = { ...defaultSettings }) {
-        const colors = [];
-        const inputColor = normalizeColor(input);
-        const targetColor = normalizeColor(target);
-        for (let i = 0; i < length; i++) {
-            const value = i / Math.floor(length);
+    ColorScale.generate = function (input, target, length, settings) {
+        if (settings === void 0) { settings = __assign({}, exports.defaultSettings); }
+        var colors = [];
+        var inputColor = (0, colors_1.normalizeColor)(input);
+        var targetColor = (0, colors_1.normalizeColor)(target);
+        for (var i = 0; i < length; i++) {
+            var value = i / Math.floor(length);
             colors.push(ColorScale.interpolate(inputColor, targetColor, value, settings));
         }
         return colors;
-    }
+    };
     /**
      * Static method for interpolating between colors
      *
@@ -51,41 +68,43 @@ export default class ColorScale {
      * @param {ColorScaleSettings} [settings]      Color scale settings
      * @returns {[number,number,number]} Interpolated color
      */
-    static interpolate(inputColor, targetColor, value, settings = { ...defaultSettings }) {
+    ColorScale.interpolate = function (inputColor, targetColor, value, settings) {
+        var _a, _b, _c, _d;
+        if (settings === void 0) { settings = __assign({}, exports.defaultSettings); }
         switch (settings.colorSpace) {
             case 'rgb': {
-                const r = lerp(value, inputColor[0], targetColor[0]);
-                const g = lerp(value, inputColor[1], targetColor[1]);
-                const b = lerp(value, inputColor[2], targetColor[2]);
+                var r = (0, maths_1.lerp)(value, inputColor[0], targetColor[0]);
+                var g = (0, maths_1.lerp)(value, inputColor[1], targetColor[1]);
+                var b = (0, maths_1.lerp)(value, inputColor[2], targetColor[2]);
                 return [r, g, b];
             }
             case 'hsl': {
-                const inputHsl = rgbToHsl(inputColor);
-                const targetHsl = rgbToHsl(targetColor);
-                const h = lerp(value, inputHsl[0], targetHsl[0]);
-                const s = lerp(value, inputHsl[1], targetHsl[1]);
-                const l = lerp(value, inputHsl[2], targetHsl[2]);
-                return hslToRgb([h, s, l]);
+                var inputHsl = (0, colors_1.rgbToHsl)(inputColor);
+                var targetHsl = (0, colors_1.rgbToHsl)(targetColor);
+                var h_1 = (0, maths_1.lerp)(value, inputHsl[0], targetHsl[0]);
+                var s = (0, maths_1.lerp)(value, inputHsl[1], targetHsl[1]);
+                var l_1 = (0, maths_1.lerp)(value, inputHsl[2], targetHsl[2]);
+                return (0, colors_1.hslToRgb)([h_1, s, l_1]);
             }
             case 'hsb': {
-                const inputHsb = rgbToHsb(inputColor);
-                const targetHsb = rgbToHsb(targetColor);
-                const h = lerp(value, inputHsb[0], targetHsb[0]);
-                const s = lerp(value, inputHsb[1], targetHsb[1]);
-                const b = lerp(value, inputHsb[2], targetHsb[2]);
-                return hsbToRgb([h, s, b]);
+                var inputHsb = (0, colors_1.rgbToHsb)(inputColor);
+                var targetHsb = (0, colors_1.rgbToHsb)(targetColor);
+                var h_2 = (0, maths_1.lerp)(value, inputHsb[0], targetHsb[0]);
+                var s = (0, maths_1.lerp)(value, inputHsb[1], targetHsb[1]);
+                var b = (0, maths_1.lerp)(value, inputHsb[2], targetHsb[2]);
+                return (0, colors_1.hsbToRgb)([h_2, s, b]);
             }
             case 'hcl':
-                const inputHcl = rgbToHcl(inputColor);
-                const targetHcl = rgbToHcl(targetColor);
-                const powerValue = Math.pow(value, settings.powerStrength ?? 1);
-                const h1 = inputHcl[0];
-                const c1 = inputHcl[1];
-                const l1 = inputHcl[2];
-                const h2 = targetHcl[0] + (settings.hueOffset ?? 0);
-                const c2 = targetHcl[1] + (settings.chromaOffset ?? 0);
-                const l2 = targetHcl[2] + (settings.luminanceOffset ?? 0);
-                let h, c, l;
+                var inputHcl = (0, colors_1.rgbToHcl)(inputColor);
+                var targetHcl = (0, colors_1.rgbToHcl)(targetColor);
+                var powerValue = Math.pow(value, (_a = settings.powerStrength) !== null && _a !== void 0 ? _a : 1);
+                var h1 = inputHcl[0];
+                var c1 = inputHcl[1];
+                var l1 = inputHcl[2];
+                var h2 = targetHcl[0] + ((_b = settings.hueOffset) !== null && _b !== void 0 ? _b : 0);
+                var c2 = targetHcl[1] + ((_c = settings.chromaOffset) !== null && _c !== void 0 ? _c : 0);
+                var l2 = targetHcl[2] + ((_d = settings.luminanceOffset) !== null && _d !== void 0 ? _d : 0);
+                var h = void 0, c = void 0, l = void 0;
                 // HCL color palettes
                 // -> https://colorspace.r-forge.r-project.org/articles/hcl_palettes.html
                 if (settings.mode === 'qualitative') {
@@ -99,7 +118,7 @@ export default class ColorScale {
                      * - Chroma:    Constant
                      * - Luminance: Constant
                      */
-                    h = lerp(value, h1, h2);
+                    h = (0, maths_1.lerp)(value, h1, h2);
                     c = c1;
                     l = l1;
                 }
@@ -113,9 +132,9 @@ export default class ColorScale {
                      * - Chroma:    Linear (+power) | Triangular (+power)
                      * - Luminance: Linear (+power)
                      */
-                    h = lerp(value, h1, h2);
-                    c = settings.triangular ? triLerp(powerValue, c1, c2, settings.triangular) : lerp(powerValue, c1, c2);
-                    l = lerp(powerValue, l1, l2);
+                    h = (0, maths_1.lerp)(value, h1, h2);
+                    c = settings.triangular ? (0, maths_1.triLerp)(powerValue, c1, c2, settings.triangular) : (0, maths_1.lerp)(powerValue, c1, c2);
+                    l = (0, maths_1.lerp)(powerValue, l1, l2);
                 }
                 else if (settings.mode === 'diverging') {
                     /**
@@ -127,16 +146,18 @@ export default class ColorScale {
                      * - Chroma:    Linear (+power) | Triangular (+power)
                      * - Luminance: Linear (+power)
                      */
-                    h = value < 0.5 ? h1 : value > 0.5 ? h2 : lerp(0.5, h1, h2);
-                    c = settings.triangular ? triLerp(powerValue, c1, c2, settings.triangular) : lerp(powerValue, c1, c2);
-                    l = lerp(powerValue, l1, l2);
+                    h = value < 0.5 ? h1 : value > 0.5 ? h2 : (0, maths_1.lerp)(0.5, h1, h2);
+                    c = settings.triangular ? (0, maths_1.triLerp)(powerValue, c1, c2, settings.triangular) : (0, maths_1.lerp)(powerValue, c1, c2);
+                    l = (0, maths_1.lerp)(powerValue, l1, l2);
                 }
                 else {
-                    h = lerp(value, h1, h2);
-                    c = lerp(value, c1, c2);
-                    l = lerp(value, l1, l2);
+                    h = (0, maths_1.lerp)(value, h1, h2);
+                    c = (0, maths_1.lerp)(value, c1, c2);
+                    l = (0, maths_1.lerp)(value, l1, l2);
                 }
-                return hclToRgb([h, c, l]);
+                return (0, colors_1.hclToRgb)([h, c, l]);
         }
-    }
-}
+    };
+    return ColorScale;
+}());
+exports.default = ColorScale;

package/lib/classes/frame-rate.js

@@ -1,20 +1,22 @@
-import { now } from '../functions';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var functions_1 = require("../functions");
 /**
  * Utility class for controlling FPS calls
  *
  * @exports
  * @class FrameRate
  */
-export default class FrameRate {
-    _fps;
-    interval = 0;
-    time = 0;
-    elapsedTime = 0;
-    lastUpdate = 0;
+var FrameRate = /** @class */ (function () {
     /**
      * @param {number} [fps=30] Frame per second limit
      */
-    constructor(fps = 30) {
+    function FrameRate(fps) {
+        if (fps === void 0) { fps = 30; }
+        this.interval = 0;
+        this.time = 0;
+        this.elapsedTime = 0;
+        this.lastUpdate = 0;
         this._fps = fps;
         this.fps = fps;
     }
@@ -23,20 +25,26 @@ export default class FrameRate {
      *
      * @returns {boolean}
      */
-    update() {
-        this.time = now();
+    FrameRate.prototype.update = function () {
+        this.time = (0, functions_1.now)();
         this.elapsedTime = this.time - this.lastUpdate;
         if (this.elapsedTime < this.interval) {
             return false;
         }
         this.lastUpdate = this.time - (this.elapsedTime % this.interval);
         return true;
-    }
-    get fps() {
-        return this._fps;
-    }
-    set fps(fps) {
-        this._fps = fps;
-        this.interval = 1000 / fps;
-    }
-}
+    };
+    Object.defineProperty(FrameRate.prototype, "fps", {
+        get: function () {
+            return this._fps;
+        },
+        set: function (fps) {
+            this._fps = fps;
+            this.interval = 1000 / fps;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return FrameRate;
+}());
+exports.default = FrameRate;