@neurodevs/node-lsl 8.0.1 → 8.0.3

package/package.json

@@ -1,52 +1,52 @@
 {
   "name": "@neurodevs/node-lsl",
-  "version": "8.0.1",
+  "version": "8.0.3",
   "main": "build/index.js",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/neurodevs/node-lsl.git"
   },
   "scripts": {
-    "build.ci": "yarn build.tsc && yarn build.resolve-paths && yarn lint",
-    "build.dev": "yarn build.tsc --sourceMap ; yarn resolve-paths.lint",
+    "build.ci": "yarn run build.tsc && yarn run build.resolve-paths && yarn run lint",
+    "build.dev": "yarn run build.tsc --sourceMap ; yarn run resolve-paths.lint",
     "build.copy-files": "mkdir -p build && rsync -avzq --exclude='*.ts' ./src/ ./build/",
     "build.resolve-paths": "resolve-path-aliases --target build --patterns '**/*.js,**/*.d.ts'",
-    "build.tsc": "yarn build.copy-files && tsc",
-    "clean": "yarn clean.build",
-    "clean.all": "yarn clean.dependencies && yarn clean.build",
+    "build.tsc": "yarn run build.copy-files && tsc",
+    "clean": "yarn run clean.build",
+    "clean.all": "yarn run clean.dependencies && yarn run clean.build",
     "clean.build": "rm -rf build/",
     "clean.dependencies": "rm -rf node_modules/ package-lock.json yarn.lock",
     "fix.lint": "eslint --fix --cache '**/*.ts'",
     "lint": "eslint --cache '**/*.ts'",
     "lint.tsc": "tsc -p . --noEmit",
-    "post.watch.build": "yarn build.copy-files && yarn build.resolve-paths",
-    "rebuild": "yarn clean.all && yarn && yarn build.dev",
-    "update.dependencies": "yarn clean.dependencies && yarn",
-    "resolve-paths.lint": "yarn build.resolve-paths ; yarn lint",
+    "post.watch.build": "yarn run build.copy-files && yarn run build.resolve-paths",
+    "rebuild": "yarn run clean.all && yarn install && yarn run build.dev",
+    "update.dependencies": "yarn run clean.dependencies && yarn",
+    "resolve-paths.lint": "yarn run build.resolve-paths ; yarn run lint",
     "test": "jest",
-    "watch.build.dev": "tsc-watch --sourceMap --onCompilationComplete 'yarn post.watch.build'",
+    "watch.build.dev": "tsc-watch --sourceMap --onCompilationComplete 'yarn run post.watch.build'",
     "watch.lint": "concurrently 'yarn lint' \"chokidar 'src/**/*' -c 'yarn lint.tsc'\"",
-    "watch.rebuild": "yarn clean.all && yarn && yarn watch.build.dev",
+    "watch.rebuild": "yarn run clean.all && yarn install && yarn run watch.build.dev",
     "watch.tsc": "tsc -w",
     "test.rs": "node build/test.js"
   },
   "devDependencies": {
-    "@sprucelabs/jest-json-reporter": "^7.0.197",
-    "@sprucelabs/resolve-path-aliases": "^1.1.298",
-    "@sprucelabs/test": "^8.0.49",
-    "@sprucelabs/test-utils": "^4.0.141",
+    "@sprucelabs/jest-json-reporter": "^8.0.24",
+    "@sprucelabs/resolve-path-aliases": "^2.0.20",
+    "@sprucelabs/test": "^9.0.13",
+    "@sprucelabs/test-utils": "^5.0.27",
     "@types/ffi-napi": "^4.0.10",
-    "@types/node": "^20.11.30",
+    "@types/node": "^20.12.11",
     "chokidar-cli": "^3.0.0",
     "concurrently": "^8.2.2",
-    "eslint": "^8.57.0",
-    "eslint-config-spruce": "^10.13.6",
+    "eslint": "^9.2.0",
+    "eslint-config-spruce": "^11.2.17",
     "jest": "^29.7.0",
     "jest-circus": "^29.7.0",
     "prettier": "^3.2.5",
     "ts-node": "^10.9.2",
     "tsc-watch": "^6.2.0",
-    "typescript": "^5.4.3"
+    "typescript": "^5.4.5"
   },
   "description": "Lab Streaming Layer (LSL) bindings for Node",
   "skill": {
@@ -74,13 +74,13 @@
     }
   },
   "dependencies": {
-    "@sprucelabs/error": "^5.1.94",
-    "@sprucelabs/schema": "^29.4.43",
-    "@sprucelabs/spruce-core-schemas": "^39.0.277",
-    "@sprucelabs/spruce-skill-utils": "^30.4.10",
-    "ffi-rs": "^1.0.62",
+    "@sprucelabs/error": "^6.0.23",
+    "@sprucelabs/schema": "^30.0.36",
+    "@sprucelabs/spruce-core-schemas": "^40.0.30",
+    "@sprucelabs/spruce-skill-utils": "^31.0.39",
+    "ffi-rs": "^1.0.74",
     "node-gyp": "^10.1.0",
     "ref-array-napi": "^1.2.2",
     "ref-napi": "^3.0.3"
   }
-}
+}

package/src/.spruce/errors/errors.types.ts

@@ -1,6 +1,3 @@
-/* eslint-disable @typescript-eslint/no-namespace */
-/* eslint-disable no-redeclare */
-
 import { default as SchemaEntity } from '@sprucelabs/schema'
 import * as SpruceSchema from '@sprucelabs/schema'
 

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

@@ -1,282 +1,287 @@
 import AbstractSpruceTest, {
-	test,
-	assert,
-	errorAssert,
-	generateId,
+    test,
+    assert,
+    errorAssert,
+    generateId,
 } from '@sprucelabs/test-utils'
 import LiblslImpl from '../../implementations/Liblsl'
 import LslOutlet from '../../implementations/LslOutlet'
 import { LslOutletOptions, LslSample } from '../../nodeLsl.types'
 import FakeLiblsl from '../../testDoubles/FakeLiblsl'
 import {
-	TEST_CHANNEL_FORMATS_MAP,
-	TEST_SUPPORTED_CHANNEL_FORMATS,
-	TEST_UNSUPPORTED_CHANNEL_FORMATS,
-	TestChannelFormat,
+    TEST_CHANNEL_FORMATS_MAP,
+    TEST_SUPPORTED_CHANNEL_FORMATS,
+    TEST_UNSUPPORTED_CHANNEL_FORMATS,
+    TestChannelFormat,
 } from '../support/consts'
 import generateRandomOutletOptions from '../support/generateRandomOutletOptions'
 
 export default class LslOutletTest extends AbstractSpruceTest {
-	private static fakeLiblsl: FakeLiblsl
-	private static randomOutletOptions: LslOutletOptions
-	private static channelFormatIdx: number
-
-	protected static async beforeEach() {
-		await super.beforeEach()
-		delete LslOutlet.Class
-		this.randomOutletOptions = generateRandomOutletOptions()
-
-		const channelFormat = this.randomOutletOptions.channelFormat
-		this.channelFormatIdx = TEST_CHANNEL_FORMATS_MAP[channelFormat]
-		this.fakeLiblsl = new FakeLiblsl()
-		LiblslImpl.setInstance(this.fakeLiblsl)
-	}
-
-	@test()
-	protected static async throwsWhenMissingRequiredParams() {
-		//@ts-ignore
-		const err = assert.doesThrow(() => new LslOutlet())
-		errorAssert.assertError(err, 'MISSING_PARAMETERS', {
-			parameters: [
-				'name',
-				'type',
-				'channelNames',
-				'sampleRate',
-				'channelFormat',
-				'sourceId',
-				'manufacturer',
-				'unit',
-				'chunkSize',
-				'maxBuffered',
-			],
-		})
-	}
-
-	@test()
-	protected static async throwsWithInvalidChannelNames() {
-		this.assertThrowsInvalidChannelNames(0)
-	}
-
-	@test()
-	protected static async throwsWithInvalidSampleRate() {
-		this.Outlet({ sampleRate: 0 })
-		this.assertThrowsInvalidSampleRate(-1)
-		this.assertThrowsInvalidSampleRate(-1.5)
-	}
-
-	@test()
-	protected static async throwsWithInvalidChannelFormat() {
-		//@ts-ignore
-		this.assertDoesThrowInvalidParameters({ channelFormat: generateId() }, [
-			'channelFormat',
-		])
-	}
-
-	@test()
-	protected static async throwsWithInvalidChunkSize() {
-		this.Outlet({ chunkSize: 0 })
-		this.assertThrowsInvalidChunkSize(-1)
-		this.assertThrowsInvalidChunkSize(-1.5)
-		this.assertThrowsInvalidChunkSize(1.5)
-	}
-
-	@test()
-	protected static async throwsWithInvalidMaxBuffered() {
-		this.Outlet({ maxBuffered: 0 })
-		this.assertThrowsInvalidMaxBuffered(-1)
-		this.assertThrowsInvalidMaxBuffered(-1.5)
-		this.assertThrowsInvalidMaxBuffered(1.5)
-	}
-
-	@test()
-	protected static async throwsWithUnsupportedType() {
-		for (let unsupportedType of TEST_UNSUPPORTED_CHANNEL_FORMATS) {
-			assert.doesThrow(
-				() => this.Outlet({ channelFormat: unsupportedType }),
-				`This method currently does not support the ${unsupportedType} type! Please implement it.`
-			)
-		}
-	}
-
-	@test()
-	protected static async supportsAllKnownChannelFormats() {
-		for (const format of TEST_SUPPORTED_CHANNEL_FORMATS) {
-			this.Outlet({ channelFormat: format as TestChannelFormat })
-		}
-	}
-
-	@test('pushing [1, 2] sample sends to LSL', [1.0, 2.0])
-	@test('pushing [1] sample sends to LSL', [1.0])
-	protected static async canPushFloatSampleToLsl(sample: LslSample) {
-		const outlet = this.FloatOutlet()
-		outlet.pushSample(sample)
-
-		assert.isEqual(
-			this.fakeLiblsl.lastPushSampleFloatTimestampOptions?.outlet,
-			this.fakeLiblsl.outlet
-		)
-		assert.isEqualDeep(
-			this.fakeLiblsl.lastPushSampleFloatTimestampOptions?.sample,
-			sample
-		)
-		assert.isEqualDeep(this.fakeLiblsl.lastCreateOutletOptions, {
-			info: this.fakeLiblsl.streamInfo,
-			chunkSize: this.randomOutletOptions.chunkSize,
-			maxBuffered: this.randomOutletOptions.maxBuffered,
-		})
-		assert.isNumber(
-			this.fakeLiblsl.lastPushSampleFloatTimestampOptions?.timestamp
-		)
-	}
-
-	@test()
-	protected static async canPushStringSampleToLsl() {
-		const sample = [generateId()]
-		const outlet = this.StringOutlet()
-
-		outlet.pushSample(sample)
-
-		assert.isEqual(
-			this.fakeLiblsl.lastPushSampleStringTimestampOptions?.outlet,
-			this.fakeLiblsl.outlet
-		)
-		assert.isEqualDeep(
-			this.fakeLiblsl.lastPushSampleStringTimestampOptions?.sample,
-			sample
-		)
-		assert.isNumber(
-			this.fakeLiblsl.lastPushSampleStringTimestampOptions?.timestamp
-		)
-	}
-
-	@test()
-	protected static async pushingStringTwiceGivesDifferentTimestamps() {
-		const outlet = this.StringOutlet()
-		const sample = [generateId()]
-
-		outlet.pushSample(sample)
-		const t1 = this.fakeLiblsl.lastPushSampleStringTimestampOptions?.timestamp
-
-		await this.wait(10)
-
-		outlet.pushSample(sample)
-		const t2 = this.fakeLiblsl.lastPushSampleStringTimestampOptions?.timestamp
-
-		assert.isNotEqual(t1, t2)
-		assert.isEqual(this.fakeLiblsl.localClockHitCount, 2)
-	}
-
-	@test()
-	protected static async constructionCreatesStreamInfo() {
-		this.Outlet()
-
-		const { ...options } = this.randomOutletOptions as any
-
-		options.channelCount = options.channelNames.length
-
-		delete options.manufacturer
-		delete options.unit
-		delete options.chunkSize
-		delete options.maxBuffered
-		delete options.channelNames
-
-		assert.isEqualDeep(this.fakeLiblsl.lastCreateStreamInfoOptions, {
-			...options,
-			channelFormat: this.channelFormatIdx,
-		})
-	}
-
-	@test()
-	protected static async canOverrideClassInstantiatedInFactory() {
-		LslOutlet.Class = CheckingOutlet
-		const instance = this.Outlet()
-
-		assert.isInstanceOf(instance, CheckingOutlet)
-	}
-
-	@test('can add one label to channels', [generateId()])
-	@test('can add two labels to channels', [generateId(), generateId()])
-	protected static async appendsChannelsBasedOnCount(labels: string[]) {
-		const type = generateId()
-		const unit = generateId()
-
-		this.Outlet({ channelNames: labels, type, unit })
-
-		assert.isEqualDeep(this.fakeLiblsl.lastAppendChannelsToStreamInfoOptions, {
-			info: this.fakeLiblsl.streamInfo,
-			channels: labels.map((label) => ({
-				label,
-				type,
-				unit,
-			})),
-		})
-	}
-
-	@test()
-	protected static async canDestroyOutlet() {
-		const outlet = this.Outlet()
-		outlet.destroy()
-
-		assert.isEqual(this.fakeLiblsl.destroyOutletHitCount, 1)
-	}
-
-	@test()
-	protected static async pushSampleShouldNotCreateMultipleOutlets() {
-		const outlet = this.FloatOutlet()
-		outlet.pushSample([1.0])
-		outlet.pushSample([2.0])
-		outlet.pushSample([3.0])
-
-		assert.isEqual(this.fakeLiblsl.createStreamInfoHitCount, 1)
-	}
-
-	private static assertThrowsInvalidMaxBuffered(maxBuffered: number) {
-		this.assertDoesThrowInvalidParameters({ maxBuffered }, ['maxBuffered'])
-	}
-
-	private static assertThrowsInvalidChunkSize(chunkSize: number) {
-		this.assertDoesThrowInvalidParameters({ chunkSize }, ['chunkSize'])
-	}
-
-	private static assertThrowsInvalidSampleRate(sampleRate: number) {
-		this.assertDoesThrowInvalidParameters({ sampleRate }, ['sampleRate'])
-	}
-
-	private static assertThrowsInvalidChannelNames(count: number) {
-		this.assertDoesThrowInvalidParameters(
-			{ channelNames: new Array(count).fill(generateId()) },
-			['channelNames']
-		)
-	}
-
-	private static assertDoesThrowInvalidParameters(
-		options: Partial<LslOutletOptions>,
-		parameters: string[]
-	) {
-		const err = assert.doesThrow(() => this.Outlet(options))
-		errorAssert.assertError(err, 'INVALID_PARAMETERS', {
-			parameters,
-		})
-	}
-
-	private static Outlet(options?: Partial<LslOutletOptions>) {
-		return LslOutlet.Outlet({
-			...this.randomOutletOptions,
-			...options,
-		})
-	}
-
-	private static StringOutlet() {
-		return this.Outlet({ channelFormat: 'string' })
-	}
-
-	private static FloatOutlet() {
-		return this.Outlet({ channelFormat: 'float32' })
-	}
+    private static fakeLiblsl: FakeLiblsl
+    private static randomOutletOptions: LslOutletOptions
+    private static channelFormatIdx: number
+
+    protected static async beforeEach() {
+        await super.beforeEach()
+        delete LslOutlet.Class
+        this.randomOutletOptions = generateRandomOutletOptions()
+
+        const channelFormat = this.randomOutletOptions.channelFormat
+        this.channelFormatIdx = TEST_CHANNEL_FORMATS_MAP[channelFormat]
+        this.fakeLiblsl = new FakeLiblsl()
+        LiblslImpl.setInstance(this.fakeLiblsl)
+    }
+
+    @test()
+    protected static async throwsWhenMissingRequiredParams() {
+        //@ts-ignore
+        const err = assert.doesThrow(() => new LslOutlet())
+        errorAssert.assertError(err, 'MISSING_PARAMETERS', {
+            parameters: [
+                'name',
+                'type',
+                'channelNames',
+                'sampleRate',
+                'channelFormat',
+                'sourceId',
+                'manufacturer',
+                'unit',
+                'chunkSize',
+                'maxBuffered',
+            ],
+        })
+    }
+
+    @test()
+    protected static async throwsWithInvalidChannelNames() {
+        this.assertThrowsInvalidChannelNames(0)
+    }
+
+    @test()
+    protected static async throwsWithInvalidSampleRate() {
+        this.Outlet({ sampleRate: 0 })
+        this.assertThrowsInvalidSampleRate(-1)
+        this.assertThrowsInvalidSampleRate(-1.5)
+    }
+
+    @test()
+    protected static async throwsWithInvalidChannelFormat() {
+        //@ts-ignore
+        this.assertDoesThrowInvalidParameters({ channelFormat: generateId() }, [
+            'channelFormat',
+        ])
+    }
+
+    @test()
+    protected static async throwsWithInvalidChunkSize() {
+        this.Outlet({ chunkSize: 0 })
+        this.assertThrowsInvalidChunkSize(-1)
+        this.assertThrowsInvalidChunkSize(-1.5)
+        this.assertThrowsInvalidChunkSize(1.5)
+    }
+
+    @test()
+    protected static async throwsWithInvalidMaxBuffered() {
+        this.Outlet({ maxBuffered: 0 })
+        this.assertThrowsInvalidMaxBuffered(-1)
+        this.assertThrowsInvalidMaxBuffered(-1.5)
+        this.assertThrowsInvalidMaxBuffered(1.5)
+    }
+
+    @test()
+    protected static async throwsWithUnsupportedType() {
+        for (let unsupportedType of TEST_UNSUPPORTED_CHANNEL_FORMATS) {
+            assert.doesThrow(
+                () => this.Outlet({ channelFormat: unsupportedType }),
+                `This method currently does not support the ${unsupportedType} type! Please implement it.`
+            )
+        }
+    }
+
+    @test()
+    protected static async supportsAllKnownChannelFormats() {
+        for (const format of TEST_SUPPORTED_CHANNEL_FORMATS) {
+            this.Outlet({ channelFormat: format as TestChannelFormat })
+        }
+    }
+
+    @test('pushing [1, 2] sample sends to LSL', [1.0, 2.0])
+    @test('pushing [1] sample sends to LSL', [1.0])
+    protected static async canPushFloatSampleToLsl(sample: LslSample) {
+        const outlet = this.FloatOutlet()
+        outlet.pushSample(sample)
+
+        assert.isEqual(
+            this.fakeLiblsl.lastPushSampleFloatTimestampOptions?.outlet,
+            this.fakeLiblsl.outlet
+        )
+        assert.isEqualDeep(
+            this.fakeLiblsl.lastPushSampleFloatTimestampOptions?.sample,
+            sample
+        )
+        assert.isEqualDeep(this.fakeLiblsl.lastCreateOutletOptions, {
+            info: this.fakeLiblsl.streamInfo,
+            chunkSize: this.randomOutletOptions.chunkSize,
+            maxBuffered: this.randomOutletOptions.maxBuffered,
+        })
+        assert.isNumber(
+            this.fakeLiblsl.lastPushSampleFloatTimestampOptions?.timestamp
+        )
+    }
+
+    @test()
+    protected static async canPushStringSampleToLsl() {
+        const sample = [generateId()]
+        const outlet = this.StringOutlet()
+
+        outlet.pushSample(sample)
+
+        assert.isEqual(
+            this.fakeLiblsl.lastPushSampleStringTimestampOptions?.outlet,
+            this.fakeLiblsl.outlet
+        )
+        assert.isEqualDeep(
+            this.fakeLiblsl.lastPushSampleStringTimestampOptions?.sample,
+            sample
+        )
+        assert.isNumber(
+            this.fakeLiblsl.lastPushSampleStringTimestampOptions?.timestamp
+        )
+    }
+
+    @test()
+    protected static async pushingStringTwiceGivesDifferentTimestamps() {
+        const outlet = this.StringOutlet()
+        const sample = [generateId()]
+
+        outlet.pushSample(sample)
+        const t1 =
+            this.fakeLiblsl.lastPushSampleStringTimestampOptions?.timestamp
+
+        await this.wait(10)
+
+        outlet.pushSample(sample)
+        const t2 =
+            this.fakeLiblsl.lastPushSampleStringTimestampOptions?.timestamp
+
+        assert.isNotEqual(t1, t2)
+        assert.isEqual(this.fakeLiblsl.localClockHitCount, 2)
+    }
+
+    @test()
+    protected static async constructionCreatesStreamInfo() {
+        this.Outlet()
+
+        const { ...options } = this.randomOutletOptions as any
+
+        options.channelCount = options.channelNames.length
+
+        delete options.manufacturer
+        delete options.unit
+        delete options.chunkSize
+        delete options.maxBuffered
+        delete options.channelNames
+
+        assert.isEqualDeep(this.fakeLiblsl.lastCreateStreamInfoOptions, {
+            ...options,
+            channelFormat: this.channelFormatIdx,
+        })
+    }
+
+    @test()
+    protected static async canOverrideClassInstantiatedInFactory() {
+        LslOutlet.Class = CheckingOutlet
+        const instance = this.Outlet()
+
+        assert.isInstanceOf(instance, CheckingOutlet)
+    }
+
+    @test('can add one label to channels', [generateId()])
+    @test('can add two labels to channels', [generateId(), generateId()])
+    protected static async appendsChannelsBasedOnCount(labels: string[]) {
+        const type = generateId()
+        const unit = generateId()
+
+        this.Outlet({ channelNames: labels, type, unit })
+
+        assert.isEqualDeep(
+            this.fakeLiblsl.lastAppendChannelsToStreamInfoOptions,
+            {
+                info: this.fakeLiblsl.streamInfo,
+                channels: labels.map((label) => ({
+                    label,
+                    type,
+                    unit,
+                })),
+            }
+        )
+    }
+
+    @test()
+    protected static async canDestroyOutlet() {
+        const outlet = this.Outlet()
+        outlet.destroy()
+
+        assert.isEqual(this.fakeLiblsl.destroyOutletHitCount, 1)
+    }
+
+    @test()
+    protected static async pushSampleShouldNotCreateMultipleOutlets() {
+        const outlet = this.FloatOutlet()
+        outlet.pushSample([1.0])
+        outlet.pushSample([2.0])
+        outlet.pushSample([3.0])
+
+        assert.isEqual(this.fakeLiblsl.createStreamInfoHitCount, 1)
+    }
+
+    private static assertThrowsInvalidMaxBuffered(maxBuffered: number) {
+        this.assertDoesThrowInvalidParameters({ maxBuffered }, ['maxBuffered'])
+    }
+
+    private static assertThrowsInvalidChunkSize(chunkSize: number) {
+        this.assertDoesThrowInvalidParameters({ chunkSize }, ['chunkSize'])
+    }
+
+    private static assertThrowsInvalidSampleRate(sampleRate: number) {
+        this.assertDoesThrowInvalidParameters({ sampleRate }, ['sampleRate'])
+    }
+
+    private static assertThrowsInvalidChannelNames(count: number) {
+        this.assertDoesThrowInvalidParameters(
+            { channelNames: new Array(count).fill(generateId()) },
+            ['channelNames']
+        )
+    }
+
+    private static assertDoesThrowInvalidParameters(
+        options: Partial<LslOutletOptions>,
+        parameters: string[]
+    ) {
+        const err = assert.doesThrow(() => this.Outlet(options))
+        errorAssert.assertError(err, 'INVALID_PARAMETERS', {
+            parameters,
+        })
+    }
+
+    private static Outlet(options?: Partial<LslOutletOptions>) {
+        return LslOutlet.Outlet({
+            ...this.randomOutletOptions,
+            ...options,
+        })
+    }
+
+    private static StringOutlet() {
+        return this.Outlet({ channelFormat: 'string' })
+    }
+
+    private static FloatOutlet() {
+        return this.Outlet({ channelFormat: 'float32' })
+    }
 }
 
 class CheckingOutlet extends LslOutlet {
-	public constructor(options: LslOutletOptions) {
-		super(options)
-	}
+    public constructor(options: LslOutletOptions) {
+        super(options)
+    }
 }