@flickfyi/flkr 0.0.140 → 0.0.146

package/node_modules/@flickfyi/core/src/kowalski/calculator.ts

@@ -0,0 +1,243 @@
+import { Decimal } from 'decimal.js'
+
+import type { KowalskiProps, KowalskiState } from './catalog'
+import { format } from './format'
+
+type CalculatorState = KowalskiState<'calculator'>['calculation']
+type CalculatorOperator = KowalskiProps<'calculator'>['operator']
+export type CalculatorKey =
+	| '0'
+	| '1'
+	| '2'
+	| '3'
+	| '4'
+	| '5'
+	| '6'
+	| '7'
+	| '8'
+	| '9'
+	| CalculatorOperator
+	| '.'
+	| '='
+	| '%'
+	| 'backspace'
+	| 'clear'
+	| 'sign'
+
+const CalculatorNumber = Decimal.clone({ precision: 12, toExpPos: 12 })
+
+export const calculatorKeys = [
+	'clear',
+	'sign',
+	'%',
+	'/',
+	'7',
+	'8',
+	'9',
+	'*',
+	'4',
+	'5',
+	'6',
+	'-',
+	'1',
+	'2',
+	'3',
+	'+',
+	'backspace',
+	'0',
+	'.',
+	'=',
+] satisfies CalculatorKey[]
+
+export function initialCalculator({
+	left,
+	operator,
+	right,
+}: Pick<KowalskiProps<'calculator'>, 'left' | 'operator' | 'right'>): CalculatorState {
+	const result = calculate(left, operator, right)
+	return {
+		entry: result === null ? 'Error' : new CalculatorNumber(result).toString(),
+		left,
+		operator,
+		overwrite: true,
+		phase: result === null ? 'error' : 'result',
+		right,
+	}
+}
+
+/** One complete JSON replacement keeps the pending operation and its entry together. */
+export function pressCalculatorKey(
+	state: CalculatorState,
+	key: CalculatorKey
+): CalculatorState {
+	if (
+		key === 'clear' ||
+		(key === 'backspace' && (state.phase === 'result' || state.phase === 'error'))
+	) {
+		return clearLabel(state) === 'C'
+			? { ...state, entry: '0', overwrite: false }
+			: { entry: '0', left: 0, operator: '+', overwrite: false, phase: 'left', right: 0 }
+	}
+	if (key === 'backspace') {
+		const shortened = state.overwrite ? '' : state.entry.slice(0, -1)
+		return {
+			...state,
+			entry: !shortened || shortened === '-' ? '0' : shortened,
+			overwrite: false,
+			phase: state.phase === 'operator' ? 'right' : state.phase,
+		}
+	}
+	if (key === '+' || key === '-' || key === '*' || key === '/') {
+		if (state.phase === 'error') {
+			return state
+		}
+		const result =
+			state.phase === 'right'
+				? calculate(state.left, state.operator, Number(state.entry))
+				: Number(state.entry)
+		if (result === null) {
+			return { ...state, entry: 'Error', phase: 'error', right: Number(state.entry) }
+		}
+		return {
+			...state,
+			entry: new CalculatorNumber(result).toString(),
+			left: result,
+			operator: key,
+			overwrite: true,
+			phase: 'operator',
+			right: 0,
+		}
+	}
+	if (key === '=') {
+		if (state.phase === 'left' || state.phase === 'error') {
+			return state
+		}
+		const left = state.phase === 'result' ? Number(state.entry) : state.left
+		const right =
+			state.phase === 'operator'
+				? left
+				: state.phase === 'result'
+					? state.right
+					: Number(state.entry)
+		return initialCalculator({ left, operator: state.operator, right })
+	}
+	if (key === 'sign' || key === '%') {
+		if (state.phase === 'error') {
+			return state
+		}
+		const phase = state.phase === 'operator' || state.phase === 'right' ? 'right' : 'left'
+		const entry = state.phase === 'operator' ? '0' : state.entry
+		if (key === 'sign') {
+			return {
+				...state,
+				entry: entry.startsWith('-') ? entry.slice(1) : `-${entry}`,
+				overwrite: state.phase === 'operator' ? false : state.overwrite,
+				phase,
+			}
+		}
+		const percent = new CalculatorNumber(entry).div(100)
+		const value =
+			phase === 'right' && (state.operator === '+' || state.operator === '-')
+				? percent.times(state.left)
+				: percent
+		return Number.isFinite(value.toNumber())
+			? {
+					...state,
+					entry: new CalculatorNumber(value.toNumber()).toString(),
+					overwrite: true,
+					phase,
+				}
+			: { ...state, entry: 'Error', phase: 'error' }
+	}
+	const phase = state.phase === 'operator' || state.phase === 'right' ? 'right' : 'left'
+	const fresh = state.overwrite || (state.phase !== 'left' && state.phase !== 'right')
+	const entry = fresh ? '0' : state.entry
+	if (
+		(key === '.' && entry.includes('.')) ||
+		(key !== '.' && entry.replaceAll(/\D/g, '').length >= 12)
+	) {
+		return state
+	}
+	const next =
+		key === '.'
+			? `${entry}.`
+			: entry === '0'
+				? key
+				: entry === '-0'
+					? `-${key}`
+					: `${entry}${key}`
+	return {
+		...(phase === 'left' && fresh ? { left: 0, operator: '+', right: 0 } : state),
+		entry: next,
+		overwrite: false,
+		phase,
+	}
+}
+
+export function calculatorKeyLabel(state: CalculatorState, key: CalculatorKey) {
+	return key === 'clear'
+		? clearLabel(state)
+		: key === 'backspace'
+			? '⌫'
+			: key === 'sign'
+				? '±'
+				: key === '*'
+					? '×'
+					: key === '/'
+						? '÷'
+						: key === '-'
+							? '−'
+							: key
+}
+
+export function calculatorEquation(state: CalculatorState) {
+	if (state.phase === 'left') {
+		return ' '
+	}
+	const left = calculatorDisplay(new CalculatorNumber(state.left).valueOf())
+	const operator = calculatorKeyLabel(state, state.operator)
+	return state.phase === 'result' || state.phase === 'error'
+		? `${left} ${operator} ${calculatorDisplay(new CalculatorNumber(state.right).valueOf())} =`
+		: `${left} ${operator}`
+}
+
+/** Presentation only: the keypad and Quantum keep the exact canonical entry. */
+export function calculatorDisplay(entry: string) {
+	if (entry === 'Error') {
+		return entry
+	}
+	const value = new CalculatorNumber(entry)
+	if (value.e >= 12 || value.e < -12) {
+		return format.formatNumber(value.toNumber(), {
+			maximumSignificantDigits: 12,
+			notation: 'scientific',
+		})
+	}
+	const decimal = entry.includes('e') ? value.toFixed(value.decimalPlaces()) : entry
+	return (
+		format.formatNumber(Number(decimal), {
+			maximumFractionDigits: 100,
+			minimumFractionDigits: decimal.split('.')[1]?.length ?? 0,
+		}) + (decimal.endsWith('.') ? '.' : '')
+	)
+}
+
+function clearLabel(state: CalculatorState) {
+	return (state.phase === 'left' || state.phase === 'right') && state.entry !== '0'
+		? 'C'
+		: 'AC'
+}
+
+function calculate(left: number, operator: CalculatorOperator, right: number) {
+	const value = new CalculatorNumber(left)
+	const result =
+		operator === '+'
+			? value.plus(right)
+			: operator === '-'
+				? value.minus(right)
+				: operator === '*'
+					? value.times(right)
+					: value.div(right)
+	const number = result.toNumber()
+	return Number.isFinite(number) ? number : null
+}