brilliantsole 0.0.26 → 0.0.28

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";
@@ -15,7 +22,7 @@ import {
 } from "./WebSocketUtils.ts";
 import { parseMessage } from "../../utils/ParseUtils.ts";
 
-const _console = createConsole("WebSocketClient", { log: true });
+const _console = createConsole("WebSocketClient", { log: false });
 
 class WebSocketClient extends BaseClient {
   // WEBSOCKET
@@ -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[]) {
@@ -114,11 +127,12 @@ class WebSocketClient extends BaseClient {
   #onWebSocketOpen(event: ws.Event) {
     _console.log("webSocket.open", event);
     this.#pingTimer.start();
-    this._connectionStatus = "connected";
+    //this._connectionStatus = "connected";
+    this._sendRequiredMessages();
   }
   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);
@@ -130,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;
     });
 
@@ -142,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/WebSocketServer.ts

@@ -12,7 +12,7 @@ import {
   createWebSocketMessage,
 } from "./WebSocketUtils.ts";
 
-const _console = createConsole("WebSocketServer", { log: true });
+const _console = createConsole("WebSocketServer", { log: false });
 
 /** NODE_START */
 import type * as ws from "ws";

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/CenterOfPressureHelper.ts

@@ -23,16 +23,16 @@ class CenterOfPressureHelper {
     this.#range.x.update(centerOfPressure.x);
     this.#range.y.update(centerOfPressure.y);
   }
-  getNormalization(centerOfPressure: CenterOfPressure): CenterOfPressure {
+  getNormalization(centerOfPressure: CenterOfPressure, weightByRange: boolean): CenterOfPressure {
     return {
-      x: this.#range.x.getNormalization(centerOfPressure.x, false),
-      y: this.#range.y.getNormalization(centerOfPressure.y, false),
+      x: this.#range.x.getNormalization(centerOfPressure.x, weightByRange),
+      y: this.#range.y.getNormalization(centerOfPressure.y, weightByRange),
     };
   }
 
-  updateAndGetNormalization(centerOfPressure: CenterOfPressure) {
+  updateAndGetNormalization(centerOfPressure: CenterOfPressure, weightByRange: boolean) {
     this.update(centerOfPressure);
-    return this.getNormalization(centerOfPressure);
+    return this.getNormalization(centerOfPressure, weightByRange);
   }
 }
 

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/MathUtils.ts

@@ -1,6 +1,7 @@
+import { PressureSensorPosition } from "../sensor/PressureSensorDataManager.ts";
 import { createConsole } from "./Console.ts";
 
-const _console = createConsole("MathUtils", { log: true });
+const _console = createConsole("MathUtils", { log: false });
 
 export function getInterpolation(value: number, min: number, max: number, span: number) {
   if (span == undefined) {
@@ -51,3 +52,32 @@ export interface Euler {
   pitch: number;
   roll: number;
 }
+
+export function computeVoronoiWeights(points: PressureSensorPosition[], sampleCount = 100000) {
+  const n = points.length;
+  const counts = new Array(n).fill(0);
+
+  for (let i = 0; i < sampleCount; i++) {
+    const x = Math.random();
+    const y = Math.random();
+
+    // Find the closest input point
+    let minDist = Infinity;
+    let closestIndex = -1;
+
+    for (let j = 0; j < n; j++) {
+      const { x: px, y: py } = points[j];
+      const dist = (px - x) ** 2 + (py - y) ** 2; // Squared Euclidean distance
+      if (dist < minDist) {
+        minDist = dist;
+        closestIndex = j;
+      }
+    }
+
+    // Increment count for the closest point
+    counts[closestIndex]++;
+  }
+
+  // Convert counts to weights (sum to 1)
+  return counts.map((c) => c / sampleCount);
+}

package/src/utils/ParseUtils.ts

@@ -2,12 +2,18 @@ import { sliceDataView } from "./ArrayBufferUtils.ts";
 import { createConsole } from "./Console.ts";
 import { textDecoder } from "./Text.ts";
 
-const _console = createConsole("ParseUtils", { log: true });
+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();

package/src/utils/checksum.ts

@@ -1,6 +1,6 @@
 import { createConsole } from "./Console.ts";
 
-const _console = createConsole("checksum", { log: true });
+const _console = createConsole("checksum", { log: false });
 
 // https://github.com/googlecreativelab/tiny-motion-trainer/blob/5fceb49f018ae0c403bf9f0ccc437309c2acb507/frontend/src/tf4micro-motion-kit/modules/bleFileTransfer#L195
 

package/src/utils/mcumgr.js

@@ -33,7 +33,7 @@
 import { CBOR } from "./cbor.js";
 import { createConsole } from "./Console.ts";
 
-const _console = createConsole("mcumgr", { log: true });
+const _console = createConsole("mcumgr", { log: false });
 
 export const constants = {
   // Opcodes