toosoon-utils 4.0.0 → 4.0.2

package/lib/classes/_pool.d.ts

@@ -2,11 +2,11 @@ export type PoolSettings = {
     max?: number;
 };
 export declare const defaultSettings: Required<PoolSettings>;
-interface PoolItem {
+type PoolItem = {
     setup?: () => void;
     reset?: () => void;
     dispose?: () => void;
-}
+};
 /**
  * Abstract class for manipulating pool items
  *

package/lib/classes/_pool.js

@@ -1,27 +1,7 @@
 // *********************
 // WIP
 // *********************
-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));
-};
-export var defaultSettings = {
+export const defaultSettings = {
     max: Infinity
 };
 /**
@@ -30,12 +10,11 @@ export var defaultSettings = {
  * @exports
  * @class Pool
  */
-var Pool = /** @class */ (function () {
-    function Pool(settings) {
-        if (settings === void 0) { settings = __assign({}, defaultSettings); }
-        this.items = [];
-        this.pool = [];
-        this.settings = __assign({}, defaultSettings);
+export default class Pool {
+    items = [];
+    pool = [];
+    settings = { ...defaultSettings };
+    constructor(settings = { ...defaultSettings }) {
         this.settings = Object.assign(this.settings, settings);
     }
     /**
@@ -43,50 +22,46 @@ var Pool = /** @class */ (function () {
      *
      * @param {PoolItem} item Item to add to the active items
      */
-    Pool.prototype.add = function (item) {
+    add(item) {
         this.items.push(item);
-    };
+    }
     /**
      * Remove an item from the active items
      *
      * @param {PoolItem} item Item to remove from the active items
      */
-    Pool.prototype.remove = function (item) {
-        this.items = this.items.filter(function (_item) { return _item !== item; });
-    };
+    remove(item) {
+        this.items = this.items.filter((_item) => _item !== item);
+    }
     /**
      * Return an item from pool or create a new one
      *
      * @returns {PoolItem|undefined}
      */
-    Pool.prototype.get = function () {
-        var _a, _b;
+    get() {
         if (this.items.length >= this.settings.max)
             return;
-        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);
+        const item = this.pool.pop() ?? this.create();
+        item.setup?.();
         this.add(item);
         return item;
-    };
+    }
     /**
      * Release an item from the active items and add it to the pool
      *
      * @param {PoolItem} item Item to release
      */
-    Pool.prototype.release = function (item) {
-        var _a;
+    release(item) {
         this.pool.push(item);
-        (_a = item.reset) === null || _a === void 0 ? void 0 : _a.call(item);
+        item.reset?.();
         this.remove(item);
-    };
+    }
     /**
      * Dispose all items
      */
-    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); });
+    dispose() {
+        [...this.items, ...this.pool].forEach((item) => item.dispose?.());
         this.items = [];
         this.pool = [];
-    };
-    return Pool;
-}());
-export default Pool;
+    }
+}

package/lib/classes/color-scale.js

@@ -1,17 +1,6 @@
-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);
-};
 import { lerp, triLerp } from '../maths';
 import { hclToRgb, hsbToRgb, hslToRgb, normalizeColor, rgbToHcl, rgbToHsb, rgbToHsl } from '../colors';
-export var defaultSettings = {
+export const defaultSettings = {
     colorSpace: 'rgb'
 };
 /**
@@ -20,20 +9,18 @@ export var defaultSettings = {
  * @exports
  * @class ColorScale
  */
-var ColorScale = /** @class */ (function () {
+export default class ColorScale {
+    /**
+     * Array of colors composing the color scale
+     */
+    colors = [];
     /**
      * @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
      */
-    function ColorScale(input, target, length, settings) {
-        if (length === void 0) { length = 5; }
-        if (settings === void 0) { settings = __assign({}, defaultSettings); }
-        /**
-         * Array of colors composing the color scale
-         */
-        this.colors = [];
+    constructor(input, target, length = 5, settings = { ...defaultSettings }) {
         this.colors = ColorScale.generate(input, target, length, settings);
     }
     /**
@@ -45,17 +32,16 @@ var ColorScale = /** @class */ (function () {
      * @param {ColorScaleSettings} [settings] Color scale generation settings
      * @returns {Array<[number, number, number]>} Color scale colors
      */
-    ColorScale.generate = function (input, target, length, settings) {
-        if (settings === void 0) { settings = __assign({}, defaultSettings); }
-        var colors = [];
-        var inputColor = normalizeColor(input);
-        var targetColor = normalizeColor(target);
-        for (var i = 0; i < length; i++) {
-            var value = i / Math.floor(length);
+    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);
             colors.push(ColorScale.interpolate(inputColor, targetColor, value, settings));
         }
         return colors;
-    };
+    }
     /**
      * Static method for interpolating between colors
      *
@@ -65,55 +51,53 @@ var ColorScale = /** @class */ (function () {
      * @param {ColorScaleSettings} [settings]      Color scale settings
      * @returns {[number,number,number]} Interpolated color
      */
-    ColorScale.interpolate = function (inputColor, targetColor, value, settings) {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
-        if (settings === void 0) { settings = __assign({}, defaultSettings); }
+    static interpolate(inputColor, targetColor, value, settings = { ...defaultSettings }) {
         switch (settings.colorSpace) {
             case 'rgb': {
-                var r = lerp(value, inputColor[0], targetColor[0]);
-                var g = lerp(value, inputColor[1], targetColor[1]);
-                var b = lerp(value, inputColor[2], targetColor[2]);
+                const r = lerp(value, inputColor[0], targetColor[0]);
+                const g = lerp(value, inputColor[1], targetColor[1]);
+                const b = lerp(value, inputColor[2], targetColor[2]);
                 return [r, g, b];
             }
             case 'hsl': {
-                var inputHsl = rgbToHsl(inputColor);
-                var targetHsl = rgbToHsl(targetColor);
-                var h1_1 = inputHsl[0];
-                var s1 = inputHsl[1];
-                var l1_1 = inputHsl[2];
-                var h2_1 = targetHsl[0] + ((_a = settings.hueOffset) !== null && _a !== void 0 ? _a : 0);
-                var s2 = targetHsl[1] + ((_b = settings.saturationOffset) !== null && _b !== void 0 ? _b : 0);
-                var l2_1 = targetHsl[2] + ((_c = settings.lightnessOffset) !== null && _c !== void 0 ? _c : 0);
-                var h_1 = lerp(value, h1_1, h2_1);
-                var s = lerp(value, s1, s2);
-                var l_1 = lerp(value, l1_1, l2_1);
-                return hslToRgb([h_1, s, l_1]);
+                const inputHsl = rgbToHsl(inputColor);
+                const targetHsl = rgbToHsl(targetColor);
+                const h1 = inputHsl[0];
+                const s1 = inputHsl[1];
+                const l1 = inputHsl[2];
+                const h2 = targetHsl[0] + (settings.hueOffset ?? 0);
+                const s2 = targetHsl[1] + (settings.saturationOffset ?? 0);
+                const l2 = targetHsl[2] + (settings.lightnessOffset ?? 0);
+                const h = lerp(value, h1, h2);
+                const s = lerp(value, s1, s2);
+                const l = lerp(value, l1, l2);
+                return hslToRgb([h, s, l]);
             }
             case 'hsb': {
-                var inputHsb = rgbToHsb(inputColor);
-                var targetHsb = rgbToHsb(targetColor);
-                var h1_2 = inputHsb[0];
-                var s1 = inputHsb[1];
-                var b1 = inputHsb[2];
-                var h2_2 = targetHsb[0] + ((_d = settings.hueOffset) !== null && _d !== void 0 ? _d : 0);
-                var s2 = targetHsb[1] + ((_e = settings.saturationOffset) !== null && _e !== void 0 ? _e : 0);
-                var b2 = targetHsb[2] + ((_f = settings.brightnessOffset) !== null && _f !== void 0 ? _f : 0);
-                var h_2 = lerp(value, h1_2, h2_2);
-                var s = lerp(value, s1, s2);
-                var b = lerp(value, b1, b2);
-                return hsbToRgb([h_2, s, b]);
+                const inputHsb = rgbToHsb(inputColor);
+                const targetHsb = rgbToHsb(targetColor);
+                const h1 = inputHsb[0];
+                const s1 = inputHsb[1];
+                const b1 = inputHsb[2];
+                const h2 = targetHsb[0] + (settings.hueOffset ?? 0);
+                const s2 = targetHsb[1] + (settings.saturationOffset ?? 0);
+                const b2 = targetHsb[2] + (settings.brightnessOffset ?? 0);
+                const h = lerp(value, h1, h2);
+                const s = lerp(value, s1, s2);
+                const b = lerp(value, b1, b2);
+                return hsbToRgb([h, s, b]);
             }
             case 'hcl':
-                var inputHcl = rgbToHcl(inputColor);
-                var targetHcl = rgbToHcl(targetColor);
-                var powerValue = Math.pow(value, (_g = settings.powerStrength) !== null && _g !== void 0 ? _g : 1);
-                var h1 = inputHcl[0];
-                var c1 = inputHcl[1];
-                var l1 = inputHcl[2];
-                var h2 = targetHcl[0] + ((_h = settings.hueOffset) !== null && _h !== void 0 ? _h : 0);
-                var c2 = targetHcl[1] + ((_j = settings.chromaOffset) !== null && _j !== void 0 ? _j : 0);
-                var l2 = targetHcl[2] + ((_k = settings.luminanceOffset) !== null && _k !== void 0 ? _k : 0);
-                var h = void 0, c = void 0, l = void 0;
+                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;
                 // HCL color palettes
                 // -> https://colorspace.r-forge.r-project.org/articles/hcl_palettes.html
                 switch (settings.mode) {
@@ -168,7 +152,5 @@ var ColorScale = /** @class */ (function () {
                 }
                 return hclToRgb([h, c, l]);
         }
-    };
-    return ColorScale;
-}());
-export default ColorScale;
+    }
+}

package/lib/classes/frame-rate.js

@@ -5,16 +5,16 @@ import { now } from '../functions';
  * @exports
  * @class FrameRate
  */
-var FrameRate = /** @class */ (function () {
+export default class FrameRate {
+    _fps;
+    _interval = 0;
+    _time = 0;
+    _elapsedTime = 0;
+    _lastUpdate = 0;
     /**
      * @param {number} [fps=30] Frame per second limit
      */
-    function FrameRate(fps) {
-        if (fps === void 0) { fps = 30; }
-        this._interval = 0;
-        this._time = 0;
-        this._elapsedTime = 0;
-        this._lastUpdate = 0;
+    constructor(fps = 30) {
         this.fps = fps;
     }
     /**
@@ -22,7 +22,7 @@ var FrameRate = /** @class */ (function () {
      *
      * @returns {boolean}
      */
-    FrameRate.prototype.update = function () {
+    update() {
         this._time = now();
         this._elapsedTime = this._time - this._lastUpdate;
         if (this._elapsedTime < this._interval) {
@@ -30,18 +30,12 @@ var FrameRate = /** @class */ (function () {
         }
         this._lastUpdate = this._time - (this._elapsedTime % this._interval);
         return true;
-    };
-    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;
-}());
-export default FrameRate;
+    }
+    get fps() {
+        return this._fps;
+    }
+    set fps(fps) {
+        this._fps = fps;
+        this._interval = 1000 / fps;
+    }
+}