@neurodevs/node-lsl 0.0.1

package/build/LslOutlet.js

@@ -0,0 +1,122 @@
+"use strict";
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const schema_1 = require("@sprucelabs/schema");
+const Liblsl_1 = __importDefault(require("./Liblsl"));
+class LslOutlet {
+    constructor(options) {
+        const { channelCount, sampleRate, channelFormat, chunkSize, maxBuffered } = (0, schema_1.assertOptions)(options, [
+            'name',
+            'type',
+            'channelCount',
+            'sampleRate',
+            'channelFormat',
+            'sourceId',
+            'manufacturer',
+            'unit',
+            'chunkSize',
+            'maxBuffered',
+        ]);
+        this.assertValidChannelCount(channelCount);
+        this.assertValidSampleRate(sampleRate);
+        this.assertValidChannelFormat(channelFormat);
+        this.assertValidChunkSize(chunkSize);
+        this.assertValidMaxBufferred(maxBuffered);
+        this.outletOptions = options;
+    }
+    assertValidMaxBufferred(maxBuffered) {
+        if (!this.isPositiveIntegerOrZero(maxBuffered)) {
+            throw new schema_1.SchemaError({
+                code: 'INVALID_PARAMETERS',
+                parameters: ['maxBuffered'],
+                friendlyMessage: 'Max buffered must be a positive integer or zero.',
+            });
+        }
+    }
+    assertValidChunkSize(chunkSize) {
+        if (!this.isPositiveIntegerOrZero(chunkSize)) {
+            throw new schema_1.SchemaError({
+                code: 'INVALID_PARAMETERS',
+                parameters: ['chunkSize'],
+                friendlyMessage: 'Chunk size must be a positive integer or zero.',
+            });
+        }
+    }
+    assertValidChannelFormat(channelFormat) {
+        const validFormats = CHANNEL_FORMATS;
+        if (validFormats.indexOf(channelFormat) === -1) {
+            throw new schema_1.SchemaError({
+                code: 'INVALID_PARAMETERS',
+                parameters: ['channelFormat'],
+                friendlyMessage: 'Channel format must be a valid format.',
+            });
+        }
+    }
+    assertValidSampleRate(sampleRate) {
+        if (!this.isPositiveNumber(sampleRate)) {
+            throw new schema_1.SchemaError({
+                code: 'INVALID_PARAMETERS',
+                parameters: ['sampleRate'],
+                friendlyMessage: 'Sample rate must be a positive number.',
+            });
+        }
+    }
+    assertValidChannelCount(channelCount) {
+        if (!this.isPositiveInteger(channelCount)) {
+            throw new schema_1.SchemaError({
+                code: 'INVALID_PARAMETERS',
+                parameters: ['channelCount'],
+                friendlyMessage: 'Channel count must be a positive integer.',
+            });
+        }
+    }
+    isPositiveNumber(value) {
+        return value > 0;
+    }
+    isPositiveIntegerOrZero(value) {
+        return Number.isInteger(value) && value >= 0;
+    }
+    isPositiveInteger(value) {
+        return Number.isInteger(value) && value > 0;
+    }
+    get lsl() {
+        return Liblsl_1.default.getInstance();
+    }
+    pushSample(sample) {
+        const _a = this
+            .outletOptions, { chunkSize, maxBuffered } = _a, streamInfoOptions = __rest(_a, ["chunkSize", "maxBuffered"]);
+        delete streamInfoOptions.manufacturer;
+        delete streamInfoOptions.unit;
+        const info = this.lsl.createStreamInfo(Object.assign(Object.assign({}, streamInfoOptions), { channelFormat: CHANNEL_FORMATS.indexOf(this.outletOptions.channelFormat) }));
+        this.lsl.pushSample(this.lsl.createOutlet({
+            info,
+            chunkSize,
+            maxBuffered,
+        }), sample);
+    }
+}
+exports.default = LslOutlet;
+const CHANNEL_FORMATS = [
+    'undefined',
+    'float32',
+    'double64',
+    'string',
+    'int32',
+    'int16',
+    'int8',
+    'int64',
+];
+//# sourceMappingURL=LslOutlet.js.map

package/build/LslOutlet.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"LslOutlet.js","sourceRoot":"","sources":["../src/LslOutlet.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,+CAA+D;AAC/D,sDAAgD;AAEhD,MAAqB,SAAS;IAE7B,YAAmB,OAAyB;QAC3C,MAAM,EAAE,YAAY,EAAE,UAAU,EAAE,aAAa,EAAE,SAAS,EAAE,WAAW,EAAE,GACxE,IAAA,sBAAa,EAAC,OAAO,EAAE;YACtB,MAAM;YACN,MAAM;YACN,cAAc;YACd,YAAY;YACZ,eAAe;YACf,UAAU;YACV,cAAc;YACd,MAAM;YACN,WAAW;YACX,aAAa;SACb,CAAC,CAAA;QAEH,IAAI,CAAC,uBAAuB,CAAC,YAAY,CAAC,CAAA;QAC1C,IAAI,CAAC,qBAAqB,CAAC,UAAU,CAAC,CAAA;QACtC,IAAI,CAAC,wBAAwB,CAAC,aAAa,CAAC,CAAA;QAC5C,IAAI,CAAC,oBAAoB,CAAC,SAAS,CAAC,CAAA;QACpC,IAAI,CAAC,uBAAuB,CAAC,WAAW,CAAC,CAAA;QAEzC,IAAI,CAAC,aAAa,GAAG,OAAO,CAAA;IAC7B,CAAC;IAEO,uBAAuB,CAAC,WAAmB;QAClD,IAAI,CAAC,IAAI,CAAC,uBAAuB,CAAC,WAAW,CAAC,EAAE;YAC/C,MAAM,IAAI,oBAAW,CAAC;gBACrB,IAAI,EAAE,oBAAoB;gBAC1B,UAAU,EAAE,CAAC,aAAa,CAAC;gBAC3B,eAAe,EAAE,kDAAkD;aACnE,CAAC,CAAA;SACF;IACF,CAAC;IAEO,oBAAoB,CAAC,SAAiB;QAC7C,IAAI,CAAC,IAAI,CAAC,uBAAuB,CAAC,SAAS,CAAC,EAAE;YAC7C,MAAM,IAAI,oBAAW,CAAC;gBACrB,IAAI,EAAE,oBAAoB;gBAC1B,UAAU,EAAE,CAAC,WAAW,CAAC;gBACzB,eAAe,EAAE,gDAAgD;aACjE,CAAC,CAAA;SACF;IACF,CAAC;IAEO,wBAAwB,CAAC,aAA4B;QAC5D,MAAM,YAAY,GAAG,eAAe,CAAA;QAEpC,IAAI,YAAY,CAAC,OAAO,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC,EAAE;YAC/C,MAAM,IAAI,oBAAW,CAAC;gBACrB,IAAI,EAAE,oBAAoB;gBAC1B,UAAU,EAAE,CAAC,eAAe,CAAC;gBAC7B,eAAe,EAAE,wCAAwC;aACzD,CAAC,CAAA;SACF;IACF,CAAC;IAEO,qBAAqB,CAAC,UAAkB;QAC/C,IAAI,CAAC,IAAI,CAAC,gBAAgB,CAAC,UAAU,CAAC,EAAE;YACvC,MAAM,IAAI,oBAAW,CAAC;gBACrB,IAAI,EAAE,oBAAoB;gBAC1B,UAAU,EAAE,CAAC,YAAY,CAAC;gBAC1B,eAAe,EAAE,wCAAwC;aACzD,CAAC,CAAA;SACF;IACF,CAAC;IAEO,uBAAuB,CAAC,YAAoB;QACnD,IAAI,CAAC,IAAI,CAAC,iBAAiB,CAAC,YAAY,CAAC,EAAE;YAC1C,MAAM,IAAI,oBAAW,CAAC;gBACrB,IAAI,EAAE,oBAAoB;gBAC1B,UAAU,EAAE,CAAC,cAAc,CAAC;gBAC5B,eAAe,EAAE,2CAA2C;aAC5D,CAAC,CAAA;SACF;IACF,CAAC;IAEO,gBAAgB,CAAC,KAAa;QACrC,OAAO,KAAK,GAAG,CAAC,CAAA;IACjB,CAAC;IAEO,uBAAuB,CAAC,KAAa;QAC5C,OAAO,MAAM,CAAC,SAAS,CAAC,KAAK,CAAC,IAAI,KAAK,IAAI,CAAC,CAAA;IAC7C,CAAC;IAEO,iBAAiB,CAAC,KAAa;QACtC,OAAO,MAAM,CAAC,SAAS,CAAC,KAAK,CAAC,IAAI,KAAK,GAAG,CAAC,CAAA;IAC5C,CAAC;IAED,IAAY,GAAG;QACd,OAAO,gBAAU,CAAC,WAAW,EAAE,CAAA;IAChC,CAAC;IAEM,UAAU,CAAC,MAAiB;QAClC,MAAM,KAAmD,IAAI;aAC3D,aAAoB,EADhB,EAAE,SAAS,EAAE,WAAW,OACR,EADa,iBAAiB,cAA9C,4BAAgD,CAChC,CAAA;QAEtB,OAAO,iBAAiB,CAAC,YAAY,CAAA;QACrC,OAAO,iBAAiB,CAAC,IAAI,CAAA;QAE7B,MAAM,IAAI,GAAG,IAAI,CAAC,GAAG,CAAC,gBAAgB,iCAClC,iBAAiB,KACpB,aAAa,EAAE,eAAe,CAAC,OAAO,CAAC,IAAI,CAAC,aAAa,CAAC,aAAa,CAAC,IACvE,CAAA;QACF,IAAI,CAAC,GAAG,CAAC,UAAU,CAClB,IAAI,CAAC,GAAG,CAAC,YAAY,CAAC;YACrB,IAAI;YACJ,SAAS;YACT,WAAW;SACX,CAAC,EACF,MAAM,CACN,CAAA;IACF,CAAC;CACD;AAlHD,4BAkHC;AAED,MAAM,eAAe,GAAG;IACvB,WAAW;IACX,SAAS;IACT,UAAU;IACV,QAAQ;IACR,OAAO;IACP,OAAO;IACP,MAAM;IACN,OAAO;CACE,CAAA"}

package/build/__tests__/behavioral/LslOutlet.test.d.ts

@@ -0,0 +1,26 @@
+import AbstractSpruceTest from '@sprucelabs/test-utils';
+import { LslSample } from '../../Liblsl';
+export declare const CHANNEL_FORMATS: readonly ["undefined", "float32", "double64", "string", "int32", "int16", "int8", "int64"];
+export default class LslOutletTest extends AbstractSpruceTest {
+    private static spyLsl;
+    private static randomOutletOptions;
+    private static channelIdx;
+    protected static beforeEach(): Promise<void>;
+    protected static throwsWhenMissingRequiredParameters(): Promise<void>;
+    protected static canCreateWithRequiredParams(): Promise<void>;
+    protected static throwsWithInvalidChannelCount(): Promise<void>;
+    protected static throwsWithInvalidSampleRate(): Promise<void>;
+    protected static throwsWithInvalidChannelFormat(): Promise<void>;
+    protected static supportsAllKnownChannelFormats(): Promise<void>;
+    protected static throwWithInvalidChunkSize(): Promise<void>;
+    protected static throwsWithInvalidMaxBuffered(): Promise<void>;
+    protected static pushingSampleSendsToLsl(sample: LslSample): Promise<void>;
+    protected static pushingSamplePassesCorrectOptionsToCreateStreamInfo(): Promise<void>;
+    private static pushSample;
+    private static assertThrowsInvalidMaxBuffered;
+    private static assertThrowsInvalidChunkSize;
+    private static assertThrowsInvalidSampleRate;
+    private static assertThrowsInvalidChannelCount;
+    private static assertDoesThrowInvalidParameters;
+    private static Outlet;
+}

package/build/__tests__/behavioral/LslOutlet.test.js

@@ -0,0 +1,232 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CHANNEL_FORMATS = void 0;
+const crypto_1 = require("crypto");
+const test_utils_1 = __importStar(require("@sprucelabs/test-utils"));
+const Liblsl_1 = __importDefault(require("../../Liblsl"));
+const LslOutlet_1 = __importDefault(require("../../LslOutlet"));
+exports.CHANNEL_FORMATS = [
+    'undefined',
+    'float32',
+    'double64',
+    'string',
+    'int32',
+    'int16',
+    'int8',
+    'int64',
+];
+class LslOutletTest extends test_utils_1.default {
+    static async beforeEach() {
+        await super.beforeEach();
+        this.channelIdx = (0, crypto_1.randomInt)(7);
+        this.randomOutletOptions = {
+            name: (0, test_utils_1.generateId)(),
+            type: (0, test_utils_1.generateId)(),
+            channelCount: (0, crypto_1.randomInt)(1, 10),
+            sampleRate: Math.random() * 10,
+            channelFormat: exports.CHANNEL_FORMATS[this.channelIdx],
+            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),
+        };
+        this.spyLsl = new SpyLiblsl();
+        Liblsl_1.default.setInstance(this.spyLsl);
+    }
+    static async throwsWhenMissingRequiredParameters() {
+        //@ts-ignore
+        const err = test_utils_1.assert.doesThrow(() => new LslOutlet_1.default());
+        test_utils_1.errorAssert.assertError(err, 'MISSING_PARAMETERS', {
+            parameters: [
+                'name',
+                'type',
+                'channelCount',
+                'sampleRate',
+                'channelFormat',
+                'sourceId',
+                'manufacturer',
+                'unit',
+                'chunkSize',
+                'maxBuffered',
+            ],
+        });
+    }
+    static async canCreateWithRequiredParams() {
+        this.Outlet();
+    }
+    static async throwsWithInvalidChannelCount() {
+        this.assertThrowsInvalidChannelCount(0);
+        this.assertThrowsInvalidChannelCount(-1);
+        this.assertThrowsInvalidChannelCount(1.5);
+    }
+    static async throwsWithInvalidSampleRate() {
+        this.assertThrowsInvalidSampleRate(0);
+        this.assertThrowsInvalidSampleRate(-1);
+        this.assertThrowsInvalidSampleRate(-1.5);
+    }
+    static async throwsWithInvalidChannelFormat() {
+        //@ts-ignore
+        this.assertDoesThrowInvalidParameters({ channelFormat: (0, test_utils_1.generateId)() }, [
+            'channelFormat',
+        ]);
+    }
+    static async supportsAllKnownChannelFormats() {
+        const valid = exports.CHANNEL_FORMATS;
+        for (const format of valid) {
+            this.Outlet({ channelFormat: format });
+        }
+    }
+    static async throwWithInvalidChunkSize() {
+        this.Outlet({ chunkSize: 0 });
+        this.assertThrowsInvalidChunkSize(-1);
+        this.assertThrowsInvalidChunkSize(-1.5);
+        this.assertThrowsInvalidChunkSize(1.5);
+    }
+    static async throwsWithInvalidMaxBuffered() {
+        this.Outlet({ maxBuffered: 0 });
+        this.assertThrowsInvalidMaxBuffered(-1);
+        this.assertThrowsInvalidMaxBuffered(-1.5);
+        this.assertThrowsInvalidMaxBuffered(1.5);
+    }
+    static async pushingSampleSendsToLsl(sample) {
+        this.pushSample(sample);
+        test_utils_1.assert.isEqual(this.spyLsl.lastPushedOutlet, this.spyLsl.outlet);
+        test_utils_1.assert.isEqualDeep(this.spyLsl.lastPushedSample, sample);
+        test_utils_1.assert.isEqualDeep(this.spyLsl.lastOutletOptions, {
+            info: this.spyLsl.streamInfo,
+            chunkSize: this.randomOutletOptions.chunkSize,
+            maxBuffered: this.randomOutletOptions.maxBuffered,
+        });
+    }
+    static async pushingSamplePassesCorrectOptionsToCreateStreamInfo() {
+        this.pushSample([1]);
+        const options = __rest(this.randomOutletOptions, []);
+        delete options.manufacturer;
+        delete options.unit;
+        delete options.chunkSize;
+        delete options.maxBuffered;
+        test_utils_1.assert.isEqualDeep(this.spyLsl.lastStreamInfoOptions, Object.assign(Object.assign({}, options), { channelFormat: this.channelIdx }));
+    }
+    static pushSample(sample) {
+        const outlet = this.Outlet();
+        outlet.pushSample(sample);
+    }
+    static assertThrowsInvalidMaxBuffered(maxBuffered) {
+        this.assertDoesThrowInvalidParameters({ maxBuffered }, ['maxBuffered']);
+    }
+    static assertThrowsInvalidChunkSize(chunkSize) {
+        this.assertDoesThrowInvalidParameters({ chunkSize }, ['chunkSize']);
+    }
+    static assertThrowsInvalidSampleRate(sampleRate) {
+        this.assertDoesThrowInvalidParameters({ sampleRate }, ['sampleRate']);
+    }
+    static assertThrowsInvalidChannelCount(count) {
+        this.assertDoesThrowInvalidParameters({ channelCount: count }, [
+            'channelCount',
+        ]);
+    }
+    static assertDoesThrowInvalidParameters(options, parameters) {
+        const err = test_utils_1.assert.doesThrow(() => this.Outlet(options));
+        test_utils_1.errorAssert.assertError(err, 'INVALID_PARAMETERS', {
+            parameters,
+        });
+    }
+    static Outlet(options) {
+        return new LslOutlet_1.default(Object.assign(Object.assign({}, this.randomOutletOptions), options));
+    }
+}
+exports.default = LslOutletTest;
+__decorate([
+    (0, test_utils_1.test)()
+], LslOutletTest, "throwsWhenMissingRequiredParameters", null);
+__decorate([
+    (0, test_utils_1.test)()
+], LslOutletTest, "canCreateWithRequiredParams", null);
+__decorate([
+    (0, test_utils_1.test)()
+], LslOutletTest, "throwsWithInvalidChannelCount", null);
+__decorate([
+    (0, test_utils_1.test)()
+], LslOutletTest, "throwsWithInvalidSampleRate", null);
+__decorate([
+    (0, test_utils_1.test)()
+], LslOutletTest, "throwsWithInvalidChannelFormat", null);
+__decorate([
+    (0, test_utils_1.test)()
+], LslOutletTest, "supportsAllKnownChannelFormats", null);
+__decorate([
+    (0, test_utils_1.test)()
+], LslOutletTest, "throwWithInvalidChunkSize", null);
+__decorate([
+    (0, test_utils_1.test)()
+], LslOutletTest, "throwsWithInvalidMaxBuffered", null);
+__decorate([
+    (0, test_utils_1.test)('pushing sample sends to lsl 1', [1]),
+    (0, test_utils_1.test)('pushing sample sends to lsl 2', [1, 2])
+], LslOutletTest, "pushingSampleSendsToLsl", null);
+__decorate([
+    (0, test_utils_1.test)()
+], LslOutletTest, "pushingSamplePassesCorrectOptionsToCreateStreamInfo", null);
+class SpyLiblsl {
+    constructor() {
+        this.outlet = {};
+        this.streamInfo = {};
+    }
+    createStreamInfo(options) {
+        this.lastStreamInfoOptions = options;
+        return this.streamInfo;
+    }
+    createOutlet(options) {
+        this.lastOutletOptions = options;
+        return this.outlet;
+    }
+    pushSample(outlet, sample) {
+        this.lastPushedOutlet = outlet;
+        this.lastPushedSample = sample;
+    }
+}
+//# sourceMappingURL=LslOutlet.test.js.map

package/build/__tests__/behavioral/LslOutlet.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"LslOutlet.test.js","sourceRoot":"","sources":["../../../src/__tests__/behavioral/LslOutlet.test.ts"],"names":[],"mappings":"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"}

package/build/__tests__/implementation/Liblsl.test.d.ts

@@ -0,0 +1,28 @@
+import AbstractSpruceTest from '@sprucelabs/test-utils';
+export default class LiblslTest extends AbstractSpruceTest {
+    private static lsl;
+    private static libraryPath?;
+    private static libraryOptions?;
+    private static fakeBindings;
+    private static fakeStreamInfo;
+    private static fakeOutlet;
+    private static createStreamInfoParams?;
+    private static createOutletParams?;
+    private static pushSampleParams?;
+    private static localClock;
+    private static shouldThrowWhenCreatingBindings;
+    protected static beforeEach(): Promise<void>;
+    protected static throwsIfNoEnvSet(): Promise<void>;
+    protected static throwsHelpfulErrorWhenBindingsFailToLoad(): Promise<void>;
+    protected static worksAsASingleton(): Promise<void>;
+    protected static singletonIsTheSame(): Promise<void>;
+    protected static canSetInstance(): void;
+    protected static createsExpectedBindingsToLiblsl(): Promise<void>;
+    protected static createStreamInfoThrowsWithMissingRequiredParams(): void;
+    protected static canGetStreamInfoWithRequiredParams(): Promise<void>;
+    protected static createOutletThrowsWhenMissingRequiredParams(): Promise<void>;
+    protected static canCreateOutletWithRequiredParams(): Promise<void>;
+    protected static pushSampleThrowsWhenMissingRequiredParams(): Promise<void>;
+    protected static pushSampleCallsBindings(): Promise<void>;
+    private static generateRandomCreateStreamInfoOptions;
+}

package/build/__tests__/implementation/Liblsl.test.js

@@ -0,0 +1,236 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const crypto_1 = require("crypto");
+const test_utils_1 = __importStar(require("@sprucelabs/test-utils"));
+const ref_array_napi_1 = __importDefault(require("ref-array-napi"));
+const ref_napi_1 = __importDefault(require("ref-napi"));
+const Liblsl_1 = __importDefault(require("../../Liblsl"));
+class LiblslTest extends test_utils_1.default {
+    static async beforeEach() {
+        await super.beforeEach();
+        delete this.libraryPath;
+        delete this.libraryOptions;
+        delete this.createStreamInfoParams;
+        delete this.createOutletParams;
+        delete this.pushSampleParams;
+        process.env.LIBLSL_PATH = (0, test_utils_1.generateId)();
+        this.fakeStreamInfo = {};
+        this.fakeOutlet = {};
+        this.localClock = new Date().getTime();
+        this.shouldThrowWhenCreatingBindings = false;
+        this.fakeBindings = {
+            lsl_create_streaminfo: (...params) => {
+                this.createStreamInfoParams = params;
+                return this.fakeStreamInfo;
+            },
+            lsl_create_outlet: (...params) => {
+                this.createOutletParams = params;
+                return this.fakeOutlet;
+            },
+            lsl_push_sample_ft: (...params) => {
+                this.pushSampleParams = params;
+                return 0;
+            },
+            lsl_local_clock: () => this.localClock,
+        };
+        Liblsl_1.default.ffi = {
+            //@ts-ignore
+            Library: (path, options) => {
+                this.libraryPath = path;
+                this.libraryOptions = options;
+                if (this.shouldThrowWhenCreatingBindings) {
+                    throw new Error('Failed to create bindings');
+                }
+                return this.fakeBindings;
+            },
+        };
+        Liblsl_1.default.reset();
+        this.lsl = Liblsl_1.default.getInstance();
+    }
+    static async throwsIfNoEnvSet() {
+        delete process.env.LIBLSL_PATH;
+        const err = test_utils_1.assert.doesThrow(() => new Liblsl_1.default());
+        test_utils_1.errorAssert.assertError(err, 'MISSING_PARAMETERS', {
+            parameters: ['env.LIBLSL_PATH'],
+        });
+    }
+    static async throwsHelpfulErrorWhenBindingsFailToLoad() {
+        this.shouldThrowWhenCreatingBindings = true;
+        const err = test_utils_1.assert.doesThrow(() => new Liblsl_1.default());
+        test_utils_1.errorAssert.assertError(err, 'FAILED_TO_LOAD_LIBLSL', {
+            liblslPath: process.env.LIBLSL_PATH,
+        });
+    }
+    static async worksAsASingleton() {
+        const liblsl = Liblsl_1.default.getInstance();
+        test_utils_1.assert.isInstanceOf(liblsl, Liblsl_1.default);
+    }
+    static async singletonIsTheSame() {
+        test_utils_1.assert.isEqual(Liblsl_1.default.getInstance(), Liblsl_1.default.getInstance());
+    }
+    static canSetInstance() {
+        const fake = new FakeLiblsl();
+        Liblsl_1.default.setInstance(fake);
+        test_utils_1.assert.isEqual(Liblsl_1.default.getInstance(), fake);
+    }
+    static async createsExpectedBindingsToLiblsl() {
+        process.env.LIBLSL_PATH = (0, test_utils_1.generateId)();
+        new Liblsl_1.default();
+        test_utils_1.assert.isEqual(this.libraryPath, process.env.LIBLSL_PATH);
+        const expected = {
+            lsl_create_streaminfo: [
+                streamInfo,
+                ['string', 'string', 'int', 'double', 'int', 'string'],
+            ],
+            lsl_create_outlet: [outletType, [streamInfo, 'int', 'int']],
+            lsl_local_clock: ['double', []],
+            lsl_push_sample_ft: ['void', [outletType, FloatArray, 'double']],
+        };
+        test_utils_1.assert.isEqual(JSON.stringify(this.libraryOptions), JSON.stringify(expected));
+    }
+    static createStreamInfoThrowsWithMissingRequiredParams() {
+        //@ts-ignore
+        const err = test_utils_1.assert.doesThrow(() => this.lsl.createStreamInfo());
+        test_utils_1.errorAssert.assertError(err, 'MISSING_PARAMETERS', {
+            parameters: [
+                'name',
+                'type',
+                'channelCount',
+                'sampleRate',
+                'channelFormat',
+                'sourceId',
+            ],
+        });
+    }
+    static async canGetStreamInfoWithRequiredParams() {
+        const options = this.generateRandomCreateStreamInfoOptions();
+        const actual = this.lsl.createStreamInfo(options);
+        test_utils_1.assert.isEqual(actual, this.fakeStreamInfo);
+        test_utils_1.assert.isEqualDeep(this.createStreamInfoParams, Object.values(options));
+    }
+    static async createOutletThrowsWhenMissingRequiredParams() {
+        //@ts-ignore
+        const err = test_utils_1.assert.doesThrow(() => this.lsl.createOutlet({}));
+        test_utils_1.errorAssert.assertError(err, 'MISSING_PARAMETERS', {
+            parameters: ['info', 'chunkSize', 'maxBuffered'],
+        });
+    }
+    static async canCreateOutletWithRequiredParams() {
+        const info = this.lsl.createStreamInfo(this.generateRandomCreateStreamInfoOptions());
+        const options = {
+            info,
+            chunkSize: (0, crypto_1.randomInt)(10),
+            maxBuffered: (0, crypto_1.randomInt)(10),
+        };
+        const actual = this.lsl.createOutlet(options);
+        test_utils_1.assert.isEqualDeep(this.createOutletParams, Object.values(options));
+        test_utils_1.assert.isEqual(actual, this.fakeOutlet);
+    }
+    static async pushSampleThrowsWhenMissingRequiredParams() {
+        //@ts-ignore
+        const err = test_utils_1.assert.doesThrow(() => this.lsl.pushSample());
+        test_utils_1.errorAssert.assertError(err, 'MISSING_PARAMETERS', {
+            parameters: ['outlet', 'sample'],
+        });
+    }
+    static async pushSampleCallsBindings() {
+        var _a, _b, _c;
+        const expected = [1, 2, 3];
+        this.lsl.pushSample(this.fakeOutlet, expected);
+        test_utils_1.assert.isEqual((_a = this.pushSampleParams) === null || _a === void 0 ? void 0 : _a[0], this.fakeOutlet);
+        test_utils_1.assert.isEqual((_b = this.pushSampleParams) === null || _b === void 0 ? void 0 : _b[1], expected);
+        test_utils_1.assert.isEqual((_c = this.pushSampleParams) === null || _c === void 0 ? void 0 : _c[2], this.localClock);
+    }
+    static generateRandomCreateStreamInfoOptions() {
+        return {
+            name: (0, test_utils_1.generateId)(),
+            type: (0, test_utils_1.generateId)(),
+            channelCount: (0, crypto_1.randomInt)(10),
+            sampleRate: (0, crypto_1.randomInt)(10),
+            channelFormat: (0, crypto_1.randomInt)(10),
+            sourceId: (0, test_utils_1.generateId)(),
+        };
+    }
+}
+exports.default = LiblslTest;
+__decorate([
+    (0, test_utils_1.test)()
+], LiblslTest, "throwsIfNoEnvSet", null);
+__decorate([
+    (0, test_utils_1.test)()
+], LiblslTest, "throwsHelpfulErrorWhenBindingsFailToLoad", null);
+__decorate([
+    (0, test_utils_1.test)()
+], LiblslTest, "worksAsASingleton", null);
+__decorate([
+    (0, test_utils_1.test)()
+], LiblslTest, "singletonIsTheSame", null);
+__decorate([
+    (0, test_utils_1.test)()
+], LiblslTest, "canSetInstance", null);
+__decorate([
+    (0, test_utils_1.test)()
+], LiblslTest, "createsExpectedBindingsToLiblsl", null);
+__decorate([
+    (0, test_utils_1.test)()
+], LiblslTest, "createStreamInfoThrowsWithMissingRequiredParams", null);
+__decorate([
+    (0, test_utils_1.test)()
+], LiblslTest, "canGetStreamInfoWithRequiredParams", null);
+__decorate([
+    (0, test_utils_1.test)()
+], LiblslTest, "createOutletThrowsWhenMissingRequiredParams", null);
+__decorate([
+    (0, test_utils_1.test)()
+], LiblslTest, "canCreateOutletWithRequiredParams", null);
+__decorate([
+    (0, test_utils_1.test)()
+], LiblslTest, "pushSampleThrowsWhenMissingRequiredParams", null);
+__decorate([
+    (0, test_utils_1.test)()
+], LiblslTest, "pushSampleCallsBindings", null);
+class FakeLiblsl {
+    createOutlet(_options) {
+        return {};
+    }
+    createStreamInfo(_options) {
+        return {};
+    }
+    pushSample(_sample) { }
+}
+const streamInfo = ref_napi_1.default.refType(ref_napi_1.default.types.void);
+const outletType = ref_napi_1.default.refType(ref_napi_1.default.types.void);
+const FloatArray = (0, ref_array_napi_1.default)(ref_napi_1.default.types.float);
+//# sourceMappingURL=Liblsl.test.js.map