@neurodevs/node-lsl 11.4.0 → 11.4.2

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

@@ -1,5 +1,5 @@
 import { randomInt } from 'crypto'
-import { test, assert, errorAssert, generateId } from '@sprucelabs/test-utils'
+import { test, assert, generateId } from '@sprucelabs/test-utils'
 import { DataType, OpenParams } from 'ffi-rs'
 import LiblslAdapter from '../../modules/LiblslAdapter'
 import FakeLiblsl from '../../testDoubles/Liblsl/FakeLiblsl'
@@ -94,9 +94,13 @@ export default class LiblslAdapterTest extends AbstractLslTest {
         LiblslAdapter.resetInstance()
 
         const err = assert.doesThrow(() => LiblslAdapter.getInstance())
-        errorAssert.assertError(err, 'FAILED_TO_LOAD_LIBLSL', {
-            liblslPath: process.env.LIBLSL_PATH,
-        })
+
+        debugger
+
+        assert.isTrue(
+            err.message.includes(this.generateFailedMessage()),
+            'Did not receive the expected error!'
+        )
     }
 
     @test()
@@ -107,60 +111,6 @@ export default class LiblslAdapterTest extends AbstractLslTest {
         })
     }
 
-    @test()
-    protected static throwsWhenCreateStreamInfoIsMissingRequiredParams() {
-        //@ts-ignore
-        const err = assert.doesThrow(() => this.lsl.createStreamInfo())
-        errorAssert.assertError(err, 'MISSING_PARAMETERS', {
-            parameters: [
-                'name',
-                'type',
-                'channelCount',
-                'sampleRate',
-                'channelFormat',
-                'sourceId',
-            ],
-        })
-    }
-
-    @test()
-    protected static async throwsWhenAppendChannelsIsMissingRequiredParams() {
-        const err = assert.doesThrow(() =>
-            //@ts-ignore
-            this.lsl.appendChannelsToStreamInfo({})
-        )
-        errorAssert.assertError(err, 'MISSING_PARAMETERS', {
-            parameters: ['info', 'channels'],
-        })
-    }
-
-    @test()
-    protected static async throwsWhenCreateOutletIsMissingRequiredParams() {
-        //@ts-ignore
-        const err = assert.doesThrow(() => this.lsl.createOutlet({}))
-        errorAssert.assertError(err, 'MISSING_PARAMETERS', {
-            parameters: ['info', 'chunkSize', 'maxBuffered'],
-        })
-    }
-
-    @test()
-    protected static async throwsWhenPushSampleFloatTimestampIsMissingRequiredParams() {
-        //@ts-ignore
-        const err = assert.doesThrow(() => this.lsl.pushSampleFloatTimestamp())
-        errorAssert.assertError(err, 'MISSING_PARAMETERS', {
-            parameters: ['outlet', 'sample', 'timestamp'],
-        })
-    }
-
-    @test()
-    protected static async throwsWhenPushSampleStringTimestampIsMissingRequiredParams() {
-        //@ts-ignore
-        const err = assert.doesThrow(() => this.lsl.pushSampleFloatTimestamp())
-        errorAssert.assertError(err, 'MISSING_PARAMETERS', {
-            parameters: ['outlet', 'sample', 'timestamp'],
-        })
-    }
-
     @test()
     protected static async worksAsASingleton() {
         const liblsl = LiblslAdapter.getInstance()
@@ -461,6 +411,10 @@ export default class LiblslAdapterTest extends AbstractLslTest {
         }
     }
 
+    private static generateFailedMessage() {
+        return `Loading the liblsl dylib failed! I tried to load it from ${process.env.LIBLSL_PATH}.`
+    }
+
     private static FakeBindings() {
         return {
             lsl_create_streaminfo: (params: any[]) => {

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

@@ -1,4 +1,4 @@
-import { test, assert, generateId, errorAssert } from '@sprucelabs/test-utils'
+import { test, assert, generateId } from '@sprucelabs/test-utils'
 import { CHANNEL_FORMATS } from '../../consts'
 import LslStreamInfo, { StreamInfoOptions } from '../../modules/LslStreamInfo'
 import SpyStreamInfo from '../../testDoubles/StreamInfo/SpyStreamInfo'
@@ -20,17 +20,6 @@ export default class LslStreamInfoTest extends AbstractLslTest {
         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 })

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

@@ -1,4 +1,4 @@
-import { test, assert, errorAssert } from '@sprucelabs/test-utils'
+import { test, assert } from '@sprucelabs/test-utils'
 import LslStreamInlet, { LslInletOptions } from '../../modules/LslStreamInlet'
 import { SpyLslInlet } from '../../testDoubles/LslInlet/SpyLslInlet'
 import FakeStreamInfo from '../../testDoubles/StreamInfo/FakeStreamInfo'
@@ -21,23 +21,6 @@ export default class LslStreamInletTest extends AbstractLslTest {
         assert.isTruthy(this.instance, 'Instance should be created!')
     }
 
-    @test()
-    protected static async throwsWithMissingRequiredOptions() {
-        const err = assert.doesThrow(
-            // @ts-ignore
-            () => LslStreamInlet.Create()
-        )
-        errorAssert.assertError(err, 'MISSING_PARAMETERS', {
-            parameters: [
-                'channelNames',
-                'channelFormat',
-                'sampleRate',
-                'chunkSize',
-                'maxBuffered',
-            ],
-        })
-    }
-
     @test()
     protected static async createsStreamInfoWithExpectedOptions() {
         assert.isEqualDeep(

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

@@ -1,4 +1,5 @@
-import { test, assert, errorAssert, generateId } from '@sprucelabs/test-utils'
+import { test, assert, generateId } from '@sprucelabs/test-utils'
+import { CHANNEL_FORMATS } from '../../consts'
 import { StreamInfo } from '../../modules/LslStreamInfo'
 import LslStreamOutlet, {
     LslOutletOptions,
@@ -11,7 +12,7 @@ import {
 
 import generateRandomOutletOptions from '../../testDoubles/generateRandomOutletOptions'
 import FakeStreamInfo from '../../testDoubles/StreamInfo/FakeStreamInfo'
-import { LslSample } from '../../types'
+import { ChannelFormat, LslSample } from '../../types'
 import AbstractLslTest from '../AbstractLslTest'
 
 export default class LslStreamOutletTest extends AbstractLslTest {
@@ -29,30 +30,8 @@ export default class LslStreamOutletTest extends AbstractLslTest {
     }
 
     @test()
-    protected static async throwsWithMissingRequiredParams() {
-        const err = await assert.doesThrowAsync(
-            //@ts-ignore
-            async () => await LslStreamOutlet.Create()
-        )
-        errorAssert.assertError(err, 'MISSING_PARAMETERS', {
-            parameters: [
-                'name',
-                'type',
-                'sourceId',
-                'channelNames',
-                'channelFormat',
-                'sampleRate',
-                'chunkSize',
-                'maxBuffered',
-                'manufacturer',
-                'unit',
-            ],
-        })
-    }
-
-    @test()
-    protected static async throwsWithInvalidChannelNames() {
-        await this.assertThrowsInvalidChannelNames(0)
+    protected static async throwsWithEmptyChannelNames() {
+        await this.assertThrowsWithEmptyChannelNames()
     }
 
     @test()
@@ -68,24 +47,30 @@ export default class LslStreamOutletTest extends AbstractLslTest {
 
     @test()
     protected static async throwsWithInvalidChannelFormat() {
-        await this.assertDoesThrowInvalidParameters(
-            //@ts-ignore
-            { channelFormat: generateId() },
-            ['channelFormat']
+        await this.assertThrowsInvalidChannelFormat(
+            'invalid-format' as ChannelFormat
         )
     }
 
     @test()
-    protected static async throwsWithInvalidChunkSize() {
+    protected static async allowsZeroChunkSize() {
         await this.LslStreamOutlet({ chunkSize: 0 })
+    }
+
+    @test()
+    protected static async throwsWithInvalidChunkSize() {
         await this.assertThrowsInvalidChunkSize(-1)
         await this.assertThrowsInvalidChunkSize(-1.5)
         await this.assertThrowsInvalidChunkSize(1.5)
     }
 
     @test()
-    protected static async throwsWithInvalidMaxBuffered() {
+    protected static async allowsZeroMaxBuffered() {
         await this.LslStreamOutlet({ maxBuffered: 0 })
+    }
+
+    @test()
+    protected static async throwsWithInvalidMaxBuffered() {
         await this.assertThrowsInvalidMaxBuffered(-1)
         await this.assertThrowsInvalidMaxBuffered(-1.5)
         await this.assertThrowsInvalidMaxBuffered(1.5)
@@ -226,41 +211,57 @@ export default class LslStreamOutletTest extends AbstractLslTest {
         assert.isAbove(endMs - startMs, 10)
     }
 
-    private static async assertThrowsInvalidMaxBuffered(maxBuffered: number) {
-        await this.assertDoesThrowInvalidParameters({ maxBuffered }, [
-            'maxBuffered',
-        ])
-    }
-
-    private static async assertThrowsInvalidChunkSize(chunkSize: number) {
-        await this.assertDoesThrowInvalidParameters({ chunkSize }, [
-            'chunkSize',
-        ])
+    private static async assertThrowsWithEmptyChannelNames() {
+        await this.createAndAssertThrows(
+            'channelNames',
+            [],
+            `Invalid channel count! Must be a positive integer, not: 0.`
+        )
     }
 
     private static async assertThrowsInvalidSampleRate(sampleRate: number) {
-        await this.assertDoesThrowInvalidParameters({ sampleRate }, [
+        await this.createAndAssertThrows(
             'sampleRate',
-        ])
+            sampleRate,
+            `Invalid sample rate! Must be a positive number or zero, not: ${sampleRate}`
+        )
+    }
+
+    private static async assertThrowsInvalidChannelFormat(
+        channelFormat: ChannelFormat
+    ) {
+        await this.createAndAssertThrows(
+            'channelFormat',
+            channelFormat,
+            `Invalid channel format! Must be one of: ${CHANNEL_FORMATS.join(', ')}, not ${channelFormat}.`
+        )
     }
 
-    private static async assertThrowsInvalidChannelNames(count: number) {
-        await this.assertDoesThrowInvalidParameters(
-            { channelNames: new Array(count).fill(generateId()) },
-            ['channelNames']
+    private static async assertThrowsInvalidMaxBuffered(maxBuffered: number) {
+        await this.createAndAssertThrows(
+            'maxBuffered',
+            maxBuffered,
+            `Invalid max buffered! Must be a positive integer or zero, not: ${maxBuffered}`
         )
     }
 
-    private static async assertDoesThrowInvalidParameters(
-        options: Partial<LslOutletOptions>,
-        parameters: string[]
+    private static async assertThrowsInvalidChunkSize(chunkSize: number) {
+        await this.createAndAssertThrows(
+            'chunkSize',
+            chunkSize,
+            `Invalid chunk size! Must be a positive integer or zero, not: ${chunkSize}`
+        )
+    }
+
+    private static async createAndAssertThrows(
+        option: keyof LslOutletOptions,
+        value: number | string[] | ChannelFormat,
+        expectedMessage: string
     ) {
         const err = await assert.doesThrowAsync(
-            async () => await this.LslStreamOutlet(options)
+            async () => await this.LslStreamOutlet({ [option]: value })
         )
-        errorAssert.assertError(err, 'INVALID_PARAMETERS', {
-            parameters,
-        })
+        assert.isTrue(err.message.includes(expectedMessage))
     }
 
     private static async StringOutlet() {

package/src/assertions.ts

@@ -1,4 +1,3 @@
-import { SchemaError } from '@sprucelabs/schema'
 import { CHANNEL_FORMATS } from './consts'
 import { ChannelFormat } from './types'
 import {
@@ -8,52 +7,42 @@ import {
     isStringInArray,
 } from './validations'
 
-export function assertValidMaxBuffered(maxBuffered: number) {
-    if (!isPositiveIntegerOrZero(maxBuffered)) {
-        throw new SchemaError({
-            code: 'INVALID_PARAMETERS',
-            parameters: ['maxBuffered'],
-            friendlyMessage: 'Max buffered must be a positive integer or zero.',
-        })
+export function assertValidChunkSize(chunkSize: number) {
+    if (!isPositiveIntegerOrZero(chunkSize)) {
+        throw new Error(
+            `Invalid chunk size! Must be a positive integer or zero, not: ${chunkSize}.`
+        )
     }
 }
 
-export function assertValidChunkSize(chunkSize: number) {
-    if (!isPositiveIntegerOrZero(chunkSize)) {
-        throw new SchemaError({
-            code: 'INVALID_PARAMETERS',
-            parameters: ['chunkSize'],
-            friendlyMessage: 'Chunk size must be a positive integer or zero.',
-        })
+export function assertValidMaxBuffered(maxBuffered: number) {
+    if (!isPositiveIntegerOrZero(maxBuffered)) {
+        throw new Error(
+            `Invalid max buffered! Must be a positive integer or zero, not: ${maxBuffered}.`
+        )
     }
 }
 
 export function assertValidChannelFormat(channelFormat: ChannelFormat) {
     if (!isStringInArray(channelFormat, CHANNEL_FORMATS)) {
-        throw new SchemaError({
-            code: 'INVALID_PARAMETERS',
-            parameters: ['channelFormat'],
-            friendlyMessage: `Invalid `,
-        })
+        throw new Error(
+            `Invalid channel format! Must be one of: ${CHANNEL_FORMATS.join(', ')}, not ${channelFormat}.`
+        )
     }
 }
 
 export function assertValidSampleRate(sampleRate: number) {
     if (!isGreaterThanOrEqualToZero(sampleRate)) {
-        throw new SchemaError({
-            code: 'INVALID_PARAMETERS',
-            parameters: ['sampleRate'],
-            friendlyMessage: 'Sample rate must be a positive number or zero.',
-        })
+        throw new Error(
+            `Invalid sample rate! Must be a positive number or zero, not: ${sampleRate}.`
+        )
     }
 }
 
 export function assertValidChannelCount(channelCount: number) {
     if (!isPositiveInteger(channelCount)) {
-        throw new SchemaError({
-            code: 'INVALID_PARAMETERS',
-            parameters: ['channelNames'],
-            friendlyMessage: 'channelNames must have 1 or more labels.',
-        })
+        throw new Error(
+            `Invalid channel count! Must be a positive integer, not: ${channelCount}.`
+        )
     }
 }

package/src/modules/LiblslAdapter.ts

@@ -1,6 +1,4 @@
-import { assertOptions } from '@sprucelabs/schema'
 import { DataType, define, open } from 'ffi-rs'
-import SpruceError from '../errors/SpruceError'
 import {
     Liblsl,
     LiblslBindings,
@@ -15,29 +13,30 @@ import {
 } from '../types'
 
 export default class LiblslAdapter implements Liblsl {
-    private static instance?: Liblsl
     public static ffiRsOpen = open
     public static ffiRsDefine = define
+    private static instance?: Liblsl
 
+    private path: string
     private bindings!: LiblslBindings
 
     protected constructor() {
-        const path = process.env.LIBLSL_PATH! ?? this.defaultMacOsPath
-        this.tryToLoadBindings(path)
+        this.path = process.env.LIBLSL_PATH! ?? this.defaultMacOsPath
+        this.tryToLoadBindings()
     }
 
-    private tryToLoadBindings(path: string) {
+    private tryToLoadBindings() {
         try {
-            this.bindings = this.loadBindings(path)
+            this.bindings = this.loadBindings(this.path)
         } catch (error) {
-            throw new SpruceError({
-                code: 'FAILED_TO_LOAD_LIBLSL',
-                liblslPath: path,
-                originalError: error as any,
-            })
+            throw new Error(this.generateFailedMessage(error as Error))
         }
     }
 
+    private generateFailedMessage(error: Error) {
+        return `Loading the liblsl dylib failed! I tried to load it from ${this.path}.\n\n${error.message}\n\n`
+    }
+
     public static getInstance() {
         if (!this.instance) {
             this.setInstance(new this())
@@ -145,14 +144,7 @@ export default class LiblslAdapter implements Liblsl {
             sampleRate,
             channelFormat,
             sourceId,
-        } = assertOptions(options, [
-            'name',
-            'type',
-            'channelCount',
-            'sampleRate',
-            'channelFormat',
-            'sourceId',
-        ])
+        } = options
 
         return this.bindings.lsl_create_streaminfo([
             name,
@@ -167,7 +159,7 @@ export default class LiblslAdapter implements Liblsl {
     public appendChannelsToStreamInfo(
         options: AppendChannelsToStreamInfoOptions
     ) {
-        const { info, channels } = assertOptions(options, ['info', 'channels'])
+        const { info, channels } = options
 
         const description = this.bindings.lsl_get_desc([info])
         const parent = this.bindings.lsl_append_child([description, 'channels'])
@@ -185,47 +177,29 @@ export default class LiblslAdapter implements Liblsl {
     }
 
     public createOutlet(options: CreateOutletOptions) {
-        const { info, chunkSize, maxBuffered } = assertOptions(options, [
-            'info',
-            'chunkSize',
-            'maxBuffered',
-        ])
-
+        const { info, chunkSize, maxBuffered } = options
         return this.bindings.lsl_create_outlet([info, chunkSize, maxBuffered])
     }
 
     public pushSampleFloatTimestamp(options: PushSampleFloatTimestampOptions) {
-        const { outlet, sample, timestamp } = assertOptions(options, [
-            'outlet',
-            'sample',
-            'timestamp',
-        ])
+        const { outlet, sample, timestamp } = options
         this.bindings.lsl_push_sample_ft([outlet, sample, timestamp])
     }
 
     public pushSampleStringTimestamp(
         options: PushSampleStringTimestampOptions
     ) {
-        const { outlet, sample, timestamp } = assertOptions(options, [
-            'outlet',
-            'sample',
-            'timestamp',
-        ])
+        const { outlet, sample, timestamp } = options
         this.bindings.lsl_push_sample_strt([outlet, sample, timestamp])
     }
 
     public destroyOutlet(options: DestroyOutletOptions) {
-        const { outlet } = assertOptions(options, ['outlet'])
+        const { outlet } = options
         this.bindings.lsl_destroy_outlet([outlet])
     }
 
     public createInlet(options: CreateInletOptions) {
-        const { info, chunkSize, maxBuffered } = assertOptions(options, [
-            'info',
-            'chunkSize',
-            'maxBuffered',
-        ])
-
+        const { info, chunkSize, maxBuffered } = options
         return this.bindings.lsl_create_inlet([info, chunkSize, maxBuffered])
     }
 

package/src/modules/LslStreamInfo.ts

@@ -1,4 +1,3 @@
-import { assertOptions } from '@sprucelabs/schema'
 import { generateId } from '@sprucelabs/test-utils'
 import { CHANNEL_FORMATS_MAP } from '../consts'
 import { BoundStreamInfo, ChannelFormat } from '../types'
@@ -40,7 +39,6 @@ export default class LslStreamInfo implements StreamInfo {
     }
 
     public static Create(options: StreamInfoOptions) {
-        assertOptions(options, ['channelNames', 'channelFormat', 'sampleRate'])
         return new (this.Class ?? this)(options)
     }
 

package/src/modules/LslStreamInlet.ts

@@ -1,4 +1,3 @@
-import { assertOptions } from '@sprucelabs/schema'
 import { generateId } from '@sprucelabs/test-utils'
 import { ChannelFormat } from '../types'
 import LiblslAdapter from './LiblslAdapter'
@@ -28,16 +27,9 @@ export default class LslStreamInlet implements LslInlet {
     }
 
     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)
+        const { maxBuffered, chunkSize, ...infoOptions } = options
+        const info = this.LslStreamInfo(infoOptions)
         return new (this.Class ?? this)(info, options)
     }
 

package/src/modules/LslStreamOutlet.ts

@@ -1,4 +1,3 @@
-import { assertOptions } from '@sprucelabs/schema'
 import {
     assertValidChannelCount,
     assertValidChannelFormat,
@@ -28,19 +27,6 @@ export default class LslStreamOutlet implements LslOutlet {
     }
 
     public static async Create(options: LslOutletOptions) {
-        assertOptions(options, [
-            'name',
-            'type',
-            'sourceId',
-            'channelNames',
-            'channelFormat',
-            'sampleRate',
-            'chunkSize',
-            'maxBuffered',
-            'manufacturer',
-            'unit',
-        ])
-
         const { waitAfterConstructionMs = 10 } = options ?? {}
 
         const streamInfoOptions = {

package/src/scripts/demoMarkerOutlet.ts

@@ -0,0 +1,23 @@
+import EventMarkerOutlet from '../modules/EventMarkerOutlet'
+
+async function main() {
+    const outlet = await EventMarkerOutlet.Create()
+
+    const markers = [
+        { name: 'phase-1-begin', durationMs: 100 },
+        { name: 'phase-1-end', durationMs: 10 },
+    ]
+
+    // Hangs until complete
+    await outlet.pushMarkers(markers)
+
+    // Void promise, does not hang
+    void outlet.pushMarkers(markers)
+
+    // Interrupts the above pushMarkers process
+    outlet.stop()
+}
+
+main().catch((error) => {
+    console.error('Error in main:', error)
+})

package/src/scripts/demoStreamOutlet.ts

@@ -0,0 +1,22 @@
+import LslStreamOutlet from '../modules/LslStreamOutlet'
+
+async function main() {
+    const instance = await LslStreamOutlet.Create({
+        name: 'Muse S (2nd gen)',
+        type: 'EEG',
+        channelNames: ['TP9', 'AF7', 'AF8', 'TP10', 'AUX'],
+        sampleRate: 256,
+        channelFormat: 'float32',
+        sourceId: 'muse-s-eeg',
+        manufacturer: 'Interaxon Inc.',
+        unit: 'microvolt',
+        chunkSize: 12,
+        maxBuffered: 360,
+    })
+
+    instance.pushSample([1, 2, 3, 4, 5])
+}
+
+main().catch((error) => {
+    console.error('Error in main:', error)
+})