@tempivo/sensor-beacon 0.1.1 → 0.3.0

package/{android → android-aar}/library/src/main/java/com/tempivo/sensor/beacon/TempivoSensorBeaconTypes.kt

@@ -20,8 +20,8 @@ data class TempivoSensorBeaconTelemetry(
     val measurementCounter: Long? = null,
     val readingTimestampUnix: Long? = null,
     val readingTimestampIso: String? = null,
-    val periodBaseSeconds: Int? = null,
-    val periodFactor: Int? = null,
+    /** Sample interval from the advertisement, in seconds. */
+    val measurementIntervalSeconds: Int? = null,
     val readings: List<TempivoSensorBeaconReading> = emptyList(),
     val readingsCount: Int = 0,
     val summary: String? = null,
@@ -37,6 +37,4 @@ data class TempivoSensorBeaconDevice(
     val rssi: Int,
     val telemetry: TempivoSensorBeaconTelemetry?,
     val summary: String?,
-    /** `true` for older firmware families; `false` for current; `null` if unknown. */
-    val legacyHint: Boolean?,
 )

package/android-aar/library/src/main/java/com/tempivo/sensor/beacon/TempivoSensorCalibration.kt

@@ -0,0 +1,36 @@
+package com.tempivo.sensor.beacon
+
+import java.util.Calendar
+import java.util.Locale
+import java.util.TimeZone
+
+data class TempivoSensorCalibration(
+    val laboratoryCalibrationDate: String?,
+    val laboratoryCalibrationTimestamp: Long?,
+)
+
+object TempivoSensorCalibrationDecoder {
+    private const val SECONDS_PER_DAY = 86_400L
+
+    fun decode(raw: Long?): TempivoSensorCalibration {
+        if (raw == null || raw <= 0L) {
+            return TempivoSensorCalibration(null, null)
+        }
+        val date =
+            if (raw < 100_000L) {
+                isoDateUtc(raw * SECONDS_PER_DAY)
+            } else {
+                isoDateUtc(raw)
+            }
+        return TempivoSensorCalibration(date, raw)
+    }
+
+    private fun isoDateUtc(unixSeconds: Long): String {
+        val cal = Calendar.getInstance(TimeZone.getTimeZone("UTC"), Locale.US)
+        cal.timeInMillis = unixSeconds * 1000L
+        val y = cal.get(Calendar.YEAR)
+        val m = cal.get(Calendar.MONTH) + 1
+        val d = cal.get(Calendar.DAY_OF_MONTH)
+        return String.format(Locale.US, "%04d-%02d-%02d", y, m, d)
+    }
+}

package/android-aar/library/src/main/java/com/tempivo/sensor/beacon/TempivoSensorError.kt

@@ -0,0 +1,18 @@
+package com.tempivo.sensor.beacon
+
+class TempivoSensorException(
+    val code: Code,
+    message: String,
+    cause: Throwable? = null,
+) : Exception(message, cause) {
+    enum class Code {
+        INVALID_PIN,
+        INVALID_QR,
+        INVALID_CONFIG,
+        NOT_CONNECTED,
+        UNSUPPORTED_COMMAND,
+        RUNTIME_UNAVAILABLE,
+        CONNECT_FAILED,
+        UNKNOWN,
+    }
+}

package/android-aar/library/src/main/java/com/tempivo/sensor/beacon/TempivoSensorProfile.kt

@@ -0,0 +1,171 @@
+package com.tempivo.sensor.beacon
+
+import org.json.JSONArray
+import org.json.JSONObject
+
+data class TempivoTemperatureAlert(
+    val type: String,
+    val channel: String,
+    val lowC: Double? = null,
+    val highC: Double? = null,
+    val minC: Double? = null,
+    val maxC: Double? = null,
+    val hysteresisC: Double? = null,
+    val transmitOnBreach: Boolean = true,
+    val transmitOnReturn: Boolean = true,
+)
+
+data class TempivoSchedule(
+    val always: Boolean,
+    val weekdays: List<Int> = emptyList(),
+    val from: String? = null,
+    val to: String? = null,
+    val utcOffsetMinutes: Int = 0,
+)
+
+data class TempivoSensorConfiguration(
+    val temperatureAlerts: List<TempivoTemperatureAlert>,
+    val schedule: TempivoSchedule,
+)
+
+object TempivoSensorProfile {
+    private val timeRe = Regex("^([01]\\d|2[0-3]):([0-5]\\d)$")
+
+    fun parseJson(json: String): TempivoSensorConfiguration {
+        val root =
+            try {
+                JSONObject(json)
+            } catch (_: Exception) {
+                throw TempivoSensorException(TempivoSensorException.Code.INVALID_CONFIG, "Configuration is not valid JSON.")
+            }
+        return parse(root)
+    }
+
+    fun parse(root: JSONObject): TempivoSensorConfiguration {
+        if (root.has("profiles") && root.optJSONArray("profiles") != null) {
+            throw invalid("Pass one profile from GET /devices/config-profiles/{slug}, not the list.")
+        }
+        val body =
+            root.optJSONObject("profile")?.takeIf {
+                it.has("temperatureAlerts") || it.has("schedule") || it.has("slug")
+            } ?: root
+        if (!body.has("temperatureAlerts") && body.has("alarmRules")) {
+            throw invalid("Use a config profile with temperatureAlerts (GET /devices/config-profiles/{slug}), not alarmRules.")
+        }
+        val alerts = mutableListOf<TempivoTemperatureAlert>()
+        val arr = body.optJSONArray("temperatureAlerts") ?: JSONArray()
+        for (i in 0 until arr.length()) {
+            val item = arr.optJSONObject(i) ?: throw invalid("temperatureAlerts[$i] must be an object.")
+            alerts.add(parseAlert(item, i))
+        }
+        return TempivoSensorConfiguration(alerts, parseSchedule(body.optJSONObject("schedule")))
+    }
+
+    fun toJson(cfg: TempivoSensorConfiguration): String {
+        val root = JSONObject()
+        val arr = JSONArray()
+        for (a in cfg.temperatureAlerts) {
+            val o = JSONObject()
+            o.put("type", a.type)
+            o.put("channel", a.channel)
+            if (a.lowC != null) o.put("lowC", a.lowC)
+            if (a.highC != null) o.put("highC", a.highC)
+            if (a.minC != null) o.put("minC", a.minC)
+            if (a.maxC != null) o.put("maxC", a.maxC)
+            if (a.hysteresisC != null) o.put("hysteresisC", a.hysteresisC)
+            o.put("transmitOnBreach", a.transmitOnBreach)
+            if (a.type == "range") o.put("transmitOnReturn", a.transmitOnReturn)
+            arr.put(o)
+        }
+        root.put("temperatureAlerts", arr)
+        val s = JSONObject()
+        if (cfg.schedule.always) {
+            s.put("always", true)
+        } else {
+            val days = JSONArray()
+            cfg.schedule.weekdays.forEach { days.put(it) }
+            s.put("weekdays", days)
+            s.put("from", cfg.schedule.from)
+            s.put("to", cfg.schedule.to)
+            s.put("utcOffsetMinutes", cfg.schedule.utcOffsetMinutes)
+        }
+        root.put("schedule", s)
+        return root.toString()
+    }
+
+    private fun parseAlert(item: JSONObject, index: Int): TempivoTemperatureAlert {
+        val channel = item.optString("channel")
+        if (channel != "ambient" && channel != "probe") {
+            throw invalid("temperatureAlerts[$index].channel must be ambient or probe.")
+        }
+        val hysteresis = if (item.has("hysteresisC") && !item.isNull("hysteresisC")) item.optDouble("hysteresisC") else 1.0
+        val transmit = if (item.has("transmitOnBreach")) item.optBoolean("transmitOnBreach", true) else true
+        val transmitOnReturn = if (item.has("transmitOnReturn")) item.optBoolean("transmitOnReturn", true) else true
+        return when (item.optString("type")) {
+            "range" -> {
+                if (!item.has("lowC") || !item.has("highC")) {
+                    throw invalid("temperatureAlerts[$index] needs lowC and highC.")
+                }
+                val low = item.optDouble("lowC")
+                val high = item.optDouble("highC")
+                if (high <= low) throw invalid("temperatureAlerts[$index]: highC must be greater than lowC.")
+                TempivoTemperatureAlert(
+                    "range",
+                    channel,
+                    lowC = low,
+                    highC = high,
+                    hysteresisC = hysteresis,
+                    transmitOnBreach = transmit,
+                    transmitOnReturn = transmitOnReturn,
+                )
+            }
+            "min" -> {
+                if (!item.has("minC")) throw invalid("temperatureAlerts[$index] needs minC.")
+                TempivoTemperatureAlert("min", channel, minC = item.optDouble("minC"), hysteresisC = hysteresis, transmitOnBreach = transmit)
+            }
+            "max" -> {
+                if (!item.has("maxC")) throw invalid("temperatureAlerts[$index] needs maxC.")
+                TempivoTemperatureAlert("max", channel, maxC = item.optDouble("maxC"), hysteresisC = hysteresis, transmitOnBreach = transmit)
+            }
+            else -> throw invalid("temperatureAlerts[$index].type must be range, min, or max.")
+        }
+    }
+
+    private fun parseSchedule(raw: JSONObject?): TempivoSchedule {
+        if (raw == null || raw.optBoolean("always", false)) return TempivoSchedule(always = true)
+        val weekdays = raw.optJSONArray("weekdays") ?: throw invalid("schedule.weekdays is required.")
+        val days = mutableListOf<Int>()
+        for (i in 0 until weekdays.length()) {
+            val n = weekdays.optInt(i, -1)
+            if (n !in 0..6) throw invalid("schedule.weekdays must be 0 to 6.")
+            days.add(n)
+        }
+        if (days.isEmpty()) throw invalid("schedule.weekdays is required.")
+        val from = raw.optString("from")
+        val to = raw.optString("to")
+        if (!timeRe.matches(from) || !timeRe.matches(to)) {
+            throw invalid("schedule.from and schedule.to must be HH:MM.")
+        }
+        if (!raw.has("utcOffsetMinutes")) throw invalid("schedule.utcOffsetMinutes is required.")
+        return TempivoSchedule(
+            always = false,
+            weekdays = days,
+            from = from,
+            to = to,
+            utcOffsetMinutes = raw.optInt("utcOffsetMinutes"),
+        )
+    }
+
+    fun minutesFromHhmm(value: String): Int {
+        val m = timeRe.matchEntire(value) ?: throw invalid("Invalid time $value.")
+        return m.groupValues[1].toInt() * 60 + m.groupValues[2].toInt()
+    }
+
+    fun hhmmFromMinutes(minutes: Int): String {
+        val clamped = minutes.coerceIn(0, 1439)
+        return String.format(java.util.Locale.US, "%02d:%02d", clamped / 60, clamped % 60)
+    }
+
+    private fun invalid(message: String): TempivoSensorException =
+        TempivoSensorException(TempivoSensorException.Code.INVALID_CONFIG, message)
+}

package/android-aar/library/src/main/java/com/tempivo/sensor/beacon/TempivoSensorQr.kt

@@ -0,0 +1,82 @@
+package com.tempivo.sensor.beacon
+
+import org.json.JSONObject
+import java.util.Locale
+
+data class TempivoSensorQr(
+    val serial: String,
+    val pin: String,
+    val model: String?,
+    val sessionType: TempivoSensorSession.SessionType,
+    val bluetoothMac: String,
+)
+
+object TempivoSensorQrParser {
+    const val DEFAULT_MODEL = "HC7"
+
+    fun normalizeSerial(value: String): String =
+        value.trim().uppercase(Locale.US).replace(Regex("[^A-Z0-9]"), "")
+
+    fun bluetoothMacFromSerial(serial: String): String {
+        val key = normalizeSerial(serial)
+        if (key.length != 12 || !key.matches(Regex("[0-9A-F]{12}"))) {
+            throw TempivoSensorException(TempivoSensorException.Code.INVALID_QR, "Serial must be 12 hex characters.")
+        }
+        return buildString(17) {
+            for (i in 0 until 12 step 2) {
+                if (isNotEmpty()) append(':')
+                append(key, i, i + 2)
+            }
+        }
+    }
+
+    fun sessionTypeFromModel(model: String?): TempivoSensorSession.SessionType {
+        if (model.isNullOrBlank()) return TempivoSensorSession.SessionType.MODERN
+        val m = model.trim().uppercase(Locale.US).replace("-", "")
+        return if (m == "HC5" || m.startsWith("6")) {
+            TempivoSensorSession.SessionType.LEGACY
+        } else {
+            TempivoSensorSession.SessionType.MODERN
+        }
+    }
+
+    fun parse(json: String): TempivoSensorQr {
+        val rec =
+            try {
+                JSONObject(json.trim())
+            } catch (_: Exception) {
+                throw TempivoSensorException(TempivoSensorException.Code.INVALID_QR, "QR is not valid JSON.")
+            }
+        val snRaw =
+            when {
+                rec.has("sn") && !rec.isNull("sn") -> rec.opt("sn")?.toString().orEmpty()
+                else -> ""
+            }
+        val serial = normalizeSerial(snRaw)
+        val pin = pinFrom(rec)
+        if (serial.length < 8) {
+            throw TempivoSensorException(TempivoSensorException.Code.INVALID_QR, "QR is missing serial (sn).")
+        }
+        if (pin.isEmpty()) {
+            throw TempivoSensorException(TempivoSensorException.Code.INVALID_QR, "QR is missing PIN.")
+        }
+        val model = rec.optString("model").trim().ifEmpty { DEFAULT_MODEL }
+        val hex = if (serial.length == 12) serial else serial.takeLast(12)
+        return TempivoSensorQr(
+            serial = serial,
+            pin = pin,
+            model = model,
+            sessionType = sessionTypeFromModel(model),
+            bluetoothMac = bluetoothMacFromSerial(hex),
+        )
+    }
+
+    private fun pinFrom(rec: JSONObject): String {
+        val raw = if (rec.has("pin") && !rec.isNull("pin")) rec.opt("pin") else rec.opt("resetCode")
+        return when (raw) {
+            null, JSONObject.NULL -> ""
+            is Number -> raw.toLong().toString()
+            else -> raw.toString().trim()
+        }
+    }
+}

package/android-aar/library/src/main/java/com/tempivo/sensor/beacon/TempivoSensorSession.kt

@@ -0,0 +1,127 @@
+package com.tempivo.sensor.beacon
+
+import android.app.Application
+import android.content.Context
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.runBlocking
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
+import kotlinx.coroutines.withContext
+
+/**
+ * GATT session: connect, read/write alert rules and schedule, trigger uplink, read lab calibration date.
+ */
+class TempivoSensorSession(
+    context: Context,
+) {
+    enum class SessionType {
+        MODERN,
+        LEGACY,
+    }
+
+    data class TriggerResult(
+        val ok: Boolean,
+        val supported: Boolean,
+    )
+
+    private val application = context.applicationContext as Application
+    private val mutex = Mutex()
+    private var session: SensorBleRuntime.Session? = null
+
+    suspend fun connect(
+        serial: String,
+        bluetoothMac: String,
+        pin: String,
+        sessionType: SessionType = SessionType.MODERN,
+    ) {
+        val pinInt =
+            pin.trim().toIntOrNull()
+                ?: throw TempivoSensorException(TempivoSensorException.Code.INVALID_PIN, "PIN must be numeric.")
+        try {
+            mutex.withLock {
+                SensorBleRuntime.disconnect(session)
+                session = null
+                session =
+                    withContext(Dispatchers.Main) {
+                        SensorBleRuntime.connect(
+                            application = application,
+                            serial = TempivoSensorQrParser.normalizeSerial(serial),
+                            bluetoothMac = bluetoothMac,
+                            pin = pinInt,
+                            legacy = sessionType == SessionType.LEGACY,
+                        )
+                    }
+            }
+        } catch (e: Throwable) {
+            throw SensorBleRuntime.mapError(e).let {
+                if (it.code == TempivoSensorException.Code.UNKNOWN) {
+                    TempivoSensorException(TempivoSensorException.Code.CONNECT_FAILED, "Could not connect.", e)
+                } else {
+                    it
+                }
+            }
+        }
+    }
+
+    suspend fun connect(qr: TempivoSensorQr) {
+        connect(qr.serial, qr.bluetoothMac, qr.pin, qr.sessionType)
+    }
+
+    suspend fun disconnect() {
+        mutex.withLock {
+            SensorBleRuntime.disconnect(session)
+            session = null
+        }
+    }
+
+    suspend fun getConfiguration(): TempivoSensorConfiguration {
+        return runGatt {
+            SensorBleRuntime.decompile(SensorBleRuntime.readConfiguration(requireSession()))
+        }
+    }
+
+    suspend fun getConfigurationJson(): String = TempivoSensorProfile.toJson(getConfiguration())
+
+    suspend fun setConfiguration(configuration: TempivoSensorConfiguration) {
+        val (rules, calendars) = SensorBleRuntime.compileRules(configuration)
+        runGatt {
+            SensorBleRuntime.writeRules(requireSession(), rules, calendars)
+        }
+    }
+
+    suspend fun setConfigurationJson(json: String) {
+        setConfiguration(TempivoSensorProfile.parseJson(json))
+    }
+
+    suspend fun triggerTransmission(): TriggerResult {
+        return runGatt { SensorBleRuntime.triggerTransmission(requireSession()) }
+    }
+
+    suspend fun getCalibration(): TempivoSensorCalibration {
+        return runGatt { SensorBleRuntime.readCalibration(requireSession()) }
+    }
+
+    fun connectBlocking(qr: TempivoSensorQr) = runBlocking { connect(qr) }
+
+    fun disconnectBlocking() = runBlocking { disconnect() }
+
+    fun getConfigurationJsonBlocking(): String = runBlocking { getConfigurationJson() }
+
+    fun setConfigurationJsonBlocking(json: String) = runBlocking { setConfigurationJson(json) }
+
+    fun triggerTransmissionBlocking(): TriggerResult = runBlocking { triggerTransmission() }
+
+    fun getCalibrationBlocking(): TempivoSensorCalibration = runBlocking { getCalibration() }
+
+    private fun requireSession(): SensorBleRuntime.Session =
+        session
+            ?: throw TempivoSensorException(TempivoSensorException.Code.NOT_CONNECTED, "Not connected.")
+
+    private suspend fun <T> runGatt(block: suspend () -> T): T {
+        try {
+            return mutex.withLock { block() }
+        } catch (e: Throwable) {
+            throw SensorBleRuntime.mapError(e)
+        }
+    }
+}

package/{android → android-aar}/settings.gradle

@@ -11,6 +11,7 @@ dependencyResolutionManagement {
     repositories {
         google()
         mavenCentral()
+        maven { url "https://maven.efento.io/releases" }
     }
 }
 

package/app.plugin.cjs

@@ -0,0 +1,142 @@
+const Module = require('module');
+const path = require('path');
+
+function loadConfigPlugins() {
+  const candidates = [process.cwd(), path.dirname(process.cwd())];
+  for (const base of candidates) {
+    try {
+      const id = require.resolve('expo/config-plugins', { paths: [base] });
+      return require(id);
+    } catch {
+      // try next
+    }
+  }
+  try {
+    const fromExpo = require.resolve('expo/package.json', { paths: [process.cwd()] });
+    return Module.createRequire(fromExpo)('expo/config-plugins');
+  } catch {
+    return require('expo/config-plugins');
+  }
+}
+
+const {
+  AndroidConfig,
+  withInfoPlist,
+  withProjectBuildGradle,
+  withSettingsGradle,
+  withGradleProperties,
+} = loadConfigPlugins();
+
+const MAVEN_URL = 'https://maven.efento.io/releases';
+const DEFAULT_BLE_MESSAGE = 'Tempivo uses Bluetooth to find and configure sensors.';
+const MIN_SDK = 26;
+
+function insertKotlinStdlibForce(contents, isKts) {
+  if (contents.includes('TEMPIVO_KOTLIN_STDLIB_FORCE')) return contents;
+  const extra = isKts
+    ? `
+// TEMPIVO_KOTLIN_STDLIB_FORCE
+subprojects {
+  configurations.configureEach {
+    resolutionStrategy {
+      force("org.jetbrains.kotlin:kotlin-stdlib:2.1.20")
+      force("org.jetbrains.kotlin:kotlin-stdlib-jdk7:2.1.20")
+      force("org.jetbrains.kotlin:kotlin-stdlib-jdk8:2.1.20")
+      force("org.jetbrains.kotlin:kotlin-reflect:2.1.20")
+    }
+  }
+}
+`
+    : `
+// TEMPIVO_KOTLIN_STDLIB_FORCE
+subprojects { sub ->
+  sub.configurations.configureEach {
+    resolutionStrategy {
+      force 'org.jetbrains.kotlin:kotlin-stdlib:2.1.20'
+      force 'org.jetbrains.kotlin:kotlin-stdlib-jdk7:2.1.20'
+      force 'org.jetbrains.kotlin:kotlin-stdlib-jdk8:2.1.20'
+      force 'org.jetbrains.kotlin:kotlin-reflect:2.1.20'
+    }
+  }
+}
+`;
+  return `${contents.trimEnd()}\n${extra}`;
+}
+
+function insertMavenRepo(contents, isKts) {
+  if (contents.includes('maven.efento.io')) return contents;
+  const line = isKts
+    ? `\n        maven { url = uri("${MAVEN_URL}") }`
+    : `\n        maven { url '${MAVEN_URL}' }`;
+  const token = 'mavenCentral()';
+  const idx = contents.lastIndexOf(token);
+  if (idx === -1) return contents;
+  const at = idx + token.length;
+  return contents.slice(0, at) + line + contents.slice(at);
+}
+
+function ensureGradleProperty(items, key, value, shouldReplace) {
+  const existing = items.find((item) => item.type === 'property' && item.key === key);
+  if (existing && existing.type === 'property') {
+    if (shouldReplace(existing.value)) existing.value = value;
+    return;
+  }
+  items.push({ type: 'property', key, value });
+}
+
+function withTempivoSensorBeacon(config, props = {}) {
+  const bleMessage =
+    (props && props.bluetoothPermission) ||
+    config.ios?.infoPlist?.NSBluetoothAlwaysUsageDescription ||
+    DEFAULT_BLE_MESSAGE;
+
+  config.android = config.android || {};
+  if (!config.android.minSdkVersion || Number(config.android.minSdkVersion) < MIN_SDK) {
+    config.android.minSdkVersion = MIN_SDK;
+  }
+
+  config = withGradleProperties(config, (mod) => {
+    ensureGradleProperty(
+      mod.modResults,
+      'android.minSdkVersion',
+      String(MIN_SDK),
+      (current) => !current || Number(current) < MIN_SDK,
+    );
+    return mod;
+  });
+
+  config = withInfoPlist(config, (mod) => {
+    if (!mod.modResults.NSBluetoothAlwaysUsageDescription) {
+      mod.modResults.NSBluetoothAlwaysUsageDescription = bleMessage;
+    }
+    if (!mod.modResults.NSBluetoothPeripheralUsageDescription) {
+      mod.modResults.NSBluetoothPeripheralUsageDescription = bleMessage;
+    }
+    return mod;
+  });
+
+  config = AndroidConfig.Permissions.withPermissions(config, [
+    'android.permission.BLUETOOTH',
+    'android.permission.BLUETOOTH_ADMIN',
+    'android.permission.BLUETOOTH_SCAN',
+    'android.permission.BLUETOOTH_CONNECT',
+    'android.permission.ACCESS_FINE_LOCATION',
+  ]);
+
+  config = withSettingsGradle(config, (mod) => {
+    const isKts = mod.modResults.language === 'kt' || (mod.modResults.path || '').endsWith('.kts');
+    mod.modResults.contents = insertMavenRepo(mod.modResults.contents, isKts);
+    return mod;
+  });
+
+  config = withProjectBuildGradle(config, (mod) => {
+    const isKts = mod.modResults.language === 'kt' || (mod.modResults.path || '').endsWith('.kts');
+    mod.modResults.contents = insertMavenRepo(mod.modResults.contents, isKts);
+    mod.modResults.contents = insertKotlinStdlibForce(mod.modResults.contents, isKts);
+    return mod;
+  });
+
+  return config;
+}
+
+module.exports = withTempivoSensorBeacon;

package/dist/calibration.d.ts

@@ -0,0 +1,7 @@
+import type { TempivoSensorCalibration } from './session-types.js';
+/**
+ * Device extended config may send lab date as Unix seconds or as days since 1970.
+ * Values below 100_000 are treated as days (year 2243 in seconds, year 2243 in days is far larger).
+ */
+export declare function decodeLaboratoryCalibrationTimestamp(raw: number | null | undefined): TempivoSensorCalibration;
+export declare function calibrationFromExtendedJson(json: string): TempivoSensorCalibration;

package/dist/calibration.js

@@ -0,0 +1,42 @@
+const SECONDS_PER_DAY = 86_400;
+function pad2(n) {
+    return n < 10 ? `0${n}` : String(n);
+}
+function isoDateUtcFromUnixSeconds(seconds) {
+    const d = new Date(seconds * 1000);
+    return `${d.getUTCFullYear()}-${pad2(d.getUTCMonth() + 1)}-${pad2(d.getUTCDate())}`;
+}
+function isoDateUtcFromEpochDays(days) {
+    return isoDateUtcFromUnixSeconds(days * SECONDS_PER_DAY);
+}
+/**
+ * Device extended config may send lab date as Unix seconds or as days since 1970.
+ * Values below 100_000 are treated as days (year 2243 in seconds, year 2243 in days is far larger).
+ */
+export function decodeLaboratoryCalibrationTimestamp(raw) {
+    if (raw == null || !Number.isFinite(raw) || raw <= 0) {
+        return { laboratoryCalibrationDate: null, laboratoryCalibrationTimestamp: null };
+    }
+    const n = Math.trunc(raw);
+    if (n < 100_000) {
+        return {
+            laboratoryCalibrationDate: isoDateUtcFromEpochDays(n),
+            laboratoryCalibrationTimestamp: n,
+        };
+    }
+    return {
+        laboratoryCalibrationDate: isoDateUtcFromUnixSeconds(n),
+        laboratoryCalibrationTimestamp: n,
+    };
+}
+export function calibrationFromExtendedJson(json) {
+    try {
+        const o = JSON.parse(json);
+        const raw = o.laboratoryCalibrationTimestamp ?? o.laboratory_calibration_date;
+        const n = typeof raw === 'number' ? raw : typeof raw === 'string' ? Number(raw) : null;
+        return decodeLaboratoryCalibrationTimestamp(Number.isFinite(n) ? n : null);
+    }
+    catch {
+        return { laboratoryCalibrationDate: null, laboratoryCalibrationTimestamp: null };
+    }
+}