brilliantsole 0.0.1

package/src/server/websocket/WebSocketClient.ts

@@ -0,0 +1,179 @@
+import { createConsole } from "../../utils/Console.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";
+import Timer from "../../utils/Timer.ts";
+import {
+  createWebSocketMessage,
+  WebSocketMessageType,
+  WebSocketMessageTypes,
+  webSocketPingTimeout,
+  webSocketReconnectTimeout,
+  WebSocketMessage,
+} from "./WebSocketUtils.ts";
+import { parseMessage } from "../../utils/ParseUtils.ts";
+
+const _console = createConsole("WebSocketClient", { log: true });
+
+class WebSocketClient extends BaseClient {
+  // WEBSOCKET
+  #webSocket?: WebSocket;
+  get webSocket() {
+    return this.#webSocket;
+  }
+  set webSocket(newWebSocket) {
+    if (this.#webSocket == newWebSocket) {
+      _console.log("redundant webSocket assignment");
+      return;
+    }
+
+    _console.log("assigning webSocket", newWebSocket);
+
+    if (this.#webSocket) {
+      removeEventListeners(this.#webSocket, this.#boundWebSocketEventListeners);
+    }
+
+    addEventListeners(newWebSocket, this.#boundWebSocketEventListeners);
+    this.#webSocket = newWebSocket;
+
+    _console.log("assigned webSocket");
+  }
+  get readyState() {
+    return this.webSocket?.readyState;
+  }
+  get isConnected() {
+    return this.readyState == WebSocket.OPEN;
+  }
+  get isDisconnected() {
+    return this.readyState == WebSocket.CLOSED;
+  }
+
+  connect(url: string | URL = `wss://${location.host}`) {
+    if (this.webSocket) {
+      this.assertDisconnection();
+    }
+    this._connectionStatus = "connecting";
+    this.webSocket = new WebSocket(url);
+  }
+
+  disconnect() {
+    this.assertConnection();
+    if (this.reconnectOnDisconnection) {
+      this.reconnectOnDisconnection = false;
+      this.webSocket!.addEventListener(
+        "close",
+        () => {
+          this.reconnectOnDisconnection = true;
+        },
+        { once: true }
+      );
+    }
+    this._connectionStatus = "disconnecting";
+    this.webSocket!.close();
+  }
+
+  reconnect() {
+    this.assertDisconnection();
+    this.webSocket = new WebSocket(this.webSocket!.url);
+  }
+
+  toggleConnection(url?: ServerURL) {
+    if (this.isConnected) {
+      this.disconnect();
+    } else if (url && this.webSocket?.url == url) {
+      this.reconnect();
+    } else {
+      this.connect(url);
+    }
+  }
+
+  // WEBSOCKET MESSAGING
+  sendMessage(message: MessageLike) {
+    this.assertConnection();
+    this.#webSocket!.send(message);
+  }
+
+  sendServerMessage(...messages: ServerMessage[]) {
+    this.sendMessage(createWebSocketMessage({ type: "serverMessage", data: createServerMessage(...messages) }));
+  }
+
+  #sendWebSocketMessage(...messages: WebSocketMessage[]) {
+    this.sendMessage(createWebSocketMessage(...messages));
+  }
+
+  // WEBSOCKET EVENTS
+  #boundWebSocketEventListeners: { [eventType: string]: Function } = {
+    open: this.#onWebSocketOpen.bind(this),
+    message: this.#onWebSocketMessage.bind(this),
+    close: this.#onWebSocketClose.bind(this),
+    error: this.#onWebSocketError.bind(this),
+  };
+
+  #onWebSocketOpen(event: ws.Event) {
+    _console.log("webSocket.open", event);
+    this.#pingTimer.start();
+    this._connectionStatus = "connected";
+  }
+  async #onWebSocketMessage(event: ws.MessageEvent) {
+    _console.log("webSocket.message", event);
+    this.#pingTimer.restart();
+    //@ts-expect-error
+    const arrayBuffer = await event.data.arrayBuffer();
+    const dataView = new DataView(arrayBuffer);
+    this.#parseWebSocketMessage(dataView);
+  }
+  #onWebSocketClose(event: ws.CloseEvent) {
+    _console.log("webSocket.close", event);
+
+    this._connectionStatus = "notConnected";
+
+    Object.entries(this.devices).forEach(([id, device]) => {
+      const connectionManager = device.connectionManager! as ClientConnectionManager;
+      connectionManager.isConnected = false;
+    });
+
+    this.#pingTimer.stop();
+    if (this.reconnectOnDisconnection) {
+      setTimeout(() => {
+        this.reconnect();
+      }, webSocketReconnectTimeout);
+    }
+  }
+  #onWebSocketError(event: ws.ErrorEvent) {
+    _console.error("webSocket.error", event.message);
+  }
+
+  // PARSING
+  #parseWebSocketMessage(dataView: DataView) {
+    parseMessage(dataView, WebSocketMessageTypes, this.#onServerMessage.bind(this), null, true);
+  }
+
+  #onServerMessage(messageType: WebSocketMessageType, dataView: DataView) {
+    switch (messageType) {
+      case "ping":
+        this.#pong();
+        break;
+      case "pong":
+        break;
+      case "serverMessage":
+        this.parseMessage(dataView);
+        break;
+      default:
+        _console.error(`uncaught messageType "${messageType}"`);
+        break;
+    }
+  }
+
+  // PING
+  #pingTimer = new Timer(this.#ping.bind(this), webSocketPingTimeout);
+  #ping() {
+    this.#sendWebSocketMessage("ping");
+  }
+  #pong() {
+    this.#sendWebSocketMessage("pong");
+  }
+}
+
+export default WebSocketClient;

package/src/server/websocket/WebSocketServer.ts

@@ -0,0 +1,184 @@
+import { createConsole } from "../../utils/Console.ts";
+import { addEventListeners, removeEventListeners } from "../../utils/EventUtils.ts";
+import { concatenateArrayBuffers, dataToArrayBuffer } from "../../utils/ArrayBufferUtils.ts";
+import Timer from "../../utils/Timer.ts";
+import BaseServer from "../BaseServer.ts";
+import {
+  webSocketPingMessage,
+  webSocketPongMessage,
+  WebSocketMessageType,
+  WebSocketMessageTypes,
+  webSocketPingTimeout,
+  createWebSocketMessage,
+} from "./WebSocketUtils.ts";
+
+const _console = createConsole("WebSocketServer", { log: true });
+
+/** NODE_START */
+import type * as ws from "ws";
+import { parseMessage } from "../../utils/ParseUtils.ts";
+/** NODE_END */
+
+interface WebSocketClient extends ws.WebSocket {
+  isAlive: boolean;
+  pingClientTimer?: Timer;
+}
+interface WebSocketServer extends ws.WebSocketServer {}
+
+class WebSocketServer extends BaseServer {
+  get numberOfClients() {
+    return this.#server?.clients.size || 0;
+  }
+
+  // WEBSOCKET SERVER
+
+  #server?: WebSocketServer;
+  get server() {
+    return this.#server;
+  }
+  set server(newServer) {
+    if (this.#server == newServer) {
+      _console.log("redundant WebSocket server assignment");
+      return;
+    }
+    _console.log("assigning WebSocket server...");
+
+    if (this.#server) {
+      _console.log("clearing existing WebSocket server...");
+      removeEventListeners(this.#server, this.#boundWebSocketServerListeners);
+    }
+
+    addEventListeners(newServer, this.#boundWebSocketServerListeners);
+    this.#server = newServer;
+
+    _console.log("assigned WebSocket server");
+  }
+
+  // WEBSOCKET SERVER LISTENERS
+
+  #boundWebSocketServerListeners = {
+    close: this.#onWebSocketServerClose.bind(this),
+    connection: this.#onWebSocketServerConnection.bind(this),
+    error: this.#onWebSocketServerError.bind(this),
+    headers: this.#onWebSocketServerHeaders.bind(this),
+    listening: this.#onWebSocketServerListening.bind(this),
+  };
+
+  #onWebSocketServerClose() {
+    _console.log("server.close");
+  }
+  #onWebSocketServerConnection(client: WebSocketClient) {
+    _console.log("server.connection");
+    client.isAlive = true;
+    client.pingClientTimer = new Timer(() => this.#pingClient(client), webSocketPingTimeout);
+    client.pingClientTimer.start();
+    addEventListeners(client, this.#boundWebSocketClientListeners);
+    this.dispatchEvent("clientConnected", { client });
+  }
+  #onWebSocketServerError(error: Error) {
+    _console.error(error);
+  }
+  #onWebSocketServerHeaders() {
+    //_console.log("server.headers");
+  }
+  #onWebSocketServerListening() {
+    _console.log("server.listening");
+  }
+
+  // WEBSOCKET CLIENT LISTENERS
+
+  #boundWebSocketClientListeners: { [eventType: string]: Function } = {
+    open: this.#onWebSocketClientOpen.bind(this),
+    message: this.#onWebSocketClientMessage.bind(this),
+    close: this.#onWebSocketClientClose.bind(this),
+    error: this.#onWebSocketClientError.bind(this),
+  };
+  #onWebSocketClientOpen(event: ws.Event) {
+    _console.log("client.open");
+  }
+  #onWebSocketClientMessage(event: ws.MessageEvent) {
+    _console.log("client.message");
+    const client = event.target as WebSocketClient;
+    client.isAlive = true;
+    client.pingClientTimer!.restart();
+    const dataView = new DataView(dataToArrayBuffer(event.data as Buffer));
+    _console.log(`received ${dataView.byteLength} bytes`, dataView.buffer);
+    this.#parseWebSocketClientMessage(client, dataView);
+  }
+  #onWebSocketClientClose(event: ws.CloseEvent) {
+    _console.log("client.close");
+    const client = event.target as WebSocketClient;
+    client.pingClientTimer!.stop();
+    removeEventListeners(client, this.#boundWebSocketClientListeners);
+    this.dispatchEvent("clientDisconnected", { client });
+  }
+  #onWebSocketClientError(event: ws.ErrorEvent) {
+    _console.error("client.error", event.message);
+  }
+
+  // PARSING
+  #parseWebSocketClientMessage(client: WebSocketClient, dataView: DataView) {
+    let responseMessages: ArrayBuffer[] = [];
+
+    parseMessage(dataView, WebSocketMessageTypes, this.#onClientMessage.bind(this), { responseMessages }, true);
+
+    responseMessages = responseMessages.filter(Boolean);
+
+    if (responseMessages.length == 0) {
+      _console.log("nothing to send back");
+      return;
+    }
+
+    const responseMessage = concatenateArrayBuffers(responseMessages);
+    _console.log(`sending ${responseMessage.byteLength} bytes to client...`);
+    try {
+      client.send(responseMessage);
+    } catch (error) {
+      _console.log("error sending message", error);
+    }
+  }
+
+  #onClientMessage(
+    messageType: WebSocketMessageType,
+    dataView: DataView,
+    context: { responseMessages: (ArrayBuffer | undefined)[] }
+  ) {
+    const { responseMessages } = context;
+    switch (messageType) {
+      case "ping":
+        responseMessages.push(webSocketPongMessage);
+        break;
+      case "pong":
+        break;
+      case "serverMessage":
+        const responseMessage = this.parseClientMessage(dataView);
+        if (responseMessage) {
+          responseMessages.push(createWebSocketMessage({ type: "serverMessage", data: responseMessage }));
+        }
+        break;
+      default:
+        _console.error(`uncaught messageType "${messageType}"`);
+        break;
+    }
+  }
+
+  // CLIENT MESSAGING
+  broadcastMessage(message: ArrayBuffer) {
+    super.broadcastMessage(message);
+    this.server!.clients.forEach((client) => {
+      client.send(createWebSocketMessage({ type: "serverMessage", data: message }));
+    });
+  }
+
+  // PING
+  #pingClient(client: WebSocketClient) {
+    if (!client.isAlive) {
+      client.terminate();
+      return;
+    }
+    client.isAlive = false;
+    client.send(webSocketPingMessage);
+  }
+}
+
+export default WebSocketServer;

package/src/server/websocket/WebSocketUtils.ts

@@ -0,0 +1,20 @@
+import { createConsole } from "../../utils/Console.ts";
+import { createMessage, Message } from "../ServerUtils.ts";
+
+const _console = createConsole("WebSocketUtils", { log: false });
+
+export const webSocketPingTimeout = 30_000_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 function createWebSocketMessage(...messages: WebSocketMessage[]) {
+  _console.log("createWebSocketMessage", ...messages);
+  return createMessage(WebSocketMessageTypes, ...messages);
+}
+
+// STATIC MESSAGES
+export const webSocketPingMessage = createWebSocketMessage("ping");
+export const webSocketPongMessage = createWebSocketMessage("pong");

package/src/utils/ArrayBufferUtils.ts

@@ -0,0 +1,88 @@
+import { createConsole } from "./Console.ts";
+import { textEncoder } from "./Text.ts";
+
+const _console = createConsole("ArrayBufferUtils", { log: false });
+
+export function concatenateArrayBuffers(...arrayBuffers: any[]): ArrayBuffer {
+  arrayBuffers = arrayBuffers.filter((arrayBuffer) => arrayBuffer != undefined || arrayBuffer != null);
+  arrayBuffers = arrayBuffers.map((arrayBuffer) => {
+    if (typeof arrayBuffer == "number") {
+      const number = arrayBuffer;
+      return Uint8Array.from([Math.floor(number)]);
+    } else if (typeof arrayBuffer == "boolean") {
+      const boolean = arrayBuffer;
+      return Uint8Array.from([boolean ? 1 : 0]);
+    } else if (typeof arrayBuffer == "string") {
+      const string = arrayBuffer;
+      return stringToArrayBuffer(string);
+    } else if (arrayBuffer instanceof Array) {
+      const array = arrayBuffer;
+      return concatenateArrayBuffers(...array);
+    } else if (arrayBuffer instanceof ArrayBuffer) {
+      return arrayBuffer;
+    } else if ("buffer" in arrayBuffer && arrayBuffer.buffer instanceof ArrayBuffer) {
+      const bufferContainer = arrayBuffer;
+      return bufferContainer.buffer;
+    } else if (arrayBuffer instanceof DataView) {
+      const dataView = arrayBuffer;
+      return dataView.buffer;
+    } else if (typeof arrayBuffer == "object") {
+      const object = arrayBuffer;
+      return objectToArrayBuffer(object);
+    } else {
+      return arrayBuffer;
+    }
+  });
+  arrayBuffers = arrayBuffers.filter((arrayBuffer) => arrayBuffer && "byteLength" in arrayBuffer);
+  const length = arrayBuffers.reduce((length, arrayBuffer) => length + arrayBuffer.byteLength, 0);
+  const uint8Array = new Uint8Array(length);
+  let byteOffset = 0;
+  arrayBuffers.forEach((arrayBuffer) => {
+    uint8Array.set(new Uint8Array(arrayBuffer), byteOffset);
+    byteOffset += arrayBuffer.byteLength;
+  });
+  return uint8Array.buffer;
+}
+
+export function dataToArrayBuffer(data: Buffer) {
+  return data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);
+}
+
+export function stringToArrayBuffer(string: string) {
+  const encoding = textEncoder.encode(string);
+  return concatenateArrayBuffers(encoding.byteLength, encoding);
+}
+
+export function objectToArrayBuffer(object: object) {
+  return stringToArrayBuffer(JSON.stringify(object));
+}
+
+export function sliceDataView(dataView: DataView, begin: number, length?: number) {
+  let end;
+  if (length != undefined) {
+    end = dataView.byteOffset + begin + length;
+  }
+  _console.log({ dataView, begin, end, length });
+  return new DataView(dataView.buffer.slice(dataView.byteOffset + begin, end));
+}
+
+export type FileLike = number[] | ArrayBuffer | DataView | URL | string | File;
+
+export async function getFileBuffer(file: FileLike) {
+  let fileBuffer;
+  if (file instanceof Array) {
+    fileBuffer = Uint8Array.from(file);
+  } else if (file instanceof DataView) {
+    fileBuffer = file.buffer;
+  } else if (typeof file == "string" || file instanceof URL) {
+    const response = await fetch(file);
+    fileBuffer = await response.arrayBuffer();
+  } else if (file instanceof File) {
+    fileBuffer = await file.arrayBuffer();
+  } else if (file instanceof ArrayBuffer) {
+    fileBuffer = file;
+  } else {
+    throw { error: "invalid file type", file };
+  }
+  return fileBuffer;
+}

package/src/utils/ArrayUtils.ts

@@ -0,0 +1,15 @@
+export function createArray(arrayLength: number, objectOrCallback: ((index: number) => any) | object) {
+  return new Array(arrayLength).fill(1).map((_, index) => {
+    if (typeof objectOrCallback == "function") {
+      const callback = objectOrCallback;
+      return callback(index);
+    } else {
+      const object = objectOrCallback;
+      return Object.assign({}, object);
+    }
+  });
+}
+
+export function arrayWithoutDuplicates(array: any[]) {
+  return array.filter((value, index) => array.indexOf(value) == index);
+}

package/src/utils/CenterOfPressureHelper.ts

@@ -0,0 +1,39 @@
+import RangeHelper from "./RangeHelper.ts";
+
+import { Vector2 } from "./MathUtils.ts";
+
+export type CenterOfPressure = Vector2;
+
+export interface CenterOfPressureRange {
+  x: RangeHelper;
+  y: RangeHelper;
+}
+
+class CenterOfPressureHelper {
+  #range: CenterOfPressureRange = {
+    x: new RangeHelper(),
+    y: new RangeHelper(),
+  };
+  reset() {
+    this.#range.x.reset();
+    this.#range.y.reset();
+  }
+
+  update(centerOfPressure: CenterOfPressure) {
+    this.#range.x.update(centerOfPressure.x);
+    this.#range.y.update(centerOfPressure.y);
+  }
+  getNormalization(centerOfPressure: CenterOfPressure): CenterOfPressure {
+    return {
+      x: this.#range.x.getNormalization(centerOfPressure.x, false),
+      y: this.#range.y.getNormalization(centerOfPressure.y, false),
+    };
+  }
+
+  updateAndGetNormalization(centerOfPressure: CenterOfPressure) {
+    this.update(centerOfPressure);
+    return this.getNormalization(centerOfPressure);
+  }
+}
+
+export default CenterOfPressureHelper;

package/src/utils/Console.ts

@@ -0,0 +1,156 @@
+import { isInDev, isInLensStudio } from "./environment.ts";
+
+declare var Studio: any | undefined;
+
+export type LogFunction = (...data: any[]) => void;
+export type AssertLogFunction = (condition: boolean, ...data: any[]) => void;
+
+export interface ConsoleLevelFlags {
+  log?: boolean;
+  warn?: boolean;
+  error?: boolean;
+  assert?: boolean;
+  table?: boolean;
+}
+
+interface ConsoleLike {
+  log?: LogFunction;
+  warn?: LogFunction;
+  error?: LogFunction;
+  assert?: AssertLogFunction;
+  table?: LogFunction;
+}
+
+var __console: ConsoleLike;
+if (isInLensStudio) {
+  const log = function (...args: any[]) {
+    Studio.log(args.map((value) => new String(value)).join(","));
+  };
+  __console = {};
+  __console.log = log;
+  __console.warn = log.bind(__console, "WARNING");
+  __console.error = log.bind(__console, "ERROR");
+} else {
+  __console = console;
+}
+
+// console.assert not supported in WebBLE
+if (!__console.assert) {
+  const assert: AssertLogFunction = (condition, ...data) => {
+    if (!condition) {
+      __console.warn!(...data);
+    }
+  };
+  __console.assert = assert;
+}
+
+// console.table not supported in WebBLE
+if (!__console.table) {
+  const table: LogFunction = (...data) => {
+    __console.log!(...data);
+  };
+  __console.table = 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 assert: AssertLogFunction = __console.assert.bind(__console);
+
+class Console {
+  static #consoles: { [type: string]: Console } = {};
+
+  constructor(type: string) {
+    if (Console.#consoles[type]) {
+      throw new Error(`"${type}" console already exists`);
+    }
+    Console.#consoles[type] = this;
+  }
+
+  #levelFlags: ConsoleLevelFlags = {
+    log: isInDev,
+    warn: isInDev,
+    assert: true,
+    error: true,
+    table: true,
+  };
+
+  setLevelFlags(levelFlags: ConsoleLevelFlags) {
+    Object.assign(this.#levelFlags, levelFlags);
+  }
+
+  /** @throws {Error} if no console with type "type" is found */
+  static setLevelFlagsForType(type: string, levelFlags: ConsoleLevelFlags) {
+    if (!this.#consoles[type]) {
+      throw new Error(`no console found with type "${type}"`);
+    }
+    this.#consoles[type].setLevelFlags(levelFlags);
+  }
+
+  static setAllLevelFlags(levelFlags: ConsoleLevelFlags) {
+    for (const type in this.#consoles) {
+      this.#consoles[type].setLevelFlags(levelFlags);
+    }
+  }
+
+  static create(type: string, levelFlags?: ConsoleLevelFlags): Console {
+    const console = this.#consoles[type] || new Console(type);
+    if (isInDev && levelFlags) {
+      console.setLevelFlags(levelFlags);
+    }
+    return console;
+  }
+
+  get log() {
+    return this.#levelFlags.log ? log : emptyFunction;
+  }
+
+  get warn() {
+    return this.#levelFlags.warn ? warn : emptyFunction;
+  }
+
+  get error() {
+    return this.#levelFlags.error ? error : emptyFunction;
+  }
+
+  get assert() {
+    return this.#levelFlags.assert ? assert : emptyFunction;
+  }
+
+  get table() {
+    return this.#levelFlags.table ? table : emptyFunction;
+  }
+
+  /** @throws {Error} if condition is not met */
+  assertWithError(condition: any, message: string) {
+    if (!Boolean(condition)) {
+      throw new Error(message);
+    }
+  }
+
+  /** @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}"`);
+  }
+
+  /** @throws {Error} if value's type doesn't match */
+  assertEnumWithError(value: string, enumeration: readonly string[]) {
+    this.assertWithError(enumeration.includes(value), `invalid enum "${value}"`);
+  }
+}
+
+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) {
+  Console.setLevelFlagsForType(type, levelFlags);
+}
+
+export function setAllConsoleLevelFlags(levelFlags: ConsoleLevelFlags) {
+  Console.setAllLevelFlags(levelFlags);
+}