toosoon-utils 1.4.0 → 2.0.0

package/README.md

@@ -687,104 +687,108 @@ xoshiro128ss(a: number, b: number, c: number, d: number): number;
 
 #### PRNG functions
 
-Thanks to the above algorithms, a seed-based version of most of the [random functions](#random) are available with a `seed` string and a PRNG `algorithm` function additionnal parameters.
+Thanks to the above algorithms, a seed-based version of most of the [random functions](#random) are exist with additionnal parameters for a `seed` string and a PRNG `algorithm` function.
 
-##### random(seed)
+PRNG parameters:
 
-Generate a pseudo-random number in the interval [0, 1]. It's the PRNG equivalent of `Math.random()`.
+```ts
+type PRNGParameters = string | { seed: string; algorithm: (...args: number[]) => number };
+```
+
+##### random(prng)
+
+Generate a pseudo-random number in the interval [0, 1]. It is the PRNG equivalent of `Math.random()`.
 
-- `prng`: Can be a seed string or a PRNG parameters object containing the seed and a PRNG algorithm function.
-  - `[prng.seed]`: Seed used for pseudo-random number generation.
-  - `[prng.algorithm=splitmix32]`: PRNG algorithm function generating a pseudo-random number.
+- `prng`: PRNG parameters.
 
 ```ts
-random(prng: string | object): number;
+random(prng: PRNGParameters): number;
 ```
 
 ##### randomBoolean(prng)
 
 Generate a pseudo-random boolean (true or false).
 
-- `prng`
+- `prng`: PRNG parameters.
 - `[probability=0.5]`: Probability to get true.
 
 ```ts
-randomBoolean(prng: string | object, probability?: number): boolean;
+randomBoolean(prng: PRNGParameters, probability?: number): boolean;
 ```
 
 ##### randomSign(prng)
 
 Generate a pseudo-random sign (1 or -1).
 
-- `prng`
+- `prng`: PRNG parameters.
 - `[probability=0.5]`: Probability to get 1.
 
 ```ts
-randomSign(prng: string | object, probability?: number): number;
+randomSign(prng: PRNGParameters, probability?: number): number;
 ```
 
 ##### randomFloat(prng, min, max)
 
 Generate a pseudo-random floating-point number within a specified range.
 
-- `prng`
+- `prng`: PRNG parameters.
 - `[min=0]`: Minimum boundary.
 - `[max=1]`: Maximum boundary.
 - `[precision=2]`: Number of digits after the decimal point.
 
 ```ts
-randomFloat(prng: string | object, min?: number, max?: number, precision?: number): number;
+randomFloat(prng: PRNGParameters, min?: number, max?: number, precision?: number): number;
 ```
 
 ##### randomInt(prng, min, max)
 
 Generate a pseudo-random integer number within a specified range.
 
-- `prng`
+- `prng`: PRNG parameters.
 - `min`: Minimum boundary.
 - `max`: Maximum boundary.
 
 ```ts
-randomInt(prng: string | object, min: number, max: number): number;
+randomInt(prng: PRNGParameters, min: number, max: number): number;
 ```
 
 ##### randomHexColor(prng)
 
 Generate a pseudo-random hexadecimal color.
 
-- `prng`
+- `prng`: PRNG parameters.
 
 ```ts
-randomHexColor(prng: string | object): string;
+randomHexColor(prng: PRNGParameters): string;
 ```
 
 ##### randomItem(prng, array)
 
 Pick a pseudo-random item from a given array.
 
-- `prng`
+- `prng`: PRNG parameters.
 - `array`: Array to pick the item from.
 
 ```ts
-randomItem<T>(prng: string | object, array: T[]): T | undefined;
+randomItem<T>(prng: PRNGParameters, array: T[]): T | undefined;
 ```
 
 ##### randomObjectProperty(prng)
 
 Pick a pseudo-random property value from a given object.
 
-- `prng`
+- `prng`: PRNG parameters.
 - `object`: Object to pick the property from.
 
 ```ts
-randomObjectProperty<T>(prng: string | object, object: Record<string, T>): T | undefined;
+randomObjectProperty<T>(prng: PRNGParameters, object: Record<string, T>): T | undefined;
 ```
 
 ##### randomIndex(prng)
 
 Select a pseudo-random index from an array of weighted items.
 
-- `prng`
+- `prng`: PRNG parameters.
 - `weights`: Array of weights.
 
 ```ts
@@ -1074,4 +1078,4 @@ FrameRate.update(): boolean;
 
 ## License
 
-MIT License, see [LICENSE](https://github.com/toosoon-dev/toosoon-utils/tree/master/LICENSE) for details
+MIT License, see [LICENSE](https://github.com/toosoon-dev/toosoon-utils/tree/master/LICENSE) for details.

package/package.json

@@ -1,8 +1,13 @@
 {
   "name": "toosoon-utils",
-  "version": "1.4.0",
+  "version": "2.0.0",
   "description": "Utility functions & classes",
+  "type": "module",
+  "engines": {
+    "node": ">=16"
+  },
   "main": "",
+  "types": "./lib/types.d.ts",
   "exports": {
     "./colors": "./lib/colors.js",
     "./dom": "./lib/dom.js",
@@ -15,8 +20,7 @@
     "./strings": "./lib/strings.js",
     "./constants": "./lib/constants.js",
     "./color-scale": "./lib/classes/color-scale.js",
-    "./frame-rate": "./lib/classes/frame-rate.js",
-    "./types": "./lib/types.d.ts"
+    "./frame-rate": "./lib/classes/frame-rate.js"
   },
   "scripts": {
     "build": "npx tsc",
@@ -27,7 +31,7 @@
     "url": "git+https://github.com/toosoon-dev/toosoon-utils.git"
   },
   "keywords": [
-    "tooson",
+    "toosoon",
     "utils",
     "colors",
     "dom",

package/tsconfig.json

@@ -9,10 +9,8 @@
     "moduleResolution": "Bundler",
     "lib": ["DOM", "ESNext"],
     "allowJs": true,
-    "allowSyntheticDefaultImports": true,
+    "checkJs": true,
     "declaration": true,
-    "esModuleInterop": true,
-    "experimentalDecorators": true,
     "forceConsistentCasingInFileNames": true,
     "isolatedModules": true,
     "incremental": true,

package/lib/classes/_pool.d.ts

@@ -1,56 +0,0 @@
-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

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

@@ -1,52 +0,0 @@
-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

@@ -1,160 +0,0 @@
-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

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

@@ -1,48 +0,0 @@
-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;