@neurodevs/node-lsl 19.0.0 → 20.0.0

package/src/impl/workers/outlet/LslStreamOutlet.worker.ts

@@ -1,144 +0,0 @@
-import { parentPort } from 'node:worker_threads'
-
-import {
-    LiblslAdapter,
-    Liblsl,
-    OutletHandle,
-    handleLslError,
-    LslErrorCode,
-} from '@neurodevs/ndx-native'
-
-import LslStreamInfo, {
-    StreamInfo,
-    StreamInfoOptions,
-} from '../../LslStreamInfo.js'
-
-let lsl = LiblslAdapter.getInstance()
-
-export function setOutletLiblslAdapter(adapter: Liblsl) {
-    LiblslAdapter.setInstance(adapter)
-    lsl = LiblslAdapter.getInstance()
-}
-
-let handleLslErrorFn = handleLslError
-
-export function setOutletHandleLslError(fn: typeof handleLslError) {
-    handleLslErrorFn = fn
-}
-
-let info: StreamInfo
-let handle: OutletHandle
-let pushMethod: (opts: unknown) => LslErrorCode
-
-parentPort?.on('message', (msg: OutletMessage) => {
-    const { type } = msg
-
-    try {
-        switch (type) {
-            case 'createOutlet': {
-                createOutlet(msg)
-                break
-            }
-
-            case 'pushSample': {
-                pushSample(msg)
-                break
-            }
-
-            case 'destroyOutlet': {
-                destroyOutlet()
-                break
-            }
-        }
-    } catch (err) {
-        parentPort?.postMessage({
-            type: 'error',
-            error: err instanceof Error ? err.message : String(err),
-        })
-    }
-})
-
-export function createOutlet(msg: {
-    type: 'createOutlet'
-    payload: CreateOutletPayload
-}) {
-    const { payload } = msg
-
-    info = LslStreamInfo.Create(payload.infoOptions)
-
-    handle = lsl.createOutlet({
-        infoHandle: info.infoHandle,
-        chunkSize: payload.chunkSize,
-        maxBufferedMs: payload.maxBufferedMs,
-    })
-
-    pushMethod = (
-        lsl[payload.pushMethod] as (opts: unknown) => LslErrorCode
-    ).bind(lsl)
-
-    parentPort?.postMessage({ type: 'ready' })
-}
-
-export function pushSample(msg: {
-    type: 'pushSample'
-    payload: PushSamplePayload
-}) {
-    const { payload } = msg
-    const { sample, timestampSec = lsl.localClock() } = payload
-
-    if (!handle || !pushMethod) {
-        throw new Error('Outlet not initialized')
-    }
-
-    const errorCode = pushMethod({
-        outletHandle: handle,
-        sample,
-        timestampSec,
-    })
-
-    try {
-        handleLslErrorFn(errorCode)
-    } catch {
-        parentPort?.postMessage({
-            type: 'error',
-            error: `Error pushing sample: ${LslErrorCode[errorCode]}`,
-        })
-    }
-}
-
-export function destroyOutlet() {
-    if (handle) {
-        lsl.destroyOutlet({ outletHandle: handle })
-    }
-
-    if (info) {
-        lsl.destroyStreamInfo({ infoHandle: info.infoHandle })
-    }
-
-    parentPort?.close()
-}
-
-export type OutletMessage =
-    | {
-          type: 'createOutlet'
-          payload: CreateOutletPayload
-      }
-    | {
-          type: 'pushSample'
-          payload: PushSamplePayload
-      }
-    | {
-          type: 'destroyOutlet'
-      }
-
-export interface CreateOutletPayload {
-    infoOptions: StreamInfoOptions
-    chunkSize: number
-    maxBufferedMs: number
-    pushMethod: 'pushSampleFloatTimestamp' | 'pushSampleStringTimestamp'
-}
-
-export interface PushSamplePayload {
-    sample: unknown
-    timestampSec?: number
-}

package/src/scripts/discoverMuse.ts

@@ -1,50 +0,0 @@
-import koffi from 'koffi'
-
-import BleDeviceController from '../impl/controllers/BleDeviceController.js'
-
-const MUSE_CHARACTERISTIC_UUIDS: Record<string, string> = {
-    CONTROL: '273E0001-4C4D-454D-96BE-F03BAC821358',
-    TELEMETRY: '273E000B-4C4D-454D-96BE-F03BAC821358',
-    GYROSCOPE: '273E0009-4C4D-454D-96BE-F03BAC821358',
-    ACCELEROMETER: '273E000A-4C4D-454D-96BE-F03BAC821358',
-    PPG_AMBIENT: '273E000F-4C4D-454D-96BE-F03BAC821358',
-    PPG_INFRARED: '273E0010-4C4D-454D-96BE-F03BAC821358',
-    PPG_RED: '273E0011-4C4D-454D-96BE-F03BAC821358',
-    EEG_TP9: '273E0003-4C4D-454D-96BE-F03BAC821358',
-    EEG_AF7: '273E0004-4C4D-454D-96BE-F03BAC821358',
-    EEG_AF8: '273E0005-4C4D-454D-96BE-F03BAC821358',
-    EEG_TP10: '273E0006-4C4D-454D-96BE-F03BAC821358',
-    EEG_AUX: '273E0007-4C4D-454D-96BE-F03BAC821358',
-}
-
-const CONTROL_UUID = MUSE_CHARACTERISTIC_UUIDS['CONTROL']
-
-const charCallbacks = Object.entries(MUSE_CHARACTERISTIC_UUIDS).map(
-    ([name, uuid]) => {
-        return {
-            charUuid: uuid,
-            charName: name,
-            onData: (data: Buffer, length: number, timestampSec: number) => {
-                const bytes = koffi.decode(data, 'uint8', length) as number[]
-                console.info(`[${timestampSec}] length=${length}`, bytes)
-            },
-        }
-    }
-)
-
-const muse = await BleDeviceController.Create({
-    deviceNamePrefix: 'Muse',
-    charCallbacks,
-    rssiIntervalMs: 1000,
-})
-
-await muse.connect()
-
-for (const cmd of ['h', 'p50', 's', 'd']) {
-    await muse.writeCharacteristic(CONTROL_UUID, cmd)
-    await new Promise((resolve) => setTimeout(resolve, 100))
-}
-
-await new Promise((resolve) => setTimeout(resolve, 5 * 1000))
-
-await muse.disconnect()

package/src/scripts/testDestroyOutlet.ts

@@ -1,5 +0,0 @@
-import LslEventMarkerEmitter from '../impl/LslEventMarkerEmitter.js'
-
-const emitter = await LslEventMarkerEmitter.Create()
-
-emitter.destroy()

package/src/testDoubles/StreamInlet/SpyStreamInlet.ts

@@ -1,10 +0,0 @@
-import LslStreamInlet, {
-    OnDataCallback,
-    StreamInletOptions,
-} from '../../impl/LslStreamInlet.js'
-
-export class SpyStreamInlet extends LslStreamInlet {
-    public constructor(options: StreamInletOptions, onData: OnDataCallback) {
-        super(options, onData)
-    }
-}

package/src/testDoubles/WebSocketBridge/SpyLslWebSocketBridge.ts

@@ -1,9 +0,0 @@
-import LslWebSocketBridge, {
-    WebSocketBridgeConstructorOptions,
-} from '../../impl/LslWebSocketBridge.js'
-
-export default class SpyLslWebSocketBridge extends LslWebSocketBridge {
-    public constructor(options: WebSocketBridgeConstructorOptions) {
-        super(options)
-    }
-}

package/src/testDoubles/WorkerThreads/FakeWorker.ts

@@ -1,99 +0,0 @@
-import { WorkerOptions } from 'node:worker_threads'
-
-import { OnDataCallback } from '../../impl/LslStreamInlet.js'
-import StreamInletWorker from '../../impl/workers/inlet/StreamInletWorker.js'
-import {
-    createOutlet,
-    destroyOutlet,
-    pushSample,
-} from '../../impl/workers/outlet/LslStreamOutlet.worker.js'
-
-export default class FakeWorker {
-    public static callsToConstructor: {
-        filename: string | URL
-        options?: WorkerOptions
-    }[] = []
-
-    public static callsToPostMessage: WorkerMessage[] = []
-
-    public static callsToOn: {
-        type: string
-        listener: (...args: unknown[]) => void
-    }[] = []
-
-    public static inletWorker = new StreamInletWorker()
-    public static fakeOnData: OnDataCallback
-
-    public createInletPromise?: Promise<void>
-
-    public constructor(filename: string | URL, options?: WorkerOptions) {
-        FakeWorker.callsToConstructor.push({ filename, options })
-    }
-
-    public postMessage(msg: WorkerMessage) {
-        FakeWorker.callsToPostMessage.push(msg)
-
-        const { type } = msg
-
-        switch (type) {
-            case 'createOutlet': {
-                createOutlet(msg as any)
-                break
-            }
-            case 'pushSample': {
-                pushSample(msg as any)
-                break
-            }
-            case 'destroyOutlet': {
-                destroyOutlet()
-                break
-            }
-            case 'createInlet': {
-                const { payload } = msg
-                this.createInletPromise = this.inletWorker.createInlet(
-                    payload as any
-                )
-                break
-            }
-            case 'startPulling': {
-                this.inletWorker.startPulling(this.fakeOnData)
-                break
-            }
-            case 'flushInlet': {
-                this.inletWorker.flushInlet()
-                break
-            }
-            case 'stopPulling': {
-                this.inletWorker.stopPulling()
-                break
-            }
-            case 'destroyInlet': {
-                this.inletWorker.destroyInlet()
-                break
-            }
-        }
-    }
-
-    public on(type: string, listener: (...args: unknown[]) => void) {
-        FakeWorker.callsToOn.push({ type, listener })
-    }
-
-    private get inletWorker() {
-        return FakeWorker.inletWorker
-    }
-
-    private get fakeOnData() {
-        return FakeWorker.fakeOnData
-    }
-
-    public static resetTestDoubles() {
-        this.callsToConstructor = []
-        this.callsToPostMessage = []
-        this.callsToOn = []
-    }
-}
-
-export interface WorkerMessage {
-    type: string
-    payload?: Record<string, unknown>[]
-}