@tempivo/sensor-beacon 1.1.2 → 1.1.4

package/dist/native-module.js

@@ -1,7 +1,9 @@
 import { requireOptionalNativeModule } from 'expo-modules-core';
 import { TempivoSensorError } from './errors.js';
 import { configToJson, mapNativeError, qrToConnectJson } from './native-helpers.js';
-import { parseSensorConfigurationFromDeviceJson } from './profile.js';
+import { partnerConfigFromProtoBase64 } from './proto/partner-from-proto.js';
+import { partnerConfigToProtoBase64 } from './proto/partner-to-proto.js';
+import { parseSensorConfigurationFromDevice } from './profile.js';
 function getNative() {
     const native = requireOptionalNativeModule('TempivoSensorBeacon');
     if (!native) {
@@ -67,24 +69,65 @@ export async function connect(qr) {
 }
 export async function disconnect() {
     try {
+        lastProtoBase64 = null;
         await getNative().disconnect();
     }
     catch (error) {
         throw mapNativeError(error);
     }
 }
+/** Last ProtoConfig from iOS raw get; used as set baseline. Not part of the partner API. */
+let lastProtoBase64 = null;
+/**
+ * Partner configuration from the device.
+ * Return shape is only {@link TempivoSensorConfiguration} (no debug fields).
+ * iOS and Android use raw ProtoConfig GATT; return shape is only partner fields.
+ */
 export async function getConfiguration() {
     try {
         const json = await getNative().getConfigurationJson();
-        return parseSensorConfigurationFromDeviceJson(json);
+        const parsed = JSON.parse(json);
+        const protoB64 = typeof parsed.protoBase64 === 'string' ? parsed.protoBase64 : null;
+        if (protoB64) {
+            lastProtoBase64 = protoB64;
+            return partnerConfigFromProtoBase64(protoB64);
+        }
+        lastProtoBase64 = null;
+        return parseSensorConfigurationFromDevice(parsed);
     }
     catch (error) {
         throw mapNativeError(error);
     }
 }
+/**
+ * Write partner configuration to the device.
+ * Same public signature as before. Encodes partner config to ProtoConfig and writes raw GATT
+ * when `writeProtoConfigBase64` is available (iOS and Android).
+ */
 export async function setConfigurationJson(config) {
     try {
-        await getNative().setConfigurationJson(configToJson(config));
+        const partner = typeof config === 'string'
+            ? JSON.parse(config)
+            : config;
+        const native = getNative();
+        if (typeof native.writeProtoConfigBase64 === 'function') {
+            let baseline = lastProtoBase64;
+            if (!baseline) {
+                await getConfiguration();
+                baseline = lastProtoBase64;
+            }
+            if (!baseline) {
+                throw new TempivoSensorError('invalidConfig', 'Cannot set: missing baseline ProtoConfig from device get.');
+            }
+            const nextB64 = partnerConfigToProtoBase64(partner, baseline);
+            await native.writeProtoConfigBase64(nextB64);
+            lastProtoBase64 = nextB64;
+            return;
+        }
+        if (typeof native.setConfigurationJson !== 'function') {
+            throw new TempivoSensorError('runtimeUnavailable', 'Native setConfigurationJson is unavailable in this build.');
+        }
+        await native.setConfigurationJson(configToJson(partner));
     }
     catch (error) {
         throw mapNativeError(error);

package/dist/partner-dual-range-fixture.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Partner BLE dual-range + always payload used in regression tests.
+ * Before SDK 1.1.2, get could return empty alerts and/or Sunday-only schedule.
+ */
+export declare const PARTNER_DUAL_RANGE_ALWAYS_BODY: {
+    schedule: {
+        always: boolean;
+    };
+    temperatureAlerts: ({
+        type: "range";
+        channel: "ambient";
+        lowC: number;
+        highC: number;
+        hysteresisC: number;
+        transmitOnBreach: boolean;
+        transmitOnReturn: boolean;
+    } | {
+        type: "range";
+        channel: "probe";
+        lowC: number;
+        highC: number;
+        hysteresisC: number;
+        transmitOnBreach: boolean;
+        transmitOnReturn: boolean;
+    })[];
+    measurementIntervalMinutes: number;
+    transmissionIntervalSeconds: number;
+};

package/dist/partner-dual-range-fixture.js

@@ -0,0 +1,29 @@
+/**
+ * Partner BLE dual-range + always payload used in regression tests.
+ * Before SDK 1.1.2, get could return empty alerts and/or Sunday-only schedule.
+ */
+export const PARTNER_DUAL_RANGE_ALWAYS_BODY = {
+    schedule: { always: true },
+    temperatureAlerts: [
+        {
+            type: 'range',
+            channel: 'ambient',
+            lowC: 2,
+            highC: 8,
+            hysteresisC: 0.5,
+            transmitOnBreach: true,
+            transmitOnReturn: true,
+        },
+        {
+            type: 'range',
+            channel: 'probe',
+            lowC: -30,
+            highC: -18,
+            hysteresisC: 0.5,
+            transmitOnBreach: true,
+            transmitOnReturn: true,
+        },
+    ],
+    measurementIntervalMinutes: 5,
+    transmissionIntervalSeconds: 3600,
+};

package/dist/profile.js

@@ -218,35 +218,49 @@ export const BLE_MAX_TRANSMISSION_INTERVAL_SECONDS = 604_800;
 function parseOptionalIntervals(body, options = {}) {
     const validatePartnerLimits = !options.fromDevice;
     const out = {};
-    if (body.measurementIntervalMinutes !== undefined) {
+    if (body.measurementIntervalMinutes !== undefined && body.measurementIntervalMinutes !== null) {
         const n = parseFiniteNumber(body.measurementIntervalMinutes);
         if (n === undefined || !Number.isFinite(n) || n <= 0) {
-            throw new TempivoSensorError('invalidConfig', 'measurementIntervalMinutes must be a positive number.');
-        }
-        if (validatePartnerLimits) {
-            if (n < BLE_MIN_MEASUREMENT_INTERVAL_MINUTES) {
-                throw new TempivoSensorError('invalidConfig', `measurementIntervalMinutes must be at least ${BLE_MIN_MEASUREMENT_INTERVAL_MINUTES}.`);
+            if (options.fromDevice) {
+                // Vendor may emit 0/null; omit rather than fail the whole get.
+            }
+            else {
+                throw new TempivoSensorError('invalidConfig', 'measurementIntervalMinutes must be a positive number.');
             }
-            if (n > BLE_MAX_MEASUREMENT_INTERVAL_MINUTES) {
-                throw new TempivoSensorError('invalidConfig', `measurementIntervalMinutes must be at most ${BLE_MAX_MEASUREMENT_INTERVAL_MINUTES}.`);
+        }
+        else {
+            if (validatePartnerLimits) {
+                if (n < BLE_MIN_MEASUREMENT_INTERVAL_MINUTES) {
+                    throw new TempivoSensorError('invalidConfig', `measurementIntervalMinutes must be at least ${BLE_MIN_MEASUREMENT_INTERVAL_MINUTES}.`);
+                }
+                if (n > BLE_MAX_MEASUREMENT_INTERVAL_MINUTES) {
+                    throw new TempivoSensorError('invalidConfig', `measurementIntervalMinutes must be at most ${BLE_MAX_MEASUREMENT_INTERVAL_MINUTES}.`);
+                }
             }
+            out.measurementIntervalMinutes = n;
         }
-        out.measurementIntervalMinutes = n;
     }
-    if (body.transmissionIntervalSeconds !== undefined) {
+    if (body.transmissionIntervalSeconds !== undefined && body.transmissionIntervalSeconds !== null) {
         const n = parseFiniteNumber(body.transmissionIntervalSeconds);
-        if (n === undefined || !Number.isInteger(n) || n <= 0) {
-            throw new TempivoSensorError('invalidConfig', 'transmissionIntervalSeconds must be a positive integer.');
-        }
-        if (validatePartnerLimits) {
-            if (n < BLE_MIN_TRANSMISSION_INTERVAL_SECONDS) {
-                throw new TempivoSensorError('invalidConfig', `transmissionIntervalSeconds must be at least ${BLE_MIN_TRANSMISSION_INTERVAL_SECONDS} (1 hour).`);
+        if (n === undefined || !Number.isFinite(n) || n <= 0 || !Number.isInteger(n)) {
+            if (options.fromDevice) {
+                // omit
+            }
+            else {
+                throw new TempivoSensorError('invalidConfig', 'transmissionIntervalSeconds must be a positive integer.');
             }
-            if (n > BLE_MAX_TRANSMISSION_INTERVAL_SECONDS) {
-                throw new TempivoSensorError('invalidConfig', `transmissionIntervalSeconds must be at most ${BLE_MAX_TRANSMISSION_INTERVAL_SECONDS}.`);
+        }
+        else {
+            if (validatePartnerLimits) {
+                if (n < BLE_MIN_TRANSMISSION_INTERVAL_SECONDS) {
+                    throw new TempivoSensorError('invalidConfig', `transmissionIntervalSeconds must be at least ${BLE_MIN_TRANSMISSION_INTERVAL_SECONDS} (1 hour).`);
+                }
+                if (n > BLE_MAX_TRANSMISSION_INTERVAL_SECONDS) {
+                    throw new TempivoSensorError('invalidConfig', `transmissionIntervalSeconds must be at most ${BLE_MAX_TRANSMISSION_INTERVAL_SECONDS}.`);
+                }
             }
+            out.transmissionIntervalSeconds = n;
         }
-        out.transmissionIntervalSeconds = n;
     }
     if (validatePartnerLimits &&
         out.measurementIntervalMinutes != null &&

package/dist/proto/decode-proto-config.d.ts

@@ -0,0 +1,3 @@
+export type ProtoConfigObject = Record<string, unknown>;
+export declare function decodeProtoConfigBytes(bytes: Uint8Array): ProtoConfigObject;
+export declare function decodeProtoConfigBase64(b64: string): ProtoConfigObject;

package/dist/proto/decode-proto-config.js

@@ -0,0 +1,46 @@
+/**
+ * Decode Efento ProtoConfig bytes (same descriptor as web bluetooth module).
+ */
+import protobuf from 'protobufjs/light.js';
+import descriptor from './efento-protobuf-descriptor.js';
+const root = protobuf.Root.fromJSON(descriptor);
+const ProtoConfig = root.lookupType('ProtoConfig');
+export function decodeProtoConfigBytes(bytes) {
+    const msg = ProtoConfig.decode(bytes);
+    return ProtoConfig.toObject(msg, {
+        enums: String,
+        longs: Number,
+        bytes: Array,
+        arrays: true,
+        objects: true,
+        oneofs: true,
+    });
+}
+function base64ToBytes(b64) {
+    const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+    const clean = b64.replace(/=+$/, '').replace(/[^A-Za-z0-9+/]/g, '');
+    const out = new Uint8Array((clean.length * 3) >> 2);
+    let o = 0;
+    for (let i = 0; i < clean.length; i += 4) {
+        const a = chars.indexOf(clean[i] ?? 'A');
+        const b = chars.indexOf(clean[i + 1] ?? 'A');
+        const c = chars.indexOf(clean[i + 2] ?? 'A');
+        const d = chars.indexOf(clean[i + 3] ?? 'A');
+        out[o++] = (a << 2) | (b >> 4);
+        if (clean[i + 2] != null)
+            out[o++] = ((b & 15) << 4) | (c >> 2);
+        if (clean[i + 3] != null)
+            out[o++] = ((c & 3) << 6) | d;
+    }
+    return out.subarray(0, o);
+}
+export function decodeProtoConfigBase64(b64) {
+    if (typeof atob === 'function') {
+        const binary = atob(b64);
+        const bytes = new Uint8Array(binary.length);
+        for (let i = 0; i < binary.length; i++)
+            bytes[i] = binary.charCodeAt(i);
+        return decodeProtoConfigBytes(bytes);
+    }
+    return decodeProtoConfigBytes(base64ToBytes(b64));
+}