smath 1.0.2 → 1.1.0

package/dist/index.js

@@ -1,18 +1,34 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./Polate"), exports);
-__exportStar(require("./SMath"), exports);
+exports.SMath = void 0;
+var SMath = (function () {
+    function SMath() {
+    }
+    SMath.clamp = function (n, min, max) {
+        if (n < min) {
+            return min;
+        }
+        if (n > max) {
+            return max;
+        }
+        return n;
+    };
+    SMath.approx = function (a, b, epsilon) {
+        if (epsilon === void 0) { epsilon = 1e-6; }
+        return a - b < epsilon && b - a < epsilon;
+    };
+    SMath.normalize = function (n, min, max) {
+        if (min === max) {
+            return 0;
+        }
+        return (n - min) / (max - min);
+    };
+    SMath.expand = function (n, min, max) {
+        return (max - min) * n + min;
+    };
+    SMath.translate = function (n, min1, max1, min2, max2) {
+        return this.expand(this.normalize(n, min1, max1), min2, max2);
+    };
+    return SMath;
+}());
+exports.SMath = SMath;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "smath",
-  "version": "1.0.2",
+  "version": "1.1.0",
   "description": "Small math function library",
   "main": "dist/index.js",
   "types": "types/index.d.ts",

package/types/index.d.ts

@@ -4,5 +4,74 @@
  *
  * Exports the public-facing API for `smath`
  */
-export * from './Polate';
-export * from './SMath';
+/**
+ * Contains a small math function library including
+ * useful interpolation and extrapolation functions.
+ */
+export declare abstract class SMath {
+    /**
+     * Clamp a number within a range.
+     * @param n The number to clamp
+     * @param min The minimum value of the range
+     * @param max The maximum value of the range
+     * @returns A clamped number
+     * @example
+     * ```js
+     * const n1 = SMath.clamp(5, 0, 10),  // 5
+     *       n2 = SMath.clamp(-2, 0, 10); // 0
+     * ```
+     */
+    static clamp(n: number, min: number, max: number): number;
+    /**
+     * Check if two numbers are approximately equal with a maximum abolute error.
+     * @param a Any number
+     * @param b Any number
+     * @param epsilon Maximum absolute error
+     * @returns True if `a` is approximately `b`
+     * @example
+     * ```js
+     * const b1 = SMath.approx(1 / 3, 0.33, 1e-6), // false
+     *       b2 = SMath.approx(1 / 3, 0.33, 1e-2); // true
+     * ```
+     */
+    static approx(a: number, b: number, epsilon?: number): boolean;
+    /**
+     * Normalize the number `n` from the range `min, max` to the range `0, 1`
+     * @param n The number to normalize
+     * @param min The minimum value in the range
+     * @param max The maximum value in the range
+     * @returns A normalized value
+     * @example
+     * ```js
+     * const y = SMath.normalize(18, 9, 99); // 0.1
+     * ```
+     */
+    static normalize(n: number, min: number, max: number): number;
+    /**
+     * Expand a normalized number `n` to the range `min, max`
+     * @param n A normalized number
+     * @param min The minimum value in the range
+     * @param max The maximum value in the range
+     * @returns A value within the number range
+     * @example
+     * ```js
+     * const y = SMath.expand(0.25, 4, 6); // 4.5
+     * ```
+     */
+    static expand(n: number, min: number, max: number): number;
+    /**
+     * Translate a number `n` from the range `min1, max1` to the range `min2, max2`
+     * @param n The number to translate
+     * @param min1 The minimum value from the initial range
+     * @param max1 The maximum value from the initial range
+     * @param min2 The minimum value for the final range
+     * @param max2 The maximum value for the final range
+     * @returns A translated number in the final range
+     * @example
+     * ```js
+     * const C = 20,
+     *       F = SMath.translate(C, 0, 100, 32, 212); // 68
+     * ```
+     */
+    static translate(n: number, min1: number, max1: number, min2: number, max2: number): number;
+}

package/dist/Polate.js

@@ -1,21 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Polate = void 0;
-var Polate = (function () {
-    function Polate() {
-    }
-    Polate.normalize = function (n, min, max) {
-        if (min === max) {
-            return 0;
-        }
-        return (n - min) / (max - min);
-    };
-    Polate.expand = function (n, min, max) {
-        return (max - min) * n + min;
-    };
-    Polate.translate = function (n, min1, max1, min2, max2) {
-        return this.expand(this.normalize(n, min1, max1), min2, max2);
-    };
-    return Polate;
-}());
-exports.Polate = Polate;

package/dist/SMath.js

@@ -1,28 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SMath = void 0;
-var SMath = (function () {
-    function SMath() {
-    }
-    SMath.isNumber = function (n) {
-        return typeof n === 'number' && n !== Infinity && n !== -Infinity;
-    };
-    SMath.clamp = function (n, min, max) {
-        if (n < min) {
-            return min;
-        }
-        if (n > max) {
-            return max;
-        }
-        return n;
-    };
-    SMath.approx = function (a, b, epsilon) {
-        if (epsilon === void 0) { epsilon = 1e-6; }
-        return a - b < epsilon && b - a < epsilon;
-    };
-    SMath.round = function (n, d) {
-        return Math.round(n * Math.pow(10, d)) / (Math.pow(10, d));
-    };
-    return SMath;
-}());
-exports.SMath = SMath;

package/types/Polate.d.ts

@@ -1,44 +0,0 @@
-/**
- * Contains useful interpolation and extrapolation functions.
- */
-export declare abstract class Polate {
-    /**
-     * Normalize the number `n` from the range `min, max` to the range `0, 1`
-     * @param n The number to normalize
-     * @param min The minimum value in the range
-     * @param max The maximum value in the range
-     * @returns A normalized value
-     * @example
-     * ```js
-     * const y = Polate.normalize(18, 9, 99); // 0.1
-     * ```
-     */
-    static normalize(n: number, min: number, max: number): number;
-    /**
-     * Expand a normalized number `n` to the range `min, max`
-     * @param n A normalized number
-     * @param min The minimum value in the range
-     * @param max The maximum value in the range
-     * @returns A value within the number range
-     * @example
-     * ```js
-     * const y = Polate.expand(0.25, 4, 6); // 4.5
-     * ```
-     */
-    static expand(n: number, min: number, max: number): number;
-    /**
-     * Translate a number `n` from the range `min1, max1` to the range `min2, max2`
-     * @param n The number to translate
-     * @param min1 The minimum value from the initial range
-     * @param max1 The maximum value from the initial range
-     * @param min2 The minimum value for the final range
-     * @param max2 The maximum value for the final range
-     * @returns A translated number in the final range
-     * @example
-     * ```js
-     * const C = 20,
-     *       F = Polate.translate(C, 0, 100, 32, 212); // 68
-     * ```
-     */
-    static translate(n: number, min1: number, max1: number, min2: number, max2: number): number;
-}

package/types/SMath.d.ts

@@ -1,53 +0,0 @@
-/**
- * Contains a small math function library.
- */
-export declare abstract class SMath {
-    /**
-     * Determine if a value is numeric.
-     * @param n Any value to check
-     * @returns True if `n` is a number
-     * @example
-     * ```js
-     * const b1 = SMath.isNumber(2),   // true
-     *       b2 = SMath.isNumber('2'); // false
-     * ```
-     */
-    static isNumber(n: any): boolean;
-    /**
-     * Clamp a number within a range.
-     * @param n The number to clamp
-     * @param min The minimum value of the range
-     * @param max The maximum value of the range
-     * @returns A clamped number
-     * @example
-     * ```js
-     * const n1 = SMath.clamp(5, 0, 10),  // 5
-     *       n2 = SMath.clamp(-2, 0, 10); // 0
-     * ```
-     */
-    static clamp(n: number, min: number, max: number): number;
-    /**
-     * Check if two numbers are approximately equal with a maximum abolute error.
-     * @param a Any number
-     * @param b Any number
-     * @param epsilon Maximum absolute error
-     * @returns True if `a` is approximately `b`
-     * @example
-     * ```js
-     * const b1 = SMath.approx(1 / 3, 0.33, 1e-6), // false
-     *       b2 = SMath.approx(1 / 3, 0.33, 1e-2); // true
-     * ```
-     */
-    static approx(a: number, b: number, epsilon?: number): boolean;
-    /**
-     * Round a number to any number of decimal places.
-     * @param n The number to round
-     * @param d The number of places on the right side of the decimal
-     * @returns The rounded number
-     * @example
-     * ```js
-     * const pi = SMath.round(3.1416, 2); // 3.14
-     * ```
-     */
-    static round(n: number, d: number): number;
-}