@neurodevs/node-lsl 3.1.0 → 3.3.0

package/build/__tests__/support/SpyLiblsl.d.ts

@@ -0,0 +1,16 @@
+import { CreateOutletOptions, CreateStreamInfoOptions, Liblsl, BoundOutlet, BoundStreamInfo, AppendChannelsToStreamInfoOptions, PushSampleOptions } from '../../Liblsl';
+export declare class SpyLiblsl implements Liblsl {
+    lastCreateStreamInfoOptions?: CreateStreamInfoOptions;
+    lastAppendChannelsToStreamInfoOptions?: AppendChannelsToStreamInfoOptions;
+    lastCreateOutletOptions?: CreateOutletOptions;
+    lastPushSampleOptions?: PushSampleOptions;
+    outlet: BoundOutlet;
+    streamInfo: BoundStreamInfo;
+    createStreamInfoHitCount: number;
+    destroyOutletHitCount: number;
+    createStreamInfo(options: CreateStreamInfoOptions): BoundStreamInfo;
+    appendChannelsToStreamInfo(options: AppendChannelsToStreamInfoOptions): void;
+    createOutlet(options: CreateOutletOptions): BoundOutlet;
+    destroyOutlet(): void;
+    pushSample(options: PushSampleOptions): void;
+}

package/build/__tests__/support/SpyLiblsl.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SpyLiblsl = void 0;
+class SpyLiblsl {
+    constructor() {
+        this.outlet = {};
+        this.streamInfo = {};
+        this.createStreamInfoHitCount = 0;
+        this.destroyOutletHitCount = 0;
+    }
+    createStreamInfo(options) {
+        this.createStreamInfoHitCount++;
+        this.lastCreateStreamInfoOptions = options;
+        return this.streamInfo;
+    }
+    appendChannelsToStreamInfo(options) {
+        this.lastAppendChannelsToStreamInfoOptions = options;
+    }
+    createOutlet(options) {
+        this.lastCreateOutletOptions = options;
+        return this.outlet;
+    }
+    destroyOutlet() {
+        this.destroyOutletHitCount++;
+    }
+    pushSample(options) {
+        this.lastPushSampleOptions = options;
+    }
+}
+exports.SpyLiblsl = SpyLiblsl;
+//# sourceMappingURL=SpyLiblsl.js.map

package/build/__tests__/support/SpyLiblsl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SpyLiblsl.js","sourceRoot":"","sources":["../../../src/__tests__/support/SpyLiblsl.ts"],"names":[],"mappings":";;;AAUA,MAAa,SAAS;IAAtB;QAMQ,WAAM,GAAgB,EAAiB,CAAA;QACvC,eAAU,GAAoB,EAAqB,CAAA;QACnD,6BAAwB,GAAG,CAAC,CAAA;QAC5B,0BAAqB,GAAG,CAAC,CAAA;IA0BjC,CAAC;IAxBO,gBAAgB,CAAC,OAAgC;QACvD,IAAI,CAAC,wBAAwB,EAAE,CAAA;QAC/B,IAAI,CAAC,2BAA2B,GAAG,OAAO,CAAA;QAC1C,OAAO,IAAI,CAAC,UAAU,CAAA;IACvB,CAAC;IAEM,0BAA0B,CAChC,OAA0C;QAE1C,IAAI,CAAC,qCAAqC,GAAG,OAAO,CAAA;IACrD,CAAC;IAEM,YAAY,CAAC,OAA4B;QAC/C,IAAI,CAAC,uBAAuB,GAAG,OAAO,CAAA;QACtC,OAAO,IAAI,CAAC,MAAM,CAAA;IACnB,CAAC;IAEM,aAAa;QACnB,IAAI,CAAC,qBAAqB,EAAE,CAAA;IAC7B,CAAC;IAEM,UAAU,CAAC,OAA0B;QAC3C,IAAI,CAAC,qBAAqB,GAAG,OAAO,CAAA;IACrC,CAAC;CACD;AAnCD,8BAmCC"}

package/build/__tests__/support/consts.d.ts

@@ -0,0 +1,2 @@
+export declare const TEST_CHANNEL_FORMATS: string[];
+export type TestChannelFormat = (typeof TEST_CHANNEL_FORMATS)[number];

package/build/__tests__/support/consts.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TEST_CHANNEL_FORMATS = void 0;
+exports.TEST_CHANNEL_FORMATS = [
+    'undefined',
+    'float32',
+    'double64',
+    'string',
+    'int32',
+    'int16',
+    'int8',
+    'int64',
+];
+//# sourceMappingURL=consts.js.map

package/build/__tests__/support/consts.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"consts.js","sourceRoot":"","sources":["../../../src/__tests__/support/consts.ts"],"names":[],"mappings":";;;AAAa,QAAA,oBAAoB,GAAG;IACnC,WAAW;IACX,SAAS;IACT,UAAU;IACV,QAAQ;IACR,OAAO;IACP,OAAO;IACP,MAAM;IACN,OAAO;CACP,CAAA"}

package/build/__tests__/support/generateRandomOutletOptions.d.ts

@@ -0,0 +1,2 @@
+import { LslOutletOptions } from '../../LslOutlet';
+export default function generateRandomOutletOptions(randomChannelIdx: number): LslOutletOptions;

package/build/__tests__/support/generateRandomOutletOptions.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const crypto_1 = require("crypto");
+const test_utils_1 = require("@sprucelabs/test-utils");
+const consts_1 = require("./consts");
+function generateRandomOutletOptions(randomChannelIdx) {
+    return {
+        name: (0, test_utils_1.generateId)(),
+        type: (0, test_utils_1.generateId)(),
+        channelNames: new Array((0, crypto_1.randomInt)(1, 10)).fill((0, test_utils_1.generateId)()),
+        sampleRate: Math.random() * 10,
+        channelFormat: consts_1.TEST_CHANNEL_FORMATS[randomChannelIdx],
+        sourceId: (0, test_utils_1.generateId)(),
+        manufacturer: (0, test_utils_1.generateId)(),
+        unit: (0, test_utils_1.generateId)(),
+        chunkSize: (0, crypto_1.randomInt)(0, 10),
+        maxBuffered: (0, crypto_1.randomInt)(0, 10),
+    };
+}
+exports.default = generateRandomOutletOptions;
+//# sourceMappingURL=generateRandomOutletOptions.js.map

package/build/__tests__/support/generateRandomOutletOptions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"generateRandomOutletOptions.js","sourceRoot":"","sources":["../../../src/__tests__/support/generateRandomOutletOptions.ts"],"names":[],"mappings":";;AAAA,mCAAkC;AAClC,uDAAmD;AAEnD,qCAA+C;AAE/C,SAAwB,2BAA2B,CAAC,gBAAwB;IAC3E,OAAO;QACN,IAAI,EAAE,IAAA,uBAAU,GAAE;QAClB,IAAI,EAAE,IAAA,uBAAU,GAAE;QAClB,YAAY,EAAE,IAAI,KAAK,CAAC,IAAA,kBAAS,EAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,IAAA,uBAAU,GAAE,CAAC;QAC5D,UAAU,EAAE,IAAI,CAAC,MAAM,EAAE,GAAG,EAAE;QAC9B,aAAa,EAAE,6BAAoB,CAAC,gBAAgB,CAAC;QACrD,QAAQ,EAAE,IAAA,uBAAU,GAAE;QACtB,YAAY,EAAE,IAAA,uBAAU,GAAE;QAC1B,IAAI,EAAE,IAAA,uBAAU,GAAE;QAClB,SAAS,EAAE,IAAA,kBAAS,EAAC,CAAC,EAAE,EAAE,CAAC;QAC3B,WAAW,EAAE,IAAA,kBAAS,EAAC,CAAC,EAAE,EAAE,CAAC;KACT,CAAA;AACtB,CAAC;AAbD,8CAaC"}

package/build/errors/SpruceError.js.map

@@ -1 +1 @@
-{"version":3,"file":"SpruceError.js","sourceRoot":"","sources":["../../src/errors/SpruceError.ts"],"names":[],"mappings":";;;;;AAAA,8DAA+C;AAG/C,MAAqB,WAAY,SAAQ,eAA6B;IACrE,kDAAkD;IAC3C,eAAe;QACrB,MAAM,EAAE,OAAO,EAAE,GAAG,IAAI,CAAA;QACxB,IAAI,OAAO,CAAA;QACX,QAAQ,OAAO,aAAP,OAAO,uBAAP,OAAO,CAAE,IAAI,EAAE;YACtB,KAAK,uBAAuB;gBAC3B,OAAO,GAAG,wEAAwE,OAAO,CAAC,UAAU,GAAG,CAAA;gBACvG,MAAK;YACN;gBACC,OAAO,GAAG,KAAK,CAAC,eAAe,EAAE,CAAA;SAClC;QAED,MAAM,WAAW,GAAG,OAAO,CAAC,eAAe;YAC1C,CAAC,CAAC,OAAO,CAAC,eAAe;YACzB,CAAC,CAAC,OAAO,CAAA;QAEV,OAAO,WAAW,CAAA;IACnB,CAAC;CACD;AAnBD,8BAmBC"}
+{"version":3,"file":"SpruceError.js","sourceRoot":"","sources":["../../src/errors/SpruceError.ts"],"names":[],"mappings":";;;;;AAAA,8DAA+C;AAG/C,MAAqB,WAAY,SAAQ,eAA6B;IACrE,kDAAkD;IAC3C,eAAe;QACrB,MAAM,EAAE,OAAO,EAAE,GAAG,IAAI,CAAA;QACxB,IAAI,OAAO,CAAA;QACX,QAAQ,OAAO,aAAP,OAAO,uBAAP,OAAO,CAAE,IAAI,EAAE,CAAC;YACvB,KAAK,uBAAuB;gBAC3B,OAAO,GAAG,wEAAwE,OAAO,CAAC,UAAU,GAAG,CAAA;gBACvG,MAAK;YACN;gBACC,OAAO,GAAG,KAAK,CAAC,eAAe,EAAE,CAAA;QACnC,CAAC;QAED,MAAM,WAAW,GAAG,OAAO,CAAC,eAAe;YAC1C,CAAC,CAAC,OAAO,CAAC,eAAe;YACzB,CAAC,CAAC,OAAO,CAAA;QAEV,OAAO,WAAW,CAAA;IACnB,CAAC;CACD;AAnBD,8BAmBC"}

package/build/index.d.ts

@@ -2,3 +2,4 @@ export { default as LiblslImpl } from './Liblsl';
 export * from './Liblsl';
 export { default as LslOutletImpl } from './LslOutlet';
 export * from './LslOutlet';
+export { default as TimeMarkerOutlet } from './TimeMarkerOutlet';

package/build/index.js

@@ -17,11 +17,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LslOutletImpl = exports.LiblslImpl = void 0;
+exports.TimeMarkerOutlet = exports.LslOutletImpl = exports.LiblslImpl = void 0;
 var Liblsl_1 = require("./Liblsl");
 Object.defineProperty(exports, "LiblslImpl", { enumerable: true, get: function () { return __importDefault(Liblsl_1).default; } });
 __exportStar(require("./Liblsl"), exports);
 var LslOutlet_1 = require("./LslOutlet");
 Object.defineProperty(exports, "LslOutletImpl", { enumerable: true, get: function () { return __importDefault(LslOutlet_1).default; } });
 __exportStar(require("./LslOutlet"), exports);
+var TimeMarkerOutlet_1 = require("./TimeMarkerOutlet");
+Object.defineProperty(exports, "TimeMarkerOutlet", { enumerable: true, get: function () { return __importDefault(TimeMarkerOutlet_1).default; } });
 //# sourceMappingURL=index.js.map

package/build/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA,mCAAgD;AAAvC,qHAAA,OAAO,OAAc;AAC9B,2CAAwB;AAExB,yCAAsD;AAA7C,2HAAA,OAAO,OAAiB;AACjC,8CAA2B"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA,mCAAgD;AAAvC,qHAAA,OAAO,OAAc;AAC9B,2CAAwB;AAExB,yCAAsD;AAA7C,2HAAA,OAAO,OAAiB;AACjC,8CAA2B;AAE3B,uDAAgE;AAAvD,qIAAA,OAAO,OAAoB"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neurodevs/node-lsl",
-  "version": "3.1.0",
+  "version": "3.3.0",
   "main": "build/index.js",
   "repository": "https://github.com/neurodevs/node-lsl.git",
   "scripts": {

package/src/Liblsl.ts

@@ -48,6 +48,7 @@ export default class LiblslImpl implements Liblsl {
 				['string', 'string', 'int', 'double', 'int', 'string'],
 			],
 			lsl_create_outlet: [outletType, [streamInfo, 'int', 'int']],
+			lsl_destroy_outlet: ['void', [outletType]],
 			lsl_local_clock: ['double', []],
 			lsl_push_sample_ft: ['void', [outletType, FloatArray, 'double']],
 			lsl_get_desc: [xmlPtr, [streamInfo]],
@@ -104,6 +105,11 @@ export default class LiblslImpl implements Liblsl {
 		return this.bindings.lsl_create_outlet(info, chunkSize, maxBuffered)
 	}
 
+	public destroyOutlet(options: DestroyOutletOptions): void {
+		const { outlet } = assertOptions(options, ['outlet'])
+		this.bindings.lsl_destroy_outlet(outlet)
+	}
+
 	public pushSample(options: PushSampleOptions): void {
 		const { outlet, sample } = assertOptions(options, ['outlet', 'sample'])
 
@@ -116,6 +122,7 @@ export interface Liblsl {
 	createStreamInfo(options: CreateStreamInfoOptions): BoundStreamInfo
 	appendChannelsToStreamInfo(options: AppendChannelsToStreamInfoOptions): void
 	createOutlet(options: CreateOutletOptions): BoundOutlet
+	destroyOutlet(options: DestroyOutletOptions): void
 	pushSample(options: PushSampleOptions): void
 }
 
@@ -141,6 +148,10 @@ export interface CreateOutletOptions {
 	maxBuffered: number
 }
 
+export interface DestroyOutletOptions {
+	outlet: BoundOutlet
+}
+
 export interface PushSampleOptions {
 	outlet: BoundOutlet
 	sample: LslSample
@@ -169,6 +180,8 @@ export interface LiblslBindings {
 		maxBuffered: number
 	): BoundOutlet
 
+	lsl_destroy_outlet(outlet: BoundOutlet): void
+
 	lsl_push_sample_ft(
 		outlet: BoundOutlet,
 		sample: LslSample,

package/src/LslOutlet.ts

@@ -63,6 +63,10 @@ export default class LslOutletImpl implements LslOutlet {
 		return new (this.Class ?? this)(options)
 	}
 
+	public destroy() {
+		this.lsl.destroyOutlet({ outlet: this.outlet })
+	}
+
 	public pushSample(sample: LslSample) {
 		this.lsl.pushSample({ outlet: this.outlet, sample })
 	}
@@ -93,7 +97,6 @@ export default class LslOutletImpl implements LslOutlet {
 
 	private assertValidChannelFormat(channelFormat: ChannelFormat) {
 		const validFormats = CHANNEL_FORMATS
-
 		if (validFormats.indexOf(channelFormat) === -1) {
 			throw new SchemaError({
 				code: 'INVALID_PARAMETERS',
@@ -104,11 +107,11 @@ export default class LslOutletImpl implements LslOutlet {
 	}
 
 	private assertValidSampleRate(sampleRate: number) {
-		if (!this.isPositiveNumber(sampleRate)) {
+		if (!this.isGreaterThanZero(sampleRate)) {
 			throw new SchemaError({
 				code: 'INVALID_PARAMETERS',
 				parameters: ['sampleRate'],
-				friendlyMessage: 'Sample rate must be a positive number.',
+				friendlyMessage: 'Sample rate must be a positive number or zero.',
 			})
 		}
 	}
@@ -123,18 +126,18 @@ export default class LslOutletImpl implements LslOutlet {
 		}
 	}
 
-	private isPositiveNumber(value: number) {
-		return value > 0
-	}
-
-	private isPositiveIntegerOrZero(value: number) {
-		return Number.isInteger(value) && value >= 0
+	private isGreaterThanZero(value: number) {
+		return value >= 0
 	}
 
 	private isPositiveInteger(value: number) {
 		return Number.isInteger(value) && value > 0
 	}
 
+	private isPositiveIntegerOrZero(value: number) {
+		return Number.isInteger(value) && value >= 0
+	}
+
 	private get lsl() {
 		return LiblslImpl.getInstance()
 	}
@@ -154,6 +157,7 @@ const CHANNEL_FORMATS = [
 export type ChannelFormat = (typeof CHANNEL_FORMATS)[number]
 
 export interface LslOutlet {
+	destroy(): void
 	pushSample(sample: LslSample): void
 }
 

package/src/TimeMarkerOutlet.ts

@@ -0,0 +1,19 @@
+import LslOutletImpl, { LslOutletOptions } from './LslOutlet'
+
+export default class TimeMarkerOutlet extends LslOutletImpl {
+	public static Outlet(options?: Partial<LslOutletOptions>) {
+		const defaultOptions = {
+			name: 'Time markers',
+			type: 'Markers',
+			channelNames: ['Markers'],
+			sampleRate: 0,
+			channelFormat: 'string',
+			sourceId: 'time-markers',
+			manufacturer: 'N/A',
+			unit: 'N/A',
+			chunkSize: 0,
+			maxBuffered: 0,
+		} as LslOutletOptions
+		return new (this.Class ?? this)({ ...defaultOptions, ...options })
+	}
+}

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

@@ -5,51 +5,24 @@ import AbstractSpruceTest, {
 	errorAssert,
 	generateId,
 } from '@sprucelabs/test-utils'
-import LiblslImpl, {
-	CreateOutletOptions,
-	CreateStreamInfoOptions,
-	Liblsl,
-	BoundOutlet,
-	BoundStreamInfo,
-	LslSample,
-	AppendChannelsToStreamInfoOptions,
-	PushSampleOptions,
-} from '../../Liblsl'
+import LiblslImpl, { LslSample } from '../../Liblsl'
 import LslOutlet, { ChannelFormat, LslOutletOptions } from '../../LslOutlet'
-
-export const CHANNEL_FORMATS = [
-	'undefined',
-	'float32',
-	'double64',
-	'string',
-	'int32',
-	'int16',
-	'int8',
-	'int64',
-] as const
+import { TEST_CHANNEL_FORMATS } from '../support/consts'
+import generateRandomOutletOptions from '../support/generateRandomOutletOptions'
+import { SpyLiblsl } from '../support/SpyLiblsl'
 
 export default class LslOutletTest extends AbstractSpruceTest {
 	private static spyLiblsl: SpyLiblsl
 	private static randomOutletOptions: LslOutletOptions
-	private static channelIdx: number
+	private static channelFormatIdx: number
 
 	protected static async beforeEach() {
 		await super.beforeEach()
 		delete LslOutlet.Class
-		this.channelIdx = randomInt(7)
-		this.randomOutletOptions = {
-			name: generateId(),
-			type: generateId(),
-			channelNames: new Array(randomInt(1, 10)).fill(generateId()),
-			sampleRate: Math.random() * 10,
-			channelFormat: CHANNEL_FORMATS[this.channelIdx],
-			sourceId: generateId(),
-			manufacturer: generateId(),
-			unit: generateId(),
-			chunkSize: randomInt(0, 10),
-			maxBuffered: randomInt(0, 10),
-		}
-
+		this.channelFormatIdx = randomInt(8)
+		this.randomOutletOptions = generateRandomOutletOptions(
+			this.channelFormatIdx
+		)
 		this.spyLiblsl = new SpyLiblsl()
 		LiblslImpl.setInstance(this.spyLiblsl)
 	}
@@ -81,7 +54,7 @@ export default class LslOutletTest extends AbstractSpruceTest {
 
 	@test()
 	protected static async throwsWithInvalidSampleRate() {
-		this.assertThrowsInvalidSampleRate(0)
+		this.Outlet({ sampleRate: 0 })
 		this.assertThrowsInvalidSampleRate(-1)
 		this.assertThrowsInvalidSampleRate(-1.5)
 	}
@@ -112,8 +85,7 @@ export default class LslOutletTest extends AbstractSpruceTest {
 
 	@test()
 	protected static async supportsAllKnownChannelFormats() {
-		const valid = CHANNEL_FORMATS
-		for (const format of valid) {
+		for (const format of TEST_CHANNEL_FORMATS) {
 			this.Outlet({ channelFormat: format as ChannelFormat })
 		}
 	}
@@ -122,6 +94,7 @@ export default class LslOutletTest extends AbstractSpruceTest {
 	@test('pushing [1] sample sends to LSL', [1])
 	protected static async canPushSampleToLsl(sample: LslSample) {
 		this.pushSample(sample)
+
 		assert.isEqual(
 			this.spyLiblsl.lastPushSampleOptions?.outlet,
 			this.spyLiblsl.outlet
@@ -150,7 +123,7 @@ export default class LslOutletTest extends AbstractSpruceTest {
 
 		assert.isEqualDeep(this.spyLiblsl.lastCreateStreamInfoOptions, {
 			...options,
-			channelFormat: this.channelIdx,
+			channelFormat: this.channelFormatIdx,
 		})
 	}
 
@@ -158,6 +131,7 @@ export default class LslOutletTest extends AbstractSpruceTest {
 	protected static async canOverrideClassInstantiatedInFactory() {
 		LslOutlet.Class = CheckingOutlet
 		const instance = this.Outlet()
+
 		assert.isInstanceOf(instance, CheckingOutlet)
 	}
 
@@ -179,6 +153,14 @@ export default class LslOutletTest extends AbstractSpruceTest {
 		})
 	}
 
+	@test()
+	protected static async canDestroyOutlet() {
+		const outlet = this.Outlet()
+		outlet.destroy()
+
+		assert.isEqual(this.spyLiblsl.destroyOutletHitCount, 1)
+	}
+
 	@test()
 	protected static async pushSampleShouldNotCreateMultipleOutlets() {
 		const outlet = this.Outlet()
@@ -231,38 +213,6 @@ export default class LslOutletTest extends AbstractSpruceTest {
 	}
 }
 
-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
-	}
-}
-
 class CheckingOutlet extends LslOutlet {
 	public constructor(options: LslOutletOptions) {
 		super(options)

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

@@ -13,6 +13,7 @@ import LiblslImpl, {
 	CreateStreamInfoOptions,
 	AppendChannelsToStreamInfoOptions,
 	CreateOutletOptions,
+	DestroyOutletOptions,
 	PushSampleOptions,
 	LslChannel,
 	BoundOutlet,
@@ -33,6 +34,7 @@ export default class LiblslTest extends AbstractSpruceTest {
 	private static createStreamInfoParams?: any[]
 	private static appendChildParams: any[] = []
 	private static createOutletParams?: any[]
+	private static destroyOutletParams?: any[]
 	private static pushSampleParams?: any[]
 	private static appendChildValueParams: any[]
 	private static localClock: number
@@ -48,6 +50,7 @@ export default class LiblslTest extends AbstractSpruceTest {
 		delete this.libraryOptions
 		delete this.createStreamInfoParams
 		delete this.createOutletParams
+		delete this.destroyOutletParams
 		delete this.pushSampleParams
 		delete this.getDescriptionParams
 		this.appendChildParams = []
@@ -75,6 +78,10 @@ export default class LiblslTest extends AbstractSpruceTest {
 				this.createOutletParams = params
 				return this.fakeOutlet
 			},
+			lsl_destroy_outlet: (...params: any[]) => {
+				this.destroyOutletParams = params
+				return
+			},
 			lsl_push_sample_ft: (...params: any[]) => {
 				this.pushSampleParams = params
 				return 0
@@ -203,6 +210,7 @@ export default class LiblslTest extends AbstractSpruceTest {
 				['string', 'string', 'int', 'double', 'int', 'string'],
 			],
 			lsl_create_outlet: [outletType, [streamInfo, 'int', 'int']],
+			lsl_destroy_outlet: ['void', [outletType]],
 			lsl_local_clock: ['double', []],
 			lsl_push_sample_ft: ['void', [outletType, FloatArray, 'double']],
 			lsl_get_desc: [xmlPtr, [streamInfo]],
@@ -226,15 +234,9 @@ export default class LiblslTest extends AbstractSpruceTest {
 
 	@test()
 	protected static async canCreateOutletWithRequiredParams() {
-		const info = this.createRandomStreamInfo()
-		const options = {
-			info,
-			chunkSize: randomInt(10),
-			maxBuffered: randomInt(10),
-		}
-		const actual = this.lsl.createOutlet(options)
+		const { options, outlet } = this.createRandomOutlet()
 		assert.isEqualDeep(this.createOutletParams, Object.values(options))
-		assert.isEqual(actual, this.fakeOutlet)
+		assert.isEqual(outlet, this.fakeOutlet)
 	}
 
 	@test()
@@ -302,12 +304,32 @@ export default class LiblslTest extends AbstractSpruceTest {
 		assert.isEqual(this.appendChildValueParams[5][2], channel2.type)
 	}
 
+	@test()
+	protected static async canDestroyOutlet() {
+		const outlet = this.createRandomOutlet()
+		const options = { outlet }
+		this.lsl.destroyOutlet(options)
+
+		assert.isEqualDeep(this.destroyOutletParams, Object.values(options))
+	}
+
 	private static createRandomStreamInfo() {
 		return this.lsl.createStreamInfo(
 			this.generateRandomCreateStreamInfoOptions()
 		)
 	}
 
+	private static createRandomOutlet() {
+		const info = this.createRandomStreamInfo()
+		const options = {
+			info,
+			chunkSize: randomInt(10),
+			maxBuffered: randomInt(10),
+		}
+		const outlet = this.lsl.createOutlet(options)
+		return { options, outlet }
+	}
+
 	private static generateRandomChannelValues(): LslChannel {
 		return {
 			label: generateId(),
@@ -341,6 +363,8 @@ class FakeLiblsl implements Liblsl {
 		return {} as BoundOutlet
 	}
 
+	public destroyOutlet(_options: DestroyOutletOptions): void {}
+
 	public pushSample(_options: PushSampleOptions): void {}
 }
 

package/src/__tests__/support/SpyLiblsl.ts

@@ -0,0 +1,46 @@
+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 destroyOutletHitCount = 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 destroyOutlet() {
+		this.destroyOutletHitCount++
+	}
+
+	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
+}