brilliantsole 0.0.27 → 0.0.29

package/src/server/udp/UDPUtils.ts

@@ -6,10 +6,17 @@ const _console = createConsole("UDPUtils", { log: false });
 export const pongUDPClientTimeout = 2_000;
 export const removeUDPClientTimeout = 3_000;
 
-export const UDPServerMessageTypes = ["ping", "pong", "setRemoteReceivePort", "serverMessage"] as const;
+export const UDPServerMessageTypes = [
+  "ping",
+  "pong",
+  "setRemoteReceivePort",
+  "serverMessage",
+] as const;
 export type UDPServerMessageType = (typeof UDPServerMessageTypes)[number];
 
-export type UDPServerMessage = UDPServerMessageType | Message<UDPServerMessageType>;
+export type UDPServerMessage =
+  | UDPServerMessageType
+  | Message<UDPServerMessageType>;
 export function createUDPServerMessage(...messages: UDPServerMessage[]) {
   _console.log("createUDPServerMessage", ...messages);
   return createMessage(UDPServerMessageTypes, ...messages);

package/src/server/websocket/WebSocketClient.ts

@@ -1,6 +1,13 @@
 import { createConsole } from "../../utils/Console.ts";
-import { createServerMessage, MessageLike, ServerMessage } from "../ServerUtils.ts";
-import { addEventListeners, removeEventListeners } from "../../utils/EventUtils.ts";
+import {
+  createServerMessage,
+  MessageLike,
+  ServerMessage,
+} from "../ServerUtils.ts";
+import {
+  addEventListeners,
+  removeEventListeners,
+} from "../../utils/EventUtils.ts";
 import ClientConnectionManager from "../../connection/ClientConnectionManager.ts";
 import BaseClient, { ServerURL } from "../BaseClient.ts";
 import type * as ws from "ws";
@@ -93,10 +100,16 @@ class WebSocketClient extends BaseClient {
   sendMessage(message: MessageLike) {
     this.assertConnection();
     this.#webSocket!.send(message);
+    this.#pingTimer.restart();
   }
 
   sendServerMessage(...messages: ServerMessage[]) {
-    this.sendMessage(createWebSocketMessage({ type: "serverMessage", data: createServerMessage(...messages) }));
+    this.sendMessage(
+      createWebSocketMessage({
+        type: "serverMessage",
+        data: createServerMessage(...messages),
+      })
+    );
   }
 
   #sendWebSocketMessage(...messages: WebSocketMessage[]) {
@@ -119,7 +132,7 @@ class WebSocketClient extends BaseClient {
   }
   async #onWebSocketMessage(event: ws.MessageEvent) {
     _console.log("webSocket.message", event);
-    this.#pingTimer.restart();
+    //this.#pingTimer.restart();
     //@ts-expect-error
     const arrayBuffer = await event.data.arrayBuffer();
     const dataView = new DataView(arrayBuffer);
@@ -131,7 +144,8 @@ class WebSocketClient extends BaseClient {
     this._connectionStatus = "notConnected";
 
     Object.entries(this.devices).forEach(([id, device]) => {
-      const connectionManager = device.connectionManager! as ClientConnectionManager;
+      const connectionManager =
+        device.connectionManager! as ClientConnectionManager;
       connectionManager.isConnected = false;
     });
 
@@ -143,12 +157,18 @@ class WebSocketClient extends BaseClient {
     }
   }
   #onWebSocketError(event: ws.ErrorEvent) {
-    _console.error("webSocket.error", event.message);
+    _console.error("webSocket.error", event);
   }
 
   // PARSING
   #parseWebSocketMessage(dataView: DataView) {
-    parseMessage(dataView, WebSocketMessageTypes, this.#onServerMessage.bind(this), null, true);
+    parseMessage(
+      dataView,
+      WebSocketMessageTypes,
+      this.#onServerMessage.bind(this),
+      null,
+      true
+    );
   }
 
   #onServerMessage(messageType: WebSocketMessageType, dataView: DataView) {

package/src/server/websocket/WebSocketUtils.ts

@@ -3,13 +3,15 @@ import { createMessage, Message } from "../ServerUtils.ts";
 
 const _console = createConsole("WebSocketUtils", { log: false });
 
-export const webSocketPingTimeout = 30_000_000;
+export const webSocketPingTimeout = 30_000;
 export const webSocketReconnectTimeout = 3_000;
 
 export const WebSocketMessageTypes = ["ping", "pong", "serverMessage"] as const;
 export type WebSocketMessageType = (typeof WebSocketMessageTypes)[number];
 
-export type WebSocketMessage = WebSocketMessageType | Message<WebSocketMessageType>;
+export type WebSocketMessage =
+  | WebSocketMessageType
+  | Message<WebSocketMessageType>;
 export function createWebSocketMessage(...messages: WebSocketMessage[]) {
   _console.log("createWebSocketMessage", ...messages);
   return createMessage(WebSocketMessageTypes, ...messages);

package/src/utils/AudioUtils.ts

@@ -0,0 +1,65 @@
+import { createConsole } from "./Console.ts";
+
+const _console = createConsole("AudioUtils", { log: true });
+
+export function float32ArrayToWav(
+  audioData: Float32Array,
+  sampleRate: number,
+  numChannels: number
+): Blob {
+  const wavBuffer = encodeWAV(audioData, sampleRate, numChannels);
+  return new Blob([wavBuffer], { type: "audio/wav" });
+}
+
+function encodeWAV(
+  interleaved: Float32Array,
+  sampleRate: number,
+  numChannels: number
+): ArrayBuffer {
+  const buffer = new ArrayBuffer(44 + interleaved.length * 2); // 44 bytes for WAV header
+  const view = new DataView(buffer);
+
+  // RIFF identifier
+  writeString(view, 0, "RIFF");
+  // File length minus RIFF identifier length and file description length
+  view.setUint32(4, 36 + interleaved.length * 2, true);
+  // RIFF type
+  writeString(view, 8, "WAVE");
+  // Format chunk identifier
+  writeString(view, 12, "fmt ");
+  // Format chunk length
+  view.setUint32(16, 16, true);
+  // Sample format (raw)
+  view.setUint16(20, 1, true);
+  // Channel count
+  view.setUint16(22, numChannels, true);
+  // Sample rate
+  view.setUint32(24, sampleRate, true);
+  // Byte rate (sample rate * block align)
+  view.setUint32(28, sampleRate * numChannels * 2, true);
+  // Block align (channel count * bytes per sample)
+  view.setUint16(32, numChannels * 2, true);
+  // Bits per sample
+  view.setUint16(34, 16, true);
+  // Data chunk identifier
+  writeString(view, 36, "data");
+  // Data chunk length
+  view.setUint32(40, interleaved.length * 2, true);
+
+  // Write interleaved audio data
+  for (let i = 0; i < interleaved.length; i++) {
+    view.setInt16(44 + i * 2, interleaved[i] * 0x7fff, true); // Convert float [-1, 1] to int16
+  }
+
+  return buffer;
+}
+
+export function writeString(
+  view: DataView,
+  offset: number,
+  string: string
+): void {
+  for (let i = 0; i < string.length; i++) {
+    view.setUint8(offset + i, string.charCodeAt(i));
+  }
+}

package/src/utils/Console.ts

@@ -1,4 +1,4 @@
-import { isInDev, isInLensStudio } from "./environment.ts";
+import { isInDev, isInLensStudio, isInNode } from "./environment.ts";
 
 declare var Studio: any | undefined;
 
@@ -34,6 +34,31 @@ if (isInLensStudio) {
   __console = console;
 }
 
+function getCallerFunctionPath(): string {
+  const stack = new Error().stack;
+  if (!stack) return "";
+
+  const lines = stack.split("\n");
+  const callerLine = lines[3] || lines[2];
+
+  const match = callerLine.match(/at (.*?) \(/) || callerLine.match(/at (.*)/);
+  if (!match) return "";
+
+  const fullFn = match[1].trim();
+  return `[${fullFn}]`;
+}
+
+function wrapWithLocation(fn: LogFunction): LogFunction {
+  return (...args: any[]) => {
+    if (isInNode) {
+      const functionPath = getCallerFunctionPath();
+      fn(functionPath, ...args);
+    } else {
+      fn(...args);
+    }
+  };
+}
+
 // console.assert not supported in WebBLE
 if (!__console.assert) {
   const assert: AssertLogFunction = (condition, ...data) => {
@@ -54,10 +79,18 @@ if (!__console.table) {
 
 function emptyFunction() {}
 
-const log: LogFunction = __console.log!.bind(__console);
-const warn: LogFunction = __console.warn!.bind(__console);
-const error: LogFunction = __console.error!.bind(__console);
-const table: LogFunction = __console.table!.bind(__console);
+const log: LogFunction = isInNode
+  ? wrapWithLocation(__console.log!.bind(__console))
+  : __console.log!.bind(__console);
+const warn: LogFunction = isInNode
+  ? wrapWithLocation(__console.warn!.bind(__console))
+  : __console.warn!.bind(__console);
+const error: LogFunction = isInNode
+  ? wrapWithLocation(__console.error!.bind(__console))
+  : __console.error!.bind(__console);
+const table: LogFunction = isInNode
+  ? wrapWithLocation(__console.table!.bind(__console))
+  : __console.table!.bind(__console);
 const assert: AssertLogFunction = __console.assert.bind(__console);
 
 class Console {
@@ -133,21 +166,41 @@ class Console {
 
   /** @throws {Error} if value's type doesn't match */
   assertTypeWithError(value: any, type: string) {
-    this.assertWithError(typeof value == type, `value ${value} of type "${typeof value}" not of type "${type}"`);
+    this.assertWithError(
+      typeof value == type,
+      `value ${value} of type "${typeof value}" not of type "${type}"`
+    );
   }
 
   /** @throws {Error} if value's type doesn't match */
   assertEnumWithError(value: string, enumeration: readonly string[]) {
-    this.assertWithError(enumeration.includes(value), `invalid enum "${value}"`);
+    this.assertWithError(
+      enumeration.includes(value),
+      `invalid enum "${value}"`
+    );
+  }
+
+  /** @throws {Error} if value is not within some range */
+  assertRangeWithError(name: string, value: number, min: number, max: number) {
+    this.assertWithError(
+      value >= min && value <= max,
+      `${name} ${value} must be within ${min}-${max}`
+    );
   }
 }
 
-export function createConsole(type: string, levelFlags?: ConsoleLevelFlags): Console {
+export function createConsole(
+  type: string,
+  levelFlags?: ConsoleLevelFlags
+): Console {
   return Console.create(type, levelFlags);
 }
 
 /** @throws {Error} if no console with type is found */
-export function setConsoleLevelFlagsForType(type: string, levelFlags: ConsoleLevelFlags) {
+export function setConsoleLevelFlagsForType(
+  type: string,
+  levelFlags: ConsoleLevelFlags
+) {
   Console.setLevelFlagsForType(type, levelFlags);
 }
 

package/src/utils/ParseUtils.ts

@@ -4,10 +4,16 @@ import { textDecoder } from "./Text.ts";
 
 const _console = createConsole("ParseUtils", { log: false });
 
-export function parseStringFromDataView(dataView: DataView, byteOffset: number = 0) {
+export function parseStringFromDataView(
+  dataView: DataView,
+  byteOffset: number = 0
+) {
   const stringLength = dataView.getUint8(byteOffset++);
   const string = textDecoder.decode(
-    dataView.buffer.slice(dataView.byteOffset + byteOffset, dataView.byteOffset + byteOffset + stringLength)
+    dataView.buffer.slice(
+      dataView.byteOffset + byteOffset,
+      dataView.byteOffset + byteOffset + stringLength
+    )
   );
   byteOffset += stringLength;
   return { string, byteOffset };
@@ -16,14 +22,21 @@ export function parseStringFromDataView(dataView: DataView, byteOffset: number =
 export function parseMessage<MessageType extends string>(
   dataView: DataView,
   messageTypes: readonly MessageType[],
-  callback: (messageType: MessageType, dataView: DataView, context?: any) => void,
+  callback: (
+    messageType: MessageType,
+    dataView: DataView,
+    context?: any
+  ) => void,
   context?: any,
   parseMessageLengthAsUint16: boolean = false
 ) {
   let byteOffset = 0;
   while (byteOffset < dataView.byteLength) {
     const messageTypeEnum = dataView.getUint8(byteOffset++);
-    _console.assertWithError(messageTypeEnum in messageTypes, `invalid messageTypeEnum ${messageTypeEnum}`);
+    _console.assertWithError(
+      messageTypeEnum in messageTypes,
+      `invalid messageTypeEnum ${messageTypeEnum}`
+    );
     const messageType = messageTypes[messageTypeEnum];
 
     let messageLength: number;
@@ -34,7 +47,13 @@ export function parseMessage<MessageType extends string>(
       messageLength = dataView.getUint8(byteOffset++);
     }
 
-    _console.log({ messageTypeEnum, messageType, messageLength, dataView, byteOffset });
+    _console.log({
+      messageTypeEnum,
+      messageType,
+      messageLength,
+      dataView,
+      byteOffset,
+    });
 
     const _dataView = sliceDataView(dataView, byteOffset, messageLength);
     _console.log({ _dataView });

package/src/utils/ThrottleUtils.ts

@@ -0,0 +1,62 @@
+export function throttle<T extends (...args: any[]) => void>(
+  fn: T,
+  interval: number,
+  trailing = false
+): (...args: Parameters<T>) => void {
+  let lastTime = 0;
+  let timeout: ReturnType<typeof setTimeout> | null = null;
+  let lastArgs: Parameters<T> | null = null;
+
+  return function (...args: Parameters<T>) {
+    const now = Date.now();
+    const remaining = interval - (now - lastTime);
+
+    if (remaining <= 0) {
+      if (timeout) {
+        clearTimeout(timeout);
+        timeout = null;
+      }
+      lastTime = now;
+      fn(...args);
+    } else if (trailing) {
+      lastArgs = args;
+      if (!timeout) {
+        timeout = setTimeout(() => {
+          lastTime = Date.now();
+          timeout = null;
+          if (lastArgs) {
+            fn(...lastArgs);
+            lastArgs = null;
+          }
+        }, remaining);
+      }
+    }
+  };
+}
+
+export function debounce<T extends (...args: any[]) => void>(
+  fn: T,
+  interval: number,
+  callImmediately = false
+): (...args: Parameters<T>) => void {
+  let timeout: ReturnType<typeof setTimeout> | null = null;
+
+  return function (...args: Parameters<T>) {
+    const callNow = callImmediately && !timeout;
+
+    if (timeout) {
+      clearTimeout(timeout);
+    }
+
+    timeout = setTimeout(() => {
+      timeout = null;
+      if (!callImmediately) {
+        fn(...args);
+      }
+    }, interval);
+
+    if (callNow) {
+      fn(...args);
+    }
+  };
+}

package/src/utils/Timer.ts

@@ -52,7 +52,7 @@ class Timer {
       _console.log("interval already running");
       return;
     }
-    _console.log("starting interval");
+    _console.log(`starting interval every ${this.#interval}ms`);
     this.#intervalId = setInterval(this.#callback, this.#interval);
     if (immediately) {
       this.#callback();