@neurodevs/node-lsl 11.4.1 → 12.0.0

package/src/__tests__/{modules → impl}/LslStreamInlet.test.ts

@@ -1,41 +1,24 @@
-import { test, assert, errorAssert } from '@sprucelabs/test-utils'
-import LslStreamInlet, { LslInletOptions } from '../../modules/LslStreamInlet'
-import { SpyLslInlet } from '../../testDoubles/LslInlet/SpyLslInlet'
+import { test, assert } from '@sprucelabs/test-utils'
+import LslStreamInlet, { StreamInletOptions } from '../../impl/LslStreamInlet'
 import FakeStreamInfo from '../../testDoubles/StreamInfo/FakeStreamInfo'
-import AbstractLslTest from '../AbstractLslTest'
+import { SpyStreamInlet } from '../../testDoubles/StreamInlet/SpyStreamInlet'
+import AbstractPackageTest from '../AbstractPackageTest'
 
-export default class LslStreamInletTest extends AbstractLslTest {
-    private static instance: SpyLslInlet
+export default class LslStreamInletTest extends AbstractPackageTest {
+    private static instance: SpyStreamInlet
 
     protected static async beforeEach() {
         await super.beforeEach()
 
-        this.setSpyLslInlet()
+        this.setSpyStreamInlet()
         this.setFakeStreamInfo()
 
         this.instance = this.LslStreamInlet()
     }
 
     @test()
-    protected static async canCreateLslStreamInlet() {
-        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',
-            ],
-        })
+    protected static async createsInstance() {
+        assert.isTruthy(this.instance, 'Failed to create instance!')
     }
 
     @test()
@@ -66,7 +49,7 @@ export default class LslStreamInletTest extends AbstractLslTest {
     }
 
     @test()
-    protected static async callsBindingsToCreateLslInlet() {
+    protected static async callsBindingsToCreateStreamInlet() {
         const fakeInfo = this.instance.getStreamInfo()
 
         assert.isTruthy(fakeInfo, 'Should have created stream info!')
@@ -82,7 +65,7 @@ export default class LslStreamInletTest extends AbstractLslTest {
         )
     }
 
-    private static LslStreamInlet(options?: Partial<LslInletOptions>) {
+    private static LslStreamInlet(options?: Partial<StreamInletOptions>) {
         const defaultOptions = {
             channelNames: this.channelNames,
             channelFormat: 'float32',
@@ -93,7 +76,7 @@ export default class LslStreamInletTest extends AbstractLslTest {
             chunkSize: this.chunkSize,
             maxBuffered: this.maxBuffered,
             ...options,
-        } as LslInletOptions
-        return LslStreamInlet.Create(defaultOptions) as SpyLslInlet
+        } as StreamInletOptions
+        return LslStreamInlet.Create(defaultOptions) as SpyStreamInlet
     }
 }

package/src/__tests__/{modules → impl}/LslStreamOutlet.test.ts

@@ -1,8 +1,10 @@
-import { test, assert, errorAssert, generateId } from '@sprucelabs/test-utils'
-import { StreamInfo } from '../../modules/LslStreamInfo'
+import { test, assert } from '@sprucelabs/test-utils'
+import generateId from '@neurodevs/generate-id'
+import { CHANNEL_FORMATS } from '../../consts'
+import { StreamInfo } from '../../impl/LslStreamInfo'
 import LslStreamOutlet, {
-    LslOutletOptions,
-} from '../../modules/LslStreamOutlet'
+    StreamOutletOptions,
+} from '../../impl/LslStreamOutlet'
 import {
     TEST_SUPPORTED_CHANNEL_FORMATS,
     TEST_UNSUPPORTED_CHANNEL_FORMATS,
@@ -11,11 +13,11 @@ import {
 
 import generateRandomOutletOptions from '../../testDoubles/generateRandomOutletOptions'
 import FakeStreamInfo from '../../testDoubles/StreamInfo/FakeStreamInfo'
-import { LslSample } from '../../types'
-import AbstractLslTest from '../AbstractLslTest'
+import { ChannelFormat, LslSample } from '../../types'
+import AbstractPackageTest from '../AbstractPackageTest'
 
-export default class LslStreamOutletTest extends AbstractLslTest {
-    private static randomOutletOptions: LslOutletOptions
+export default class LslStreamOutletTest extends AbstractPackageTest {
+    private static randomOutletOptions: StreamOutletOptions
 
     protected static async beforeEach() {
         await super.beforeEach()
@@ -29,30 +31,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 +48,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 +212,61 @@ 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 StreamOutletOptions,
+        value: number | string[] | ChannelFormat,
+        expectedMessage: string
     ) {
         const err = await assert.doesThrowAsync(
-            async () => await this.LslStreamOutlet(options)
+            async () => await this.LslStreamOutlet({ [option]: value })
+        )
+
+        assert.isTrue(
+            err.message.includes(expectedMessage),
+            'Did not receive the expected error!'
         )
-        errorAssert.assertError(err, 'INVALID_PARAMETERS', {
-            parameters,
-        })
     }
 
     private static async StringOutlet() {
@@ -271,7 +277,9 @@ export default class LslStreamOutletTest extends AbstractLslTest {
         return await this.LslStreamOutlet({ channelFormat: 'float32' })
     }
 
-    private static async LslStreamOutlet(options?: Partial<LslOutletOptions>) {
+    private static async LslStreamOutlet(
+        options?: Partial<StreamOutletOptions>
+    ) {
         return await LslStreamOutlet.Create({
             ...this.randomOutletOptions,
             ...options,
@@ -280,7 +288,7 @@ export default class LslStreamOutletTest extends AbstractLslTest {
 }
 
 class CheckingOutlet extends LslStreamOutlet {
-    public constructor(info: StreamInfo, options: LslOutletOptions) {
+    public constructor(info: StreamInfo, options: StreamOutletOptions) {
         super(info, options)
     }
 }

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

@@ -0,0 +1,23 @@
+import AbstractSpruceTest, { test, assert } from '@sprucelabs/test-utils'
+import LslWebSocketBridge, {
+    StreamTransportBridge,
+} from '../../impl/LslWebSocketBridge'
+
+export default class LslWebSocketBridgeTest extends AbstractSpruceTest {
+    private static instance: StreamTransportBridge
+
+    protected static async beforeEach() {
+        await super.beforeEach()
+
+        this.instance = this.LslWebSocketBridge()
+    }
+
+    @test()
+    protected static async createsInstance() {
+        assert.isTruthy(this.instance, 'Failed to create instance!')
+    }
+
+    private static LslWebSocketBridge() {
+        return LslWebSocketBridge.Create()
+    }
+}

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 → impl}/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/EventMarkerOutlet.ts → impl/LslEventMarkerOutlet.ts}

@@ -1,19 +1,22 @@
 import { DurationMarker } from '../types'
-import LslStreamOutlet, { LslOutletOptions, LslOutlet } from './LslStreamOutlet'
+import LslStreamOutlet, {
+    StreamOutletOptions,
+    StreamOutlet,
+} from './LslStreamOutlet'
 
-export default class EventMarkerOutlet implements MarkerOutlet {
-    public static Class?: MarkerOutletConstructor
+export default class LslEventMarkerOutlet implements EventMarkerOutlet {
+    public static Class?: EventMarkerOutletConstructor
 
-    protected lslOutlet: LslOutlet
+    protected streamOutlet: StreamOutlet
     private isPlaying = false
     private waitResolve?: () => void
     private timeout?: any
 
-    protected constructor(lslOutlet: LslOutlet) {
-        this.lslOutlet = lslOutlet
+    protected constructor(outlet: StreamOutlet) {
+        this.streamOutlet = outlet
     }
 
-    public static async Create(options?: Partial<LslOutletOptions>) {
+    public static async Create(options?: Partial<StreamOutletOptions>) {
         const defaultOptions = {
             name: 'Event markers',
             type: 'Markers',
@@ -25,7 +28,7 @@ export default class EventMarkerOutlet implements MarkerOutlet {
             unit: 'N/A',
             chunkSize: 0,
             maxBuffered: 0,
-        } as LslOutletOptions
+        } as StreamOutletOptions
 
         const outlet = await LslStreamOutlet.Create({
             ...defaultOptions,
@@ -55,7 +58,7 @@ export default class EventMarkerOutlet implements MarkerOutlet {
     }
 
     private pushMarkerToOutlet(markerName: string) {
-        this.lslOutlet.pushSample([markerName])
+        this.streamOutlet.pushSample([markerName])
     }
 
     protected async wait(durationMs: number) {
@@ -74,10 +77,12 @@ export default class EventMarkerOutlet implements MarkerOutlet {
     }
 }
 
-export interface MarkerOutlet {
+export interface EventMarkerOutlet {
     pushMarker(markerName: string): void
     pushMarkers(markers: DurationMarker[]): Promise<void>
     stop(): void
 }
 
-export type MarkerOutletConstructor = new (lslOutlet: LslOutlet) => MarkerOutlet
+export type EventMarkerOutletConstructor = new (
+    outlet: StreamOutlet
+) => EventMarkerOutlet

package/src/{modules → impl}/LslStreamInfo.ts

@@ -1,5 +1,4 @@
-import { assertOptions } from '@sprucelabs/schema'
-import { generateId } from '@sprucelabs/test-utils'
+import generateId from '@neurodevs/generate-id'
 import { CHANNEL_FORMATS_MAP } from '../consts'
 import { BoundStreamInfo, ChannelFormat } from '../types'
 import LiblslAdapter from './LiblslAdapter'
@@ -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 → impl}/LslStreamInlet.ts

@@ -1,18 +1,17 @@
-import { assertOptions } from '@sprucelabs/schema'
-import { generateId } from '@sprucelabs/test-utils'
+import generateId from '@neurodevs/generate-id'
 import { ChannelFormat } from '../types'
 import LiblslAdapter from './LiblslAdapter'
 import LslStreamInfo, { StreamInfo, StreamInfoOptions } from './LslStreamInfo'
 
-export default class LslStreamInlet implements LslInlet {
-    public static Class?: LslInletConstructor
+export default class LslStreamInlet implements StreamInlet {
+    public static Class?: StreamInletConstructor
 
     protected name: string
     protected info: StreamInfo
     private chunkSize: number
     private maxBuffered: number
 
-    protected constructor(info: StreamInfo, options: LslInletOptions) {
+    protected constructor(info: StreamInfo, options: StreamInletOptions) {
         const {
             name = this.defaultName,
             chunkSize,
@@ -24,24 +23,17 @@ export default class LslStreamInlet implements LslInlet {
         this.maxBuffered = maxBuffered
         this.name = name
 
-        this.createLslInlet()
+        this.createStreamInlet()
     }
 
-    public static Create(options: LslInletOptions) {
-        assertOptions(options, [
-            'channelNames',
-            'channelFormat',
-            'sampleRate',
-            'chunkSize',
-            'maxBuffered',
-        ])
+    public static Create(options: StreamInletOptions) {
         // 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)
     }
 
-    private createLslInlet() {
+    private createStreamInlet() {
         this.lsl.createInlet({
             info: this.boundStreamInfo,
             chunkSize: this.chunkSize,
@@ -64,14 +56,14 @@ export default class LslStreamInlet implements LslInlet {
     }
 }
 
-export interface LslInlet {}
+export interface StreamInlet {}
 
-export type LslInletConstructor = new (
+export type StreamInletConstructor = new (
     info: StreamInfo,
-    options: LslInletOptions
-) => LslInlet
+    options: StreamInletOptions
+) => StreamInlet
 
-export interface LslInletOptions {
+export interface StreamInletOptions {
     sampleRate: number
     channelNames: string[]
     channelFormat: ChannelFormat