exprify 1.0.3 → 1.0.6

package/src/function/registry.js

@@ -1,8 +1,9 @@
 export function createFunctionRegistry(initial = {}) {
+  // Object.create(null) avoids prototype pollution (no inherited properties)
   const store = Object.create(null);
 
   for (const key in initial) {
-    if (typeof initial[key] === "function") {
+    if (typeof initial[key] === 'function') {
       store[key] = initial[key];
     }
   }
@@ -11,58 +12,64 @@ export function createFunctionRegistry(initial = {}) {
     getAllFunctionsName() {
       return Object.keys(store);
     },
-    // register new formula
+
+    /**
+     * @param {string} name
+     * @param {any} fn
+     */
     register(name, fn) {
-      if (typeof name !== "string" || !name) {
-        throw new Error("Formula name must be a non-empty string");
+      if (typeof name !== 'string' || !name) {
+        throw new Error('Formula name must be a non-empty string');
       }
 
-      if (typeof fn !== "function") {
+      if (typeof fn !== 'function') {
         throw new Error(`Formula "${name}" must be callable`);
       }
 
       store[name] = fn;
     },
 
-    // get formula
+    /**
+     * @param {string} name
+     */
     get(name) {
       return store[name];
     },
 
-    // check existence
+    /**
+     * @param {any} name
+     */
     has(name) {
       return Object.prototype.hasOwnProperty.call(store, name);
     },
 
-    // remove formula
+    /**
+     * @param {string | number} name
+     */
     remove(name) {
       delete store[name];
     },
 
-    // list all
     all() {
       return { ...store };
     },
 
-    // clear registry
     clear() {
       for (const key in store) {
         delete store[key];
       }
     },
 
-    // extend multiple
     extend(formulas = {}) {
       for (const name in formulas) {
-        if (typeof formulas[name] === "function") {
+        if (typeof formulas[name] === 'function') {
           store[name] = formulas[name];
         }
       }
     },
 
-    // clone (for scoped instances)
     clone() {
-      return createFormulaRegistry(store);
-    }
+      return createFunctionRegistry(store);
+    },
   };
-}
+}

package/src/index.js

@@ -1,2 +1,2 @@
-import Exprify from "./core/Exprify.js";
+import Exprify from './core/exprify.js';
 export default Exprify;

package/src/math/bignumber.js

@@ -0,0 +1,31 @@
+import { ExprDecimal } from '../utils/decimal.js';
+
+/**
+ * @param {any} value
+ */
+export function bigNumber(value) {
+  if (ExprDecimal.isDecimal(value)) {
+    return value;
+  }
+  if (typeof value === 'number' || typeof value === 'string' || typeof value === 'bigint') {
+    return new ExprDecimal(value);
+  }
+  throw new Error('bignumber() expects a number, string, or bigint');
+}
+
+/**
+ * @param {unknown} v
+ */
+export function isBigNumber(v) {
+  return ExprDecimal.isDecimal(v);
+}
+
+/**
+ * @param {ExprDecimal} v
+ */
+export function formatBigNumber(v) {
+  if (!ExprDecimal.isDecimal(v)) {
+    return String(v);
+  }
+  return v.toString();
+}

package/src/math/fraction.js

@@ -0,0 +1,112 @@
+const gcd = (/** @type {number} */ a, /** @type {number} */ b) => {
+  a = Math.abs(a);
+  b = Math.abs(b);
+  while (b) {
+    [a, b] = [b, a % b];
+  }
+  return a;
+};
+
+/**
+ * @param {any} n
+ */
+export function fraction(n, d = 1) {
+  if (typeof n !== 'number' || typeof d !== 'number') {
+    throw new Error('Fraction requires numeric arguments');
+  }
+  if (!Number.isInteger(n) || !Number.isInteger(d)) {
+    throw new Error('Fraction requires integer arguments');
+  }
+  if (d === 0) {
+    throw new Error('Fraction denominator cannot be zero');
+  }
+  if (d < 0) {
+    n = -n;
+    d = -d;
+  }
+  const g = gcd(n, d);
+  return { n: n / g, d: d / g };
+}
+
+/**
+ * @param {any} v
+ */
+export function isFraction(v) {
+  return v && typeof v === 'object' && 'n' in v && 'd' in v && !('re' in v) && !('unit' in v);
+}
+
+/**
+ * @param {{ n: number; d: number; }} a
+ * @param {{ d: number; n: number; }} b
+ */
+export function addFrac(a, b) {
+  return fraction(a.n * b.d + b.n * a.d, a.d * b.d);
+}
+
+/**
+ * @param {{ n: number; d: number; }} a
+ * @param {{ d: number; n: number; }} b
+ */
+export function subFrac(a, b) {
+  return fraction(a.n * b.d - b.n * a.d, a.d * b.d);
+}
+
+/**
+ * @param {{ n: number; d: number; }} a
+ * @param {{ n: number; d: number; }} b
+ */
+export function mulFrac(a, b) {
+  return fraction(a.n * b.n, a.d * b.d);
+}
+
+/**
+ * @param {{ n: number; d: number; }} a
+ * @param {{ d: number; n: number; }} b
+ */
+export function divFrac(a, b) {
+  return fraction(a.n * b.d, a.d * b.n);
+}
+
+/**
+ * @param {{ n: number; d: number; }} a
+ * @param {any} exp
+ */
+export function powFrac(a, exp) {
+  if (!Number.isInteger(exp) || exp < 0) {
+    return null;
+  }
+  return fraction(a.n ** exp, a.d ** exp);
+}
+
+/**
+ * @param {{ n: any; }} v
+ */
+export function numer(v) {
+  if (!isFraction(v)) {
+    throw new Error('numer() expects a fraction');
+  }
+  return v.n;
+}
+
+/**
+ * @param {{ d: any; }} v
+ */
+export function denom(v) {
+  if (!isFraction(v)) {
+    throw new Error('denom() expects a fraction');
+  }
+  return v.d;
+}
+
+/**
+ * @param {{ d: number; n: any; }} v
+ */
+export function formatFraction(v) {
+  if (!isFraction(v)) {
+    return String(v);
+  }
+  if (v.d === 1) {
+    return String(v.n);
+  }
+  return `${v.n}/${v.d}`;
+}

package/src/math/operations.js

@@ -1,38 +1,52 @@
-const isValidNumberPair = (a, b) =>
-  (typeof a === typeof b) &&
-  (typeof a === 'number' || typeof a === 'bigint');
+const isValidNumberPair = (/** @type {any} */ a, /** @type {any} */ b) =>
+  typeof a === typeof b && (typeof a === 'number' || typeof a === 'bigint');
 
 export const mathOperations = Object.freeze({
-  power: function(a, b) {
-    if (isValidNumberPair(a, b)) return a ** b;
-    throw new Error("Invalid types for ^");
+  power: function (/** @type {number} */ a, /** @type {number} */ b) {
+    if (isValidNumberPair(a, b)) {
+      return a ** b;
+    }
+    throw new Error('Invalid types for ^');
   },
 
-  multiply: function(a, b) {
-    if (isValidNumberPair(a, b)) return a * b;
-    throw new Error("Invalid types for *");
+  multiply: function (/** @type {number} */ a, /** @type {number} */ b) {
+    if (isValidNumberPair(a, b)) {
+      return a * b;
+    }
+    throw new Error('Invalid types for *');
   },
 
-  divide: function(a, b) {
+  divide: function (/** @type {number} */ a, /** @type {number} */ b) {
     if (isValidNumberPair(a, b)) {
-      if (b === 0) throw new Error("Division by zero");
+      if (b === 0) {
+        throw new Error('Division by zero');
+      }
       return a / b;
     }
-    throw new Error("Invalid types for /");
+    throw new Error('Invalid types for /');
   },
 
-  add: function(a, b) {
-    if (isValidNumberPair(a, b)) return a + b;
-    if (typeof a === 'string' && typeof b === 'string') return a + b;
-    throw new Error("Invalid types for +");
+  add: function (/** @type {string} */ a, /** @type {string} */ b) {
+    if (isValidNumberPair(a, b)) {
+      return a + b;
+    }
+    if (typeof a === 'string' && typeof b === 'string') {
+      return a + b;
+    }
+    throw new Error('Invalid types for +');
   },
-  subtract: function(a, b) {
-    if (isValidNumberPair(a, b)) return a - b;
-    throw new Error("Invalid types for -");
+
+  subtract: function (/** @type {number} */ a, /** @type {number} */ b) {
+    if (isValidNumberPair(a, b)) {
+      return a - b;
+    }
+    throw new Error('Invalid types for -');
   },
 
-  modulus: function(a, b) {
-    if (isValidNumberPair(a, b)) return a % b;
-    throw new Error("Invalid types for %");
-  }
-});
+  modulus: function (/** @type {number} */ a, /** @type {number} */ b) {
+    if (isValidNumberPair(a, b)) {
+      return a % b;
+    }
+    throw new Error('Invalid types for %');
+  },
+});