ember-mug 0.1.3

package/dist/lib/types.js

@@ -0,0 +1,34 @@
+export var LiquidState;
+(function (LiquidState) {
+    LiquidState[LiquidState["Empty"] = 1] = "Empty";
+    LiquidState[LiquidState["Filling"] = 2] = "Filling";
+    LiquidState[LiquidState["Cooling"] = 4] = "Cooling";
+    LiquidState[LiquidState["Heating"] = 5] = "Heating";
+    LiquidState[LiquidState["StableTemperature"] = 6] = "StableTemperature";
+})(LiquidState || (LiquidState = {}));
+export var TemperatureUnit;
+(function (TemperatureUnit) {
+    TemperatureUnit[TemperatureUnit["Celsius"] = 0] = "Celsius";
+    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 },
+];
+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',
+};
+export const MIN_TEMP_CELSIUS = 50;
+export const MAX_TEMP_CELSIUS = 63;
+export const BATTERY_DRAIN_RATE_HEATING = 0.5; // % per minute when heating
+export const BATTERY_DRAIN_RATE_MAINTAINING = 0.2; // % per minute when maintaining
+export const BATTERY_CHARGE_RATE = 1.5; // % per minute when charging

package/dist/lib/utils.d.ts

@@ -0,0 +1,20 @@
+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 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;
+export declare function hexToRgb(hex: string): {
+    r: number;
+    g: number;
+    b: number;
+} | null;

package/dist/lib/utils.js

@@ -0,0 +1,152 @@
+import { TemperatureUnit, LiquidState, MIN_TEMP_CELSIUS, MAX_TEMP_CELSIUS, BATTERY_DRAIN_RATE_HEATING, BATTERY_DRAIN_RATE_MAINTAINING, BATTERY_CHARGE_RATE, } from './types.js';
+export function formatTemperature(temp, unit) {
+    if (unit === TemperatureUnit.Celsius) {
+        return `${temp.toFixed(1)}°C`;
+    }
+    const fahrenheit = (temp * 9) / 5 + 32;
+    return `${Math.round(fahrenheit)}°F`;
+}
+export function celsiusToFahrenheit(celsius) {
+    return (celsius * 9) / 5 + 32;
+}
+export function fahrenheitToCelsius(fahrenheit) {
+    return ((fahrenheit - 32) * 5) / 9;
+}
+export function formatBatteryLevel(level) {
+    return `${level}%`;
+}
+export function getBatteryIcon(level, isCharging) {
+    if (isCharging) {
+        return '⚡';
+    }
+    if (level >= 75)
+        return '████';
+    if (level >= 50)
+        return '███░';
+    if (level >= 25)
+        return '██░░';
+    if (level >= 10)
+        return '█░░░';
+    return '░░░░';
+}
+export function getLiquidStateText(state) {
+    switch (state) {
+        case LiquidState.Empty:
+            return 'Empty';
+        case LiquidState.Filling:
+            return 'Filling';
+        case LiquidState.Cooling:
+            return 'Cooling';
+        case LiquidState.Heating:
+            return 'Heating';
+        case LiquidState.StableTemperature:
+            return 'Perfect';
+        default:
+            return 'Unknown';
+    }
+}
+export function getLiquidStateIcon(state) {
+    switch (state) {
+        case LiquidState.Empty:
+            return '○';
+        case LiquidState.Filling:
+            return '◐';
+        case LiquidState.Cooling:
+            return '❄';
+        case LiquidState.Heating:
+            return '🔥';
+        case LiquidState.StableTemperature:
+            return '✓';
+        default:
+            return '?';
+    }
+}
+export function clampTemperature(temp) {
+    return Math.max(MIN_TEMP_CELSIUS, Math.min(MAX_TEMP_CELSIUS, temp));
+}
+export function formatDuration(minutes) {
+    if (minutes < 1) {
+        return '< 1 min';
+    }
+    if (minutes < 60) {
+        return `${Math.round(minutes)} min`;
+    }
+    const hours = Math.floor(minutes / 60);
+    const mins = Math.round(minutes % 60);
+    if (mins === 0) {
+        return `${hours}h`;
+    }
+    return `${hours}h ${mins}m`;
+}
+export function estimateTimeToTargetTemp(currentTemp, targetTemp, liquidState) {
+    if (liquidState === LiquidState.Empty) {
+        return null;
+    }
+    const tempDiff = Math.abs(targetTemp - currentTemp);
+    if (tempDiff < 0.5) {
+        return 0; // Already at target
+    }
+    // Estimate based on typical Ember mug heating/cooling rates
+    // Heating: approximately 1°C per minute
+    // Cooling: approximately 0.5°C per minute (slower due to insulation)
+    const isHeating = currentTemp < targetTemp;
+    const ratePerMinute = isHeating ? 1.0 : 0.5;
+    return tempDiff / ratePerMinute;
+}
+export function estimateBatteryLife(batteryLevel, isCharging, liquidState) {
+    if (isCharging) {
+        // Estimate time to full charge
+        const remaining = 100 - batteryLevel;
+        if (remaining <= 0)
+            return 0;
+        return remaining / BATTERY_CHARGE_RATE;
+    }
+    if (batteryLevel <= 0) {
+        return 0;
+    }
+    // Determine drain rate based on mug state
+    let drainRate;
+    switch (liquidState) {
+        case LiquidState.Heating:
+            drainRate = BATTERY_DRAIN_RATE_HEATING;
+            break;
+        case LiquidState.StableTemperature:
+        case LiquidState.Cooling:
+            drainRate = BATTERY_DRAIN_RATE_MAINTAINING;
+            break;
+        default:
+            drainRate = 0.1; // Minimal drain when empty or idle
+    }
+    return batteryLevel / drainRate;
+}
+export function getTemperatureColor(currentTemp, targetTemp) {
+    const diff = currentTemp - targetTemp;
+    if (Math.abs(diff) < 1) {
+        return 'green'; // At target
+    }
+    if (diff > 0) {
+        return 'red'; // Too hot
+    }
+    return 'blue'; // Too cold
+}
+export function interpolateColor(value, minColor, maxColor) {
+    const clampedValue = Math.max(0, Math.min(1, value));
+    return [
+        Math.round(minColor[0] + (maxColor[0] - minColor[0]) * clampedValue),
+        Math.round(minColor[1] + (maxColor[1] - minColor[1]) * clampedValue),
+        Math.round(minColor[2] + (maxColor[2] - minColor[2]) * clampedValue),
+    ];
+}
+export function rgbToHex(r, g, b) {
+    return `#${[r, g, b].map((c) => c.toString(16).padStart(2, '0')).join('')}`;
+}
+export function hexToRgb(hex) {
+    const result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex);
+    return result
+        ? {
+            r: parseInt(result[1], 16),
+            g: parseInt(result[2], 16),
+            b: parseInt(result[3], 16),
+        }
+        : null;
+}

package/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "ember-mug",
+  "version": "0.1.3",
+  "description": "A CLI app for controlling Ember mugs via Bluetooth",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "ember-mug": "dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "clean": "rm -rf dist",
+    "prebuild": "npm run clean",
+    "start": "node dist/cli.js",
+    "dev": "tsx src/cli.tsx",
+    "prepublishOnly": "npm run build",
+    "version": "npm run build"
+  },
+  "keywords": [
+    "ember",
+    "ember-mug",
+    "mug",
+    "cli",
+    "bluetooth",
+    "ble",
+    "temperature",
+    "smart-mug"
+  ],
+  "author": "",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/singerbj/ember-cli.git"
+  },
+  "bugs": {
+    "url": "https://github.com/singerbj/ember-cli/issues"
+  },
+  "homepage": "https://github.com/singerbj/ember-cli#readme",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "@abandonware/noble": "^1.9.2-25",
+    "chalk": "^5.3.0",
+    "conf": "^12.0.0",
+    "ink": "^5.0.1",
+    "ink-select-input": "^6.0.0",
+    "ink-spinner": "^5.0.0",
+    "ink-text-input": "^6.0.0",
+    "react": "^18.3.1"
+  },
+  "devDependencies": {
+    "@types/node": "^20.11.0",
+    "@types/react": "^18.3.3",
+    "tsx": "^4.7.0",
+    "typescript": "^5.3.3"
+  }
+}