@neurodevs/node-lsl 19.0.0 → 22.0.0

package/src/impl/LslStreamOutlet.ts

@@ -1,6 +1,11 @@
-import { Worker } from 'node:worker_threads'
-
-import { ChannelFormat, Liblsl, LslSample } from '@neurodevs/ndx-native'
+import {
+    ChannelFormat,
+    LiblslAdapter,
+    LslErrorCode,
+    LslSample,
+    OutletHandle,
+    handleLslError,
+} from '@neurodevs/ndx-native'
 
 import {
     assertValidChannelCount,
@@ -9,11 +14,13 @@ import {
     assertValidMaxBufferedMs,
     assertValidSampleRateHz,
 } from '../assertions.js'
+import LslStreamInfo, { LslInfo } from './LslStreamInfo.js'
 
-export default class LslStreamOutlet implements StreamOutlet {
-    public static Class?: StreamOutletConstructor
-    public static Worker = Worker
+export default class LslStreamOutlet implements LslOutlet {
+    public static Class?: LslOutletConstructor
     public static setTimeout = setTimeout
+    public static lsl = LiblslAdapter.getInstance()
+    public static handleLslError = handleLslError
 
     public readonly name: string
     public readonly type: string
@@ -27,9 +34,11 @@ export default class LslStreamOutlet implements StreamOutlet {
     public readonly manufacturer: string = 'N/A'
     public readonly units: string = 'N/A'
 
-    private worker!: Worker
+    private info!: LslInfo
+    private handle!: OutletHandle
+    private pushSampleToLsl!: (opts: unknown) => LslErrorCode
 
-    protected constructor(options: StreamOutletOptions) {
+    protected constructor(options: LslOutletOptions) {
         const {
             name,
             type,
@@ -56,11 +65,10 @@ export default class LslStreamOutlet implements StreamOutlet {
         this.units = units ?? this.units
 
         this.validateOptions()
-        this.createWorkerThread()
         this.createStreamOutlet()
     }
 
-    public static async Create(options: StreamOutletOptions) {
+    public static async Create(options: LslOutletOptions) {
         const { waitAfterConstructionMs = 10 } = options ?? {}
 
         const instance = new (this.Class ?? this)(options)
@@ -94,62 +102,57 @@ export default class LslStreamOutlet implements StreamOutlet {
         )
     }
 
-    private createWorkerThread() {
-        this.worker = new this.Worker(
-            new URL(
-                './workers/outlet/LslStreamOutlet.worker.js',
-                import.meta.url
-            )
-        )
-    }
-
     private createStreamOutlet() {
-        this.worker.postMessage({
-            type: 'createOutlet',
-            payload: {
-                infoOptions: {
-                    name: this.name,
-                    type: this.type,
-                    sourceId: this.sourceId,
-                    channelNames: this.channelNames,
-                    channelFormat: this.channelFormat,
-                    sampleRateHz: this.sampleRateHz,
-                    units: this.units,
-                },
-                chunkSize: this.chunkSize,
-                maxBufferedMs: this.maxBufferedMs,
-                pushMethod: this.pushMethod,
-            },
+        this.info = LslStreamInfo.Create({
+            name: this.name,
+            type: this.type,
+            sourceId: this.sourceId,
+            channelNames: this.channelNames,
+            channelFormat: this.channelFormat,
+            sampleRateHz: this.sampleRateHz,
+            units: this.units,
         })
+
+        this.handle = this.lsl.createOutlet({
+            infoHandle: this.info.infoHandle,
+            chunkSize: this.chunkSize,
+            maxBufferedMs: this.maxBufferedMs,
+        })
+
+        this.pushSampleToLsl = (
+            this.lsl[this.pushMethod] as (opts: unknown) => LslErrorCode
+        ).bind(this.lsl)
+    }
+
+    private get lsl() {
+        return LslStreamOutlet.lsl
     }
 
     private get pushMethod() {
         return this.methodMap[this.channelFormat]
     }
 
-    private readonly methodMap: Record<string, keyof Liblsl> = {
+    private readonly methodMap: Record<
+        string,
+        'pushSampleFloatTimestamp' | 'pushSampleStringTimestamp'
+    > = {
         float32: 'pushSampleFloatTimestamp',
         string: 'pushSampleStringTimestamp',
     }
 
-    public pushSample(sample: LslSample, timestampSec?: number) {
-        this.worker.postMessage({
-            type: 'pushSample',
-            payload: {
-                sample,
-                timestampSec,
-            },
+    public pushSample(sample: LslSample, timestampSec = this.lsl.localClock()) {
+        const errorCode = this.pushSampleToLsl({
+            outletHandle: this.handle,
+            sample,
+            timestampSec,
         })
-    }
 
-    public destroy() {
-        this.worker.postMessage({
-            type: 'destroyOutlet',
-        })
+        LslStreamOutlet.handleLslError(errorCode)
     }
 
-    private get Worker() {
-        return LslStreamOutlet.Worker
+    public destroy() {
+        this.lsl.destroyOutlet({ outletHandle: this.handle })
+        this.lsl.destroyStreamInfo({ infoHandle: this.info.infoHandle })
     }
 
     private static async waitForSetup(waitAfterConstructionMs: number) {
@@ -159,7 +162,7 @@ export default class LslStreamOutlet implements StreamOutlet {
     }
 }
 
-export interface StreamOutlet {
+export interface LslOutlet {
     pushSample(sample: LslSample, timestampSec?: number): void
     destroy(): void
     readonly name: string
@@ -175,15 +178,9 @@ export interface StreamOutlet {
     readonly manufacturer: string
 }
 
-export type StreamOutletConstructor = new (
-    options: StreamOutletOptions
-) => StreamOutlet
+export type LslOutletConstructor = new (options: LslOutletOptions) => LslOutlet
 
-export interface StreamOutletOptions extends StreamOutletConstructorOptions {
-    waitAfterConstructionMs?: number
-}
-
-export interface StreamOutletConstructorOptions {
+export interface LslOutletOptions {
     name: string
     type: string
     sourceId: string
@@ -194,4 +191,10 @@ export interface StreamOutletConstructorOptions {
     maxBufferedMs?: number
     manufacturer?: string
     units?: string
+    waitAfterConstructionMs?: number
 }
+
+export type LslOutletConstructorOptions = Omit<
+    LslOutletOptions,
+    'waitAfterConstructionMs'
+>

package/src/impl/LslWebSocketBridge.ts

@@ -1,22 +1,19 @@
 import WebSocket, { WebSocketServer } from 'ws'
 
-import LslStreamInlet, {
-    StreamInlet,
-    StreamInletOptions,
-} from './LslStreamInlet.js'
+import LslStreamInlet, { LslInlet, LslInletOptions } from './LslStreamInlet.js'
 
-export default class LslWebSocketBridge implements WebSocketBridge {
-    public static Class?: WebSocketBridgeConstructor
+export default class LslWebSocketBridge implements LslWsBridge {
+    public static Class?: LslWsBridgeConstructor
     public static WS = WebSocket
     public static WSS = WebSocketServer
 
-    private inlet: StreamInlet
+    private inlet: LslInlet
     private localServer?: WebSocketServer
     private remoteSockets?: WebSocket[]
 
     private isDestroyed = false
 
-    protected constructor(options: WebSocketBridgeConstructorOptions) {
+    protected constructor(options: LslWsBridgeConstructorOptions) {
         const { inlet, localServer, remoteSockets } = options
 
         this.inlet = inlet
@@ -26,9 +23,9 @@ export default class LslWebSocketBridge implements WebSocketBridge {
         this.throwIfNoLocalServerOrRemoteSockets()
     }
 
-    public static async Create(options: WebSocketBridgeOptions) {
+    public static async Create(options: LslWsBridgeOptions) {
         const { listenPort, connectUrls, ...rest } = options
-        const inletOptions: StreamInletOptions = rest
+        const inletOptions: LslInletOptions = rest
 
         const localServer = this.WebSocketServer(listenPort)
         const remoteSockets = this.createSocketsFrom(connectUrls)
@@ -155,7 +152,7 @@ export default class LslWebSocketBridge implements WebSocketBridge {
     }
 
     private static async LslStreamInlet(
-        options: StreamInletOptions,
+        options: LslInletOptions,
         localServer?: WebSocketServer,
         remoteSockets?: WebSocket[]
     ) {
@@ -164,25 +161,25 @@ export default class LslWebSocketBridge implements WebSocketBridge {
     }
 }
 
-export interface WebSocketBridge {
+export interface LslWsBridge {
     activate(): Promise<void>
     deactivate(): void
     destroy(): void
 }
 
-export type WebSocketBridgeConstructor = new (
-    options: WebSocketBridgeConstructorOptions
-) => WebSocketBridge
+export type LslWsBridgeConstructor = new (
+    options: LslWsBridgeConstructorOptions
+) => LslWsBridge
 
-export interface WebSocketBridgeOptions {
+export interface LslWsBridgeOptions {
     sourceId: string
     chunkSize: number
     listenPort?: number
     connectUrls?: string | string[]
 }
 
-export interface WebSocketBridgeConstructorOptions extends WebSocketBridgeOptions {
-    inlet: StreamInlet
+export interface LslWsBridgeConstructorOptions extends LslWsBridgeOptions {
+    inlet: LslInlet
     localServer?: WebSocketServer
     remoteSockets?: WebSocket[]
 }

package/src/impl/controllers/{BleDeviceController.ts → BleGattController.ts}

@@ -1,7 +1,7 @@
 import { LibndxAdapter, Libndx, NativePeripheral } from '@neurodevs/ndx-native'
 
-export default class BleDeviceController implements BleController {
-    public static Class?: BleControllerConstructor
+export default class BleGattController implements BleGatt {
+    public static Class?: BleGattConstructor
     public static setTimeout = setTimeout
     public static waitAfterMs = 1000
 
@@ -28,7 +28,7 @@ export default class BleDeviceController implements BleController {
     private deviceName?: string
     private onConnected?: (peripheral: NativePeripheral) => void
 
-    protected constructor(options: BleControllerOptions) {
+    protected constructor(options: BleGattOptions) {
         const {
             deviceUuid,
             deviceNamePrefix,
@@ -44,7 +44,7 @@ export default class BleDeviceController implements BleController {
         this.rssiIntervalMs = rssiIntervalMs
     }
 
-    public static async Create(options: BleControllerOptions) {
+    public static Create(options: BleGattOptions) {
         return new (this.Class ?? this)(options)
     }
 
@@ -53,13 +53,13 @@ export default class BleDeviceController implements BleController {
             await this.discoverUuid()
         }
 
-        this.createBleBackend()
-        this.startBleBackend()
+        this.createBleGattBackend()
+        this.startBleGattBackend()
 
         await this.waitForOnConnected()
         await this.waitToDiscoverServices()
 
-        this.setBleRssiInterval()
+        this.startBleGattRssiPolling()
     }
 
     private async discoverUuid() {
@@ -81,15 +81,15 @@ export default class BleDeviceController implements BleController {
                 if (this.deviceUuid) {
                     resolve()
                 } else {
-                    BleDeviceController.setTimeout(checkDiscovered, 100)
+                    BleGattController.setTimeout(checkDiscovered, 100)
                 }
             }
             checkDiscovered()
         })
     }
 
-    private createBleBackend() {
-        const { status, error } = this.ndx.createBleBackend({
+    private createBleGattBackend() {
+        const { status, error } = this.ndx.createBleGattBackend({
             deviceUuid: this.uuid,
         })
 
@@ -102,9 +102,9 @@ export default class BleDeviceController implements BleController {
         }
     }
 
-    private setBleRssiInterval() {
+    private startBleGattRssiPolling() {
         if (this.rssiIntervalMs) {
-            this.ndx.setBleRssiInterval({
+            this.ndx.startBleGattRssiPolling({
                 deviceUuid: this.uuid,
                 intervalMs: this.rssiIntervalMs,
                 onRssi: (rssi: number) => {
@@ -114,8 +114,8 @@ export default class BleDeviceController implements BleController {
         }
     }
 
-    private startBleBackend() {
-        const { status, error } = this.ndx.startBleBackend({
+    private startBleGattBackend() {
+        const { status, error } = this.ndx.startBleGattBackend({
             deviceUuid: this.uuid,
             onConnected: (peripheral: NativePeripheral) => {
                 const { name } = peripheral
@@ -136,7 +136,7 @@ export default class BleDeviceController implements BleController {
                 if (this.connected) {
                     resolve()
                 } else {
-                    BleDeviceController.setTimeout(checkConnected, 100)
+                    BleGattController.setTimeout(checkConnected, 100)
                 }
             }
             checkConnected()
@@ -145,10 +145,7 @@ export default class BleDeviceController implements BleController {
 
     private async waitToDiscoverServices() {
         await new Promise<void>((resolve) =>
-            BleDeviceController.setTimeout(
-                resolve,
-                BleDeviceController.waitAfterMs
-            )
+            BleGattController.setTimeout(resolve, BleGattController.waitAfterMs)
         )
     }
 
@@ -156,7 +153,7 @@ export default class BleDeviceController implements BleController {
         charUuid: CharacteristicUuid,
         value: string
     ) {
-        const { status, error } = this.ndx.writeBleCharacteristic({
+        const { status, error } = this.ndx.writeBleGattChar({
             deviceUuid: this.uuid,
             charUuid,
             value,
@@ -168,7 +165,7 @@ export default class BleDeviceController implements BleController {
     public async subscribeCharacteristics(
         charCallbacks: CharacteristicCallbacks
     ) {
-        const { status, error } = this.ndx.addBleCharCallbacks({
+        const { status, error } = this.ndx.registerBleGattCharCallbacks({
             deviceUuid: this.uuid,
             charCallbacks,
         })
@@ -179,7 +176,7 @@ export default class BleDeviceController implements BleController {
     }
 
     public async disconnect() {
-        const { status, error } = this.ndx.stopBleBackend({
+        const { status, error } = this.ndx.stopBleGattBackend({
             deviceUuid: this.uuid,
         })
 
@@ -196,11 +193,11 @@ export default class BleDeviceController implements BleController {
     }
 
     private get ndx() {
-        return BleDeviceController.ndx
+        return BleGattController.ndx
     }
 }
 
-export interface BleController {
+export interface BleGatt {
     uuid: string
     name: string
 
@@ -218,7 +215,7 @@ export interface BleController {
     disconnect(): Promise<void>
 }
 
-export type BleControllerOptions = {
+export type BleGattOptions = {
     charCallbacks: CharacteristicCallbacks
     onConnected?: (peripheral: NativePeripheral) => void
     rssiIntervalMs?: number
@@ -227,9 +224,7 @@ export type BleControllerOptions = {
     | { deviceUuid?: string; deviceNamePrefix: string }
 )
 
-export type BleControllerConstructor = new (
-    options: BleControllerOptions
-) => BleController
+export type BleGattConstructor = new (options: BleGattOptions) => BleGatt
 
 export type CharacteristicCallbacks = {
     charUuid: string

package/src/impl/controllers/BleObserverController.ts

@@ -0,0 +1,62 @@
+import { LibndxAdapter } from '@neurodevs/ndx-native'
+
+export default class BleObserverController implements BleObserver {
+    public static Class?: BleObserverConstructor
+
+    private readonly deviceUuid: string
+    private readonly ndx = LibndxAdapter.getInstance()
+
+    protected constructor(options: BleObserverOptions) {
+        const { deviceUuid } = options
+
+        this.deviceUuid = deviceUuid ?? ''
+    }
+
+    public static Create(options: BleObserverOptions) {
+        return new (this.Class ?? this)(options)
+    }
+
+    public async startObserving() {
+        this.createBleObserverBackend()
+        this.startBleObserverBackend()
+    }
+
+    private createBleObserverBackend() {
+        this.ndx.createBleObserverBackend({
+            deviceUuid: this.deviceUuid,
+        })
+    }
+
+    private startBleObserverBackend() {
+        this.ndx.startBleObserverBackend({
+            deviceUuid: this.deviceUuid,
+            onAdvertisement: (
+                _data: Buffer,
+                _length: number,
+                _timestampSec: number
+            ) => {},
+        })
+    }
+
+    public async stopObserving() {
+        this.stopBleObserverBackend()
+    }
+
+    private stopBleObserverBackend() {
+        this.ndx.stopBleObserverBackend({
+            deviceUuid: this.deviceUuid,
+        })
+    }
+}
+export interface BleObserver {
+    startObserving(): Promise<void>
+    stopObserving(): Promise<void>
+}
+
+export type BleObserverConstructor = new (
+    options: BleObserverOptions
+) => BleObserver
+
+export type BleObserverOptions = {
+    deviceUuid: string
+}

package/src/impl/controllers/UsbDeviceController.ts

@@ -1,65 +1,63 @@
 import { LibndxAdapter } from '@neurodevs/ndx-native'
 
-export default class UsbDeviceController implements UsbController {
-    public static Class?: UsbControllerConstructor
+export default class UsbDeviceController implements UsbDevice {
+    public static Class?: UsbDeviceConstructor
 
     private onData: (data: Buffer, length: number, timestampSec: number) => void
     private serialNumber: string
 
     private ndx = LibndxAdapter.getInstance()
 
-    protected constructor(options: UsbControllerOptions) {
+    protected constructor(options: UsbDeviceOptions) {
         const { onData, serialNumber } = options ?? {}
 
         this.onData = onData
         this.serialNumber = serialNumber ?? ''
     }
 
-    public static Create(options: UsbControllerOptions) {
+    public static Create(options: UsbDeviceOptions) {
         return new (this.Class ?? this)(options)
     }
 
     public async connect() {
-        this.ndx.createUsbBackend(this.usbControllerOptions)
-        this.ndx.startUsbBackend(this.startUsbControllerOptions)
+        this.ndx.createUsbBackend(this.usbDeviceOptions)
+        this.ndx.startUsbBackend(this.startUsbDeviceOptions)
     }
 
-    private get usbControllerOptions() {
+    private get usbDeviceOptions() {
         return {
             serialNumber: this.serialNumber,
         }
     }
 
-    private get startUsbControllerOptions() {
+    private get startUsbDeviceOptions() {
         return {
-            ...this.usbControllerOptions,
+            ...this.usbDeviceOptions,
             onData: this.onData,
         }
     }
 
     public async writeUsb(value: string) {
         this.ndx.writeUsbBackend({
-            ...this.usbControllerOptions,
+            ...this.usbDeviceOptions,
             value,
         })
     }
 
     public async disconnect() {
-        this.ndx.stopUsbBackend(this.usbControllerOptions)
+        this.ndx.stopUsbBackend(this.usbDeviceOptions)
     }
 }
 
-export interface UsbController {
+export interface UsbDevice {
     connect(): Promise<void>
     writeUsb(value: string): Promise<void>
     disconnect(): Promise<void>
 }
 
-export interface UsbControllerOptions {
+export interface UsbDeviceOptions {
     onData: (data: Buffer, length: number, timestampSec: number) => void
     serialNumber?: string
 }
 
-export type UsbControllerConstructor = new (
-    options?: UsbControllerOptions
-) => UsbController
+export type UsbDeviceConstructor = new (options?: UsbDeviceOptions) => UsbDevice