@neurodevs/node-lsl 19.0.0 → 20.0.0

package/src/__tests__/impl/LslStreamInlet.test.ts

@@ -1,5 +1,3 @@
-import { Worker } from 'node:worker_threads'
-
 import { FakeLiblsl } from '@neurodevs/ndx-native'
 import { test, assert } from '@neurodevs/node-tdd'
 import {
@@ -11,16 +9,12 @@ import {
     unwrapPointer,
 } from 'ffi-rs'
 
-import LslStreamInlet, {
-    StreamInletOptions,
-} from '../../impl/LslStreamInlet.js'
-import StreamInletWorker from '../../impl/workers/inlet/StreamInletWorker.js'
-import { SpyStreamInlet } from '../../testDoubles/StreamInlet/SpyStreamInlet.js'
-import FakeWorker from '../../testDoubles/WorkerThreads/FakeWorker.js'
+import LslStreamInlet, { LslInletOptions } from '../../impl/LslStreamInlet.js'
+import SpyLslInlet from '../../testDoubles/LslInlet/SpyLslInlet.js'
 import AbstractPackageTest from '../AbstractPackageTest.js'
 
 export default class LslStreamInletTest extends AbstractPackageTest {
-    private static instance: SpyStreamInlet
+    private static instance: SpyLslInlet
 
     private static callsToOnData: {
         samples: number[]
@@ -60,20 +54,14 @@ export default class LslStreamInletTest extends AbstractPackageTest {
         await super.beforeEach()
 
         this.setFakeLiblsl()
-        this.setFakeStreamInfo()
-        this.setSpyStreamInlet()
+        this.setFakeLslInfo()
+        this.setSpyLslInlet()
 
         this.callsToOnData = []
 
         LslStreamInlet.waitAfterOpenStreamMs = 0
-
-        LslStreamInlet.Worker = FakeWorker as unknown as typeof Worker
-        FakeWorker.resetTestDoubles()
-
-        StreamInletWorker.lsl = this.fakeLiblsl
-        StreamInletWorker.freePointer = () => {}
-
-        FakeWorker.fakeOnData = this.onData
+        LslStreamInlet.lsl = this.fakeLiblsl
+        LslStreamInlet.freePointer = () => {}
 
         this.instance = await this.LslStreamInlet()
     }
@@ -133,7 +121,7 @@ export default class LslStreamInletTest extends AbstractPackageTest {
 
         let calls: FreePointerParams[] = []
 
-        StreamInletWorker.freePointer = (params: FreePointerParams) => {
+        LslStreamInlet.freePointer = (params: FreePointerParams) => {
             calls.push(params)
         }
 
@@ -201,9 +189,7 @@ export default class LslStreamInletTest extends AbstractPackageTest {
         await this.startPulling()
 
         assert.isEqual(
-            FakeWorker.callsToPostMessage.filter(
-                (msg) => msg.type === 'startPulling'
-            ).length,
+            this.fakeLiblsl.createInletHitCount,
             1,
             'startPulling did not return early!'
         )
@@ -243,7 +229,7 @@ export default class LslStreamInletTest extends AbstractPackageTest {
         assert.isEqualDeep(
             this.fakeLiblsl.lastOpenStreamOptions,
             {
-                inletHandle: this.inletHandle,
+                inletHandle: instance['inletHandle'],
                 timeoutMs: openStreamTimeoutMs,
                 errorCodePtr: this.errorCodePtr,
             },
@@ -253,27 +239,6 @@ export default class LslStreamInletTest extends AbstractPackageTest {
         instance.stopPulling()
     }
 
-    @test()
-    protected static async waitsAfterOpeningStreamWithPassedOption() {
-        const waitAfterOpenStreamMs = 10
-
-        const instance = await this.LslStreamInlet({
-            waitAfterOpenStreamMs,
-        })
-
-        let t0 = Date.now()
-        await this.startPulling(instance)
-        let elapsed = Date.now() - t0
-
-        instance.stopPulling()
-
-        assert.isAbove(
-            elapsed,
-            waitAfterOpenStreamMs * 0.8,
-            'Did not wait after opening stream!'
-        )
-    }
-
     @test()
     protected static async stopPullingClosesInletStream() {
         await this.startPulling()
@@ -386,15 +351,10 @@ export default class LslStreamInletTest extends AbstractPackageTest {
     protected static async pushSampleHandlesErrorCode() {
         let passedErrorCode: number | undefined
 
-        StreamInletWorker.handleLslError = (errorCode: number) => {
+        LslStreamInlet.handleLslError = (errorCode: number) => {
             passedErrorCode = errorCode
         }
 
-        const fakeErrorCode = [-4, -3, -2, -1, 0][Math.floor(Math.random() * 5)]
-        const worker = this.getFakeWorker()
-
-        worker['inletWorker']['pullErrorBuffer'].writeInt32LE(fakeErrorCode)
-
         await this.startThenStop()
 
         assert.isEqualDeep(
@@ -414,10 +374,9 @@ export default class LslStreamInletTest extends AbstractPackageTest {
 
         let pulls = 0
 
-        const inletWorker = this.getFakeWorker(instance)['inletWorker']
-        const original = inletWorker['pullDataOnce'].bind(inletWorker)
+        const original = instance['pullDataOnce'].bind(instance)
 
-        inletWorker['pullDataOnce'] = async () => {
+        instance['pullDataOnce'] = async () => {
             pulls++
             await original()
         }
@@ -508,32 +467,23 @@ export default class LslStreamInletTest extends AbstractPackageTest {
     }
 
     private static async runInletWithOptions(
-        options?: Partial<StreamInletOptions>
+        options?: Partial<LslInletOptions>
     ) {
         const inlet = await this.LslStreamInlet(options)
+        this.instance = inlet
         await this.startThenStop(inlet)
         return inlet
     }
 
-    private static async startThenStop(inlet?: SpyStreamInlet) {
+    private static async startThenStop(inlet?: SpyLslInlet) {
         const instance = inlet || this.instance
         await this.startPulling(instance)
         await this.wait(10)
         instance.stopPulling()
     }
 
-    private static async startPulling(instance?: SpyStreamInlet) {
-        const inst = instance || this.instance
-        const startPullingPromise = inst.startPulling()
-
-        while (!this.getFakeWorker(inst).createInletPromise) {
-            await this.wait(1)
-        }
-
-        await this.getFakeWorker(inst).createInletPromise
-        inst['workerReady'] = true
-
-        await startPullingPromise
+    private static async startPulling(instance?: SpyLslInlet) {
+        await (instance || this.instance).startPulling()
     }
 
     private static stopPulling() {
@@ -549,26 +499,19 @@ export default class LslStreamInletTest extends AbstractPackageTest {
     }
 
     private static get inletHandle() {
-        return this.getFakeWorker()['inletWorker']['inletHandle']
-    }
-
-    private static getFakeWorker(instance?: SpyStreamInlet) {
-        const inst = instance || this.instance
-        return inst['worker'] as unknown as FakeWorker
+        return this.instance['inletHandle']
     }
 
     private static onData = (samples: number[], timestamps: number[]) => {
         this.callsToOnData.push({ samples, timestamps })
     }
 
-    protected static async LslStreamInlet(
-        options?: Partial<StreamInletOptions>
-    ) {
+    protected static async LslStreamInlet(options?: Partial<LslInletOptions>) {
         return (await AbstractPackageTest.LslStreamInlet(
             {
                 ...options,
             },
             this.onData
-        )) as SpyStreamInlet
+        )) as SpyLslInlet
     }
 }

package/src/__tests__/impl/LslStreamOutlet.test.ts

@@ -1,27 +1,25 @@
-import { Worker } from 'node:worker_threads'
-import { ChannelFormat, LslSample, FakeLiblsl } from '@neurodevs/ndx-native'
+import {
+    ChannelFormat,
+    LslSample,
+    FakeLiblsl,
+    CHANNEL_FORMATS,
+} from '@neurodevs/ndx-native'
 import { test, assert } from '@neurodevs/node-tdd'
 
-import { CHANNEL_FORMATS } from '../../consts.js'
 import LslStreamOutlet, {
-    StreamOutletOptions,
+    LslOutletOptions,
 } from '../../impl/LslStreamOutlet.js'
-import {
-    setOutletHandleLslError,
-    setOutletLiblslAdapter,
-} from '../../impl/workers/outlet/LslStreamOutlet.worker.js'
 import {
     TEST_SUPPORTED_CHANNEL_FORMATS,
     TEST_UNSUPPORTED_CHANNEL_FORMATS,
     TestChannelFormat,
 } from '../../testDoubles/consts.js'
 import generateRandomOutletOptions from '../../testDoubles/generateRandomOutletOptions.js'
-import FakeStreamInfo from '../../testDoubles/StreamInfo/FakeStreamInfo.js'
-import FakeWorker from '../../testDoubles/WorkerThreads/FakeWorker.js'
+import FakeLslInfo from '../../testDoubles/LslInfo/FakeLslInfo.js'
 import AbstractPackageTest from '../AbstractPackageTest.js'
 
 export default class LslStreamOutletTest extends AbstractPackageTest {
-    private static randomOutletOptions: StreamOutletOptions
+    private static randomOutletOptions: LslOutletOptions
 
     protected static async beforeEach() {
         await super.beforeEach()
@@ -31,12 +29,9 @@ export default class LslStreamOutletTest extends AbstractPackageTest {
         this.randomOutletOptions = generateRandomOutletOptions()
 
         this.setFakeLiblsl()
-        this.setFakeStreamInfo()
-
-        LslStreamOutlet.Worker = FakeWorker as unknown as typeof Worker
-        FakeWorker.resetTestDoubles()
+        this.setFakeLslInfo()
 
-        setOutletLiblslAdapter(this.fakeLiblsl)
+        LslStreamOutlet.lsl = this.fakeLiblsl
     }
 
     @test()
@@ -175,7 +170,7 @@ export default class LslStreamOutletTest extends AbstractPackageTest {
     protected static async constructionCreatesStreamInfo() {
         await this.LslStreamOutlet()
 
-        assert.isEqualDeep(FakeStreamInfo.callsToConstructor[0], {
+        assert.isEqualDeep(FakeLslInfo.callsToConstructor[0], {
             channelNames: this.randomOutletOptions.channelNames,
             channelFormat: this.randomOutletOptions.channelFormat,
             sampleRateHz: this.randomOutletOptions.sampleRateHz,
@@ -241,9 +236,9 @@ export default class LslStreamOutletTest extends AbstractPackageTest {
     protected static async pushSampleHandlesErrorCode() {
         let passedErrorCode: number | undefined
 
-        setOutletHandleLslError((errorCode: number) => {
+        LslStreamOutlet.handleLslError = (errorCode: number) => {
             passedErrorCode = errorCode
-        })
+        }
 
         FakeLiblsl.fakeErrorCode = [-4, -3, -2, -1, 0][
             Math.floor(Math.random() * 5)
@@ -346,7 +341,7 @@ export default class LslStreamOutletTest extends AbstractPackageTest {
     }
 
     private static async createAndAssertThrows(
-        option: keyof StreamOutletOptions,
+        option: keyof LslOutletOptions,
         value: number | string[] | ChannelFormat,
         expectedMessage: string
     ) {
@@ -368,9 +363,7 @@ export default class LslStreamOutletTest extends AbstractPackageTest {
         return await this.LslStreamOutlet({ channelFormat: 'float32' })
     }
 
-    private static async LslStreamOutlet(
-        options?: Partial<StreamOutletOptions>
-    ) {
+    private static async LslStreamOutlet(options?: Partial<LslOutletOptions>) {
         return await LslStreamOutlet.Create({
             ...this.randomOutletOptions,
             ...options,
@@ -379,7 +372,7 @@ export default class LslStreamOutletTest extends AbstractPackageTest {
 }
 
 class CheckingOutlet extends LslStreamOutlet {
-    public constructor(options: StreamOutletOptions) {
+    public constructor(options: LslOutletOptions) {
         super(options)
     }
 }

package/src/__tests__/impl/LslWebSocketBridge.test.ts

@@ -2,30 +2,29 @@ import { randomInt } from 'node:crypto'
 
 import { test, assert } from '@neurodevs/node-tdd'
 
-import { StreamInletOptions } from '../../impl/LslStreamInlet.js'
+import { LslInletOptions } from '../../impl/LslStreamInlet.js'
 import LslWebSocketBridge, {
-    WebSocketBridgeOptions,
+    LslWsBridgeOptions,
 } from '../../impl/LslWebSocketBridge.js'
-import FakeStreamInlet from '../../testDoubles/StreamInlet/FakeStreamInlet.js'
-import SpyLslWebSocketBridge from '../../testDoubles/WebSocketBridge/SpyLslWebSocketBridge.js'
+import FakeLslInlet from '../../testDoubles/LslInlet/FakeLslInlet.js'
+import SpyLslWsBridge from '../../testDoubles/LslWsBridge/SpyLslWsBridge.js'
 import FakeWebSocket from '../../testDoubles/WebSockets/FakeWebSocket.js'
 import FakeWebSocketServer from '../../testDoubles/WebSockets/FakeWebSocketServer.js'
 import AbstractPackageTest from '../AbstractPackageTest.js'
 
 export default class LslWebSocketBridgeTest extends AbstractPackageTest {
-    private static instance: SpyLslWebSocketBridge
+    private static instance: SpyLslWsBridge
 
     protected static async beforeEach() {
         await super.beforeEach()
 
         this.setFakeLiblsl()
-        this.setFakeStreamInlet()
+        this.setFakeLslInlet()
         this.setFakeWebSocket()
         this.setFakeWebSocketServer()
-        this.setSpyLslWebSocketBridge()
+        this.setSpyLslWsBridge()
 
-        this.instance =
-            (await this.LslWebSocketBridge()) as SpyLslWebSocketBridge
+        this.instance = (await this.LslWebSocketBridge()) as SpyLslWsBridge
     }
 
     @test()
@@ -35,7 +34,7 @@ export default class LslWebSocketBridgeTest extends AbstractPackageTest {
 
     @test()
     protected static async createsLslStreamInlet() {
-        const call = FakeStreamInlet.callsToConstructor[0]
+        const call = FakeLslInlet.callsToConstructor[0]
 
         const sourceId = call.options!.sourceId
         const chunkSize = call.options!.chunkSize
@@ -54,7 +53,7 @@ export default class LslWebSocketBridgeTest extends AbstractPackageTest {
         await this.activate()
 
         assert.isEqual(
-            FakeStreamInlet.numCallsToStartPulling,
+            FakeLslInlet.numCallsToStartPulling,
             1,
             'Did not call startPulling on inlet!'
         )
@@ -66,7 +65,7 @@ export default class LslWebSocketBridgeTest extends AbstractPackageTest {
         this.deactivate()
 
         assert.isEqual(
-            FakeStreamInlet.numCallsToStopPulling,
+            FakeLslInlet.numCallsToStopPulling,
             1,
             'Did not call stopPulling on inlet!'
         )
@@ -77,7 +76,7 @@ export default class LslWebSocketBridgeTest extends AbstractPackageTest {
         this.destroy()
 
         assert.isEqual(
-            FakeStreamInlet.numCallsToDestroy,
+            FakeLslInlet.numCallsToDestroy,
             1,
             'Did not call destroy on inlet!'
         )
@@ -270,7 +269,7 @@ export default class LslWebSocketBridgeTest extends AbstractPackageTest {
         const samples = [...new Float32Array([1, 2, 3, 4, 5, 6])]
         const timestamps = [...new Float64Array([7, 8])]
 
-        FakeStreamInlet.callsToConstructor[0]?.onData!(samples, timestamps)
+        FakeLslInlet.callsToConstructor[0]?.onData!(samples, timestamps)
         return { samples, timestamps }
     }
 
@@ -278,7 +277,7 @@ export default class LslWebSocketBridgeTest extends AbstractPackageTest {
 
     private static readonly connectUrls = [this.generateId(), this.generateId()]
 
-    private static readonly inletOptions: StreamInletOptions = {
+    private static readonly inletOptions: LslInletOptions = {
         sourceId: this.sourceId,
         chunkSize: randomInt(1, 100),
     }
@@ -289,9 +288,7 @@ export default class LslWebSocketBridgeTest extends AbstractPackageTest {
         connectUrls: this.connectUrls,
     }
 
-    private static LslWebSocketBridge(
-        options?: Partial<WebSocketBridgeOptions>
-    ) {
+    private static LslWebSocketBridge(options?: Partial<LslWsBridgeOptions>) {
         return LslWebSocketBridge.Create({ ...this.baseOptions, ...options })
     }
 }

package/src/__tests__/impl/WindowedClockRegressor.test.ts

@@ -4,7 +4,7 @@ import { test, assert } from '@neurodevs/node-tdd'
 
 import WindowedClockRegressor, {
     ClockRegressor,
-} from '../../impl/WindowedClockRegressor.js'
+} from '../../impl/clocks/WindowedClockRegressor.js'
 import AbstractPackageTest from '../AbstractPackageTest.js'
 
 export default class WindowedClockRegressorTest extends AbstractPackageTest {

package/src/assertions.ts

@@ -1,6 +1,5 @@
-import { ChannelFormat } from '@neurodevs/ndx-native'
+import { CHANNEL_FORMATS, ChannelFormat } from '@neurodevs/ndx-native'
 
-import { CHANNEL_FORMATS } from './consts.js'
 import {
     isGreaterThanOrEqualToZero,
     isPositiveInteger,

package/src/impl/LslEventMarkerEmitter.ts

@@ -1,28 +1,28 @@
 import { generateShortId } from '@neurodevs/generate-id'
 
 import LslStreamOutlet, {
-    StreamOutletOptions,
-    StreamOutlet,
+    LslOutletOptions,
+    LslOutlet,
 } from './LslStreamOutlet.js'
 
-export default class LslEventMarkerEmitter implements EventMarkerEmitter {
-    public static Class?: EventMarkerEmitterConstructor
+export default class LslEventMarkerEmitter implements LslEmitter {
+    public static Class?: LslEmitterConstructor
 
-    protected outlet: StreamOutlet
+    protected outlet: LslOutlet
     private isRunning = false
     private waitResolve?: () => void
     private timeout?: any
 
-    protected constructor(outlet: StreamOutlet) {
+    protected constructor(outlet: LslOutlet) {
         this.outlet = outlet
     }
 
-    public static async Create(options?: EventMarkerEmitterOptions) {
+    public static async Create(options?: LslEmitterOptions) {
         const outlet = await this.LslStreamOutlet(options)
         return new (this.Class ?? this)(outlet)
     }
 
-    public async emit(markerName: string, options?: EventMarkerOptions) {
+    public async emit(markerName: string, options?: EmitOptions) {
         this.throwIfAlreadyRunning('emit')
         this.isRunning = true
 
@@ -99,10 +99,10 @@ export default class LslEventMarkerEmitter implements EventMarkerEmitter {
             channelFormat: 'string',
             sampleRateHz: 0,
             chunkSize: 1,
-        } as StreamOutletOptions
+        } as LslOutletOptions
     }
 
-    private static LslStreamOutlet(options?: Partial<StreamOutletOptions>) {
+    private static LslStreamOutlet(options?: Partial<LslOutletOptions>) {
         return LslStreamOutlet.Create({
             ...this.generateDefaultOutletOptions(),
             ...options,
@@ -110,20 +110,18 @@ export default class LslEventMarkerEmitter implements EventMarkerEmitter {
     }
 }
 
-export interface EventMarkerEmitter {
-    emit(markerName: string, options?: EventMarkerOptions): Promise<void>
+export interface LslEmitter {
+    emit(markerName: string, options?: EmitOptions): Promise<void>
     emitMany(markers: TimedEventMarker[]): Promise<void>
     interrupt(): void
     destroy(): void
 }
 
-export type EventMarkerEmitterOptions = Partial<StreamOutletOptions>
+export type LslEmitterOptions = Partial<LslOutletOptions>
 
-export type EventMarkerEmitterConstructor = new (
-    outlet: StreamOutlet
-) => EventMarkerEmitter
+export type LslEmitterConstructor = new (outlet: LslOutlet) => LslEmitter
 
-export interface EventMarkerOptions {
+export interface EmitOptions {
     waitAfterMs?: number
 }
 

package/src/impl/LslStreamInfo.ts

@@ -6,8 +6,8 @@ import {
     CHANNEL_FORMATS_MAP,
 } from '@neurodevs/ndx-native'
 
-export default class LslStreamInfo implements StreamInfo {
-    public static Class?: StreamInfoConstructor
+export default class LslStreamInfo implements LslInfo {
+    public static Class?: LslInfoConstructor
 
     public readonly name: string
     public readonly type: string
@@ -22,7 +22,7 @@ export default class LslStreamInfo implements StreamInfo {
 
     private lsl = LiblslAdapter.getInstance()
 
-    protected constructor(options: StreamInfoOptions) {
+    protected constructor(options: LslInfoOptions) {
         const {
             name = `lsl-stream-info-${generateId()}`,
             type = generateId(),
@@ -46,7 +46,7 @@ export default class LslStreamInfo implements StreamInfo {
         this.appendChannelsToStreamInfo()
     }
 
-    public static Create(options: StreamInfoOptions) {
+    public static Create(options: LslInfoOptions) {
         return new (this.Class ?? this)(options)
     }
 
@@ -81,7 +81,7 @@ export default class LslStreamInfo implements StreamInfo {
     }
 }
 
-export interface StreamInfo {
+export interface LslInfo {
     destroy(): void
     readonly name: string
     readonly type: string
@@ -94,11 +94,9 @@ export interface StreamInfo {
     readonly infoHandle: InfoHandle
 }
 
-export type StreamInfoConstructor = new (
-    options: StreamInfoOptions
-) => StreamInfo
+export type LslInfoConstructor = new (options: LslInfoOptions) => LslInfo
 
-export interface StreamInfoOptions {
+export interface LslInfoOptions {
     channelNames: string[]
     channelFormat: ChannelFormat
     sampleRateHz: number