ember-mug 0.1.3 → 0.1.5

package/dist/lib/mock-bluetooth.js

@@ -0,0 +1,214 @@
+import { EventEmitter } from 'events';
+import { LiquidState, TemperatureUnit, MIN_TEMP_CELSIUS, MAX_TEMP_CELSIUS, BATTERY_DRAIN_RATE_HEATING, BATTERY_DRAIN_RATE_MAINTAINING, BATTERY_CHARGE_RATE, } from './types.js';
+const DEFAULT_CONFIG = {
+    initialBattery: 75,
+    initialCurrentTemp: 45,
+    initialTargetTemp: 55,
+    initialLiquidState: LiquidState.Cooling,
+    initiallyCharging: false,
+    mugName: 'Mock Ember Mug',
+    scanDelay: 1500,
+    connectionDelay: 800,
+    tempChangeRate: 0.5, // degrees per second
+    updateInterval: 1000,
+};
+export class MockBluetoothManager extends EventEmitter {
+    config;
+    isConnected = false;
+    simulationInterval = null;
+    lastUpdateTime = Date.now();
+    state;
+    constructor(config = {}) {
+        super();
+        this.config = { ...DEFAULT_CONFIG, ...config };
+        this.state = {
+            connected: false,
+            batteryLevel: this.config.initialBattery,
+            isCharging: this.config.initiallyCharging,
+            currentTemp: this.config.initialCurrentTemp,
+            targetTemp: this.config.initialTargetTemp,
+            liquidState: this.config.initialLiquidState,
+            temperatureUnit: TemperatureUnit.Celsius,
+            color: { r: 255, g: 147, b: 41, a: 255 }, // Default ember orange
+            mugName: '',
+        };
+    }
+    async startScanning() {
+        this.emit('scanning', true);
+        // Simulate finding a mug after a delay
+        setTimeout(() => {
+            this.emit('mugFound', this.config.mugName);
+            this.emit('scanning', false);
+            // Auto-connect after finding
+            setTimeout(() => {
+                this.connect();
+            }, this.config.connectionDelay);
+        }, this.config.scanDelay);
+    }
+    async stopScanning() {
+        this.emit('scanning', false);
+    }
+    async connect() {
+        this.isConnected = true;
+        this.state.connected = true;
+        this.state.mugName = this.config.mugName;
+        this.startSimulation();
+        this.emit('connected');
+        this.emitState();
+    }
+    startSimulation() {
+        this.lastUpdateTime = Date.now();
+        this.simulationInterval = setInterval(() => {
+            if (!this.isConnected)
+                return;
+            const now = Date.now();
+            const deltaSeconds = (now - this.lastUpdateTime) / 1000;
+            this.lastUpdateTime = now;
+            this.updateSimulation(deltaSeconds);
+        }, this.config.updateInterval);
+    }
+    updateSimulation(deltaSeconds) {
+        let stateChanged = false;
+        // Update temperature based on liquid state
+        if (this.state.liquidState !== LiquidState.Empty) {
+            const tempDiff = this.state.targetTemp - this.state.currentTemp;
+            const maxChange = this.config.tempChangeRate * deltaSeconds;
+            if (Math.abs(tempDiff) > 0.1) {
+                // Temperature is changing
+                const change = Math.sign(tempDiff) * Math.min(Math.abs(tempDiff), maxChange);
+                this.state.currentTemp = Math.round((this.state.currentTemp + change) * 100) / 100;
+                stateChanged = true;
+                // Update liquid state based on temperature direction
+                if (tempDiff > 0.5) {
+                    if (this.state.liquidState !== LiquidState.Heating) {
+                        this.state.liquidState = LiquidState.Heating;
+                    }
+                }
+                else if (tempDiff < -0.5) {
+                    if (this.state.liquidState !== LiquidState.Cooling) {
+                        this.state.liquidState = LiquidState.Cooling;
+                    }
+                }
+            }
+            else {
+                // Temperature is stable
+                if (this.state.liquidState !== LiquidState.StableTemperature) {
+                    this.state.liquidState = LiquidState.StableTemperature;
+                    stateChanged = true;
+                }
+            }
+        }
+        // Update battery
+        if (this.state.isCharging) {
+            // Charging
+            const chargeGain = (BATTERY_CHARGE_RATE / 60) * deltaSeconds;
+            this.state.batteryLevel = Math.min(100, this.state.batteryLevel + chargeGain);
+            stateChanged = true;
+        }
+        else if (this.state.liquidState === LiquidState.Heating) {
+            // Draining while heating
+            const drain = (BATTERY_DRAIN_RATE_HEATING / 60) * deltaSeconds;
+            this.state.batteryLevel = Math.max(0, this.state.batteryLevel - drain);
+            stateChanged = true;
+        }
+        else if (this.state.liquidState === LiquidState.StableTemperature) {
+            // Draining while maintaining
+            const drain = (BATTERY_DRAIN_RATE_MAINTAINING / 60) * deltaSeconds;
+            this.state.batteryLevel = Math.max(0, this.state.batteryLevel - drain);
+            stateChanged = true;
+        }
+        if (stateChanged) {
+            this.emitState();
+        }
+    }
+    async setTargetTemp(temp) {
+        const clampedTemp = Math.max(MIN_TEMP_CELSIUS, Math.min(MAX_TEMP_CELSIUS, temp));
+        this.state.targetTemp = clampedTemp;
+        this.emitState();
+    }
+    async setTemperatureUnit(unit) {
+        this.state.temperatureUnit = unit;
+        this.emitState();
+    }
+    async setLedColor(color) {
+        this.state.color = { ...color };
+        this.emitState();
+    }
+    getState() {
+        return { ...this.state };
+    }
+    emitState() {
+        this.emit('stateChange', this.getState());
+    }
+    async disconnect() {
+        if (this.simulationInterval) {
+            clearInterval(this.simulationInterval);
+            this.simulationInterval = null;
+        }
+        if (this.isConnected) {
+            this.isConnected = false;
+            this.state.connected = false;
+            this.emit('disconnected');
+            this.emitState();
+        }
+    }
+    // Mock-specific methods for testing scenarios
+    /** Simulate placing the mug on the charger */
+    simulateStartCharging() {
+        this.state.isCharging = true;
+        this.emitState();
+    }
+    /** Simulate removing the mug from the charger */
+    simulateStopCharging() {
+        this.state.isCharging = false;
+        this.emitState();
+    }
+    /** Simulate the mug becoming empty */
+    simulateEmpty() {
+        this.state.liquidState = LiquidState.Empty;
+        this.state.currentTemp = 0;
+        this.emitState();
+    }
+    /** Simulate filling the mug with liquid at a given temperature */
+    simulateFill(temperature) {
+        this.state.currentTemp = temperature;
+        this.state.liquidState = LiquidState.Filling;
+        this.emitState();
+        // Transition to appropriate state after a short delay
+        setTimeout(() => {
+            if (this.state.currentTemp < this.state.targetTemp) {
+                this.state.liquidState = LiquidState.Heating;
+            }
+            else if (this.state.currentTemp > this.state.targetTemp) {
+                this.state.liquidState = LiquidState.Cooling;
+            }
+            else {
+                this.state.liquidState = LiquidState.StableTemperature;
+            }
+            this.emitState();
+        }, 500);
+    }
+    /** Simulate a connection drop */
+    simulateDisconnect() {
+        this.disconnect();
+    }
+    /** Set battery level directly (for testing low battery scenarios) */
+    simulateBatteryLevel(level) {
+        this.state.batteryLevel = Math.max(0, Math.min(100, level));
+        this.emitState();
+    }
+}
+// Singleton instance for mock mode
+let mockInstance = null;
+export function getMockBluetoothManager(config) {
+    if (!mockInstance) {
+        mockInstance = new MockBluetoothManager(config);
+    }
+    return mockInstance;
+}
+export function resetMockBluetoothManager() {
+    if (mockInstance) {
+        mockInstance.disconnect();
+        mockInstance = null;
+    }
+}

package/dist/lib/settings.d.ts

@@ -1,4 +1,4 @@
-import { AppSettings, Preset, TemperatureUnit } from './types.js';
+import { AppSettings, Preset, TemperatureUnit } from "./types.js";
 export declare function getSettings(): AppSettings;
 export declare function getPresets(): Preset[];
 export declare function setPresets(presets: Preset[]): void;

package/dist/lib/settings.js

@@ -1,10 +1,10 @@
-import Conf from 'conf';
-import { TemperatureUnit, DEFAULT_PRESETS, } from './types.js';
+import Conf from "conf";
+import { TemperatureUnit, DEFAULT_PRESETS, } from "./types.js";
 const config = new Conf({
-    projectName: 'ember-mug-cli',
+    projectName: "ember-mug-cli",
     defaults: {
         presets: DEFAULT_PRESETS,
-        temperatureUnit: TemperatureUnit.Celsius,
+        temperatureUnit: TemperatureUnit.Fahrenheit,
         notifyOnTemperatureReached: true,
         notifyAtBatteryPercentage: 15,
         lastTargetTemp: 55,
@@ -13,17 +13,17 @@ const config = new Conf({
 });
 export function getSettings() {
     return {
-        presets: config.get('presets'),
-        temperatureUnit: config.get('temperatureUnit'),
-        notifyOnTemperatureReached: config.get('notifyOnTemperatureReached'),
-        notifyAtBatteryPercentage: config.get('notifyAtBatteryPercentage'),
+        presets: config.get("presets"),
+        temperatureUnit: config.get("temperatureUnit"),
+        notifyOnTemperatureReached: config.get("notifyOnTemperatureReached"),
+        notifyAtBatteryPercentage: config.get("notifyAtBatteryPercentage"),
     };
 }
 export function getPresets() {
-    return config.get('presets');
+    return config.get("presets");
 }
 export function setPresets(presets) {
-    config.set('presets', presets);
+    config.set("presets", presets);
 }
 export function addPreset(preset) {
     const presets = getPresets();
@@ -39,34 +39,34 @@ export function updatePreset(id, updates) {
     setPresets(presets);
 }
 export function getTemperatureUnit() {
-    return config.get('temperatureUnit');
+    return config.get("temperatureUnit");
 }
 export function setTemperatureUnit(unit) {
-    config.set('temperatureUnit', unit);
+    config.set("temperatureUnit", unit);
 }
 export function getLastTargetTemp() {
-    return config.get('lastTargetTemp');
+    return config.get("lastTargetTemp");
 }
 export function setLastTargetTemp(temp) {
-    config.set('lastTargetTemp', temp);
+    config.set("lastTargetTemp", temp);
 }
 export function getLedColor() {
-    return config.get('ledColor');
+    return config.get("ledColor");
 }
 export function setLedColor(color) {
-    config.set('ledColor', color);
+    config.set("ledColor", color);
 }
 export function getNotifyOnTemperatureReached() {
-    return config.get('notifyOnTemperatureReached');
+    return config.get("notifyOnTemperatureReached");
 }
 export function setNotifyOnTemperatureReached(enabled) {
-    config.set('notifyOnTemperatureReached', enabled);
+    config.set("notifyOnTemperatureReached", enabled);
 }
 export function getNotifyAtBatteryPercentage() {
-    return config.get('notifyAtBatteryPercentage');
+    return config.get("notifyAtBatteryPercentage");
 }
 export function setNotifyAtBatteryPercentage(percentage) {
-    config.set('notifyAtBatteryPercentage', percentage);
+    config.set("notifyAtBatteryPercentage", percentage);
 }
 export function resetSettings() {
     config.clear();

package/dist/lib/theme.d.ts

@@ -0,0 +1,135 @@
+import { LiquidState } from './types.js';
+export interface Theme {
+    primary: string;
+    secondary: string;
+    text: string;
+    dimText: string;
+    name: string;
+}
+export declare const THEMES: {
+    readonly heating: {
+        readonly primary: "#FF6B35";
+        readonly secondary: "#FF8C5A";
+        readonly text: "white";
+        readonly dimText: "#FFD4C4";
+        readonly name: "Heating";
+    };
+    readonly cooling: {
+        readonly primary: "#FF6B35";
+        readonly secondary: "#FF8C5A";
+        readonly text: "white";
+        readonly dimText: "#FFD4C4";
+        readonly name: "Cooling";
+    };
+    readonly stable: {
+        readonly primary: "#4A90D9";
+        readonly secondary: "#6BA3E0";
+        readonly text: "white";
+        readonly dimText: "#B8D4F0";
+        readonly name: "Perfect";
+    };
+    readonly empty: {
+        readonly primary: "#666666";
+        readonly secondary: "#888888";
+        readonly text: "white";
+        readonly dimText: "#AAAAAA";
+        readonly name: "Empty";
+    };
+    readonly filling: {
+        readonly primary: "#4A90D9";
+        readonly secondary: "#6BA3E0";
+        readonly text: "white";
+        readonly dimText: "#B8D4F0";
+        readonly name: "Filling";
+    };
+    readonly disconnected: {
+        readonly primary: "#444444";
+        readonly secondary: "#666666";
+        readonly text: "white";
+        readonly dimText: "#999999";
+        readonly name: "Disconnected";
+    };
+};
+export declare const TERMINAL_COLORS: {
+    readonly heating: {
+        readonly primary: "yellow";
+        readonly secondary: "yellowBright";
+        readonly border: "yellow";
+        readonly text: "white";
+        readonly dimText: "gray";
+    };
+    readonly cooling: {
+        readonly primary: "yellow";
+        readonly secondary: "yellowBright";
+        readonly border: "yellow";
+        readonly text: "white";
+        readonly dimText: "gray";
+    };
+    readonly stable: {
+        readonly primary: "cyan";
+        readonly secondary: "cyanBright";
+        readonly border: "cyan";
+        readonly text: "white";
+        readonly dimText: "gray";
+    };
+    readonly empty: {
+        readonly primary: "gray";
+        readonly secondary: "white";
+        readonly border: "gray";
+        readonly text: "white";
+        readonly dimText: "gray";
+    };
+    readonly filling: {
+        readonly primary: "cyan";
+        readonly secondary: "cyanBright";
+        readonly border: "cyan";
+        readonly text: "white";
+        readonly dimText: "gray";
+    };
+    readonly disconnected: {
+        readonly primary: "gray";
+        readonly secondary: "white";
+        readonly border: "gray";
+        readonly text: "white";
+        readonly dimText: "gray";
+    };
+};
+export type ThemeKey = keyof typeof TERMINAL_COLORS;
+export declare function getThemeForState(liquidState: LiquidState, connected: boolean): ThemeKey;
+export declare function getTerminalTheme(themeKey: ThemeKey): {
+    readonly primary: "yellow";
+    readonly secondary: "yellowBright";
+    readonly border: "yellow";
+    readonly text: "white";
+    readonly dimText: "gray";
+} | {
+    readonly primary: "yellow";
+    readonly secondary: "yellowBright";
+    readonly border: "yellow";
+    readonly text: "white";
+    readonly dimText: "gray";
+} | {
+    readonly primary: "cyan";
+    readonly secondary: "cyanBright";
+    readonly border: "cyan";
+    readonly text: "white";
+    readonly dimText: "gray";
+} | {
+    readonly primary: "gray";
+    readonly secondary: "white";
+    readonly border: "gray";
+    readonly text: "white";
+    readonly dimText: "gray";
+} | {
+    readonly primary: "cyan";
+    readonly secondary: "cyanBright";
+    readonly border: "cyan";
+    readonly text: "white";
+    readonly dimText: "gray";
+} | {
+    readonly primary: "gray";
+    readonly secondary: "white";
+    readonly border: "gray";
+    readonly text: "white";
+    readonly dimText: "gray";
+};

package/dist/lib/theme.js

@@ -0,0 +1,112 @@
+import { LiquidState } from './types.js';
+export const THEMES = {
+    heating: {
+        primary: '#FF6B35', // Orange
+        secondary: '#FF8C5A',
+        text: 'white',
+        dimText: '#FFD4C4',
+        name: 'Heating',
+    },
+    cooling: {
+        primary: '#FF6B35', // Orange (cooling down but not at temp yet)
+        secondary: '#FF8C5A',
+        text: 'white',
+        dimText: '#FFD4C4',
+        name: 'Cooling',
+    },
+    stable: {
+        primary: '#4A90D9', // Blue
+        secondary: '#6BA3E0',
+        text: 'white',
+        dimText: '#B8D4F0',
+        name: 'Perfect',
+    },
+    empty: {
+        primary: '#666666', // Grey
+        secondary: '#888888',
+        text: 'white',
+        dimText: '#AAAAAA',
+        name: 'Empty',
+    },
+    filling: {
+        primary: '#4A90D9', // Blue
+        secondary: '#6BA3E0',
+        text: 'white',
+        dimText: '#B8D4F0',
+        name: 'Filling',
+    },
+    disconnected: {
+        primary: '#444444',
+        secondary: '#666666',
+        text: 'white',
+        dimText: '#999999',
+        name: 'Disconnected',
+    },
+};
+// Terminal color mappings (closest ANSI colors)
+export const TERMINAL_COLORS = {
+    heating: {
+        primary: 'yellow', // Closest to orange in terminal
+        secondary: 'yellowBright',
+        border: 'yellow',
+        text: 'white',
+        dimText: 'gray',
+    },
+    cooling: {
+        primary: 'yellow',
+        secondary: 'yellowBright',
+        border: 'yellow',
+        text: 'white',
+        dimText: 'gray',
+    },
+    stable: {
+        primary: 'cyan',
+        secondary: 'cyanBright',
+        border: 'cyan',
+        text: 'white',
+        dimText: 'gray',
+    },
+    empty: {
+        primary: 'gray',
+        secondary: 'white',
+        border: 'gray',
+        text: 'white',
+        dimText: 'gray',
+    },
+    filling: {
+        primary: 'cyan',
+        secondary: 'cyanBright',
+        border: 'cyan',
+        text: 'white',
+        dimText: 'gray',
+    },
+    disconnected: {
+        primary: 'gray',
+        secondary: 'white',
+        border: 'gray',
+        text: 'white',
+        dimText: 'gray',
+    },
+};
+export function getThemeForState(liquidState, connected) {
+    if (!connected) {
+        return 'disconnected';
+    }
+    switch (liquidState) {
+        case LiquidState.Empty:
+            return 'empty';
+        case LiquidState.Filling:
+            return 'filling';
+        case LiquidState.Heating:
+            return 'heating';
+        case LiquidState.Cooling:
+            return 'cooling';
+        case LiquidState.StableTemperature:
+            return 'stable';
+        default:
+            return 'empty';
+    }
+}
+export function getTerminalTheme(themeKey) {
+    return TERMINAL_COLORS[themeKey];
+}

package/dist/lib/types.d.ts

@@ -29,7 +29,6 @@ export interface RGBColor {
 export interface Preset {
     id: string;
     name: string;
-    icon: string;
     temperature: number;
 }
 export interface AppSettings {

package/dist/lib/types.js

@@ -12,20 +12,20 @@ export var TemperatureUnit;
     TemperatureUnit[TemperatureUnit["Fahrenheit"] = 1] = "Fahrenheit";
 })(TemperatureUnit || (TemperatureUnit = {}));
 export const DEFAULT_PRESETS = [
-    { id: '1', name: 'Latte', icon: '☕', temperature: 52.0 },
-    { id: '2', name: 'Coffee', icon: '🍵', temperature: 55.0 },
-    { id: '3', name: 'Tea', icon: '🍃', temperature: 60.0 },
+    { id: "1", name: "Latte", temperature: 52.0 },
+    { id: "2", name: "Coffee", temperature: 55.56 },
+    { id: "3", name: "Tea", temperature: 60.0 },
 ];
-export const EMBER_SERVICE_UUID = 'fc543622236c4c948fa9944a3e5353fa';
+export const EMBER_SERVICE_UUID = "fc543622236c4c948fa9944a3e5353fa";
 export const EMBER_CHARACTERISTICS = {
-    MUG_NAME: 'fc540001236c4c948fa9944a3e5353fa',
-    CURRENT_TEMP: 'fc540002236c4c948fa9944a3e5353fa',
-    TARGET_TEMP: 'fc540003236c4c948fa9944a3e5353fa',
-    TEMP_UNIT: 'fc540004236c4c948fa9944a3e5353fa',
-    BATTERY: 'fc540007236c4c948fa9944a3e5353fa',
-    LIQUID_STATE: 'fc540008236c4c948fa9944a3e5353fa',
-    PUSH_EVENTS: 'fc540012236c4c948fa9944a3e5353fa',
-    LED_COLOR: 'fc540014236c4c948fa9944a3e5353fa',
+    MUG_NAME: "fc540001236c4c948fa9944a3e5353fa",
+    CURRENT_TEMP: "fc540002236c4c948fa9944a3e5353fa",
+    TARGET_TEMP: "fc540003236c4c948fa9944a3e5353fa",
+    TEMP_UNIT: "fc540004236c4c948fa9944a3e5353fa",
+    BATTERY: "fc540007236c4c948fa9944a3e5353fa",
+    LIQUID_STATE: "fc540008236c4c948fa9944a3e5353fa",
+    PUSH_EVENTS: "fc540012236c4c948fa9944a3e5353fa",
+    LED_COLOR: "fc540014236c4c948fa9944a3e5353fa",
 };
 export const MIN_TEMP_CELSIUS = 50;
 export const MAX_TEMP_CELSIUS = 63;

package/dist/lib/utils.d.ts

@@ -1,15 +1,18 @@
-import { TemperatureUnit, LiquidState } from './types.js';
+import { TemperatureUnit, LiquidState } from "./types.js";
 export declare function formatTemperature(temp: number, unit: TemperatureUnit): string;
 export declare function celsiusToFahrenheit(celsius: number): number;
 export declare function fahrenheitToCelsius(fahrenheit: number): number;
 export declare function formatBatteryLevel(level: number): string;
 export declare function getBatteryIcon(level: number, isCharging: boolean): string;
 export declare function getLiquidStateText(state: LiquidState): string;
-export declare function getLiquidStateIcon(state: LiquidState): string;
 export declare function clampTemperature(temp: number): number;
 export declare function formatDuration(minutes: number): string;
-export declare function estimateTimeToTargetTemp(currentTemp: number, targetTemp: number, liquidState: LiquidState): number | null;
-export declare function estimateBatteryLife(batteryLevel: number, isCharging: boolean, liquidState: LiquidState): number | null;
+export declare function estimateTimeToTargetTemp(currentTemp: number, targetTemp: number, liquidState: LiquidState, dynamicRate?: number): number | null;
+export declare function estimateBatteryLife(batteryLevel: number, isCharging: boolean, liquidState: LiquidState, dynamicRate?: number): number | null;
+export declare function calculateRate(history: {
+    value: number;
+    time: number;
+}[], windowMs?: number): number;
 export declare function getTemperatureColor(currentTemp: number, targetTemp: number): string;
 export declare function interpolateColor(value: number, minColor: [number, number, number], maxColor: [number, number, number]): [number, number, number];
 export declare function rgbToHex(r: number, g: number, b: number): string;