@neurosity/sdk 6.5.9 → 6.5.11

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

@@ -0,0 +1,133 @@
+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());
+    });
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { createOAuthURL } from "../api/https/createOAuthURL";
+import { getOAuthToken } from "../api/https/getOAuthToken";
+import axios from "axios";
+// Mock axios
+jest.mock("axios", () => ({
+    get: jest.fn().mockImplementation((url, config) => {
+        var _a;
+        if (!((_a = config === null || config === void 0 ? void 0 : config.params) === null || _a === void 0 ? void 0 : _a.client_id)) {
+            return Promise.reject(new Error("Missing required parameter: clientId"));
+        }
+        return Promise.resolve({
+            data: {
+                url: `/oauth/createOAuthURL?client_id=${config.params.client_id}&redirect_uri=${encodeURIComponent(config.params.redirect_uri)}&response_type=${config.params.response_type}&state=${config.params.state}&scope=${encodeURIComponent(config.params.scope)}`
+            }
+        });
+    }),
+    post: jest.fn().mockImplementation((url, data) => {
+        if (!data.clientId || !data.clientSecret || !data.userId) {
+            return Promise.reject(new Error("Missing OAuth credentials"));
+        }
+        if (data.clientId === "expired") {
+            return Promise.reject(new Error("Token expired"));
+        }
+        return Promise.resolve({
+            data: {
+                userId: "test-user-id",
+                accessToken: "test-access-token",
+                refreshToken: "test-refresh-token",
+                expiresIn: 3600
+            }
+        });
+    })
+}));
+// Mock getOAuthToken
+jest.mock("../api/https/getOAuthToken", () => {
+    return {
+        __esModule: true,
+        getOAuthToken: jest
+            .fn()
+            .mockImplementation((query, options) => __awaiter(void 0, void 0, void 0, function* () {
+            try {
+                const baseURL = options.emulator
+                    ? `http://${options.emulatorHost}:${options.emulatorFunctionsPort}/neurosity-device/us-central1`
+                    : "https://us-central1-neurosity-device.cloudfunctions.net";
+                const response = yield axios.post(baseURL, query);
+                return response.data;
+            }
+            catch (error) {
+                throw error;
+            }
+        }))
+    };
+});
+describe("OAuth and Token Management", () => {
+    const options = {
+        emulator: true,
+        emulatorHost: "localhost",
+        emulatorFunctionsPort: 5001
+    };
+    describe("OAuth URL Creation", () => {
+        const config = {
+            clientId: "test-client-id",
+            redirectUri: "http://localhost:3000/callback",
+            responseType: "token",
+            state: "random-state",
+            scope: ["read:devices-info", "read:brainwaves"]
+        };
+        it("should create OAuth URL with valid credentials", () => __awaiter(void 0, void 0, void 0, function* () {
+            const url = yield createOAuthURL(config, options);
+            expect(url).toContain(`client_id=${config.clientId}`);
+            expect(url).toContain(`redirect_uri=${encodeURIComponent(config.redirectUri)}`);
+            expect(url).toContain(`response_type=${config.responseType}`);
+            expect(url).toContain(`state=${config.state}`);
+            expect(url).toContain(`scope=${encodeURIComponent(config.scope.join(","))}`);
+        }));
+        it("should reject OAuth URL creation with missing credentials", () => __awaiter(void 0, void 0, void 0, function* () {
+            const { clientId } = config, invalidConfig = __rest(config, ["clientId"]);
+            yield expect(createOAuthURL(invalidConfig, options)).rejects.toThrow("Missing required parameter: clientId");
+        }));
+    });
+    describe("OAuth Token Management", () => {
+        it("should get OAuth token with valid credentials", () => __awaiter(void 0, void 0, void 0, function* () {
+            const query = {
+                clientId: "test-client-id",
+                clientSecret: "test-client-secret",
+                userId: "test-user-id"
+            };
+            const token = yield getOAuthToken(query, options);
+            expect(token).toEqual({
+                userId: "test-user-id",
+                accessToken: "test-access-token",
+                refreshToken: "test-refresh-token",
+                expiresIn: 3600
+            });
+        }));
+        it("should handle expired token", () => __awaiter(void 0, void 0, void 0, function* () {
+            const query = {
+                clientId: "expired",
+                clientSecret: "test-client-secret",
+                userId: "test-user-id"
+            };
+            yield expect(getOAuthToken(query, options)).rejects.toThrow("Token expired");
+        }));
+        it("should handle missing credentials", () => __awaiter(void 0, void 0, void 0, function* () {
+            const query = {
+                clientId: "test-client-id",
+                clientSecret: "",
+                userId: ""
+            };
+            yield expect(getOAuthToken(query, options)).rejects.toThrow("Missing OAuth credentials");
+        }));
+    });
+});

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

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

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

@@ -0,0 +1,128 @@
+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 { BehaviorSubject, of } from "rxjs";
+import { take } from "rxjs/operators";
+import { Neurosity } from "../Neurosity";
+// Mock CloudClient
+jest.mock("../api/index", () => {
+    const mockSettings = new BehaviorSubject({
+        lsl: false,
+        supportAccess: false,
+        activityLogging: false
+    });
+    const mockCloudClient = {
+        login: jest.fn(),
+        logout: jest.fn(),
+        onAuthStateChanged: jest.fn(),
+        onDeviceChange: jest.fn(),
+        status: jest.fn(),
+        didSelectDevice: jest.fn().mockResolvedValue(true),
+        observeNamespace: jest.fn((namespace) => {
+            if (namespace === "settings") {
+                return mockSettings;
+            }
+            return of(null);
+        }),
+        changeSettings: jest.fn((settings) => __awaiter(void 0, void 0, void 0, function* () {
+            // Validate settings
+            const validKeys = ["lsl", "bluetooth", "timesync", "deviceNickname"];
+            const hasInvalidKey = Object.keys(settings).some((key) => !validKeys.includes(key));
+            if (hasInvalidKey) {
+                throw new Error("Invalid settings");
+            }
+            mockSettings.next(Object.assign(Object.assign({}, mockSettings.value), settings));
+            return Promise.resolve();
+        })),
+        userClaims: {
+            scopes: ["settings"]
+        }
+    };
+    return {
+        CloudClient: jest.fn().mockImplementation(() => mockCloudClient)
+    };
+});
+const testDeviceId = "mock-device-id";
+describe("Settings", () => {
+    let neurosity;
+    let cloudClient;
+    beforeEach(() => {
+        neurosity = new Neurosity({
+            deviceId: testDeviceId
+        });
+        cloudClient = neurosity.cloudClient;
+    });
+    describe("Settings Management", () => {
+        it("should get current settings", (done) => {
+            neurosity
+                .settings()
+                .pipe(take(1))
+                .subscribe({
+                next: (settings) => {
+                    expect(settings).toBeDefined();
+                    expect(settings.lsl).toBe(false);
+                    expect(settings.supportAccess).toBe(false);
+                    expect(settings.activityLogging).toBe(false);
+                    done();
+                },
+                error: done
+            });
+        });
+        it("should update settings", (done) => {
+            const newSettings = {
+                lsl: true,
+                bluetooth: true,
+                timesync: true
+            };
+            neurosity
+                .changeSettings(newSettings)
+                .then(() => {
+                neurosity
+                    .settings()
+                    .pipe(take(1))
+                    .subscribe({
+                    next: (settings) => {
+                        expect(settings.lsl).toBe(true);
+                        expect(settings.supportAccess).toBe(true);
+                        expect(settings.activityLogging).toBe(true);
+                        done();
+                    },
+                    error: done
+                });
+            })
+                .catch(done);
+        });
+        it("should update device nickname", (done) => {
+            neurosity
+                .changeSettings({ supportAccess: true })
+                .then(() => {
+                neurosity
+                    .settings()
+                    .pipe(take(1))
+                    .subscribe({
+                    next: (settings) => {
+                        expect(settings.supportAccess).toBe(true);
+                        done();
+                    },
+                    error: done
+                });
+            })
+                .catch(done);
+        });
+    });
+    describe("Error Handling", () => {
+        it("should handle invalid settings changes", () => __awaiter(void 0, void 0, void 0, function* () {
+            const invalidChanges = {
+                invalidSetting: true
+            };
+            // @ts-ignore - Testing invalid settings
+            yield expect(neurosity.changeSettings(invalidChanges)).rejects.toThrow("Invalid settings");
+        }));
+    });
+});

package/dist/esm/__tests__/setup/webBluetooth.setup.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Setup file for Web Bluetooth tests
+ * This configures a minimal browser-like environment for testing Web Bluetooth functionality
+ */
+/// <reference types="jest" />
+declare const mockBluetooth: {
+    getDevices: jest.Mock<any, any, any>;
+    requestDevice: jest.Mock<any, any, any>;
+};
+declare const mockNavigator: Navigator;
+declare const mockWindow: Window & typeof globalThis;

package/dist/esm/__tests__/setup/webBluetooth.setup.js

@@ -0,0 +1,35 @@
+/**
+ * Setup file for Web Bluetooth tests
+ * This configures a minimal browser-like environment for testing Web Bluetooth functionality
+ */
+// Mock window and navigator.bluetooth
+const mockBluetooth = {
+    getDevices: jest.fn(),
+    requestDevice: jest.fn()
+};
+const mockNavigator = {
+    bluetooth: mockBluetooth
+};
+const mockWindow = {
+    navigator: mockNavigator
+};
+// Set up global object for Node environment
+global.window = mockWindow;
+global.navigator = mockWindow.navigator;
+// Mock isWebBluetoothSupported
+jest.mock("../../api/bluetooth/web/isWebBluetoothSupported", () => ({
+    isWebBluetoothSupported: jest.fn().mockReturnValue(true)
+}));
+// Mock IPK constants
+jest.mock("@neurosity/ipk", () => ({
+    BLUETOOTH_PRIMARY_SERVICE_UUID_HEX: "test-service-uuid",
+    BLUETOOTH_COMPANY_IDENTIFIER_HEX: 0x1234,
+    BLUETOOTH_DEVICE_NAME_PREFIXES: ["Crown"],
+    BLUETOOTH_CHUNK_DELIMITER: "\n",
+    BLUETOOTH_CHARACTERISTICS: {
+        ACTION: "test-action-uuid",
+        ACTION_STATUS: "test-action-status-uuid",
+        COMMAND: "test-command-uuid",
+        STATE: "test-state-uuid"
+    }
+}));

package/dist/esm/__tests__/setup.js

@@ -0,0 +1,7 @@
+/// <reference types="jest" />
+// Increase the default timeout for async operations
+jest.setTimeout(10000);
+// Add custom matchers if needed
+expect.extend({
+// Add custom matchers here if needed in the future
+});

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

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

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

@@ -0,0 +1,257 @@
+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, take, of } from "rxjs";
+import { STATUS } from "../types/status";
+// Mock Firebase modules
+jest.mock("../api/firebase", () => ({
+    FirebaseApp: jest.fn().mockImplementation(() => ({
+        disconnect: jest.fn(),
+        useEmulator: jest.fn()
+    })),
+    FirebaseUser: jest.fn().mockImplementation(() => ({
+        login: jest.fn(),
+        logout: jest.fn(),
+        onAuthStateChanged: jest.fn().mockReturnValue(of(null)),
+        onUserClaimsChange: jest.fn().mockReturnValue(of({}))
+    })),
+    FirebaseDevice: jest.fn().mockImplementation(() => ({
+        disconnect: jest.fn(),
+        getInfo: jest.fn(),
+        dispatchAction: jest.fn()
+    }))
+}));
+describe("Data Streaming", () => {
+    let neurosity;
+    const testDeviceId = "test-device-id";
+    const options = {
+        deviceId: testDeviceId,
+        emulator: true,
+        skill: {
+            id: "test-skill-id",
+            bundleId: "test-bundle-id",
+            spec: "1.0.0",
+            name: "Test Skill",
+            description: "A test skill",
+            metrics: ["brainwaves"],
+            userId: "test-user-id",
+            timestamp: Date.now(),
+            status: "active",
+            thumbnail: "test-thumbnail"
+        }
+    };
+    beforeEach(() => {
+        neurosity = new Neurosity(options);
+        // Mock cloudClient with userClaims for OAuth scope validation
+        // and required methods
+        neurosity["cloudClient"] = {
+            userClaims: {
+                scopes: ["brainwaves"]
+            },
+            onDeviceChange: jest.fn().mockReturnValue(of({
+                deviceId: testDeviceId,
+                status: STATUS.ONLINE
+            })),
+            osVersion: jest.fn().mockReturnValue(of("1.0.0")),
+            status: jest.fn().mockReturnValue(of({ state: STATUS.ONLINE })),
+            metrics: {
+                subscribe: jest.fn().mockReturnValue(of({})),
+                on: jest.fn().mockImplementation((subscription, callback) => {
+                    // Simulate metric data
+                    callback({});
+                    return jest.fn();
+                }),
+                unsubscribe: jest.fn()
+            },
+            subscriptionManager: {
+                add: jest.fn(),
+                remove: jest.fn(),
+                removeAll: jest.fn()
+            }
+        };
+        // Mock _osHasBluetoothSupport to return false to avoid Bluetooth-related code paths
+        neurosity["_osHasBluetoothSupport"] = jest.fn().mockReturnValue(of(false));
+    });
+    afterEach(() => __awaiter(void 0, void 0, void 0, function* () {
+        try {
+            yield neurosity.logout();
+        }
+        catch (error) {
+            // Ignore logout errors in cleanup
+        }
+    }));
+    describe("Brainwaves", () => {
+        it("should stream raw brainwaves data", () => __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(),
+                    channelNames: ["test-channel-1", "test-channel-2"]
+                }
+            };
+            // Mock the getCloudMetric function to return our mock data
+            neurosity["_getCloudMetricDependencies"] = jest.fn().mockReturnValue({
+                options,
+                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);
+                expect(brainwaves.info.samplingRate).toBe(256);
+            }
+        }));
+        it("should stream power by band data", () => __awaiter(void 0, void 0, void 0, function* () {
+            const mockPowerByBand = {
+                gamma: [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8],
+                beta: [0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9],
+                alpha: [0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0],
+                theta: [0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 1.1],
+                delta: [0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 1.1, 1.2],
+                info: {
+                    samplingRate: 256,
+                    startTime: Date.now(),
+                    channelNames: ["test-channel-1", "test-channel-2"]
+                }
+            };
+            // Mock the getCloudMetric function to return our mock data
+            neurosity["_getCloudMetricDependencies"] = jest.fn().mockReturnValue({
+                options,
+                cloudClient: neurosity["cloudClient"],
+                onDeviceChange: neurosity["cloudClient"].onDeviceChange,
+                status: neurosity["cloudClient"].status,
+                getCloudMetric: jest.fn().mockReturnValue(of(mockPowerByBand))
+            });
+            const powerByBand = yield firstValueFrom(neurosity.brainwaves("powerByBand").pipe(take(1)));
+            expect(powerByBand).toBeDefined();
+            if ("gamma" in powerByBand) {
+                expect(powerByBand.gamma).toBeDefined();
+                expect(powerByBand.beta).toBeDefined();
+                expect(powerByBand.alpha).toBeDefined();
+                expect(powerByBand.theta).toBeDefined();
+                expect(powerByBand.delta).toBeDefined();
+                expect(powerByBand.gamma.length).toBe(8);
+            }
+        }));
+        it("should stream PSD data", () => __awaiter(void 0, void 0, void 0, function* () {
+            const mockPSD = {
+                label: "psd",
+                psd: [
+                    [1, 2, 3, 4],
+                    [5, 6, 7, 8]
+                ],
+                freqs: [0, 2, 4, 6],
+                info: {
+                    samplingRate: 256,
+                    startTime: Date.now(),
+                    notchFrequency: "50",
+                    channelNames: ["test-channel-1", "test-channel-2"]
+                }
+            };
+            // Mock the getCloudMetric function to return our mock data
+            neurosity["_getCloudMetricDependencies"] = jest.fn().mockReturnValue({
+                options,
+                cloudClient: neurosity["cloudClient"],
+                onDeviceChange: neurosity["cloudClient"].onDeviceChange,
+                status: neurosity["cloudClient"].status,
+                getCloudMetric: jest.fn().mockReturnValue(of(mockPSD))
+            });
+            const psd = yield firstValueFrom(neurosity.brainwaves("psd").pipe(take(1)));
+            expect(psd).toBeDefined();
+            if ("psd" in psd) {
+                expect(Array.isArray(psd.psd)).toBe(true);
+                expect(Array.isArray(psd.freqs)).toBe(true);
+                expect(psd.info.samplingRate).toBe(256);
+            }
+        }));
+        it("should throw error when OAuth scope is missing", () => __awaiter(void 0, void 0, void 0, function* () {
+            // Remove brainwaves scope
+            neurosity["cloudClient"].userClaims.scopes = [];
+            // Mock the getCloudMetric function to throw an error
+            neurosity["_getCloudMetricDependencies"] = jest.fn().mockReturnValue({
+                options,
+                cloudClient: neurosity["cloudClient"],
+                onDeviceChange: neurosity["cloudClient"].onDeviceChange,
+                status: neurosity["cloudClient"].status,
+                getCloudMetric: jest.fn().mockImplementation(() => {
+                    throw new Error("Neurosity SDK: No permission to access the brainwaves metric. To access this metric, edit the skill's permissions");
+                })
+            });
+            // Mock the metrics subscription to throw an error
+            neurosity["cloudClient"].metrics.subscribe = jest
+                .fn()
+                .mockImplementation(() => {
+                throw new Error("Neurosity SDK: No permission to access the brainwaves metric. To access this metric, edit the skill's permissions");
+            });
+            yield expect(firstValueFrom(neurosity.brainwaves("raw").pipe(take(1)))).rejects.toThrow("Neurosity SDK: No permission to access the brainwaves metric. To access this metric, edit the skill's permissions");
+        }));
+    });
+    describe("Metrics", () => {
+        // TODO: Issue #XYZ - Metric streaming tests need to be implemented
+        // These tests require proper mocking of the metric data streams
+        it.skip("should stream focus data", () => __awaiter(void 0, void 0, void 0, function* () {
+            const focus = yield firstValueFrom(neurosity.focus().pipe(take(1)));
+            expect(focus).toBeDefined();
+            expect(typeof focus.probability).toBe("number");
+            expect(focus.probability).toBeGreaterThanOrEqual(0);
+            expect(focus.probability).toBeLessThanOrEqual(1);
+        }));
+        it.skip("should stream calm data", () => __awaiter(void 0, void 0, void 0, function* () {
+            const calm = yield firstValueFrom(neurosity.calm().pipe(take(1)));
+            expect(calm).toBeDefined();
+            expect(typeof calm.probability).toBe("number");
+            expect(calm.probability).toBeGreaterThanOrEqual(0);
+            expect(calm.probability).toBeLessThanOrEqual(1);
+        }));
+        it.skip("should stream kinesis data", () => __awaiter(void 0, void 0, void 0, function* () {
+            const kinesis = yield firstValueFrom(neurosity.kinesis("someAction").pipe(take(1)));
+            expect(kinesis).toBeDefined();
+            expect(typeof kinesis.probability).toBe("number");
+            expect(kinesis.probability).toBeGreaterThanOrEqual(0);
+            expect(kinesis.probability).toBeLessThanOrEqual(1);
+        }));
+    });
+    describe("Accelerometer", () => {
+        // TODO: Issue #XYZ - Accelerometer streaming tests need to be implemented
+        // These tests require proper mocking of the accelerometer data
+        it.skip("should stream accelerometer data", () => __awaiter(void 0, void 0, void 0, function* () {
+            const accelerometer = yield firstValueFrom(neurosity.accelerometer().pipe(take(1)));
+            expect(accelerometer).toBeDefined();
+            expect(accelerometer.x).toBeDefined();
+            expect(accelerometer.y).toBeDefined();
+            expect(accelerometer.z).toBeDefined();
+        }));
+    });
+    describe("Error Handling", () => {
+        // TODO: Issue #XYZ - Error handling tests need to be implemented
+        // These tests require proper error simulation and handling
+        it.skip("should handle subscription errors gracefully", () => __awaiter(void 0, void 0, void 0, function* () {
+            // Mock a subscription error
+            const errorSubscription = neurosity.brainwaves("raw").pipe(take(1));
+            yield expect(firstValueFrom(errorSubscription)).rejects.toThrow();
+        }));
+        it.skip("should handle rate limiting", () => __awaiter(void 0, void 0, void 0, function* () {
+            // Test rapid subscription creation and cleanup
+            const subscriptions = Array(10)
+                .fill(null)
+                .map(() => neurosity.brainwaves("raw").pipe(take(1)));
+            yield expect(Promise.all(subscriptions.map((sub) => firstValueFrom(sub)))).rejects.toThrow();
+        }));
+    });
+});

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

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

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

@@ -0,0 +1,52 @@
+import { Neurosity } from "../Neurosity";
+// Mock CloudClient
+jest.mock("../api", () => {
+    const originalModule = jest.requireActual("../api");
+    class MockCloudClient {
+        constructor(options) {
+            this.user = null;
+            this.userClaims = { scopes: ["brainwaves"] };
+            this.getTimesyncOffset = jest.fn().mockImplementation(() => {
+                return 150; // Mock 150ms offset
+            });
+            this.options = options;
+        }
+    }
+    return Object.assign(Object.assign({}, originalModule), { CloudClient: jest
+            .fn()
+            .mockImplementation((options) => new MockCloudClient(options)) });
+});
+describe("Timesync", () => {
+    let neurosity;
+    const testDeviceId = "test-device-id";
+    describe("with timesync enabled", () => {
+        beforeEach(() => {
+            neurosity = new Neurosity({
+                deviceId: testDeviceId,
+                emulator: true,
+                timesync: true
+            });
+        });
+        it("should get timesync offset", () => {
+            const offset = neurosity.getTimesyncOffset();
+            expect(offset).toBeDefined();
+            expect(typeof offset).toBe("number");
+            expect(offset).toBe(150);
+        });
+    });
+    describe("with timesync disabled", () => {
+        beforeEach(() => {
+            neurosity = new Neurosity({
+                deviceId: testDeviceId,
+                emulator: true,
+                timesync: false
+            });
+        });
+        it("should return 0 when timesync is disabled", () => {
+            const offset = neurosity.getTimesyncOffset();
+            expect(offset).toBeDefined();
+            expect(typeof offset).toBe("number");
+            expect(offset).toBe(0);
+        });
+    });
+});

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

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