ember-mug 0.1.3

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,106 @@
+# Ember Mug CLI
+
+[![npm version](https://badge.fury.io/js/ember-mug.svg)](https://www.npmjs.com/package/ember-mug)
+[![CI](https://github.com/singerbj/ember-cli/actions/workflows/ci.yml/badge.svg)](https://github.com/singerbj/ember-cli/actions/workflows/ci.yml)
+
+A TypeScript CLI application for controlling Ember mugs, built with [Ink](https://github.com/vadimdemedes/ink) (React for CLIs).
+
+## Installation
+
+### Global Installation (Recommended)
+
+```bash
+npm install -g ember-mug
+```
+
+Then run:
+
+```bash
+ember-mug
+```
+
+### Run with npx (No Installation)
+
+```bash
+npx ember-mug
+```
+
+### Local Development
+
+```bash
+git clone https://github.com/singerbj/ember-cli.git
+cd ember-cli
+npm install
+npm run dev
+```
+
+## Features
+
+- **Temperature Control**: View current temperature and adjust target temperature
+- **Temperature Presets**: Quick-select from predefined temperature presets (Latte, Coffee, Tea)
+- **Battery Monitoring**: Real-time battery level with estimated battery life
+- **Time Estimates**:
+  - Estimated time to reach target temperature
+  - Estimated battery life based on current mug state
+- **LED Color Control**: Customize your mug's LED color with presets or custom RGB values
+- **Temperature Unit Toggle**: Switch between Celsius and Fahrenheit
+- **Persistent Settings**: Your preferences are saved between sessions
+
+## Controls
+
+### When Disconnected
+- `s` - Start scanning for Ember mug
+- `r` - Retry scanning (after error)
+- `q` - Quit
+
+### When Connected
+- `t` - Enter temperature adjustment mode
+  - `←/→` or `h/l` - Adjust by ±0.5°
+  - `↑/↓` or `j/k` - Adjust by ±1°
+  - `t` or `Enter` - Exit temperature mode
+- `1-3` - Select temperature preset
+- `c` - Toggle LED color control
+  - `1-8` - Select preset color
+  - `c` - Toggle custom color mode
+  - `r/g/b` - Select color channel (in custom mode)
+  - `←/→` - Adjust selected channel
+- `u` - Toggle temperature unit (°C/°F)
+- `o` - Open settings
+- `q` - Quit
+
+## Requirements
+
+- Node.js 18+
+- Bluetooth adapter with BLE support
+- Ember Mug 2 (other models may work but are untested)
+
+### Platform-Specific Notes
+
+#### Linux
+You may need to grant Bluetooth permissions:
+```bash
+sudo setcap cap_net_raw+eip $(eval readlink -f `which node`)
+```
+
+#### macOS
+Grant Bluetooth permissions to your terminal application in System Preferences > Security & Privacy > Privacy > Bluetooth.
+
+#### Windows
+Requires Windows 10 build 15063 or later with Bluetooth 4.0+ adapter.
+
+## Technical Details
+
+This application uses:
+- [@abandonware/noble](https://github.com/abandonware/noble) for Bluetooth LE communication
+- [Ink](https://github.com/vadimdemedes/ink) for the React-based CLI interface
+- [Conf](https://github.com/sindresorhus/conf) for persistent settings storage
+
+The Ember mug Bluetooth protocol was reverse-engineered by [orlopau/ember-mug](https://github.com/orlopau/ember-mug).
+
+## Versioning
+
+This project uses [Semantic Versioning](https://semver.org/). Releases are published to npm automatically when a new version tag is pushed to the main branch.
+
+## License
+
+MIT

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+import { jsx as _jsx } from "react/jsx-runtime";
+import { render } from 'ink';
+import { App } from './components/App.js';
+// Handle graceful shutdown
+process.on('SIGINT', () => {
+    process.exit(0);
+});
+process.on('SIGTERM', () => {
+    process.exit(0);
+});
+// Render the app
+render(_jsx(App, {}));

package/dist/components/App.d.ts

@@ -0,0 +1,2 @@
+import React from 'react';
+export declare function App(): React.ReactElement;

package/dist/components/App.js

@@ -0,0 +1,120 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState, useEffect, useCallback } from 'react';
+import { Box, useApp, useInput } from 'ink';
+import { useMug } from '../hooks/useMug.js';
+import { Header } from './Header.js';
+import { TemperatureDisplay } from './TemperatureDisplay.js';
+import { BatteryDisplay } from './BatteryDisplay.js';
+import { TemperatureControl } from './TemperatureControl.js';
+import { Presets } from './Presets.js';
+import { ColorControl } from './ColorControl.js';
+import { ConnectionStatus } from './ConnectionStatus.js';
+import { SettingsView } from './SettingsView.js';
+import { HelpDisplay } from './HelpDisplay.js';
+import { TemperatureUnit } from '../lib/types.js';
+import { getPresets, getTemperatureUnit, setTemperatureUnit as saveTemperatureUnit, setLastTargetTemp, } from '../lib/settings.js';
+export function App() {
+    const { exit } = useApp();
+    const { state: mugState, isScanning, error, foundMugName, startScanning, setTargetTemp, setTemperatureUnit: setMugTempUnit, setLedColor, } = useMug();
+    const [viewMode, setViewMode] = useState('main');
+    const [activeControl, setActiveControl] = useState('none');
+    const [presets] = useState(getPresets());
+    const [selectedPresetIndex, setSelectedPresetIndex] = useState(-1);
+    const [localTempUnit, setLocalTempUnit] = useState(getTemperatureUnit());
+    // Start scanning on mount
+    useEffect(() => {
+        startScanning();
+    }, [startScanning]);
+    // Sync temperature unit with mug when connected
+    useEffect(() => {
+        if (mugState.connected) {
+            setLocalTempUnit(mugState.temperatureUnit);
+        }
+    }, [mugState.connected, mugState.temperatureUnit]);
+    const handleTempChange = useCallback(async (temp) => {
+        await setTargetTemp(temp);
+        setLastTargetTemp(temp);
+        setSelectedPresetIndex(-1);
+    }, [setTargetTemp]);
+    const handlePresetSelect = useCallback(async (preset) => {
+        await setTargetTemp(preset.temperature);
+        setLastTargetTemp(preset.temperature);
+        const index = presets.findIndex((p) => p.id === preset.id);
+        setSelectedPresetIndex(index);
+    }, [setTargetTemp, presets]);
+    const handleColorChange = useCallback(async (color) => {
+        await setLedColor(color);
+    }, [setLedColor]);
+    const handleTemperatureUnitChange = useCallback(async (unit) => {
+        setLocalTempUnit(unit);
+        saveTemperatureUnit(unit);
+        if (mugState.connected) {
+            await setMugTempUnit(unit);
+        }
+    }, [mugState.connected, setMugTempUnit]);
+    useInput((input, key) => {
+        // Global controls
+        if (input === 'q' && viewMode === 'main' && activeControl === 'none') {
+            exit();
+            return;
+        }
+        // Handle escape to go back
+        if (key.escape) {
+            if (activeControl !== 'none') {
+                setActiveControl('none');
+            }
+            else if (viewMode !== 'main') {
+                setViewMode('main');
+            }
+            return;
+        }
+        // Only handle these if we're in main view with no active control
+        if (viewMode === 'main' && activeControl === 'none') {
+            if (input === 's' && !mugState.connected) {
+                startScanning();
+                return;
+            }
+            if (input === 'r' && !mugState.connected && error) {
+                startScanning();
+                return;
+            }
+            if (mugState.connected) {
+                if (input === 't') {
+                    setActiveControl('temperature');
+                    return;
+                }
+                if (input === 'c') {
+                    setActiveControl('color');
+                    return;
+                }
+                if (input === 'o') {
+                    setViewMode('settings');
+                    return;
+                }
+                if (input === 'u') {
+                    const newUnit = localTempUnit === TemperatureUnit.Celsius
+                        ? TemperatureUnit.Fahrenheit
+                        : TemperatureUnit.Celsius;
+                    handleTemperatureUnitChange(newUnit);
+                    return;
+                }
+            }
+        }
+        // Exit temperature control mode
+        if (activeControl === 'temperature' && (key.return || input === 't')) {
+            setActiveControl('none');
+            return;
+        }
+        // Exit color control mode
+        if (activeControl === 'color' && input === 'c') {
+            setActiveControl('none');
+            return;
+        }
+    });
+    // Settings view
+    if (viewMode === 'settings') {
+        return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Header, { mugName: mugState.mugName, connected: mugState.connected }), _jsx(SettingsView, { presets: presets, temperatureUnit: localTempUnit, onTemperatureUnitChange: handleTemperatureUnitChange, onClose: () => setViewMode('main'), isActive: true })] }));
+    }
+    // Main view
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Header, { mugName: mugState.mugName, connected: mugState.connected }), !mugState.connected ? (_jsx(ConnectionStatus, { isScanning: isScanning, isConnected: mugState.connected, foundMugName: foundMugName, error: error, onRetry: startScanning })) : (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Box, { flexDirection: "column", flexGrow: 1, children: _jsx(TemperatureDisplay, { currentTemp: mugState.currentTemp, targetTemp: mugState.targetTemp, liquidState: mugState.liquidState, temperatureUnit: localTempUnit }) }), _jsx(Box, { flexDirection: "column", flexGrow: 1, children: _jsx(BatteryDisplay, { batteryLevel: mugState.batteryLevel, isCharging: mugState.isCharging, liquidState: mugState.liquidState }) })] }), _jsx(TemperatureControl, { targetTemp: mugState.targetTemp, temperatureUnit: localTempUnit, onTempChange: handleTempChange, isActive: activeControl === 'temperature' }), _jsx(Presets, { presets: presets, selectedIndex: selectedPresetIndex, temperatureUnit: localTempUnit, onSelect: handlePresetSelect, isActive: activeControl === 'none' }), activeControl === 'color' && (_jsx(ColorControl, { color: mugState.color, onColorChange: handleColorChange, isActive: true }))] })), _jsx(HelpDisplay, { isConnected: mugState.connected })] }));
+}

package/dist/components/BatteryDisplay.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+import { LiquidState } from '../lib/types.js';
+interface BatteryDisplayProps {
+    batteryLevel: number;
+    isCharging: boolean;
+    liquidState: LiquidState;
+}
+export declare function BatteryDisplay({ batteryLevel, isCharging, liquidState, }: BatteryDisplayProps): React.ReactElement;
+export {};

package/dist/components/BatteryDisplay.js

@@ -0,0 +1,25 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import { formatBatteryLevel, getBatteryIcon, estimateBatteryLife, formatDuration, } from '../lib/utils.js';
+export function BatteryDisplay({ batteryLevel, isCharging, liquidState, }) {
+    const batteryColor = getBatteryColor(batteryLevel, isCharging);
+    const batteryIcon = getBatteryIcon(batteryLevel, isCharging);
+    const batteryTimeEstimate = estimateBatteryLife(batteryLevel, isCharging, liquidState);
+    return (_jsxs(Box, { flexDirection: "column", marginY: 1, children: [_jsx(Box, { justifyContent: "center", children: _jsx(Text, { bold: true, children: "Battery" }) }), _jsx(Box, { justifyContent: "center", marginY: 1, children: _jsxs(Text, { color: batteryColor, children: [batteryIcon, " ", formatBatteryLevel(batteryLevel), isCharging && _jsx(Text, { color: "yellow", children: " (Charging)" })] }) }), batteryTimeEstimate !== null && (_jsx(Box, { justifyContent: "center", children: _jsx(Text, { dimColor: true, children: isCharging ? (_jsxs(_Fragment, { children: ['Time to full: ', _jsx(Text, { color: "green", children: formatDuration(batteryTimeEstimate) })] })) : (_jsxs(_Fragment, { children: ['Est. battery life: ', _jsx(Text, { color: batteryLevel < 20 ? 'red' : 'yellow', children: formatDuration(batteryTimeEstimate) })] })) }) })), _jsx(Box, { justifyContent: "center", marginTop: 1, children: _jsx(BatteryBar, { level: batteryLevel, isCharging: isCharging }) })] }));
+}
+function BatteryBar({ level, isCharging }) {
+    const totalSegments = 20;
+    const filledSegments = Math.round((level / 100) * totalSegments);
+    const emptySegments = totalSegments - filledSegments;
+    const color = getBatteryColor(level, isCharging);
+    return (_jsxs(Text, { children: [_jsx(Text, { dimColor: true, children: "[" }), _jsx(Text, { color: color, children: '█'.repeat(filledSegments) }), _jsx(Text, { dimColor: true, children: '░'.repeat(emptySegments) }), _jsx(Text, { dimColor: true, children: "]" }), isCharging && _jsx(Text, { color: "yellow", children: " \u26A1" })] }));
+}
+function getBatteryColor(level, isCharging) {
+    if (isCharging)
+        return 'yellow';
+    if (level >= 50)
+        return 'green';
+    if (level >= 25)
+        return 'yellow';
+    return 'red';
+}

package/dist/components/ColorControl.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+import { RGBColor } from '../lib/types.js';
+interface ColorControlProps {
+    color: RGBColor;
+    onColorChange: (color: RGBColor) => void;
+    isActive: boolean;
+}
+export declare function ColorControl({ color, onColorChange, isActive, }: ColorControlProps): React.ReactElement;
+export {};

package/dist/components/ColorControl.js

@@ -0,0 +1,71 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState } from 'react';
+import { Box, Text, useInput } from 'ink';
+import { rgbToHex } from '../lib/utils.js';
+const PRESET_COLORS = [
+    { name: 'Orange', color: { r: 255, g: 147, b: 41, a: 255 } },
+    { name: 'Red', color: { r: 255, g: 0, b: 0, a: 255 } },
+    { name: 'Green', color: { r: 0, g: 255, b: 0, a: 255 } },
+    { name: 'Blue', color: { r: 0, g: 128, b: 255, a: 255 } },
+    { name: 'Purple', color: { r: 128, g: 0, b: 255, a: 255 } },
+    { name: 'Pink', color: { r: 255, g: 105, b: 180, a: 255 } },
+    { name: 'White', color: { r: 255, g: 255, b: 255, a: 255 } },
+    { name: 'Teal', color: { r: 0, g: 255, b: 200, a: 255 } },
+];
+export function ColorControl({ color, onColorChange, isActive, }) {
+    const [selectedChannel, setSelectedChannel] = useState('r');
+    const [customMode, setCustomMode] = useState(false);
+    useInput((input, key) => {
+        if (!isActive)
+            return;
+        // Number keys for preset colors
+        const numKey = parseInt(input, 10);
+        if (numKey >= 1 && numKey <= PRESET_COLORS.length) {
+            onColorChange(PRESET_COLORS[numKey - 1].color);
+            setCustomMode(false);
+            return;
+        }
+        // Toggle custom mode
+        if (input === 'c') {
+            setCustomMode(!customMode);
+            return;
+        }
+        if (customMode) {
+            // Switch channels
+            if (input === 'r') {
+                setSelectedChannel('r');
+            }
+            else if (input === 'g') {
+                setSelectedChannel('g');
+            }
+            else if (input === 'b') {
+                setSelectedChannel('b');
+            }
+            // Adjust selected channel
+            let delta = 0;
+            if (key.leftArrow || input === 'h') {
+                delta = -10;
+            }
+            else if (key.rightArrow || input === 'l') {
+                delta = 10;
+            }
+            else if (key.upArrow || input === 'k') {
+                delta = 25;
+            }
+            else if (key.downArrow || input === 'j') {
+                delta = -25;
+            }
+            if (delta !== 0) {
+                const newColor = { ...color };
+                newColor[selectedChannel] = Math.max(0, Math.min(255, newColor[selectedChannel] + delta));
+                onColorChange(newColor);
+            }
+        }
+    }, { isActive });
+    return (_jsxs(Box, { flexDirection: "column", marginY: 1, children: [_jsx(Box, { justifyContent: "center", children: _jsx(Text, { bold: true, children: "LED Color" }) }), _jsx(Box, { justifyContent: "center", marginY: 1, children: _jsxs(Text, { children: ["Current: ", _jsx(Text, { color: rgbToHex(color.r, color.g, color.b), children: "\u25CF" }), ' ', _jsxs(Text, { dimColor: true, children: ["(", rgbToHex(color.r, color.g, color.b), ")"] })] }) }), _jsx(Box, { justifyContent: "center", gap: 1, marginY: 1, children: PRESET_COLORS.map((preset, index) => (_jsxs(Box, { children: [_jsx(Text, { color: rgbToHex(preset.color.r, preset.color.g, preset.color.b), children: "\u25CF" }), _jsx(Text, { dimColor: true, children: index + 1 })] }, preset.name))) }), customMode && (_jsxs(Box, { flexDirection: "column", marginY: 1, children: [_jsx(Box, { justifyContent: "center", children: _jsx(Text, { dimColor: true, children: "Custom Color Mode" }) }), _jsxs(Box, { justifyContent: "center", gap: 2, children: [_jsx(ChannelSlider, { label: "R", value: color.r, isSelected: selectedChannel === 'r', color: "red" }), _jsx(ChannelSlider, { label: "G", value: color.g, isSelected: selectedChannel === 'g', color: "green" }), _jsx(ChannelSlider, { label: "B", value: color.b, isSelected: selectedChannel === 'b', color: "blue" })] })] })), _jsx(Box, { justifyContent: "center", marginTop: 1, children: _jsxs(Text, { dimColor: true, children: ["Press ", _jsxs(Text, { color: "cyan", children: ["1-", PRESET_COLORS.length] }), " for presets |", ' ', _jsx(Text, { color: "cyan", children: "c" }), " for custom mode"] }) })] }));
+}
+function ChannelSlider({ label, value, isSelected, color, }) {
+    const width = 10;
+    const filled = Math.round((value / 255) * width);
+    return (_jsx(Box, { children: _jsxs(Text, { color: isSelected ? color : 'gray', children: [label, ": ", '█'.repeat(filled), '░'.repeat(width - filled), " ", value.toString().padStart(3)] }) }));
+}

package/dist/components/ConnectionStatus.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+interface ConnectionStatusProps {
+    isScanning: boolean;
+    isConnected: boolean;
+    foundMugName: string | null;
+    error: string | null;
+    onRetry: () => void;
+}
+export declare function ConnectionStatus({ isScanning, isConnected, foundMugName, error, }: ConnectionStatusProps): React.ReactElement;
+export {};

package/dist/components/ConnectionStatus.js

@@ -0,0 +1,9 @@
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import Spinner from 'ink-spinner';
+export function ConnectionStatus({ isScanning, isConnected, foundMugName, error, }) {
+    if (isConnected) {
+        return _jsx(_Fragment, {});
+    }
+    return (_jsx(Box, { flexDirection: "column", alignItems: "center", marginY: 2, children: error ? (_jsxs(Box, { flexDirection: "column", alignItems: "center", children: [_jsxs(Text, { color: "red", children: ["Error: ", error] }), _jsx(Box, { marginTop: 1, children: _jsxs(Text, { dimColor: true, children: ["Press ", _jsx(Text, { color: "cyan", children: "r" }), " to retry scanning"] }) })] })) : isScanning ? (_jsxs(Box, { flexDirection: "column", alignItems: "center", children: [_jsxs(Box, { children: [_jsx(Text, { color: "cyan", children: _jsx(Spinner, { type: "dots" }) }), _jsx(Text, { children: " Scanning for Ember mug..." })] }), foundMugName && (_jsxs(Box, { marginTop: 1, children: [_jsxs(Text, { color: "green", children: ["Found: ", foundMugName] }), _jsx(Text, { children: " - Connecting..." })] })), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "Make sure your Ember mug is powered on and in range" }) })] })) : (_jsxs(Box, { flexDirection: "column", alignItems: "center", children: [_jsx(Text, { children: "No Ember mug connected" }), _jsx(Box, { marginTop: 1, children: _jsxs(Text, { dimColor: true, children: ["Press ", _jsx(Text, { color: "cyan", children: "s" }), " to start scanning"] }) })] })) }));
+}

package/dist/components/Header.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+interface HeaderProps {
+    mugName: string;
+    connected: boolean;
+}
+export declare function Header({ mugName, connected }: HeaderProps): React.ReactElement;
+export {};

package/dist/components/Header.js

@@ -0,0 +1,5 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+export function Header({ mugName, connected }) {
+    return (_jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [_jsxs(Box, { children: [_jsx(Text, { bold: true, color: "cyan", children: '☕ Ember Mug CLI ' }), connected ? (_jsxs(Text, { color: "green", children: ["[Connected: ", mugName, "]"] })) : (_jsx(Text, { color: "yellow", children: "[Disconnected]" }))] }), _jsx(Text, { dimColor: true, children: '─'.repeat(50) })] }));
+}

package/dist/components/HelpDisplay.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+interface HelpDisplayProps {
+    isConnected: boolean;
+}
+export declare function HelpDisplay({ isConnected }: HelpDisplayProps): React.ReactElement;
+export {};

package/dist/components/HelpDisplay.js

@@ -0,0 +1,5 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+export function HelpDisplay({ isConnected }) {
+    return (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { dimColor: true, children: '─'.repeat(50) }), _jsx(Box, { marginY: 1, justifyContent: "center", children: _jsx(Text, { dimColor: true, children: isConnected ? (_jsxs(_Fragment, { children: [_jsx(Text, { color: "cyan", children: "t" }), ":temp", ' ', _jsx(Text, { color: "cyan", children: "1-3" }), ":presets", ' ', _jsx(Text, { color: "cyan", children: "c" }), ":color", ' ', _jsx(Text, { color: "cyan", children: "u" }), ":unit", ' ', _jsx(Text, { color: "cyan", children: "o" }), ":settings", ' ', _jsx(Text, { color: "cyan", children: "q" }), ":quit"] })) : (_jsxs(_Fragment, { children: [_jsx(Text, { color: "cyan", children: "s" }), ":scan", ' ', _jsx(Text, { color: "cyan", children: "r" }), ":retry", ' ', _jsx(Text, { color: "cyan", children: "q" }), ":quit"] })) }) })] }));
+}

package/dist/components/Presets.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+import { Preset, TemperatureUnit } from '../lib/types.js';
+interface PresetsProps {
+    presets: Preset[];
+    selectedIndex: number;
+    temperatureUnit: TemperatureUnit;
+    onSelect: (preset: Preset) => void;
+    isActive: boolean;
+}
+export declare function Presets({ presets, selectedIndex, temperatureUnit, onSelect, isActive, }: PresetsProps): React.ReactElement;
+export {};

package/dist/components/Presets.js

@@ -0,0 +1,19 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text, useInput } from 'ink';
+import { formatTemperature } from '../lib/utils.js';
+export function Presets({ presets, selectedIndex, temperatureUnit, onSelect, isActive, }) {
+    useInput((input, key) => {
+        if (!isActive)
+            return;
+        const numKey = parseInt(input, 10);
+        if (numKey >= 1 && numKey <= presets.length) {
+            onSelect(presets[numKey - 1]);
+        }
+    }, { isActive });
+    return (_jsxs(Box, { flexDirection: "column", marginY: 1, children: [_jsx(Box, { justifyContent: "center", children: _jsx(Text, { bold: true, children: "Presets" }) }), _jsx(Box, { justifyContent: "center", marginY: 1, gap: 2, children: presets.map((preset, index) => (_jsx(PresetButton, { preset: preset, index: index, isSelected: selectedIndex === index, temperatureUnit: temperatureUnit }, preset.id))) }), _jsx(Box, { justifyContent: "center", children: _jsxs(Text, { dimColor: true, children: ["Press ", _jsxs(Text, { color: "cyan", children: ["1-", presets.length] }), " to select a preset"] }) })] }));
+}
+function PresetButton({ preset, index, isSelected, temperatureUnit, }) {
+    const borderColor = isSelected ? 'cyan' : 'gray';
+    const textColor = isSelected ? 'cyan' : 'white';
+    return (_jsxs(Box, { flexDirection: "column", alignItems: "center", children: [_jsx(Text, { color: borderColor, children: isSelected ? '┌───────────┐' : '┌───────────┐' }), _jsxs(Text, { color: borderColor, children: ["\u2502 ", _jsxs(Text, { color: textColor, children: [preset.icon, " ", preset.name.padEnd(6)] }), " \u2502"] }), _jsxs(Text, { color: borderColor, children: ["\u2502 ", _jsx(Text, { color: textColor, children: formatTemperature(preset.temperature, temperatureUnit).padStart(7) }), " \u2502"] }), _jsx(Text, { color: borderColor, children: "\u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518" }), _jsxs(Text, { color: "cyan", children: ["[", index + 1, "]"] })] }));
+}

package/dist/components/SettingsView.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+import { TemperatureUnit, Preset } from '../lib/types.js';
+interface SettingsViewProps {
+    presets: Preset[];
+    temperatureUnit: TemperatureUnit;
+    onTemperatureUnitChange: (unit: TemperatureUnit) => void;
+    onClose: () => void;
+    isActive: boolean;
+}
+export declare function SettingsView({ presets, temperatureUnit, onTemperatureUnitChange, onClose, isActive, }: SettingsViewProps): React.ReactElement;
+export {};

package/dist/components/SettingsView.js

@@ -0,0 +1,34 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState } from 'react';
+import { Box, Text, useInput } from 'ink';
+import { TemperatureUnit } from '../lib/types.js';
+import { formatTemperature } from '../lib/utils.js';
+export function SettingsView({ presets, temperatureUnit, onTemperatureUnitChange, onClose, isActive, }) {
+    const [selectedOption, setSelectedOption] = useState('unit');
+    useInput((input, key) => {
+        if (!isActive)
+            return;
+        if (key.escape || input === 'q') {
+            onClose();
+            return;
+        }
+        if (key.upArrow || input === 'k') {
+            setSelectedOption('unit');
+        }
+        else if (key.downArrow || input === 'j') {
+            setSelectedOption('presets');
+        }
+        if (key.return || input === ' ') {
+            if (selectedOption === 'unit') {
+                const newUnit = temperatureUnit === TemperatureUnit.Celsius
+                    ? TemperatureUnit.Fahrenheit
+                    : TemperatureUnit.Celsius;
+                onTemperatureUnitChange(newUnit);
+            }
+        }
+    }, { isActive });
+    return (_jsxs(Box, { flexDirection: "column", padding: 1, children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { bold: true, color: "cyan", children: "Settings" }) }), _jsx(Text, { dimColor: true, children: '─'.repeat(40) }), _jsxs(Box, { flexDirection: "column", marginY: 1, children: [_jsx(SettingRow, { label: "Temperature Unit", value: temperatureUnit === TemperatureUnit.Celsius ? 'Celsius (°C)' : 'Fahrenheit (°F)', isSelected: selectedOption === 'unit', hint: "Press Enter to toggle" }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { bold: true, children: "Presets:" }) }), presets.map((preset, index) => (_jsx(Box, { marginLeft: 2, children: _jsxs(Text, { dimColor: true, children: [index + 1, ". ", preset.icon, " ", preset.name, ":", ' ', formatTemperature(preset.temperature, temperatureUnit)] }) }, preset.id)))] }), _jsx(Text, { dimColor: true, children: '─'.repeat(40) }), _jsx(Box, { marginTop: 1, children: _jsxs(Text, { dimColor: true, children: ["Press ", _jsx(Text, { color: "cyan", children: "Esc" }), " or ", _jsx(Text, { color: "cyan", children: "q" }), " to close settings"] }) })] }));
+}
+function SettingRow({ label, value, isSelected, hint, }) {
+    return (_jsx(Box, { children: _jsxs(Text, { color: isSelected ? 'cyan' : 'white', children: [isSelected ? '> ' : '  ', label, ": ", _jsx(Text, { bold: true, children: value }), hint && isSelected && _jsxs(Text, { dimColor: true, children: [" (", hint, ")"] })] }) }));
+}

package/dist/components/TemperatureControl.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+import { TemperatureUnit } from '../lib/types.js';
+interface TemperatureControlProps {
+    targetTemp: number;
+    temperatureUnit: TemperatureUnit;
+    onTempChange: (temp: number) => void;
+    isActive: boolean;
+}
+export declare function TemperatureControl({ targetTemp, temperatureUnit, onTempChange, isActive, }: TemperatureControlProps): React.ReactElement;
+export {};

package/dist/components/TemperatureControl.js

@@ -0,0 +1,38 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text, useInput } from 'ink';
+import { MIN_TEMP_CELSIUS, MAX_TEMP_CELSIUS } from '../lib/types.js';
+import { formatTemperature, clampTemperature } from '../lib/utils.js';
+export function TemperatureControl({ targetTemp, temperatureUnit, onTempChange, isActive, }) {
+    useInput((input, key) => {
+        if (!isActive)
+            return;
+        let delta = 0;
+        if (key.leftArrow || input === 'h' || input === '-') {
+            delta = -0.5;
+        }
+        else if (key.rightArrow || input === 'l' || input === '+' || input === '=') {
+            delta = 0.5;
+        }
+        else if (key.upArrow || input === 'k') {
+            delta = 1;
+        }
+        else if (key.downArrow || input === 'j') {
+            delta = -1;
+        }
+        if (delta !== 0) {
+            const newTemp = clampTemperature(targetTemp + delta);
+            onTempChange(newTemp);
+        }
+    }, { isActive });
+    const minTempDisplay = formatTemperature(MIN_TEMP_CELSIUS, temperatureUnit);
+    const maxTempDisplay = formatTemperature(MAX_TEMP_CELSIUS, temperatureUnit);
+    return (_jsxs(Box, { flexDirection: "column", marginY: 1, children: [_jsx(Box, { justifyContent: "center", children: _jsx(Text, { bold: true, children: "Adjust Temperature" }) }), _jsxs(Box, { justifyContent: "center", marginY: 1, children: [_jsx(Text, { dimColor: true, children: minTempDisplay }), _jsx(Text, { children: " " }), _jsx(TemperatureSlider, { value: targetTemp, min: MIN_TEMP_CELSIUS, max: MAX_TEMP_CELSIUS, isActive: isActive }), _jsx(Text, { children: " " }), _jsx(Text, { dimColor: true, children: maxTempDisplay })] }), _jsx(Box, { justifyContent: "center", children: _jsx(Text, { dimColor: true, children: isActive ? (_jsxs(Text, { children: ["Use ", _jsx(Text, { color: "cyan", children: "\u2190/\u2192" }), " or ", _jsx(Text, { color: "cyan", children: "h/l" }), " (\u00B10.5\u00B0) |", ' ', _jsx(Text, { color: "cyan", children: "\u2191/\u2193" }), " or ", _jsx(Text, { color: "cyan", children: "j/k" }), " (\u00B11\u00B0)"] })) : (_jsxs(Text, { children: ["Press ", _jsx(Text, { color: "cyan", children: "t" }), " to adjust temperature"] })) }) })] }));
+}
+function TemperatureSlider({ value, min, max, isActive, }) {
+    const totalWidth = 20;
+    const normalizedValue = (value - min) / (max - min);
+    const position = Math.round(normalizedValue * (totalWidth - 1));
+    const sliderChars = Array(totalWidth).fill('─');
+    sliderChars[position] = '●';
+    return (_jsx(Text, { color: isActive ? 'cyan' : 'white', children: sliderChars.join('') }));
+}

package/dist/components/TemperatureDisplay.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+import { LiquidState, TemperatureUnit } from '../lib/types.js';
+interface TemperatureDisplayProps {
+    currentTemp: number;
+    targetTemp: number;
+    liquidState: LiquidState;
+    temperatureUnit: TemperatureUnit;
+}
+export declare function TemperatureDisplay({ currentTemp, targetTemp, liquidState, temperatureUnit, }: TemperatureDisplayProps): React.ReactElement;
+export {};

package/dist/components/TemperatureDisplay.js

@@ -0,0 +1,40 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import { LiquidState } from '../lib/types.js';
+import { formatTemperature, getLiquidStateText, getLiquidStateIcon, estimateTimeToTargetTemp, formatDuration, } from '../lib/utils.js';
+export function TemperatureDisplay({ currentTemp, targetTemp, liquidState, temperatureUnit, }) {
+    const isEmpty = liquidState === LiquidState.Empty;
+    const isAtTarget = Math.abs(currentTemp - targetTemp) < 0.5 && !isEmpty;
+    const tempDiff = currentTemp - targetTemp;
+    let tempColor;
+    if (isEmpty) {
+        tempColor = 'gray';
+    }
+    else if (Math.abs(tempDiff) < 1) {
+        tempColor = 'green';
+    }
+    else if (tempDiff > 0) {
+        tempColor = 'red';
+    }
+    else {
+        tempColor = 'blue';
+    }
+    const timeToTarget = estimateTimeToTargetTemp(currentTemp, targetTemp, liquidState);
+    return (_jsxs(Box, { flexDirection: "column", marginY: 1, children: [_jsx(Box, { justifyContent: "center", children: _jsx(Text, { bold: true, children: "Temperature" }) }), _jsxs(Box, { marginY: 1, justifyContent: "center", children: [_jsxs(Box, { flexDirection: "column", alignItems: "center", children: [_jsx(Text, { dimColor: true, children: "Current" }), _jsx(Text, { bold: true, color: tempColor, children: isEmpty ? '---' : formatTemperature(currentTemp, temperatureUnit) })] }), _jsx(Box, { marginX: 3, children: _jsx(Text, { dimColor: true, children: '  →  ' }) }), _jsxs(Box, { flexDirection: "column", alignItems: "center", children: [_jsx(Text, { dimColor: true, children: "Target" }), _jsx(Text, { bold: true, color: "cyan", children: formatTemperature(targetTemp, temperatureUnit) })] })] }), _jsx(Box, { justifyContent: "center", marginTop: 1, children: _jsxs(Text, { children: [_jsxs(Text, { color: getStateColor(liquidState), children: [getLiquidStateIcon(liquidState), " ", getLiquidStateText(liquidState)] }), isAtTarget && _jsx(Text, { color: "green", children: " - Perfect!" })] }) }), timeToTarget !== null && timeToTarget > 0 && (_jsx(Box, { justifyContent: "center", marginTop: 1, children: _jsxs(Text, { dimColor: true, children: ['Est. time to target: ', _jsx(Text, { color: "yellow", children: formatDuration(timeToTarget) })] }) })), timeToTarget === 0 && !isEmpty && (_jsx(Box, { justifyContent: "center", marginTop: 1, children: _jsx(Text, { color: "green", children: "At target temperature!" }) }))] }));
+}
+function getStateColor(state) {
+    switch (state) {
+        case LiquidState.Empty:
+            return 'gray';
+        case LiquidState.Filling:
+            return 'cyan';
+        case LiquidState.Cooling:
+            return 'blue';
+        case LiquidState.Heating:
+            return 'red';
+        case LiquidState.StableTemperature:
+            return 'green';
+        default:
+            return 'white';
+    }
+}