@neurodevs/node-lsl 16.0.2 → 16.1.0

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

@@ -18,6 +18,7 @@ import {
     Liblsl,
     LiblslBindings,
     LslChannel,
+    ResolveByPropOptions,
 } from 'impl/LiblslAdapter.js'
 import LiblslAdapter from '../../impl/LiblslAdapter.js'
 import FakeLiblsl from '../../testDoubles/Liblsl/FakeLiblsl.js'
@@ -97,7 +98,7 @@ export default class LiblslAdapterTest extends AbstractPackageTest {
 
         LiblslAdapter.load = (options) => {
             this.ffiRsLoadOptions = options
-            return {} as any
+            return this.fakeNumResolveResults as any
         }
 
         LiblslAdapter.resetInstance()
@@ -200,7 +201,12 @@ export default class LiblslAdapterTest extends AbstractPackageTest {
             lsl_create_inlet: {
                 library: 'lsl',
                 retType: DataType.External,
-                paramsType: [DataType.External, DataType.I32, DataType.I32],
+                paramsType: [
+                    DataType.External,
+                    DataType.I32,
+                    DataType.I32,
+                    DataType.I32,
+                ],
             },
             lsl_flush_inlet: {
                 library: 'lsl',
@@ -260,6 +266,89 @@ export default class LiblslAdapterTest extends AbstractPackageTest {
         )
     }
 
+    @test()
+    protected static async resolvesStreamInfoByProp() {
+        await this.resolveByProp()
+
+        assert.isEqualDeep(
+            this.ffiRsLoadOptions,
+            {
+                library: 'lsl',
+                funcName: 'lsl_resolve_byprop',
+                retType: DataType.I32,
+                paramsType: [
+                    DataType.External,
+                    DataType.I32,
+                    DataType.String,
+                    DataType.String,
+                    DataType.I32,
+                    DataType.Double,
+                ],
+                paramsValue: [
+                    this.resultsBufferPtr,
+                    this.maxResults,
+                    this.prop,
+                    this.value,
+                    this.minResults,
+                    this.timeoutMs / 1000,
+                ],
+                runInNewThread: true,
+            },
+            'Did not call resolveByProp with expected params!'
+        )
+    }
+
+    @test()
+    protected static async resolveByPropAcceptsOptionalArgs() {
+        const minResults = randomInt(0, 10)
+        const timeoutMs = Math.random() * 1000
+
+        await this.resolveByProp({
+            minResults,
+            timeoutMs,
+        })
+
+        assert.isEqualDeep(
+            {
+                minResults: this.ffiRsLoadOptions?.['paramsValue']?.[4],
+                timeoutMs: this.ffiRsLoadOptions?.['paramsValue']?.[5],
+            },
+            { minResults, timeoutMs: timeoutMs / 1000 },
+            'Did not call resolveByProp with expected params!'
+        )
+    }
+
+    @test()
+    protected static async returnsHandlesForResolvedStreamInfos() {
+        LiblslAdapter.alloc = (size: number) => {
+            const buffer = Buffer.alloc(size)
+
+            for (let i = 0; i < this.fakeNumResolveResults; i++) {
+                const offset = i * this.bytesPerPointer
+                buffer.writeBigUInt64LE(BigInt(i + 1), offset)
+            }
+
+            return buffer
+        }
+
+        const expectedHandles: bigint[] = []
+
+        for (let i = 0; i < this.fakeNumResolveResults; i++) {
+            expectedHandles.push(BigInt(i + 1))
+        }
+
+        const actualHandles = await this.resolveByProp()
+
+        const actual = actualHandles.map((h) => h.toString())
+        const expected = expectedHandles.map((h) => h.toString())
+
+        assert.isEqualDeep(
+            actual,
+            expected,
+            'Did not receive expected resolved stream info handles!'
+        )
+    }
+
     @test()
     protected static async createsOutletWithRequiredParams() {
         const { options, outlet } = this.createRandomOutlet()
@@ -396,7 +485,7 @@ export default class LiblslAdapterTest extends AbstractPackageTest {
         delete process.env.LIBLSL_PATH
 
         LiblslAdapter.resetInstance()
-        this.instance = LiblslAdapter.getInstance()
+        this.instance = LiblslAdapter.getInstance() as FakeLiblsl
 
         assert.isEqual(
             this.ffiRsOpenOptions?.path,
@@ -407,14 +496,23 @@ export default class LiblslAdapterTest extends AbstractPackageTest {
     @test()
     protected static async createInletWithRequiredParams() {
         const { options, inlet } = this.createRandomInlet()
+        const { maxBufferedMs } = options
 
         const expected = {
             ...options,
-            maxBufferedMs: options.maxBufferedMs / 1000,
+            maxBufferedMs: maxBufferedMs / 1000,
         }
 
-        assert.isEqualDeep(this.createInletParams, Object.values(expected))
-        assert.isEqual(inlet, this.fakeInlet)
+        const maxChunkSize = 0
+        const shouldRecover = 1
+
+        assert.isEqualDeep(
+            this.createInletParams,
+            [...Object.values(expected), maxChunkSize, shouldRecover],
+            'Did not call createInlet with expected params!'
+        )
+
+        assert.isEqual(inlet, this.fakeInlet, 'Did not receive expected inlet!')
     }
 
     @test()
@@ -572,23 +670,44 @@ export default class LiblslAdapterTest extends AbstractPackageTest {
         )
     }
 
+    private static async resolveByProp(
+        options?: Partial<ResolveByPropOptions>
+    ) {
+        return this.instance.resolveByProp({
+            prop: this.prop,
+            value: this.value,
+            minResults: this.minResults,
+            timeoutMs: this.timeoutMs,
+            ...options,
+        })
+    }
+
     private static createRandomOutlet() {
-        const options = this.createRandomOptions()
+        const options = this.createRandomOutletOptions()
         const outlet = this.instance.createOutlet(options)
         return { options, outlet }
     }
 
+    private static createRandomOutletOptions() {
+        const info = this.createRandomStreamInfo()
+        const options = {
+            info,
+            chunkSize: randomInt(10),
+            maxBufferedMs: randomInt(10),
+        }
+        return options
+    }
+
     private static createRandomInlet() {
-        const options = this.createRandomOptions()
+        const options = this.createRandomInletOptions()
         const inlet = this.instance.createInlet(options)
         return { options, inlet }
     }
 
-    private static createRandomOptions() {
+    private static createRandomInletOptions() {
         const info = this.createRandomStreamInfo()
         const options = {
             info,
-            chunkSize: randomInt(10),
             maxBufferedMs: randomInt(10),
         }
         return options
@@ -613,6 +732,26 @@ export default class LiblslAdapterTest extends AbstractPackageTest {
         }
     }
 
+    // resolveByProp
+    private static readonly maxResults = 1024
+    private static readonly bytesPerPointer = 8
+    private static readonly minResults = 1
+    private static readonly timeoutMs = 1000
+    private static readonly prop = this.generateId()
+    private static readonly value = this.generateId()
+    private static readonly fakeNumResolveResults = 2
+
+    private static readonly resultsBuffer = Buffer.alloc(
+        this.maxResults * this.bytesPerPointer
+    )
+
+    private static readonly resultsBufferPtr = unwrapPointer(
+        createPointer({
+            paramsType: [DataType.U8Array],
+            paramsValue: [this.resultsBuffer],
+        })
+    )[0]
+
     private static generateFailedMessage() {
         return `Loading the liblsl dylib failed! I tried to load it from ${process.env.LIBLSL_PATH}.`
     }

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

@@ -11,10 +11,9 @@ export default class LslStreamInfoTest extends AbstractPackageTest {
     protected static async beforeEach() {
         await super.beforeEach()
 
+        this.setFakeLiblsl()
         this.setSpyStreamInfo()
 
-        LslStreamInfo['instanceCache'] = {}
-
         this.instance = this.LslStreamInfo()
     }
 
@@ -220,13 +219,28 @@ export default class LslStreamInfoTest extends AbstractPackageTest {
     }
 
     @test()
-    protected static async cachesInfoIfPassedSameOptions() {
-        this.LslStreamInfo()
+    protected static async doesNotCreateNewStreamInfoIfPassedBoundStreamInfo() {
+        this.LslStreamInfo({
+            boundStreamInfo: this.instance.getBoundInfo(),
+        })
 
         assert.isEqual(
-            SpyStreamInfo.numCallsToConstructor,
+            this.fakeLiblsl.createStreamInfoHitCount,
             1,
-            'Did not cache stream info!'
+            'Should not have created new stream info!'
+        )
+    }
+
+    @test()
+    protected static async setsBoundStreamInfoWhenPassed() {
+        const instance = this.LslStreamInfo({
+            boundStreamInfo: this.instance.getBoundInfo(),
+        })
+
+        assert.isEqualDeep(
+            instance.getBoundInfo(),
+            this.instance.getBoundInfo(),
+            'Should have set bound stream info!'
         )
     }
 

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

@@ -15,8 +15,9 @@ export default class LslStreamInletTest extends AbstractPackageTest {
     protected static async beforeEach() {
         await super.beforeEach()
 
-        this.setSpyStreamInlet()
+        this.setFakeLiblsl()
         this.setFakeStreamInfo()
+        this.setSpyStreamInlet()
 
         this.callsToOnData = []
 
@@ -65,8 +66,7 @@ export default class LslStreamInletTest extends AbstractPackageTest {
             this.fakeLiblsl.lastCreateInletOptions,
             {
                 info: fakeInfo.boundStreamInfo,
-                chunkSize: this.chunkSize,
-                maxBufferedMs: this.maxBufferedMs / 1000,
+                maxBufferedMs: this.maxBufferedMs,
             },
             'Should have called createInlet!'
         )
@@ -212,11 +212,11 @@ export default class LslStreamInletTest extends AbstractPackageTest {
             maxBufferedMs: undefined,
         })
 
-        const sixMinutesInSeconds = 360
+        const sixMinutesInMs = 360 * 1000
 
         assert.isEqualDeep(
             this.fakeLiblsl.lastCreateInletOptions?.maxBufferedMs,
-            sixMinutesInSeconds
+            sixMinutesInMs
         )
     }
 

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

@@ -17,6 +17,7 @@ export default class LslWebSocketBridgeTest extends AbstractPackageTest {
     protected static async beforeEach() {
         await super.beforeEach()
 
+        this.setFakeLiblsl()
         this.setFakeStreamInlet()
         this.setFakeWebSocket()
         this.setFakeWebSocketServer()

package/src/impl/LiblslAdapter.ts

@@ -1,4 +1,12 @@
-import { DataType, define, JsExternal, load, open, unwrapPointer } from 'ffi-rs'
+import {
+    createPointer,
+    DataType,
+    define,
+    JsExternal,
+    load,
+    open,
+    unwrapPointer,
+} from 'ffi-rs'
 
 import { CHANNEL_FORMATS } from '../consts.js'
 import { LslErrorCode } from '../handleError.js'
@@ -7,6 +15,7 @@ export default class LiblslAdapter implements Liblsl {
     public static open = open
     public static define = define
     public static load = load
+    public static alloc = Buffer.alloc
 
     private static instance?: Liblsl
 
@@ -62,7 +71,7 @@ export default class LiblslAdapter implements Liblsl {
     }
 
     private defineLiblslBindings() {
-        return this.define(this.liblslFuncs) as unknown as LiblslBindings
+        return this.define(this.liblslFuncs) as LiblslBindings
     }
 
     public createStreamInfo(options: CreateStreamInfoOptions) {
@@ -85,11 +94,6 @@ export default class LiblslAdapter implements Liblsl {
         ])
     }
 
-    public destroyStreamInfo(options: DestroyStreamInfoOptions) {
-        const { info } = options
-        this.bindings.lsl_destroy_streaminfo([info])
-    }
-
     public appendChannelsToStreamInfo(
         options: AppendChannelsToStreamInfoOptions
     ) {
@@ -110,6 +114,62 @@ export default class LiblslAdapter implements Liblsl {
         }
     }
 
+    public destroyStreamInfo(options: DestroyStreamInfoOptions) {
+        const { info } = options
+        this.bindings.lsl_destroy_streaminfo([info])
+    }
+
+    public async resolveByProp(options: ResolveByPropOptions) {
+        const { prop, value, minResults = 1, timeoutMs = 1000 } = options
+
+        const maxResults = 1024
+        const bytesPerPointer = 8
+
+        const resultsBuffer = this.alloc(maxResults * bytesPerPointer)
+
+        const resultsBufferPtr = unwrapPointer(
+            createPointer({
+                paramsType: [DataType.U8Array],
+                paramsValue: [resultsBuffer],
+            })
+        )[0]
+
+        const numResults = await this.load({
+            library: 'lsl',
+            funcName: 'lsl_resolve_byprop',
+            retType: DataType.I32,
+            paramsType: [
+                DataType.External,
+                DataType.I32,
+                DataType.String,
+                DataType.String,
+                DataType.I32,
+                DataType.Double,
+            ],
+            paramsValue: [
+                resultsBufferPtr,
+                maxResults,
+                prop,
+                value,
+                minResults,
+                timeoutMs / 1000,
+            ],
+            runInNewThread: true,
+        })
+
+        const handles: bigint[] = []
+
+        for (let i = 0; i < numResults; i++) {
+            const handle = resultsBuffer.readBigUInt64LE(i * bytesPerPointer)
+
+            if (handle !== 0n) {
+                handles.push(handle)
+            }
+        }
+
+        return handles
+    }
+
     public createOutlet(options: CreateOutletOptions) {
         const { info, chunkSize, maxBufferedMs } = options
 
@@ -138,15 +198,19 @@ export default class LiblslAdapter implements Liblsl {
     }
 
     public createInlet(options: CreateInletOptions) {
-        const { info, chunkSize, maxBufferedMs } = options
+        const { info, maxBufferedMs } = options
 
         return this.bindings.lsl_create_inlet([
             info,
-            chunkSize,
             maxBufferedMs / 1000,
+            this.maxChunkSize,
+            this.shouldRecover,
         ])
     }
 
+    private readonly maxChunkSize = 0
+    private readonly shouldRecover = 1
+
     public pullSample(options: PullSampleOptions) {
         const {
             inlet,
@@ -239,6 +303,10 @@ export default class LiblslAdapter implements Liblsl {
         return LiblslAdapter.load
     }
 
+    private get alloc() {
+        return LiblslAdapter.alloc
+    }
+
     private get liblslFuncs() {
         return {
             lsl_create_streaminfo: {
@@ -289,7 +357,12 @@ export default class LiblslAdapter implements Liblsl {
             lsl_create_inlet: {
                 library: 'lsl',
                 retType: DataType.External,
-                paramsType: [DataType.External, DataType.I32, DataType.I32],
+                paramsType: [
+                    DataType.External,
+                    DataType.I32,
+                    DataType.I32,
+                    DataType.I32,
+                ],
             },
             lsl_flush_inlet: {
                 library: 'lsl',
@@ -336,6 +409,8 @@ export interface Liblsl {
     destroyStreamInfo(options: DestroyStreamInfoOptions): void
     appendChannelsToStreamInfo(options: AppendChannelsToStreamInfoOptions): void
 
+    resolveByProp(options: ResolveByPropOptions): Promise<bigint[]>
+
     createOutlet(options: CreateOutletOptions): BoundOutlet
 
     pushSampleFloatTimestamp(
@@ -373,14 +448,21 @@ export interface AppendChannelsToStreamInfoOptions {
     channels: LslChannel[]
 }
 
-export interface CreateOutletOptions {
+export interface DestroyStreamInfoOptions {
     info: BoundStreamInfo
-    chunkSize: number
-    maxBufferedMs: number
 }
 
-export interface DestroyStreamInfoOptions {
+export interface ResolveByPropOptions {
+    prop: string
+    value: string
+    minResults?: number
+    timeoutMs?: number
+}
+
+export interface CreateOutletOptions {
     info: BoundStreamInfo
+    chunkSize: number
+    maxBufferedMs: number
 }
 
 export interface PushSampleFloatTimestampOptions {
@@ -401,7 +483,6 @@ export interface DestroyOutletOptions {
 
 export interface CreateInletOptions {
     info: BoundStreamInfo
-    chunkSize: number
     maxBufferedMs: number
 }
 

package/src/impl/LslStreamInfo.ts

@@ -7,8 +7,6 @@ import LiblslAdapter from './LiblslAdapter.js'
 export default class LslStreamInfo implements StreamInfo {
     public static Class?: StreamInfoConstructor
 
-    private static instanceCache: Record<string, StreamInfo> = {}
-
     public readonly name: string
     public readonly type: string
     public readonly sourceId: string
@@ -36,6 +34,7 @@ export default class LslStreamInfo implements StreamInfo {
             channelFormat,
             sampleRateHz,
             units = this.defaultUnits,
+            boundStreamInfo,
         } = options
 
         this.name = name
@@ -47,38 +46,16 @@ export default class LslStreamInfo implements StreamInfo {
         this.sampleRateHz = sampleRateHz
         this.units = units
 
-        this.createStreamInfo()
-        this.appendChannelsToStreamInfo()
+        if (!boundStreamInfo) {
+            this.createStreamInfo()
+            this.appendChannelsToStreamInfo()
+        } else {
+            this.boundInfo = boundStreamInfo
+        }
     }
 
     public static Create(options: StreamInfoOptions) {
-        const {
-            name,
-            type,
-            sourceId,
-            channelNames,
-            channelFormat,
-            sampleRateHz,
-        } = options
-
-        const channelCount = channelNames.length
-
-        const key = JSON.stringify({
-            name,
-            type,
-            sourceId,
-            channelCount,
-            channelFormat,
-            sampleRateHz,
-        })
-
-        let instance = this.instanceCache[key]
-
-        if (instance === undefined) {
-            instance = new (this.Class ?? this)(options)
-            this.instanceCache[key] = instance
-        }
-        return instance
+        return new (this.Class ?? this)(options)
     }
 
     private createStreamInfo() {
@@ -139,4 +116,5 @@ export interface StreamInfoOptions {
     type?: string
     sourceId?: string
     units?: string
+    boundStreamInfo?: BoundStreamInfo
 }

package/src/impl/LslStreamInlet.ts

@@ -92,8 +92,7 @@ export default class LslStreamInlet implements StreamInlet {
     private createBoundInlet() {
         this.inlet = this.lsl.createInlet({
             info: this.boundStreamInfo,
-            chunkSize: this.chunkSize,
-            maxBufferedMs: this.maxBufferedMs / 1000,
+            maxBufferedMs: this.maxBufferedMs,
         })
     }
 
@@ -117,23 +116,27 @@ export default class LslStreamInlet implements StreamInlet {
     }
 
     private createDataBuffer() {
-        const bytesPerFloat = 4
-
         this.dataBuffer = Buffer.alloc(
-            bytesPerFloat * this.chunkSize * this.channelCount
+            this.bytesPerFloat * this.chunkSize * this.channelCount
         )
     }
 
+    private readonly bytesPerFloat = 4
+
     private createTimestampBuffer() {
-        const bytesPerDouble = 8
-        this.timestampBuffer = Buffer.alloc(bytesPerDouble * this.chunkSize)
+        this.timestampBuffer = Buffer.alloc(
+            this.bytesPerDouble * this.chunkSize
+        )
     }
 
+    private readonly bytesPerDouble = 8
+
     private createErrorCodeBuffer() {
-        const bytesPerInt = 4
-        this.errorCodeBuffer = Buffer.alloc(bytesPerInt)
+        this.errorCodeBuffer = Buffer.alloc(this.bytesPerInt)
     }
 
+    private readonly bytesPerInt = 4
+
     private createPointersToBuffers() {
         this.createDataBufferPtr()
         this.createTimestampBufferPtr()

package/src/testDoubles/Liblsl/FakeLiblsl.ts

@@ -16,9 +16,13 @@ import {
     PullChunkOptions,
     PullSampleOptions,
     DestroyStreamInfoOptions,
+    ResolveByPropOptions,
+    DestroyOutletOptions,
 } from 'impl/LiblslAdapter.js'
 
 export default class FakeLiblsl implements Liblsl {
+    public static fakeResolveHandles: bigint[] = []
+
     public static fakeSamples: Float32Array[] = [
         new Float32Array([1, 2, 3]),
         new Float32Array([4, 5, 6]),
@@ -46,12 +50,14 @@ export default class FakeLiblsl implements Liblsl {
     public streamInfo: BoundStreamInfo = {} as BoundStreamInfo
 
     public lastCreateStreamInfoOptions?: CreateStreamInfoOptions
-    public lastDestroyStreamInfoOptions?: DestroyStreamInfoOptions
     public lastAppendChannelsToStreamInfoOptions?: AppendChannelsToStreamInfoOptions
+    public lastDestroyStreamInfoOptions?: DestroyStreamInfoOptions
+    public lastResolveByPropOptions?: ResolveByPropOptions
     public lastCreateOutletOptions?: CreateOutletOptions
     public lastPushSampleFloatTimestampOptions?: PushSampleFloatTimestampOptions
     public lastPushSampleStringTimestampOptions?: PushSampleStringTimestampOptions
     public lastCreateInletOptions?: CreateInletOptions
+    public lastDestroyOutletOptions?: DestroyOutletOptions
     public lastPullSampleOptions?: PullSampleOptions
     public lastPullChunkOptions?: PullChunkOptions
     public lastFlushInletOptions?: FlushInletOptions
@@ -72,16 +78,21 @@ export default class FakeLiblsl implements Liblsl {
         return this.streamInfo
     }
 
-    public destroyStreamInfo(options: DestroyStreamInfoOptions) {
-        this.lastDestroyStreamInfoOptions = options
-    }
-
     public appendChannelsToStreamInfo(
         options: AppendChannelsToStreamInfoOptions
     ) {
         this.lastAppendChannelsToStreamInfoOptions = options
     }
 
+    public destroyStreamInfo(options: DestroyStreamInfoOptions) {
+        this.lastDestroyStreamInfoOptions = options
+    }
+
+    public async resolveByProp(options: ResolveByPropOptions) {
+        this.lastResolveByPropOptions = options
+        return FakeLiblsl.fakeResolveHandles
+    }
+
     public pushSampleFloatTimestamp(options: PushSampleFloatTimestampOptions) {
         this.lastPushSampleFloatTimestampOptions = options
         return FakeLiblsl.fakeErrorCode
@@ -101,8 +112,9 @@ export default class FakeLiblsl implements Liblsl {
         return this.outlet
     }
 
-    public destroyOutlet() {
+    public destroyOutlet(options: DestroyOutletOptions) {
         this.destroyOutletHitCount++
+        this.lastDestroyOutletOptions = options
     }
 
     public createInlet(options: CreateInletOptions) {