@neurodevs/node-lsl 2.0.2 → 3.2.1

package/src/__tests__/behavioral/TimeMarkerOutlet.test.ts

@@ -0,0 +1,54 @@
+import { randomInt } from 'crypto'
+import AbstractSpruceTest, { assert, test } from '@sprucelabs/test-utils'
+import LiblslImpl from '../../Liblsl'
+import { LslOutletOptions } from '../../LslOutlet'
+import TimeMarkerOutlet from '../../TimeMarkerOutlet'
+import generateRandomOutletOptions from '../support/generateRandomOutletOptions'
+import { SpyLiblsl } from '../support/SpyLiblsl'
+
+export default class TimeMarkerOutletTest extends AbstractSpruceTest {
+	private static spyLiblsl: SpyLiblsl
+
+	protected static async beforeEach() {
+		await super.beforeEach()
+		TimeMarkerOutlet.Class = SpyTimeMarkerOutlet
+		this.spyLiblsl = new SpyLiblsl()
+		LiblslImpl.setInstance(this.spyLiblsl)
+	}
+
+	@test()
+	protected static async loadsWithTimeMarkerSpecificOptions() {
+		const outlet = this.Outlet()
+		assert.isEqualDeep(outlet.options, {
+			name: 'Time markers',
+			type: 'Markers',
+			channelNames: ['Markers'],
+			sampleRate: 0,
+			channelFormat: 'string',
+			sourceId: 'time-markers',
+			manufacturer: 'N/A',
+			unit: 'N/A',
+			chunkSize: 0,
+			maxBuffered: 0,
+		})
+	}
+
+	@test()
+	protected static async canOverrideDefaultOptions() {
+		const options = generateRandomOutletOptions(randomInt(8))
+		const outlet = this.Outlet(options)
+		assert.isEqualDeep(outlet.options, options)
+	}
+
+	private static Outlet(options?: Partial<LslOutletOptions>) {
+		return TimeMarkerOutlet.Outlet(options) as SpyTimeMarkerOutlet
+	}
+}
+
+class SpyTimeMarkerOutlet extends TimeMarkerOutlet {
+	public options: LslOutletOptions
+	public constructor(options: LslOutletOptions) {
+		super(options)
+		this.options = options
+	}
+}

package/src/__tests__/implementation/Liblsl.test.ts

@@ -8,16 +8,17 @@ import AbstractSpruceTest, {
 import ArrayType from 'ref-array-napi'
 import ref from 'ref-napi'
 import LiblslImpl, {
-	CreateStreamInfoOptions,
-	LiblslBindings,
 	Liblsl,
-	LslSample,
+	LiblslBindings,
+	CreateStreamInfoOptions,
+	AppendChannelsToStreamInfoOptions,
 	CreateOutletOptions,
-	LslBindingsOutlet,
-	LslBindingsStreamInfo,
+	PushSampleOptions,
 	LslChannel,
-	LslBindingsDesc,
-	LslBindingsChild,
+	BoundOutlet,
+	BoundStreamInfo,
+	BoundDesc,
+	BoundChild,
 } from '../../Liblsl'
 
 export default class LiblslTest extends AbstractSpruceTest {
@@ -25,10 +26,10 @@ export default class LiblslTest extends AbstractSpruceTest {
 	private static libraryPath?: string
 	private static libraryOptions?: Record<string, any>
 	private static fakeBindings: LiblslBindings
-	private static fakeStreamInfo: LslBindingsStreamInfo
-	private static fakeOutlet: LslBindingsOutlet
-	private static fakeDesc: LslBindingsDesc
-	private static fakeChildNamedChannels: LslBindingsChild
+	private static fakeStreamInfo: BoundStreamInfo
+	private static fakeOutlet: BoundOutlet
+	private static fakeDesc: BoundDesc
+	private static fakeChildNamedChannels: BoundChild
 	private static createStreamInfoParams?: any[]
 	private static appendChildParams: any[] = []
 	private static createOutletParams?: any[]
@@ -36,8 +37,8 @@ export default class LiblslTest extends AbstractSpruceTest {
 	private static appendChildValueParams: any[]
 	private static localClock: number
 	private static shouldThrowWhenCreatingBindings: boolean
-	private static getDescriptionParams?: [LslBindingsStreamInfo]
-	private static fakeChildNamedChannel: LslBindingsChild
+	private static getDescriptionParams?: [BoundStreamInfo]
+	private static fakeChildNamedChannel: BoundChild
 	private static appendChildHitCount: number
 
 	protected static async beforeEach(): Promise<void> {
@@ -79,7 +80,7 @@ export default class LiblslTest extends AbstractSpruceTest {
 				return 0
 			},
 			lsl_local_clock: () => this.localClock,
-			lsl_get_desc: (info: LslBindingsStreamInfo) => {
+			lsl_get_desc: (info: BoundStreamInfo) => {
 				this.getDescriptionParams = [info]
 				return this.fakeDesc
 			},
@@ -108,12 +109,12 @@ export default class LiblslTest extends AbstractSpruceTest {
 			},
 		}
 
-		LiblslImpl.reset()
+		LiblslImpl.resetInstance()
 		this.lsl = LiblslImpl.getInstance()
 	}
 
 	@test()
-	protected static async throwsIfNoEnvSet() {
+	protected static async throwsWithMissingEnv() {
 		delete process.env.LIBLSL_PATH
 		const err = assert.doesThrow(() => new LiblslImpl())
 		errorAssert.assertError(err, 'MISSING_PARAMETERS', {
@@ -122,7 +123,7 @@ export default class LiblslTest extends AbstractSpruceTest {
 	}
 
 	@test()
-	protected static async throwsHelpfulErrorWhenBindingsFailToLoad() {
+	protected static async throwsWhenBindingsFailToLoad() {
 		this.shouldThrowWhenCreatingBindings = true
 		const err = assert.doesThrow(() => new LiblslImpl())
 		errorAssert.assertError(err, 'FAILED_TO_LOAD_LIBLSL', {
@@ -130,6 +131,49 @@ export default class LiblslTest extends AbstractSpruceTest {
 		})
 	}
 
+	@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() {
+		//@ts-ignore
+		const err = assert.doesThrow(() => 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 throwsWhenPushSampleIsMissingRequiredParams() {
+		//@ts-ignore
+		const err = assert.doesThrow(() => this.lsl.pushSample())
+		errorAssert.assertError(err, 'MISSING_PARAMETERS', {
+			parameters: ['outlet', 'sample'],
+		})
+	}
+
 	@test()
 	protected static async worksAsASingleton() {
 		const liblsl = LiblslImpl.getInstance()
@@ -172,23 +216,7 @@ export default class LiblslTest extends AbstractSpruceTest {
 	}
 
 	@test()
-	protected static createStreamInfoThrowsWithMissingRequiredParams() {
-		//@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 canGetStreamInfoWithRequiredParams() {
+	protected static async canCreateStreamInfoWithRequiredParams() {
 		const options = this.generateRandomCreateStreamInfoOptions()
 		const actual = this.lsl.createStreamInfo(options)
 
@@ -196,15 +224,6 @@ export default class LiblslTest extends AbstractSpruceTest {
 		assert.isEqualDeep(this.createStreamInfoParams, Object.values(options))
 	}
 
-	@test()
-	protected static async createOutletThrowsWhenMissingRequiredParams() {
-		//@ts-ignore
-		const err = assert.doesThrow(() => this.lsl.createOutlet({}))
-		errorAssert.assertError(err, 'MISSING_PARAMETERS', {
-			parameters: ['info', 'chunkSize', 'maxBuffered'],
-		})
-	}
-
 	@test()
 	protected static async canCreateOutletWithRequiredParams() {
 		const info = this.createRandomStreamInfo()
@@ -219,37 +238,27 @@ export default class LiblslTest extends AbstractSpruceTest {
 	}
 
 	@test()
-	protected static async pushSampleThrowsWhenMissingRequiredParams() {
-		//@ts-ignore
-		const err = assert.doesThrow(() => this.lsl.pushSample())
-		errorAssert.assertError(err, 'MISSING_PARAMETERS', {
-			parameters: ['outlet', 'sample'],
-		})
-	}
-
-	@test()
-	protected static async pushSampleCallsBindings() {
+	protected static async canPushSampleWithRequiredParams() {
 		const expected = [1, 2, 3]
-		this.lsl.pushSample(this.fakeOutlet, expected)
+		const options = {
+			outlet: this.fakeOutlet,
+			sample: expected,
+		}
+		this.lsl.pushSample(options)
 		assert.isEqual(this.pushSampleParams?.[0], this.fakeOutlet)
 		assert.isEqual(this.pushSampleParams?.[1], expected)
 		assert.isEqual(this.pushSampleParams?.[2], this.localClock)
 	}
 
-	@test()
-	protected static async appendChannelsThrowsWithMissingParams() {
-		//@ts-ignore
-		const err = assert.doesThrow(() => this.lsl.appendChannelsToStreamInfo())
-		errorAssert.assertError(err, 'MISSING_PARAMETERS', {
-			parameters: ['info', 'channels'],
-		})
-	}
-
 	@test()
 	protected static async addingSingleChannelGetsDescription() {
 		const info = this.createRandomStreamInfo()
 		const channel: LslChannel = this.generateRandomChannelValues()
-		this.lsl.appendChannelsToStreamInfo(info, [channel])
+
+		this.lsl.appendChannelsToStreamInfo({
+			info,
+			channels: [channel],
+		})
 		assert.isEqual(this.getDescriptionParams?.[0], info)
 
 		assert.isEqual(this.appendChildParams?.[0][0], this.fakeDesc)
@@ -280,7 +289,10 @@ export default class LiblslTest extends AbstractSpruceTest {
 		const channel1 = this.generateRandomChannelValues()
 		const channel2 = this.generateRandomChannelValues()
 
-		this.lsl.appendChannelsToStreamInfo(info, [channel1, channel2])
+		this.lsl.appendChannelsToStreamInfo({
+			info,
+			channels: [channel1, channel2],
+		})
 
 		assert.isEqual(this.appendChildParams?.[2][0], this.fakeChildNamedChannels)
 		assert.isEqual(this.appendChildParams?.[2][1], 'channel')
@@ -290,6 +302,12 @@ export default class LiblslTest extends AbstractSpruceTest {
 		assert.isEqual(this.appendChildValueParams[5][2], channel2.type)
 	}
 
+	private static createRandomStreamInfo() {
+		return this.lsl.createStreamInfo(
+			this.generateRandomCreateStreamInfoOptions()
+		)
+	}
+
 	private static generateRandomChannelValues(): LslChannel {
 		return {
 			label: generateId(),
@@ -298,38 +316,32 @@ export default class LiblslTest extends AbstractSpruceTest {
 		}
 	}
 
-	private static createRandomStreamInfo() {
-		return this.lsl.createStreamInfo(
-			this.generateRandomCreateStreamInfoOptions()
-		)
-	}
-
 	private static generateRandomCreateStreamInfoOptions() {
 		return {
 			name: generateId(),
 			type: generateId(),
-			channelCount: randomInt(10),
-			sampleRate: randomInt(10),
-			channelFormat: randomInt(10),
+			channelCount: randomInt(1, 10),
+			sampleRate: randomInt(100),
+			channelFormat: randomInt(7),
 			sourceId: generateId(),
 		}
 	}
 }
 
 class FakeLiblsl implements Liblsl {
+	public createStreamInfo(_options: CreateStreamInfoOptions): BoundStreamInfo {
+		return {} as BoundStreamInfo
+	}
+
 	public appendChannelsToStreamInfo(
-		_info: LslBindingsStreamInfo,
-		_channels: LslChannel[]
+		_options: AppendChannelsToStreamInfoOptions
 	): void {}
-	public createOutlet(_options: CreateOutletOptions): LslBindingsOutlet {
-		return {} as LslBindingsOutlet
-	}
-	public createStreamInfo(
-		_options: CreateStreamInfoOptions
-	): LslBindingsStreamInfo {
-		return {} as LslBindingsStreamInfo
+
+	public createOutlet(_options: CreateOutletOptions): BoundOutlet {
+		return {} as BoundOutlet
 	}
-	public pushSample(_sample: LslSample): void {}
+
+	public pushSample(_options: PushSampleOptions): void {}
 }
 
 const streamInfo = ref.refType(ref.types.void)

package/src/__tests__/support/SpyLiblsl.ts

@@ -0,0 +1,41 @@
+import {
+	CreateOutletOptions,
+	CreateStreamInfoOptions,
+	Liblsl,
+	BoundOutlet,
+	BoundStreamInfo,
+	AppendChannelsToStreamInfoOptions,
+	PushSampleOptions,
+} from '../../Liblsl'
+
+export class SpyLiblsl implements Liblsl {
+	public lastCreateStreamInfoOptions?: CreateStreamInfoOptions
+	public lastAppendChannelsToStreamInfoOptions?: AppendChannelsToStreamInfoOptions
+	public lastCreateOutletOptions?: CreateOutletOptions
+	public lastPushSampleOptions?: PushSampleOptions
+
+	public outlet: BoundOutlet = {} as BoundOutlet
+	public streamInfo: BoundStreamInfo = {} as BoundStreamInfo
+	public createStreamInfoHitCount = 0
+
+	public createStreamInfo(options: CreateStreamInfoOptions): BoundStreamInfo {
+		this.createStreamInfoHitCount++
+		this.lastCreateStreamInfoOptions = options
+		return this.streamInfo
+	}
+
+	public appendChannelsToStreamInfo(
+		options: AppendChannelsToStreamInfoOptions
+	): void {
+		this.lastAppendChannelsToStreamInfoOptions = options
+	}
+
+	public createOutlet(options: CreateOutletOptions): BoundOutlet {
+		this.lastCreateOutletOptions = options
+		return this.outlet
+	}
+
+	public pushSample(options: PushSampleOptions): void {
+		this.lastPushSampleOptions = options
+	}
+}

package/src/__tests__/support/consts.ts

@@ -0,0 +1,12 @@
+export const TEST_CHANNEL_FORMATS = [
+	'undefined',
+	'float32',
+	'double64',
+	'string',
+	'int32',
+	'int16',
+	'int8',
+	'int64',
+]
+
+export type TestChannelFormat = (typeof TEST_CHANNEL_FORMATS)[number]

package/src/__tests__/support/generateRandomOutletOptions.ts

@@ -0,0 +1,19 @@
+import { randomInt } from 'crypto'
+import { generateId } from '@sprucelabs/test-utils'
+import { LslOutletOptions } from '../../LslOutlet'
+import { TEST_CHANNEL_FORMATS } from './consts'
+
+export default function generateRandomOutletOptions(randomChannelIdx: number) {
+	return {
+		name: generateId(),
+		type: generateId(),
+		channelNames: new Array(randomInt(1, 10)).fill(generateId()),
+		sampleRate: Math.random() * 10,
+		channelFormat: TEST_CHANNEL_FORMATS[randomChannelIdx],
+		sourceId: generateId(),
+		manufacturer: generateId(),
+		unit: generateId(),
+		chunkSize: randomInt(0, 10),
+		maxBuffered: randomInt(0, 10),
+	} as LslOutletOptions
+}

package/src/index.ts

@@ -3,3 +3,5 @@ export * from './Liblsl'
 
 export { default as LslOutletImpl } from './LslOutlet'
 export * from './LslOutlet'
+
+export { default as TimeMarkerOutlet } from './TimeMarkerOutlet'