@neurosity/sdk 6.2.0 → 6.2.1-next.1

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

@@ -1,72 +0,0 @@
-import { Observable } from "rxjs";
-import { ReplaySubject } from "rxjs";
-import { WebBluetoothTransport } from "./web/WebBluetoothTransport";
-import { ReactNativeTransport } from "./react-native/ReactNativeTransport";
-import { DeviceInfo } from "../../types/deviceInfo";
-import { Action } from "../../types/actions";
-import { Epoch } from "../../types/epoch";
-import { BLUETOOTH_CONNECTION } from "./types";
-import { DeviceNicknameOrPeripheral } from "./BluetoothTransport";
-import { Peripheral } from "./react-native/types/BleManagerTypes";
-export declare type BluetoothTransport = WebBluetoothTransport | ReactNativeTransport;
-declare type IsAuthenticated = boolean;
-declare type ExpiresIn = number;
-declare type IsAuthenticatedResponse = [IsAuthenticated, ExpiresIn];
-declare type CreateBluetoothToken = () => Promise<string>;
-declare type Options = {
-    transport: BluetoothTransport;
-    selectedDevice$: Observable<DeviceInfo>;
-    createBluetoothToken: CreateBluetoothToken;
-};
-export declare class BluetoothClient {
-    transport: BluetoothTransport;
-    deviceInfo: DeviceInfo;
-    selectedDevice$: ReplaySubject<DeviceInfo>;
-    isAuthenticated$: ReplaySubject<boolean>;
-    _focus$: Observable<any>;
-    _calm$: Observable<any>;
-    _accelerometer$: Observable<any>;
-    _brainwavesRaw$: Observable<any>;
-    _brainwavesRawUnfiltered$: Observable<any>;
-    _brainwavesPSD$: Observable<any>;
-    _brainwavesPowerByBand$: Observable<any>;
-    _signalQuality$: Observable<any>;
-    _status$: Observable<any>;
-    _settings$: Observable<any>;
-    _wifiNearbyNetworks$: Observable<any>;
-    _wifiConnections$: Observable<any>;
-    constructor(options: Options);
-    _autoAuthenticate(createBluetoothToken: CreateBluetoothToken): Observable<IsAuthenticatedResponse>;
-    enableAutoConnect(autoConnect: boolean): void;
-    _hasBluetoothSupport(): Promise<boolean>;
-    authenticate(token: string): Promise<IsAuthenticatedResponse>;
-    isAuthenticated(): Promise<IsAuthenticatedResponse>;
-    scan(options?: any): Observable<Peripheral[]>;
-    connect(deviceNicknameORPeripheral?: DeviceNicknameOrPeripheral): Promise<void>;
-    disconnect(): Promise<void>;
-    connection(): Observable<BLUETOOTH_CONNECTION>;
-    logs(): Observable<string>;
-    getDeviceId(): Promise<string>;
-    _withAuthentication<T>(getter: () => Promise<T>): Promise<T>;
-    _subscribeWhileAuthenticated(characteristicName: string): Observable<any>;
-    focus(): Observable<any>;
-    calm(): Observable<any>;
-    accelerometer(): Observable<any>;
-    brainwaves(label: string): Observable<Epoch | any>;
-    signalQuality(): Observable<any>;
-    addMarker(label: string): Promise<void>;
-    getInfo(): Promise<DeviceInfo>;
-    status(): Observable<any>;
-    dispatchAction(action: Action): Promise<any>;
-    settings(): Observable<any>;
-    haptics(effects: any): Promise<any>;
-    get wifi(): {
-        nearbyNetworks: () => Observable<any>;
-        connections: () => Observable<any>;
-        connect: (ssid: string, password?: string) => Promise<any>;
-        forgetConnection: (ssid: string) => Promise<any>;
-        reset: () => Promise<any>;
-        speedTest: () => Promise<any>;
-    };
-}
-export {};

package/dist/esm/api/bluetooth/BluetoothClient.js

@@ -1,306 +0,0 @@
-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 { defer, firstValueFrom, timer } from "rxjs";
-import { ReplaySubject, EMPTY } from "rxjs";
-import { switchMap, share, tap } from "rxjs/operators";
-import { distinctUntilChanged } from "rxjs/operators";
-import { WebBluetoothTransport } from "./web/WebBluetoothTransport";
-import { ReactNativeTransport } from "./react-native/ReactNativeTransport";
-import { csvBufferToEpoch } from "./utils/csvBufferToEpoch";
-import { BLUETOOTH_CONNECTION } from "./types";
-import { osHasBluetoothSupport } from "./utils/osHasBluetoothSupport";
-export class BluetoothClient {
-    constructor(options) {
-        this.selectedDevice$ = new ReplaySubject(1);
-        this.isAuthenticated$ = new ReplaySubject(1);
-        const { transport, selectedDevice$, createBluetoothToken } = options !== null && options !== void 0 ? options : {};
-        if (!transport) {
-            throw new Error(`No bluetooth transport provided.`);
-        }
-        this.transport = transport;
-        // Pass events to the internal selectedDevice$ if selectedDevice$ is passed via options
-        if (selectedDevice$) {
-            selectedDevice$.subscribe(this.selectedDevice$);
-        }
-        // Auto Connect
-        this.transport._autoConnect(this.selectedDevice$).subscribe({
-            error: (error) => {
-                var _a;
-                this.transport.addLog(`Auto connect: error -> ${(_a = error === null || error === void 0 ? void 0 : error.message) !== null && _a !== void 0 ? _a : error}`);
-            }
-        });
-        // Auto authentication
-        if (typeof createBluetoothToken === "function") {
-            this.transport.addLog("Auto authentication enabled");
-            this._autoAuthenticate(createBluetoothToken).subscribe();
-        }
-        else {
-            this.transport.addLog("Auto authentication not enabled");
-        }
-        // Auto manage action notifications
-        this.transport._autoToggleActionNotifications(this.selectedDevice$);
-        // Multicast metrics (share)
-        this._focus$ = this._subscribeWhileAuthenticated("focus");
-        this._calm$ = this._subscribeWhileAuthenticated("calm");
-        this._accelerometer$ = this._subscribeWhileAuthenticated("accelerometer");
-        this._brainwavesRaw$ = this._subscribeWhileAuthenticated("raw");
-        this._brainwavesRawUnfiltered$ =
-            this._subscribeWhileAuthenticated("rawUnfiltered");
-        this._brainwavesPSD$ = this._subscribeWhileAuthenticated("psd");
-        this._brainwavesPowerByBand$ =
-            this._subscribeWhileAuthenticated("powerByBand");
-        this._signalQuality$ = this._subscribeWhileAuthenticated("signalQuality");
-        this._status$ = this._subscribeWhileAuthenticated("status");
-        this._settings$ = this._subscribeWhileAuthenticated("settings");
-        this._wifiNearbyNetworks$ =
-            this._subscribeWhileAuthenticated("wifiNearbyNetworks");
-        this._wifiConnections$ =
-            this._subscribeWhileAuthenticated("wifiConnections");
-    }
-    _autoAuthenticate(createBluetoothToken) {
-        const REAUTHENTICATE_INTERVAL = 3600000; // 1 hour
-        const reauthenticateInterval$ = timer(0, REAUTHENTICATE_INTERVAL).pipe(tap(() => {
-            this.transport.addLog(`Auto authentication in progress...`);
-        }));
-        return this.selectedDevice$.pipe(switchMap((selectedDevice) => !osHasBluetoothSupport(selectedDevice)
-            ? EMPTY
-            : this.connection().pipe(switchMap((connection) => connection === BLUETOOTH_CONNECTION.CONNECTED
-                ? reauthenticateInterval$
-                : EMPTY), switchMap(() => __awaiter(this, void 0, void 0, function* () { return yield this.isAuthenticated(); })), tap(([isAuthenticated]) => __awaiter(this, void 0, void 0, function* () {
-                if (!isAuthenticated) {
-                    const token = yield createBluetoothToken();
-                    yield this.authenticate(token);
-                }
-                else {
-                    this.transport.addLog(`Already authenticated`);
-                }
-            })))));
-    }
-    enableAutoConnect(autoConnect) {
-        this.transport.enableAutoConnect(autoConnect);
-    }
-    _hasBluetoothSupport() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const selectedDevice = yield firstValueFrom(this.selectedDevice$);
-            return osHasBluetoothSupport(selectedDevice);
-        });
-    }
-    authenticate(token) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const hasBluetoothSupport = yield this._hasBluetoothSupport();
-            if (!hasBluetoothSupport) {
-                const errorMessage = `authenticate method: The OS version does not support Bluetooth.`;
-                this.transport.addLog(errorMessage);
-                return Promise.reject(errorMessage);
-            }
-            yield this.transport.writeCharacteristic("auth", token);
-            const isAuthenticatedResponse = yield this.isAuthenticated();
-            const [isAuthenticated] = isAuthenticatedResponse;
-            this.transport.addLog(`Authentication ${isAuthenticated ? "succeeded" : "failed"}`);
-            this.isAuthenticated$.next(isAuthenticated);
-            return isAuthenticatedResponse;
-        });
-    }
-    isAuthenticated() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const [isAuthenticated, expiresIn] = yield this.transport.readCharacteristic("auth", true);
-            this.isAuthenticated$.next(isAuthenticated);
-            return [isAuthenticated, expiresIn];
-        });
-    }
-    // Method for React Native only
-    scan(options) {
-        if (this.transport instanceof ReactNativeTransport) {
-            return this.transport.scan(options);
-        }
-        if (this.transport instanceof WebBluetoothTransport) {
-            throw new Error(`scan method is compatibly with the React Native transport only`);
-        }
-        throw new Error(`unknown transport`);
-    }
-    // Argument for React Native only
-    connect(deviceNicknameORPeripheral) {
-        if (this.transport instanceof ReactNativeTransport) {
-            return this.transport.connect(deviceNicknameORPeripheral);
-        }
-        if (this.transport instanceof WebBluetoothTransport) {
-            return deviceNicknameORPeripheral
-                ? this.transport.connect(deviceNicknameORPeripheral)
-                : this.transport.connect();
-        }
-    }
-    disconnect() {
-        return this.transport.disconnect();
-    }
-    connection() {
-        return this.transport.connection();
-    }
-    logs() {
-        return this.transport.logs$.asObservable();
-    }
-    getDeviceId() {
-        return __awaiter(this, void 0, void 0, function* () {
-            // This is a public characteristic and does not require authentication
-            return this.transport.readCharacteristic("deviceId");
-        });
-    }
-    _withAuthentication(getter) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // First check if the OS supports Bluetooth before checking if the device is authenticated
-            const hasBluetoothSupport = yield this._hasBluetoothSupport();
-            if (!hasBluetoothSupport) {
-                const errorMessage = `The OS version does not support Bluetooth.`;
-                this.transport.addLog(errorMessage);
-                return Promise.reject(errorMessage);
-            }
-            const isAuthenticated = yield firstValueFrom(this.isAuthenticated$);
-            if (!isAuthenticated) {
-                const errorMessage = `Authentication required.`;
-                this.transport.addLog(errorMessage);
-                return Promise.reject(errorMessage);
-            }
-            return yield getter();
-        });
-    }
-    _subscribeWhileAuthenticated(characteristicName) {
-        return this.selectedDevice$.pipe(switchMap((selectedDevice) => !osHasBluetoothSupport(selectedDevice)
-            ? EMPTY
-            : this.isAuthenticated$.pipe(distinctUntilChanged(), switchMap((isAuthenticated) => isAuthenticated
-                ? this.transport.subscribeToCharacteristic({
-                    characteristicName
-                })
-                : EMPTY))), share());
-    }
-    focus() {
-        return this._focus$;
-    }
-    calm() {
-        return this._calm$;
-    }
-    accelerometer() {
-        return this._accelerometer$;
-    }
-    brainwaves(label) {
-        switch (label) {
-            default:
-            case "raw":
-                return defer(() => this.getInfo()).pipe(switchMap((deviceInfo) => this._brainwavesRaw$.pipe(csvBufferToEpoch(deviceInfo))));
-            case "rawUnfiltered":
-                return defer(() => this.getInfo()).pipe(switchMap((deviceInfo) => this._brainwavesRawUnfiltered$.pipe(csvBufferToEpoch(deviceInfo))));
-            case "psd":
-                return this._brainwavesPSD$;
-            case "powerByBand":
-                return this._brainwavesPowerByBand$;
-        }
-    }
-    signalQuality() {
-        return this._signalQuality$;
-    }
-    addMarker(label) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.dispatchAction({
-                action: "marker",
-                command: "add",
-                message: {
-                    timestamp: Date.now(),
-                    label
-                }
-            });
-        });
-    }
-    getInfo() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return yield this._withAuthentication(() => firstValueFrom(this.transport.subscribeToCharacteristic({
-                characteristicName: "deviceInfo"
-            })));
-        });
-    }
-    status() {
-        return this._status$;
-    }
-    dispatchAction(action) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return yield this._withAuthentication(() => this.transport.dispatchAction({
-                characteristicName: "actions",
-                action
-            }));
-        });
-    }
-    settings() {
-        return this._settings$;
-    }
-    haptics(effects) {
-        const metric = "haptics";
-        return this.dispatchAction({
-            action: metric,
-            command: "queue",
-            responseRequired: true,
-            responseTimeout: 4000,
-            //  @TODO: implement validation logic as per SDK
-            message: { effects }
-        });
-    }
-    get wifi() {
-        return {
-            nearbyNetworks: () => this._wifiNearbyNetworks$,
-            connections: () => this._wifiConnections$,
-            connect: (ssid, password) => {
-                if (!ssid) {
-                    return Promise.reject(`Missing ssid`);
-                }
-                return this.dispatchAction({
-                    action: "wifi",
-                    command: "connect",
-                    responseRequired: true,
-                    responseTimeout: 1000 * 60 * 2,
-                    message: {
-                        ssid,
-                        password: password !== null && password !== void 0 ? password : null
-                    }
-                });
-            },
-            forgetConnection: (ssid) => {
-                if (!ssid) {
-                    return Promise.reject(`Missing ssid`);
-                }
-                return this.dispatchAction({
-                    action: "wifi",
-                    command: "forget-connection",
-                    responseRequired: true,
-                    responseTimeout: 1000 * 15,
-                    message: {
-                        ssid
-                    }
-                });
-            },
-            reset: () => {
-                return this.dispatchAction({
-                    action: "wifi",
-                    command: "reset",
-                    responseRequired: true,
-                    responseTimeout: 1000 * 30,
-                    message: {
-                        // without this, the action will resolve as soon as the
-                        // action is received by the OS
-                        respondOnSuccess: true
-                    }
-                });
-            },
-            speedTest: () => {
-                return this.dispatchAction({
-                    action: "wifi",
-                    command: "speed-test",
-                    responseRequired: true,
-                    responseTimeout: 1000 * 60 * 1 // 1 minute
-                });
-            }
-        };
-    }
-}

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

@@ -1,33 +0,0 @@
-import { Observable, Subject } from "rxjs";
-import { BLUETOOTH_CONNECTION, TRANSPORT_TYPE } from "./types";
-import { Action } from "../../types/actions";
-import { DeviceInfo } from "../../types/deviceInfo";
-import { Peripheral } from "./react-native/types/BleManagerTypes";
-export declare type DeviceNicknameOrPeripheral = string | Peripheral;
-/**
- * @hidden
- */
-export interface BluetoothTransport {
-    type: TRANSPORT_TYPE;
-    connect(deviceNicknameORPeripheral?: DeviceNicknameOrPeripheral): Promise<void>;
-    _autoConnect(selectedDevice$: Observable<DeviceInfo>): Observable<void>;
-    disconnect(): Promise<void>;
-    connection(): Observable<BLUETOOTH_CONNECTION>;
-    requestDevice?(): any;
-    addLog: (log: string) => void;
-    logs$: Subject<string>;
-    enableAutoConnect?(value: boolean): void;
-    scan?(options?: {
-        seconds?: number;
-    }): Observable<Peripheral[]>;
-    subscribeToCharacteristic(args: {
-        characteristicName: string;
-        manageNotifications?: boolean;
-    }): Observable<any>;
-    readCharacteristic(characteristicName: string, parse?: boolean): Promise<any>;
-    writeCharacteristic(characteristicName: string, data: string): Promise<void>;
-    dispatchAction(args: {
-        characteristicName: string;
-        action: Action;
-    }): Promise<any>;
-}

package/dist/esm/api/bluetooth/BluetoothTransport.js

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

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

@@ -1,4 +0,0 @@
-export declare const ANDROID_MAX_MTU: number;
-export declare const REACT_NATIVE_MAX_BYTE_SIZE: number;
-export declare const DEFAULT_ACTION_RESPONSE_TIMEOUT: number;
-export declare const CHARACTERISTIC_UUIDS_TO_NAMES: any;

package/dist/esm/api/bluetooth/constants.js

@@ -1,6 +0,0 @@
-import { BLUETOOTH_CHARACTERISTICS } from "@neurosity/ipk";
-export const ANDROID_MAX_MTU = 512;
-export const REACT_NATIVE_MAX_BYTE_SIZE = 512; // the default is 20
-export const DEFAULT_ACTION_RESPONSE_TIMEOUT = 1000 * 60; // 1 minute
-// Reverse BLUETOOTH_CHARACTERISTICS key/values for easy lookup
-export const CHARACTERISTIC_UUIDS_TO_NAMES = Object.fromEntries(Object.entries(BLUETOOTH_CHARACTERISTICS).map((entries) => entries.reverse()));

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

@@ -1,4 +0,0 @@
-export * from "./BluetoothClient";
-export * from "./web/WebBluetoothTransport";
-export * from "./react-native/ReactNativeTransport";
-export * from "./utils/osHasBluetoothSupport";

package/dist/esm/api/bluetooth/index.js

@@ -1,4 +0,0 @@
-export * from "./BluetoothClient";
-export * from "./web/WebBluetoothTransport";
-export * from "./react-native/ReactNativeTransport";
-export * from "./utils/osHasBluetoothSupport";

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

@@ -1,70 +0,0 @@
-import { BehaviorSubject, ReplaySubject } from "rxjs";
-import { Observable } from "rxjs";
-import { BluetoothTransport } from "../BluetoothTransport";
-import { ActionOptions, SubscribeOptions } from "../types";
-import { TRANSPORT_TYPE, BLUETOOTH_CONNECTION } from "../types";
-import { BleManager } from "./types/BleManagerTypes";
-import { Peripheral } from "./types/BleManagerTypes";
-import { NativeEventEmitter } from "./types/ReactNativeTypes";
-import { PlatformOSType } from "./types/ReactNativeTypes";
-import { DeviceInfo } from "../../../types/deviceInfo";
-declare type Characteristic = {
-    characteristicUUID: string;
-    serviceUUID: string;
-    peripheralId: string;
-};
-declare type CharacteristicsByName = {
-    [name: string]: Characteristic;
-};
-declare type Options = {
-    BleManager: BleManager;
-    bleManagerEmitter: NativeEventEmitter;
-    platform: PlatformOSType;
-    autoConnect?: boolean;
-};
-declare type BleManagerEvents = {
-    stopScan$: Observable<void>;
-    discoverPeripheral$: Observable<Peripheral>;
-    connectPeripheral$: Observable<void>;
-    disconnectPeripheral$: Observable<void>;
-    didUpdateValueForCharacteristic$: Observable<any>;
-    didUpdateState$: Observable<any>;
-};
-export declare class ReactNativeTransport implements BluetoothTransport {
-    type: TRANSPORT_TYPE;
-    options: Options;
-    BleManager: BleManager;
-    bleManagerEmitter: NativeEventEmitter;
-    platform: PlatformOSType;
-    bleEvents: BleManagerEvents;
-    device: Peripheral;
-    characteristicsByName: CharacteristicsByName;
-    connection$: BehaviorSubject<BLUETOOTH_CONNECTION>;
-    pendingActions$: BehaviorSubject<any[]>;
-    logs$: ReplaySubject<string>;
-    onDisconnected$: Observable<void>;
-    connectionStream$: Observable<BLUETOOTH_CONNECTION>;
-    _isAutoConnectEnabled$: ReplaySubject<boolean>;
-    constructor(options: Options);
-    addLog(log: string): void;
-    isConnected(): boolean;
-    _autoConnect(selectedDevice$: Observable<DeviceInfo>): Observable<void>;
-    enableAutoConnect(autoConnect: boolean): void;
-    connection(): Observable<BLUETOOTH_CONNECTION>;
-    _fromEvent(eventName: string): Observable<any>;
-    scan(options?: {
-        seconds?: number;
-        once?: boolean;
-    }): Observable<Peripheral[]>;
-    connect(peripheral: Peripheral): Promise<void>;
-    disconnect(): Promise<void>;
-    getCharacteristicByName(characteristicName: string): Characteristic;
-    subscribeToCharacteristic({ characteristicName, manageNotifications }: SubscribeOptions): Observable<any>;
-    readCharacteristic(characteristicName: string, parse?: boolean): Promise<any>;
-    writeCharacteristic(characteristicName: string, data: string): Promise<void>;
-    _addPendingAction(actionId: number): void;
-    _removePendingAction(actionId: number): void;
-    _autoToggleActionNotifications(selectedDevice$: Observable<DeviceInfo>): Promise<void>;
-    dispatchAction({ characteristicName, action }: ActionOptions): Promise<any>;
-}
-export {};