@neurodevs/node-lsl 17.1.1 → 18.1.0

package/src/testDoubles/StreamInlet/FakeStreamInlet.ts

@@ -1,40 +1,34 @@
-import { StreamInfo } from '../../impl/LslStreamInfo.js'
 import {
+    OnDataCallback,
     StreamInlet,
-    StreamInletConstructorOptions,
+    StreamInletOptions,
 } from '../../impl/LslStreamInlet.js'
 
 export default class FakeStreamInlet implements StreamInlet {
     public static callsToConstructor: {
-        info?: StreamInfo
-        options?: StreamInletConstructorOptions
-        onData?: (samples: Float32Array, timestamps: Float64Array) => void
+        options?: StreamInletOptions
+        onData?: OnDataCallback
     }[] = []
 
     public static numCallsToStartPulling = 0
     public static numCallsToStopPulling = 0
-    public static numCallsToFlushQueue = 0
+    public static numCallsToFlushInlet = 0
     public static numCallsToDestroy = 0
 
     public isRunning = false
 
-    protected onData!: (samples: Float32Array, timestamps: Float64Array) => void
+    protected onData!: OnDataCallback
 
-    public constructor(
-        info?: StreamInfo,
-        options?: StreamInletConstructorOptions,
-        onData?: (samples: Float32Array, timestamps: Float64Array) => void
-    ) {
+    public constructor(options?: StreamInletOptions, onData?: OnDataCallback) {
         this.onData = onData ?? (() => {})
 
         FakeStreamInlet.callsToConstructor.push({
-            info,
             options,
             onData: this.onData,
         })
     }
 
-    public startPulling() {
+    public async startPulling() {
         FakeStreamInlet.numCallsToStartPulling++
         this.isRunning = true
     }
@@ -44,8 +38,8 @@ export default class FakeStreamInlet implements StreamInlet {
         this.isRunning = false
     }
 
-    public flushQueue() {
-        FakeStreamInlet.numCallsToFlushQueue++
+    public flushInlet() {
+        FakeStreamInlet.numCallsToFlushInlet++
     }
 
     public destroy() {
@@ -55,7 +49,7 @@ export default class FakeStreamInlet implements StreamInlet {
     public static resetTestDouble() {
         FakeStreamInlet.callsToConstructor = []
         FakeStreamInlet.numCallsToStartPulling = 0
-        FakeStreamInlet.numCallsToFlushQueue = 0
+        FakeStreamInlet.numCallsToFlushInlet = 0
         FakeStreamInlet.numCallsToDestroy = 0
     }
 }

package/src/testDoubles/StreamInlet/SpyStreamInlet.ts

@@ -1,23 +1,10 @@
-import { StreamInfo } from '../../impl/LslStreamInfo.js'
 import LslStreamInlet, {
     OnDataCallback,
-    StreamInletConstructorOptions,
+    StreamInletOptions,
 } from '../../impl/LslStreamInlet.js'
 
 export class SpyStreamInlet extends LslStreamInlet {
-    public constructor(
-        info: StreamInfo,
-        options: StreamInletConstructorOptions,
-        onData: OnDataCallback
-    ) {
-        super(info, options, onData)
-    }
-
-    public getStreamInfo() {
-        return this.info
-    }
-
-    public getBoundInlet() {
-        return this.inlet
+    public constructor(options: StreamInletOptions, onData: OnDataCallback) {
+        super(options, onData)
     }
 }

package/src/testDoubles/StreamOutlet/FakeStreamOutlet.ts

@@ -1,30 +1,27 @@
-import { randomInt } from 'crypto'
+import { randomInt } from 'node:crypto'
+
 import generateId from '@neurodevs/generate-id'
+import { LslSample } from '@neurodevs/ndx-native'
 
-import { LslSample } from 'impl/LiblslAdapter.js'
-import { StreamInfo } from '../../impl/LslStreamInfo.js'
 import {
     StreamOutlet,
     StreamOutletOptions,
 } from '../../impl/LslStreamOutlet.js'
-import FakeStreamInfo from '../StreamInfo/FakeStreamInfo.js'
 
 export default class FakeStreamOutlet implements StreamOutlet {
-    public static callsToConstructor: {
-        info?: StreamInfo
-        options?: StreamOutletOptions
+    public static callsToConstructor: (StreamOutletOptions | undefined)[] = []
+
+    public static callsToPushSample: {
+        sample: LslSample
+        timestampSec?: number
     }[] = []
 
-    public static callsToPushSample: LslSample[] = []
     public static numCallsToDestroy = 0
 
-    public info: StreamInfo
     public options?: StreamOutletOptions
 
-    public constructor(info?: StreamInfo, options?: StreamOutletOptions) {
-        FakeStreamOutlet.callsToConstructor.push({ info, options })
-
-        this.info = info ?? new FakeStreamInfo()
+    public constructor(options?: StreamOutletOptions) {
+        FakeStreamOutlet.callsToConstructor.push(options)
         this.options = options
     }
 
@@ -32,8 +29,11 @@ export default class FakeStreamOutlet implements StreamOutlet {
         FakeStreamOutlet.numCallsToDestroy++
     }
 
-    public pushSample(sample: LslSample) {
-        FakeStreamOutlet.callsToPushSample.push(sample)
+    public pushSample(sample: LslSample, timestampSec?: number) {
+        FakeStreamOutlet.callsToPushSample.push({
+            sample,
+            timestampSec,
+        })
     }
 
     public get name() {

package/src/testDoubles/WebSocketBridge/FakeWebSocketBridge.ts

@@ -20,7 +20,7 @@ export default class FakeWebSocketBridge implements WebSocketBridge {
         FakeWebSocketBridge.callsToConstructor.push(options)
     }
 
-    public activate() {
+    public async activate() {
         FakeWebSocketBridge.numCallsToActivate++
     }
 

package/src/testDoubles/WorkerThreads/FakeWorker.ts

@@ -0,0 +1,99 @@
+import { WorkerOptions } from 'node:worker_threads'
+
+import { OnDataCallback } from '../../impl/LslStreamInlet.js'
+import StreamInletWorker from '../../impl/workers/inlet/StreamInletWorker.js'
+import {
+    createOutlet,
+    destroyOutlet,
+    pushSample,
+} from '../../impl/workers/outlet/LslStreamOutlet.worker.js'
+
+export default class FakeWorker {
+    public static callsToConstructor: {
+        filename: string | URL
+        options?: WorkerOptions
+    }[] = []
+
+    public static callsToPostMessage: WorkerMessage[] = []
+
+    public static callsToOn: {
+        type: string
+        listener: (...args: unknown[]) => void
+    }[] = []
+
+    public static inletWorker = new StreamInletWorker()
+    public static fakeOnData: OnDataCallback
+
+    public createInletPromise?: Promise<void>
+
+    public constructor(filename: string | URL, options?: WorkerOptions) {
+        FakeWorker.callsToConstructor.push({ filename, options })
+    }
+
+    public postMessage(msg: WorkerMessage) {
+        FakeWorker.callsToPostMessage.push(msg)
+
+        const { type } = msg
+
+        switch (type) {
+            case 'createOutlet': {
+                createOutlet(msg as any)
+                break
+            }
+            case 'pushSample': {
+                pushSample(msg as any)
+                break
+            }
+            case 'destroyOutlet': {
+                destroyOutlet()
+                break
+            }
+            case 'createInlet': {
+                const { payload } = msg
+                this.createInletPromise = this.inletWorker.createInlet(
+                    payload as any
+                )
+                break
+            }
+            case 'startPulling': {
+                this.inletWorker.startPulling(this.fakeOnData)
+                break
+            }
+            case 'flushInlet': {
+                this.inletWorker.flushInlet()
+                break
+            }
+            case 'stopPulling': {
+                this.inletWorker.stopPulling()
+                break
+            }
+            case 'destroyInlet': {
+                this.inletWorker.destroyInlet()
+                break
+            }
+        }
+    }
+
+    public on(type: string, listener: (...args: unknown[]) => void) {
+        FakeWorker.callsToOn.push({ type, listener })
+    }
+
+    private get inletWorker() {
+        return FakeWorker.inletWorker
+    }
+
+    private get fakeOnData() {
+        return FakeWorker.fakeOnData
+    }
+
+    public static resetTestDoubles() {
+        this.callsToConstructor = []
+        this.callsToPostMessage = []
+        this.callsToOn = []
+    }
+}
+
+export interface WorkerMessage {
+    type: string
+    payload?: Record<string, unknown>[]
+}

package/src/testDoubles/generateRandomOutletOptions.ts

@@ -1,4 +1,5 @@
-import { randomInt } from 'crypto'
+import { randomInt } from 'node:crypto'
+
 import generateId from '@neurodevs/generate-id'
 
 import { StreamOutletOptions } from '../impl/LslStreamOutlet.js'

package/src/validations.ts

@@ -7,11 +7,9 @@ export function isGreaterThanOrEqualToZero(value: number) {
 }
 
 export function isPositiveInteger(value: number) {
-    //@ts-ignore
     return Number.isInteger(value) && value > 0
 }
 
 export function isPositiveIntegerOrZero(value: number) {
-    //@ts-ignore
     return Number.isInteger(value) && value >= 0
 }

package/tsconfig.json

@@ -1,28 +1,24 @@
 {
-	"compilerOptions": {
-		"module": "nodenext",
-		"moduleResolution": "nodenext",
-		"target": "ES2022",
-		"lib": ["ES2022"],
-		"types": ["node"],
-		"baseUrl": "src",
-		"outDir": "build",
-		"sourceMap": false,
-		"strict": true,
-		"noImplicitAny": true,
-		"noImplicitReturns": true,
-		"noUnusedLocals": true,
-		"forceConsistentCasingInFileNames": true,
-		"declaration": true,
-		"skipLibCheck": true,
-		"esModuleInterop": true,
-		"moduleDetection": "force",
-		"allowJs": true,
-		"resolveJsonModule": true,
-		"experimentalDecorators": true
-	},
-	"include": [
-		"./src/*.ts",
-		"./src/**/*.ts"
-	]
-}
+  "compilerOptions": {
+    "module": "nodenext",
+    "target": "esnext",
+    "lib": ["esnext"],
+    "types": ["node"],
+    "rootDir": "src",
+    "outDir": "build",
+    "sourceMap": false,
+    "strict": true,
+    "noImplicitAny": true,
+    "noImplicitReturns": true,
+    "noUnusedLocals": true,
+    "forceConsistentCasingInFileNames": true,
+    "declaration": true,
+    "skipLibCheck": true,
+    "esModuleInterop": true,
+    "moduleDetection": "force",
+    "allowJs": true,
+    "resolveJsonModule": true,
+    "experimentalDecorators": true
+  },
+  "include": ["./src/*.ts", "./src/**/*.ts"]
+}

package/build/.spruce/settings.json

@@ -1,11 +0,0 @@
-{
-  "scriptUpdater": {
-    "skipped": []
-  },
-  "skipped": [
-    "skill"
-  ],
-  "installed": [
-    "test"
-  ]
-}

package/build/__tests__/impl/LiblslAdapter.test.d.ts

@@ -1,79 +0,0 @@
-import { FieldType, FuncObj } from 'ffi-rs';
-import AbstractPackageTest from '../AbstractPackageTest.js';
-export default class LiblslAdapterTest extends AbstractPackageTest {
-    private static instance;
-    private static libraryPath?;
-    private static libraryOptions?;
-    private static fakeBindings;
-    private static fakeStreamInfo;
-    private static fakeOutlet;
-    private static fakeInlet;
-    private static fakeDesc;
-    private static fakeChildNamedChannels;
-    private static createStreamInfoParams?;
-    private static destroyStreamInfoParams?;
-    private static appendChildParams;
-    private static createOutletParams?;
-    private static destroyOutletParams?;
-    private static createInletParams?;
-    private static flushInletParams?;
-    private static destroyInletParams?;
-    private static localClockParams?;
-    private static pushSampleFloatTimestampParams?;
-    private static pushSampleStringTimestampParams?;
-    private static appendChildValueParams;
-    private static shouldThrowWhenCreatingBindings;
-    private static getDescriptionParams?;
-    private static fakeChildNamedChannel;
-    private static appendChildHitCount;
-    private static ffiRsOpenOptions?;
-    private static ffiRsDefineOptions;
-    private static ffiRsLoadOptions?;
-    protected static beforeEach(): Promise<void>;
-    protected static createsInstance(): Promise<void>;
-    protected static throwsWhenBindingsFailToLoad(): Promise<void>;
-    protected static callsOpenOnFfiRs(): Promise<void>;
-    protected static worksAsASingleton(): Promise<void>;
-    protected static singletonIsTheSame(): Promise<void>;
-    protected static canSetInstance(): void;
-    protected static createsExpectedBindingsWithFfiRs(): Promise<void>;
-    protected static createsStreamInfoWithRequiredParams(): Promise<void>;
-    protected static destroysStreamInfoWithBoundInfo(): Promise<void>;
-    protected static resolvesStreamInfoByProp(): Promise<void>;
-    protected static resolveByPropAcceptsOptionalArgs(): Promise<void>;
-    protected static returnsHandlesForResolvedStreamInfos(): Promise<void>;
-    protected static createsOutletWithRequiredParams(): Promise<void>;
-    protected static pushesFloatSample(): Promise<void>;
-    protected static pushesStringSample(): Promise<void>;
-    protected static addingSingleChannelGetsDescription(): Promise<void>;
-    protected static addingMultpleChannelsAddsChildrenToChannelsChild(): Promise<void>;
-    protected static canDestroyOutlet(): Promise<void>;
-    protected static callingLocalClockTwiceReturnsDifferentTimestamps(): Promise<void>;
-    protected static localClockBindingReceivesEmptyArray(): Promise<void>;
-    protected static defaultsToMacOsPath(): Promise<void>;
-    protected static createInletWithRequiredParams(): Promise<void>;
-    protected static pullSampleCallsBinding(): Promise<void>;
-    protected static pullChunkCallsBinding(): Promise<void>;
-    protected static flushInletCallsBinding(): Promise<void>;
-    protected static destroyInletCallsBinding(): Promise<void>;
-    private static createRandomStreamInfo;
-    private static resolveByProp;
-    private static createRandomOutlet;
-    private static createRandomOutletOptions;
-    private static createRandomInlet;
-    private static createRandomInletOptions;
-    private static generateRandomChannelValues;
-    private static generateRandomCreateStreamInfoOptions;
-    private static readonly maxResults;
-    private static readonly bytesPerPointer;
-    private static readonly minResults;
-    private static readonly timeoutMs;
-    private static readonly prop;
-    private static readonly value;
-    private static readonly fakeNumResolveResults;
-    private static readonly resultsBuffer;
-    private static readonly resultsBufferPtr;
-    private static generateFailedMessage;
-    private static FakeBindings;
-}
-export type FfiRsDefineOptions = FuncObj<FieldType, boolean | undefined>;