@neurosity/sdk 6.5.10 → 6.5.11

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

@@ -0,0 +1,279 @@
+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, BehaviorSubject, take } from "rxjs";
+import { STATUS, SLEEP_MODE_REASON } 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._deviceInfo = {
+                deviceId: "test-device-id",
+                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
+            };
+            this._selectedDevice = new BehaviorSubject(this._deviceInfo);
+            this._deviceStatus = new BehaviorSubject({
+                state: STATUS.ONLINE,
+                charging: false,
+                battery: 100,
+                sleepMode: false,
+                sleepModeReason: null,
+                lastHeartbeat: Date.now(),
+                ssid: "test-network"
+            });
+            this._signalQuality = new BehaviorSubject({
+                CH1: {
+                    standardDeviation: 0.1,
+                    status: "good"
+                },
+                CH2: {
+                    standardDeviation: 0.1,
+                    status: "good"
+                }
+            });
+            this.getInfo = jest.fn().mockResolvedValue(this._deviceInfo);
+            this.selectDevice = jest
+                .fn()
+                .mockImplementation((selector) => __awaiter(this, void 0, void 0, function* () {
+                try {
+                    const selectedDevice = selector([this._deviceInfo]);
+                    this._selectedDevice.next(selectedDevice);
+                    return selectedDevice;
+                }
+                catch (error) {
+                    this._selectedDevice.next(null);
+                    throw error;
+                }
+            }));
+            this.didSelectDevice = jest.fn().mockResolvedValue(true);
+            this.onDeviceChange = jest
+                .fn()
+                .mockReturnValue(this._selectedDevice.asObservable());
+            this.status = jest.fn().mockReturnValue(this._deviceStatus.asObservable());
+            this.signalQuality = jest
+                .fn()
+                .mockReturnValue(this._signalQuality.asObservable());
+            this.osVersion = jest.fn().mockReturnValue(of("1.0.0"));
+            this.metrics = {
+                subscribe: jest.fn().mockImplementation((subscription) => {
+                    return Object.assign({ id: "test-id" }, subscription);
+                }),
+                on: jest.fn().mockImplementation((subscription, callback) => {
+                    if (subscription.metric === "signalQuality") {
+                        const sub = this._signalQuality.subscribe(callback);
+                        return () => sub.unsubscribe();
+                    }
+                    return () => { };
+                })
+            };
+            this.addDevice = jest.fn().mockImplementation((deviceId) => __awaiter(this, void 0, void 0, function* () {
+                if (deviceId === "invalid-id") {
+                    throw new Error("Invalid device ID");
+                }
+                return Promise.resolve();
+            }));
+            this.removeDevice = jest.fn().mockImplementation((deviceId) => __awaiter(this, void 0, void 0, function* () {
+                if (deviceId === "invalid-id") {
+                    throw new Error("Invalid device ID");
+                }
+                return Promise.resolve();
+            }));
+            this.transferDevice = jest
+                .fn()
+                .mockImplementation((options) => __awaiter(this, void 0, void 0, function* () {
+                if (options.deviceId === "invalid-id" ||
+                    options.recipientsUserId === "invalid-user") {
+                    throw new Error("Invalid transfer parameters");
+                }
+                return Promise.resolve();
+            }));
+            this.onUserDevicesChange = jest.fn().mockReturnValue(of([this._deviceInfo]));
+            this.options = options;
+        }
+        // Helper methods for tests
+        _updateDeviceStatus(status) {
+            this._deviceStatus.next(Object.assign(Object.assign({}, this._deviceStatus.value), status));
+        }
+        _updateSignalQuality(quality) {
+            this._signalQuality.next(quality);
+        }
+    }
+    return Object.assign(Object.assign({}, originalModule), { CloudClient: jest
+            .fn()
+            .mockImplementation((options) => new MockCloudClient(options)) });
+});
+describe("Device Management", () => {
+    let neurosity;
+    let cloudClient;
+    const testDeviceId = "test-device-id";
+    beforeEach(() => {
+        neurosity = new Neurosity({
+            deviceId: testDeviceId,
+            emulator: true
+        });
+        cloudClient = neurosity.cloudClient;
+    });
+    describe("Device Information", () => {
+        it("should get device info", () => __awaiter(void 0, void 0, void 0, function* () {
+            const info = yield neurosity.getInfo();
+            expect(info).toBeDefined();
+            expect(info.deviceId).toBe(testDeviceId);
+            expect(info.manufacturer).toBe("Neurosity");
+            expect(info.model).toBe("Crown");
+        }));
+        it("should get device status", () => __awaiter(void 0, void 0, void 0, function* () {
+            const status = yield firstValueFrom(neurosity.status());
+            expect(status).toBeDefined();
+            expect(status.state).toBe(STATUS.ONLINE);
+            expect(status.charging).toBe(false);
+            expect(status.battery).toBe(100);
+            expect(status.sleepMode).toBe(false);
+            expect(status.ssid).toBe("test-network");
+        }));
+        it("should get signal quality", () => __awaiter(void 0, void 0, void 0, function* () {
+            const quality = yield firstValueFrom(neurosity.signalQuality());
+            expect(quality).toBeDefined();
+            expect(quality.CH1.status).toBe("good");
+            expect(quality.CH1.standardDeviation).toBe(0.1);
+        }));
+        it("should get OS version", () => __awaiter(void 0, void 0, void 0, function* () {
+            const version = yield firstValueFrom(neurosity.osVersion());
+            expect(version).toBeDefined();
+            expect(version).toBe("1.0.0");
+        }));
+        it("should handle device status changes", (done) => {
+            const newStatus = {
+                state: STATUS.ONLINE,
+                charging: true,
+                battery: 80,
+                sleepMode: true,
+                sleepModeReason: SLEEP_MODE_REASON.CHARGING
+            };
+            neurosity.status().subscribe({
+                next: (status) => {
+                    if (status.charging === true) {
+                        expect(status.battery).toBe(80);
+                        expect(status.sleepMode).toBe(true);
+                        expect(status.sleepModeReason).toBe(SLEEP_MODE_REASON.CHARGING);
+                        done();
+                    }
+                },
+                error: done
+            });
+            cloudClient._updateDeviceStatus(newStatus);
+        });
+        it("should handle signal quality changes", (done) => {
+            const newQuality = {
+                CH1: {
+                    standardDeviation: 0.5,
+                    status: "bad"
+                },
+                CH2: {
+                    standardDeviation: 0.5,
+                    status: "bad"
+                }
+            };
+            cloudClient._updateSignalQuality(newQuality);
+            neurosity
+                .signalQuality()
+                .pipe(take(1))
+                .subscribe({
+                next: (quality) => {
+                    expect(quality.CH1.standardDeviation).toBe(0.5);
+                    expect(quality.CH2.status).toBe("bad");
+                    done();
+                },
+                error: done
+            });
+        }, 10000);
+    });
+    describe("Device Selection", () => {
+        it("should select device", () => __awaiter(void 0, void 0, void 0, function* () {
+            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();
+            const deviceInfo = yield neurosity.getInfo();
+            expect(deviceInfo.deviceId).toBe(testDeviceId);
+        }));
+        it("should handle device selection failure", () => __awaiter(void 0, void 0, void 0, function* () {
+            yield expect(neurosity.selectDevice(() => {
+                throw new Error("Device not found");
+            })).rejects.toThrow("Device not found");
+        }));
+        it("should monitor device changes", (done) => {
+            neurosity
+                .onDeviceChange()
+                .pipe(take(1))
+                .subscribe({
+                next: (deviceInfo) => {
+                    expect(deviceInfo).toBeDefined();
+                    expect(deviceInfo.deviceId).toBe(testDeviceId);
+                    done();
+                },
+                error: done
+            });
+        });
+    });
+    describe("Device Management", () => {
+        it("should add device", () => __awaiter(void 0, void 0, void 0, function* () {
+            yield expect(neurosity.addDevice(testDeviceId)).resolves.not.toThrow();
+        }));
+        it("should handle invalid device ID when adding", () => __awaiter(void 0, void 0, void 0, function* () {
+            yield expect(neurosity.addDevice("invalid-id")).rejects.toThrow("Invalid device ID");
+        }));
+        it("should remove device", () => __awaiter(void 0, void 0, void 0, function* () {
+            yield expect(neurosity.removeDevice(testDeviceId)).resolves.not.toThrow();
+        }));
+        it("should handle invalid device ID when removing", () => __awaiter(void 0, void 0, void 0, function* () {
+            yield expect(neurosity.removeDevice("invalid-id")).rejects.toThrow("Invalid device ID");
+        }));
+        it("should transfer device", () => __awaiter(void 0, void 0, void 0, function* () {
+            const transferOptions = {
+                deviceId: testDeviceId,
+                recipientsUserId: "target-user-id"
+            };
+            yield expect(neurosity.transferDevice(transferOptions)).resolves.not.toThrow();
+        }));
+        it("should handle invalid transfer parameters", () => __awaiter(void 0, void 0, void 0, function* () {
+            const invalidOptions = {
+                deviceId: "invalid-id",
+                recipientsUserId: "invalid-user"
+            };
+            yield expect(neurosity.transferDevice(invalidOptions)).rejects.toThrow("Invalid transfer parameters");
+        }));
+        it("should monitor user devices changes", () => __awaiter(void 0, void 0, void 0, function* () {
+            const devices = yield firstValueFrom(neurosity.onUserDevicesChange());
+            expect(devices).toBeDefined();
+            expect(Array.isArray(devices)).toBe(true);
+            expect(devices[0].deviceId).toBe(testDeviceId);
+        }));
+    });
+});

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

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

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

@@ -0,0 +1,160 @@
+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 { of, ReplaySubject } from "rxjs";
+import { STATUS } from "../types/status";
+import { strongClick100, strongBuzz100, alert750ms, doubleClick100, sharpClick100 } from "../utils/hapticEffects";
+import { MODEL_VERSION_2, HAPTIC_P7, HAPTIC_P8 } 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.osVersion = jest.fn().mockReturnValue(of("1.0.0"));
+            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.dispatchAction = jest.fn().mockImplementation((payload) => __awaiter(this, void 0, void 0, function* () {
+                const { effects } = payload.message;
+                for (const location of Object.keys(effects)) {
+                    if (![HAPTIC_P7, HAPTIC_P8].includes(location)) {
+                        throw new Error(`Invalid haptic location: ${location}`);
+                    }
+                    const effectList = effects[location];
+                    if (!Array.isArray(effectList)) {
+                        throw new Error("Effects must be an array");
+                    }
+                    if (effectList.length > 7) {
+                        throw new Error("Maximum items in array is 7");
+                    }
+                    for (const effect of effectList) {
+                        const validEffects = [
+                            strongClick100,
+                            strongBuzz100,
+                            alert750ms,
+                            doubleClick100,
+                            sharpClick100
+                        ];
+                        if (!validEffects.includes(effect)) {
+                            throw new Error("Invalid haptic effect");
+                        }
+                    }
+                }
+                return Promise.resolve();
+            }));
+            this.options = options;
+            this._selectedDevice.next(this._deviceInfo);
+        }
+    }
+    return Object.assign(Object.assign({}, originalModule), { CloudClient: jest
+            .fn()
+            .mockImplementation((options) => new MockCloudClient(options)) });
+});
+describe("Haptics", () => {
+    let neurosity;
+    const testDeviceId = "test-device-id";
+    beforeEach(() => {
+        neurosity = new Neurosity({
+            deviceId: testDeviceId,
+            emulator: true
+        });
+    });
+    describe("Haptic Effects", () => {
+        it("should trigger strong click haptic effect on P7", () => __awaiter(void 0, void 0, void 0, function* () {
+            yield expect(neurosity.haptics({
+                [HAPTIC_P7]: [strongClick100]
+            })).resolves.not.toThrow();
+        }));
+        it("should trigger strong buzz haptic effect on P8", () => __awaiter(void 0, void 0, void 0, function* () {
+            yield expect(neurosity.haptics({
+                [HAPTIC_P8]: [strongBuzz100]
+            })).resolves.not.toThrow();
+        }));
+        it("should trigger effects on both motors", () => __awaiter(void 0, void 0, void 0, function* () {
+            yield expect(neurosity.haptics({
+                [HAPTIC_P7]: [alert750ms],
+                [HAPTIC_P8]: [doubleClick100]
+            })).resolves.not.toThrow();
+        }));
+        it("should trigger multiple effects on one motor", () => __awaiter(void 0, void 0, void 0, function* () {
+            yield expect(neurosity.haptics({
+                [HAPTIC_P7]: [sharpClick100, strongClick100, doubleClick100]
+            })).resolves.not.toThrow();
+        }));
+    });
+    describe("Error Handling", () => {
+        it("should handle invalid haptic location", () => __awaiter(void 0, void 0, void 0, function* () {
+            yield expect(neurosity.haptics({
+                invalid: [strongClick100]
+            })).rejects.toThrow(/location not supported/);
+        }));
+        it("should handle invalid haptic effect", () => __awaiter(void 0, void 0, void 0, function* () {
+            yield expect(neurosity.haptics({
+                [HAPTIC_P7]: ["invalid"]
+            })).rejects.toThrow("Invalid haptic effect");
+        }));
+        it("should handle too many effects", () => __awaiter(void 0, void 0, void 0, function* () {
+            yield expect(neurosity.haptics({
+                [HAPTIC_P7]: Array(8).fill(strongClick100)
+            })).rejects.toThrow(/Maximum items in array is 7/);
+        }));
+    });
+});

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

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

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

@@ -0,0 +1,176 @@
+import { Neurosity } from "../Neurosity";
+import { BehaviorSubject, of, throwError } from "rxjs";
+import { take } from "rxjs/operators";
+import { STATUS } from "../types/status";
+// Mock CloudClient
+jest.mock("../api/index", () => {
+    const mockSubscriptions = new Map();
+    const mockListeners = new Map();
+    let subscriptionId = 0;
+    const mockCloudClient = {
+        login: jest.fn(),
+        logout: jest.fn(),
+        onAuthStateChanged: jest.fn(),
+        onDeviceChange: jest.fn(),
+        status: jest.fn(),
+        metrics: {
+            on: jest.fn((subscription, callback) => {
+                const listener = (value) => callback(value);
+                const key = `${subscription.id}-${subscription.metric}-${subscription.labels.join(",")}`;
+                if (!mockListeners.has(key)) {
+                    mockListeners.set(key, []);
+                }
+                mockListeners.get(key).push(listener);
+                return listener;
+            }),
+            subscribe: jest.fn((subscription) => {
+                const id = `subscription-${subscriptionId++}`;
+                const sub = Object.assign({ id }, subscription);
+                mockSubscriptions.set(id, sub);
+                return sub;
+            }),
+            unsubscribe: jest.fn((subscription, listener) => {
+                const key = `${subscription.id}-${subscription.metric}-${subscription.labels.join(",")}`;
+                const listeners = mockListeners.get(key) || [];
+                const index = listeners.indexOf(listener);
+                if (index > -1) {
+                    listeners.splice(index, 1);
+                }
+                mockSubscriptions.delete(subscription.id);
+            })
+        },
+        osVersion: jest.fn(),
+        userClaims: {
+            scopes: ["focus", "kinesis"]
+        }
+    };
+    return {
+        CloudClient: jest.fn().mockImplementation(() => mockCloudClient)
+    };
+});
+const testDeviceId = "mock-device-id";
+describe("Metrics", () => {
+    let neurosity;
+    let mockFocusData;
+    let mockKinesisData;
+    let cloudClient;
+    beforeEach(() => {
+        neurosity = new Neurosity({
+            deviceId: testDeviceId,
+            emulator: true
+        });
+        cloudClient = neurosity.cloudClient;
+        // Mock device info
+        const mockDeviceInfo = {
+            deviceId: testDeviceId,
+            channelNames: ["CP3", "C3", "F5", "PO3", "PO4", "F6", "C4", "CP4"],
+            samplingRate: 256,
+            modelName: "crown",
+            modelVersion: "v3"
+        };
+        // Mock device status
+        const mockDeviceStatus = {
+            state: STATUS.ONLINE,
+            charging: false,
+            battery: 100,
+            sleepMode: false,
+            sleepModeReason: null,
+            lastHeartbeat: Date.now(),
+            ssid: "test-network"
+        };
+        // Setup mock data
+        mockFocusData = new BehaviorSubject({
+            probability: 0.85,
+            label: "focus",
+            metric: "awareness",
+            timestamp: Date.now()
+        });
+        mockKinesisData = new BehaviorSubject({
+            probability: 0.75,
+            label: "leftArm",
+            metric: "kinesis",
+            timestamp: Date.now()
+        });
+        // Mock cloud client methods
+        cloudClient.onDeviceChange.mockReturnValue(of(mockDeviceInfo));
+        cloudClient.status.mockReturnValue(of(mockDeviceStatus));
+        cloudClient.osVersion.mockReturnValue(of("16.0.0"));
+        // Setup metrics subscription behavior
+        cloudClient.metrics.subscribe.mockImplementation((subscription) => {
+            return Object.assign({ id: "test-id" }, subscription);
+        });
+        cloudClient.metrics.on.mockImplementation((subscription, callback) => {
+            if (subscription.metric === "awareness") {
+                const sub = mockFocusData.subscribe((value) => callback(value));
+                return () => sub.unsubscribe();
+            }
+            else if (subscription.metric === "kinesis") {
+                const sub = mockKinesisData.subscribe((value) => callback(value));
+                return () => sub.unsubscribe();
+            }
+            return () => { };
+        });
+    });
+    describe("Focus", () => {
+        it("should get focus metrics", (done) => {
+            neurosity
+                .focus()
+                .pipe(take(1))
+                .subscribe({
+                next: (focus) => {
+                    expect(focus).toBeDefined();
+                    expect(focus.probability).toBe(0.85);
+                    expect(focus.label).toBe("focus");
+                    expect(focus.metric).toBe("awareness");
+                    expect(focus.timestamp).toBeDefined();
+                    done();
+                },
+                error: done
+            });
+        });
+    });
+    describe("Kinesis", () => {
+        it("should get kinesis metrics", (done) => {
+            neurosity
+                .kinesis("leftArm")
+                .pipe(take(1))
+                .subscribe({
+                next: (kinesis) => {
+                    expect(kinesis).toBeDefined();
+                    expect(kinesis.probability).toBe(0.75);
+                    expect(kinesis.label).toBe("leftArm");
+                    expect(kinesis.metric).toBe("kinesis");
+                    expect(kinesis.timestamp).toBeDefined();
+                    done();
+                },
+                error: done
+            });
+        });
+    });
+    describe("Error Handling", () => {
+        it("should handle device offline state", (done) => {
+            // Mock device going offline
+            cloudClient.onDeviceChange.mockReturnValue(of({
+                deviceId: testDeviceId,
+                channelNames: ["CP3", "C3", "F5", "PO3", "PO4", "F6", "C4", "CP4"],
+                samplingRate: 256,
+                modelName: "crown",
+                modelVersion: "v3"
+            }));
+            cloudClient.status.mockReturnValue(throwError(() => new Error("Device is offline")));
+            neurosity
+                .focus()
+                .pipe(take(1))
+                .subscribe({
+                next: () => {
+                    done(new Error("Should not emit when device is offline"));
+                },
+                error: (err) => {
+                    expect(err).toBeDefined();
+                    expect(err.message).toContain("offline");
+                    done();
+                }
+            });
+        });
+    });
+});

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

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