toosoon-utils 1.1.0 → 1.2.0

package/lib/classes/_pool.d.ts

@@ -0,0 +1,56 @@
+export type PoolSettings = {
+    max?: number;
+};
+export declare const defaultSettings: Required<PoolSettings>;
+interface PoolItem {
+    setup?: () => void;
+    reset?: () => void;
+    dispose?: () => void;
+}
+/**
+ * Abstract class for manipulating pool items
+ *
+ * @exports
+ * @class Pool
+ */
+export default abstract class Pool<I extends PoolItem> {
+    items: I[];
+    pool: I[];
+    settings: Required<PoolSettings>;
+    constructor(settings?: PoolSettings);
+    /**
+     * Abstract method to implement custom item creation
+     *
+     * @returns {PoolItem}
+     */
+    protected abstract create(): I;
+    /**
+     * Add an item to the active items
+     *
+     * @param {PoolItem} item Item to add to the active items
+     */
+    protected add(item: I): void;
+    /**
+     * Remove an item from the active items
+     *
+     * @param {PoolItem} item Item to remove from the active items
+     */
+    protected remove(item: I): void;
+    /**
+     * Return an item from pool or create a new one
+     *
+     * @returns {PoolItem|undefined}
+     */
+    get(): I | undefined;
+    /**
+     * Release an item from the active items and add it to the pool
+     *
+     * @param {PoolItem} item Item to release
+     */
+    release(item: I): void;
+    /**
+     * Dispose all items
+     */
+    dispose(): void;
+}
+export {};

package/lib/classes/_pool.js

@@ -0,0 +1,92 @@
+// *********************
+// 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 = {
+    max: Infinity
+};
+/**
+ * Abstract class for manipulating pool items
+ *
+ * @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);
+        this.settings = Object.assign(this.settings, settings);
+    }
+    /**
+     * Add an item to the active items
+     *
+     * @param {PoolItem} item Item to add to the active items
+     */
+    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
+     */
+    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}
+     */
+    Pool.prototype.get = function () {
+        var _a, _b;
+        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);
+        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;
+        this.pool.push(item);
+        (_a = item.reset) === null || _a === void 0 ? void 0 : _a.call(item);
+        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); });
+        this.items = [];
+        this.pool = [];
+    };
+    return Pool;
+}());
+export default Pool;

package/lib/classes/color-scale.d.ts

@@ -0,0 +1,52 @@
+import { ColorRepresentation } from '../types';
+export type ColorScaleSettings = {
+    colorSpace: 'rgb' | 'hsl' | 'hsb';
+} | {
+    colorSpace: 'hcl';
+    mode?: 'qualitative' | 'sequential' | 'diverging';
+    triangular?: number;
+    powerStrength?: number;
+    hueOffset?: number;
+    chromaOffset?: number;
+    luminanceOffset?: number;
+};
+export declare const defaultSettings: Required<ColorScaleSettings>;
+/**
+ * Utility class for generating color scales and interpolating between colors
+ *
+ * @exports
+ * @class ColorScale
+ */
+export default class ColorScale {
+    /**
+     * Array of colors composing the color scale
+     */
+    colors: Array<[number, number, number]>;
+    /**
+     * @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: ColorRepresentation, target: ColorRepresentation, length?: number, settings?: ColorScaleSettings);
+    /**
+     * Static method for generating a color scale
+     *
+     * @param {ColorRepresentation} input     Input color representation
+     * @param {ColorRepresentation} target    Target color representation
+     * @param {number} length                 Amount of colors composing the color scale
+     * @param {ColorScaleSettings} [settings] Color scale generation settings
+     * @returns {Array<[number, number, number]>} Color scale colors
+     */
+    static generate(input: ColorRepresentation, target: ColorRepresentation, length: number, settings?: ColorScaleSettings): Array<[number, number, number]>;
+    /**
+     * Static method for interpolating between colors
+     *
+     * @param {[number,number,number]} inputColor  Input color
+     * @param {[number,number,number]} targetColor Target color
+     * @param {number} value                       Interpolation normalized value
+     * @param {ColorScaleSettings} [settings]      Color scale settings
+     * @returns {[number,number,number]} Interpolated color
+     */
+    static interpolate(inputColor: [number, number, number], targetColor: [number, number, number], value: number, settings?: ColorScaleSettings): [number, number, number];
+}

package/lib/classes/color-scale.js

@@ -0,0 +1,160 @@
+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 = {
+    colorSpace: 'rgb'
+};
+/**
+ * Utility class for generating color scales and interpolating between colors
+ *
+ * @exports
+ * @class ColorScale
+ */
+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
+     */
+    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 = [];
+        this.colors = ColorScale.generate(input, target, length, settings);
+    }
+    /**
+     * Static method for generating a color scale
+     *
+     * @param {ColorRepresentation} input     Input color representation
+     * @param {ColorRepresentation} target    Target color representation
+     * @param {number} length                 Amount of colors composing the color scale
+     * @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);
+            colors.push(ColorScale.interpolate(inputColor, targetColor, value, settings));
+        }
+        return colors;
+    };
+    /**
+     * Static method for interpolating between colors
+     *
+     * @param {[number,number,number]} inputColor  Input color
+     * @param {[number,number,number]} targetColor Target color
+     * @param {number} value                       Interpolation normalized value
+     * @param {ColorScaleSettings} [settings]      Color scale settings
+     * @returns {[number,number,number]} Interpolated color
+     */
+    ColorScale.interpolate = function (inputColor, targetColor, value, settings) {
+        var _a, _b, _c, _d;
+        if (settings === void 0) { settings = __assign({}, 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]);
+                return [r, g, b];
+            }
+            case 'hsl': {
+                var inputHsl = rgbToHsl(inputColor);
+                var targetHsl = rgbToHsl(targetColor);
+                var h_1 = lerp(value, inputHsl[0], targetHsl[0]);
+                var s = lerp(value, inputHsl[1], targetHsl[1]);
+                var l_1 = lerp(value, inputHsl[2], targetHsl[2]);
+                return hslToRgb([h_1, s, l_1]);
+            }
+            case 'hsb': {
+                var inputHsb = rgbToHsb(inputColor);
+                var targetHsb = rgbToHsb(targetColor);
+                var h_2 = lerp(value, inputHsb[0], targetHsb[0]);
+                var s = lerp(value, inputHsb[1], targetHsb[1]);
+                var b = lerp(value, inputHsb[2], targetHsb[2]);
+                return hsbToRgb([h_2, s, b]);
+            }
+            case 'hcl':
+                var inputHcl = rgbToHcl(inputColor);
+                var targetHcl = 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') {
+                    /**
+                     * Qualitative
+                     *    Designed for coding categorical information,
+                     *    where no particular ordering of categories is available
+                     *    and every color should receive the same perceptual weight.
+                     *
+                     * - Hue:       Linear
+                     * - Chroma:    Constant
+                     * - Luminance: Constant
+                     */
+                    h = lerp(value, h1, h2);
+                    c = c1;
+                    l = l1;
+                }
+                else if (settings.mode === 'sequential') {
+                    /**
+                     * Sequential
+                     *    Designed for coding ordered/numeric information,
+                     *    going from high to low (or vice versa).
+                     *
+                     * - Hue:       Constant | Linear
+                     * - 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);
+                }
+                else if (settings.mode === 'diverging') {
+                    /**
+                     * Diverging
+                     *    Designed for coding ordered/numeric information around a central neutral value,
+                     *    where colors diverge from neutral to two extremes.
+                     *
+                     * - Hue:       Constants (x2)
+                     * - 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);
+                }
+                else {
+                    h = lerp(value, h1, h2);
+                    c = lerp(value, c1, c2);
+                    l = lerp(value, l1, l2);
+                }
+                return hclToRgb([h, c, l]);
+        }
+    };
+    return ColorScale;
+}());
+export default ColorScale;

package/lib/classes/frame-rate.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Utility class for controlling FPS calls
+ *
+ * @exports
+ * @class FrameRate
+ */
+export default class FrameRate {
+    private _fps;
+    private interval;
+    private time;
+    private elapsedTime;
+    private lastUpdate;
+    /**
+     * @param {number} [fps=30] Frame per second limit
+     */
+    constructor(fps?: number);
+    /**
+     * Return true if elapsed time since last update is higher than current FPS
+     *
+     * @returns {boolean}
+     */
+    update(): boolean;
+    get fps(): number;
+    set fps(fps: number);
+}

package/lib/classes/frame-rate.js

@@ -0,0 +1,48 @@
+import { now } from '../functions';
+/**
+ * Utility class for controlling FPS calls
+ *
+ * @exports
+ * @class FrameRate
+ */
+var FrameRate = /** @class */ (function () {
+    /**
+     * @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;
+        this._fps = fps;
+        this.fps = fps;
+    }
+    /**
+     * Return true if elapsed time since last update is higher than current FPS
+     *
+     * @returns {boolean}
+     */
+    FrameRate.prototype.update = function () {
+        this.time = now();
+        this.elapsedTime = this.time - this.lastUpdate;
+        if (this.elapsedTime < this.interval) {
+            return false;
+        }
+        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;

package/lib/colors.d.ts

@@ -1,7 +1,15 @@
+import { ColorRepresentation } from './types';
+/**
+ * Normalize a color representation into RGB
+ *
+ * @param {ColorRepresentation} color Color representation
+ * @returns {[number,number,number]} Normalized RGB color
+ */
+export declare function normalizeColor(color: ColorRepresentation): [number, number, number];
 /**
  * Normalize an hexadecimal string
  *
- * @param  {string} hex Hexadecimal string
+ * @param {string} hex Hexadecimal string
  * @returns {string} Normalized hexadecimal string
  */
 export declare function normalizeHexString(hex: string): string;