"use strict"; 'use client'; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = void 0; var _react = _interopRequireWildcard(require("react")); var _card = require("@/components/ui/card"); var _button = require("@/components/ui/button"); var _scrollArea = require("@/components/ui/scroll-area"); var _useLocalStorage = require("@/hooks/use-local-storage"); var _icons = require("lucide-react"); function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); } function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) return obj; if (obj === null || typeof obj !== "object" && typeof obj !== "function") return { default: obj }; var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) return cache.get(obj); var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) Object.defineProperty(newObj, key, desc); else newObj[key] = obj[key]; } } newObj.default = obj; if (cache) cache.set(obj, newObj); return newObj; } /** * Ultimate Transpiled Calculator * - Switchable between Simple and Scientific * - Safe expression parsing (shunting-yard -> RPN evaluate) * - Scientific functions, rad/deg mode, memory, history * - LocalStorage persistence for history and settings * - CommonJS transpiled style (interop helpers) * - React.createElement style (no JSX) * * NOTE: This component expects your project to provide: * - Card, Button, ScrollArea components at "@/components/ui/*" * - useLocalStorage hook at "@/hooks/use-local-storage" * * Buttons are rendered with type="button" to avoid form submit issues. */ /* ------------------------- Expression Parser / Evaluator ------------------------- */ /** * Tokenize expression string into numbers, operators, parentheses, functions, constants */ function tokenize(expr) { var i = 0; var tokens = []; var len = expr.length; function isDigit(ch) { return /\d/.test(ch); } function isAlpha(ch) { return /[a-zA-Zπe]/.test(ch); } function isWhitespace(ch) { return /\s/.test(ch); } while (i < len) { var ch = expr[i]; if (isWhitespace(ch)) { i++; continue; } // numbers (support decimals) if (isDigit(ch) || (ch === '.' && isDigit(expr[i + 1]))) { var num = ch; i++; while (i < len && (isDigit(expr[i]) || expr[i] === '.')) { num += expr[i++]; } tokens.push({ type: 'number', value: parseFloat(num) }); continue; } // multi-char operators or functions / constants if (isAlpha(ch)) { var name = ch; i++; while (i < len && /[a-zA-Z0-9_]/.test(expr[i])) { name += expr[i++]; } // treat π and e as constants if (name === 'pi' || name === 'π') { tokens.push({ type: 'number', value: Math.PI }); } else if (name === 'e') { tokens.push({ type: 'number', value: Math.E }); } else { tokens.push({ type: 'func', value: name.toLowerCase() }); } continue; } // parentheses if (ch === '(' || ch === ')') { tokens.push({ type: 'paren', value: ch }); i++; continue; } // operators and special chars // include unary minus/plus handled in parser by context var twoChar = expr.substr(i, 2); var opCandidates = ['**']; if (opCandidates.indexOf(twoChar) !== -1) { tokens.push({ type: 'op', value: twoChar }); i += 2; continue; } // single char tokens if ('+-*/^%!'.indexOf(ch) !== -1 || ch === ',') { if (ch === '^') tokens.push({ type: 'op', value: '^' }); else if (ch === '%') tokens.push({ type: 'op', value: '%' }); else tokens.push({ type: ch === ',' ? 'comma' : 'op', value: ch }); i++; continue; } // other characters — unknown, skip i++; } return tokens; } /** * Shunting-yard algorithm: convert tokens (infix) -> RPN array * Support functions, unary minus (handled as 'u-'), factorial (!), percent (%) */ function toRPN(tokens) { var out = []; var ops = []; var precedence = { '!': 5, '^': 4, '**': 4, '*': 3, '/': 3, '%': 3, '+': 2, '-': 2, 'u-': 6, // unary minus highest 'u+': 6 }; var rightAssociative = { '^': true, '**': true, 'u-': true, 'u+': true }; function isOperatorToken(t) { return t && t.type === 'op'; } for (var i = 0; i < tokens.length; i++) { var t = tokens[i]; if (t.type === 'number') { out.push(t); continue; } if (t.type === 'func') { ops.push(t); continue; } if (t.type === 'comma') { while (ops.length && ops[ops.length - 1].value !== '(') { out.push(ops.pop()); } continue; } if (t.type === 'op') { var op = t.value; // Determine unary operators: if at start or after another operator or left paren/comma var prev = tokens[i - 1]; var isUnary = false; if (op === '+' || op === '-') { if (!prev || (prev.type === 'op' || (prev.type === 'paren' && prev.value === '(') || prev.type === 'comma' || prev.type === 'func')) { isUnary = true; op = op === '-' ? 'u-' : 'u+'; } } while (ops.length) { var top = ops[ops.length - 1]; if (top.type === 'func') { out.push(ops.pop()); continue; } var topVal = top.value; if (topVal === '(') break; var p1 = precedence[op] || 0; var p2 = precedence[topVal] || 0; if ((rightAssociative[op] && p1 < p2) || (!rightAssociative[op] && p1 <= p2)) { out.push(ops.pop()); continue; } break; } ops.push({ type: 'op', value: op }); continue; } if (t.type === 'paren') { if (t.value === '(') { ops.push({ type: 'paren', value: '(' }); continue; } else { // right paren, pop until left paren while (ops.length && ops[ops.length - 1].value !== '(') { out.push(ops.pop()); } // pop left paren if (ops.length && ops[ops.length - 1].value === '(') { ops.pop(); } // if function on top, pop it too if (ops.length && ops[ops.length - 1].type === 'func') { out.push(ops.pop()); } continue; } } } while (ops.length) { var op2 = ops.pop(); if (op2.value === '(' || op2.value === ')') { // mismatched paren — skip continue; } out.push(op2); } return out; } /** * Evaluate RPN tokens, with support for functions and modes (deg/rad) */ function evalRPN(rpn, opts) { opts = opts || {}; var mode = opts.mode || 'deg'; // 'deg' or 'rad' var stack = []; function toNumber(v) { if (typeof v === 'number') return v; var n = parseFloat(v); if (Number.isNaN(n)) throw new Error('Invalid number'); return n; } function applyFunc(name, arg) { var a = toNumber(arg); switch (name) { case 'sin': return mode === 'deg' ? Math.sin(a * Math.PI / 180) : Math.sin(a); case 'cos': return mode === 'deg' ? Math.cos(a * Math.PI / 180) : Math.cos(a); case 'tan': return mode === 'deg' ? Math.tan(a * Math.PI / 180) : Math.tan(a); case 'asin': return mode === 'deg' ? Math.asin(a) * 180 / Math.PI : Math.asin(a); case 'acos': return mode === 'deg' ? Math.acos(a) * 180 / Math.PI : Math.acos(a); case 'atan': return mode === 'deg' ? Math.atan(a) * 180 / Math.PI : Math.atan(a); case 'sqrt': return Math.sqrt(a); case 'ln': return Math.log(a); case 'log': return Math.log10 ? Math.log10(a) : Math.log(a) / Math.LN10; case 'abs': return Math.abs(a); case 'floor': return Math.floor(a); case 'ceil': return Math.ceil(a); case 'round': return Math.round(a); default: throw new Error('Unknown function: ' + name); } } function factorial(n) { n = Math.floor(n); if (n < 0) throw new Error('Factorial of negative'); if (n === 0 || n === 1) return 1; var res = 1; for (var i = 2; i <= n; i++) res *= i; return res; } for (var i = 0; i < rpn.length; i++) { var t = rpn[i]; if (t.type === 'number') { stack.push(t.value); continue; } if (t.type === 'func') { if (stack.length < 1) throw new Error('Insufficient args for func ' + t.value); var arg = stack.pop(); stack.push(applyFunc(t.value, arg)); continue; } if (t.type === 'op') { var op = t.value; if (op === 'u-' || op === 'u+') { if (stack.length < 1) throw new Error('Insufficient args for unary'); var v = stack.pop(); stack.push(op === 'u-' ? -toNumber(v) : toNumber(v)); continue; } if (op === '!') { if (stack.length < 1) throw new Error('Insufficient args for !'); var v2 = stack.pop(); stack.push(factorial(v2)); continue; } if (op === '%') { if (stack.length < 1) throw new Error('Insufficient args for %'); var pct = stack.pop(); stack.push(toNumber(pct) / 100); continue; } // binary operators if (stack.length < 2) throw new Error('Insufficient args for binary op'); var b = toNumber(stack.pop()); var a2 = toNumber(stack.pop()); switch (op) { case '+': stack.push(a2 + b); break; case '-': stack.push(a2 - b); break; case '*': stack.push(a2 * b); break; case '/': stack.push(b === 0 ? (function () { throw new Error('Division by zero'); })() : a2 / b); break; case '^': case '**': stack.push(Math.pow(a2, b)); break; default: throw new Error('Unknown op ' + op); } continue; } // else ignore } if (stack.length !== 1) { throw new Error('Invalid expression'); } return stack[0]; } /* ------------------------- UI + Logic Component ------------------------- */ var SIMPLE_BUTTONS = ['7', '8', '9', '÷', '4', '5', '6', '×', '1', '2', '3', '-', '0', '.', '=', '+']; var SCI_BUTTONS = [ 'sin', 'cos', 'tan', '(', ')', 'ln', 'log', '√', 'x^2', 'x^y', '7', '8', '9', '÷', '4', '5', '6', '×', '1', '2', '3', '-', '0', '.', '%', '+', 'π', 'e', '!', '=', 'ANS' ]; // Utility to map display label -> insertion token function labelToToken(label) { if (label === '×') return '*'; if (label === '÷') return '/'; if (label === 'x^2') return '^2'; if (label === 'x^y') return '^'; if (label === '√') return 'sqrt'; if (label === 'π') return 'pi'; if (label === 'ANS') return 'ANS'; return label; } function UltimateCalculator() { // Core states var _useLocalStorage2 = (0, _useLocalStorage.useLocalStorage)("ultimate-calculator-history-v1", []), history = _useLocalStorage2[0], setHistory = _useLocalStorage2[1]; var _useLocalStorage3 = (0, _useLocalStorage.useLocalStorage)("ultimate-calculator-mode-v1", "simple"), mode = _useLocalStorage3[0], setMode = _useLocalStorage3[1]; var _useLocalStorage4 = (0, _useLocalStorage.useLocalStorage)("ultimate-calculator-ans-v1", "0"), lastAns = _useLocalStorage4[0], setLastAns = _useLocalStorage4[1]; var _useLocalStorage5 = (0, _useLocalStorage.useLocalStorage)("ultimate-calculator-memory-v1", 0), memory = _useLocalStorage5[0], setMemory = _useLocalStorage5[1]; var _useLocalStorage6 = (0, _useLocalStorage.useLocalStorage)("ultimate-calculator-mode-deg-rad-v1", "deg"), angleMode = _useLocalStorage6[0], setAngleMode = _useLocalStorage6[1]; var _useLocalStorage7 = (0, _useLocalStorage.useLocalStorage)("ultimate-calculator-display-v1", "0"), display = _useLocalStorage7[0], setDisplay = _useLocalStorage7[1]; var inputRef = (0, _react.useRef)(null); // Helper to push history safely (limit 100) function pushHistory(entry) { setHistory(function (prev) { var next = [entry].concat(prev || []); if (next.length > 100) next = next.slice(0, 100); return next; }); } // Reset calculator state function clearAll() { setDisplay('0'); } // Evaluate expression string using parser function evaluateExpression(expr) { if (!expr || expr.trim() === '') return ''; try { // replace ANS token if present var replaced = expr.replace(/ANS/g, String(lastAns)); // a few convenience replacements: // '^2' -> '^ 2' handled by parsing as power operator sequence; convert 'x^2' earlier // replace unicode pi with 'pi' replaced = replaced.replace(/π/g, 'pi'); // normalize unary minus for tokenization will be handled by parser var tokens = tokenize(replaced); var rpn = toRPN(tokens); var result = evalRPN(rpn, { mode: angleMode }); // round small floating point noise if (typeof result === 'number' && !Number.isInteger(result)) { result = Number(result.toPrecision(12)); } return result; } catch (err) { return 'Error'; } } // Handle button clicks in both modes function handleButton(label) { var tokenLabel = labelToToken(label); // Special buttons and operations if (label === 'AC') { clearAll(); return; } if (label === 'C') { clearAll(); return; } if (label === 'ANS') { // insert last answer literal setDisplay(function (prev) { return (prev === '0' ? String(lastAns) : prev + String(lastAns)); }); return; } if (label === 'MC') { setMemory(0); return; } if (label === 'MR') { setDisplay(function (prev) { return (prev === '0' ? String(memory) : prev + String(memory)); }); return; } if (label === 'M+') { try { var calcVal = evaluateExpression(display); if (calcVal !== 'Error') setMemory(function (m) { return Number(m) + Number(calcVal); }); } catch (e) {} return; } if (label === 'M-') { try { var calcVal2 = evaluateExpression(display); if (calcVal2 !== 'Error') setMemory(function (m) { return Number(m) - Number(calcVal2); }); } catch (e) {} return; } // Mode-specific: scientific special tokens if (mode === 'scientific') { // functions var funcs = ['sin','cos','tan','asin','acos','atan','ln','log','sqrt']; if (funcs.indexOf(tokenLabel) !== -1) { // append function with parenthesis for ease: e.g., sin( -> user can type inside or append ) setDisplay(function (prev) { return (prev === '0' ? tokenLabel + '(' : prev + tokenLabel + '('); }); return; } if (tokenLabel === '^2') { // append ^2 to previous token setDisplay(function (prev) { return (prev === '0' ? '0^2' : prev + '^2'); }); return; } if (tokenLabel === '%') { setDisplay(function (prev) { return (prev === '0' ? '0%' : prev + '%'); }); return; } if (tokenLabel === '!') { setDisplay(function (prev) { return (prev === '0' ? '0!' : prev + '!'); }); return; } if (tokenLabel === 'pi') { setDisplay(function (prev) { return (prev === '0' ? String(Math.PI) : prev + String(Math.PI)); }); return; } if (tokenLabel === 'e') { setDisplay(function (prev) { return (prev === '0' ? String(Math.E) : prev + String(Math.E)); }); return; } } // Equals if (label === '=' || label === 'ENTER') { var result = evaluateExpression(display); if (result === 'Error') { setDisplay('Error'); } else { pushHistory(display + " = " + String(result)); setLastAns(String(result)); setDisplay(String(result)); } return; } // parentheses and decimal and digits and operators // map label to raw insert token var insertion = tokenLabel; // decimal / digit handling if (!isNaN(insertion) || insertion === '.') { // append cleanly setDisplay(function (prev) { if (prev === 'Error') return insertion === '.' ? '0.' : String(insertion); if (prev === '0' && insertion !== '.') return String(insertion); // prevent multiple decimals in current numeric token // find last token after last operator or paren var m = prev.match(/([0-9.]+)$/); if (insertion === '.' && m && m[0].indexOf('.') !== -1) { return prev; } return prev + insertion; }); return; } // operators var operatorMap = { '+': '+', '-': '-', '*': '*', '/': '/', '^': '^' }; if (operatorMap[insertion]) { setDisplay(function (prev) { if (prev === 'Error') return insertion; // avoid double operator (replace last operator) if (/[+\-*/^]$/.test(prev)) { return prev.slice(0, -1) + insertion; } return prev + insertion; }); return; } // parentheses and comma if (insertion === '(' || insertion === ')') { setDisplay(function (prev) { return (prev === '0' && insertion === '(' ? '(' : prev + insertion); }); return; } // fallback: append label text setDisplay(function (prev) { return (prev === '0' ? String(label) : prev + String(label)); }); } // UI helpers function toggleMode() { setMode(function (m) { return m === 'simple' ? 'scientific' : 'simple'; }); } function toggleAngleMode() { setAngleMode(function (m) { return m === 'deg' ? 'rad' : 'deg'; }); } function clearHistory() { setHistory([]); } // Precompute buttons for active mode var buttons = mode === 'simple' ? SIMPLE_BUTTONS.slice(0) : SCI_BUTTONS.slice(0); // Additional action row for memory and mode controls var actionRow = [ { label: 'AC', className: 'destructive' }, { label: 'MC' }, { label: 'MR' }, { label: 'M+' }, { label: 'M-' }, { label: 'Mode' } // toggles simple/scientific ]; // Render return _react.default.createElement("div", { className: "flex flex-col md:flex-row gap-6 w-full max-w-4xl mx-auto items-start p-3" }, // Left: Calculator area _react.default.createElement(_card.Card, { className: "flex-1 shadow-lg" }, _react.default.createElement(_card.CardHeader, null, _react.default.createElement("div", { className: "flex items-center justify-between gap-2 w-full" }, _react.default.createElement("div", { className: "bg-muted text-right p-4 rounded-lg text-4xl font-mono break-all w-full transition-colors" }, display), _react.default.createElement("div", { className: "flex flex-col items-end gap-2 ml-4" }, _react.default.createElement("div", { className: "text-sm text-muted-foreground" }, mode === 'simple' ? 'Simple' : 'Scientific'), _react.default.createElement("div", { className: "flex items-center gap-2" }, _react.default.createElement(_button.Button, { type: "button", variant: "ghost", onClick: toggleMode, className: "h-9" }, mode === 'simple' ? _react.default.createElement(_icons.ToggleRight, { className: "h-5 w-5" }) : _react.default.createElement(_icons.ToggleLeft, { className: "h-5 w-5" })), mode === 'scientific' && _react.default.createElement(_button.Button, { type: "button", variant: "outline", onClick: toggleAngleMode, className: "h-9 text-sm" }, angleMode === 'deg' ? 'DEG' : 'RAD') ) ) ) ), _react.default.createElement(_card.CardContent, null, // Actions row _react.default.createElement("div", { className: "grid grid-cols-6 gap-2 mb-3" }, actionRow.map(function (act) { if (act.label === 'Mode') { return _react.default.createElement(_button.Button, { key: 'mode', type: "button", onClick: toggleMode, variant: "secondary", className: "col-span-2" }, mode === 'simple' ? 'Switch to Scientific' : 'Switch to Simple'); } return _react.default.createElement(_button.Button, { key: act.label, type: "button", onClick: function () { return handleButton(act.label); }, variant: act.className === 'destructive' ? 'destructive' : 'outline', className: "h-9" }, act.label); }) ), // Buttons grid _react.default.createElement("div", { className: "grid grid-cols-4 gap-2" }, buttons.map(function (btnLabel, idx) { // make label prettier and map to token when needed var displayLabel = btnLabel; var btnClass = "text-lg md:text-xl h-14"; // special styling for "=" if (displayLabel === '=') btnClass += " bg-gradient-to-b from-indigo-500 to-indigo-600 text-white col-span-1"; return _react.default.createElement(_button.Button, { key: String(idx) + "-" + displayLabel, type: "button", onClick: function () { return handleButton(displayLabel); }, variant: /[+\-×÷^*/=!]/.test(displayLabel) ? "default" : "outline", className: btnClass }, displayLabel); }) ) ) ), // Right: History panel _react.default.createElement(_card.Card, { className: "md:w-80 w-full shrink-0 shadow-md" }, _react.default.createElement(_card.CardHeader, null, _react.default.createElement(_card.CardTitle, null, "History") ), _react.default.createElement(_card.CardContent, { className: "p-0" }, _react.default.createElement(_scrollArea.ScrollArea, { className: "h-80" }, _react.default.createElement("div", { className: "p-4 space-y-2" }, (history && history.length > 0) ? history.map(function (item, index) { return _react.default.createElement("div", { key: index, className: "text-sm text-muted-foreground border-b pb-1" }, item); }) : _react.default.createElement("p", { className: "text-sm text-center text-muted-foreground pt-10" }, "No history yet.") ) ) ), _react.default.createElement(_card.CardFooter, { className: "pt-4" }, history && history.length > 0 && _react.default.createElement(_button.Button, { type: "button", variant: "outline", className: "w-full", onClick: clearHistory }, "Clear History") ) ) ); } var _default = exports.default = UltimateCalculator;

Simple Calculator