@neurosity/sdk 6.2.1-next.2 → 6.2.2

package/dist/esm/api/bluetooth/types/index.d.ts

@@ -0,0 +1,31 @@
+/**
+ * @hidden
+ */
+export declare type ActionOptions = {
+    characteristicName: string;
+    action: any;
+};
+/**
+ * @hidden
+ */
+export declare type SubscribeOptions = {
+    characteristicName: string;
+    manageNotifications?: boolean;
+};
+/**
+ * @hidden
+ */
+export declare enum BLUETOOTH_CONNECTION {
+    SCANNING = "scanning",
+    CONNECTED = "connected",
+    CONNECTING = "connecting",
+    DISCONNECTING = "disconnecting",
+    DISCONNECTED = "disconnected"
+}
+/**
+ * @hidden
+ */
+export declare enum TRANSPORT_TYPE {
+    WEB = "web",
+    REACT_NATIVE = "reactNative"
+}

package/dist/esm/api/bluetooth/types/index.js

@@ -0,0 +1,19 @@
+/**
+ * @hidden
+ */
+export var BLUETOOTH_CONNECTION;
+(function (BLUETOOTH_CONNECTION) {
+    BLUETOOTH_CONNECTION["SCANNING"] = "scanning";
+    BLUETOOTH_CONNECTION["CONNECTED"] = "connected";
+    BLUETOOTH_CONNECTION["CONNECTING"] = "connecting";
+    BLUETOOTH_CONNECTION["DISCONNECTING"] = "disconnecting";
+    BLUETOOTH_CONNECTION["DISCONNECTED"] = "disconnected";
+})(BLUETOOTH_CONNECTION || (BLUETOOTH_CONNECTION = {}));
+/**
+ * @hidden
+ */
+export var TRANSPORT_TYPE;
+(function (TRANSPORT_TYPE) {
+    TRANSPORT_TYPE["WEB"] = "web";
+    TRANSPORT_TYPE["REACT_NATIVE"] = "reactNative";
+})(TRANSPORT_TYPE || (TRANSPORT_TYPE = {}));

package/dist/esm/api/bluetooth/utils/create6DigitPin.d.ts

@@ -0,0 +1 @@
+export declare function create6DigitPin(): number;

package/dist/esm/api/bluetooth/utils/create6DigitPin.js

@@ -0,0 +1,4 @@
+// Creates a number of 6 digits and ensures the first digit will never be 0
+export function create6DigitPin() {
+    return Math.floor(100000 + Math.random() * 900000);
+}

package/dist/esm/api/bluetooth/utils/csvBufferToEpoch.d.ts

@@ -0,0 +1,11 @@
+import { Observable, UnaryFunction } from "rxjs";
+import { Epoch } from "../../../types/epoch";
+import { DeviceInfo } from "../../../types/deviceInfo";
+/**
+ * @hidden
+ */
+export declare function csvBufferToEpoch(deviceInfo: DeviceInfo): UnaryFunction<Observable<Epoch>, any>;
+/**
+ * @hidden
+ */
+export declare function csvBufferToSamples(): UnaryFunction<any, any>;

package/dist/esm/api/bluetooth/utils/csvBufferToEpoch.js

@@ -0,0 +1,31 @@
+import { pipe, from } from "rxjs";
+import { mergeMap, map } from "rxjs/operators";
+import { epoch, addInfo } from "../../../utils/pipes";
+const EPOCH_BUFFER_SIZE = 16;
+const SAMPLING_RATE_FALLBACK = 256; // Crown's sampling rate
+/**
+ * @hidden
+ */
+export function csvBufferToEpoch(deviceInfo) {
+    var _a;
+    if (!(deviceInfo === null || deviceInfo === void 0 ? void 0 : deviceInfo.samplingRate)) {
+        console.warn(`Didn't receive a sampling rate, defaulting to ${SAMPLING_RATE_FALLBACK}`);
+    }
+    return pipe(csvBufferToSamples(), epoch({
+        duration: EPOCH_BUFFER_SIZE,
+        interval: EPOCH_BUFFER_SIZE,
+        samplingRate: (_a = deviceInfo === null || deviceInfo === void 0 ? void 0 : deviceInfo.samplingRate) !== null && _a !== void 0 ? _a : SAMPLING_RATE_FALLBACK
+    }), addInfo({
+        channelNames: deviceInfo.channelNames,
+        samplingRate: deviceInfo.samplingRate
+    }));
+}
+/**
+ * @hidden
+ */
+export function csvBufferToSamples() {
+    return pipe(mergeMap((samples) => from(samples)), map(([timestamp, marker, ...data]) => ({
+        timestamp,
+        data
+    })));
+}

package/dist/esm/api/bluetooth/utils/encoding.d.ts

@@ -0,0 +1,3 @@
+import { TRANSPORT_TYPE } from "../types";
+export declare function encode(transportType: TRANSPORT_TYPE, data: string): Uint8Array | number[];
+export declare function decode(transportType: TRANSPORT_TYPE, data: Uint8Array | number[]): string;

package/dist/esm/api/bluetooth/utils/encoding.js

@@ -0,0 +1,17 @@
+import { TRANSPORT_TYPE } from "../types";
+const encoder = new TextEncoder();
+const decoder = new TextDecoder("utf-8");
+export function encode(transportType, data) {
+    if (transportType === TRANSPORT_TYPE.REACT_NATIVE) {
+        // React Native expects a plain array  of numbers and not a Uint8Array
+        return [...encoder.encode(data)];
+    }
+    return encoder.encode(data);
+}
+export function decode(transportType, data) {
+    if (transportType === TRANSPORT_TYPE.REACT_NATIVE) {
+        // React Native outpouts a plain array of numbers and not a Uint8Array
+        return decoder.decode(new Uint8Array(data));
+    }
+    return decoder.decode(data);
+}

package/dist/esm/api/bluetooth/utils/osHasBluetoothSupport.d.ts

@@ -0,0 +1,2 @@
+import { DeviceInfo } from "../../../types/deviceInfo";
+export declare function osHasBluetoothSupport(selectedDevice: DeviceInfo): any;

package/dist/esm/api/bluetooth/utils/osHasBluetoothSupport.js

@@ -0,0 +1,16 @@
+import semverGte from "semver/functions/gte";
+export function osHasBluetoothSupport(selectedDevice) {
+    if (!selectedDevice) {
+        return false;
+    }
+    // Only the Crown supports Bluetooth
+    const isCrown = Number(selectedDevice.modelVersion) >= 3;
+    if (!isCrown) {
+        return false;
+    }
+    const isEmulator = !!(selectedDevice === null || selectedDevice === void 0 ? void 0 : selectedDevice.emulator);
+    if (isEmulator) {
+        return false;
+    }
+    return semverGte(selectedDevice.osVersion, "16.0.0");
+}

package/dist/esm/api/bluetooth/utils/stitch.d.ts

@@ -0,0 +1,5 @@
+declare type StitchChunkOptions = {
+    delimiter: string;
+};
+export declare function stitchChunks({ delimiter }: StitchChunkOptions): import("rxjs").UnaryFunction<import("rxjs").Observable<string>, import("rxjs").Observable<string>>;
+export {};

package/dist/esm/api/bluetooth/utils/stitch.js

@@ -0,0 +1,18 @@
+import { pipe } from "rxjs";
+import { map, scan, filter } from "rxjs/operators";
+export function stitchChunks({ delimiter }) {
+    return pipe(scan(([remainder], currentBuffer) => {
+        const nextBuffer = remainder + currentBuffer;
+        if (!nextBuffer.includes(delimiter)) {
+            return [nextBuffer, ""];
+        }
+        if (nextBuffer.endsWith(delimiter)) {
+            return ["", nextBuffer];
+        }
+        const remainderStart = nextBuffer.lastIndexOf(delimiter);
+        const remainderIndex = remainderStart + delimiter.length;
+        const nextPacket = nextBuffer.slice(0, remainderIndex);
+        const nextRemainder = nextBuffer.slice(remainderIndex);
+        return [nextRemainder, nextPacket];
+    }, ["", ""]), map(([, nextPacket]) => nextPacket.slice(0, -delimiter.length)), filter((nextPacket) => !!nextPacket.length));
+}

package/dist/esm/api/bluetooth/web/WebBluetoothTransport.d.ts

@@ -0,0 +1,54 @@
+/// <reference types="web-bluetooth" />
+import { BehaviorSubject, ReplaySubject } from "rxjs";
+import { Observable } from "rxjs";
+import { BluetoothTransport } from "../BluetoothTransport";
+import { ActionOptions, SubscribeOptions } from "../types";
+import { TRANSPORT_TYPE, BLUETOOTH_CONNECTION } from "../types";
+import { DeviceInfo } from "../../../types/deviceInfo";
+declare type Options = {
+    autoConnect?: boolean;
+};
+export declare class WebBluetoothTransport implements BluetoothTransport {
+    type: TRANSPORT_TYPE;
+    options: Options;
+    device: BluetoothDevice;
+    server: BluetoothRemoteGATTServer;
+    service: BluetoothRemoteGATTService;
+    characteristicsByName: {
+        [name: string]: BluetoothRemoteGATTCharacteristic;
+    };
+    connection$: BehaviorSubject<BLUETOOTH_CONNECTION>;
+    pendingActions$: BehaviorSubject<any[]>;
+    logs$: ReplaySubject<string>;
+    onDisconnected$: Observable<void>;
+    connectionStream$: Observable<BLUETOOTH_CONNECTION>;
+    _isAutoConnectEnabled$: ReplaySubject<boolean>;
+    constructor(options?: Options);
+    _getPairedDevices(): Promise<BluetoothDevice[]>;
+    _autoConnect(selectedDevice$: Observable<DeviceInfo>): Observable<void>;
+    enableAutoConnect(autoConnect: boolean): void;
+    addLog(log: string): void;
+    isConnected(): boolean;
+    connection(): Observable<BLUETOOTH_CONNECTION>;
+    connect(deviceNickname?: string): Promise<void>;
+    requestDevice(deviceNickname?: string): Promise<BluetoothDevice>;
+    getServerServiceAndCharacteristics(device: BluetoothDevice): Promise<never>;
+    _onDisconnected(): Observable<any>;
+    disconnect(): Promise<void>;
+    /**
+     *
+     * Bluetooth GATT attributes, services, characteristics, etc. are invalidated
+     * when a device disconnects. This means your code should always retrieve
+     * (through getPrimaryService(s), getCharacteristic(s), etc.) these attributes
+     * after reconnecting.
+     */
+    getCharacteristicByName(characteristicName: string): Promise<BluetoothRemoteGATTCharacteristic>;
+    subscribeToCharacteristic({ characteristicName, manageNotifications }: SubscribeOptions): Observable<any>;
+    readCharacteristic(characteristicName: string, parse?: boolean): Promise<any>;
+    writeCharacteristic(characteristicName: string, data: string): Promise<void>;
+    _addPendingAction(actionId: number): void;
+    _removePendingAction(actionId: number): void;
+    _autoToggleActionNotifications(selectedDevice$: Observable<DeviceInfo>): Promise<void>;
+    dispatchAction({ characteristicName, action }: ActionOptions): Promise<any>;
+}
+export {};

package/dist/esm/api/bluetooth/web/WebBluetoothTransport.js

@@ -0,0 +1,426 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { BLUETOOTH_PRIMARY_SERVICE_UUID_HEX } from "@neurosity/ipk";
+import { BLUETOOTH_CHUNK_DELIMITER } from "@neurosity/ipk";
+import { BLUETOOTH_DEVICE_NAME_PREFIXES } from "@neurosity/ipk";
+import { BLUETOOTH_COMPANY_IDENTIFIER_HEX } from "@neurosity/ipk";
+import { BehaviorSubject, defer, merge, of, ReplaySubject, timer } from "rxjs";
+import { fromEventPattern, Observable, EMPTY, NEVER } from "rxjs";
+import { switchMap, map, filter, tap } from "rxjs/operators";
+import { shareReplay, distinctUntilChanged } from "rxjs/operators";
+import { take, share } from "rxjs/operators";
+import { isWebBluetoothSupported } from "./isWebBluetoothSupported";
+import { create6DigitPin } from "../utils/create6DigitPin";
+import { stitchChunks } from "../utils/stitch";
+import { encode, decode } from "../utils/encoding";
+import { TRANSPORT_TYPE, BLUETOOTH_CONNECTION } from "../types";
+import { DEFAULT_ACTION_RESPONSE_TIMEOUT } from "../constants";
+import { CHARACTERISTIC_UUIDS_TO_NAMES } from "../constants";
+import { osHasBluetoothSupport } from "../utils/osHasBluetoothSupport";
+const defaultOptions = {
+    autoConnect: true
+};
+export class WebBluetoothTransport {
+    constructor(options = {}) {
+        this.type = TRANSPORT_TYPE.WEB;
+        this.characteristicsByName = {};
+        this.connection$ = new BehaviorSubject(BLUETOOTH_CONNECTION.DISCONNECTED);
+        this.pendingActions$ = new BehaviorSubject([]);
+        this.logs$ = new ReplaySubject(10);
+        this.onDisconnected$ = this._onDisconnected().pipe(share());
+        this.connectionStream$ = this.connection$
+            .asObservable()
+            .pipe(filter((connection) => !!connection), distinctUntilChanged(), shareReplay(1));
+        this._isAutoConnectEnabled$ = new ReplaySubject(1);
+        this.options = Object.assign(Object.assign({}, defaultOptions), options);
+        if (!isWebBluetoothSupported()) {
+            const errorMessage = "Web Bluetooth is not supported";
+            this.addLog(errorMessage);
+            throw new Error(errorMessage);
+        }
+        this._isAutoConnectEnabled$.subscribe((autoConnect) => {
+            this.addLog(`Auto connect: ${autoConnect ? "enabled" : "disabled"}`);
+        });
+        this._isAutoConnectEnabled$.next(this.options.autoConnect);
+        this.connection$.asObservable().subscribe((connection) => {
+            this.addLog(`connection status is ${connection}`);
+        });
+        this.onDisconnected$.subscribe(() => {
+            this.connection$.next(BLUETOOTH_CONNECTION.DISCONNECTED);
+        });
+    }
+    _getPairedDevices() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield navigator.bluetooth.getDevices();
+        });
+    }
+    _autoConnect(selectedDevice$) {
+        return this._isAutoConnectEnabled$.pipe(switchMap((isAutoConnectEnabled) => isAutoConnectEnabled
+            ? merge(selectedDevice$, this.onDisconnected$.pipe(switchMap(() => selectedDevice$)))
+            : NEVER), switchMap((selectedDevice) => osHasBluetoothSupport(selectedDevice) ? of(selectedDevice) : EMPTY), switchMap((selectedDevice) => __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const { deviceNickname } = selectedDevice;
+            if (this.isConnected()) {
+                this.addLog(`Auto connect: ${deviceNickname} is already connected. Skipping auto connect.`);
+                return;
+            }
+            const [devicesError, devices] = yield this._getPairedDevices()
+                .then((devices) => [null, devices])
+                .catch((error) => [error, null]);
+            if (devicesError) {
+                throw new Error(`failed to get devices: ${(_a = devicesError === null || devicesError === void 0 ? void 0 : devicesError.message) !== null && _a !== void 0 ? _a : devicesError}`);
+            }
+            this.addLog(`Auto connect: found ${devices.length} devices ${devices
+                .map(({ name }) => name)
+                .join(", ")}`);
+            // @important - Using `findLast` instead of `find` because somehow the browser
+            // is finding multiple peripherals with the same name
+            const device = devices.findLast((device) => device.name === deviceNickname);
+            if (!device) {
+                throw new Error(`couldn't find selected device in the list of paired devices.`);
+            }
+            this.addLog(`Auto connect: ${deviceNickname} was detected and previously paired`);
+            return device;
+        })), tap(() => {
+            this.connection$.next(BLUETOOTH_CONNECTION.SCANNING);
+        }), switchMap((device) => onAdvertisementReceived(device)), switchMap((advertisement) => __awaiter(this, void 0, void 0, function* () {
+            this.addLog(`Advertisement received for ${advertisement.device.name}`);
+            return yield this.getServerServiceAndCharacteristics(advertisement.device);
+        })));
+    }
+    enableAutoConnect(autoConnect) {
+        this._isAutoConnectEnabled$.next(autoConnect);
+    }
+    addLog(log) {
+        this.logs$.next(log);
+    }
+    isConnected() {
+        const connection = this.connection$.getValue();
+        return connection === BLUETOOTH_CONNECTION.CONNECTED;
+    }
+    connection() {
+        return this.connectionStream$;
+    }
+    connect(deviceNickname) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                // requires user gesture
+                const device = yield this.requestDevice(deviceNickname);
+                yield this.getServerServiceAndCharacteristics(device);
+            }
+            catch (error) {
+                return Promise.reject(error);
+            }
+        });
+    }
+    requestDevice(deviceNickname) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                this.addLog("Requesting Bluetooth Device...");
+                const prefixes = BLUETOOTH_DEVICE_NAME_PREFIXES.map((namePrefix) => ({
+                    namePrefix
+                }));
+                // Ability to only show selectedDevice if provided
+                const filters = deviceNickname
+                    ? [
+                        {
+                            name: deviceNickname
+                        }
+                    ]
+                    : prefixes;
+                const device = yield window.navigator.bluetooth.requestDevice({
+                    filters: [
+                        ...filters,
+                        {
+                            manufacturerData: [
+                                {
+                                    companyIdentifier: BLUETOOTH_COMPANY_IDENTIFIER_HEX
+                                }
+                            ]
+                        }
+                    ],
+                    optionalServices: [BLUETOOTH_PRIMARY_SERVICE_UUID_HEX]
+                });
+                return device;
+            }
+            catch (error) {
+                return Promise.reject(error);
+            }
+        });
+    }
+    getServerServiceAndCharacteristics(device) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                this.device = device;
+                const isConnecting = this.connection$.getValue() === BLUETOOTH_CONNECTION.CONNECTING;
+                if (!isConnecting) {
+                    this.connection$.next(BLUETOOTH_CONNECTION.CONNECTING);
+                }
+                this.server = yield device.gatt.connect();
+                this.addLog(`Getting service...`);
+                this.service = yield this.server.getPrimaryService(BLUETOOTH_PRIMARY_SERVICE_UUID_HEX);
+                this.addLog(`Got service ${this.service.uuid}, getting characteristics...`);
+                const characteristicsList = yield this.service.getCharacteristics();
+                this.addLog(`Got characteristics`);
+                this.characteristicsByName = Object.fromEntries(characteristicsList.map((characteristic) => [
+                    CHARACTERISTIC_UUIDS_TO_NAMES[characteristic.uuid],
+                    characteristic
+                ]));
+                this.connection$.next(BLUETOOTH_CONNECTION.CONNECTED);
+            }
+            catch (error) {
+                return Promise.reject(error);
+            }
+        });
+    }
+    _onDisconnected() {
+        return this.connection$
+            .asObservable()
+            .pipe(switchMap((connection) => connection === BLUETOOTH_CONNECTION.CONNECTED
+            ? fromDOMEvent(this.device, "gattserverdisconnected")
+            : NEVER));
+    }
+    disconnect() {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            const isDeviceConnected = (_b = (_a = this === null || this === void 0 ? void 0 : this.device) === null || _a === void 0 ? void 0 : _a.gatt) === null || _b === void 0 ? void 0 : _b.connected;
+            if (isDeviceConnected) {
+                this.device.gatt.disconnect();
+            }
+        });
+    }
+    /**
+     *
+     * Bluetooth GATT attributes, services, characteristics, etc. are invalidated
+     * when a device disconnects. This means your code should always retrieve
+     * (through getPrimaryService(s), getCharacteristic(s), etc.) these attributes
+     * after reconnecting.
+     */
+    getCharacteristicByName(characteristicName) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            return (_a = this.characteristicsByName) === null || _a === void 0 ? void 0 : _a[characteristicName];
+        });
+    }
+    subscribeToCharacteristic({ characteristicName, manageNotifications = true }) {
+        const data$ = defer(() => this.getCharacteristicByName(characteristicName)).pipe(switchMap((characteristic) => __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            if (this.isConnected() && manageNotifications) {
+                try {
+                    yield characteristic.startNotifications();
+                    this.addLog(`Started notifications for ${characteristicName} characteristic`);
+                }
+                catch (error) {
+                    this.addLog(`Attemped to stop notifications for ${characteristicName} characteristic: ${(_a = error === null || error === void 0 ? void 0 : error.message) !== null && _a !== void 0 ? _a : error}`);
+                }
+            }
+            return characteristic;
+        })), switchMap((characteristic) => {
+            return fromDOMEvent(characteristic, "characteristicvaluechanged", () => __awaiter(this, void 0, void 0, function* () {
+                var _a;
+                if (this.isConnected() && manageNotifications) {
+                    try {
+                        yield characteristic.stopNotifications();
+                        this.addLog(`Stopped notifications for ${characteristicName} characteristic`);
+                    }
+                    catch (error) {
+                        this.addLog(`Attemped to stop notifications for ${characteristicName} characteristic: ${(_a = error === null || error === void 0 ? void 0 : error.message) !== null && _a !== void 0 ? _a : error}`);
+                    }
+                }
+            }));
+        }), map((event) => {
+            const buffer = event.target.value;
+            const decoded = decode(this.type, buffer);
+            this.addLog(`Received chunk with buffer size of ${buffer.byteLength} and decoded size ${decoded.length} for ${characteristicName} characteristic: \n${decoded}`);
+            return decoded;
+        }), stitchChunks({ delimiter: BLUETOOTH_CHUNK_DELIMITER }), map((payload) => {
+            var _a;
+            try {
+                return JSON.parse(payload);
+            }
+            catch (error) {
+                this.addLog(`Failed to parse JSON for ${characteristicName} characteristic. Falling back to unparsed string. ${(_a = error === null || error === void 0 ? void 0 : error.message) !== null && _a !== void 0 ? _a : error}`);
+                return payload;
+            }
+        })
+        // when streaming at ultra-low latency, the logs will slow down rendering
+        // tap((data) => {
+        //   this.addLog(
+        //     `Received data for ${characteristicName} characteristic: \n${JSON.stringify(
+        //       data,
+        //       null,
+        //       2
+        //     )}`
+        //   );
+        // })
+        );
+        return this.connection$.pipe(switchMap((connection) => connection === BLUETOOTH_CONNECTION.CONNECTED ? data$ : NEVER));
+    }
+    readCharacteristic(characteristicName, parse = false) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                this.addLog(`Reading characteristic: ${characteristicName}`);
+                const characteristic = yield this.getCharacteristicByName(characteristicName);
+                if (!characteristic) {
+                    this.addLog(`Did not fund ${characteristicName} characteristic`);
+                    return Promise.reject(`Did not find characteristic by the name: ${characteristicName}`);
+                }
+                const value = yield characteristic.readValue();
+                const uint8Array = value;
+                const decodedValue = decode(this.type, uint8Array);
+                const data = parse ? JSON.parse(decodedValue) : decodedValue;
+                this.addLog(`Received read data from ${characteristicName} characteristic: \n${data}`);
+                return data;
+            }
+            catch (error) {
+                return Promise.reject(`Error reading characteristic: ${error.message}`);
+            }
+        });
+    }
+    writeCharacteristic(characteristicName, data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.addLog(`Writing characteristic: ${characteristicName}`);
+            const characteristic = yield this.getCharacteristicByName(characteristicName);
+            if (!characteristic) {
+                this.addLog(`Did not fund ${characteristicName} characteristic`);
+                return Promise.reject(`Did not find characteristic by the name: ${characteristicName}`);
+            }
+            const encoded = encode(this.type, data);
+            yield characteristic.writeValueWithResponse(encoded);
+        });
+    }
+    _addPendingAction(actionId) {
+        const actions = this.pendingActions$.getValue();
+        this.pendingActions$.next([...actions, actionId]);
+    }
+    _removePendingAction(actionId) {
+        const actions = this.pendingActions$.getValue();
+        this.pendingActions$.next(actions.filter((id) => id !== actionId));
+    }
+    _autoToggleActionNotifications(selectedDevice$) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let actionsCharacteristic;
+            let started = false;
+            const sideEffects$ = this.connection$.asObservable().pipe(switchMap((connection) => connection === BLUETOOTH_CONNECTION.CONNECTED
+                ? defer(() => this.getCharacteristicByName("actions")).pipe(switchMap((characteristic) => {
+                    actionsCharacteristic = characteristic;
+                    return this.pendingActions$;
+                }))
+                : NEVER), tap((pendingActions) => __awaiter(this, void 0, void 0, function* () {
+                var _a, _b;
+                const hasPendingActions = !!pendingActions.length;
+                if (hasPendingActions && !started) {
+                    started = true;
+                    try {
+                        yield actionsCharacteristic.startNotifications();
+                        this.addLog(`Started notifications for [actions] characteristic`);
+                    }
+                    catch (error) {
+                        this.addLog(`Attemped to start notifications for [actions] characteristic: ${(_a = error === null || error === void 0 ? void 0 : error.message) !== null && _a !== void 0 ? _a : error}`);
+                    }
+                }
+                if (!hasPendingActions && started) {
+                    started = false;
+                    try {
+                        yield actionsCharacteristic.stopNotifications();
+                        this.addLog(`Stopped notifications for actions characteristic`);
+                    }
+                    catch (error) {
+                        this.addLog(`Attemped to stop notifications for [actions] characteristic: ${(_b = error === null || error === void 0 ? void 0 : error.message) !== null && _b !== void 0 ? _b : error}`);
+                    }
+                }
+            })));
+            selectedDevice$
+                .pipe(switchMap((selectedDevice) => !osHasBluetoothSupport(selectedDevice) ? EMPTY : sideEffects$))
+                .subscribe();
+        });
+    }
+    dispatchAction({ characteristicName, action }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { responseRequired = false, responseTimeout = DEFAULT_ACTION_RESPONSE_TIMEOUT } = action;
+            return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
+                const characteristic = yield this.getCharacteristicByName(characteristicName).catch(() => {
+                    reject(`Did not find characteristic by the name: ${characteristicName}`);
+                });
+                if (!characteristic) {
+                    return;
+                }
+                const actionId = create6DigitPin(); // use to later identify and filter response
+                const payload = JSON.stringify(Object.assign({ actionId }, action)); // add the response id to the action
+                this.addLog(`Dispatched action with id ${actionId}`);
+                if (responseRequired && responseTimeout) {
+                    this._addPendingAction(actionId);
+                    const timeout = timer(responseTimeout).subscribe(() => {
+                        this._removePendingAction(actionId);
+                        reject(`Action with id ${actionId} timed out after ${responseTimeout}ms`);
+                    });
+                    // listen for a response before writing
+                    this.subscribeToCharacteristic({
+                        characteristicName,
+                        manageNotifications: false
+                    })
+                        .pipe(filter((response) => (response === null || response === void 0 ? void 0 : response.actionId) === actionId), take(1))
+                        .subscribe((response) => {
+                        timeout.unsubscribe();
+                        this._removePendingAction(actionId);
+                        resolve(response);
+                    });
+                    // register action by writing
+                    this.writeCharacteristic(characteristicName, payload).catch((error) => {
+                        this._removePendingAction(actionId);
+                        reject(error.message);
+                    });
+                }
+                else {
+                    this.writeCharacteristic(characteristicName, payload)
+                        .then(() => {
+                        resolve(null);
+                    })
+                        .catch((error) => {
+                        reject(error.message);
+                    });
+                }
+            }));
+        });
+    }
+}
+function fromDOMEvent(target, eventName, beforeRemove) {
+    return fromEventPattern((addHandler) => {
+        target.addEventListener(eventName, addHandler);
+    }, (removeHandler) => __awaiter(this, void 0, void 0, function* () {
+        if (beforeRemove) {
+            yield beforeRemove();
+        }
+        target.removeEventListener(eventName, removeHandler);
+    }));
+}
+function onAdvertisementReceived(device) {
+    return new Observable((subscriber) => {
+        const abortController = new AbortController();
+        const { signal } = abortController;
+        const listener = device.addEventListener("advertisementreceived", (advertisement) => {
+            abortController.abort();
+            subscriber.next(advertisement);
+            subscriber.complete();
+        }, {
+            once: true
+        });
+        try {
+            device.watchAdvertisements({ signal });
+        }
+        catch (error) {
+            subscriber.error(error);
+        }
+        return () => {
+            abortController.abort();
+            device.removeEventListener("advertisementreceived", listener);
+        };
+    });
+}

package/dist/esm/api/bluetooth/web/isMaybeWebWorkerContext.d.ts

@@ -0,0 +1 @@
+export declare const isMaybeWebWorkerContext: () => boolean;

package/dist/esm/api/bluetooth/web/isMaybeWebWorkerContext.js

@@ -0,0 +1,4 @@
+const self = this;
+export const isMaybeWebWorkerContext = () => {
+    return self && (self === null || self === void 0 ? void 0 : self.document) === undefined;
+};

package/dist/esm/api/bluetooth/web/isWebBluetoothSupported.d.ts

@@ -0,0 +1 @@
+export declare function isWebBluetoothSupported(): boolean;