@neurosity/sdk 6.5.9 → 6.5.11

package/dist/esm/__tests__/Neurosity.test.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,199 @@
+/// <reference types="node" />
+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 { describe } from "node:test";
+import { Neurosity } from "../Neurosity";
+import { firstValueFrom, take, of, ReplaySubject } from "rxjs";
+import { STATUS } from "../types/status";
+// Mock Firebase modules
+jest.mock("../api/firebase", () => {
+    const mockFirebaseApp = jest.fn().mockImplementation(() => ({
+        disconnect: jest.fn(),
+        useEmulator: jest.fn()
+    }));
+    mockFirebaseApp.prototype.constructor = mockFirebaseApp;
+    const mockFirebaseUser = jest.fn().mockImplementation(() => ({
+        login: jest.fn().mockResolvedValue({}),
+        logout: jest.fn().mockResolvedValue({}),
+        onAuthStateChanged: jest.fn().mockReturnValue(of(null)),
+        onUserClaimsChange: jest.fn().mockReturnValue(of({}))
+    }));
+    mockFirebaseUser.prototype.constructor = mockFirebaseUser;
+    const mockFirebaseDevice = jest.fn().mockImplementation(() => ({
+        disconnect: jest.fn(),
+        getInfo: jest.fn().mockResolvedValue({}),
+        selectDevice: jest.fn().mockResolvedValue({}),
+        dispatchAction: jest.fn()
+    }));
+    mockFirebaseDevice.prototype.constructor = mockFirebaseDevice;
+    return {
+        FirebaseApp: mockFirebaseApp,
+        FirebaseUser: mockFirebaseUser,
+        FirebaseDevice: mockFirebaseDevice
+    };
+});
+// Mock CloudClient
+jest.mock("../api", () => {
+    const originalModule = jest.requireActual("../api");
+    class MockCloudClient {
+        constructor(options) {
+            this.user = null;
+            this.userClaims = { scopes: ["brainwaves"] };
+            this.subscriptionManager = {
+                add: jest.fn(),
+                remove: jest.fn(),
+                removeAll: jest.fn()
+            };
+            this._selectedDevice = new ReplaySubject(1);
+            this.login = jest.fn().mockResolvedValue({});
+            this.logout = jest.fn().mockResolvedValue({});
+            this.getInfo = jest.fn().mockResolvedValue({});
+            this.selectDevice = jest.fn().mockResolvedValue({});
+            this.didSelectDevice = jest.fn().mockResolvedValue(true);
+            this.onDeviceChange = jest.fn().mockReturnValue(of({
+                deviceId: "test-device-id",
+                status: STATUS.ONLINE
+            }));
+            this.osVersion = jest.fn().mockReturnValue(of("1.0.0"));
+            this.status = jest.fn().mockReturnValue(of({ state: STATUS.ONLINE }));
+            this.metrics = {
+                subscribe: jest.fn().mockReturnValue(of({})),
+                on: jest.fn().mockImplementation((subscription, callback) => {
+                    callback({});
+                    return jest.fn();
+                }),
+                unsubscribe: jest.fn()
+            };
+            this.options = options;
+            this._selectedDevice.next(undefined);
+        }
+    }
+    return Object.assign(Object.assign({}, originalModule), { CloudClient: jest
+            .fn()
+            .mockImplementation((options) => new MockCloudClient(options)) });
+});
+describe("Neurosity", () => {
+    let neurosity;
+    const testDeviceId = "test-device-id";
+    const testEmail = "test@example.com";
+    const testPassword = "test-password";
+    beforeEach(() => {
+        jest.clearAllMocks();
+        neurosity = new Neurosity({
+            deviceId: testDeviceId,
+            emulator: true
+        });
+        // Mock _osHasBluetoothSupport to return false to avoid Bluetooth-related code paths
+        neurosity["_osHasBluetoothSupport"] = jest.fn().mockReturnValue(of(false));
+    });
+    describe("Initialization", () => {
+        test("should initialize with default options when no options provided", () => {
+            const instance = new Neurosity();
+            expect(instance).toBeDefined();
+        });
+        test("should initialize with provided deviceId", () => {
+            const instance = new Neurosity({ deviceId: testDeviceId });
+            expect(instance).toBeDefined();
+        });
+        test("should initialize with custom options", () => {
+            const instance = new Neurosity({
+                deviceId: testDeviceId,
+                emulator: true,
+                timesync: false
+            });
+            expect(instance).toBeDefined();
+        });
+    });
+    describe("Authentication", () => {
+        test("should handle login with email and password", () => __awaiter(void 0, void 0, void 0, function* () {
+            yield expect(neurosity.login({ email: testEmail, password: testPassword })).resolves.not.toThrow();
+        }));
+        test("should handle logout", () => __awaiter(void 0, void 0, void 0, function* () {
+            yield expect(neurosity.logout()).resolves.not.toThrow();
+        }));
+    });
+    describe("Device Management", () => {
+        test("should get device info", () => __awaiter(void 0, void 0, void 0, function* () {
+            const mockInfo = {
+                deviceId: testDeviceId,
+                deviceNickname: "Test Device",
+                channelNames: ["CH1", "CH2"],
+                channels: 2,
+                samplingRate: 250,
+                manufacturer: "Neurosity",
+                model: "Crown",
+                modelName: "Crown",
+                modelVersion: "v1",
+                apiVersion: "1.0.0",
+                osVersion: "1.0.0",
+                emulator: false
+            };
+            neurosity["cloudClient"].getInfo.mockResolvedValueOnce(mockInfo);
+            const info = yield neurosity.getInfo();
+            expect(info).toEqual(mockInfo);
+        }));
+        test("should handle device selection", () => __awaiter(void 0, void 0, void 0, function* () {
+            const mockDevice = {
+                deviceId: testDeviceId,
+                deviceNickname: "Test Device",
+                channelNames: ["CH1", "CH2"],
+                channels: 2,
+                samplingRate: 250,
+                manufacturer: "Neurosity",
+                model: "Crown",
+                modelName: "Crown",
+                modelVersion: "v1",
+                apiVersion: "1.0.0",
+                osVersion: "1.0.0",
+                emulator: false
+            };
+            neurosity["cloudClient"].selectDevice.mockResolvedValueOnce(mockDevice);
+            yield expect(neurosity.selectDevice((devices) => {
+                const device = devices.find((d) => d.deviceId === testDeviceId);
+                if (!device) {
+                    throw new Error("Device not found");
+                }
+                return device;
+            })).resolves.not.toThrow();
+        }));
+    });
+    describe("Streaming", () => {
+        test("should stream brainwaves", () => __awaiter(void 0, void 0, void 0, function* () {
+            const mockRawData = {
+                data: [
+                    [1, 2, 3, 4, 5, 6, 7, 8],
+                    [9, 10, 11, 12, 13, 14, 15, 16]
+                ],
+                info: {
+                    samplingRate: 256,
+                    startTime: Date.now()
+                }
+            };
+            // Mock the getCloudMetric function to return our mock data
+            neurosity["_getCloudMetricDependencies"] = jest.fn().mockReturnValue({
+                options: {
+                    deviceId: testDeviceId,
+                    emulator: true
+                },
+                cloudClient: neurosity["cloudClient"],
+                onDeviceChange: neurosity["cloudClient"].onDeviceChange,
+                status: neurosity["cloudClient"].status,
+                getCloudMetric: jest.fn().mockReturnValue(of(mockRawData))
+            });
+            const brainwaves = yield firstValueFrom(neurosity.brainwaves("raw").pipe(take(1)));
+            expect(brainwaves).toBeDefined();
+            if ("data" in brainwaves) {
+                expect(Array.isArray(brainwaves.data)).toBe(true);
+                expect(brainwaves.data.length).toBe(2);
+                expect(brainwaves.data[0].length).toBe(8);
+            }
+        }));
+    });
+});

package/dist/esm/__tests__/WebBluetoothTransport.test.d.ts

@@ -0,0 +1 @@
+import "./setup/webBluetooth.setup";

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

@@ -0,0 +1,199 @@
+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 "./setup/webBluetooth.setup";
+import { BLUETOOTH_PRIMARY_SERVICE_UUID_HEX } from "@neurosity/ipk";
+import { BLUETOOTH_DEVICE_NAME_PREFIXES } from "@neurosity/ipk";
+import { BLUETOOTH_COMPANY_IDENTIFIER_HEX } from "@neurosity/ipk";
+import { NEVER } from "rxjs";
+import { WebBluetoothTransport } from "../api/bluetooth/web/WebBluetoothTransport";
+import { BLUETOOTH_CONNECTION, TRANSPORT_TYPE } from "../api/bluetooth/types";
+// Get the mock function for isWebBluetoothSupported
+const mockIsWebBluetoothSupported = jest.requireMock("../api/bluetooth/web/isWebBluetoothSupported").isWebBluetoothSupported;
+describe("WebBluetoothTransport", () => {
+    let transport;
+    let mockDevice;
+    let mockServer;
+    let mockService;
+    let mockCharacteristic;
+    beforeEach(() => {
+        // Mock device and GATT objects
+        mockCharacteristic = {
+            uuid: "characteristic-uuid",
+            properties: {
+                write: true,
+                notify: true
+            },
+            startNotifications: jest.fn().mockResolvedValue(undefined),
+            addEventListener: jest.fn(),
+            removeEventListener: jest.fn(),
+            writeValue: jest.fn().mockResolvedValue(undefined)
+        };
+        mockService = {
+            uuid: BLUETOOTH_PRIMARY_SERVICE_UUID_HEX,
+            getCharacteristics: jest.fn().mockResolvedValue([mockCharacteristic])
+        };
+        mockServer = {
+            connected: true,
+            getPrimaryService: jest.fn().mockResolvedValue(mockService),
+            connect: jest.fn().mockResolvedValue(undefined),
+            disconnect: jest.fn()
+        };
+        mockDevice = {
+            id: "test-device",
+            name: "Test Device",
+            gatt: mockServer,
+            watchAdvertisements: jest.fn().mockResolvedValue(undefined),
+            addEventListener: jest.fn(),
+            removeEventListener: jest.fn()
+        };
+        // Mock navigator.bluetooth methods
+        window.navigator.bluetooth.getDevices.mockResolvedValue([]);
+        window.navigator.bluetooth.requestDevice.mockResolvedValue(mockDevice);
+        transport = new WebBluetoothTransport();
+    });
+    afterEach(() => {
+        jest.clearAllMocks();
+    });
+    it("should initialize with correct type and default options", () => {
+        expect(transport.type).toBe(TRANSPORT_TYPE.WEB);
+        expect(transport.options.autoConnect).toBe(true);
+    });
+    it("should throw error if Web Bluetooth is not supported", () => {
+        mockIsWebBluetoothSupported.mockReturnValueOnce(false);
+        expect(() => new WebBluetoothTransport()).toThrow("Web Bluetooth is not supported");
+    });
+    it("should enable/disable auto connect", (done) => {
+        transport.enableAutoConnect(false);
+        transport.connection().subscribe((connection) => {
+            expect(connection).toBe(BLUETOOTH_CONNECTION.DISCONNECTED);
+            done();
+        });
+    });
+    it("should handle connection state changes", (done) => {
+        const states = [];
+        transport.connection().subscribe((state) => {
+            states.push(state);
+            if (states.length === 2) {
+                expect(states).toEqual([
+                    BLUETOOTH_CONNECTION.DISCONNECTED,
+                    BLUETOOTH_CONNECTION.CONNECTED
+                ]);
+                done();
+            }
+        });
+        transport.connection$.next(BLUETOOTH_CONNECTION.CONNECTED);
+    });
+    it("should request device with correct options", () => __awaiter(void 0, void 0, void 0, function* () {
+        const deviceNickname = "Test Device";
+        yield transport.requestDevice(deviceNickname);
+        expect(window.navigator.bluetooth.requestDevice).toHaveBeenCalledWith({
+            filters: [
+                {
+                    name: deviceNickname
+                },
+                {
+                    manufacturerData: [
+                        {
+                            companyIdentifier: BLUETOOTH_COMPANY_IDENTIFIER_HEX
+                        }
+                    ]
+                }
+            ],
+            optionalServices: [BLUETOOTH_PRIMARY_SERVICE_UUID_HEX]
+        });
+    }));
+    it("should request device with prefixes when no nickname provided", () => __awaiter(void 0, void 0, void 0, function* () {
+        yield transport.requestDevice();
+        expect(window.navigator.bluetooth.requestDevice).toHaveBeenCalledWith({
+            filters: [
+                ...BLUETOOTH_DEVICE_NAME_PREFIXES.map((namePrefix) => ({
+                    namePrefix
+                })),
+                {
+                    manufacturerData: [
+                        {
+                            companyIdentifier: BLUETOOTH_COMPANY_IDENTIFIER_HEX
+                        }
+                    ]
+                }
+            ],
+            optionalServices: [BLUETOOTH_PRIMARY_SERVICE_UUID_HEX]
+        });
+    }));
+    it("should connect to device and setup GATT server", () => __awaiter(void 0, void 0, void 0, function* () {
+        mockServer.connect.mockResolvedValueOnce(mockServer);
+        yield transport.getServerServiceAndCharacteristics(mockDevice);
+        expect(mockServer.connect).toHaveBeenCalled();
+        expect(mockServer.getPrimaryService).toHaveBeenCalledWith(BLUETOOTH_PRIMARY_SERVICE_UUID_HEX);
+        expect(mockService.getCharacteristics).toHaveBeenCalled();
+        expect(transport.connection$.getValue()).toBe(BLUETOOTH_CONNECTION.CONNECTED);
+    }));
+    it("should handle disconnection", (done) => {
+        mockServer.connect.mockResolvedValueOnce(mockServer);
+        transport.device = mockDevice;
+        transport.server = mockServer;
+        transport.connection$.next(BLUETOOTH_CONNECTION.CONNECTED);
+        transport.connection().subscribe((connection) => {
+            if (connection === BLUETOOTH_CONNECTION.DISCONNECTED) {
+                done();
+            }
+        });
+        // Simulate disconnection
+        const disconnectCallback = mockDevice.addEventListener.mock.calls.find(([eventName]) => eventName === "gattserverdisconnected")[1];
+        disconnectCallback();
+    });
+    it("should auto connect when enabled", () => __awaiter(void 0, void 0, void 0, function* () {
+        const selectedDevice$ = NEVER;
+        const autoConnect$ = transport._autoConnect(selectedDevice$);
+        // Subscribe to auto connect observable
+        autoConnect$.subscribe();
+        // Verify auto connect is enabled
+        expect(transport.options.autoConnect).toBe(true);
+    }));
+    it("should get paired devices", () => __awaiter(void 0, void 0, void 0, function* () {
+        const devices = [mockDevice];
+        window.navigator.bluetooth.getDevices.mockResolvedValueOnce(devices);
+        const result = yield transport._getPairedDevices();
+        expect(result).toEqual(devices);
+    }));
+    it("should check connection status", () => {
+        transport.connection$.next(BLUETOOTH_CONNECTION.CONNECTED);
+        expect(transport.isConnected()).toBe(true);
+        transport.connection$.next(BLUETOOTH_CONNECTION.DISCONNECTED);
+        expect(transport.isConnected()).toBe(false);
+    });
+    it("should add logs", (done) => {
+        const testLog = "Test log message";
+        transport.logs$.subscribe((log) => {
+            expect(log).toBe(testLog);
+            done();
+        });
+        transport.addLog(testLog);
+    });
+    it("should handle connection errors", () => __awaiter(void 0, void 0, void 0, function* () {
+        const error = new Error("Connection failed");
+        mockServer.connect.mockRejectedValueOnce(error);
+        yield expect(transport.getServerServiceAndCharacteristics(mockDevice)).rejects.toThrow("Connection failed");
+        expect(transport.connection$.getValue()).not.toBe(BLUETOOTH_CONNECTION.CONNECTED);
+    }));
+    it("should handle service discovery errors", () => __awaiter(void 0, void 0, void 0, function* () {
+        mockServer.connect.mockResolvedValueOnce(mockServer);
+        mockServer.getPrimaryService.mockRejectedValueOnce(new Error("Service not found"));
+        yield expect(transport.getServerServiceAndCharacteristics(mockDevice)).rejects.toThrow("Service not found");
+        expect(transport.connection$.getValue()).not.toBe(BLUETOOTH_CONNECTION.CONNECTED);
+    }));
+    it("should handle characteristic discovery errors", () => __awaiter(void 0, void 0, void 0, function* () {
+        mockServer.connect.mockResolvedValueOnce(mockServer);
+        mockServer.getPrimaryService.mockResolvedValueOnce(mockService);
+        mockService.getCharacteristics.mockRejectedValueOnce(new Error("Characteristics not found"));
+        yield expect(transport.getServerServiceAndCharacteristics(mockDevice)).rejects.toThrow("Characteristics not found");
+        expect(transport.connection$.getValue()).not.toBe(BLUETOOTH_CONNECTION.CONNECTED);
+    }));
+});

package/dist/esm/__tests__/accelerometer.test.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,156 @@
+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 { Neurosity } from "../Neurosity";
+import { BehaviorSubject, Subscription } from "rxjs";
+import { take } from "rxjs/operators";
+import { STATUS } from "../types/status";
+// Mock CloudClient
+jest.mock("../api", () => {
+    const originalModule = jest.requireActual("../api");
+    class MockCloudClient {
+        constructor(options) {
+            this.user = null;
+            this.userClaims = { scopes: ["brainwaves"] };
+            this.subscriptionManager = {
+                add: jest.fn(),
+                remove: jest.fn(),
+                removeAll: jest.fn()
+            };
+            this._accelerometerData = new BehaviorSubject({
+                x: 0.1,
+                y: -0.2,
+                z: 9.8,
+                timestamp: Date.now(),
+                acceleration: 9.8,
+                inclination: 0,
+                orientation: 0,
+                pitch: 0,
+                roll: 0
+            });
+            this.bluetoothClient = {
+                accelerometer: jest.fn().mockReturnValue(this._accelerometerData),
+                connection: jest.fn().mockReturnValue(new BehaviorSubject("connected"))
+            };
+            this._selectedDevice = new BehaviorSubject({
+                deviceId: "test-device-id",
+                deviceNickname: "Test Device",
+                channelNames: ["CH1", "CH2"],
+                channels: 2,
+                samplingRate: 250,
+                manufacturer: "Neurosity",
+                model: "Crown",
+                modelName: "Crown",
+                modelVersion: "3",
+                apiVersion: "1.0.0",
+                osVersion: "16.0.0",
+                emulator: false
+            });
+            this.getInfo = jest.fn().mockResolvedValue(this._selectedDevice.value);
+            this.selectDevice = jest
+                .fn()
+                .mockImplementation(() => __awaiter(this, void 0, void 0, function* () { return this._selectedDevice.value; }));
+            this.didSelectDevice = jest.fn().mockResolvedValue(true);
+            this.onDeviceChange = jest.fn().mockReturnValue(this._selectedDevice);
+            this.status = jest.fn().mockReturnValue(new BehaviorSubject({
+                state: STATUS.ONLINE,
+                charging: false,
+                battery: 100,
+                sleepMode: false,
+                sleepModeReason: null,
+                lastHeartbeat: Date.now(),
+                ssid: "test-network"
+            }));
+            this.osVersion = jest.fn().mockReturnValue(new BehaviorSubject("16.0.0"));
+            this.metrics = {
+                subscribe: jest.fn().mockImplementation(() => {
+                    const subscription = new Subscription();
+                    subscription.add(this._accelerometerData.subscribe());
+                    return subscription;
+                }),
+                on: jest.fn().mockImplementation((subscription, callback) => {
+                    const sub = this._accelerometerData.subscribe(callback);
+                    return () => sub.unsubscribe();
+                })
+            };
+            this.options = options;
+        }
+    }
+    return Object.assign(Object.assign({}, originalModule), { CloudClient: jest
+            .fn()
+            .mockImplementation((options) => new MockCloudClient(options)) });
+});
+describe("Accelerometer", () => {
+    let neurosity;
+    const testDeviceId = "test-device-id";
+    beforeEach(() => {
+        neurosity = new Neurosity({
+            deviceId: testDeviceId,
+            emulator: true
+        });
+    });
+    describe("Accelerometer Data", () => {
+        it("should get accelerometer readings", (done) => {
+            neurosity
+                .accelerometer()
+                .pipe(take(1))
+                .subscribe({
+                next: (accel) => {
+                    expect(accel).toBeDefined();
+                    expect(typeof accel.x).toBe("number");
+                    expect(typeof accel.y).toBe("number");
+                    expect(typeof accel.z).toBe("number");
+                    expect(accel.timestamp).toBeDefined();
+                    // Check for reasonable values
+                    expect(accel.x).toBe(0.1);
+                    expect(accel.y).toBe(-0.2);
+                    expect(accel.z).toBe(9.8); // Approximately Earth's gravity
+                    done();
+                },
+                error: done
+            });
+        });
+        it("should provide continuous accelerometer updates", (done) => {
+            neurosity
+                .accelerometer()
+                .pipe(take(1))
+                .subscribe({
+                next: (reading) => {
+                    expect(reading.x).toBeDefined();
+                    expect(reading.y).toBeDefined();
+                    expect(reading.z).toBeDefined();
+                    expect(reading.timestamp).toBeDefined();
+                    done();
+                },
+                error: done
+            });
+        });
+    });
+    describe("Error Handling", () => {
+        it("should handle device offline state", (done) => {
+            // Mock device going offline
+            const cloudClient = neurosity.cloudClient;
+            cloudClient.status.mockReturnValueOnce(new BehaviorSubject({
+                state: STATUS.OFFLINE,
+                charging: false,
+                battery: 100,
+                sleepMode: false,
+                sleepModeReason: null,
+                lastHeartbeat: Date.now(),
+                ssid: "test-network"
+            }));
+            neurosity.accelerometer().subscribe({
+                error: (err) => {
+                    expect(err).toBeDefined();
+                    done();
+                }
+            });
+        });
+    });
+});

package/dist/esm/__tests__/auth.test.d.ts

@@ -0,0 +1 @@
+export {};