exprify 1.0.1 → 1.0.2

package/src/utils/store.js

@@ -1,178 +0,0 @@
-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

@@ -1,75 +0,0 @@
-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/test/browser.html

@@ -1,23 +0,0 @@
-<script src="../dist/exprify.js"></script>
-<script>
-  const expr = new Exprify();   // ✅ no namespace needed (usually)
-  // console.log(expr.parse("5 + 7 * 2")); // 19
-  // console.log(expr.evaluate("5 + 7 * 2")); // 19
-  console.log(expr.parse("max(5, 2)")); // 19
-  // console.log(expr.evaluate("max('5' + 7 * 2)")); // 19
-
-
-// const exprify = new Exprify();
-// const exprFn = exprify.compile("or(a, b)");
-// console.log(exprFn({ a: true, b: false })); // 22
-// console.log(exprFn({ a: 7, b: 3 }));  // 17
-
-console.log(expr.parse("5 px to em")); // 19
-console.log(expr.evaluate("5 px to em")); // 19
-
-// console.log(expr.parse("value |> double |> sqrt")); // 19
-// console.log(expr.evaluate("value |> double |> sqrt")); // 19
-
-
-  
-</script>

package/test/exprify.test.js

@@ -1,140 +0,0 @@
-import Exprify from "../src/core/Exprify.js";
-
-describe("Exprify Engine - Extended Tests", () => {
-  let expr;
-
-  beforeEach(() => {
-    expr = new Exprify();
-  });
-
-  /* ================= BASIC ================= */
-  test("addition", () => {
-    expect(expr.evaluate("2 + 3 + 5")).toBe(10);
-  });
-
-  test("operator precedence", () => {
-    expect(expr.evaluate("2 + 3 * 4")).toBe(14);
-  });
-
-  test("parentheses override precedence", () => {
-    expect(expr.evaluate("(2 + 3) * 4")).toBe(20);
-  });
-
-  test("mixed parentheses", () => {
-    expect(expr.evaluate("(1 + 2) * (3 + 4)")).toBe(21);
-  });
-
-  /* ================= NESTED ================= */
-  test("nested parentheses", () => {
-    expect(expr.evaluate("((2 + 3) * (4 + 1))")).toBe(25);
-  });
-
-  test("deep nesting", () => {
-    expect(expr.evaluate("(((1 + 1) + 1) + 1)")).toBe(4);
-  });
-
-  /* ================= UNARY ================= */
-  test("unary minus", () => {
-    expect(expr.evaluate("-5 + 10")).toBe(5);
-  });
-
-  test("double unary", () => {
-    expect(expr.evaluate("--5")).toBe(5);
-  });
-
-  /* ================= POWER ================= */
-  test("power operator", () => {
-    expect(expr.evaluate("2 ^ 3")).toBe(8);
-  });
-
-  test("power precedence", () => {
-    expect(expr.evaluate("2 + 2 ^ 3")).toBe(10);
-  });
-
-  /* ================= LOGICAL ================= */
-  test("logical AND", () => {
-    expect(expr.evaluate("true && false")).toBe(false);
-  });
-
-  test("logical OR", () => {
-    expect(expr.evaluate("true || false")).toBe(true);
-  });
-
-  /* ================= FUNCTION ================= */
-  test("function call", () => {
-    expect(expr.evaluate("max(2, 5, 3)")).toBe(5);
-  });
-
-  test("nested function", () => {
-    expect(expr.evaluate("max(2, min(5, 3))")).toBe(3);
-  });
-
-  test("matrix determinant with semicolon rows", () => {
-    expect(expr.evaluate("det([-1, 2; 3, 1])")).toBe(-7);
-  });
-
-  /* ================= STRING ================= */
-  test("string concat", () => {
-    expect(expr.evaluate('"Hello " + "World"')).toBe("Hello World");
-  });
-
-  /* ================= BIGINT ================= */
-  test("bigint power", () => {
-    expect(expr.evaluate("11n ^ 2n")).toBe(121n);
-  });
-
-  /* ================= UNIT ================= */
-  test("unit conversion", () => {
-    expect(expr.evaluate("2 inch to cm")).toBe("5.08 cm");
-  });
-
-  test("unit addition", () => {
-    expect(expr.evaluate("5 cm + 2 inch")).toBe("10.08 cm");
-  });
-
-  /* ================= EDGE CASE ================= */
-  test("division", () => {
-    expect(expr.evaluate("10 / 2")).toBe(5);
-  });
-
-  test("modulus", () => {
-    expect(expr.evaluate("10 % 3")).toBe(1);
-  });
-
-  test("invalid expression", () => {
-    expect(() => expr.evaluate("(2 + 3")).toThrow();
-  });
-
-  
-  test("set and use variable", () => {
-    expr.setVariable("x", 5);
-    expr.setVariable("y", 3);
-    expect(expr.evaluate("x + y")).toBe(8);
-    expect(expr.evaluate("x * y + 2")).toBe(17); // 5*3=15 +2=17
-  });
-
-    test("variable in parentheses", () => {
-    expr.setVariable("a", 2);
-    expr.setVariable("b", 4);
-    expect(expr.evaluate("(a + b) * 3")).toBe(18); // (2+4)*3=18
-  });
-
-  test("add and use external function", () => {
-    // Example: double(n) returns n*2
-    expr.addFunction("double", (n) => n * 2);
-    expect(expr.evaluate("double(4)")).toBe(8);
-    expect(expr.evaluate("2 + double(5)")).toBe(12); // 2+10=12
-  });
-
-  test("external function with multiple arguments", () => {
-    expr.addFunction("sumThree", (a, b, c) => a + b + c);
-    expect(expr.evaluate("sumThree(2, 3, 5)")).toBe(10);
-  });
-
-  test("nested function calls", () => {
-    expr.addFunction("double", (n) => n * 2);
-    expr.addFunction("addTen", (n) => n + 10);
-    expect(expr.evaluate("addTen(double(5))")).toBe(20); // double(5)=10 → addTen(10)=20
-  });
-  
-});