@wodzik/cubecore 0.1.0

package/bluetooth/vendor/smartcube-web-bluetooth/gan-smart-cube.js

@@ -0,0 +1,152 @@
+import * as def from './gan-cube-definitions.js';
+import { GanGen2CubeEncrypter, GanGen3CubeEncrypter, GanGen4CubeEncrypter } from './gan-cube-encrypter.js';
+import { GanGen1CubeConnection } from './gan-gen1.js';
+import { macStringToSaltOrThrow } from './gan-mac-salt.js';
+import { isValidGanGen2Packet, isValidGanGen3Packet, isValidGanGen4Packet, } from './gan-gen234-packet-validate.js';
+import { normalizeUuid } from './smartcube/attachment/normalize-uuid.js';
+import { GanCubeClassicConnection, GanGen2ProtocolDriver, GanGen3ProtocolDriver, GanGen4ProtocolDriver } from './gan-cube-protocol.js';
+/** Iterate over all known GAN cube CICs to find Manufacturer Specific Data */
+function getManufacturerDataBytes(manufacturerData) {
+    // Workaround for Bluefy browser which may return raw DataView directly instead of Map
+    if (manufacturerData instanceof DataView) {
+        return new DataView(manufacturerData.buffer.slice(2, 11));
+    }
+    for (var id of def.GAN_CIC_LIST) {
+        if (manufacturerData.has(id)) {
+            return new DataView(manufacturerData.get(id).buffer.slice(0, 9));
+        }
+    }
+    return;
+}
+/** Extract MAC from last 6 bytes of Manufacturer Specific Data */
+function extractMAC(manufacturerData) {
+    var mac = [];
+    var dataView = getManufacturerDataBytes(manufacturerData);
+    if (dataView && dataView.byteLength >= 6) {
+        for (let i = 1; i <= 6; i++) {
+            mac.push(dataView.getUint8(dataView.byteLength - i).toString(16).toUpperCase().padStart(2, "0"));
+        }
+    }
+    return mac.join(":");
+}
+/** If browser supports Web Bluetooth watchAdvertisements() API, try to retrieve MAC address automatically */
+async function autoRetrieveMacAddress(device) {
+    return new Promise((resolve) => {
+        if (typeof device.watchAdvertisements != 'function') {
+            resolve(null);
+        }
+        var abortController = new AbortController();
+        var onAdvEvent = (evt) => {
+            device.removeEventListener("advertisementreceived", onAdvEvent);
+            abortController.abort();
+            var mac = extractMAC(evt.manufacturerData);
+            resolve(mac || null);
+        };
+        var onAbort = () => {
+            device.removeEventListener("advertisementreceived", onAdvEvent);
+            abortController.abort();
+            resolve(null);
+        };
+        device.addEventListener("advertisementreceived", onAdvEvent);
+        device.watchAdvertisements({ signal: abortController.signal }).catch(onAbort);
+        setTimeout(onAbort, 5000);
+    });
+}
+function hasGanGen1Profile(serviceUuids) {
+    const primary = normalizeUuid(def.GAN_GEN1_PRIMARY_SERVICE);
+    const deviceInfo = normalizeUuid(def.GAN_GEN1_DEVICE_INFO_SERVICE);
+    return serviceUuids.has(primary) && serviceUuids.has(deviceInfo);
+}
+/**
+ * Initiate new connection with the GAN Smart Cube device
+ * @param customMacAddressProvider Optional custom provider for cube MAC address
+ * @returns Object representing connection API and state
+ */
+async function connectGanCube(customMacAddressProvider) {
+    // Request user for the bluetooth device (popup selection dialog)
+    const nameFilters = [
+        { namePrefix: "GAN" },
+        { namePrefix: "MG" },
+        { namePrefix: "AiCube" },
+    ];
+    const cicFilters = def.GAN_CIC_LIST.map((companyIdentifier) => ({
+        manufacturerData: [{ companyIdentifier }],
+    }));
+    var device = await navigator.bluetooth.requestDevice({
+        filters: [...nameFilters, ...cicFilters],
+        optionalServices: [
+            def.GAN_GEN1_PRIMARY_SERVICE,
+            def.GAN_GEN1_DEVICE_INFO_SERVICE,
+            def.GAN_GEN2_SERVICE,
+            def.GAN_GEN3_SERVICE,
+            def.GAN_GEN4_SERVICE,
+            "0000180a-0000-1000-8000-00805f9b34fb",
+            "00001800-0000-1000-8000-00805f9b34fb",
+        ],
+    });
+    // Connect to GATT and get primary services
+    var gatt = await device.gatt.connect();
+    var services = await gatt.getPrimaryServices();
+    const serviceUuidSet = new Set(services.map((s) => normalizeUuid(s.uuid)));
+    if (hasGanGen1Profile(serviceUuidSet)) {
+        return GanGen1CubeConnection.create(device);
+    }
+    // Retrieve cube MAC address needed for key salting
+    var mac = customMacAddressProvider && await customMacAddressProvider(device, false)
+        || await autoRetrieveMacAddress(device)
+        || customMacAddressProvider && await customMacAddressProvider(device, true);
+    if (!mac)
+        throw new Error('Unable to determine cube MAC address, connection is not possible!');
+    device.mac = mac;
+    // Create encryption salt from MAC address bytes placed in reverse order
+    var salt = macStringToSaltOrThrow(mac);
+    const g2 = normalizeUuid(def.GAN_GEN2_SERVICE);
+    const g3 = normalizeUuid(def.GAN_GEN3_SERVICE);
+    const g4 = normalizeUuid(def.GAN_GEN4_SERVICE);
+    let pick = null;
+    if (serviceUuidSet.has(g2))
+        pick = 'g2';
+    else if (serviceUuidSet.has(g3))
+        pick = 'g3';
+    else if (serviceUuidSet.has(g4))
+        pick = 'g4';
+    var conn = null;
+    // Resolve type of connected cube device and setup appropriate encryption / protocol driver
+    if (pick === 'g2') {
+        const service = await gatt.getPrimaryService(def.GAN_GEN2_SERVICE);
+        let commandCharacteristic = await service.getCharacteristic(def.GAN_GEN2_COMMAND_CHARACTERISTIC);
+        let stateCharacteristic = await service.getCharacteristic(def.GAN_GEN2_STATE_CHARACTERISTIC);
+        let key = device.name?.startsWith('AiCube') ? def.GAN_ENCRYPTION_KEYS[1] : def.GAN_ENCRYPTION_KEYS[0];
+        let encrypter = new GanGen2CubeEncrypter(new Uint8Array(key.key), new Uint8Array(key.iv), salt);
+        let driver = new GanGen2ProtocolDriver();
+        conn = await GanCubeClassicConnection.create(device, commandCharacteristic, stateCharacteristic, encrypter, driver, {
+            validateDecrypted: isValidGanGen2Packet,
+        });
+    }
+    else if (pick === 'g3') {
+        const service = await gatt.getPrimaryService(def.GAN_GEN3_SERVICE);
+        let commandCharacteristic = await service.getCharacteristic(def.GAN_GEN3_COMMAND_CHARACTERISTIC);
+        let stateCharacteristic = await service.getCharacteristic(def.GAN_GEN3_STATE_CHARACTERISTIC);
+        let key = def.GAN_ENCRYPTION_KEYS[0];
+        let encrypter = new GanGen3CubeEncrypter(new Uint8Array(key.key), new Uint8Array(key.iv), salt);
+        let driver = new GanGen3ProtocolDriver();
+        conn = await GanCubeClassicConnection.create(device, commandCharacteristic, stateCharacteristic, encrypter, driver, {
+            validateDecrypted: isValidGanGen3Packet,
+        });
+    }
+    else if (pick === 'g4') {
+        const service = await gatt.getPrimaryService(def.GAN_GEN4_SERVICE);
+        let commandCharacteristic = await service.getCharacteristic(def.GAN_GEN4_COMMAND_CHARACTERISTIC);
+        let stateCharacteristic = await service.getCharacteristic(def.GAN_GEN4_STATE_CHARACTERISTIC);
+        let key = def.GAN_ENCRYPTION_KEYS[0];
+        let encrypter = new GanGen4CubeEncrypter(new Uint8Array(key.key), new Uint8Array(key.iv), salt);
+        let driver = new GanGen4ProtocolDriver();
+        conn = await GanCubeClassicConnection.create(device, commandCharacteristic, stateCharacteristic, encrypter, driver, {
+            validateDecrypted: isValidGanGen4Packet,
+        });
+    }
+    if (!conn)
+        throw new Error("Can't find target BLE services - wrong or unsupported cube device model");
+    return conn;
+}
+export { connectGanCube };

package/bluetooth/vendor/smartcube-web-bluetooth/gan-smart-timer.d.ts

@@ -0,0 +1,74 @@
+import { Observable } from 'rxjs';
+/**
+ * GAN Smart Timer events/states
+ */
+declare enum GanTimerState {
+    /** Fired when timer is disconnected from bluetooth */
+    DISCONNECT = 0,
+    /** Grace delay is expired and timer is ready to start */
+    GET_SET = 1,
+    /** Hands removed from the timer before grace delay expired */
+    HANDS_OFF = 2,
+    /** Timer is running */
+    RUNNING = 3,
+    /** Timer is stopped, this event includes recorded time */
+    STOPPED = 4,
+    /** Timer is reset and idle */
+    IDLE = 5,
+    /** Hands are placed on the timer */
+    HANDS_ON = 6,
+    /** Timer moves to this state immediately after STOPPED */
+    FINISHED = 7
+}
+/**
+ * Representation of time value
+ */
+interface GanTimerTime {
+    readonly minutes: number;
+    readonly seconds: number;
+    readonly milliseconds: number;
+    readonly asTimestamp: number;
+    toString(): string;
+}
+/**
+ * Timer state event
+ */
+interface GanTimerEvent {
+    /** Current timer state */
+    state: GanTimerState;
+    /** Recorder time value in case of STOPPED event */
+    recordedTime?: GanTimerTime;
+}
+/**
+ * Representation of recorded in timer memory time values
+ */
+interface GanTimerRecordedTimes {
+    displayTime: GanTimerTime;
+    previousTimes: [GanTimerTime, GanTimerTime, GanTimerTime];
+}
+/**
+ * GAN Timer connection object representing connection API and state
+ */
+interface GanTimerConnection {
+    /** RxJS Subject to subscribe for cube event messages */
+    events$: Observable<GanTimerEvent>;
+    /** Retrieve last time values recored by timer */
+    getRecordedTimes(): Promise<GanTimerRecordedTimes>;
+    /** Disconnect from timer */
+    disconnect(): void;
+}
+/**
+ * Construct time object
+ */
+declare function makeTime(min: number, sec: number, msec: number): GanTimerTime;
+/**
+ * Construct time object from milliseconds timestamp
+ */
+declare function makeTimeFromTimestamp(timestamp: number): GanTimerTime;
+/**
+ * Initiate new connection with the GAN Smart Timer device
+ * @returns Connection connection object representing connection API and state
+ */
+declare function connectGanTimer(): Promise<GanTimerConnection>;
+export type { GanTimerConnection, GanTimerEvent, GanTimerTime, GanTimerRecordedTimes };
+export { connectGanTimer, makeTime, makeTimeFromTimestamp, GanTimerState };

package/bluetooth/vendor/smartcube-web-bluetooth/gan-smart-timer.js

@@ -0,0 +1,161 @@
+import { Subject } from 'rxjs';
+// GAN Smart Timer bluetooth service and characteristic UUIDs
+const GAN_TIMER_SERVICE = '0000fff0-0000-1000-8000-00805f9b34fb';
+const GAN_TIMER_TIME_CHARACTERISTIC = '0000fff2-0000-1000-8000-00805f9b34fb';
+const GAN_TIMER_STATE_CHARACTERISTIC = '0000fff5-0000-1000-8000-00805f9b34fb';
+/**
+ * GAN Smart Timer events/states
+ */
+var GanTimerState;
+(function (GanTimerState) {
+    /** Fired when timer is disconnected from bluetooth */
+    GanTimerState[GanTimerState["DISCONNECT"] = 0] = "DISCONNECT";
+    /** Grace delay is expired and timer is ready to start */
+    GanTimerState[GanTimerState["GET_SET"] = 1] = "GET_SET";
+    /** Hands removed from the timer before grace delay expired */
+    GanTimerState[GanTimerState["HANDS_OFF"] = 2] = "HANDS_OFF";
+    /** Timer is running */
+    GanTimerState[GanTimerState["RUNNING"] = 3] = "RUNNING";
+    /** Timer is stopped, this event includes recorded time */
+    GanTimerState[GanTimerState["STOPPED"] = 4] = "STOPPED";
+    /** Timer is reset and idle */
+    GanTimerState[GanTimerState["IDLE"] = 5] = "IDLE";
+    /** Hands are placed on the timer */
+    GanTimerState[GanTimerState["HANDS_ON"] = 6] = "HANDS_ON";
+    /** Timer moves to this state immediately after STOPPED */
+    GanTimerState[GanTimerState["FINISHED"] = 7] = "FINISHED";
+})(GanTimerState || (GanTimerState = {}));
+/**
+ * Construct time object
+ */
+function makeTime(min, sec, msec) {
+    return {
+        minutes: min,
+        seconds: sec,
+        milliseconds: msec,
+        asTimestamp: 60000 * min + 1000 * sec + msec,
+        toString: () => `${min.toString(10)}:${sec.toString(10).padStart(2, '0')}.${msec.toString(10).padStart(3, '0')}`
+    };
+}
+/**
+ * Construct time object from raw event data
+ */
+function makeTimeFromRaw(data, offset) {
+    var min = data.getUint8(offset);
+    var sec = data.getUint8(offset + 1);
+    var msec = data.getUint16(offset + 2, true);
+    return makeTime(min, sec, msec);
+}
+/**
+ * Construct time object from milliseconds timestamp
+ */
+function makeTimeFromTimestamp(timestamp) {
+    var min = Math.trunc(timestamp / 60000);
+    var sec = Math.trunc(timestamp % 60000 / 1000);
+    var msec = Math.trunc(timestamp % 1000);
+    return makeTime(min, sec, msec);
+}
+/**
+ * Calculate ArrayBuffer checksum using CRC-16/CCIT-FALSE algorithm variation
+ */
+function crc16ccit(buff) {
+    var dataView = new DataView(buff);
+    var crc = 0xFFFF;
+    for (let i = 0; i < dataView.byteLength; ++i) {
+        crc ^= dataView.getUint8(i) << 8;
+        for (let j = 0; j < 8; ++j) {
+            crc = (crc & 0x8000) > 0 ? (crc << 1) ^ 0x1021 : crc << 1;
+        }
+    }
+    return crc & 0xFFFF;
+}
+/**
+ * Ensure received timer event has valid data: check data magic and CRC
+ */
+function validateEventData(data) {
+    try {
+        if (data?.byteLength == 0 || data.getUint8(0) != 0xFE) {
+            return false;
+        }
+        var eventCRC = data.getUint16(data.byteLength - 2, true);
+        var calculatedCRC = crc16ccit(data.buffer.slice(2, data.byteLength - 2));
+        return eventCRC == calculatedCRC;
+    }
+    catch (err) {
+        return false;
+    }
+}
+/**
+ * Construct event object from raw data
+ */
+function buildTimerEvent(data) {
+    var evt = {
+        state: data.getUint8(3)
+    };
+    if (evt.state == GanTimerState.STOPPED) {
+        evt.recordedTime = makeTimeFromRaw(data, 4);
+    }
+    return evt;
+}
+/**
+ * Initiate new connection with the GAN Smart Timer device
+ * @returns Connection connection object representing connection API and state
+ */
+async function connectGanTimer() {
+    // Request user for the bluetooth device (popup selection dialog)
+    var device = await navigator.bluetooth.requestDevice({
+        filters: [
+            { namePrefix: "GAN" },
+            { namePrefix: "gan" },
+            { namePrefix: "Gan" }
+        ],
+        optionalServices: [GAN_TIMER_SERVICE]
+    });
+    // Connect to GATT server
+    var server = await device.gatt.connect();
+    // Connect to main timer service and characteristics
+    var service = await server.getPrimaryService(GAN_TIMER_SERVICE);
+    var timeCharacteristic = await service.getCharacteristic(GAN_TIMER_TIME_CHARACTERISTIC);
+    var stateCharacteristic = await service.getCharacteristic(GAN_TIMER_STATE_CHARACTERISTIC);
+    // Subscribe to value updates of the timer state characteristic
+    var eventSubject = new Subject();
+    var onStateChanged = async (evt) => {
+        var chr = evt.target;
+        var data = chr.value;
+        if (validateEventData(data)) {
+            eventSubject.next(buildTimerEvent(data));
+        }
+        else {
+            eventSubject.error("Invalid event data received from Timer");
+        }
+    };
+    stateCharacteristic.addEventListener('characteristicvaluechanged', onStateChanged);
+    stateCharacteristic.startNotifications();
+    // This action retrieves latest recorded times from timer
+    var getRecordedTimesAction = async () => {
+        var data = await timeCharacteristic.readValue();
+        return data?.byteLength >= 16 ?
+            Promise.resolve({
+                displayTime: makeTimeFromRaw(data, 0),
+                previousTimes: [makeTimeFromRaw(data, 4), makeTimeFromRaw(data, 8), makeTimeFromRaw(data, 12)]
+            }) : Promise.reject("Invalid time characteristic value received from Timer");
+    };
+    // Manual disconnect action
+    var disconnectAction = async () => {
+        device.removeEventListener('gattserverdisconnected', disconnectAction);
+        stateCharacteristic.removeEventListener('characteristicvaluechanged', onStateChanged);
+        await stateCharacteristic.stopNotifications().catch(() => { });
+        eventSubject.next({ state: GanTimerState.DISCONNECT });
+        eventSubject.complete();
+        if (server.connected) {
+            server.disconnect();
+        }
+    };
+    device.addEventListener('gattserverdisconnected', disconnectAction);
+    return {
+        events$: eventSubject,
+        getRecordedTimes: getRecordedTimesAction,
+        disconnect: disconnectAction,
+    };
+}
+export { connectGanTimer, makeTime, makeTimeFromTimestamp, GanTimerState };

package/bluetooth/vendor/smartcube-web-bluetooth/gan-write-queue.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Serializes GATT write operations (writeValueWithResponse / writeValueWithoutResponse) to avoid overlapping operations on some stacks.
+ */
+export declare class GattWriteQueue {
+    private tail;
+    enqueue<T>(fn: () => Promise<T>): Promise<T>;
+}

package/bluetooth/vendor/smartcube-web-bluetooth/gan-write-queue.js

@@ -0,0 +1,11 @@
+/**
+ * Serializes GATT write operations (writeValueWithResponse / writeValueWithoutResponse) to avoid overlapping operations on some stacks.
+ */
+export class GattWriteQueue {
+    tail = Promise.resolve();
+    enqueue(fn) {
+        const run = this.tail.then(() => fn());
+        this.tail = run.then(() => { }, () => { });
+        return run;
+    }
+}

package/bluetooth/vendor/smartcube-web-bluetooth/gatt-characteristic-write.d.ts

@@ -0,0 +1,2 @@
+/// <reference types="web-bluetooth" />
+export declare function writeGattCharacteristicValue(characteristic: BluetoothRemoteGATTCharacteristic, value: BufferSource): Promise<void>;

package/bluetooth/vendor/smartcube-web-bluetooth/gatt-characteristic-write.js

@@ -0,0 +1,36 @@
+import { GattWriteQueue } from './gan-write-queue.js';
+/**
+ * One in-flight GATT operation per connection on common stacks; overlapping writes throw
+ * NetworkError "GATT operation already in progress". Queue writes per device.
+ */
+const writeQueuesByDevice = new WeakMap();
+function writeQueueForCharacteristic(characteristic) {
+    const device = characteristic.service.device;
+    let q = writeQueuesByDevice.get(device);
+    if (!q) {
+        q = new GattWriteQueue();
+        writeQueuesByDevice.set(device, q);
+    }
+    return q;
+}
+/**
+ * Writes using explicit Web Bluetooth APIs (writeValue is deprecated).
+ * Chooses write-with-response vs write-without-response from characteristic.properties.
+ * When both are supported, prefers write-with-response for reliable cross-platform command traffic.
+ */
+function writeGattCharacteristicValueNow(characteristic, value) {
+    const { write, writeWithoutResponse } = characteristic.properties;
+    if (!write && !writeWithoutResponse) {
+        return Promise.reject(new Error('Characteristic is not writable'));
+    }
+    if (writeWithoutResponse && !write) {
+        return characteristic.writeValueWithoutResponse(value);
+    }
+    if (write && !writeWithoutResponse) {
+        return characteristic.writeValueWithResponse(value);
+    }
+    return characteristic.writeValueWithResponse(value);
+}
+export function writeGattCharacteristicValue(characteristic, value) {
+    return writeQueueForCharacteristic(characteristic).enqueue(() => writeGattCharacteristicValueNow(characteristic, value));
+}

package/bluetooth/vendor/smartcube-web-bluetooth/index.d.ts

@@ -0,0 +1,4 @@
+export * from './gan-smart-timer.js';
+export * from './gan-smart-cube.js';
+export * from './utils.js';
+export * from './smartcube/index.js';

package/bluetooth/vendor/smartcube-web-bluetooth/index.js

@@ -0,0 +1,4 @@
+export * from './gan-smart-timer.js';
+export * from './gan-smart-cube.js';
+export * from './utils.js';
+export * from './smartcube/index.js';

package/bluetooth/vendor/smartcube-web-bluetooth/smartcube/attachment/address-hints.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="web-bluetooth" />
+export declare function getCachedMacForDevice(device: BluetoothDevice): string | null;
+export declare function setCachedMacForDevice(device: BluetoothDevice, mac: string): void;
+export declare function removeCachedMacForDevice(device: BluetoothDevice): void;
+/**
+ * Wait for manufacturer data from advertisements (single shared listener).
+ * Merges all packets until timeout: the first BLE advertisement often has an empty
+ * manufacturerData map; MAC-bearing data appears on later frames.
+ */
+export declare function waitForManufacturerData(device: BluetoothDevice, timeoutMs?: number): Promise<BluetoothManufacturerData | null>;
+/** GAN-style MAC from manufacturer data (last 6 bytes, reversed order in payload). */
+export declare function macFromGanManufacturerData(mf: BluetoothManufacturerData | DataView): string | null;

package/bluetooth/vendor/smartcube-web-bluetooth/smartcube/attachment/address-hints.js

@@ -0,0 +1,122 @@
+import * as ganDef from '../../gan-cube-definitions.js';
+const STORAGE_PREFIX = 'smartcube-ble-mac:';
+export function getCachedMacForDevice(device) {
+    if (typeof localStorage === 'undefined') {
+        return null;
+    }
+    try {
+        return localStorage.getItem(STORAGE_PREFIX + device.id);
+    }
+    catch {
+        return null;
+    }
+}
+export function setCachedMacForDevice(device, mac) {
+    if (typeof localStorage === 'undefined') {
+        return;
+    }
+    try {
+        localStorage.setItem(STORAGE_PREFIX + device.id, mac);
+    }
+    catch {
+        /* ignore quota */
+    }
+}
+export function removeCachedMacForDevice(device) {
+    if (typeof localStorage === 'undefined') {
+        return;
+    }
+    try {
+        localStorage.removeItem(STORAGE_PREFIX + device.id);
+    }
+    catch {
+        /* ignore */
+    }
+}
+function mergeManufacturerDataInto(acc, mf) {
+    if (!mf || typeof mf.keys !== 'function') {
+        return;
+    }
+    for (const id of mf.keys()) {
+        const v = mf.get(id);
+        if (v) {
+            acc.set(id, new DataView(v.buffer.slice(v.byteOffset, v.byteOffset + v.byteLength)));
+        }
+    }
+}
+/**
+ * Wait for manufacturer data from advertisements (single shared listener).
+ * Merges all packets until timeout: the first BLE advertisement often has an empty
+ * manufacturerData map; MAC-bearing data appears on later frames.
+ */
+export async function waitForManufacturerData(device, timeoutMs = 5000) {
+    if (typeof device.watchAdvertisements !== 'function') {
+        return null;
+    }
+    const name = (device.name || '').trim();
+    /** MoYu32-style names rarely expose useful MF in the picker; keep connect snappy. */
+    const emptyFirstAdvExit = name.startsWith('WCU_');
+    return new Promise((resolve) => {
+        const abortController = new AbortController();
+        const merged = new Map();
+        let sawAdvertisement = false;
+        let finished = false;
+        const cleanup = () => {
+            device.removeEventListener('advertisementreceived', onAdvEvent);
+            abortController.abort();
+            clearTimeout(maxTimer);
+        };
+        const finish = (value) => {
+            if (finished) {
+                return;
+            }
+            finished = true;
+            cleanup();
+            resolve(value);
+        };
+        const onAdvEvent = (evt) => {
+            const adv = evt;
+            mergeManufacturerDataInto(merged, adv.manufacturerData ?? null);
+            const isFirstAdv = !sawAdvertisement;
+            sawAdvertisement = true;
+            if (merged.size > 0) {
+                finish(merged);
+                return;
+            }
+            if (emptyFirstAdvExit && isFirstAdv) {
+                finish(null);
+            }
+        };
+        const maxTimer = setTimeout(() => {
+            finish(merged.size > 0 ? merged : null);
+        }, timeoutMs);
+        device.addEventListener('advertisementreceived', onAdvEvent);
+        device.watchAdvertisements({ signal: abortController.signal }).catch(() => {
+            clearTimeout(maxTimer);
+            finish(null);
+        });
+    });
+}
+/** GAN-style MAC from manufacturer data (last 6 bytes, reversed order in payload). */
+export function macFromGanManufacturerData(mf) {
+    function getBytes(manufacturerData) {
+        if (manufacturerData instanceof DataView) {
+            return new DataView(manufacturerData.buffer.slice(2, 11));
+        }
+        for (const id of ganDef.GAN_CIC_LIST) {
+            if (manufacturerData.has(id)) {
+                return new DataView(manufacturerData.get(id).buffer.slice(0, 9));
+            }
+        }
+        return undefined;
+    }
+    const dataView = getBytes(mf);
+    if (!dataView || dataView.byteLength < 6) {
+        return null;
+    }
+    const mac = [];
+    for (let i = 1; i <= 6; i++) {
+        mac.push(dataView.getUint8(dataView.byteLength - i).toString(16).toUpperCase().padStart(2, '0'));
+    }
+    return mac.join(':');
+}

package/bluetooth/vendor/smartcube-web-bluetooth/smartcube/attachment/build-picker-options.d.ts

@@ -0,0 +1,11 @@
+import type { SmartCubeProtocol } from '../protocol.js';
+import type { DeviceSelectionMode } from './types.js';
+export interface BuildRequestDeviceOptionsExtras {
+    deviceName?: string;
+}
+/**
+ * Build Web Bluetooth `requestDevice` options for the given mode.
+ * Manufacturer IDs appear in `filters` (OR with name filters) and in `optionalManufacturerData`
+ * so `watchAdvertisements` exposes manufacturer data when the device matched by name prefix.
+ */
+export declare function buildRequestDeviceOptions(protocols: SmartCubeProtocol[], mode: DeviceSelectionMode, extras?: BuildRequestDeviceOptionsExtras): RequestDeviceOptions;

package/bluetooth/vendor/smartcube-web-bluetooth/smartcube/attachment/build-picker-options.js

@@ -0,0 +1,55 @@
+import { mergeOptionalServiceUuids } from './default-optional-services.js';
+import { extraScanFiltersForKnownDeviceName } from './device-name-scan-filters.js';
+function mergeManufacturerCompanyIds(protocols) {
+    const all = new Set();
+    for (const p of protocols) {
+        if (p.optionalManufacturerData) {
+            for (const cic of p.optionalManufacturerData) {
+                all.add(cic);
+            }
+        }
+    }
+    return Array.from(all).sort((a, b) => a - b);
+}
+/**
+ * Build Web Bluetooth `requestDevice` options for the given mode.
+ * Manufacturer IDs appear in `filters` (OR with name filters) and in `optionalManufacturerData`
+ * so `watchAdvertisements` exposes manufacturer data when the device matched by name prefix.
+ */
+export function buildRequestDeviceOptions(protocols, mode, extras) {
+    const protocolServices = [];
+    for (const p of protocols) {
+        for (const s of p.optionalServices) {
+            protocolServices.push(s);
+        }
+    }
+    const optionalServices = mergeOptionalServiceUuids(protocolServices);
+    const cics = mergeManufacturerCompanyIds(protocols);
+    const optionalManufacturerData = cics.length > 0 ? cics : undefined;
+    if (mode === 'any') {
+        return {
+            acceptAllDevices: true,
+            optionalServices,
+            optionalManufacturerData,
+        };
+    }
+    const filters = [];
+    for (const p of protocols) {
+        for (const f of p.nameFilters) {
+            filters.push(f);
+        }
+    }
+    for (const f of extraScanFiltersForKnownDeviceName(extras?.deviceName)) {
+        filters.push(f);
+    }
+    for (const companyIdentifier of cics) {
+        filters.push({
+            manufacturerData: [{ companyIdentifier }],
+        });
+    }
+    return {
+        filters,
+        optionalServices,
+        optionalManufacturerData,
+    };
+}