exprify 1.0.2 → 1.0.3

package/src/utils/store.js

@@ -0,0 +1,178 @@
+export function createUnitsStore(initial = {}) {
+  let units = { ...initial};
+
+  // ---------- Helpers ----------
+
+  function getAllUnitsFlat() {
+    const result = new Set();
+
+    for (const type in units) {
+      for (const key in units[type]) {
+        const u = units[type][key];
+
+        const keyLower = key.toLowerCase();
+        result.add(keyLower);
+
+        // Unit name
+        if (u.unit) {
+          const unitLower = u.unit.toLowerCase();
+
+          // Avoid duplicate like "m" vs "meter"
+          if (unitLower !== keyLower) {
+            // Optional: only single-word units
+            if (unitLower.split(/\s+/).length === 1) {
+              result.add(unitLower);
+            }
+          }
+        }
+
+        // Symbol
+        if (u.symbol) {
+          const symbolLower = u.symbol.toLowerCase();
+
+          // Avoid duplicate with unit name
+          if (!u.unit || symbolLower !== u.unit.toLowerCase()) {
+            result.add(symbolLower);
+          }
+        }
+      }
+    }
+
+    return Array.from(result);
+  }
+
+  function findUnit(input) {
+    input = input.toLowerCase();
+
+    for (const type in units) {
+      for (const key in units[type]) {
+        const u = units[type][key];
+
+        if (
+          key.toLowerCase() === input ||
+          u.unit?.toLowerCase() === input ||
+          u.symbol?.toLowerCase() === input
+        ) {
+          return { type, key , data: u};
+        }
+      }
+    }
+
+    return null;
+  }
+
+  // ---------- Core Convert ----------
+
+  function convert(value, fromUnit, toUnit) {
+      const from = findUnit(fromUnit);
+      const to = findUnit(toUnit);
+
+      if (!from) throw new Error(`Unknown unit: ${fromUnit}`);
+      if (!to) throw new Error(`Unknown unit: ${toUnit}`);
+
+      if (from.type !== to.type) {
+        throw new Error(`Cannot convert ${fromUnit} to ${toUnit} (${to.data.unit || to.key}). ${from.data.unit || from.key} conversion units like ${Object.keys(units[from.type]).join(", ")}`);
+      }
+
+      const result = value * (from.data.value / to.data.value);
+
+      return { value: result, unit: to.key };
+    }
+
+  // ---------- Public API ----------
+
+  return {
+    // Get all units
+    getUnits: () => units,
+
+    // Replace all units
+    setUnits: (newUnits) => {
+      units = { ...newUnits };
+    },
+
+    // Update single type
+    updateType: (type, data) => {
+      units[type] = { ...units[type], ...data };
+    },
+
+    // Add new unit
+    addUnit: (type, key, unitObj) => {
+      if (!units[type]) units[type] = {};
+      units[type][key] = unitObj;
+    },
+    compute(op, left, right) {
+
+      const isUnit = (v) =>
+        v && typeof v === "object" && "value" in v && "unit" in v;
+
+      const apply = (a, b) => {
+        switch (op) {
+          case "+": return a + b;
+          case "-": return a - b;
+          case "*": return a * b;
+          case "/": return a / b;
+          case "%": return a % b;
+          case "^": return Math.pow(a, b);
+        }
+      };
+
+      // BOTH UNIT
+      if (isUnit(left) && isUnit(right)) {
+
+        const from = this.findUnit(right.unit);
+        const to = this.findUnit(left.unit);
+
+        if (from.type !== to.type) {
+          throw new Error(`Cannot operate on different unit types`);
+        }
+
+        // convert right → left unit
+        const r = right.value * (from.data.value / to.data.value);
+
+        const result = apply(left.value, r);
+
+        // multiplication/division produce compound units
+        if (op === "*") {
+          return { value: result, unit: left.unit };
+        }
+
+        if (op === "/") {
+          return { value: result, unit: left.unit };
+        }
+
+        if (op === "^") {
+          return { value: result, unit: left.unit };
+        }
+
+        return { value: result, unit: left.unit };
+      }
+
+      // ================= LEFT UNIT =================
+      if (isUnit(left) && !isUnit(right)) {
+        const result = apply(left.value, right);
+
+        return { value: result, unit: left.unit };
+      }
+
+      // ================= RIGHT UNIT =================
+      if (!isUnit(left) && isUnit(right)) {
+        const result = apply(left, right.value);
+
+        if (op === "/") {
+          return { value: result, unit: right.unit };
+        }
+
+        return { value: result, unit: right.unit };
+      }
+
+      // ================= NORMAL =================
+      return apply(left, right);
+    },
+    // Convert
+    convert,
+
+    // Search helpers
+    getAllUnitsFlat,
+    findUnit
+  };
+}

package/src/variables/store.js

@@ -0,0 +1,75 @@
+const validVarName = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/;
+
+export function createVarStore(initial = {}) {
+  let store = Object.create(null);
+  
+
+  for (const key in initial) {
+    store[key] = initial[key];
+  }
+
+  return {
+    set(name, value, { override = true } = {}) {
+
+      // Name validation
+      if (typeof name !== "string" || !name) {
+        throw new Error("Variable name must be a non-empty string");
+      }
+
+      if (!validVarName.test(name)) {
+        throw new Error(`Variable Name Error: '${name}' is not a valid variable name`);
+      }
+
+      // Value validation
+      if (value === undefined) {
+        throw new Error(`Variable Value Error: '${name}' cannot be undefined`);
+      }
+
+      // Prevent overwrite (optional)
+      if (!override && name in variablesDB) {
+        throw new Error(`Variable '${name}' already exists`);
+      }
+
+      store[name] = value;
+    },
+
+    //get variable
+    get(name) {
+      return store[name];
+    },
+
+    // check existence
+    has(name) {
+      return Object.prototype.hasOwnProperty.call(store, name);
+    },
+
+    // remove variable
+    remove(name) {
+      delete store[name];
+    },
+
+    // get all variables (snapshot)
+    all() {
+      return { ...store };
+    },
+
+    // clear all
+    clear() {
+      store = Object.create(null);
+    },
+
+    // merge multiple variables
+    merge(obj = {}) {
+      for (const key in obj) {
+        store[key] = obj[key];
+      }
+    },
+
+    // clone store (for scoped instances) 
+    clone() {
+      return createVarStore(store);
+    }
+  };
+}
+
+export default { createVarStore };

package/docs/README.md

@@ -1,34 +0,0 @@
----
-layout: default
-title: Exprify Docs
----
-
-# Exprify Docs
-
-Exprify is a JavaScript expression parser and evaluator for math-heavy apps.
-
-## Highlights
-
-- arithmetic, precedence, bigint, and booleans
-- variables, assignments, and inline functions
-- unit conversion
-- matrices and linear algebra helpers
-- complex numbers
-- symbolic helpers like `simplify`, `derivative`, and `rationalize`
-
-## Quick Example
-
-```js
-import Exprify from "exprify";
-
-const expr = new Exprify();
-
-expr.evaluate("hyp(a, b) = sqrt(a ^ 2 + b ^ 2)");
-console.log(expr.evaluate("hyp(3, 4)"));
-// 5
-```
-
-## References
-
-- [Project README](../README.md)
-- [Token Type Notes](./tokenType.txt)

package/docs/assets/css/style.scss

@@ -1,4 +0,0 @@
----
----
-
-@import "jekyll-theme-primer";

package/docs/tokenType.txt

@@ -1,21 +0,0 @@
-Token notes for Exprify
-
-- Number
-- BigInt
-- Boolean
-- String
-- Identifier
-- Function
-- Operator
-- UnaryOperator
-- Keyword
-- Unit
-- NumberWithUnit
-- ImaginaryLiteral
-- Parenthesis
-- ArrayStart / ArrayEnd
-- BlockStart / BlockEnd
-- Comma
-- Semicolon
-- Colon
-- Dot