@neurodevs/node-lsl 10.2.1 → 11.0.0

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: [
@@ -46,7 +46,7 @@ export default class LslInletTest extends AbstractNodeLslTest {
                 channelNames: this.channelNames,
                 channelFormat: 'float32',
                 sampleRate: 0,
-                name: this.infoName,
+                name: this.name_,
                 type: this.type,
                 sourceId: this.sourceId,
             },
@@ -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,18 +82,18 @@ 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',
             sampleRate: 0,
-            name: this.infoName,
+            name: this.name_,
             type: this.type,
             sourceId: this.sourceId,
             chunkSize: this.chunkSize,
             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,42 +1,45 @@
 import { DurationMarker } from '../nodeLsl.types'
-import LslOutletImpl, { LslOutlet, LslOutletOptions } from './LslOutlet'
-import { 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
 
+    protected constructor(lslOutlet: LslOutlet) {
+        this.lslOutlet = lslOutlet
+    }
+
     public static async Create(options?: Partial<LslOutletOptions>) {
         const defaultOptions = {
-            name: 'Time markers',
+            name: 'Event markers',
             type: 'Markers',
             channelNames: ['Markers'],
             sampleRate: 0,
             channelFormat: 'string',
-            sourceId: 'time-markers',
+            sourceId: 'event-markers',
             manufacturer: 'N/A',
             unit: 'N/A',
             chunkSize: 0,
             maxBuffered: 0,
         } as LslOutletOptions
 
-        return new (this.Class ?? this)({} as StreamInfo, {
+        const outlet = await LslStreamOutlet.Create({
             ...defaultOptions,
             ...options,
-        }) 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)
 
@@ -62,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()}`

package/src/components/{LslInlet.ts → LslStreamInlet.ts}

@@ -1,10 +1,10 @@
 import { assertOptions } from '@sprucelabs/schema'
 import { generateId } from '@sprucelabs/test-utils'
 import { ChannelFormat } from '../nodeLsl.types'
-import LiblslImpl from './Liblsl'
+import LiblslAdapter from './LiblslAdapter'
 import LslStreamInfo, { StreamInfo, StreamInfoOptions } from './LslStreamInfo'
 
-export default class LslInlet implements StreamInlet {
+export default class LslStreamInlet implements LslInlet {
     public static Class?: LslInletConstructor
 
     protected name: string
@@ -54,7 +54,7 @@ export default class LslInlet implements StreamInlet {
     }
 
     private get lsl() {
-        return LiblslImpl.getInstance()
+        return LiblslAdapter.getInstance()
     }
 
     private readonly defaultName = `lsl-inlet-${generateId()}`
@@ -64,12 +64,12 @@ export default class LslInlet implements StreamInlet {
     }
 }
 
-export interface StreamInlet {}
+export interface LslInlet {}
 
 export type LslInletConstructor = new (
     info: StreamInfo,
     options: LslInletOptions
-) => StreamInlet
+) => LslInlet
 
 export interface LslInletOptions {
     sampleRate: number

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

@@ -7,10 +7,10 @@ import {
     assertValidSampleRate,
 } from '../assertions'
 import { ChannelFormat, BoundOutlet, Liblsl, LslSample } from '../nodeLsl.types'
-import LiblslImpl from './Liblsl'
+import LiblslAdapter from './LiblslAdapter'
 import LslStreamInfo, { StreamInfo, StreamInfoOptions } from './LslStreamInfo'
 
-export default class LslOutletImpl implements LslOutlet {
+export default class LslStreamOutlet implements LslOutlet {
     public static Class?: LslOutletConstructor
 
     private info: StreamInfo
@@ -141,7 +141,7 @@ export default class LslOutletImpl implements LslOutlet {
     }
 
     private get lsl() {
-        return LiblslImpl.getInstance()
+        return LiblslAdapter.getInstance()
     }
 
     private static async wait(waitMs: number) {

package/src/index.ts

@@ -1,35 +1,44 @@
 export * from './nodeLsl.types'
 
-export { default as LiblslImpl } from './components/Liblsl'
-export * from './components/Liblsl'
+// Liblsl
+
+export { default as LiblslAdapter } from './components/LiblslAdapter'
+export * from './components/LiblslAdapter'
+
+export { default as FakeLiblsl } from './testDoubles/Liblsl/FakeLiblsl'
+export * from './testDoubles/Liblsl/FakeLiblsl'
+
+// LslStreamInfo
 
 export { default as LslStreamInfo } from './components/LslStreamInfo'
 export * from './components/LslStreamInfo'
 
-export { default as SpyLslStreamInfo } from './testDoubles/SpyLslStreamInfo'
-export * from './testDoubles/SpyLslStreamInfo'
+export { default as SpyStreamInfo } from './testDoubles/StreamInfo/SpyStreamInfo'
+export * from './testDoubles/StreamInfo/SpyStreamInfo'
+
+export { default as FakeStreamInfo } from './testDoubles/StreamInfo/FakeStreamInfo'
+export * from './testDoubles/StreamInfo/FakeStreamInfo'
 
-export { default as FakeStreamInfo } from './testDoubles/FakeStreamInfo'
+// LslStreamOutlet
 
-export { default as LslOutletImpl } from './components/LslOutlet'
-export * from './components/LslOutlet'
+export { default as LslStreamOutlet } from './components/LslStreamOutlet'
+export * from './components/LslStreamOutlet'
 
-export { default as TimeMarkerOutletImpl } from './components/TimeMarkerOutlet'
-export * from './components/TimeMarkerOutlet'
+export { default as FakeLslOutlet } from './testDoubles/LslOutlet/FakeLslOutlet'
+export * from './testDoubles/LslOutlet/FakeLslOutlet'
 
-export { default as FakeLiblsl } from './testDoubles/FakeLiblsl'
-export * from './testDoubles/FakeLiblsl'
+// EventMarkerOutlet
 
-export { default as FakeLslOutlet } from './testDoubles/FakeLslOutlet'
-export * from './testDoubles/FakeLslOutlet'
+export { default as EventMarkerOutlet } from './components/EventMarkerOutlet'
+export * from './components/EventMarkerOutlet'
 
-export { default as FakeTimeMarkerOutlet } from './testDoubles/FakeTimeMarkerOutlet'
-export * from './testDoubles/FakeTimeMarkerOutlet'
+export { default as FakeMarkerOutlet } from './testDoubles/MarkerOutlet/FakeMarkerOutlet'
+export * from './testDoubles/MarkerOutlet/FakeMarkerOutlet'
 
-export { default as MockTimeMarkerOutlet } from './testDoubles/MockTimeMarkerOutlet'
-export * from './testDoubles/MockTimeMarkerOutlet'
+export { default as MockMarkerOutlet } from './testDoubles/MarkerOutlet/MockMarkerOutlet'
+export * from './testDoubles/MarkerOutlet/MockMarkerOutlet'
 
-export { default as SpyTimeMarkerOutlet } from './testDoubles/SpyTimeMarkerOutlet'
-export * from './testDoubles/SpyTimeMarkerOutlet'
+export { default as SpyMarkerOutlet } from './testDoubles/MarkerOutlet/SpyMarkerOutlet'
+export * from './testDoubles/MarkerOutlet/SpyMarkerOutlet'
 
 export { default as generateRandomOutletOptions } from './testDoubles/generateRandomOutletOptions'

package/src/nodeLsl.types.ts

@@ -1,9 +1,9 @@
 import { FuncObj, FieldType } from 'ffi-rs'
-import { StreamInlet } from './components/LslInlet'
-import { LslOutlet } from './components/LslOutlet'
+import { LslInlet } from './components/LslStreamInlet'
+import { LslOutlet } from './components/LslStreamOutlet'
 import { CHANNEL_FORMATS } from './consts'
 
-export type StreamFixuture = LslOutlet | StreamInlet
+export type StreamFixuture = LslOutlet | LslInlet
 
 export type ChannelFormat = (typeof CHANNEL_FORMATS)[number]
 

package/src/testDoubles/{FakeLiblsl.ts → Liblsl/FakeLiblsl.ts}

@@ -10,7 +10,7 @@ import {
     CreateInletOptions,
     DestroyInletOptions,
     BoundInlet,
-} from '../nodeLsl.types'
+} from '../../nodeLsl.types'
 
 export default class FakeLiblsl implements Liblsl {
     public outlet: BoundOutlet = {} as BoundOutlet

package/src/testDoubles/{SpyLslInlet.ts → LslInlet/SpyLslInlet.ts}

@@ -1,7 +1,9 @@
-import LslInlet, { LslInletOptions } from '../components/LslInlet'
-import { StreamInfo } from '../components/LslStreamInfo'
+import { StreamInfo } from '../../components/LslStreamInfo'
+import LslStreamInlet, {
+    LslInletOptions,
+} from '../../components/LslStreamInlet'
 
-export class SpyLslInlet extends LslInlet {
+export class SpyLslInlet extends LslStreamInlet {
     public constructor(info: StreamInfo, options: LslInletOptions) {
         super(info, options)
     }