@neurodevs/node-lsl 10.2.2 → 11.0.0

package/src/__tests__/EventMarkerOutlet.test.ts

@@ -0,0 +1,165 @@
+import { randomInt } from 'crypto'
+import { assert, generateId, test } from '@sprucelabs/test-utils'
+import EventMarkerOutlet from '../components/EventMarkerOutlet'
+import { LslOutletOptions } from '../components/LslStreamOutlet'
+import generateRandomOutletOptions from '../testDoubles/generateRandomOutletOptions'
+import FakeLslOutlet from '../testDoubles/LslOutlet/FakeLslOutlet'
+import SpyMarkerOutlet from '../testDoubles/MarkerOutlet/SpyMarkerOutlet'
+import AbstractLslTest from './AbstractLslTest'
+
+export default class EventMarkerOutletTest extends AbstractLslTest {
+    private static instance: SpyMarkerOutlet
+
+    protected static async beforeEach() {
+        await super.beforeEach()
+
+        this.setFakeLiblsl()
+        this.setFakeLslOutlet()
+        this.setSpyMarkerOutlet()
+
+        this.instance = await this.EventMarkerOutlet()
+    }
+
+    @test()
+    protected static async loadsWithEventMarkerSpecificOptions() {
+        assert.isEqualDeep(FakeLslOutlet.callsToConstructor[0].options, {
+            name: 'Event markers',
+            type: 'Markers',
+            channelNames: ['Markers'],
+            sampleRate: 0,
+            channelFormat: 'string',
+            sourceId: 'event-markers',
+            manufacturer: 'N/A',
+            unit: 'N/A',
+            chunkSize: 0,
+            maxBuffered: 0,
+        })
+    }
+
+    @test()
+    protected static async canOverrideDefaultOptions() {
+        const options = generateRandomOutletOptions()
+        await this.EventMarkerOutlet(options)
+
+        assert.isEqualDeep(FakeLslOutlet.callsToConstructor[1].options, options)
+    }
+
+    @test()
+    protected static async pushingSingleMarkerIncrementsHitCountAndWaitTime() {
+        const markers = [this.generateDurationMarker()]
+        await this.instance.pushMarkers(markers)
+
+        const marker = markers[0]
+
+        assert.isEqual(
+            FakeLslOutlet.callsToPushSample[0][0],
+            marker.name,
+            'Pushed the wrong marker!'
+        )
+
+        assert.isEqual(this.instance.totalWaitTimeMs, marker.durationMs)
+    }
+
+    @test()
+    protected static async pushingTwoMarkersIncrementsHitCountAndWaitTimeTwice() {
+        const markers = await this.pushTotalMarkers(2)
+
+        assert.isEqual(FakeLslOutlet.callsToPushSample.length, 2)
+
+        assert.isEqual(
+            this.instance.totalWaitTimeMs,
+            markers[0].durationMs + markers[1].durationMs
+        )
+    }
+
+    @test('can stop on the first marker', 1)
+    @test('can stop on the second marker', 2)
+    @test('can stop on the third marker', 3)
+    protected static async canStopEventMarkersMidPush(bailIdx: number) {
+        let hitCount = 0
+
+        const outlet = this.instance.getLslOutlet()
+
+        outlet.pushSample = () => {
+            hitCount += 1
+            if (hitCount === bailIdx) {
+                this.instance.stop()
+            }
+        }
+
+        await this.pushTotalMarkers(10)
+
+        assert.isEqual(hitCount, bailIdx)
+    }
+
+    @test()
+    protected static async canStartAgainAfterStopping() {
+        this.instance.stop()
+
+        let hitCount = 0
+
+        const outlet = this.instance.getLslOutlet()
+
+        outlet.pushSample = () => {
+            hitCount++
+        }
+
+        await this.pushTotalMarkers(10)
+
+        assert.isEqual(hitCount, 10)
+    }
+
+    @test()
+    protected static async doesNotWaitIfStopped() {
+        await this.setupOutlet()
+
+        const startMs = Date.now()
+        const promise = this.pushTotalMarkers(2, 1000)
+        this.instance.stop()
+        await promise
+        const endMs = Date.now()
+
+        assert.isBelow(endMs - startMs, 10)
+    }
+
+    @test()
+    protected static async clearsTheTimeoutOnStop() {
+        void this.pushTotalMarkers(2, 100)
+        this.instance.stop()
+
+        this.lslOutlet.pushSample = () =>
+            assert.fail('Should not have been called')
+    }
+
+    private static get lslOutlet() {
+        return this.instance.getLslOutlet()
+    }
+
+    private static async setupOutlet() {
+        EventMarkerOutlet.Class = EventMarkerOutlet as any
+        this.instance = await this.EventMarkerOutlet()
+    }
+
+    private static async pushTotalMarkers(total: number, durationMs?: number) {
+        const markers = new Array(total)
+            .fill(null)
+            .map(() => this.generateDurationMarker(durationMs))
+
+        await this.instance.pushMarkers(markers)
+
+        return markers
+    }
+
+    private static generateDurationMarker(durationMs?: number) {
+        return {
+            name: generateId(),
+            durationMs: durationMs ?? randomInt(100, 1000),
+        }
+    }
+
+    private static async EventMarkerOutlet(
+        options?: Partial<LslOutletOptions>
+    ) {
+        return (await EventMarkerOutlet.Create(options)) as SpyMarkerOutlet
+    }
+}

package/src/__tests__/{Liblsl.test.ts → LiblslAdapter.test.ts}

@@ -1,12 +1,7 @@
 import { randomInt } from 'crypto'
-import AbstractSpruceTest, {
-    test,
-    assert,
-    errorAssert,
-    generateId,
-} from '@sprucelabs/test-utils'
+import { test, assert, errorAssert, generateId } from '@sprucelabs/test-utils'
 import { DataType, OpenParams } from 'ffi-rs'
-import LiblslImpl from '../components/Liblsl'
+import LiblslAdapter from '../components/LiblslAdapter'
 import {
     BoundChild,
     BoundDescription,
@@ -18,9 +13,10 @@ import {
     LiblslBindings,
     LslChannel,
 } from '../nodeLsl.types'
-import FakeLiblsl from '../testDoubles/FakeLiblsl'
+import FakeLiblsl from '../testDoubles/Liblsl/FakeLiblsl'
+import AbstractLslTest from './AbstractLslTest'
 
-export default class LiblslTest extends AbstractSpruceTest {
+export default class LiblslAdapterTest extends AbstractLslTest {
     private static lsl: Liblsl
     private static libraryPath?: string
     private static libraryOptions?: Record<string, any>
@@ -76,11 +72,11 @@ export default class LiblslTest extends AbstractSpruceTest {
         this.appendChildHitCount = 0
 
         delete this.ffiRsOpenOptions
-        LiblslImpl.ffiRsOpen = (options) => {
+        LiblslAdapter.ffiRsOpen = (options) => {
             this.ffiRsOpenOptions = options
         }
 
-        LiblslImpl.ffiRsDefine = (options) => {
+        LiblslAdapter.ffiRsDefine = (options) => {
             this.ffiRsDefineOptions = options
             if (this.shouldThrowWhenCreatingBindings) {
                 throw new Error('Failed to create bindings!')
@@ -88,16 +84,16 @@ export default class LiblslTest extends AbstractSpruceTest {
             return this.fakeBindings as any
         }
 
-        LiblslImpl.resetInstance()
-        this.lsl = LiblslImpl.getInstance()
+        LiblslAdapter.resetInstance()
+        this.lsl = LiblslAdapter.getInstance()
     }
 
     @test()
     protected static async throwsWhenBindingsFailToLoad() {
         this.shouldThrowWhenCreatingBindings = true
-        LiblslImpl.resetInstance()
+        LiblslAdapter.resetInstance()
 
-        const err = assert.doesThrow(() => LiblslImpl.getInstance())
+        const err = assert.doesThrow(() => LiblslAdapter.getInstance())
         errorAssert.assertError(err, 'FAILED_TO_LOAD_LIBLSL', {
             liblslPath: process.env.LIBLSL_PATH,
         })
@@ -167,21 +163,21 @@ export default class LiblslTest extends AbstractSpruceTest {
 
     @test()
     protected static async worksAsASingleton() {
-        const liblsl = LiblslImpl.getInstance()
+        const liblsl = LiblslAdapter.getInstance()
         //@ts-ignore
-        assert.isInstanceOf(liblsl, LiblslImpl)
+        assert.isInstanceOf(liblsl, LiblslAdapter)
     }
 
     @test()
     protected static async singletonIsTheSame() {
-        assert.isEqual(LiblslImpl.getInstance(), LiblslImpl.getInstance())
+        assert.isEqual(LiblslAdapter.getInstance(), LiblslAdapter.getInstance())
     }
 
     @test()
     protected static canSetInstance() {
         const fake = new FakeLiblsl()
-        LiblslImpl.setInstance(fake)
-        assert.isEqual(LiblslImpl.getInstance(), fake)
+        LiblslAdapter.setInstance(fake)
+        assert.isEqual(LiblslAdapter.getInstance(), fake)
     }
 
     @test()
@@ -402,8 +398,8 @@ export default class LiblslTest extends AbstractSpruceTest {
     protected static async defaultsToMacOsPath() {
         delete process.env.LIBLSL_PATH
 
-        LiblslImpl.resetInstance()
-        this.lsl = LiblslImpl.getInstance()
+        LiblslAdapter.resetInstance()
+        this.lsl = LiblslAdapter.getInstance()
 
         assert.isEqual(
             this.ffiRsOpenOptions?.path,

package/src/__tests__/LslStreamInfo.test.ts

@@ -1,16 +1,16 @@
 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'
+import SpyStreamInfo from '../testDoubles/StreamInfo/SpyStreamInfo'
+import AbstractLslTest from './AbstractLslTest'
 
-export default class LslStreamInfoTest extends AbstractNodeLslTest {
-    private static instance: SpyLslStreamInfo
+export default class LslStreamInfoTest extends AbstractLslTest {
+    private static instance: SpyStreamInfo
 
     protected static async beforeEach() {
         await super.beforeEach()
 
-        this.setSpyLslStreamInfo()
+        this.setSpyStreamInfo()
 
         this.instance = this.LslStreamInfo()
     }
@@ -191,13 +191,6 @@ export default class LslStreamInfoTest extends AbstractNodeLslTest {
         )
     }
 
-    private static LslStreamInfo(options?: Partial<StreamInfoOptions>) {
-        return LslStreamInfo.Create({
-            ...this.defaultOptions,
-            ...options,
-        }) as SpyLslStreamInfo
-    }
-
     private static readonly defaultOptions = {
         name: generateId(),
         type: generateId(),
@@ -206,4 +199,11 @@ export default class LslStreamInfoTest extends AbstractNodeLslTest {
         channelFormat: 'float32',
         sampleRate: 100 * Math.random(),
     } as StreamInfoOptions
+
+    private static LslStreamInfo(options?: Partial<StreamInfoOptions>) {
+        return LslStreamInfo.Create({
+            ...this.defaultOptions,
+            ...options,
+        }) as SpyStreamInfo
+    }
 }

package/src/__tests__/{LslInlet.test.ts → LslStreamInlet.test.ts}

@@ -1,10 +1,10 @@
 import { test, assert, errorAssert } from '@sprucelabs/test-utils'
-import LslInlet, { LslInletOptions } from '../components/LslInlet'
-import FakeStreamInfo from '../testDoubles/FakeStreamInfo'
-import { SpyLslInlet } from '../testDoubles/SpyLslInlet'
-import AbstractNodeLslTest from './AbstractNodeLslTest'
+import LslStreamInlet, { LslInletOptions } from '../components/LslStreamInlet'
+import { SpyLslInlet } from '../testDoubles/LslInlet/SpyLslInlet'
+import FakeStreamInfo from '../testDoubles/StreamInfo/FakeStreamInfo'
+import AbstractLslTest from './AbstractLslTest'
 
-export default class LslInletTest extends AbstractNodeLslTest {
+export default class LslStreamInletTest extends AbstractLslTest {
     private static instance: SpyLslInlet
 
     protected static async beforeEach() {
@@ -13,11 +13,11 @@ export default class LslInletTest extends AbstractNodeLslTest {
         this.setSpyLslInlet()
         this.setFakeStreamInfo()
 
-        this.instance = this.LslInlet()
+        this.instance = this.LslStreamInlet()
     }
 
     @test()
-    protected static async canCreateLslInlet() {
+    protected static async canCreateLslStreamInlet() {
         assert.isTruthy(this.instance, 'Instance should be created!')
     }
 
@@ -25,7 +25,7 @@ export default class LslInletTest extends AbstractNodeLslTest {
     protected static async throwsWithMissingRequiredOptions() {
         const err = assert.doesThrow(
             // @ts-ignore
-            () => LslInlet.Create()
+            () => LslStreamInlet.Create()
         )
         errorAssert.assertError(err, 'MISSING_PARAMETERS', {
             parameters: [
@@ -56,7 +56,7 @@ export default class LslInletTest extends AbstractNodeLslTest {
 
     @test()
     protected static async uniqueNameHasSetPrefix() {
-        const instance = this.LslInlet({ name: undefined })
+        const instance = this.LslStreamInlet({ name: undefined })
 
         assert.doesInclude(
             instance.getName(),
@@ -82,7 +82,7 @@ export default class LslInletTest extends AbstractNodeLslTest {
         )
     }
 
-    private static LslInlet(options?: Partial<LslInletOptions>) {
+    private static LslStreamInlet(options?: Partial<LslInletOptions>) {
         const defaultOptions = {
             channelNames: this.channelNames,
             channelFormat: 'float32',
@@ -94,6 +94,6 @@ export default class LslInletTest extends AbstractNodeLslTest {
             maxBuffered: this.maxBuffered,
             ...options,
         } as LslInletOptions
-        return LslInlet.Create(defaultOptions) as SpyLslInlet
+        return LslStreamInlet.Create(defaultOptions) as SpyLslInlet
     }
 }

package/src/__tests__/{LslOutlet.test.ts → LslStreamOutlet.test.ts}

@@ -1,6 +1,8 @@
 import { test, assert, errorAssert, generateId } from '@sprucelabs/test-utils'
-import LslOutletImpl, { LslOutletOptions } from '../components/LslOutlet'
 import { StreamInfo } from '../components/LslStreamInfo'
+import LslStreamOutlet, {
+    LslOutletOptions,
+} from '../components/LslStreamOutlet'
 import { LslSample } from '../nodeLsl.types'
 import {
     TEST_SUPPORTED_CHANNEL_FORMATS,
@@ -8,17 +10,17 @@ import {
     TestChannelFormat,
 } from '../testDoubles/consts'
 
-import FakeStreamInfo from '../testDoubles/FakeStreamInfo'
 import generateRandomOutletOptions from '../testDoubles/generateRandomOutletOptions'
-import AbstractNodeLslTest from './AbstractNodeLslTest'
+import FakeStreamInfo from '../testDoubles/StreamInfo/FakeStreamInfo'
+import AbstractLslTest from './AbstractLslTest'
 
-export default class LslOutletTest extends AbstractNodeLslTest {
+export default class LslStreamOutletTest extends AbstractLslTest {
     private static randomOutletOptions: LslOutletOptions
 
     protected static async beforeEach() {
         await super.beforeEach()
 
-        delete LslOutletImpl.Class
+        delete LslStreamOutlet.Class
 
         this.randomOutletOptions = generateRandomOutletOptions()
 
@@ -30,7 +32,7 @@ export default class LslOutletTest extends AbstractNodeLslTest {
     protected static async throwsWithMissingRequiredParams() {
         const err = await assert.doesThrowAsync(
             //@ts-ignore
-            async () => await LslOutletImpl.Create()
+            async () => await LslStreamOutlet.Create()
         )
         errorAssert.assertError(err, 'MISSING_PARAMETERS', {
             parameters: [
@@ -55,7 +57,7 @@ export default class LslOutletTest extends AbstractNodeLslTest {
 
     @test()
     protected static async allowsZeroSampleRate() {
-        await this.Outlet({ sampleRate: 0 })
+        await this.LslStreamOutlet({ sampleRate: 0 })
     }
 
     @test()
@@ -75,7 +77,7 @@ export default class LslOutletTest extends AbstractNodeLslTest {
 
     @test()
     protected static async throwsWithInvalidChunkSize() {
-        await this.Outlet({ chunkSize: 0 })
+        await this.LslStreamOutlet({ chunkSize: 0 })
         await this.assertThrowsInvalidChunkSize(-1)
         await this.assertThrowsInvalidChunkSize(-1.5)
         await this.assertThrowsInvalidChunkSize(1.5)
@@ -83,7 +85,7 @@ export default class LslOutletTest extends AbstractNodeLslTest {
 
     @test()
     protected static async throwsWithInvalidMaxBuffered() {
-        await this.Outlet({ maxBuffered: 0 })
+        await this.LslStreamOutlet({ maxBuffered: 0 })
         await this.assertThrowsInvalidMaxBuffered(-1)
         await this.assertThrowsInvalidMaxBuffered(-1.5)
         await this.assertThrowsInvalidMaxBuffered(1.5)
@@ -94,7 +96,9 @@ export default class LslOutletTest extends AbstractNodeLslTest {
         for (let unsupportedType of TEST_UNSUPPORTED_CHANNEL_FORMATS) {
             await assert.doesThrowAsync(
                 async () =>
-                    await this.Outlet({ channelFormat: unsupportedType }),
+                    await this.LslStreamOutlet({
+                        channelFormat: unsupportedType,
+                    }),
                 `This method currently does not support the ${unsupportedType} type! Please implement it.`
             )
         }
@@ -103,7 +107,9 @@ export default class LslOutletTest extends AbstractNodeLslTest {
     @test()
     protected static async supportsAllKnownChannelFormats() {
         for (const format of TEST_SUPPORTED_CHANNEL_FORMATS) {
-            await this.Outlet({ channelFormat: format as TestChannelFormat })
+            await this.LslStreamOutlet({
+                channelFormat: format as TestChannelFormat,
+            })
         }
     }
 
@@ -172,7 +178,7 @@ export default class LslOutletTest extends AbstractNodeLslTest {
 
     @test()
     protected static async constructionCreatesStreamInfo() {
-        await this.Outlet()
+        await this.LslStreamOutlet()
 
         assert.isEqualDeep(FakeStreamInfo.callsToConstructor[0], {
             channelNames: this.randomOutletOptions.channelNames,
@@ -187,15 +193,15 @@ export default class LslOutletTest extends AbstractNodeLslTest {
 
     @test()
     protected static async canOverrideClassInstantiatedInFactory() {
-        LslOutletImpl.Class = CheckingOutlet
-        const instance = await this.Outlet()
+        LslStreamOutlet.Class = CheckingOutlet
+        const instance = await this.LslStreamOutlet()
 
         assert.isInstanceOf(instance, CheckingOutlet)
     }
 
     @test()
     protected static async canDestroyOutlet() {
-        const outlet = await this.Outlet()
+        const outlet = await this.LslStreamOutlet()
         outlet.destroy()
 
         assert.isEqual(this.fakeLiblsl.destroyOutletHitCount, 1)
@@ -214,7 +220,7 @@ export default class LslOutletTest extends AbstractNodeLslTest {
     @test()
     protected static async waitsForTenMsAfterConstructionBeforeReturning() {
         const startMs = Date.now()
-        await this.Outlet({ waitAfterConstructionMs: 10 })
+        await this.LslStreamOutlet({ waitAfterConstructionMs: 10 })
         const endMs = Date.now()
 
         assert.isAbove(endMs - startMs, 10)
@@ -250,7 +256,7 @@ export default class LslOutletTest extends AbstractNodeLslTest {
         parameters: string[]
     ) {
         const err = await assert.doesThrowAsync(
-            async () => await this.Outlet(options)
+            async () => await this.LslStreamOutlet(options)
         )
         errorAssert.assertError(err, 'INVALID_PARAMETERS', {
             parameters,
@@ -258,22 +264,22 @@ export default class LslOutletTest extends AbstractNodeLslTest {
     }
 
     private static async StringOutlet() {
-        return await this.Outlet({ channelFormat: 'string' })
+        return await this.LslStreamOutlet({ channelFormat: 'string' })
     }
 
     private static async FloatOutlet() {
-        return await this.Outlet({ channelFormat: 'float32' })
+        return await this.LslStreamOutlet({ channelFormat: 'float32' })
     }
 
-    private static async Outlet(options?: Partial<LslOutletOptions>) {
-        return await LslOutletImpl.Create({
+    private static async LslStreamOutlet(options?: Partial<LslOutletOptions>) {
+        return await LslStreamOutlet.Create({
             ...this.randomOutletOptions,
             ...options,
         })
     }
 }
 
-class CheckingOutlet extends LslOutletImpl {
+class CheckingOutlet extends LslStreamOutlet {
     public constructor(info: StreamInfo, options: LslOutletOptions) {
         super(info, options)
     }

package/src/components/{TimeMarkerOutlet.ts → EventMarkerOutlet.ts}

@@ -1,52 +1,45 @@
 import { DurationMarker } from '../nodeLsl.types'
-import LslOutletImpl, { LslOutlet, LslOutletOptions } from './LslOutlet'
-import LslStreamInfo, { StreamInfo } from './LslStreamInfo'
+import LslStreamOutlet, { LslOutletOptions, LslOutlet } from './LslStreamOutlet'
 
-export default class TimeMarkerOutletImpl
-    extends LslOutletImpl
-    implements TimeMarkerOutlet
-{
-    public static Class?: TimeMarkerOutletConstructor
+export default class EventMarkerOutlet implements MarkerOutlet {
+    public static Class?: MarkerOutletConstructor
 
+    protected lslOutlet: LslOutlet
     private isPlaying = false
     private waitResolve?: () => void
     private timeout?: any
 
-    public static async Create(options?: Partial<LslOutletOptions>) {
-        const { unit, manufacturer, maxBuffered, chunkSize } = options ?? {}
+    protected constructor(lslOutlet: LslOutlet) {
+        this.lslOutlet = lslOutlet
+    }
 
-        const infoOptions = {
-            name: 'Time markers',
+    public static async Create(options?: Partial<LslOutletOptions>) {
+        const defaultOptions = {
+            name: 'Event markers',
             type: 'Markers',
             channelNames: ['Markers'],
             sampleRate: 0,
             channelFormat: 'string',
-            sourceId: 'time-markers',
-            units: unit ?? 'N/A',
-            ...options,
+            sourceId: 'event-markers',
+            manufacturer: 'N/A',
+            unit: 'N/A',
+            chunkSize: 0,
+            maxBuffered: 0,
         } as LslOutletOptions
 
-        const info = LslStreamInfo.Create(infoOptions)
-
-        const outletOptions = {
-            ...infoOptions,
-            manufacturer: manufacturer ?? 'N/A',
-            chunkSize: chunkSize ?? 0,
-            maxBuffered: maxBuffered ?? 0,
-            unit: unit ?? 'N/A',
-        }
-
-        // @ts-ignore
-        delete outletOptions.units
+        const outlet = await LslStreamOutlet.Create({
+            ...defaultOptions,
+            ...options,
+        })
 
-        return new (this.Class ?? this)(info, outletOptions) as TimeMarkerOutlet
+        return new (this.Class ?? this)(outlet)
     }
 
     public async pushMarkers(markers: DurationMarker[]) {
         this.isPlaying = true
 
         for (let marker of markers) {
-            this.pushSample([marker.name])
+            this.lslOutlet.pushSample([marker.name])
 
             await this.wait(marker.durationMs)
 
@@ -72,12 +65,9 @@ export default class TimeMarkerOutletImpl
     }
 }
 
-export interface TimeMarkerOutlet extends LslOutlet {
+export interface MarkerOutlet {
     pushMarkers(markers: DurationMarker[]): Promise<void>
     stop(): void
 }
 
-export type TimeMarkerOutletConstructor = new (
-    info: StreamInfo,
-    options: LslOutletOptions
-) => TimeMarkerOutlet
+export type MarkerOutletConstructor = new (lslOutlet: LslOutlet) => MarkerOutlet

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

@@ -14,7 +14,7 @@ import {
     DestroyInletOptions,
 } from '../nodeLsl.types'
 
-export default class LiblslImpl implements Liblsl {
+export default class LiblslAdapter implements Liblsl {
     private static instance?: Liblsl
     public static ffiRsOpen = open
     public static ffiRsDefine = define
@@ -54,12 +54,12 @@ export default class LiblslImpl implements Liblsl {
     }
 
     private loadBindings(liblslPath: string) {
-        LiblslImpl.ffiRsOpen({
+        LiblslAdapter.ffiRsOpen({
             library: 'lsl',
             path: liblslPath,
         })
 
-        return LiblslImpl.ffiRsDefine({
+        return LiblslAdapter.ffiRsDefine({
             lsl_create_streaminfo: {
                 library: 'lsl',
                 retType: DataType.External,

package/src/components/LslStreamInfo.ts

@@ -2,7 +2,7 @@ import { assertOptions } from '@sprucelabs/schema'
 import { generateId } from '@sprucelabs/test-utils'
 import { CHANNEL_FORMATS_MAP } from '../consts'
 import { BoundStreamInfo, ChannelFormat } from '../nodeLsl.types'
-import LiblslImpl from './Liblsl'
+import LiblslAdapter from './LiblslAdapter'
 
 export default class LslStreamInfo implements StreamInfo {
     public static Class?: StreamInfoConstructor
@@ -79,7 +79,7 @@ export default class LslStreamInfo implements StreamInfo {
     }
 
     private get lsl() {
-        return LiblslImpl.getInstance()
+        return LiblslAdapter.getInstance()
     }
 
     private readonly defaultName = `lsl-stream-info-${generateId()}`