@neurosity/sdk 6.5.10 → 6.5.11

package/dist/esm/__tests__/utils.test.js

@@ -0,0 +1,279 @@
+import { create6DigitPin } from "../api/bluetooth/utils/create6DigitPin";
+import { decodeJSONChunks } from "../api/bluetooth/utils/decodeJSONChunks";
+import { stitchChunks } from "../api/bluetooth/utils/stitch";
+import { TextCodec } from "../api/bluetooth/utils/textCodec";
+import { TRANSPORT_TYPE } from "../api/bluetooth/types";
+import { of } from "rxjs";
+import { toArray } from "rxjs/operators";
+describe("Bluetooth Utils", () => {
+    describe("create6DigitPin", () => {
+        it("should create a 6-digit pin", () => {
+            const pin = create6DigitPin();
+            expect(pin.toString()).toMatch(/^\d{6}$/);
+        });
+    });
+    describe("decodeJSONChunks", () => {
+        let textCodec;
+        let addLog;
+        beforeEach(() => {
+            textCodec = new TextCodec(TRANSPORT_TYPE.WEB);
+            addLog = jest.fn();
+        });
+        it("should decode complete JSON chunks", (done) => {
+            const chunks = [
+                new Uint8Array(textCodec.encode('{"id":1,"name":"test"}\n')),
+                new Uint8Array(textCodec.encode('{"id":2,"name":"test2"}\n'))
+            ];
+            of(...chunks)
+                .pipe(decodeJSONChunks({
+                textCodec,
+                characteristicName: "test",
+                delimiter: "\n",
+                addLog
+            }), toArray())
+                .subscribe((result) => {
+                expect(result).toEqual([
+                    { id: 1, name: "test" },
+                    { id: 2, name: "test2" }
+                ]);
+                done();
+            });
+        });
+        it("should handle invalid JSON", (done) => {
+            const chunks = [
+                new Uint8Array(textCodec.encode('{"id":1\n')),
+                new Uint8Array(textCodec.encode("invalid json\n"))
+            ];
+            of(...chunks)
+                .pipe(decodeJSONChunks({
+                textCodec,
+                characteristicName: "test",
+                delimiter: "\n",
+                addLog
+            }), toArray())
+                .subscribe((result) => {
+                expect(result).toEqual(['{"id":1', "invalid json"]);
+                done();
+            });
+        });
+        it("should handle empty chunks", (done) => {
+            const chunks = [
+                new Uint8Array(textCodec.encode("\n")),
+                new Uint8Array(textCodec.encode("\n"))
+            ];
+            of(...chunks)
+                .pipe(decodeJSONChunks({
+                textCodec,
+                characteristicName: "test",
+                delimiter: "\n",
+                addLog
+            }), toArray())
+                .subscribe((result) => {
+                expect(result).toEqual([]);
+                done();
+            });
+        });
+        it("should handle chunks without delimiters", (done) => {
+            const chunks = [
+                new Uint8Array(textCodec.encode('{"id":1}')),
+                new Uint8Array(textCodec.encode('{"id":2}'))
+            ];
+            of(...chunks)
+                .pipe(decodeJSONChunks({
+                textCodec,
+                characteristicName: "test",
+                delimiter: "\n",
+                addLog
+            }), toArray())
+                .subscribe((result) => {
+                expect(result).toEqual([]);
+                done();
+            });
+        });
+        it("should handle invalid JSON with custom error", (done) => {
+            const chunks = [
+                new Uint8Array(textCodec.encode('{"id":1\n')),
+                new Uint8Array(textCodec.encode("invalid json\n"))
+            ];
+            // Mock error without message property
+            const originalJSONParse = JSON.parse;
+            JSON.parse = jest.fn().mockImplementation(() => {
+                const error = Object.create(Error.prototype);
+                throw error;
+            });
+            of(...chunks)
+                .pipe(decodeJSONChunks({
+                textCodec,
+                characteristicName: "test",
+                delimiter: "\n",
+                addLog
+            }), toArray())
+                .subscribe({
+                next: (result) => {
+                    expect(result).toEqual(['{"id":1', "invalid json"]);
+                    JSON.parse = originalJSONParse;
+                    done();
+                },
+                error: (error) => {
+                    JSON.parse = originalJSONParse;
+                    done(error);
+                }
+            });
+        });
+    });
+    describe("stitch", () => {
+        it("should stitch complete chunks", (done) => {
+            const chunks = ['{"id":1}\n', '{"id":2}\n'];
+            of(...chunks)
+                .pipe(stitchChunks({ delimiter: "\n" }), toArray())
+                .subscribe({
+                next: (result) => {
+                    expect(result).toEqual(['{"id":1}', '{"id":2}']);
+                    done();
+                },
+                error: (error) => {
+                    done(error);
+                }
+            });
+        });
+        it("should stitch incomplete chunks", (done) => {
+            const chunks = ['{"id":', "1}\n", '{"id":2', "}\n"];
+            of(...chunks)
+                .pipe(stitchChunks({ delimiter: "\n" }), toArray())
+                .subscribe({
+                next: (result) => {
+                    expect(result).toEqual(['{"id":1}', '{"id":2}']);
+                    done();
+                },
+                error: (error) => {
+                    done(error);
+                }
+            });
+        });
+        it("should handle chunks with multiple delimiters", (done) => {
+            const chunks = ['{"id":1}\n', '{"id":2}\n', '{"id":3}\n'];
+            of(...chunks)
+                .pipe(stitchChunks({ delimiter: "\n" }), toArray())
+                .subscribe({
+                next: (result) => {
+                    expect(result).toEqual(['{"id":1}', '{"id":2}', '{"id":3}']);
+                    done();
+                },
+                error: (error) => {
+                    done(error);
+                }
+            });
+        });
+        it("should handle empty chunks", (done) => {
+            of()
+                .pipe(stitchChunks({ delimiter: "\n" }), toArray())
+                .subscribe({
+                next: (result) => {
+                    expect(result).toEqual([]);
+                    done();
+                },
+                error: (error) => {
+                    done(error);
+                }
+            });
+        });
+        it("should handle chunks without delimiters", (done) => {
+            const chunks = ['{"id":1}', '{"id":2}'];
+            of(...chunks)
+                .pipe(stitchChunks({ delimiter: "\n" }), toArray())
+                .subscribe({
+                next: (result) => {
+                    expect(result).toEqual([]);
+                    done();
+                },
+                error: (error) => {
+                    done(error);
+                }
+            });
+        });
+        it("should handle chunks ending with delimiter", (done) => {
+            const chunks = ['{"id":1}\n', '{"id":2}\n'];
+            of(...chunks)
+                .pipe(stitchChunks({ delimiter: "\n" }), toArray())
+                .subscribe({
+                next: (result) => {
+                    expect(result).toEqual(['{"id":1}', '{"id":2}']);
+                    done();
+                },
+                error: (error) => {
+                    done(error);
+                }
+            });
+        });
+        it("should handle remainder with delimiter", (done) => {
+            const chunks = ['{"id":1}\n{"id', ":2}\n"];
+            of(...chunks)
+                .pipe(stitchChunks({ delimiter: "\n" }), toArray())
+                .subscribe({
+                next: (result) => {
+                    expect(result).toEqual(['{"id":1}', '{"id:2}']);
+                    done();
+                },
+                error: (error) => {
+                    done(error);
+                }
+            });
+        });
+    });
+    describe("TextCodec", () => {
+        let textCodec;
+        beforeEach(() => {
+            textCodec = new TextCodec(TRANSPORT_TYPE.WEB);
+        });
+        it("should encode and decode text", () => {
+            const text = "Hello, World!";
+            const encoded = textCodec.encode(text);
+            const decoded = textCodec.decode(encoded);
+            expect(decoded).toBe(text);
+        });
+        it("should handle empty text", () => {
+            const text = "";
+            const encoded = textCodec.encode(text);
+            const decoded = textCodec.decode(encoded);
+            expect(decoded).toBe(text);
+        });
+        it("should handle special characters", () => {
+            const text = "Hello, 世界!";
+            const encoded = textCodec.encode(text);
+            const decoded = textCodec.decode(encoded);
+            expect(decoded).toBe(text);
+        });
+        it("should handle different transport types", () => {
+            const nativeCodec = new TextCodec(TRANSPORT_TYPE.REACT_NATIVE);
+            const text = "Hello, World!";
+            const encoded = nativeCodec.encode(text);
+            expect(Array.isArray(encoded)).toBe(true);
+            const decoded = nativeCodec.decode(Uint8Array.from(encoded));
+            expect(decoded).toBe(text);
+        });
+        it("should handle invalid input for decode", () => {
+            const invalidInput = new Uint8Array([0xff, 0xff, 0xff]);
+            const decoded = textCodec.decode(invalidInput);
+            expect(decoded).toBeDefined();
+            expect(typeof decoded).toBe("string");
+        });
+        it("should handle null input in decode", () => {
+            const emptyArray = new Uint8Array(0);
+            const result = textCodec.decode(emptyArray);
+            expect(result).toBe("");
+        });
+        it("should handle undefined input in decode", () => {
+            const emptyArray = new Uint8Array(0);
+            const result = textCodec.decode(emptyArray);
+            expect(result).toBe("");
+        });
+        it("should handle non-web transport type", () => {
+            const nodeCodec = new TextCodec("node");
+            const text = "Hello, World!";
+            const encoded = nodeCodec.encode(text);
+            expect(encoded).toBeDefined();
+            const decoded = nodeCodec.decode(encoded);
+            expect(decoded).toBe(text);
+        });
+    });
+});

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

@@ -8,12 +8,12 @@ import { Epoch } from "../../types/epoch";
 import { BLUETOOTH_CONNECTION } from "./types";
 import { DeviceNicknameOrPeripheral } from "./BluetoothTransport";
 import { Peripheral } from "./react-native/types/BleManagerTypes";
-export declare type BluetoothTransport = WebBluetoothTransport | ReactNativeTransport;
-declare type IsAuthenticated = boolean;
-declare type ExpiresIn = number;
-declare type IsAuthenticatedResponse = [IsAuthenticated, ExpiresIn];
-declare type CreateBluetoothToken = () => Promise<string>;
-declare type Options = {
+export type BluetoothTransport = WebBluetoothTransport | ReactNativeTransport;
+type IsAuthenticated = boolean;
+type ExpiresIn = number;
+type IsAuthenticatedResponse = [IsAuthenticated, ExpiresIn];
+type CreateBluetoothToken = () => Promise<string>;
+type Options = {
     transport: BluetoothTransport;
     selectedDevice$: Observable<DeviceInfo>;
     osHasBluetoothSupport$: Observable<boolean>;

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

@@ -3,7 +3,7 @@ import { BLUETOOTH_CONNECTION, TRANSPORT_TYPE } from "./types";
 import { Action } from "../../types/actions";
 import { DeviceInfo, OSVersion } from "../../types/deviceInfo";
 import { Peripheral } from "./react-native/types/BleManagerTypes";
-export declare type DeviceNicknameOrPeripheral = string | Peripheral;
+export type DeviceNicknameOrPeripheral = string | Peripheral;
 /**
  * @hidden
  */

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

@@ -8,21 +8,21 @@ import { Peripheral } from "./types/BleManagerTypes";
 import { NativeEventEmitter } from "./types/ReactNativeTypes";
 import { PlatformOSType } from "./types/ReactNativeTypes";
 import { DeviceInfo } from "../../../types/deviceInfo";
-declare type Characteristic = {
+type Characteristic = {
     characteristicUUID: string;
     serviceUUID: string;
     peripheralId: string;
 };
-declare type CharacteristicsByName = {
+type CharacteristicsByName = {
     [name: string]: Characteristic;
 };
-declare type Options = {
+type Options = {
     BleManager: BleManager;
     bleManagerEmitter: NativeEventEmitter;
     platform: PlatformOSType;
     autoConnect?: boolean;
 };
-declare type BleManagerEvents = {
+type BleManagerEvents = {
     stopScan$: Observable<void>;
     discoverPeripheral$: Observable<Peripheral>;
     connectPeripheral$: Observable<void>;

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

@@ -130,7 +130,7 @@ declare class EventEmitter {
  * The React Native implementation of the IOS RCTEventEmitter which is required when creating
  * a module that communicates with IOS
  */
-declare type NativeModule = {
+type NativeModule = {
     /**
      * Add the provided eventType as an active listener
      * @param eventType name of the event for which we are registering listener
@@ -176,5 +176,5 @@ export declare class NativeEventEmitter extends EventEmitter {
 /**
  * @see https://reactnative.dev/docs/platform-specific-code#content
  */
-export declare type PlatformOSType = "ios" | "android" | "macos" | "windows" | "web" | "native";
+export type PlatformOSType = "ios" | "android" | "macos" | "windows" | "web" | "native";
 export {};

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

@@ -1,14 +1,14 @@
 /**
  * @hidden
  */
-export declare type ActionOptions = {
+export type ActionOptions = {
     characteristicName: string;
     action: any;
 };
 /**
  * @hidden
  */
-export declare type SubscribeOptions = {
+export type SubscribeOptions = {
     characteristicName: string;
     manageNotifications?: boolean;
     skipJSONDecoding?: boolean;

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

@@ -2,7 +2,7 @@ import { TextCodec } from "./textCodec";
 /**
  * @hidden
  */
-declare type Options = {
+type Options = {
     textCodec: TextCodec;
     characteristicName: string;
     delimiter: string;

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

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

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

@@ -3,7 +3,7 @@ import { TRANSPORT_TYPE } from "../types";
  * @hidden
  * Uint8Array in Web | number[] in React Native
  */
-export declare type BufferLike = Uint8Array | number[];
+export type BufferLike = Uint8Array | number[];
 /**
  * @hidden
  */

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

@@ -5,7 +5,7 @@ import { TextCodec } from "../utils/textCodec";
 import { ActionOptions, SubscribeOptions } from "../types";
 import { TRANSPORT_TYPE, BLUETOOTH_CONNECTION } from "../types";
 import { DeviceInfo } from "../../../types/deviceInfo";
-declare type Options = {
+type Options = {
     autoConnect?: boolean;
 };
 export declare class WebBluetoothTransport implements BluetoothTransport {

package/dist/esm/api/firebase/FirebaseDevice.d.ts

@@ -1,7 +1,7 @@
 import firebase from "firebase/app";
 import { FirebaseApp } from "./FirebaseApp";
 import { SDKDependencies } from "../../types/options";
-declare type FirebaseDeviceOptions = {
+type FirebaseDeviceOptions = {
     deviceId: string;
     firebaseApp: FirebaseApp;
     dependencies: SDKDependencies;

package/dist/esm/api/firebase/FirebaseUser.d.ts

@@ -11,7 +11,7 @@ import { TransferDeviceOptions } from "../../utils/transferDevice";
 /**
  * @hidden
  */
-export declare type UserWithMetadata = User & {
+export type UserWithMetadata = User & {
     selectedDevice: DeviceInfo | null;
 };
 /**

package/dist/esm/api/index.js

@@ -9,7 +9,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 import { ReplaySubject, EMPTY } from "rxjs";
 import { fromEventPattern, firstValueFrom } from "rxjs";
-import { filter, shareReplay, share, switchMap } from "rxjs/operators";
+import { filter, shareReplay, switchMap } from "rxjs/operators";
 import { FirebaseApp, FirebaseUser, FirebaseDevice } from "./firebase";
 import { Timesync } from "../timesync";
 import { SubscriptionManager } from "../subscriptions/SubscriptionManager";
@@ -30,7 +30,7 @@ export class CloudClient {
         this.firebaseApp = new FirebaseApp(options);
         this.firebaseUser = new FirebaseUser(this.firebaseApp);
         this._selectedDevice.next(undefined);
-        this.status$ = heartbeatAwareStatus(this.observeNamespace("status").pipe(share())).pipe(filterInternalKeys(), shareReplay(1));
+        this.status$ = heartbeatAwareStatus(this.observeNamespace("status").pipe(shareReplay(1))).pipe(filterInternalKeys(), shareReplay(1));
         this.osVersion$ = this.observeNamespace("info/osVersion").pipe(shareReplay(1));
         this.firebaseUser.onAuthStateChanged().subscribe((user) => {
             this.user = user;