toosoon-utils 3.0.4 → 4.0.0

package/README.md

@@ -651,6 +651,144 @@ Smoothly interpolate a number toward another.
 damp(value: number, target: number, damping: number, delta: number): number;
 ```
 
+### Random
+
+##### randomBoolean(probability)
+
+Generate a random boolean (true or false).
+
+- `[probability=0.5]`: Probability to get true.
+
+```ts
+randomBoolean(probability?: number): boolean;
+```
+
+##### randomSign(probability)
+
+Generate a random sign (1 or -1).
+
+- `[probability=0.5]`: Probability to get 1.
+
+```ts
+randomSign(probability?: number): number;
+```
+
+##### randomFloat(min, max)
+
+Generate a random floating-point number within a specified range.
+
+- `[min=0]`: Minimum boundary.
+- `[max=1]`: Maximum boundary.
+- `[precision=2]`: Number of digits after the decimal point.
+
+```ts
+randomFloat(min?: number, max?: number, precision?: number): number;
+```
+
+##### randomInt(min, max)
+
+Generate a random integer number within a specified range.
+
+- `min`: Minimum boundary.
+- `max`: Maximum boundary.
+
+```ts
+randomInt(min: number, max: number): number;
+```
+
+##### randomHexColor()
+
+Generate a random hexadecimal color.
+
+```ts
+randomHexColor(): string;
+```
+
+##### randomItem(array)
+
+Pick a random item from a given array.
+
+- `array`: Array to pick the item from.
+
+```ts
+randomItem<T>(array: T[]): T | undefined;
+```
+
+##### randomObjectProperty(object)
+
+Pick a random property value from a given object.
+
+- `object`: Object to pick the property from.
+
+```ts
+randomObjectProperty<T>(object: Record<string, T>): T | undefined;
+```
+
+##### randomIndex(weights)
+
+Select a random index from an array of weighted items.
+
+- `weights`: Array of weights.
+
+```ts
+randomIndex(weights: number[]): number;
+```
+
+##### randomGaussian(mean, spread)
+
+Generate a random number fitting a Gaussian (normal) distribution.
+
+- `[mean=0]`: Central value.
+- `[spread=1]`: Standard deviation.
+
+```ts
+randomGaussian(mean?: number, spread?: number): number;
+```
+
+##### onCircle(radius)
+
+Produce a random 2D point around the perimiter of a unit circle.
+
+- `[radius=1]`: Radius of the circle.
+- `[target]`: Target vector.
+
+```ts
+onCircle(radius?: number, target?: Vector2): Vector2;
+```
+
+##### insideCircle(radius)
+
+Produce a random 2D point inside a unit circle.
+
+- `[radius=1]`: Radius of the circle.
+- `[target]` Target vector.
+
+```ts
+insideCircle(radius?: number, target?: Vector2): Vector2;
+```
+
+##### onSphere(radius)
+
+Produce a random 3D point on the surface of a unit sphere.
+
+- `[radius=1]`: Radius of the sphere.
+- `[target]`: Target vector.
+
+```ts
+onSphere(radius?: number, target?: Vector3): Vector3;
+```
+
+##### insideSphere(radius)
+
+Produce a random 3D point inside a unit sphere.
+
+- `[radius=1]`: Radius of the sphere.
+- `[target]`: Target vector.
+
+```ts
+insideSphere(radius?: number, target?: Vector3): Vector3;
+```
+
 ### Pseudo-Random Number Generator (PRNG)
 
 #### PRNG Algorithms
@@ -709,7 +847,7 @@ 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 exist with additionnal parameters for a `seed` string and a PRNG `algorithm` function.
+Thanks to the above algorithms, a seed-based version of most of the [random functions](#random) exist with additionnal parameters for a `seed` string and a PRNG `algorithm` function.
 
 PRNG parameters:
 
@@ -829,164 +967,143 @@ Generate a pseudo-random number fitting a Gaussian (normal) distribution.
 randomGaussian(prng: string | object, mean?: number, spread?: number): number;
 ```
 
-### Random
+### Query parameters
 
-##### randomBoolean(probability)
+##### getQuery(property)
 
-Generate a random boolean (true or false).
+Get a query parameter.
 
-- `[probability=0.5]`: Probability to get true.
+- `property`: Query property to check.
 
 ```ts
-randomBoolean(probability?: number): boolean;
+getQuery(property: string): string | null;
 ```
 
-##### randomSign(probability)
+##### setQuery(property)
 
-Generate a random sign (1 or -1).
+Set a query parameter.
 
-- `[probability=0.5]`: Probability to get 1.
+- `property`: Query property to set.
+- `value`: Value to set.
 
 ```ts
-randomSign(probability?: number): number;
+setQuery(property: string, value: string): void;
 ```
 
-##### randomFloat(min, max)
+##### hasQuery(property)
 
-Generate a random floating-point number within a specified range.
+Check if a query parameter exists.
 
-- `[min=0]`: Minimum boundary.
-- `[max=1]`: Maximum boundary.
-- `[precision=2]`: Number of digits after the decimal point.
+- `property`: Query property to check.
 
 ```ts
-randomFloat(min?: number, max?: number, precision?: number): number;
+hasQuery(property: string): boolean;
 ```
 
-##### randomInt(min, max)
-
-Generate a random integer number within a specified range.
+### Strings
 
-- `min`: Minimum boundary.
-- `max`: Maximum boundary.
+#### Cases
 
-```ts
-randomInt(min: number, max: number): number;
-```
+##### capitalize(string)
 
-##### randomHexColor()
+Capitalize a string.
 
-Generate a random hexadecimal color.
+- `string`: String to capitalize.
 
 ```ts
-randomHexColor(): string;
+capitalize(string: string): string;
 ```
 
-##### randomItem(array)
+##### toKebabCase(string)
 
-Pick a random item from a given array.
+Convert a string to kebab-case: 'Hello world' -> 'hello-world'.
 
-- `array`: Array to pick the item from.
+- `string`: String to convert.
 
 ```ts
-randomItem<T>(array: T[]): T | undefined;
+toKebabCase(string: string): string;
 ```
 
-##### randomObjectProperty(object)
+##### toSnakeCase(string)
 
-Pick a random property value from a given object.
+Convert a string to snake_case: 'Hello world' -> 'hello_world'.
 
-- `object`: Object to pick the property from.
+- `string`: String to convert.
 
 ```ts
-randomObjectProperty<T>(object: Record<string, T>): T | undefined;
+toSnakeCase(string: string): string;
 ```
 
-##### randomIndex(weights)
+##### toCamelCase(string)
 
-Select a random index from an array of weighted items.
+Convert a string to camelCase: 'Hello world' -> 'helloWorld'.
 
-- `weights`: Array of weights.
+- `string`: String to convert.
 
 ```ts
-randomIndex(weights: number[]): number;
+toCamelCase(string: string): string;
 ```
 
-##### randomGaussian(mean, spread)
+##### toPascalCase(string)
 
-Generate a random number fitting a Gaussian (normal) distribution.
+Convert a string to PascalCase: 'Hello world' -> 'HelloWorld'.
 
-- `[mean=0]`: Central value.
-- `[spread=1]`: Standard deviation.
+- `string`: String to convert.
 
 ```ts
-randomGaussian(mean?: number, spread?: number): number;
+toPascalCase(string: string): string;
 ```
 
-##### onCircle(radius)
+##### toTrainCase(string)
 
-Produce a random 2D point around the perimiter of a unit circle.
+Convert a string to Train-Case: 'Hello world' -> 'Hello-World'.
 
-- `[radius=1]`: Radius of the circle.
-- `[target]`: Target vector.
+- `string`: String to convert.
 
 ```ts
-onCircle(radius?: number, target?: Vector2): Vector2;
+toTrainCase(string: string): string;
 ```
 
-##### insideCircle(radius)
+##### toConstantCase(string)
 
-Produce a random 2D point inside a unit circle.
+Convert a string to CONSTANT_CASE: 'Hello world' -> 'HELLO_WORLD'.
 
-- `[radius=1]`: Radius of the circle.
-- `[target]` Target vector.
+- `string`: String to convert.
 
 ```ts
-insideCircle(radius?: number, target?: Vector2): Vector2;
+toConstantCase(string: string): string;
 ```
 
-##### onSphere(radius)
-
-Produce a random 3D point on the surface of a unit sphere.
-
-- `[radius=1]`: Radius of the sphere.
-- `[target]`: Target vector.
-
-```ts
-onSphere(radius?: number, target?: Vector3): Vector3;
-```
+#### Paths
 
-##### insideSphere(radius)
+##### cleanPath(path)
 
-Produce a random 3D point inside a unit sphere.
+Clean a path by removing its parameters.
 
-- `[radius=1]`: Radius of the sphere.
-- `[target]`: Target vector.
+- `path`: Path to clean.
 
 ```ts
-insideSphere(radius?: number, target?: Vector3): Vector3;
+cleanPath(path: string): string;
 ```
 
-### Strings
+##### addTrailingSlash(path)
 
-##### capitalize(string)
+Convert a path by ensuring it has a trailing slash.
 
-Capitalize a string.
-
-- `string`: String to capitalize.
+- `path`: Path to convert.
 
 ```ts
-capitalize(string: string): string;
+addTrailingSlash(path: string): string;
 ```
 
-##### cleanPath(path)
+##### removeTrailingSlash(path)
 
-Clean a path by removing params.
+Convert a path by ensuring it has not a trailing slash.
 
-- `path`: Path to clean.
+- `path`: Path to convert.
 
 ```ts
-cleanPath(path: string): string;
+removeTrailingSlash(path: string): string;
 ```
 
 ## Utility classes

package/lib/classes/_pool.js

@@ -1,4 +1,3 @@
-"use strict";
 // *********************
 // WIP
 // *********************
@@ -22,9 +21,7 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
     }
     return to.concat(ar || Array.prototype.slice.call(from));
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.defaultSettings = void 0;
-exports.defaultSettings = {
+export var defaultSettings = {
     max: Infinity
 };
 /**
@@ -35,10 +32,10 @@ exports.defaultSettings = {
  */
 var Pool = /** @class */ (function () {
     function Pool(settings) {
-        if (settings === void 0) { settings = __assign({}, exports.defaultSettings); }
+        if (settings === void 0) { settings = __assign({}, defaultSettings); }
         this.items = [];
         this.pool = [];
-        this.settings = __assign({}, exports.defaultSettings);
+        this.settings = __assign({}, defaultSettings);
         this.settings = Object.assign(this.settings, settings);
     }
     /**
@@ -92,4 +89,4 @@ var Pool = /** @class */ (function () {
     };
     return Pool;
 }());
-exports.default = Pool;
+export default Pool;

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

@@ -1,4 +1,4 @@
-import { ColorRepresentation } from '../types';
+import type { ColorRepresentation } from '../types';
 export type ColorScaleSettings = {
     colorSpace: 'rgb';
 } | {

package/lib/classes/color-scale.js

@@ -1,4 +1,3 @@
-"use strict";
 var __assign = (this && this.__assign) || function () {
     __assign = Object.assign || function(t) {
         for (var s, i = 1, n = arguments.length; i < n; i++) {
@@ -10,11 +9,9 @@ var __assign = (this && this.__assign) || function () {
     };
     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 = {
+import { lerp, triLerp } from '../maths';
+import { hclToRgb, hsbToRgb, hslToRgb, normalizeColor, rgbToHcl, rgbToHsb, rgbToHsl } from '../colors';
+export var defaultSettings = {
     colorSpace: 'rgb'
 };
 /**
@@ -32,7 +29,7 @@ var ColorScale = /** @class */ (function () {
      */
     function ColorScale(input, target, length, settings) {
         if (length === void 0) { length = 5; }
-        if (settings === void 0) { settings = __assign({}, exports.defaultSettings); }
+        if (settings === void 0) { settings = __assign({}, defaultSettings); }
         /**
          * Array of colors composing the color scale
          */
@@ -49,10 +46,10 @@ var ColorScale = /** @class */ (function () {
      * @returns {Array<[number, number, number]>} Color scale colors
      */
     ColorScale.generate = function (input, target, length, settings) {
-        if (settings === void 0) { settings = __assign({}, exports.defaultSettings); }
+        if (settings === void 0) { settings = __assign({}, defaultSettings); }
         var colors = [];
-        var inputColor = (0, colors_1.normalizeColor)(input);
-        var targetColor = (0, colors_1.normalizeColor)(target);
+        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));
@@ -70,45 +67,45 @@ var ColorScale = /** @class */ (function () {
      */
     ColorScale.interpolate = function (inputColor, targetColor, value, settings) {
         var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
-        if (settings === void 0) { settings = __assign({}, exports.defaultSettings); }
+        if (settings === void 0) { settings = __assign({}, defaultSettings); }
         switch (settings.colorSpace) {
             case 'rgb': {
-                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]);
+                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 = (0, colors_1.rgbToHsl)(inputColor);
-                var targetHsl = (0, colors_1.rgbToHsl)(targetColor);
+                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 = (0, maths_1.lerp)(value, h1_1, h2_1);
-                var s = (0, maths_1.lerp)(value, s1, s2);
-                var l_1 = (0, maths_1.lerp)(value, l1_1, l2_1);
-                return (0, colors_1.hslToRgb)([h_1, s, l_1]);
+                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]);
             }
             case 'hsb': {
-                var inputHsb = (0, colors_1.rgbToHsb)(inputColor);
-                var targetHsb = (0, colors_1.rgbToHsb)(targetColor);
+                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 = (0, maths_1.lerp)(value, h1_2, h2_2);
-                var s = (0, maths_1.lerp)(value, s1, s2);
-                var b = (0, maths_1.lerp)(value, b1, b2);
-                return (0, colors_1.hsbToRgb)([h_2, s, b]);
+                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]);
             }
             case 'hcl':
-                var inputHcl = (0, colors_1.rgbToHcl)(inputColor);
-                var targetHcl = (0, colors_1.rgbToHcl)(targetColor);
+                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];
@@ -131,7 +128,7 @@ var ColorScale = /** @class */ (function () {
                      * - Luminance: Constant
                      */
                     case 'qualitative': {
-                        h = (0, maths_1.lerp)(value, h1, h2);
+                        h = lerp(value, h1, h2);
                         c = c1;
                         l = l1;
                     }
@@ -145,9 +142,9 @@ var ColorScale = /** @class */ (function () {
                      * - Luminance: Linear (+power)
                      */
                     case 'sequential': {
-                        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);
+                        h = lerp(value, h1, h2);
+                        c = settings.triangular ? triLerp(powerValue, c1, c2, settings.triangular) : lerp(powerValue, c1, c2);
+                        l = lerp(powerValue, l1, l2);
                     }
                     /**
                      * Diverging
@@ -159,19 +156,19 @@ var ColorScale = /** @class */ (function () {
                      * - Luminance: Linear (+power)
                      */
                     case 'diverging': {
-                        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);
+                        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 = (0, maths_1.lerp)(value, h1, h2);
-                        c = (0, maths_1.lerp)(value, c1, c2);
-                        l = (0, maths_1.lerp)(value, l1, l2);
+                        h = lerp(value, h1, h2);
+                        c = lerp(value, c1, c2);
+                        l = lerp(value, l1, l2);
                     }
                 }
-                return (0, colors_1.hclToRgb)([h, c, l]);
+                return hclToRgb([h, c, l]);
         }
     };
     return ColorScale;
 }());
-exports.default = ColorScale;
+export default ColorScale;

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

@@ -6,10 +6,10 @@
  */
 export default class FrameRate {
     private _fps;
-    private interval;
-    private time;
-    private elapsedTime;
-    private lastUpdate;
+    private _interval;
+    private _time;
+    private _elapsedTime;
+    private _lastUpdate;
     /**
      * @param {number} [fps=30] Frame per second limit
      */

package/lib/classes/frame-rate.js

@@ -1,6 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-var functions_1 = require("../functions");
+import { now } from '../functions';
 /**
  * Utility class for controlling FPS calls
  *
@@ -13,11 +11,10 @@ var FrameRate = /** @class */ (function () {
      */
     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._interval = 0;
+        this._time = 0;
+        this._elapsedTime = 0;
+        this._lastUpdate = 0;
         this.fps = fps;
     }
     /**
@@ -26,12 +23,12 @@ var FrameRate = /** @class */ (function () {
      * @returns {boolean}
      */
     FrameRate.prototype.update = function () {
-        this.time = (0, functions_1.now)();
-        this.elapsedTime = this.time - this.lastUpdate;
-        if (this.elapsedTime < this.interval) {
+        this._time = now();
+        this._elapsedTime = this._time - this._lastUpdate;
+        if (this._elapsedTime < this._interval) {
             return false;
         }
-        this.lastUpdate = this.time - (this.elapsedTime % this.interval);
+        this._lastUpdate = this._time - (this._elapsedTime % this._interval);
         return true;
     };
     Object.defineProperty(FrameRate.prototype, "fps", {
@@ -40,11 +37,11 @@ var FrameRate = /** @class */ (function () {
         },
         set: function (fps) {
             this._fps = fps;
-            this.interval = 1000 / fps;
+            this._interval = 1000 / fps;
         },
         enumerable: false,
         configurable: true
     });
     return FrameRate;
 }());
-exports.default = FrameRate;
+export default FrameRate;

package/lib/colors.d.ts

@@ -1,4 +1,4 @@
-import { ColorRepresentation } from './types';
+import type { ColorRepresentation } from './types';
 /**
  * Normalize a color representation into RGB
  *
@@ -33,7 +33,7 @@ export declare function rgbToHexString([r, g, b]: [number, number, number]): str
  * Convert hexadecimal to RGB
  * Note: rgb values are contained in the interval [0, 1]
  *
- * @param  {(number|string)} hex Hexadecimal color
+ * @param  {number|string} hex Hexadecimal color
  * @returns {[number, number, number]} RGB color
  */
 export declare function hexToRgb(hex: number | string): [number, number, number];