@neurodevs/node-lsl 10.1.4 → 10.2.0

package/src/__tests__/LslStreamInfo.test.ts

@@ -0,0 +1,209 @@
+import { test, assert, generateId, errorAssert } from '@sprucelabs/test-utils'
+import LslStreamInfo, { StreamInfoOptions } from '../components/LslStreamInfo'
+import { CHANNEL_FORMATS } from '../consts'
+import SpyLslStreamInfo from '../testDoubles/SpyLslStreamInfo'
+import AbstractNodeLslTest from './AbstractNodeLslTest'
+
+export default class LslStreamInfoTest extends AbstractNodeLslTest {
+    private static instance: SpyLslStreamInfo
+
+    protected static async beforeEach() {
+        await super.beforeEach()
+
+        this.setSpyLslStreamInfo()
+
+        this.instance = this.LslStreamInfo()
+    }
+
+    @test()
+    protected static async canCreateLslStreamInfo() {
+        assert.isTruthy(this.instance, 'Instance should be created!')
+    }
+
+    @test()
+    protected static async throwsWithMissingRequiredOptions() {
+        const err = assert.doesThrow(
+            // @ts-ignore
+            () => LslStreamInfo.Create()
+        )
+        errorAssert.assertError(err, 'MISSING_PARAMETERS', {
+            parameters: ['channelNames', 'channelFormat', 'sampleRate'],
+        })
+    }
+
+    @test()
+    protected static async generatesUniqueNameIfNotProvided() {
+        const instance1 = this.LslStreamInfo({ name: undefined })
+        const instance2 = this.LslStreamInfo({ name: undefined })
+
+        assert.isNotEqual(
+            instance1.getName(),
+            instance2.getName(),
+            'Inlet names should be unique!'
+        )
+    }
+
+    @test()
+    protected static async uniqueNameHasSetPrefix() {
+        const instance = this.LslStreamInfo({ name: undefined })
+
+        assert.doesInclude(
+            instance.getName(),
+            'lsl-stream-info-',
+            'Name should have set prefix!'
+        )
+    }
+
+    @test()
+    protected static async canManuallySetName() {
+        const name = generateId()
+        const instance = this.LslStreamInfo({ name })
+
+        assert.isEqual(
+            instance.getName(),
+            name,
+            'Name should be set to provided value!'
+        )
+    }
+
+    @test()
+    protected static async generatesUniqueTypeIfNotProvided() {
+        const instance1 = this.LslStreamInfo({ type: undefined })
+        const instance2 = this.LslStreamInfo({ type: undefined })
+
+        assert.isNotEqual(
+            instance1.getType(),
+            instance2.getType(),
+            'Inlet types should be unique!'
+        )
+    }
+
+    @test()
+    protected static async canManuallySetType() {
+        const type = generateId()
+        const instance = this.LslStreamInfo({ type })
+
+        assert.isEqual(
+            instance.getType(),
+            type,
+            'Type should be set to provided value!'
+        )
+    }
+
+    @test()
+    protected static async generatesUniqueSourceIdIfNotProvided() {
+        const instance1 = this.LslStreamInfo({ sourceId: undefined })
+        const instance2 = this.LslStreamInfo({ sourceId: undefined })
+
+        assert.isNotEqual(
+            instance1.getSourceId(),
+            instance2.getSourceId(),
+            'Inlet sourceIds should be unique!'
+        )
+    }
+
+    @test()
+    protected static async canManuallySetSourceId() {
+        const sourceId = generateId()
+        const instance = this.LslStreamInfo({ sourceId })
+
+        assert.isEqual(
+            instance.getSourceId(),
+            sourceId,
+            'SourceId should be set to provided value!'
+        )
+    }
+
+    @test()
+    protected static async setsUnitsToNAIfNotProvided() {
+        assert.isEqual(
+            this.instance.getUnits(),
+            'N/A',
+            'Units should be set to "N/A"!'
+        )
+    }
+
+    @test()
+    protected static async canManuallySetUnits() {
+        const units = generateId()
+        const instance = this.LslStreamInfo({ units })
+
+        assert.isEqual(
+            instance.getUnits(),
+            units,
+            'Units should be set to provided value!'
+        )
+    }
+
+    @test()
+    protected static async callsBindingsToCreateStreamInfo() {
+        assert.isEqual(
+            this.fakeLiblsl.createStreamInfoHitCount,
+            1,
+            'Should have called createStreamInfo!'
+        )
+    }
+
+    @test()
+    protected static async passesOptionsToStreamInfo() {
+        const randomChannelIdx = Math.floor(
+            Math.random() * CHANNEL_FORMATS.length
+        )
+
+        const options = {
+            name: generateId(),
+            type: generateId(),
+            sourceId: generateId(),
+            channelCount: this.channelNames.length,
+            channelFormat: CHANNEL_FORMATS[randomChannelIdx],
+            sampleRate: 100 * Math.random(),
+        }
+
+        this.LslStreamInfo(options)
+
+        const expected = {
+            ...options,
+            channelFormat: randomChannelIdx,
+        }
+
+        assert.isEqualDeep(
+            this.fakeLiblsl.lastCreateStreamInfoOptions,
+            expected,
+            'Should have passed options to createStreamInfo!'
+        )
+    }
+
+    @test()
+    protected static async appendsChannelsToStreamInfo() {
+        this.LslStreamInfo({ units: this.units, type: this.type })
+
+        assert.isEqualDeep(
+            this.fakeLiblsl.lastAppendChannelsToStreamInfoOptions,
+            {
+                info: this.instance.getStreamInfo(),
+                channels: this.channelNames.map((label: string) => ({
+                    label,
+                    unit: this.units,
+                    type: this.type,
+                })),
+            },
+            'Should have called appendChannelsToStreamInfo!'
+        )
+    }
+
+    private static LslStreamInfo(options?: Partial<StreamInfoOptions>) {
+        return LslStreamInfo.Create({
+            ...this.defaultOptions,
+            ...options,
+        }) as SpyLslStreamInfo
+    }
+
+    private static readonly defaultOptions = {
+        name: generateId(),
+        type: generateId(),
+        sourceId: generateId(),
+        channelNames: this.channelNames,
+        channelFormat: 'float32',
+        sampleRate: 100 * Math.random(),
+    } as StreamInfoOptions
+}

package/src/__tests__/{behavioral/TimeMarkerOutlet.test.ts → TimeMarkerOutlet.test.ts}

@@ -1,25 +1,20 @@
 import { randomInt } from 'crypto'
-import AbstractSpruceTest, {
-    assert,
-    generateId,
-    test,
-} from '@sprucelabs/test-utils'
-import LiblslImpl from '../../implementations/Liblsl'
-import { LslOutletOptions } from '../../implementations/LslOutlet'
-import TimeMarkerOutletImpl from '../../implementations/TimeMarkerOutlet'
-import FakeLiblsl from '../../testDoubles/FakeLiblsl'
-import SpyTimeMarkerOutlet from '../../testDoubles/SpyTimeMarkerOutlet'
-import generateRandomOutletOptions from '../support/generateRandomOutletOptions'
-
-export default class TimeMarkerOutletTest extends AbstractSpruceTest {
-    private static fakeLiblsl: FakeLiblsl
+import { assert, generateId, test } from '@sprucelabs/test-utils'
+import { LslOutletOptions } from '../components/LslOutlet'
+import TimeMarkerOutletImpl from '../components/TimeMarkerOutlet'
+import generateRandomOutletOptions from '../testDoubles/generateRandomOutletOptions'
+import SpyTimeMarkerOutlet from '../testDoubles/SpyTimeMarkerOutlet'
+import AbstractNodeLslTest from './AbstractNodeLslTest'
+
+export default class TimeMarkerOutletTest extends AbstractNodeLslTest {
     private static outlet: SpyTimeMarkerOutlet
 
     protected static async beforeEach() {
         await super.beforeEach()
-        TimeMarkerOutletImpl.Class = SpyTimeMarkerOutlet
-        this.fakeLiblsl = new FakeLiblsl()
-        LiblslImpl.setInstance(this.fakeLiblsl)
+
+        this.setSpyTimeMarkerOutlet()
+        this.setFakeLiblsl()
+
         this.outlet = await this.Outlet()
     }
 

package/src/{implementations → components}/Liblsl.ts

@@ -10,6 +10,8 @@ import {
     DestroyOutletOptions,
     PushSampleFloatTimestampOptions,
     PushSampleStringTimestampOptions,
+    CreateInletOptions,
+    DestroyInletOptions,
 } from '../nodeLsl.types'
 
 export default class LiblslImpl implements Liblsl {
@@ -80,6 +82,16 @@ export default class LiblslImpl implements Liblsl {
                 retType: DataType.Void,
                 paramsType: [DataType.External],
             },
+            lsl_create_inlet: {
+                library: 'lsl',
+                retType: DataType.External,
+                paramsType: [DataType.External, DataType.I32, DataType.I32],
+            },
+            lsl_destroy_inlet: {
+                library: 'lsl',
+                retType: DataType.Void,
+                paramsType: [DataType.External],
+            },
             lsl_local_clock: {
                 library: 'lsl',
                 retType: DataType.Double,
@@ -182,11 +194,6 @@ export default class LiblslImpl implements Liblsl {
         return this.bindings.lsl_create_outlet([info, chunkSize, maxBuffered])
     }
 
-    public destroyOutlet(options: DestroyOutletOptions) {
-        const { outlet } = assertOptions(options, ['outlet'])
-        this.bindings.lsl_destroy_outlet([outlet])
-    }
-
     public pushSampleFloatTimestamp(options: PushSampleFloatTimestampOptions) {
         const { outlet, sample, timestamp } = assertOptions(options, [
             'outlet',
@@ -207,6 +214,23 @@ export default class LiblslImpl implements Liblsl {
         this.bindings.lsl_push_sample_strt([outlet, sample, timestamp])
     }
 
+    public destroyOutlet(options: DestroyOutletOptions) {
+        const { outlet } = assertOptions(options, ['outlet'])
+        this.bindings.lsl_destroy_outlet([outlet])
+    }
+
+    public createInlet(options: CreateInletOptions) {
+        const { info, chunkSize, maxBuffered } = assertOptions(options, [
+            'info',
+            'chunkSize',
+            'maxBuffered',
+        ])
+
+        return this.bindings.lsl_create_inlet([info, chunkSize, maxBuffered])
+    }
+
+    public destroyInlet(_options: DestroyInletOptions) {}
+
     public localClock() {
         return this.bindings.lsl_local_clock([])
     }

package/src/components/LslInlet.ts

@@ -0,0 +1,85 @@
+import { assertOptions } from '@sprucelabs/schema'
+import { generateId } from '@sprucelabs/test-utils'
+import { ChannelFormat } from '../nodeLsl.types'
+import LiblslImpl from './Liblsl'
+import LslStreamInfo, { StreamInfo, StreamInfoOptions } from './LslStreamInfo'
+
+export default class LslInlet implements StreamInlet {
+    public static Class?: LslInletConstructor
+
+    protected name: string
+    protected info: StreamInfo
+    private chunkSize: number
+    private maxBuffered: number
+
+    protected constructor(info: StreamInfo, options: LslInletOptions) {
+        const {
+            name = this.defaultName,
+            chunkSize,
+            maxBuffered,
+        } = options ?? {}
+
+        this.info = info
+        this.chunkSize = chunkSize
+        this.maxBuffered = maxBuffered
+        this.name = name
+
+        this.createLslInlet()
+    }
+
+    public static Create(options: LslInletOptions) {
+        assertOptions(options, [
+            'channelNames',
+            'channelFormat',
+            'sampleRate',
+            'chunkSize',
+            'maxBuffered',
+        ])
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        const { maxBuffered, chunkSize, ...streamInfoOptions } = options
+        const info = this.LslStreamInfo(streamInfoOptions)
+        return new (this.Class ?? this)(info, options)
+    }
+
+    private createLslInlet() {
+        this.lsl.createInlet({
+            info: this.boundStreamInfo,
+            chunkSize: this.chunkSize,
+            maxBuffered: this.maxBuffered,
+        })
+    }
+
+    private get boundStreamInfo() {
+        return this.info.boundStreamInfo
+    }
+
+    private get lsl() {
+        return LiblslImpl.getInstance()
+    }
+
+    private readonly defaultName = `lsl-inlet-${generateId()}`
+
+    private static LslStreamInfo(options: StreamInfoOptions) {
+        return LslStreamInfo.Create(options)
+    }
+}
+
+export interface StreamInlet {}
+
+export type LslInletConstructor = new (
+    info: StreamInfo,
+    options: LslInletOptions
+) => StreamInlet
+
+export interface LslInletOptions {
+    sampleRate: number
+    channelNames: string[]
+    channelFormat: ChannelFormat
+    chunkSize: number
+    maxBuffered: number
+    name?: string
+    type?: string
+    sourceId?: string
+    manufacturer?: string
+    units?: string
+}

package/src/{implementations → components}/LslOutlet.ts

@@ -6,90 +6,82 @@ import {
     assertValidMaxBuffered,
     assertValidSampleRate,
 } from '../assertions'
-import { CHANNEL_FORMATS_MAP } from '../consts'
-import {
-    ChannelFormat,
-    BoundOutlet,
-    BoundStreamInfo,
-    Liblsl,
-    LslSample,
-} from '../nodeLsl.types'
+import { ChannelFormat, BoundOutlet, Liblsl, LslSample } from '../nodeLsl.types'
 import LiblslImpl from './Liblsl'
+import LslStreamInfo, { StreamInfo, StreamInfoOptions } from './LslStreamInfo'
 
 export default class LslOutletImpl implements LslOutlet {
     public static Class?: LslOutletConstructor
 
+    private info: StreamInfo
     private options: LslOutletOptions
-    private streamInfo: BoundStreamInfo
-    private outlet: BoundOutlet
-    private pushSampleByType: (options: any) => void
+    private outlet!: BoundOutlet
+    private pushSampleByType!: (options: any) => void
+
+    protected constructor(info: StreamInfo, options: LslOutletOptions) {
+        this.info = info
+        this.options = options
+
+        this.validateOptions()
+        this.createLslOutlet()
+        this.setPushSampleType()
+    }
 
-    protected constructor(options: LslOutletOptions) {
-        const { sampleRate, channelFormat } = assertOptions(options, [
+    public static async Create(options: LslOutletOptions) {
+        assertOptions(options, [
             'name',
             'type',
+            'sourceId',
             'channelNames',
-            'sampleRate',
             'channelFormat',
-            'sourceId',
-            'manufacturer',
-            'unit',
+            'sampleRate',
             'chunkSize',
             'maxBuffered',
+            'manufacturer',
+            'unit',
         ])
 
-        this.options = options
-
-        const { chunkSize, maxBuffered, channelNames, ...streamInfoOptions } =
-            this.options as any
+        const { waitAfterConstructionMs = 10 } = options ?? {}
 
-        const channelCount = channelNames.length
+        const streamInfoOptions = {
+            channelNames: options.channelNames,
+            channelFormat: options.channelFormat,
+            sampleRate: options.sampleRate,
+            name: options.name,
+            type: options.type,
+            sourceId: options.sourceId,
+            units: options.unit,
+        }
 
-        assertValidChannelCount(channelCount)
-        assertValidSampleRate(sampleRate)
-        assertValidChannelFormat(channelFormat)
-        assertValidChunkSize(chunkSize)
-        assertValidMaxBuffered(maxBuffered)
+        const info = this.LslStreamInfo(streamInfoOptions)
+        const instance = new (this.Class ?? this)(info, options)
 
-        delete streamInfoOptions.manufacturer
-        delete streamInfoOptions.unit
+        await this.wait(waitAfterConstructionMs)
 
-        this.streamInfo = this.lsl.createStreamInfo({
-            ...streamInfoOptions,
-            channelCount,
-            channelFormat: this.lookupChannelFormat(channelFormat),
-        })
+        return instance
+    }
 
-        this.lsl.appendChannelsToStreamInfo({
-            info: this.streamInfo,
-            channels: channelNames.map((label: string) => ({
-                label,
-                unit: this.options.unit,
-                type: this.options.type,
-            })),
-        })
+    private validateOptions() {
+        assertValidChannelCount(this.channelCount)
+        assertValidSampleRate(this.sampleRate)
+        assertValidChannelFormat(this.channelFormat)
+        assertValidChunkSize(this.chunkSize)
+        assertValidMaxBuffered(this.maxBuffered)
+    }
 
+    private createLslOutlet() {
         this.outlet = this.lsl.createOutlet({
-            info: this.streamInfo,
-            chunkSize: this.options.chunkSize,
-            maxBuffered: this.options.maxBuffered,
+            info: this.boundStreamInfo,
+            chunkSize: this.chunkSize,
+            maxBuffered: this.maxBuffered,
         })
+    }
 
+    private setPushSampleType() {
         const pushMethod = this.getPushMethod()
         this.pushSampleByType = this.lsl[pushMethod].bind(this.lsl)
     }
 
-    public static async Create(options: LslOutletOptions) {
-        const { waitAfterConstructionMs = 10 } = options ?? {}
-        const instance = new (this.Class ?? this)(options)
-        await this.wait(waitAfterConstructionMs)
-        return instance
-    }
-
-    private static async wait(waitMs: number) {
-        return new Promise((resolve) => setTimeout(resolve, waitMs))
-    }
-
     public destroy() {
         this.lsl.destroyOutlet({ outlet: this.outlet })
     }
@@ -105,7 +97,7 @@ export default class LslOutletImpl implements LslOutlet {
     }
 
     private getPushMethod() {
-        const channelFormat = this.options.channelFormat
+        const channelFormat = this.channelFormat
 
         const methodMap: Record<string, keyof Liblsl> = {
             float32: 'pushSampleFloatTimestamp',
@@ -120,13 +112,45 @@ export default class LslOutletImpl implements LslOutlet {
         return methodMap[channelFormat]
     }
 
-    private lookupChannelFormat(channelFormat: ChannelFormat) {
-        return CHANNEL_FORMATS_MAP[channelFormat]
+    private get channelNames() {
+        return this.options.channelNames
+    }
+
+    private get channelCount() {
+        return this.channelNames.length
+    }
+
+    private get channelFormat() {
+        return this.options.channelFormat
+    }
+
+    private get sampleRate() {
+        return this.options.sampleRate
+    }
+
+    private get chunkSize() {
+        return this.options.chunkSize
+    }
+
+    private get maxBuffered() {
+        return this.options.maxBuffered
+    }
+
+    private get boundStreamInfo() {
+        return this.info.boundStreamInfo
     }
 
     private get lsl() {
         return LiblslImpl.getInstance()
     }
+
+    private static async wait(waitMs: number) {
+        return new Promise((resolve) => setTimeout(resolve, waitMs))
+    }
+
+    private static LslStreamInfo(options: StreamInfoOptions) {
+        return LslStreamInfo.Create(options)
+    }
 }
 
 export interface LslOutlet {
@@ -134,18 +158,21 @@ export interface LslOutlet {
     pushSample(sample: LslSample): void
 }
 
-export type LslOutletConstructor = new (options: LslOutletOptions) => LslOutlet
+export type LslOutletConstructor = new (
+    info: StreamInfo,
+    options: LslOutletOptions
+) => LslOutlet
 
 export interface LslOutletOptions {
     name: string
     type: string
+    sourceId: string
     channelNames: string[]
-    sampleRate: number
     channelFormat: ChannelFormat
-    sourceId: string
-    manufacturer: string
-    unit: string
+    sampleRate: number
     chunkSize: number
     maxBuffered: number
+    manufacturer: string
+    unit: string
     waitAfterConstructionMs?: number
 }