@neurosity/sdk 6.4.1 → 6.5.1

package/dist/esm/Neurosity.js

@@ -8,7 +8,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 import { combineLatest, of, throwError } from "rxjs";
-import { ReplaySubject, firstValueFrom, EMPTY } from "rxjs";
+import { ReplaySubject, firstValueFrom } from "rxjs";
 import { map, startWith, switchMap } from "rxjs/operators";
 import { distinctUntilChanged } from "rxjs/operators";
 import isEqual from "fast-deep-equal";
@@ -132,7 +132,11 @@ export class Neurosity {
                 osHasBluetoothSupport: this._osHasBluetoothSupport()
             }).pipe(switchMap(({ selectedDevice, osHasBluetoothSupport }) => {
                 if (!selectedDevice) {
-                    return EMPTY;
+                    return of({
+                        connected: false,
+                        streamingMode,
+                        activeMode: STREAMING_TYPE.WIFI
+                    });
                 }
                 const isUnableToUseBluetooth = this.isMissingBluetoothTransport || !osHasBluetoothSupport;
                 if (isUnableToUseBluetooth) {

package/dist/esm/api/bluetooth/BluetoothClient.d.ts

@@ -50,7 +50,7 @@ export declare class BluetoothClient {
     logs(): Observable<string>;
     getDeviceId(): Promise<string>;
     _withAuthentication<T>(getter: () => Promise<T>): Promise<T>;
-    _subscribeWhileAuthenticated(characteristicName: string): Observable<any>;
+    _subscribeWhileAuthenticated(characteristicName: string, skipJSONDecoding?: boolean): Observable<any>;
     focus(): Observable<any>;
     calm(): Observable<any>;
     accelerometer(): Observable<any>;

package/dist/esm/api/bluetooth/BluetoothClient.js

@@ -12,7 +12,7 @@ import { ReplaySubject, firstValueFrom, EMPTY } from "rxjs";
 import { switchMap, share, tap, distinctUntilChanged } from "rxjs/operators";
 import { WebBluetoothTransport } from "./web/WebBluetoothTransport";
 import { ReactNativeTransport } from "./react-native/ReactNativeTransport";
-import { csvBufferToEpoch } from "./utils/csvBufferToEpoch";
+import { binaryBufferToEpoch } from "./utils/binaryBufferToEpoch";
 import { BLUETOOTH_CONNECTION } from "./types";
 export class BluetoothClient {
     constructor(options) {
@@ -60,9 +60,10 @@ export class BluetoothClient {
         this._focus$ = this._subscribeWhileAuthenticated("focus");
         this._calm$ = this._subscribeWhileAuthenticated("calm");
         this._accelerometer$ = this._subscribeWhileAuthenticated("accelerometer");
-        this._brainwavesRaw$ = this._subscribeWhileAuthenticated("raw");
-        this._brainwavesRawUnfiltered$ =
-            this._subscribeWhileAuthenticated("rawUnfiltered");
+        this._brainwavesRaw$ = this._subscribeWhileAuthenticated("raw", true // skipJSONDecoding
+        );
+        this._brainwavesRawUnfiltered$ = this._subscribeWhileAuthenticated("rawUnfiltered", true // skipJSONDecoding
+        );
         this._brainwavesPSD$ = this._subscribeWhileAuthenticated("psd");
         this._brainwavesPowerByBand$ =
             this._subscribeWhileAuthenticated("powerByBand");
@@ -184,10 +185,11 @@ export class BluetoothClient {
             return yield getter();
         });
     }
-    _subscribeWhileAuthenticated(characteristicName) {
+    _subscribeWhileAuthenticated(characteristicName, skipJSONDecoding = false) {
         return this.osHasBluetoothSupport$.pipe(switchMap((osHasBluetoothSupport) => osHasBluetoothSupport ? this.isAuthenticated$ : EMPTY), distinctUntilChanged(), switchMap((isAuthenticated) => isAuthenticated
             ? this.transport.subscribeToCharacteristic({
-                characteristicName
+                characteristicName,
+                skipJSONDecoding
             })
             : EMPTY), share());
     }
@@ -204,9 +206,9 @@ export class BluetoothClient {
         switch (label) {
             default:
             case "raw":
-                return defer(() => this.getInfo()).pipe(switchMap((deviceInfo) => this._brainwavesRaw$.pipe(csvBufferToEpoch(deviceInfo))));
+                return defer(() => this.getInfo()).pipe(switchMap((deviceInfo) => this._brainwavesRaw$.pipe(binaryBufferToEpoch(deviceInfo))));
             case "rawUnfiltered":
-                return defer(() => this.getInfo()).pipe(switchMap((deviceInfo) => this._brainwavesRawUnfiltered$.pipe(csvBufferToEpoch(deviceInfo))));
+                return defer(() => this.getInfo()).pipe(switchMap((deviceInfo) => this._brainwavesRawUnfiltered$.pipe(binaryBufferToEpoch(deviceInfo))));
             case "psd":
                 return this._brainwavesPSD$;
             case "powerByBand":

package/dist/esm/api/bluetooth/react-native/ReactNativeTransport.d.ts

@@ -1,5 +1,6 @@
 import { Observable, BehaviorSubject, ReplaySubject } from "rxjs";
 import { BluetoothTransport } from "../BluetoothTransport";
+import { TextCodec } from "../utils/textCodec";
 import { ActionOptions, SubscribeOptions } from "../types";
 import { TRANSPORT_TYPE, BLUETOOTH_CONNECTION } from "../types";
 import { BleManager } from "./types/BleManagerTypes";
@@ -31,6 +32,7 @@ declare type BleManagerEvents = {
 };
 export declare class ReactNativeTransport implements BluetoothTransport {
     type: TRANSPORT_TYPE;
+    textCodec: TextCodec;
     options: Options;
     BleManager: BleManager;
     bleManagerEmitter: NativeEventEmitter;
@@ -59,7 +61,7 @@ export declare class ReactNativeTransport implements BluetoothTransport {
     connect(peripheral: Peripheral): Promise<void>;
     disconnect(): Promise<void>;
     getCharacteristicByName(characteristicName: string): Characteristic;
-    subscribeToCharacteristic({ characteristicName, manageNotifications }: SubscribeOptions): Observable<any>;
+    subscribeToCharacteristic({ characteristicName, manageNotifications, skipJSONDecoding }: SubscribeOptions): Observable<any>;
     readCharacteristic(characteristicName: string, parse?: boolean): Promise<any>;
     writeCharacteristic(characteristicName: string, data: string): Promise<void>;
     _addPendingAction(actionId: number): void;

package/dist/esm/api/bluetooth/react-native/ReactNativeTransport.js

@@ -11,24 +11,25 @@ import { BLUETOOTH_PRIMARY_SERVICE_UUID_STRING } from "@neurosity/ipk";
 import { BLUETOOTH_CHUNK_DELIMITER } from "@neurosity/ipk";
 import { BLUETOOTH_DEVICE_NAME_PREFIXES } from "@neurosity/ipk";
 import { Observable, BehaviorSubject, ReplaySubject, NEVER } from "rxjs";
-import { defer, merge, of, timer, fromEventPattern } from "rxjs";
+import { defer, merge, of, timer, fromEventPattern, identity } from "rxjs";
 import { switchMap, map, filter, takeUntil, tap } from "rxjs/operators";
 import { shareReplay, distinctUntilChanged, finalize } from "rxjs/operators";
 import { take, share, scan, distinct } from "rxjs/operators";
 import { create6DigitPin } from "../utils/create6DigitPin";
-import { stitchChunks } from "../utils/stitch";
-import { encode, decode } from "../utils/encoding";
+import { TextCodec } from "../utils/textCodec";
 import { TRANSPORT_TYPE, BLUETOOTH_CONNECTION } from "../types";
 import { DEFAULT_ACTION_RESPONSE_TIMEOUT } from "../constants";
 import { CHARACTERISTIC_UUIDS_TO_NAMES } from "../constants";
 import { ANDROID_MAX_MTU } from "../constants";
 import { REACT_NATIVE_MAX_BYTE_SIZE } from "../constants";
+import { decodeJSONChunks } from "../utils/decodeJSONChunks";
 const defaultOptions = {
     autoConnect: true
 };
 export class ReactNativeTransport {
     constructor(options) {
         this.type = TRANSPORT_TYPE.REACT_NATIVE;
+        this.textCodec = new TextCodec(this.type);
         this.characteristicsByName = {};
         this.connection$ = new BehaviorSubject(BLUETOOTH_CONNECTION.DISCONNECTED);
         this.pendingActions$ = new BehaviorSubject([]);
@@ -179,7 +180,8 @@ export class ReactNativeTransport {
             // it only has peripheral.advertising.localName as deviceNickname
             // and OS v16 has both as deviceNickname
             const peripheralName = (_c = (_b = (_a = peripheral === null || peripheral === void 0 ? void 0 : peripheral.advertising) === null || _a === void 0 ? void 0 : _a.localName) !== null && _b !== void 0 ? _b : peripheral.name) !== null && _c !== void 0 ? _c : "";
-            const manufactureDataString = (_h = (_g = decode(this.type, (_f = (_e = (_d = peripheral === null || peripheral === void 0 ? void 0 : peripheral.advertising) === null || _d === void 0 ? void 0 : _d.manufacturerData) === null || _e === void 0 ? void 0 : _e.bytes) !== null && _f !== void 0 ? _f : [])) === null || _g === void 0 ? void 0 : _g.slice) === null || _h === void 0 ? void 0 : _h.call(_g, 2); // First 2 bytes are reserved for the Neurosity company code
+            const manufactureDataString = (_h = (_g = this.textCodec
+                .decode((_f = (_e = (_d = peripheral === null || peripheral === void 0 ? void 0 : peripheral.advertising) === null || _d === void 0 ? void 0 : _d.manufacturerData) === null || _e === void 0 ? void 0 : _e.bytes) !== null && _f !== void 0 ? _f : [])) === null || _g === void 0 ? void 0 : _g.slice) === null || _h === void 0 ? void 0 : _h.call(_g, 2); // First 2 bytes are reserved for the Neurosity company code
             return Object.assign(Object.assign({}, acc), { [peripheral.id]: Object.assign(Object.assign({}, peripheral), { name: peripheralName, manufactureDataString }) });
         }, {}), distinctUntilChanged((a, b) => JSON.stringify(a) === JSON.stringify(b)), map((peripheralMap) => Object.values(peripheralMap)), share());
         return peripherals$;
@@ -254,7 +256,7 @@ export class ReactNativeTransport {
         }
         return (_a = this.characteristicsByName) === null || _a === void 0 ? void 0 : _a[characteristicName];
     }
-    subscribeToCharacteristic({ characteristicName, manageNotifications = true }) {
+    subscribeToCharacteristic({ characteristicName, manageNotifications = true, skipJSONDecoding = false }) {
         const getData = ({ peripheralId, serviceUUID, characteristicUUID }) => defer(() => __awaiter(this, void 0, void 0, function* () {
             var _a;
             if (manageNotifications) {
@@ -277,18 +279,16 @@ export class ReactNativeTransport {
                     this.addLog(`Attemped to stop notifications for ${characteristicName} characteristic: ${(_b = error === null || error === void 0 ? void 0 : error.message) !== null && _b !== void 0 ? _b : error}`);
                 }
             }
-        })), filter(({ characteristic }) => characteristic === characteristicUUID), map(({ value }) => decode(this.type, value)), 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;
-            }
-        }));
+        })), filter(({ characteristic }) => characteristic === characteristicUUID), map(({ value }) => new Uint8Array(value)));
         return this.connection$.pipe(switchMap((connection) => connection === BLUETOOTH_CONNECTION.CONNECTED
-            ? getData(this.getCharacteristicByName(characteristicName))
+            ? getData(this.getCharacteristicByName(characteristicName)).pipe(skipJSONDecoding
+                ? identity // noop
+                : decodeJSONChunks({
+                    textCodec: this.textCodec,
+                    characteristicName,
+                    delimiter: BLUETOOTH_CHUNK_DELIMITER,
+                    addLog: (message) => this.addLog(message)
+                }))
             : NEVER));
     }
     readCharacteristic(characteristicName, parse = false) {
@@ -301,7 +301,7 @@ export class ReactNativeTransport {
             }
             try {
                 const value = yield this.BleManager.read(peripheralId, serviceUUID, characteristicUUID);
-                const decodedValue = decode(this.type, value);
+                const decodedValue = this.textCodec.decode(new Uint8Array(value));
                 const data = parse ? JSON.parse(decodedValue) : decodedValue;
                 this.addLog(`Received read data from ${characteristicName} characteristic: \n${data}`);
                 return data;
@@ -318,7 +318,7 @@ export class ReactNativeTransport {
             if (!characteristicUUID) {
                 return Promise.reject(new Error(`Did not find characteristic matching ${characteristicName}`));
             }
-            const encoded = encode(this.type, data);
+            const encoded = this.textCodec.encode(data);
             yield this.BleManager.write(peripheralId, serviceUUID, characteristicUUID, encoded, REACT_NATIVE_MAX_BYTE_SIZE);
         });
     }

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

@@ -11,6 +11,7 @@ export declare type ActionOptions = {
 export declare type SubscribeOptions = {
     characteristicName: string;
     manageNotifications?: boolean;
+    skipJSONDecoding?: boolean;
 };
 /**
  * @hidden

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

@@ -0,0 +1,51 @@
+import { Observable, UnaryFunction } from "rxjs";
+import { Buffer } from "buffer/index.js";
+import { Sample } from "../../../types/sample";
+import { Epoch } from "../../../types/epoch";
+import { DeviceInfo } from "../../../types/deviceInfo";
+/**
+ * @hidden
+ */
+export declare function binaryBufferToEpoch(deviceInfo: DeviceInfo): UnaryFunction<Observable<Epoch>, any>;
+/**
+ * @hidden
+ */
+export declare function binaryBufferToSamples(channelCount: number): UnaryFunction<any, any>;
+/**
+ * @hidden
+ *
+ * Decode the supplied Buffer as a list of Sample.
+ *
+ * Supplied buffer's length must be multiple of
+ * `encodedSampleSize(channelCount)`.
+ *
+ * NB: This method does not guarantee validity of decoded samples. When
+ * supplied with a buffer of appropriate length, it will always return a
+ * matching number of Sample8. Since the encoding protocol defines no
+ * metadata/checksum, correctness must be guaranteed via test coverage.
+ *
+ * @param buffer Buffer with binary payload to decode.
+ * @param channelCount Number of expected channels in each sample.
+ *
+ * @returns List of decoded Samples present in buffer.
+ */
+export declare function decode(buffer: Buffer, channelCount: number): Array<Sample>;
+/**
+ * @hidden
+ *
+ * Calculate the size of each sample based on the number of channels.
+ *
+ * Each sample has the following 3 segments:
+ * - Timestamp: 8 bytes (UInt64); contains current time in millis since epoch)
+ * - Marker: 2 bytes (UInt16); for classifier data
+ * - Data: N * 8 bytes (Double), each entry representing data from a different
+ *   electrode.
+ *
+ *  +-----------+--------+------------------+
+ *  | timestamp | marker | data (e1 ... eN) |
+ *  +-----------+--------+------------------+
+ *
+ * The number of entries for Data varies per hardware model. It can be assumed
+ * to remain constant for the lifetime of the program.
+ */
+export declare function encodedSampleSize(channelCount: number): number;

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

@@ -0,0 +1,109 @@
+import { pipe, from } from "rxjs";
+import { mergeMap } from "rxjs/operators";
+import { Buffer } from "buffer/index.js"; // not including /index.js causes typescript to uses Node's native Buffer built-in and we want to use this npm package for both node and the browser
+import { epoch, addInfo } from "../../../utils/pipes";
+const EPOCH_BUFFER_SIZE = 16;
+const SAMPLING_RATE_FALLBACK = 256; // Crown's sampling rate
+/** Size in bytes for each channel's payload. */
+const TimestampSize = 8; // UInt64
+const MarkerSize = 2; // UInt16
+const ChannelDataSize = 8; // Double
+/** Size in bytes for the static payload of every sample (Timestamp + Marker) */
+const SampleFixedSize = TimestampSize + MarkerSize;
+/**
+ * @hidden
+ */
+export function binaryBufferToEpoch(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(binaryBufferToSamples(deviceInfo.channels), 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 binaryBufferToSamples(channelCount) {
+    return pipe(mergeMap((arrayBuffer) => {
+        const buffer = Buffer.from(arrayBuffer);
+        const decoded = decode(buffer, channelCount);
+        return from(decoded); // `from` creates an Observable emission from each item (Sample) in the array
+    }));
+}
+/**
+ * @hidden
+ *
+ * Decode the supplied Buffer as a list of Sample.
+ *
+ * Supplied buffer's length must be multiple of
+ * `encodedSampleSize(channelCount)`.
+ *
+ * NB: This method does not guarantee validity of decoded samples. When
+ * supplied with a buffer of appropriate length, it will always return a
+ * matching number of Sample8. Since the encoding protocol defines no
+ * metadata/checksum, correctness must be guaranteed via test coverage.
+ *
+ * @param buffer Buffer with binary payload to decode.
+ * @param channelCount Number of expected channels in each sample.
+ *
+ * @returns List of decoded Samples present in buffer.
+ */
+export function decode(buffer, channelCount) {
+    let sampleLen = encodedSampleSize(channelCount);
+    // Alternative: relax this check, process sampleLen at a time, discard remainder?
+    if (buffer.length % sampleLen != 0) {
+        throw new Error(`buffer.length (${buffer.length}) for ${channelCount} channels must be multiple of ${sampleLen}B)`);
+    }
+    let sampleCount = buffer.length / sampleLen;
+    let samples = new Array(sampleCount);
+    for (let i = 0; i < sampleCount; i++) {
+        let offset = i * sampleLen;
+        let channelData = new Array(channelCount);
+        // Read 8 bytes for timestamp & advance offset
+        let ts = buffer.readBigUInt64BE(offset);
+        offset += TimestampSize;
+        // Read 1 byte for marker & advance offset
+        let marker = buffer.readUInt16BE(offset);
+        offset += MarkerSize;
+        // Read 8 bytes for each channel & advance offset
+        for (let i = 0; i < channelCount; i++) {
+            channelData[i] = buffer.readDoubleBE(offset);
+            offset += ChannelDataSize;
+        }
+        samples[i] = {
+            timestamp: Number(ts),
+            // TODO: uncomment when ready
+            // marker: marker,
+            data: channelData
+        };
+    }
+    return samples;
+}
+/**
+ * @hidden
+ *
+ * Calculate the size of each sample based on the number of channels.
+ *
+ * Each sample has the following 3 segments:
+ * - Timestamp: 8 bytes (UInt64); contains current time in millis since epoch)
+ * - Marker: 2 bytes (UInt16); for classifier data
+ * - Data: N * 8 bytes (Double), each entry representing data from a different
+ *   electrode.
+ *
+ *  +-----------+--------+------------------+
+ *  | timestamp | marker | data (e1 ... eN) |
+ *  +-----------+--------+------------------+
+ *
+ * The number of entries for Data varies per hardware model. It can be assumed
+ * to remain constant for the lifetime of the program.
+ */
+export function encodedSampleSize(channelCount) {
+    return SampleFixedSize + channelCount * ChannelDataSize;
+}

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

@@ -0,0 +1,15 @@
+import { TextCodec } from "./textCodec";
+/**
+ * @hidden
+ */
+declare type Options = {
+    textCodec: TextCodec;
+    characteristicName: string;
+    delimiter: string;
+    addLog: (message: string) => void;
+};
+/**
+ * @hidden
+ */
+export declare function decodeJSONChunks({ textCodec, characteristicName, delimiter, addLog }: Options): import("rxjs").UnaryFunction<import("rxjs").Observable<Uint8Array>, import("rxjs").Observable<any>>;
+export {};

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

@@ -0,0 +1,21 @@
+import { map, pipe } from "rxjs";
+import { stitchChunks } from "./stitch";
+/**
+ * @hidden
+ */
+export function decodeJSONChunks({ textCodec, characteristicName, delimiter, addLog }) {
+    return pipe(map((arrayBuffer) => {
+        const decoded = textCodec.decode(arrayBuffer);
+        addLog(`Received chunk with buffer size of ${arrayBuffer.byteLength} and decoded size ${decoded.length} for ${characteristicName} characteristic: \n${decoded}`);
+        return decoded;
+    }), stitchChunks({ delimiter }), map((payload) => {
+        var _a;
+        try {
+            return JSON.parse(payload);
+        }
+        catch (error) {
+            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;
+        }
+    }));
+}

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

@@ -0,0 +1,17 @@
+import { TRANSPORT_TYPE } from "../types";
+/**
+ * @hidden
+ * Uint8Array in Web | number[] in React Native
+ */
+export declare type BufferLike = Uint8Array | number[];
+/**
+ * @hidden
+ */
+export declare class TextCodec {
+    transportType: TRANSPORT_TYPE;
+    webEncoder: TextEncoder;
+    webDecoder: TextDecoder;
+    constructor(transportType: TRANSPORT_TYPE);
+    encode(data: string): BufferLike;
+    decode(arrayBuffer: Uint8Array): string;
+}

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

@@ -0,0 +1,36 @@
+import { Buffer } from "buffer/index.js"; // not including /index.js causes typescript to uses Node's native Buffer built-in and we want to use this npm package for both node and the browser
+import { TRANSPORT_TYPE } from "../types";
+/**
+ * @hidden
+ */
+export class TextCodec {
+    constructor(transportType) {
+        this.transportType = transportType;
+        if (transportType === TRANSPORT_TYPE.WEB) {
+            this.webEncoder = new TextEncoder();
+            this.webDecoder = new TextDecoder("utf-8");
+        }
+    }
+    encode(data) {
+        if (this.transportType === TRANSPORT_TYPE.WEB) {
+            const encoded = this.webEncoder.encode(data);
+            return encoded;
+        }
+        if (this.transportType === TRANSPORT_TYPE.REACT_NATIVE) {
+            // React Native BLE Manager expects a number[] instead of a Uint8Array
+            const encoded = [...Buffer.from(data)];
+            return encoded;
+        }
+        const encoded = Buffer.from(data);
+        return encoded;
+    }
+    decode(arrayBuffer) {
+        if (this.transportType === TRANSPORT_TYPE.WEB) {
+            const decoded = this.webDecoder.decode(arrayBuffer);
+            return decoded;
+        }
+        // For React Native, and as a default
+        const decoded = Buffer.from(arrayBuffer).toString("utf-8");
+        return decoded;
+    }
+}

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

@@ -1,6 +1,7 @@
 /// <reference types="web-bluetooth" />
 import { Observable, BehaviorSubject, ReplaySubject } from "rxjs";
 import { BluetoothTransport } from "../BluetoothTransport";
+import { TextCodec } from "../utils/textCodec";
 import { ActionOptions, SubscribeOptions } from "../types";
 import { TRANSPORT_TYPE, BLUETOOTH_CONNECTION } from "../types";
 import { DeviceInfo } from "../../../types/deviceInfo";
@@ -9,6 +10,7 @@ declare type Options = {
 };
 export declare class WebBluetoothTransport implements BluetoothTransport {
     type: TRANSPORT_TYPE;
+    textCodec: TextCodec;
     options: Options;
     device: BluetoothDevice;
     server: BluetoothRemoteGATTServer;
@@ -42,7 +44,7 @@ export declare class WebBluetoothTransport implements BluetoothTransport {
      * after reconnecting.
      */
     getCharacteristicByName(characteristicName: string): Promise<BluetoothRemoteGATTCharacteristic>;
-    subscribeToCharacteristic({ characteristicName, manageNotifications }: SubscribeOptions): Observable<any>;
+    subscribeToCharacteristic({ characteristicName, manageNotifications, skipJSONDecoding }: SubscribeOptions): Observable<any>;
     readCharacteristic(characteristicName: string, parse?: boolean): Promise<any>;
     writeCharacteristic(characteristicName: string, data: string): Promise<void>;
     _addPendingAction(actionId: number): void;

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

@@ -11,24 +11,25 @@ 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 { Observable, BehaviorSubject, ReplaySubject } from "rxjs";
+import { Observable, BehaviorSubject, ReplaySubject, identity } from "rxjs";
 import { defer, merge, timer, fromEventPattern, 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 { TextCodec } from "../utils/textCodec";
 import { TRANSPORT_TYPE, BLUETOOTH_CONNECTION } from "../types";
 import { DEFAULT_ACTION_RESPONSE_TIMEOUT } from "../constants";
 import { CHARACTERISTIC_UUIDS_TO_NAMES } from "../constants";
+import { decodeJSONChunks } from "../utils/decodeJSONChunks";
 const defaultOptions = {
     autoConnect: true
 };
 export class WebBluetoothTransport {
     constructor(options = {}) {
         this.type = TRANSPORT_TYPE.WEB;
+        this.textCodec = new TextCodec(this.type);
         this.characteristicsByName = {};
         this.connection$ = new BehaviorSubject(BLUETOOTH_CONNECTION.DISCONNECTED);
         this.pendingActions$ = new BehaviorSubject([]);
@@ -208,7 +209,7 @@ export class WebBluetoothTransport {
             return (_a = this.characteristicsByName) === null || _a === void 0 ? void 0 : _a[characteristicName];
         });
     }
-    subscribeToCharacteristic({ characteristicName, manageNotifications = true }) {
+    subscribeToCharacteristic({ characteristicName, manageNotifications = true, skipJSONDecoding = false }) {
         const data$ = defer(() => this.getCharacteristicByName(characteristicName)).pipe(switchMap((characteristic) => __awaiter(this, void 0, void 0, function* () {
             var _a;
             if (this.isConnected() && manageNotifications) {
@@ -234,33 +235,17 @@ export class WebBluetoothTransport {
                     }
                 }
             }));
-        }), 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));
+        }), map((event) => event.target.value.buffer));
+        return this.connection$.pipe(switchMap((connection) => connection === BLUETOOTH_CONNECTION.CONNECTED
+            ? data$.pipe(skipJSONDecoding
+                ? identity // noop
+                : decodeJSONChunks({
+                    textCodec: this.textCodec,
+                    characteristicName,
+                    delimiter: BLUETOOTH_CHUNK_DELIMITER,
+                    addLog: (message) => this.addLog(message)
+                }))
+            : NEVER));
     }
     readCharacteristic(characteristicName, parse = false) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -271,9 +256,9 @@ export class WebBluetoothTransport {
                     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 dataview = yield characteristic.readValue();
+                const arrayBuffer = dataview.buffer;
+                const decodedValue = this.textCodec.decode(arrayBuffer);
                 const data = parse ? JSON.parse(decodedValue) : decodedValue;
                 this.addLog(`Received read data from ${characteristicName} characteristic: \n${data}`);
                 return data;
@@ -291,7 +276,7 @@ export class WebBluetoothTransport {
                 this.addLog(`Did not fund ${characteristicName} characteristic`);
                 return Promise.reject(`Did not find characteristic by the name: ${characteristicName}`);
             }
-            const encoded = encode(this.type, data);
+            const encoded = this.textCodec.encode(data);
             yield characteristic.writeValueWithResponse(encoded);
         });
     }