ember-mug 0.1.3

package/dist/hooks/useMug.d.ts

@@ -0,0 +1,14 @@
+import { MugState, TemperatureUnit, RGBColor } from '../lib/types.js';
+interface UseMugReturn {
+    state: MugState;
+    isScanning: boolean;
+    error: string | null;
+    foundMugName: string | null;
+    startScanning: () => Promise<void>;
+    setTargetTemp: (temp: number) => Promise<void>;
+    setTemperatureUnit: (unit: TemperatureUnit) => Promise<void>;
+    setLedColor: (color: RGBColor) => Promise<void>;
+    disconnect: () => Promise<void>;
+}
+export declare function useMug(): UseMugReturn;
+export {};

package/dist/hooks/useMug.js

@@ -0,0 +1,112 @@
+import { useState, useEffect, useCallback } from 'react';
+import { getBluetoothManager } from '../lib/bluetooth.js';
+import { LiquidState, TemperatureUnit } from '../lib/types.js';
+const initialState = {
+    connected: false,
+    batteryLevel: 0,
+    isCharging: false,
+    currentTemp: 0,
+    targetTemp: 55,
+    liquidState: LiquidState.Empty,
+    temperatureUnit: TemperatureUnit.Celsius,
+    color: { r: 255, g: 147, b: 41, a: 255 },
+    mugName: '',
+};
+export function useMug() {
+    const [state, setState] = useState(initialState);
+    const [isScanning, setIsScanning] = useState(false);
+    const [error, setError] = useState(null);
+    const [foundMugName, setFoundMugName] = useState(null);
+    useEffect(() => {
+        const manager = getBluetoothManager();
+        const handleStateChange = (newState) => {
+            setState(newState);
+        };
+        const handleScanning = (scanning) => {
+            setIsScanning(scanning);
+        };
+        const handleError = (err) => {
+            setError(err.message);
+        };
+        const handleMugFound = (name) => {
+            setFoundMugName(name);
+        };
+        const handleConnected = () => {
+            setError(null);
+        };
+        const handleDisconnected = () => {
+            setFoundMugName(null);
+        };
+        manager.on('stateChange', handleStateChange);
+        manager.on('scanning', handleScanning);
+        manager.on('error', handleError);
+        manager.on('mugFound', handleMugFound);
+        manager.on('connected', handleConnected);
+        manager.on('disconnected', handleDisconnected);
+        return () => {
+            manager.off('stateChange', handleStateChange);
+            manager.off('scanning', handleScanning);
+            manager.off('error', handleError);
+            manager.off('mugFound', handleMugFound);
+            manager.off('connected', handleConnected);
+            manager.off('disconnected', handleDisconnected);
+        };
+    }, []);
+    const startScanning = useCallback(async () => {
+        setError(null);
+        const manager = getBluetoothManager();
+        try {
+            await manager.startScanning();
+        }
+        catch (err) {
+            setError(err instanceof Error ? err.message : 'Failed to start scanning');
+        }
+    }, []);
+    const setTargetTemp = useCallback(async (temp) => {
+        const manager = getBluetoothManager();
+        try {
+            await manager.setTargetTemp(temp);
+        }
+        catch (err) {
+            setError(err instanceof Error ? err.message : 'Failed to set temperature');
+        }
+    }, []);
+    const setTemperatureUnit = useCallback(async (unit) => {
+        const manager = getBluetoothManager();
+        try {
+            await manager.setTemperatureUnit(unit);
+        }
+        catch (err) {
+            setError(err instanceof Error ? err.message : 'Failed to set temperature unit');
+        }
+    }, []);
+    const setLedColor = useCallback(async (color) => {
+        const manager = getBluetoothManager();
+        try {
+            await manager.setLedColor(color);
+        }
+        catch (err) {
+            setError(err instanceof Error ? err.message : 'Failed to set LED color');
+        }
+    }, []);
+    const disconnect = useCallback(async () => {
+        const manager = getBluetoothManager();
+        try {
+            await manager.disconnect();
+        }
+        catch (err) {
+            setError(err instanceof Error ? err.message : 'Failed to disconnect');
+        }
+    }, []);
+    return {
+        state,
+        isScanning,
+        error,
+        foundMugName,
+        startScanning,
+        setTargetTemp,
+        setTemperatureUnit,
+        setLedColor,
+        disconnect,
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export * from './lib/types.js';
+export * from './lib/utils.js';
+export * from './lib/bluetooth.js';
+export * from './lib/settings.js';
+export { useMug } from './hooks/useMug.js';

package/dist/index.js

@@ -0,0 +1,5 @@
+export * from './lib/types.js';
+export * from './lib/utils.js';
+export * from './lib/bluetooth.js';
+export * from './lib/settings.js';
+export { useMug } from './hooks/useMug.js';

package/dist/lib/bluetooth.d.ts

@@ -0,0 +1,43 @@
+import { EventEmitter } from 'events';
+import { MugState, TemperatureUnit, RGBColor } from './types.js';
+export interface BluetoothManagerEvents {
+    stateChange: (state: MugState) => void;
+    connected: () => void;
+    disconnected: () => void;
+    scanning: (isScanning: boolean) => void;
+    error: (error: Error) => void;
+    mugFound: (name: string) => void;
+}
+export declare class BluetoothManager extends EventEmitter {
+    private peripheral;
+    private characteristics;
+    private isConnected;
+    private pollInterval;
+    private state;
+    constructor();
+    private setupNobleListeners;
+    startScanning(): Promise<void>;
+    stopScanning(): Promise<void>;
+    private connect;
+    private discoverCharacteristics;
+    private setupNotifications;
+    private handlePushEvent;
+    private readInitialValues;
+    private startPolling;
+    private handleDisconnect;
+    private readCharacteristic;
+    private writeCharacteristic;
+    private readCurrentTemp;
+    private readTargetTemp;
+    private readBattery;
+    private readLiquidState;
+    private readTemperatureUnit;
+    private readLedColor;
+    setTargetTemp(temp: number): Promise<void>;
+    setTemperatureUnit(unit: TemperatureUnit): Promise<void>;
+    setLedColor(color: RGBColor): Promise<void>;
+    getState(): MugState;
+    private emitState;
+    disconnect(): Promise<void>;
+}
+export declare function getBluetoothManager(): BluetoothManager;

package/dist/lib/bluetooth.js

@@ -0,0 +1,334 @@
+import noble from '@abandonware/noble';
+import { EventEmitter } from 'events';
+import { LiquidState, TemperatureUnit, EMBER_SERVICE_UUID, EMBER_CHARACTERISTICS, MIN_TEMP_CELSIUS, MAX_TEMP_CELSIUS, } from './types.js';
+// Noble's state property exists but isn't properly typed
+const getNobleState = () => noble.state;
+export class BluetoothManager extends EventEmitter {
+    peripheral = null;
+    characteristics = new Map();
+    isConnected = false;
+    pollInterval = null;
+    state = {
+        connected: false,
+        batteryLevel: 0,
+        isCharging: false,
+        currentTemp: 0,
+        targetTemp: 0,
+        liquidState: LiquidState.Empty,
+        temperatureUnit: TemperatureUnit.Celsius,
+        color: { r: 255, g: 255, b: 255, a: 255 },
+        mugName: '',
+    };
+    constructor() {
+        super();
+        this.setupNobleListeners();
+    }
+    setupNobleListeners() {
+        noble.on('stateChange', (state) => {
+            if (state === 'poweredOn') {
+                // Ready for scanning
+            }
+            else {
+                this.emit('error', new Error(`Bluetooth state: ${state}`));
+            }
+        });
+        noble.on('discover', async (peripheral) => {
+            const name = peripheral.advertisement.localName || '';
+            if (name.toLowerCase().includes('ember')) {
+                this.emit('mugFound', name);
+                await this.stopScanning();
+                this.peripheral = peripheral;
+                await this.connect();
+            }
+        });
+    }
+    async startScanning() {
+        return new Promise((resolve, reject) => {
+            if (getNobleState() === 'poweredOn') {
+                this.emit('scanning', true);
+                noble.startScanning([EMBER_SERVICE_UUID], false, (error) => {
+                    if (error) {
+                        reject(error);
+                    }
+                    else {
+                        resolve();
+                    }
+                });
+            }
+            else {
+                noble.once('stateChange', (state) => {
+                    if (state === 'poweredOn') {
+                        this.emit('scanning', true);
+                        noble.startScanning([EMBER_SERVICE_UUID], false, (error) => {
+                            if (error) {
+                                reject(error);
+                            }
+                            else {
+                                resolve();
+                            }
+                        });
+                    }
+                    else {
+                        reject(new Error(`Bluetooth not available: ${state}`));
+                    }
+                });
+            }
+        });
+    }
+    async stopScanning() {
+        this.emit('scanning', false);
+        return new Promise((resolve) => {
+            noble.stopScanning(() => resolve());
+        });
+    }
+    async connect() {
+        if (!this.peripheral) {
+            throw new Error('No peripheral to connect to');
+        }
+        return new Promise((resolve, reject) => {
+            this.peripheral.connect(async (error) => {
+                if (error) {
+                    reject(error);
+                    return;
+                }
+                this.isConnected = true;
+                this.state.connected = true;
+                this.state.mugName = this.peripheral.advertisement.localName || 'Ember Mug';
+                this.peripheral.once('disconnect', () => {
+                    this.handleDisconnect();
+                });
+                try {
+                    await this.discoverCharacteristics();
+                    await this.setupNotifications();
+                    await this.readInitialValues();
+                    this.startPolling();
+                    this.emit('connected');
+                    this.emitState();
+                    resolve();
+                }
+                catch (err) {
+                    reject(err);
+                }
+            });
+        });
+    }
+    async discoverCharacteristics() {
+        return new Promise((resolve, reject) => {
+            this.peripheral.discoverAllServicesAndCharacteristics((error, services, characteristics) => {
+                if (error) {
+                    reject(error);
+                    return;
+                }
+                for (const char of characteristics || []) {
+                    const uuid = char.uuid.toLowerCase().replace(/-/g, '');
+                    this.characteristics.set(uuid, char);
+                }
+                resolve();
+            });
+        });
+    }
+    async setupNotifications() {
+        const pushEventsChar = this.characteristics.get(EMBER_CHARACTERISTICS.PUSH_EVENTS);
+        if (pushEventsChar) {
+            return new Promise((resolve, reject) => {
+                pushEventsChar.subscribe((error) => {
+                    if (error) {
+                        reject(error);
+                        return;
+                    }
+                    pushEventsChar.on('data', (data) => {
+                        this.handlePushEvent(data);
+                    });
+                    resolve();
+                });
+            });
+        }
+    }
+    handlePushEvent(data) {
+        const eventType = data[0];
+        switch (eventType) {
+            case 1: // Battery changed
+                this.readBattery();
+                break;
+            case 2: // Started charging
+                this.state.isCharging = true;
+                this.emitState();
+                break;
+            case 3: // Stopped charging
+                this.state.isCharging = false;
+                this.emitState();
+                break;
+            case 4: // Target temp changed
+                this.readTargetTemp();
+                break;
+            case 5: // Current temp changed
+                this.readCurrentTemp();
+                break;
+            case 8: // Liquid state changed
+                this.readLiquidState();
+                break;
+        }
+    }
+    async readInitialValues() {
+        await Promise.all([
+            this.readCurrentTemp(),
+            this.readTargetTemp(),
+            this.readBattery(),
+            this.readLiquidState(),
+            this.readTemperatureUnit(),
+            this.readLedColor(),
+        ]);
+    }
+    startPolling() {
+        // Poll temperature every 2 seconds
+        this.pollInterval = setInterval(async () => {
+            if (this.isConnected) {
+                await this.readCurrentTemp();
+                await this.readLiquidState();
+            }
+        }, 2000);
+    }
+    handleDisconnect() {
+        this.isConnected = false;
+        this.state.connected = false;
+        if (this.pollInterval) {
+            clearInterval(this.pollInterval);
+            this.pollInterval = null;
+        }
+        this.characteristics.clear();
+        this.emit('disconnected');
+        this.emitState();
+    }
+    async readCharacteristic(uuid) {
+        const char = this.characteristics.get(uuid);
+        if (!char)
+            return null;
+        return new Promise((resolve) => {
+            char.read((error, data) => {
+                if (error) {
+                    resolve(null);
+                }
+                else {
+                    resolve(data);
+                }
+            });
+        });
+    }
+    async writeCharacteristic(uuid, data) {
+        const char = this.characteristics.get(uuid);
+        if (!char)
+            return;
+        return new Promise((resolve, reject) => {
+            char.write(data, false, (error) => {
+                if (error) {
+                    reject(error);
+                }
+                else {
+                    resolve();
+                }
+            });
+        });
+    }
+    async readCurrentTemp() {
+        const data = await this.readCharacteristic(EMBER_CHARACTERISTICS.CURRENT_TEMP);
+        if (data && data.length >= 2) {
+            const temp = data.readUInt16LE(0) * 0.01;
+            this.state.currentTemp = temp;
+            this.emitState();
+        }
+    }
+    async readTargetTemp() {
+        const data = await this.readCharacteristic(EMBER_CHARACTERISTICS.TARGET_TEMP);
+        if (data && data.length >= 2) {
+            const temp = data.readUInt16LE(0) * 0.01;
+            this.state.targetTemp = temp;
+            this.emitState();
+        }
+    }
+    async readBattery() {
+        const data = await this.readCharacteristic(EMBER_CHARACTERISTICS.BATTERY);
+        if (data && data.length >= 2) {
+            this.state.batteryLevel = data[0];
+            this.state.isCharging = data[1] === 1;
+            this.emitState();
+        }
+    }
+    async readLiquidState() {
+        const data = await this.readCharacteristic(EMBER_CHARACTERISTICS.LIQUID_STATE);
+        if (data && data.length >= 1) {
+            const state = data[0];
+            if (Object.values(LiquidState).includes(state)) {
+                this.state.liquidState = state;
+                this.emitState();
+            }
+        }
+    }
+    async readTemperatureUnit() {
+        const data = await this.readCharacteristic(EMBER_CHARACTERISTICS.TEMP_UNIT);
+        if (data && data.length >= 1) {
+            this.state.temperatureUnit = data[0];
+            this.emitState();
+        }
+    }
+    async readLedColor() {
+        const data = await this.readCharacteristic(EMBER_CHARACTERISTICS.LED_COLOR);
+        if (data && data.length >= 4) {
+            this.state.color = {
+                r: data[0],
+                g: data[1],
+                b: data[2],
+                a: data[3],
+            };
+            this.emitState();
+        }
+    }
+    async setTargetTemp(temp) {
+        const clampedTemp = Math.max(MIN_TEMP_CELSIUS, Math.min(MAX_TEMP_CELSIUS, temp));
+        const value = Math.round(clampedTemp * 100);
+        const buffer = Buffer.alloc(2);
+        buffer.writeUInt16LE(value, 0);
+        await this.writeCharacteristic(EMBER_CHARACTERISTICS.TARGET_TEMP, buffer);
+        this.state.targetTemp = clampedTemp;
+        this.emitState();
+    }
+    async setTemperatureUnit(unit) {
+        const buffer = Buffer.from([unit]);
+        await this.writeCharacteristic(EMBER_CHARACTERISTICS.TEMP_UNIT, buffer);
+        this.state.temperatureUnit = unit;
+        this.emitState();
+    }
+    async setLedColor(color) {
+        const buffer = Buffer.from([color.r, color.g, color.b, color.a]);
+        await this.writeCharacteristic(EMBER_CHARACTERISTICS.LED_COLOR, buffer);
+        this.state.color = color;
+        this.emitState();
+    }
+    getState() {
+        return { ...this.state };
+    }
+    emitState() {
+        this.emit('stateChange', this.getState());
+    }
+    async disconnect() {
+        if (this.pollInterval) {
+            clearInterval(this.pollInterval);
+            this.pollInterval = null;
+        }
+        if (this.peripheral && this.isConnected) {
+            return new Promise((resolve) => {
+                this.peripheral.disconnect(() => {
+                    this.handleDisconnect();
+                    resolve();
+                });
+            });
+        }
+    }
+}
+// Singleton instance
+let instance = null;
+export function getBluetoothManager() {
+    if (!instance) {
+        instance = new BluetoothManager();
+    }
+    return instance;
+}

package/dist/lib/settings.d.ts

@@ -0,0 +1,28 @@
+import { AppSettings, Preset, TemperatureUnit } from './types.js';
+export declare function getSettings(): AppSettings;
+export declare function getPresets(): Preset[];
+export declare function setPresets(presets: Preset[]): void;
+export declare function addPreset(preset: Preset): void;
+export declare function removePreset(id: string): void;
+export declare function updatePreset(id: string, updates: Partial<Preset>): void;
+export declare function getTemperatureUnit(): TemperatureUnit;
+export declare function setTemperatureUnit(unit: TemperatureUnit): void;
+export declare function getLastTargetTemp(): number;
+export declare function setLastTargetTemp(temp: number): void;
+export declare function getLedColor(): {
+    r: number;
+    g: number;
+    b: number;
+    a: number;
+};
+export declare function setLedColor(color: {
+    r: number;
+    g: number;
+    b: number;
+    a: number;
+}): void;
+export declare function getNotifyOnTemperatureReached(): boolean;
+export declare function setNotifyOnTemperatureReached(enabled: boolean): void;
+export declare function getNotifyAtBatteryPercentage(): number;
+export declare function setNotifyAtBatteryPercentage(percentage: number): void;
+export declare function resetSettings(): void;

package/dist/lib/settings.js

@@ -0,0 +1,73 @@
+import Conf from 'conf';
+import { TemperatureUnit, DEFAULT_PRESETS, } from './types.js';
+const config = new Conf({
+    projectName: 'ember-mug-cli',
+    defaults: {
+        presets: DEFAULT_PRESETS,
+        temperatureUnit: TemperatureUnit.Celsius,
+        notifyOnTemperatureReached: true,
+        notifyAtBatteryPercentage: 15,
+        lastTargetTemp: 55,
+        ledColor: { r: 255, g: 147, b: 41, a: 255 }, // Warm orange
+    },
+});
+export function getSettings() {
+    return {
+        presets: config.get('presets'),
+        temperatureUnit: config.get('temperatureUnit'),
+        notifyOnTemperatureReached: config.get('notifyOnTemperatureReached'),
+        notifyAtBatteryPercentage: config.get('notifyAtBatteryPercentage'),
+    };
+}
+export function getPresets() {
+    return config.get('presets');
+}
+export function setPresets(presets) {
+    config.set('presets', presets);
+}
+export function addPreset(preset) {
+    const presets = getPresets();
+    presets.push(preset);
+    setPresets(presets);
+}
+export function removePreset(id) {
+    const presets = getPresets().filter((p) => p.id !== id);
+    setPresets(presets);
+}
+export function updatePreset(id, updates) {
+    const presets = getPresets().map((p) => p.id === id ? { ...p, ...updates } : p);
+    setPresets(presets);
+}
+export function getTemperatureUnit() {
+    return config.get('temperatureUnit');
+}
+export function setTemperatureUnit(unit) {
+    config.set('temperatureUnit', unit);
+}
+export function getLastTargetTemp() {
+    return config.get('lastTargetTemp');
+}
+export function setLastTargetTemp(temp) {
+    config.set('lastTargetTemp', temp);
+}
+export function getLedColor() {
+    return config.get('ledColor');
+}
+export function setLedColor(color) {
+    config.set('ledColor', color);
+}
+export function getNotifyOnTemperatureReached() {
+    return config.get('notifyOnTemperatureReached');
+}
+export function setNotifyOnTemperatureReached(enabled) {
+    config.set('notifyOnTemperatureReached', enabled);
+}
+export function getNotifyAtBatteryPercentage() {
+    return config.get('notifyAtBatteryPercentage');
+}
+export function setNotifyAtBatteryPercentage(percentage) {
+    config.set('notifyAtBatteryPercentage', percentage);
+}
+export function resetSettings() {
+    config.clear();
+}

package/dist/lib/types.d.ts

@@ -0,0 +1,57 @@
+export declare enum LiquidState {
+    Empty = 1,
+    Filling = 2,
+    Cooling = 4,
+    Heating = 5,
+    StableTemperature = 6
+}
+export declare enum TemperatureUnit {
+    Celsius = 0,
+    Fahrenheit = 1
+}
+export interface MugState {
+    connected: boolean;
+    batteryLevel: number;
+    isCharging: boolean;
+    currentTemp: number;
+    targetTemp: number;
+    liquidState: LiquidState;
+    temperatureUnit: TemperatureUnit;
+    color: RGBColor;
+    mugName: string;
+}
+export interface RGBColor {
+    r: number;
+    g: number;
+    b: number;
+    a: number;
+}
+export interface Preset {
+    id: string;
+    name: string;
+    icon: string;
+    temperature: number;
+}
+export interface AppSettings {
+    presets: Preset[];
+    temperatureUnit: TemperatureUnit;
+    notifyOnTemperatureReached: boolean;
+    notifyAtBatteryPercentage: number;
+}
+export declare const DEFAULT_PRESETS: Preset[];
+export declare const EMBER_SERVICE_UUID = "fc543622236c4c948fa9944a3e5353fa";
+export declare const EMBER_CHARACTERISTICS: {
+    readonly MUG_NAME: "fc540001236c4c948fa9944a3e5353fa";
+    readonly CURRENT_TEMP: "fc540002236c4c948fa9944a3e5353fa";
+    readonly TARGET_TEMP: "fc540003236c4c948fa9944a3e5353fa";
+    readonly TEMP_UNIT: "fc540004236c4c948fa9944a3e5353fa";
+    readonly BATTERY: "fc540007236c4c948fa9944a3e5353fa";
+    readonly LIQUID_STATE: "fc540008236c4c948fa9944a3e5353fa";
+    readonly PUSH_EVENTS: "fc540012236c4c948fa9944a3e5353fa";
+    readonly LED_COLOR: "fc540014236c4c948fa9944a3e5353fa";
+};
+export declare const MIN_TEMP_CELSIUS = 50;
+export declare const MAX_TEMP_CELSIUS = 63;
+export declare const BATTERY_DRAIN_RATE_HEATING = 0.5;
+export declare const BATTERY_DRAIN_RATE_MAINTAINING = 0.2;
+export declare const BATTERY_CHARGE_RATE = 1.5;