@neurodevs/node-lsl 8.0.1 → 8.0.3

package/src/__tests__/support/consts.ts

@@ -1,34 +1,34 @@
 export const TEST_SUPPORTED_CHANNEL_FORMATS = ['float32', 'string'] as const
 
 export const TEST_UNSUPPORTED_CHANNEL_FORMATS = [
-	'undefined',
-	'double64',
-	'int32',
-	'int16',
-	'int8',
-	'int64',
+    'undefined',
+    'double64',
+    'int32',
+    'int16',
+    'int8',
+    'int64',
 ] as const
 
 export const TEST_CHANNEL_FORMATS = [
-	'undefined',
-	'float32',
-	'double64',
-	'string',
-	'int32',
-	'int16',
-	'int8',
-	'int64',
+    'undefined',
+    'float32',
+    'double64',
+    'string',
+    'int32',
+    'int16',
+    'int8',
+    'int64',
 ] as const
 
 export const TEST_CHANNEL_FORMATS_MAP = {
-	undefined: 0,
-	float32: 1,
-	double64: 2,
-	string: 3,
-	int32: 4,
-	int16: 5,
-	int8: 6,
-	int64: 7,
+    undefined: 0,
+    float32: 1,
+    double64: 2,
+    string: 3,
+    int32: 4,
+    int16: 5,
+    int8: 6,
+    int64: 7,
 }
 
 export type TestChannelFormat = (typeof TEST_CHANNEL_FORMATS)[number]

package/src/__tests__/support/generateRandomOutletOptions.ts

@@ -4,18 +4,18 @@ import { LslOutletOptions } from '../../nodeLsl.types'
 import { TEST_SUPPORTED_CHANNEL_FORMATS } from './consts'
 
 export default function generateRandomOutletOptions() {
-	const randomChannelIdx = randomInt(TEST_SUPPORTED_CHANNEL_FORMATS.length)
+    const randomChannelIdx = randomInt(TEST_SUPPORTED_CHANNEL_FORMATS.length)
 
-	return {
-		name: generateId(),
-		type: generateId(),
-		channelNames: new Array(randomInt(1, 10)).fill(generateId()),
-		sampleRate: Math.random() * 10,
-		channelFormat: TEST_SUPPORTED_CHANNEL_FORMATS[randomChannelIdx],
-		sourceId: generateId(),
-		manufacturer: generateId(),
-		unit: generateId(),
-		chunkSize: randomInt(0, 10),
-		maxBuffered: randomInt(0, 10),
-	} as LslOutletOptions
+    return {
+        name: generateId(),
+        type: generateId(),
+        channelNames: new Array(randomInt(1, 10)).fill(generateId()),
+        sampleRate: Math.random() * 10,
+        channelFormat: TEST_SUPPORTED_CHANNEL_FORMATS[randomChannelIdx],
+        sourceId: generateId(),
+        manufacturer: generateId(),
+        unit: generateId(),
+        chunkSize: randomInt(0, 10),
+        maxBuffered: randomInt(0, 10),
+    } as LslOutletOptions
 }

package/src/assertions.ts

@@ -2,58 +2,58 @@ import { SchemaError } from '@sprucelabs/schema'
 import { CHANNEL_FORMATS } from './consts'
 import { ChannelFormat } from './nodeLsl.types'
 import {
-	isGreaterThanOrEqualToZero,
-	isPositiveInteger,
-	isPositiveIntegerOrZero,
-	isStringInArray,
+    isGreaterThanOrEqualToZero,
+    isPositiveInteger,
+    isPositiveIntegerOrZero,
+    isStringInArray,
 } from './validations'
 
 export function assertValidMaxBuffered(maxBuffered: number) {
-	if (!isPositiveIntegerOrZero(maxBuffered)) {
-		throw new SchemaError({
-			code: 'INVALID_PARAMETERS',
-			parameters: ['maxBuffered'],
-			friendlyMessage: 'Max buffered must be a positive integer or zero.',
-		})
-	}
+    if (!isPositiveIntegerOrZero(maxBuffered)) {
+        throw new SchemaError({
+            code: 'INVALID_PARAMETERS',
+            parameters: ['maxBuffered'],
+            friendlyMessage: 'Max buffered must be a positive integer or zero.',
+        })
+    }
 }
 
 export function assertValidChunkSize(chunkSize: number) {
-	if (!isPositiveIntegerOrZero(chunkSize)) {
-		throw new SchemaError({
-			code: 'INVALID_PARAMETERS',
-			parameters: ['chunkSize'],
-			friendlyMessage: 'Chunk size must be a positive integer or zero.',
-		})
-	}
+    if (!isPositiveIntegerOrZero(chunkSize)) {
+        throw new SchemaError({
+            code: 'INVALID_PARAMETERS',
+            parameters: ['chunkSize'],
+            friendlyMessage: 'Chunk size must be a positive integer or zero.',
+        })
+    }
 }
 
 export function assertValidChannelFormat(channelFormat: ChannelFormat) {
-	if (!isStringInArray(channelFormat, CHANNEL_FORMATS)) {
-		throw new SchemaError({
-			code: 'INVALID_PARAMETERS',
-			parameters: ['channelFormat'],
-			friendlyMessage: `Invalid `,
-		})
-	}
+    if (!isStringInArray(channelFormat, CHANNEL_FORMATS)) {
+        throw new SchemaError({
+            code: 'INVALID_PARAMETERS',
+            parameters: ['channelFormat'],
+            friendlyMessage: `Invalid `,
+        })
+    }
 }
 
 export function assertValidSampleRate(sampleRate: number) {
-	if (!isGreaterThanOrEqualToZero(sampleRate)) {
-		throw new SchemaError({
-			code: 'INVALID_PARAMETERS',
-			parameters: ['sampleRate'],
-			friendlyMessage: 'Sample rate must be a positive number or zero.',
-		})
-	}
+    if (!isGreaterThanOrEqualToZero(sampleRate)) {
+        throw new SchemaError({
+            code: 'INVALID_PARAMETERS',
+            parameters: ['sampleRate'],
+            friendlyMessage: 'Sample rate must be a positive number or zero.',
+        })
+    }
 }
 
 export function assertValidChannelCount(channelCount: number) {
-	if (!isPositiveInteger(channelCount)) {
-		throw new SchemaError({
-			code: 'INVALID_PARAMETERS',
-			parameters: ['channelNames'],
-			friendlyMessage: 'channelNames must have 1 or more labels.',
-		})
-	}
+    if (!isPositiveInteger(channelCount)) {
+        throw new SchemaError({
+            code: 'INVALID_PARAMETERS',
+            parameters: ['channelNames'],
+            friendlyMessage: 'channelNames must have 1 or more labels.',
+        })
+    }
 }

package/src/consts.ts

@@ -1,21 +1,21 @@
 export const CHANNEL_FORMATS = [
-	'undefined',
-	'float32',
-	'double64',
-	'string',
-	'int32',
-	'int16',
-	'int8',
-	'int64',
+    'undefined',
+    'float32',
+    'double64',
+    'string',
+    'int32',
+    'int16',
+    'int8',
+    'int64',
 ] as const
 
 export const CHANNEL_FORMATS_MAP = {
-	undefined: 0,
-	float32: 1,
-	double64: 2,
-	string: 3,
-	int32: 4,
-	int16: 5,
-	int8: 6,
-	int64: 7,
+    undefined: 0,
+    float32: 1,
+    double64: 2,
+    string: 3,
+    int32: 4,
+    int16: 5,
+    int8: 6,
+    int64: 7,
 }

package/src/errors/SpruceError.ts

@@ -2,22 +2,22 @@ import BaseSpruceError from '@sprucelabs/error'
 import ErrorOptions from '#spruce/errors/options.types'
 
 export default class SpruceError extends BaseSpruceError<ErrorOptions> {
-	/** an easy to understand version of the errors */
-	public friendlyMessage(): string {
-		const { options } = this
-		let message
-		switch (options?.code) {
-			case 'FAILED_TO_LOAD_LIBLSL':
-				message = `Well shoot! Loading the liblsl dylib failed. I tried to load it from ${options.liblslPath}.`
-				break
-			default:
-				message = super.friendlyMessage()
-		}
+    /** an easy to understand version of the errors */
+    public friendlyMessage(): string {
+        const { options } = this
+        let message
+        switch (options?.code) {
+            case 'FAILED_TO_LOAD_LIBLSL':
+                message = `Well shoot! Loading the liblsl dylib failed. I tried to load it from ${options.liblslPath}.`
+                break
+            default:
+                message = super.friendlyMessage()
+        }
 
-		const fullMessage = options.friendlyMessage
-			? options.friendlyMessage
-			: message
+        const fullMessage = options.friendlyMessage
+            ? options.friendlyMessage
+            : message
 
-		return fullMessage
-	}
+        return fullMessage
+    }
 }

package/src/errors/failedToLoadLiblsl.builder.ts

@@ -1,12 +1,12 @@
 import { buildErrorSchema } from '@sprucelabs/schema'
 
 export default buildErrorSchema({
-	id: 'failedToLoadLiblsl',
-	name: 'FAILED_TO_LOAD_LIBLSL',
-	fields: {
-		liblslPath: {
-			type: 'text',
-			isRequired: true,
-		},
-	},
+    id: 'failedToLoadLiblsl',
+    name: 'FAILED_TO_LOAD_LIBLSL',
+    fields: {
+        liblslPath: {
+            type: 'text',
+            isRequired: true,
+        },
+    },
 })