@neurosity/sdk 6.5.10 → 6.5.11

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

@@ -0,0 +1,237 @@
+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, take } from "rxjs";
+// 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 BehaviorSubject(undefined);
+            this._authStateSubject = new BehaviorSubject(null);
+            this.login = jest.fn().mockImplementation((credentials) => __awaiter(this, void 0, void 0, function* () {
+                if (credentials.email === "invalid@example.com") {
+                    throw new Error("Invalid credentials");
+                }
+                this._authStateSubject.next({ email: credentials.email });
+                return { user: { email: credentials.email } };
+            }));
+            this.logout = jest.fn().mockImplementation(() => __awaiter(this, void 0, void 0, function* () {
+                this._authStateSubject.next(null);
+                return {};
+            }));
+            this.createAccount = jest.fn().mockImplementation((credentials) => __awaiter(this, void 0, void 0, function* () {
+                var _a;
+                if ((_a = this._existingAccounts) === null || _a === void 0 ? void 0 : _a.includes(credentials.email)) {
+                    throw new Error("Account already exists");
+                }
+                if (!this._existingAccounts) {
+                    this._existingAccounts = [];
+                }
+                this._existingAccounts.push(credentials.email);
+                return { user: { email: credentials.email } };
+            }));
+            this.deleteAccount = jest.fn().mockImplementation(() => __awaiter(this, void 0, void 0, function* () {
+                this._authStateSubject.next(null);
+                return {};
+            }));
+            this.onAuthStateChanged = jest.fn().mockImplementation(() => {
+                return this._authStateSubject.asObservable();
+            });
+            this._existingAccounts = [];
+            this.options = options;
+        }
+    }
+    return Object.assign(Object.assign({}, originalModule), { CloudClient: jest
+            .fn()
+            .mockImplementation((options) => new MockCloudClient(options)) });
+});
+describe("Authentication", () => {
+    let neurosity;
+    const testDeviceId = "test-device-id";
+    const credentials = {
+        email: "test@example.com",
+        password: "testPassword123"
+    };
+    beforeEach(() => {
+        neurosity = new Neurosity({
+            deviceId: testDeviceId,
+            emulator: true
+        });
+    });
+    afterEach(() => __awaiter(void 0, void 0, void 0, function* () {
+        try {
+            yield neurosity.logout();
+        }
+        catch (error) {
+            // Ignore logout errors in cleanup
+        }
+    }));
+    describe("Basic Authentication", () => {
+        it("should handle login and logout flow", (done) => {
+            neurosity.login(credentials).then(() => {
+                neurosity
+                    .onAuthStateChanged()
+                    .pipe(take(1))
+                    .subscribe({
+                    next: (authState) => {
+                        expect(authState).toBeTruthy();
+                        expect(authState.email).toBe(credentials.email);
+                        done();
+                    },
+                    error: done
+                });
+            });
+        });
+        it("should handle logout", (done) => {
+            neurosity.login(credentials).then(() => {
+                neurosity.logout().then(() => {
+                    neurosity
+                        .onAuthStateChanged()
+                        .pipe(take(1))
+                        .subscribe({
+                        next: (loggedOutState) => {
+                            expect(loggedOutState).toBeFalsy();
+                            done();
+                        },
+                        error: done
+                    });
+                });
+            });
+        });
+        it("should reject invalid credentials", () => __awaiter(void 0, void 0, void 0, function* () {
+            const invalidCredentials = {
+                email: "invalid@example.com",
+                password: "wrongPassword"
+            };
+            yield expect(neurosity.login(invalidCredentials)).rejects.toThrow("Invalid credentials");
+        }));
+    });
+    describe("Account Management", () => {
+        it("should create account", (done) => {
+            const newAccount = {
+                email: "new@example.com",
+                password: "newPassword123"
+            };
+            neurosity.createAccount(newAccount).then(() => {
+                neurosity.login(newAccount).then(() => {
+                    neurosity
+                        .onAuthStateChanged()
+                        .pipe(take(1))
+                        .subscribe({
+                        next: (authState) => {
+                            expect(authState).toBeTruthy();
+                            expect(authState.email).toBe(newAccount.email);
+                            done();
+                        },
+                        error: done
+                    });
+                });
+            });
+        });
+        it("should delete account", (done) => {
+            const account = {
+                email: "delete@example.com",
+                password: "deletePassword123"
+            };
+            neurosity.createAccount(account).then(() => {
+                neurosity.login(account).then(() => {
+                    neurosity.deleteAccount().then(() => {
+                        neurosity
+                            .onAuthStateChanged()
+                            .pipe(take(1))
+                            .subscribe({
+                            next: (deletedState) => {
+                                expect(deletedState).toBeFalsy();
+                                done();
+                            },
+                            error: done
+                        });
+                    });
+                });
+            });
+        });
+        it("should prevent duplicate account creation", () => __awaiter(void 0, void 0, void 0, function* () {
+            const existingAccount = {
+                email: "existing@example.com",
+                password: "existingPassword123"
+            };
+            yield expect(neurosity.createAccount(existingAccount)).resolves.not.toThrow();
+            yield expect(neurosity.createAccount(existingAccount)).rejects.toThrow("Account already exists");
+            // Cleanup
+            yield neurosity.login(existingAccount);
+            yield neurosity.deleteAccount();
+        }));
+    });
+    describe("Auth State Changes", () => {
+        it("should emit initial auth state", (done) => {
+            neurosity
+                .onAuthStateChanged()
+                .pipe(take(1))
+                .subscribe({
+                next: (state) => {
+                    expect(state).toBeFalsy(); // Initial state should be null
+                    done();
+                },
+                error: done
+            });
+        });
+        it("should emit logged in state", (done) => {
+            neurosity.login(credentials).then(() => {
+                neurosity
+                    .onAuthStateChanged()
+                    .pipe(take(1))
+                    .subscribe({
+                    next: (loggedInState) => {
+                        expect(loggedInState).toBeTruthy();
+                        expect(loggedInState.email).toBe(credentials.email);
+                        done();
+                    },
+                    error: done
+                });
+            });
+        });
+        it("should handle session expiration", (done) => {
+            neurosity.login(credentials).then(() => {
+                const cloudClient = neurosity.cloudClient;
+                cloudClient._authStateSubject.next(null);
+                neurosity
+                    .onAuthStateChanged()
+                    .pipe(take(1))
+                    .subscribe({
+                    next: (expiredState) => {
+                        expect(expiredState).toBeFalsy();
+                        done();
+                    },
+                    error: done
+                });
+            });
+        });
+    });
+    describe("Error Handling", () => {
+        it("should handle network errors during login", () => __awaiter(void 0, void 0, void 0, function* () {
+            const cloudClient = neurosity.cloudClient;
+            cloudClient.login.mockRejectedValueOnce(new Error("Network error"));
+            yield expect(neurosity.login(credentials)).rejects.toThrow("Network error");
+        }));
+        it("should handle server errors during account creation", () => __awaiter(void 0, void 0, void 0, function* () {
+            const cloudClient = neurosity.cloudClient;
+            cloudClient.createAccount.mockRejectedValueOnce(new Error("Server error"));
+            yield expect(neurosity.createAccount(credentials)).rejects.toThrow("Server error");
+        }));
+    });
+});

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

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

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

@@ -0,0 +1,289 @@
+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 { firstValueFrom, of, ReplaySubject } from "rxjs";
+import { STATUS } from "../types/status";
+import { MODEL_VERSION_2 } from "../utils/platform";
+// 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._deviceInfo = {
+                deviceId: "test-device-id",
+                deviceNickname: "Test Device",
+                channelNames: ["CH1", "CH2"],
+                channels: 2,
+                samplingRate: 250,
+                manufacturer: "Neurosity",
+                model: "Crown",
+                modelName: "Crown",
+                modelVersion: MODEL_VERSION_2,
+                apiVersion: "1.0.0",
+                osVersion: "1.0.0",
+                emulator: false
+            };
+            this.getInfo = jest.fn().mockResolvedValue(this._deviceInfo);
+            this.selectDevice = jest
+                .fn()
+                .mockImplementation((selector) => __awaiter(this, void 0, void 0, function* () {
+                const selectedDevice = selector([this._deviceInfo]);
+                this._selectedDevice.next(selectedDevice);
+                return selectedDevice;
+            }));
+            this.getSelectedDevice = jest.fn().mockResolvedValue(this._deviceInfo);
+            this.didSelectDevice = jest.fn().mockResolvedValue(true);
+            this.onDeviceChange = jest.fn().mockReturnValue(of({
+                state: STATUS.ONLINE,
+                charging: false,
+                battery: 100,
+                sleepMode: false,
+                updatingProgress: 0,
+                bluetoothEnabled: false,
+                sleepModeReason: null,
+                lastHeartbeat: Date.now(),
+                ssid: "test-network"
+            }));
+            this.status = jest.fn().mockReturnValue(of({
+                state: STATUS.ONLINE,
+                charging: false,
+                battery: 100,
+                sleepMode: false,
+                updatingProgress: 0,
+                bluetoothEnabled: false,
+                sleepModeReason: null,
+                lastHeartbeat: Date.now(),
+                ssid: "test-network"
+            }));
+            this.osVersion = jest.fn().mockReturnValue(of("1.0.0"));
+            this.metrics = {
+                subscribe: jest.fn().mockImplementation((subscription) => {
+                    return subscription;
+                }),
+                unsubscribe: jest.fn(),
+                on: jest.fn().mockImplementation((subscription, callback) => {
+                    switch (subscription.labels[0]) {
+                        case "raw":
+                            callback({
+                                data: [
+                                    [100, 200],
+                                    [150, 250]
+                                ],
+                                info: {
+                                    samplingRate: 250,
+                                    startTime: Date.now(),
+                                    notchFrequency: "60Hz",
+                                    channelNames: [
+                                        "CP3",
+                                        "C3",
+                                        "F5",
+                                        "PO3",
+                                        "PO4",
+                                        "F6",
+                                        "C4",
+                                        "CP4"
+                                    ]
+                                }
+                            });
+                            break;
+                        case "rawUnfiltered":
+                            callback({
+                                data: [
+                                    [100, 200],
+                                    [150, 250]
+                                ],
+                                info: {
+                                    samplingRate: 250,
+                                    startTime: Date.now(),
+                                    channelNames: [
+                                        "CP3",
+                                        "C3",
+                                        "F5",
+                                        "PO3",
+                                        "PO4",
+                                        "F6",
+                                        "C4",
+                                        "CP4"
+                                    ]
+                                }
+                            });
+                            break;
+                        case "powerByBand":
+                            callback({
+                                gamma: [0.5, 0.6],
+                                beta: [0.4, 0.5],
+                                alpha: [0.3, 0.4],
+                                theta: [0.2, 0.3],
+                                delta: [0.1, 0.2],
+                                info: {
+                                    channelNames: [
+                                        "CP3",
+                                        "C3",
+                                        "F5",
+                                        "PO3",
+                                        "PO4",
+                                        "F6",
+                                        "C4",
+                                        "CP4"
+                                    ],
+                                    samplingRate: 256,
+                                    startTime: Date.now()
+                                }
+                            });
+                            break;
+                        case "psd":
+                            callback({
+                                label: "psd",
+                                psd: [
+                                    [0.1, 0.2],
+                                    [0.3, 0.4]
+                                ],
+                                freqs: [1, 2],
+                                info: {
+                                    notchFrequency: "60Hz",
+                                    samplingRate: 250,
+                                    startTime: Date.now(),
+                                    channelNames: [
+                                        "CP3",
+                                        "C3",
+                                        "F5",
+                                        "PO3",
+                                        "PO4",
+                                        "F6",
+                                        "C4",
+                                        "CP4"
+                                    ]
+                                }
+                            });
+                            break;
+                        default:
+                            throw new Error(`One ore more labels provided to brainwaves are invalid. The valid labels for brainwaves are raw, rawUnfiltered, frequency, powerByBand, psd`);
+                    }
+                    return () => { };
+                })
+            };
+            this.options = options;
+            this._selectedDevice.next(this._deviceInfo);
+        }
+    }
+    return Object.assign(Object.assign({}, originalModule), { CloudClient: jest
+            .fn()
+            .mockImplementation((options) => new MockCloudClient(options)) });
+});
+describe("Brainwaves", () => {
+    let neurosity;
+    const testDeviceId = "test-device-id";
+    beforeEach(() => {
+        neurosity = new Neurosity({
+            deviceId: testDeviceId,
+            emulator: true
+        });
+    });
+    describe("Raw Brainwaves", () => {
+        it("should get raw brainwaves data", () => __awaiter(void 0, void 0, void 0, function* () {
+            const data = (yield firstValueFrom(neurosity.brainwaves("raw")));
+            expect(data).toBeDefined();
+            expect(data.data).toBeInstanceOf(Array);
+            expect(data.data[0]).toBeInstanceOf(Array);
+            expect(data.info.samplingRate).toBe(250);
+            expect(data.info.startTime).toBeDefined();
+            expect(data.info.notchFrequency).toBe("60Hz");
+            expect(data.info.channelNames).toEqual([
+                "CP3",
+                "C3",
+                "F5",
+                "PO3",
+                "PO4",
+                "F6",
+                "C4",
+                "CP4"
+            ]);
+        }));
+        it("should get raw unfiltered brainwaves data", () => __awaiter(void 0, void 0, void 0, function* () {
+            const data = (yield firstValueFrom(neurosity.brainwaves("rawUnfiltered")));
+            expect(data).toBeDefined();
+            expect(data.data).toBeInstanceOf(Array);
+            expect(data.data[0]).toBeInstanceOf(Array);
+            expect(data.info.samplingRate).toBe(250);
+            expect(data.info.startTime).toBeDefined();
+            expect(data.info.channelNames).toEqual([
+                "CP3",
+                "C3",
+                "F5",
+                "PO3",
+                "PO4",
+                "F6",
+                "C4",
+                "CP4"
+            ]);
+            expect(data.info.notchFrequency).toBeUndefined();
+        }));
+    });
+    describe("Power by Band", () => {
+        it("should get power by band data", () => __awaiter(void 0, void 0, void 0, function* () {
+            const data = (yield firstValueFrom(neurosity.brainwaves("powerByBand")));
+            expect(data).toBeDefined();
+            expect(data.gamma).toBeInstanceOf(Array);
+            expect(data.beta).toBeInstanceOf(Array);
+            expect(data.alpha).toBeInstanceOf(Array);
+            expect(data.theta).toBeInstanceOf(Array);
+            expect(data.delta).toBeInstanceOf(Array);
+            // Verify info object exists and has correct properties
+            expect(data.info).toBeDefined();
+            expect(data.info.samplingRate).toBe(256);
+            expect(data.info.startTime).toBeDefined();
+            expect(data.info.channelNames).toEqual([
+                "CP3",
+                "C3",
+                "F5",
+                "PO3",
+                "PO4",
+                "F6",
+                "C4",
+                "CP4"
+            ]);
+        }));
+    });
+    describe("Power Spectral Density", () => {
+        it("should get PSD data", () => __awaiter(void 0, void 0, void 0, function* () {
+            const data = (yield firstValueFrom(neurosity.brainwaves("psd")));
+            expect(data).toBeDefined();
+            expect(data.label).toBe("psd");
+            expect(data.psd).toBeInstanceOf(Array);
+            expect(data.freqs).toBeInstanceOf(Array);
+            expect(data.info.samplingRate).toBe(250);
+            expect(data.info.startTime).toBeDefined();
+            expect(data.info.notchFrequency).toBe("60Hz");
+            expect(data.info.channelNames).toEqual([
+                "CP3",
+                "C3",
+                "F5",
+                "PO3",
+                "PO4",
+                "F6",
+                "C4",
+                "CP4"
+            ]);
+        }));
+    });
+    describe("Error Handling", () => {
+        it("should handle invalid brainwaves label", () => __awaiter(void 0, void 0, void 0, function* () {
+            yield expect(firstValueFrom(neurosity.brainwaves("invalid"))).rejects.toThrow("One ore more labels provided to brainwaves are invalid. The valid labels for brainwaves are raw, rawUnfiltered, frequency, powerByBand, psd");
+        }));
+    });
+});

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

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