@neurosity/sdk 6.0.0-next.11

package/dist/cjs/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/cjs/api/bluetooth/types/index.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TRANSPORT_TYPE = exports.BLUETOOTH_CONNECTION = void 0;
+/**
+ * @hidden
+ */
+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 = exports.BLUETOOTH_CONNECTION || (exports.BLUETOOTH_CONNECTION = {}));
+/**
+ * @hidden
+ */
+var TRANSPORT_TYPE;
+(function (TRANSPORT_TYPE) {
+    TRANSPORT_TYPE["WEB"] = "web";
+    TRANSPORT_TYPE["REACT_NATIVE"] = "reactNative";
+})(TRANSPORT_TYPE = exports.TRANSPORT_TYPE || (exports.TRANSPORT_TYPE = {}));

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

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

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

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.create6DigitPin = void 0;
+// Creates a number of 6 digits and ensures the first digit will never be 0
+function create6DigitPin() {
+    return Math.floor(100000 + Math.random() * 900000);
+}
+exports.create6DigitPin = create6DigitPin;

package/dist/cjs/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/cjs/api/bluetooth/utils/csvBufferToEpoch.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.csvBufferToSamples = exports.csvBufferToEpoch = void 0;
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+const pipes_1 = require("../../../utils/pipes");
+const EPOCH_BUFFER_SIZE = 16;
+const SAMPLING_RATE_FALLBACK = 256; // Crown's sampling rate
+/**
+ * @hidden
+ */
+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 (0, rxjs_1.pipe)(csvBufferToSamples(), (0, pipes_1.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
+    }), (0, pipes_1.addInfo)({
+        channelNames: deviceInfo.channelNames,
+        samplingRate: deviceInfo.samplingRate
+    }));
+}
+exports.csvBufferToEpoch = csvBufferToEpoch;
+/**
+ * @hidden
+ */
+function csvBufferToSamples() {
+    return (0, rxjs_1.pipe)((0, operators_1.mergeMap)((samples) => (0, rxjs_1.from)(samples)), (0, operators_1.map)(([timestamp, marker, ...data]) => ({
+        timestamp,
+        data
+    })));
+}
+exports.csvBufferToSamples = csvBufferToSamples;

package/dist/cjs/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/cjs/api/bluetooth/utils/encoding.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decode = exports.encode = void 0;
+const types_1 = require("../types");
+const encoder = new TextEncoder();
+const decoder = new TextDecoder("utf-8");
+function encode(transportType, data) {
+    if (transportType === types_1.TRANSPORT_TYPE.REACT_NATIVE) {
+        // React Native expects a plain array  of numbers and not a Uint8Array
+        return [...encoder.encode(data)];
+    }
+    return encoder.encode(data);
+}
+exports.encode = encode;
+function decode(transportType, data) {
+    if (transportType === types_1.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);
+}
+exports.decode = decode;

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

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

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

@@ -0,0 +1,23 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.osHasBluetoothSupport = void 0;
+const gte_1 = __importDefault(require("semver/functions/gte"));
+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 (0, gte_1.default)(selectedDevice.osVersion, "16.0.0");
+}
+exports.osHasBluetoothSupport = osHasBluetoothSupport;

package/dist/cjs/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/cjs/api/bluetooth/utils/stitch.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stitchChunks = void 0;
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+function stitchChunks({ delimiter }) {
+    return (0, rxjs_1.pipe)((0, operators_1.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];
+    }, ["", ""]), (0, operators_1.map)(([, nextPacket]) => nextPacket.slice(0, -delimiter.length)), (0, operators_1.filter)((nextPacket) => !!nextPacket.length));
+}
+exports.stitchChunks = stitchChunks;

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

@@ -0,0 +1,47 @@
+/// <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";
+export declare class WebBluetoothTransport implements BluetoothTransport {
+    type: TRANSPORT_TYPE;
+    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>;
+    constructor();
+    _getPairedDevices(): Promise<BluetoothDevice[]>;
+    _autoConnect(selectedDevice$: Observable<DeviceInfo>): Observable<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>;
+}

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

@@ -0,0 +1,412 @@
+"use strict";
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebBluetoothTransport = void 0;
+const ipk_1 = require("@neurosity/ipk");
+const ipk_2 = require("@neurosity/ipk");
+const ipk_3 = require("@neurosity/ipk");
+const ipk_4 = require("@neurosity/ipk");
+const rxjs_1 = require("rxjs");
+const rxjs_2 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+const operators_2 = require("rxjs/operators");
+const operators_3 = require("rxjs/operators");
+const isWebBluetoothSupported_1 = require("./isWebBluetoothSupported");
+const create6DigitPin_1 = require("../utils/create6DigitPin");
+const stitch_1 = require("../utils/stitch");
+const encoding_1 = require("../utils/encoding");
+const types_1 = require("../types");
+const constants_1 = require("../constants");
+const constants_2 = require("../constants");
+const osHasBluetoothSupport_1 = require("../utils/osHasBluetoothSupport");
+class WebBluetoothTransport {
+    constructor() {
+        this.type = types_1.TRANSPORT_TYPE.WEB;
+        this.characteristicsByName = {};
+        this.connection$ = new rxjs_1.BehaviorSubject(types_1.BLUETOOTH_CONNECTION.DISCONNECTED);
+        this.pendingActions$ = new rxjs_1.BehaviorSubject([]);
+        this.logs$ = new rxjs_1.ReplaySubject(10);
+        this.onDisconnected$ = this._onDisconnected().pipe((0, operators_3.share)());
+        this.connectionStream$ = this.connection$
+            .asObservable()
+            .pipe((0, operators_1.filter)((connection) => !!connection), (0, operators_2.distinctUntilChanged)(), (0, operators_2.shareReplay)(1));
+        if (!(0, isWebBluetoothSupported_1.isWebBluetoothSupported)()) {
+            const errorMessage = "Web Bluetooth is not supported";
+            this.addLog(errorMessage);
+            throw new Error(errorMessage);
+        }
+        this.connection$.asObservable().subscribe((connection) => {
+            this.addLog(`connection status is ${connection}`);
+        });
+        this.onDisconnected$.subscribe(() => {
+            this.connection$.next(types_1.BLUETOOTH_CONNECTION.DISCONNECTED);
+        });
+    }
+    _getPairedDevices() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield navigator.bluetooth.getDevices();
+        });
+    }
+    _autoConnect(selectedDevice$) {
+        return (0, rxjs_1.merge)(selectedDevice$, this.onDisconnected$.pipe((0, operators_1.switchMap)(() => selectedDevice$))).pipe((0, operators_1.switchMap)((selectedDevice) => (0, osHasBluetoothSupport_1.osHasBluetoothSupport)(selectedDevice) ? (0, rxjs_1.of)(selectedDevice) : rxjs_2.EMPTY), (0, operators_1.switchMap)((selectedDevice) => __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const { deviceNickname } = selectedDevice;
+            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;
+        })), (0, operators_1.tap)(() => {
+            this.connection$.next(types_1.BLUETOOTH_CONNECTION.SCANNING);
+        }), (0, operators_1.switchMap)((device) => onAdvertisementReceived(device)), (0, operators_1.switchMap)((advertisement) => __awaiter(this, void 0, void 0, function* () {
+            this.addLog(`Advertisement received for ${advertisement.device.name}`);
+            return yield this.getServerServiceAndCharacteristics(advertisement.device);
+        })));
+    }
+    addLog(log) {
+        this.logs$.next(log);
+    }
+    isConnected() {
+        const connection = this.connection$.getValue();
+        return connection === types_1.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 = ipk_3.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: ipk_4.BLUETOOTH_COMPANY_IDENTIFIER_HEX
+                                }
+                            ]
+                        }
+                    ],
+                    optionalServices: [ipk_1.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() === types_1.BLUETOOTH_CONNECTION.CONNECTING;
+                if (!isConnecting) {
+                    this.connection$.next(types_1.BLUETOOTH_CONNECTION.CONNECTING);
+                }
+                this.server = yield device.gatt.connect();
+                this.addLog(`Getting service...`);
+                this.service = yield this.server.getPrimaryService(ipk_1.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) => [
+                    constants_2.CHARACTERISTIC_UUIDS_TO_NAMES[characteristic.uuid],
+                    characteristic
+                ]));
+                this.connection$.next(types_1.BLUETOOTH_CONNECTION.CONNECTED);
+            }
+            catch (error) {
+                return Promise.reject(error);
+            }
+        });
+    }
+    _onDisconnected() {
+        return this.connection$
+            .asObservable()
+            .pipe((0, operators_1.switchMap)((connection) => connection === types_1.BLUETOOTH_CONNECTION.CONNECTED
+            ? fromDOMEvent(this.device, "gattserverdisconnected")
+            : rxjs_2.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$ = (0, rxjs_1.defer)(() => this.getCharacteristicByName(characteristicName)).pipe((0, operators_1.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;
+        })), (0, operators_1.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}`);
+                    }
+                }
+            }));
+        }), (0, operators_1.map)((event) => {
+            const buffer = event.target.value;
+            const decoded = (0, encoding_1.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;
+        }), (0, stitch_1.stitchChunks)({ delimiter: ipk_2.BLUETOOTH_CHUNK_DELIMITER }), (0, operators_1.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((0, operators_1.switchMap)((connection) => connection === types_1.BLUETOOTH_CONNECTION.CONNECTED ? data$ : rxjs_2.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 = (0, encoding_1.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 = (0, encoding_1.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((0, operators_1.switchMap)((connection) => connection === types_1.BLUETOOTH_CONNECTION.CONNECTED
+                ? (0, rxjs_1.defer)(() => this.getCharacteristicByName("actions")).pipe((0, operators_1.switchMap)((characteristic) => {
+                    actionsCharacteristic = characteristic;
+                    return this.pendingActions$;
+                }))
+                : rxjs_2.NEVER), (0, operators_1.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((0, operators_1.switchMap)((selectedDevice) => !(0, osHasBluetoothSupport_1.osHasBluetoothSupport)(selectedDevice) ? rxjs_2.EMPTY : sideEffects$))
+                .subscribe();
+        });
+    }
+    dispatchAction({ characteristicName, action }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { responseRequired = false, responseTimeout = constants_1.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 = (0, create6DigitPin_1.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 = (0, rxjs_1.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((0, operators_1.filter)((response) => (response === null || response === void 0 ? void 0 : response.actionId) === actionId), (0, operators_3.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);
+                    });
+                }
+            }));
+        });
+    }
+}
+exports.WebBluetoothTransport = WebBluetoothTransport;
+function fromDOMEvent(target, eventName, beforeRemove) {
+    return (0, rxjs_2.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 rxjs_2.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/cjs/api/bluetooth/web/isMaybeWebWorkerContext.d.ts

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