@neurodevs/node-lsl 17.1.1 → 18.0.0

package/src/scripts/runOutletToInlet.ts

@@ -1,11 +1,13 @@
 import LslStreamInlet from '../impl/LslStreamInlet.js'
 import LslStreamOutlet from '../impl/LslStreamOutlet.js'
 
+const sourceId = 'TestOutletID'
+
 console.log('Creating outlet...')
 const outlet = await LslStreamOutlet.Create({
     name: 'TestOutlet',
     type: 'TEST',
-    sourceId: 'TestOutletID',
+    sourceId,
     sampleRateHz: 100,
     channelNames: ['Ch1', 'Ch2', 'Ch3'],
     channelFormat: 'float32',
@@ -16,20 +18,18 @@ const outlet = await LslStreamOutlet.Create({
 
 console.log('Creating inlet...')
 
-const inletOptions = {
-    info: outlet.info,
-    chunkSize: 1,
-}
-
 const inlet = await LslStreamInlet.Create(
-    inletOptions,
+    {
+        sourceId,
+        chunkSize: 1,
+    },
     (samples, timestamps) => {
         console.log('Received samples:', samples, 'at timestamps:', timestamps)
     }
 )
 
 console.log('Start pulling...')
-inlet.startPulling()
+await inlet.startPulling()
 
 console.log('Waiting for 100 ms...')
 await new Promise((resolve) => setTimeout(resolve, 100))
@@ -49,3 +49,5 @@ for (let i = 0; i < 30; i++) {
     outlet.pushSample(sample)
     await new Promise((resolve) => setTimeout(resolve, 100))
 }
+
+process.exit(0)

package/src/scripts/testDestroyOutlet.ts

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

package/src/testDoubles/BackpressureMonitor/FakeBackpressureMonitor.ts

@@ -0,0 +1,13 @@
+import { BackpressureMonitor } from '../../impl/LslBackpressureMonitor.js'
+
+export default class FakeBackpressureMonitor implements BackpressureMonitor {
+    public static numCallsToConstructor = 0
+
+    public constructor() {
+        FakeBackpressureMonitor.numCallsToConstructor++
+    }
+
+    public static resetTestDouble() {
+        FakeBackpressureMonitor.numCallsToConstructor = 0
+    }
+}

package/src/testDoubles/EventMarkerEmitter/FakeEventMarkerEmitter.ts

@@ -0,0 +1,46 @@
+import {
+    EventMarkerEmitter,
+    EventMarkerOptions,
+    TimedEventMarker,
+} from '../../impl/LslEventMarkerEmitter.js'
+
+export default class FakeEventMarkerEmitter implements EventMarkerEmitter {
+    public static numCallsToConstructor = 0
+
+    public static callsToEmit: {
+        markerName: string
+        options?: EventMarkerOptions
+    }[] = []
+
+    public static callsToEmitMany: TimedEventMarker[][] = []
+    public static numCallsToInterrupt = 0
+    public static numCallsToDestroy = 0
+
+    public constructor() {
+        FakeEventMarkerEmitter.numCallsToConstructor++
+    }
+
+    public async emit(markerName: string, options?: EventMarkerOptions) {
+        FakeEventMarkerEmitter.callsToEmit.push({ markerName, options })
+    }
+
+    public async emitMany(markers: TimedEventMarker[]) {
+        FakeEventMarkerEmitter.callsToEmitMany.push(markers)
+    }
+
+    public interrupt() {
+        FakeEventMarkerEmitter.numCallsToInterrupt++
+    }
+
+    public destroy() {
+        FakeEventMarkerEmitter.numCallsToDestroy++
+    }
+
+    public static resetTestDouble() {
+        this.numCallsToConstructor = 0
+        this.callsToEmit = []
+        this.callsToEmitMany = []
+        this.numCallsToInterrupt = 0
+        this.numCallsToDestroy = 0
+    }
+}

package/src/testDoubles/EventMarkerEmitter/SpyEventMarkerEmitter.ts

@@ -0,0 +1,31 @@
+import LslEventMarkerEmitter from '../../impl/LslEventMarkerEmitter.js'
+import { StreamOutlet } from '../../impl/LslStreamOutlet.js'
+
+export default class SpyEventMarkerEmitter extends LslEventMarkerEmitter {
+    public static shouldCallWaitOnSuper = false
+
+    public totalwaitAfterMs: number
+
+    public constructor(outlet: StreamOutlet) {
+        super(outlet)
+
+        this.totalwaitAfterMs = 0
+    }
+
+    public async wait(waitAfterMs: number) {
+        this.totalwaitAfterMs += waitAfterMs
+
+        if (SpyEventMarkerEmitter.shouldCallWaitOnSuper) {
+            return super.wait(waitAfterMs)
+        }
+        return Promise.resolve()
+    }
+
+    public getStreamOutlet() {
+        return this.outlet
+    }
+
+    public resetTestDouble() {
+        this.totalwaitAfterMs = 0
+    }
+}

package/src/testDoubles/EventMarkerEmitter/ThrowingEventMarkerEmitter.ts

@@ -0,0 +1,29 @@
+import {
+    EventMarkerEmitter,
+    EventMarkerOptions,
+    TimedEventMarker,
+} from '../../impl/LslEventMarkerEmitter.js'
+
+export default class ThrowingEventMarkerEmitter implements EventMarkerEmitter {
+    private errorMsg = 'Intentional throwing: '
+
+    public constructor() {
+        throw new Error(this.errorMsg + 'constructor')
+    }
+
+    public async emit(_markerName: string, _options?: EventMarkerOptions) {
+        throw new Error(this.errorMsg + 'emit')
+    }
+
+    public async emitMany(_markers: TimedEventMarker[]) {
+        throw new Error(this.errorMsg + 'emitMany')
+    }
+
+    public interrupt() {
+        throw new Error(this.errorMsg + 'interrupt')
+    }
+
+    public destroy() {
+        throw new Error(this.errorMsg + 'destroy')
+    }
+}

package/src/testDoubles/StreamInfo/FakeStreamInfo.ts

@@ -1,13 +1,13 @@
 import generateId from '@neurodevs/generate-id'
+import { InfoHandle } from '@neurodevs/ndx-native'
 
-import { BoundStreamInfo } from 'impl/LiblslAdapter.js'
 import { StreamInfo, StreamInfoOptions } from '../../impl/LslStreamInfo.js'
 
 export default class FakeStreamInfo implements StreamInfo {
     public static callsToConstructor: (StreamInfoOptions | undefined)[] = []
     public static numCallsToDestroy = 0
 
-    public static boundInfo = {} as BoundStreamInfo
+    public static infoHandle = {} as InfoHandle
 
     public name = generateId()
     public type = generateId()
@@ -29,8 +29,8 @@ export default class FakeStreamInfo implements StreamInfo {
         return this.channelNames.length
     }
 
-    public get boundInfo() {
-        return FakeStreamInfo.boundInfo
+    public get infoHandle() {
+        return FakeStreamInfo.infoHandle
     }
 
     public static resetTestDouble() {

package/src/testDoubles/StreamInlet/FakeStreamInlet.ts

@@ -1,40 +1,34 @@
-import { StreamInfo } from '../../impl/LslStreamInfo.js'
 import {
+    OnDataCallback,
     StreamInlet,
-    StreamInletConstructorOptions,
+    StreamInletOptions,
 } from '../../impl/LslStreamInlet.js'
 
 export default class FakeStreamInlet implements StreamInlet {
     public static callsToConstructor: {
-        info?: StreamInfo
-        options?: StreamInletConstructorOptions
-        onData?: (samples: Float32Array, timestamps: Float64Array) => void
+        options?: StreamInletOptions
+        onData?: OnDataCallback
     }[] = []
 
     public static numCallsToStartPulling = 0
     public static numCallsToStopPulling = 0
-    public static numCallsToFlushQueue = 0
+    public static numCallsToFlushInlet = 0
     public static numCallsToDestroy = 0
 
     public isRunning = false
 
-    protected onData!: (samples: Float32Array, timestamps: Float64Array) => void
+    protected onData!: OnDataCallback
 
-    public constructor(
-        info?: StreamInfo,
-        options?: StreamInletConstructorOptions,
-        onData?: (samples: Float32Array, timestamps: Float64Array) => void
-    ) {
+    public constructor(options?: StreamInletOptions, onData?: OnDataCallback) {
         this.onData = onData ?? (() => {})
 
         FakeStreamInlet.callsToConstructor.push({
-            info,
             options,
             onData: this.onData,
         })
     }
 
-    public startPulling() {
+    public async startPulling() {
         FakeStreamInlet.numCallsToStartPulling++
         this.isRunning = true
     }
@@ -44,8 +38,8 @@ export default class FakeStreamInlet implements StreamInlet {
         this.isRunning = false
     }
 
-    public flushQueue() {
-        FakeStreamInlet.numCallsToFlushQueue++
+    public flushInlet() {
+        FakeStreamInlet.numCallsToFlushInlet++
     }
 
     public destroy() {
@@ -55,7 +49,7 @@ export default class FakeStreamInlet implements StreamInlet {
     public static resetTestDouble() {
         FakeStreamInlet.callsToConstructor = []
         FakeStreamInlet.numCallsToStartPulling = 0
-        FakeStreamInlet.numCallsToFlushQueue = 0
+        FakeStreamInlet.numCallsToFlushInlet = 0
         FakeStreamInlet.numCallsToDestroy = 0
     }
 }

package/src/testDoubles/StreamInlet/SpyStreamInlet.ts

@@ -1,23 +1,10 @@
-import { StreamInfo } from '../../impl/LslStreamInfo.js'
 import LslStreamInlet, {
     OnDataCallback,
-    StreamInletConstructorOptions,
+    StreamInletOptions,
 } from '../../impl/LslStreamInlet.js'
 
 export class SpyStreamInlet extends LslStreamInlet {
-    public constructor(
-        info: StreamInfo,
-        options: StreamInletConstructorOptions,
-        onData: OnDataCallback
-    ) {
-        super(info, options, onData)
-    }
-
-    public getStreamInfo() {
-        return this.info
-    }
-
-    public getBoundInlet() {
-        return this.inlet
+    public constructor(options: StreamInletOptions, onData: OnDataCallback) {
+        super(options, onData)
     }
 }

package/src/testDoubles/StreamOutlet/FakeStreamOutlet.ts

@@ -1,30 +1,27 @@
-import { randomInt } from 'crypto'
+import { randomInt } from 'node:crypto'
+
 import generateId from '@neurodevs/generate-id'
+import { LslSample } from '@neurodevs/ndx-native'
 
-import { LslSample } from 'impl/LiblslAdapter.js'
-import { StreamInfo } from '../../impl/LslStreamInfo.js'
 import {
     StreamOutlet,
     StreamOutletOptions,
 } from '../../impl/LslStreamOutlet.js'
-import FakeStreamInfo from '../StreamInfo/FakeStreamInfo.js'
 
 export default class FakeStreamOutlet implements StreamOutlet {
-    public static callsToConstructor: {
-        info?: StreamInfo
-        options?: StreamOutletOptions
+    public static callsToConstructor: (StreamOutletOptions | undefined)[] = []
+
+    public static callsToPushSample: {
+        sample: LslSample
+        timestamp?: number
     }[] = []
 
-    public static callsToPushSample: LslSample[] = []
     public static numCallsToDestroy = 0
 
-    public info: StreamInfo
     public options?: StreamOutletOptions
 
-    public constructor(info?: StreamInfo, options?: StreamOutletOptions) {
-        FakeStreamOutlet.callsToConstructor.push({ info, options })
-
-        this.info = info ?? new FakeStreamInfo()
+    public constructor(options?: StreamOutletOptions) {
+        FakeStreamOutlet.callsToConstructor.push(options)
         this.options = options
     }
 
@@ -32,8 +29,8 @@ export default class FakeStreamOutlet implements StreamOutlet {
         FakeStreamOutlet.numCallsToDestroy++
     }
 
-    public pushSample(sample: LslSample) {
-        FakeStreamOutlet.callsToPushSample.push(sample)
+    public pushSample(sample: LslSample, timestamp?: number) {
+        FakeStreamOutlet.callsToPushSample.push({ sample, timestamp })
     }
 
     public get name() {

package/src/testDoubles/WebSocketBridge/FakeWebSocketBridge.ts

@@ -20,7 +20,7 @@ export default class FakeWebSocketBridge implements WebSocketBridge {
         FakeWebSocketBridge.callsToConstructor.push(options)
     }
 
-    public activate() {
+    public async activate() {
         FakeWebSocketBridge.numCallsToActivate++
     }
 

package/src/testDoubles/WorkerThreads/FakeWorker.ts

@@ -0,0 +1,99 @@
+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>[]
+}

package/src/validations.ts

@@ -7,11 +7,9 @@ export function isGreaterThanOrEqualToZero(value: number) {
 }
 
 export function isPositiveInteger(value: number) {
-    //@ts-ignore
     return Number.isInteger(value) && value > 0
 }
 
 export function isPositiveIntegerOrZero(value: number) {
-    //@ts-ignore
     return Number.isInteger(value) && value >= 0
 }

package/build/__tests__/impl/LiblslAdapter.test.d.ts

@@ -1,79 +0,0 @@
-import { FieldType, FuncObj } from 'ffi-rs';
-import AbstractPackageTest from '../AbstractPackageTest.js';
-export default class LiblslAdapterTest extends AbstractPackageTest {
-    private static instance;
-    private static libraryPath?;
-    private static libraryOptions?;
-    private static fakeBindings;
-    private static fakeStreamInfo;
-    private static fakeOutlet;
-    private static fakeInlet;
-    private static fakeDesc;
-    private static fakeChildNamedChannels;
-    private static createStreamInfoParams?;
-    private static destroyStreamInfoParams?;
-    private static appendChildParams;
-    private static createOutletParams?;
-    private static destroyOutletParams?;
-    private static createInletParams?;
-    private static flushInletParams?;
-    private static destroyInletParams?;
-    private static localClockParams?;
-    private static pushSampleFloatTimestampParams?;
-    private static pushSampleStringTimestampParams?;
-    private static appendChildValueParams;
-    private static shouldThrowWhenCreatingBindings;
-    private static getDescriptionParams?;
-    private static fakeChildNamedChannel;
-    private static appendChildHitCount;
-    private static ffiRsOpenOptions?;
-    private static ffiRsDefineOptions;
-    private static ffiRsLoadOptions?;
-    protected static beforeEach(): Promise<void>;
-    protected static createsInstance(): Promise<void>;
-    protected static throwsWhenBindingsFailToLoad(): Promise<void>;
-    protected static callsOpenOnFfiRs(): Promise<void>;
-    protected static worksAsASingleton(): Promise<void>;
-    protected static singletonIsTheSame(): Promise<void>;
-    protected static canSetInstance(): void;
-    protected static createsExpectedBindingsWithFfiRs(): Promise<void>;
-    protected static createsStreamInfoWithRequiredParams(): Promise<void>;
-    protected static destroysStreamInfoWithBoundInfo(): Promise<void>;
-    protected static resolvesStreamInfoByProp(): Promise<void>;
-    protected static resolveByPropAcceptsOptionalArgs(): Promise<void>;
-    protected static returnsHandlesForResolvedStreamInfos(): Promise<void>;
-    protected static createsOutletWithRequiredParams(): Promise<void>;
-    protected static pushesFloatSample(): Promise<void>;
-    protected static pushesStringSample(): Promise<void>;
-    protected static addingSingleChannelGetsDescription(): Promise<void>;
-    protected static addingMultpleChannelsAddsChildrenToChannelsChild(): Promise<void>;
-    protected static canDestroyOutlet(): Promise<void>;
-    protected static callingLocalClockTwiceReturnsDifferentTimestamps(): Promise<void>;
-    protected static localClockBindingReceivesEmptyArray(): Promise<void>;
-    protected static defaultsToMacOsPath(): Promise<void>;
-    protected static createInletWithRequiredParams(): Promise<void>;
-    protected static pullSampleCallsBinding(): Promise<void>;
-    protected static pullChunkCallsBinding(): Promise<void>;
-    protected static flushInletCallsBinding(): Promise<void>;
-    protected static destroyInletCallsBinding(): Promise<void>;
-    private static createRandomStreamInfo;
-    private static resolveByProp;
-    private static createRandomOutlet;
-    private static createRandomOutletOptions;
-    private static createRandomInlet;
-    private static createRandomInletOptions;
-    private static generateRandomChannelValues;
-    private static generateRandomCreateStreamInfoOptions;
-    private static readonly maxResults;
-    private static readonly bytesPerPointer;
-    private static readonly minResults;
-    private static readonly timeoutMs;
-    private static readonly prop;
-    private static readonly value;
-    private static readonly fakeNumResolveResults;
-    private static readonly resultsBuffer;
-    private static readonly resultsBufferPtr;
-    private static generateFailedMessage;
-    private static FakeBindings;
-}
-export type FfiRsDefineOptions = FuncObj<FieldType, boolean | undefined>;