toosoon-utils 4.2.3 → 4.3.1

package/lib/extras/colors/ColorScale.js

@@ -0,0 +1,347 @@
+import { clamp, lerp } from '../../maths';
+import Color from './Color';
+/**
+ * Utility class for generating and processing color scales
+ *
+ * @exports
+ * @class ColorScale
+ */
+export default class ColorScale {
+    isColorScale = true;
+    type = 'ColorScale';
+    /**
+     * Array of colors composing this color scale
+     */
+    colors = [];
+    *[Symbol.iterator]() {
+        yield* this.colors;
+    }
+    /**
+     * Pick an interpolated color from this color scale
+     *
+     * @param {number} t Normalized time value to interpolate
+     * @returns {Color} Interpolated color on this scale
+     */
+    getColor(t) {
+        const index = lerp(t, 0, this.length - 1);
+        return this.colors[index];
+    }
+    /**
+     * Set this color scale colors to an array of interpolated colors
+     *
+     * @param {ColorInterpolation} interpolation Type of interpolation used for generation
+     * @param {number} length Amount of colors to generate
+     * @param {Color} color1 Start color
+     * @param {Color} color2 End color
+     * @param {object} [params] Interpolation parameters
+     * @returns {this}
+     */
+    generate(interpolation, length, color1, color2, params) {
+        this.colors = ColorScale.generate(interpolation, length, color1, color2, params);
+        return this;
+    }
+    /**
+     * Set this color scale colors to an array of interpolated colors in the RGB color space
+     *
+     * @param {number} length Amount of colors to generate
+     * @param {Color} color1 Start color
+     * @param {Color} color2 End color
+     * @param {object} [params]       Interpolation parameters
+     * @param {number} [params.power] Interpolation exponent
+     * @returns {this}
+     */
+    generateRgb(length, color1, color2, params) {
+        this.colors = ColorScale.generateRgb(length, color1, color2, params);
+        return this;
+    }
+    /**
+     * Set this color scale colors to an array of interpolated colors in the HSL color space
+     *
+     * @param {number} length Amount of colors to generate
+     * @param {Color} color1 Start color
+     * @param {Color} color2 End color
+     * @param {object} [params]                Interpolation parameters
+     * @param {number|number[]} [params.power] Interpolation exponent(s) : [h, s, l]
+     * @param {string} [params.hueMode]        Hue interpolation mode. Can be 'direct' | 'shortest' | 'longest'
+     * @returns {this}
+     */
+    generateHsl(length, color1, color2, params) {
+        this.colors = ColorScale.generateHsl(length, color1, color2, params);
+        return this;
+    }
+    /**
+     * Set this color scale colors to an array of interpolated colors in the HSB color space
+     *
+     * @param {number} length Amount of colors to generate
+     * @param {Color} color1 Start color
+     * @param {Color} color2 End color
+     * @param {object} [params]                Interpolation parameters
+     * @param {number|number[]} [params.power] Interpolation exponent(s) : [h, s, b]
+     * @param {string} [params.hueMode]        Hue interpolation mode. Can be 'direct' | 'shortest' | 'longest'
+     * @returns {this}
+     */
+    generateHsb(length, color1, color2, params) {
+        this.colors = ColorScale.generateHsb(length, color1, color2, params);
+        return this;
+    }
+    /**
+     * Set this color scale colors to an array of interpolated colors following HCL Qualitative color palettes algorithm
+     *
+     * @param {number} length Amount of colors to generate
+     * @param {Color} color1 Start color
+     * @param {Color} color2 End color
+     * @param {object} [params]         Interpolation parameters
+     * @param {string} [params.hueMode] Hue interpolation mode. Can be 'direct' | 'shortest' | 'longest'
+     * @returns {this}
+     */
+    generateQualitative(length, color1, color2, params) {
+        this.colors = ColorScale.generateQualitative(length, color1, color2, params);
+        return this;
+    }
+    /**
+     * Set this color scale colors to an array of interpolated colors following HCL Sequential color palettes algorithm
+     *
+     * @param {number} length Amount of colors to generate
+     * @param {Color} color1 Start color
+     * @param {Color} color2 End color
+     * @param {number|number[]} [params.power] Interpolation exponent(s) : [c, l]
+     * @param {string} [params.hueMode]        Hue interpolation mode. Can be 'direct' | 'shortest' | 'longest'
+     * @param {number} [params.chromaMax]      Maximum chroma value
+     * @returns {this}
+     */
+    generateSequential(length, color1, color2, params) {
+        this.colors = ColorScale.generateSequential(length, color1, color2, params);
+        return this;
+    }
+    /**
+     * Set this color scale colors to an array of interpolated colors following HCL Diverging color palettes algorithm
+     *
+     * @param {number} length Amount of colors to generate
+     * @param {Color} color1 Start color
+     * @param {Color} color2 End color
+     * @param {object} [params]                Interpolation parameters
+     * @param {number|number[]} [params.power] Interpolation exponent(s) : ([c, l])
+     * @returns {this}
+     */
+    generateDiverging(length, color1, color2, params) {
+        this.colors = ColorScale.generateDiverging(length, color1, color2, params);
+        return this;
+    }
+    /**
+     * Process all colors composing this scale
+     *
+     * @param {ColorScaleProcessingParameters} [params] Processing parameters
+     * @returns {this}
+     */
+    process(params) {
+        ColorScale.process(this, params);
+        return this;
+    }
+    /**
+     * Amount of colors composing this color scale
+     */
+    get length() {
+        return this.colors.length;
+    }
+    /**
+     * Generate an array of interpolated colors
+     *
+     * @param {ColorInterpolation} interpolation Type of interpolation used for generation
+     * @param {number} length Amount of colors to generate
+     * @param {Color} color1 Start color
+     * @param {Color} color2 End color
+     * @param {object} [params] Interpolation parameters
+     * @returns {Color[]} Generated color scale
+     */
+    static generate(interpolation, length, color1, color2, params) {
+        const interpolate = ColorScale._getInterpolateFunction(interpolation, color1, color2, params);
+        const colors = [];
+        for (let i = 0; i < length; i++) {
+            const t = i / (length - 1);
+            const color = interpolate(t);
+            colors.push(color);
+        }
+        return colors;
+    }
+    /**
+     * Generate an array of interpolated colors in the RGB color space
+     *
+     * @param {number} length Amount of colors to generate
+     * @param {Color} color1 Start color
+     * @param {Color} color2 End color
+     * @param {object} [params]       Interpolation parameters
+     * @param {number} [params.power] Interpolation exponent
+     * @returns {Color[]} Generated RGB color scale
+     */
+    static generateRgb(length, color1, color2, params) {
+        return ColorScale.generate('rgb', length, color1, color2, params);
+    }
+    /**
+     * Generate an array of interpolated colors in the HSL color space
+     *
+     * @param {number} length Amount of colors to generate
+     * @param {Color} color1 Start color
+     * @param {Color} color2 End color
+     * @param {object} [params]                Interpolation parameters
+     * @param {number|number[]} [params.power] Interpolation exponent(s) : [h, s, l]
+     * @param {string} [params.hueMode]        Hue interpolation mode. Can be 'direct' | 'shortest' | 'longest'
+     * @returns {Color[]} Generated HSL color scale
+     */
+    static generateHsl(length, color1, color2, params) {
+        return ColorScale.generate('hsl', length, color1, color2, params);
+    }
+    /**
+     * Generate an array of interpolated colors in the HSB color space
+     *
+     * @param {number} length Amount of colors to generate
+     * @param {Color} color1 Start color
+     * @param {Color} color2 End color
+     * @param {object} [params]                Interpolation parameters
+     * @param {number|number[]} [params.power] Interpolation exponent(s) : [h, s, b]
+     * @param {string} [params.hueMode]        Hue interpolation mode. Can be 'direct' | 'shortest' | 'longest'
+     * @returns {Color[]} Generated HSB color scale
+     */
+    static generateHsb(length, color1, color2, params) {
+        return ColorScale.generate('hsb', length, color1, color2, params);
+    }
+    /**
+     * Generate an array of interpolated colors following HCL Qualitative color palettes algorithm
+     *
+     * @param {number} length Amount of colors to generate
+     * @param {Color} color1 Start color
+     * @param {Color} color2 End color
+     * @param {object} [params]         Interpolation parameters
+     * @param {string} [params.hueMode] Hue interpolation mode. Can be 'direct' | 'shortest' | 'longest'
+     * @returns {Color[]} Generated qualitative color scale
+     */
+    static generateQualitative(length, color1, color2, params) {
+        return ColorScale.generate('qualitative', length, color1, color2, params);
+    }
+    /**
+     * Generate an array of interpolated colors following HCL Sequential color palettes algorithm
+     *
+     * @param {number} length Amount of colors to generate
+     * @param {Color} color1 Start color
+     * @param {Color} color2 End color
+     * @param {object} [params]                Interpolation parameters
+     * @param {number|number[]} [params.power] Interpolation exponent(s) : [c, l]
+     * @param {string} [params.hueMode]        Hue interpolation mode. Can be 'direct' | 'shortest' | 'longest'
+     * @param {number} [params.chromaMax]      Maximum chroma value
+     * @returns {Color[]} Generated sequential color scale
+     */
+    static generateSequential(length, color1, color2, params) {
+        return ColorScale.generate('sequential', length, color1, color2, params);
+    }
+    /**
+     * Generate an array of interpolated colors following HCL Diverging color palettes algorithm
+     *
+     * @param {number} length Amount of colors to generate
+     * @param {Color} color1 Start color
+     * @param {Color} color2 End color
+     * @param {object} [params]                Interpolation parameters
+     * @param {number|number[]} [params.power] Interpolation exponent(s) : ([c, l])
+     * @returns {Color[]} Generated diverging color scale
+     */
+    static generateDiverging(length, color1, color2, params) {
+        return ColorScale.generate('diverging', length, color1, color2, params);
+    }
+    /**
+     * Process a given value
+     *
+     * @param {number} value Value to process
+     * @param {ColorScaleProcessingTarget} [target] Processing target
+     * @returns {number} Processed value
+     */
+    static processValue(value, target) {
+        if (typeof target === 'undefined')
+            return value;
+        if (typeof target === 'number')
+            return target;
+        if (Array.isArray(target))
+            return clamp(value, target[0], target[1]);
+        return value;
+    }
+    /**
+     * Process a given color
+     *
+     * @param {Color} color Color to process
+     * @param {ColorScaleProcessingParameters} [params] Processing parameters
+     * @returns {Color} Processed color
+     */
+    static processColor(color, params = {}) {
+        if (params.hsl) {
+            let [h, s, l] = color.hsl;
+            h = this.processValue(h, params.hsl.hue);
+            s = this.processValue(s, params.hsl.saturation);
+            l = this.processValue(l, params.hsl.lightness);
+            color.setHsl([h, s, l]);
+        }
+        if (params.hsb) {
+            let [h, s, b] = color.hsb;
+            h = this.processValue(h, params.hsb.hue);
+            s = this.processValue(s, params.hsb.saturation);
+            b = this.processValue(b, params.hsb.brightness);
+            color.setHsb([h, s, b]);
+        }
+        if (params.hcl) {
+            let [h, c, l] = color.hcl;
+            h = this.processValue(h, params.hcl.hue);
+            c = this.processValue(c, params.hcl.chroma);
+            l = this.processValue(l, params.hcl.luminance);
+            color.setHcl([h, c, l]);
+        }
+        return color;
+    }
+    /**
+     * Process all colors composing a given scale
+     *
+     * @param {ColorScale} scale Color scale to process
+     * @param {ColorScaleProcessingParameters} [params] Processing parameters
+     * @returns {ColorScale} Processed color scale
+     */
+    static process(scale, params = {}) {
+        scale.colors.forEach((color) => this.processColor(color, params));
+        return scale;
+    }
+    static _getInterpolateFunction(interpolation, color1, color2, params) {
+        switch (interpolation) {
+            case 'rgb':
+            default:
+                return (t) => {
+                    const rgb = Color.lerpRgb(t, color1.rgb, color2.rgb, params);
+                    const color = new Color().setRgb(rgb);
+                    return color;
+                };
+            case 'hsl':
+                return (t) => {
+                    const hsl = Color.lerpHsl(t, color1.hsl, color2.hsl, params);
+                    const color = new Color().setHsl(hsl);
+                    return color;
+                };
+            case 'hsb':
+                return (t) => {
+                    const hsb = Color.lerpHsb(t, color1.hsb, color2.hsb, params);
+                    const color = new Color().setHsb(hsb);
+                    return color;
+                };
+            case 'qualitative':
+                return (t) => {
+                    const hcl = Color.interpolateQualitative(t, color1.hcl, color2.hcl, params);
+                    const color = new Color().setHcl(hcl);
+                    return color;
+                };
+            case 'sequential':
+                return (t) => {
+                    const hcl = Color.interpolateSequential(t, color1.hcl, color2.hcl, params);
+                    const color = new Color().setHcl(hcl);
+                    return color;
+                };
+            case 'diverging':
+                return (t) => {
+                    const hcl = Color.interpolateDiverging(t, color1.hcl, color2.hcl, params);
+                    const color = new Color().setHcl(hcl);
+                    return color;
+                };
+        }
+    }
+}

package/lib/extras/colors/_ColorScale.d.ts

@@ -0,0 +1,62 @@
+import type { ColorRepresentation } from '../../types';
+export type ColorScaleSettings = {
+    colorSpace: 'rgb';
+} | {
+    colorSpace: 'hsl';
+    hueOffset?: number;
+    saturationOffset?: number;
+    lightnessOffset?: number;
+} | {
+    colorSpace: 'hsb';
+    hueOffset?: number;
+    saturationOffset?: number;
+    brightnessOffset?: number;
+} | {
+    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);
+    /**
+     * Generate 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]>;
+    /**
+     * Interpolate 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/extras/colors/_ColorScale.js

@@ -0,0 +1,156 @@
+import { lerp, triLerp } from '../../maths';
+import { hclToRgb, hsbToRgb, hslToRgb, normalizeColor, rgbToHcl, rgbToHsb, rgbToHsl } from '../../colors';
+export const defaultSettings = {
+    colorSpace: 'rgb'
+};
+/**
+ * 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 = [];
+    /**
+     * @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 }) {
+        this.colors = ColorScale.generate(input, target, length, settings);
+    }
+    /**
+     * Generate 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, 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;
+    }
+    /**
+     * Interpolate 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, targetColor, value, settings = { ...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]);
+                return [r, g, b];
+            }
+            case 'hsl': {
+                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': {
+                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':
+                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) {
+                    /**
+                     * 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
+                     */
+                    case 'qualitative': {
+                        h = lerp(value, h1, h2);
+                        c = c1;
+                        l = l1;
+                    }
+                    /**
+                     * 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)
+                     */
+                    case 'sequential': {
+                        h = lerp(value, h1, h2);
+                        c = settings.triangular ? triLerp(powerValue, c1, c2, settings.triangular) : lerp(powerValue, c1, c2);
+                        l = lerp(powerValue, l1, l2);
+                    }
+                    /**
+                     * 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)
+                     */
+                    case 'diverging': {
+                        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);
+                    }
+                    default: {
+                        h = lerp(value, h1, h2);
+                        c = lerp(value, c1, c2);
+                        l = lerp(value, l1, l2);
+                    }
+                }
+                return hclToRgb([h, c, l]);
+        }
+    }
+}

package/lib/extras/colors/index.d.ts

@@ -0,0 +1,3 @@
+export { default as Color, type ColorInterpolationsParameters, type ColorInterpolation, type HueInterpolationMode } from './Color';
+export { default as ColorScale, type ColorScaleProcessingTarget, type ColorScaleProcessingParameters } from './ColorScale';
+export { default as ColorPalette, type ColorPaletteGenerationParameters, type ColorPaletteGenerator, LightScaleGenerator, DarkScaleGenerator, SequentialLightGenerator, SequentialDarkGenerator } from './ColorPalette';

package/lib/extras/colors/index.js

@@ -0,0 +1,3 @@
+export { default as Color } from './Color';
+export { default as ColorScale } from './ColorScale';
+export { default as ColorPalette, LightScaleGenerator, DarkScaleGenerator, SequentialLightGenerator, SequentialDarkGenerator } from './ColorPalette';

package/lib/extras/frame-rate/FrameRate.d.ts

@@ -5,21 +5,24 @@
  * @class FrameRate
  */
 export default class FrameRate {
-    private _fps;
-    private _interval;
-    private _time;
-    private _elapsedTime;
-    private _lastUpdate;
+    protected _fps: number;
+    protected _interval: number;
+    protected _time: number;
+    protected _elapsedTime: number;
+    protected _lastUpdate: number;
     /**
-     * @param {number} [fps=30] Frame per second limit
+     * @param {number} [fps=60] Frame per second limit
      */
     constructor(fps?: number);
     /**
-     * Return true if elapsed time since last update is higher than current FPS
+     * Check if elapsed time since last update is higher than current FPS
      *
-     * @returns {boolean}
+     * @returns {boolean} True if elapsed time since last update is higher than current FPS, false otherwise
      */
     update(): boolean;
-    get fps(): number;
+    /**
+     * Frame per second limit
+     */
     set fps(fps: number);
+    get fps(): number;
 }

package/lib/extras/frame-rate/FrameRate.js

@@ -12,15 +12,15 @@ export default class FrameRate {
     _elapsedTime = 0;
     _lastUpdate = 0;
     /**
-     * @param {number} [fps=30] Frame per second limit
+     * @param {number} [fps=60] Frame per second limit
      */
-    constructor(fps = 30) {
+    constructor(fps = 60) {
         this.fps = fps;
     }
     /**
-     * Return true if elapsed time since last update is higher than current FPS
+     * Check if elapsed time since last update is higher than current FPS
      *
-     * @returns {boolean}
+     * @returns {boolean} True if elapsed time since last update is higher than current FPS, false otherwise
      */
     update() {
         this._time = now();
@@ -31,11 +31,14 @@ export default class FrameRate {
         this._lastUpdate = this._time - (this._elapsedTime % this._interval);
         return true;
     }
-    get fps() {
-        return this._fps;
-    }
+    /**
+     * Frame per second limit
+     */
     set fps(fps) {
         this._fps = fps;
         this._interval = 1000 / fps;
     }
+    get fps() {
+        return this._fps;
+    }
 }

package/lib/extras/geometry/Vector.d.ts

@@ -20,7 +20,7 @@ export interface Vector<V = any> {
     round(): this;
     trunc(): this;
     negate(): this;
-    lerp(vector: V, t: number): this;
+    lerp(t: number, vector: V): this;
     normalize(): this;
     setLength(length: number): this;
     length(): number;