brilliantsole 0.0.1

package/src/utils/EventDispatcher.ts

@@ -0,0 +1,153 @@
+import { createConsole } from "./Console.ts";
+
+const _console = createConsole("EventDispatcher", { log: false });
+
+export type EventMap<
+  Target extends any,
+  EventType extends string,
+  EventMessages extends Partial<Record<EventType, any>>
+> = {
+  [T in keyof EventMessages]: { type: T; target: Target; message: EventMessages[T] };
+};
+export type EventListenerMap<
+  Target extends any,
+  EventType extends string,
+  EventMessages extends Partial<Record<EventType, any>>
+> = {
+  [T in keyof EventMessages]: (event: { type: T; target: Target; message: EventMessages[T] }) => void;
+};
+
+export type Event<
+  Target extends any,
+  EventType extends string,
+  EventMessages extends Partial<Record<EventType, any>>
+> = EventMap<Target, EventType, EventMessages>[keyof EventMessages];
+
+type SpecificEvent<
+  Target extends any,
+  EventType extends string,
+  EventMessages extends Partial<Record<EventType, any>>,
+  SpecificEventType extends EventType
+> = { type: SpecificEventType; target: Target; message: EventMessages[SpecificEventType] };
+
+export type BoundEventListeners<
+  Target extends any,
+  EventType extends string,
+  EventMessages extends Partial<Record<EventType, any>>
+> = {
+  [SpecificEventType in keyof EventMessages]?: (
+    // @ts-expect-error
+    event: SpecificEvent<Target, EventType, EventMessages, SpecificEventType>
+  ) => void;
+};
+
+class EventDispatcher<
+  Target extends any,
+  EventType extends string,
+  EventMessages extends Partial<Record<EventType, any>>
+> {
+  private listeners: {
+    [T in EventType]?: {
+      listener: (event: { type: T; target: Target; message: EventMessages[T] }) => void;
+      once?: boolean;
+      shouldRemove?: boolean;
+    }[];
+  } = {};
+
+  constructor(private target: Target, private validEventTypes: readonly EventType[]) {
+    this.addEventListener = this.addEventListener.bind(this);
+    this.removeEventListener = this.removeEventListener.bind(this);
+    this.dispatchEvent = this.dispatchEvent.bind(this);
+    this.waitForEvent = this.waitForEvent.bind(this);
+  }
+
+  private isValidEventType(type: any): type is EventType {
+    return this.validEventTypes.includes(type);
+  }
+
+  private updateEventListeners(type: EventType) {
+    if (!this.listeners[type]) return;
+    this.listeners[type] = this.listeners[type]!.filter((listenerObj) => {
+      if (listenerObj.shouldRemove) {
+        _console.log(`removing "${type}" eventListener`, listenerObj);
+      }
+      return !listenerObj.shouldRemove;
+    });
+  }
+
+  addEventListener<T extends EventType>(
+    type: T,
+    listener: (event: { type: T; target: Target; message: EventMessages[T] }) => void,
+    options: { once?: boolean } = { once: false }
+  ): void {
+    if (!this.isValidEventType(type)) {
+      throw new Error(`Invalid event type: ${type}`);
+    }
+
+    if (!this.listeners[type]) {
+      this.listeners[type] = [];
+      _console.log(`creating "${type}" listeners array`, this.listeners[type]!);
+    }
+    _console.log(`adding "${type}" listener`, listener, options);
+    this.listeners[type]!.push({ listener, once: options.once });
+
+    _console.log(`currently have ${this.listeners[type]!.length} "${type}" listeners`);
+  }
+
+  removeEventListener<T extends EventType>(
+    type: T,
+    listener: (event: { type: T; target: Target; message: EventMessages[T] }) => void
+  ): void {
+    if (!this.isValidEventType(type)) {
+      throw new Error(`Invalid event type: ${type}`);
+    }
+
+    if (!this.listeners[type]) return;
+
+    _console.log(`removing "${type}" listener...`, listener);
+    this.listeners[type]!.forEach((listenerObj) => {
+      const isListenerToRemove = listenerObj.listener === listener;
+      if (isListenerToRemove) {
+        _console.log(`flagging "${type}" listener`, listener);
+        listenerObj.shouldRemove = true;
+      }
+    });
+
+    this.updateEventListeners(type);
+  }
+
+  dispatchEvent<T extends EventType>(type: T, message: EventMessages[T]): void {
+    if (!this.isValidEventType(type)) {
+      throw new Error(`Invalid event type: ${type}`);
+    }
+
+    if (!this.listeners[type]) return;
+
+    this.listeners[type]!.forEach((listenerObj) => {
+      if (listenerObj.shouldRemove) {
+        return;
+      }
+
+      _console.log(`dispatching "${type}" listener`, listenerObj);
+      listenerObj.listener({ type, target: this.target, message });
+
+      if (listenerObj.once) {
+        _console.log(`flagging "${type}" listener`, listenerObj);
+        listenerObj.shouldRemove = true;
+      }
+    });
+    this.updateEventListeners(type);
+  }
+
+  waitForEvent<T extends EventType>(type: T): Promise<{ type: T; target: Target; message: EventMessages[T] }> {
+    return new Promise((resolve) => {
+      const onceListener = (event: { type: T; target: Target; message: EventMessages[T] }) => {
+        resolve(event);
+      };
+
+      this.addEventListener(type, onceListener, { once: true });
+    });
+  }
+}
+
+export default EventDispatcher;

package/src/utils/EventUtils.ts

@@ -0,0 +1,41 @@
+import { createConsole } from "./Console.ts";
+import { spacesToPascalCase } from "./stringUtils.ts";
+
+const _console = createConsole("EventUtils", { log: false });
+
+type BoundEventListeners = { [eventType: string]: EventListener };
+export type BoundGenericEventListeners = { [eventType: string]: Function };
+
+export function bindEventListeners(
+  eventTypes: readonly string[],
+  boundEventListeners: BoundGenericEventListeners,
+  target: any
+) {
+  _console.log("bindEventListeners", { eventTypes, boundEventListeners, target });
+  eventTypes.forEach((eventType) => {
+    const _eventType = `_on${spacesToPascalCase(eventType)}`;
+    _console.assertWithError(target[_eventType], `no event "${_eventType}" found in target`);
+    _console.log(`binding eventType "${eventType}" as ${_eventType} from target`, target);
+    const boundEvent = target[_eventType].bind(target);
+    target[_eventType] = boundEvent;
+    boundEventListeners[eventType] = boundEvent;
+  });
+}
+
+export function addEventListeners(target: any, boundEventListeners: BoundGenericEventListeners) {
+  let addEventListener = target.addEventListener || target.addListener || target.on || target.AddEventListener;
+  _console.assertWithError(addEventListener, "no add listener function found for target");
+  addEventListener = addEventListener.bind(target);
+  Object.entries(boundEventListeners).forEach(([eventType, eventListener]) => {
+    addEventListener(eventType, eventListener);
+  });
+}
+
+export function removeEventListeners(target: any, boundEventListeners: BoundGenericEventListeners) {
+  let removeEventListener = target.removeEventListener || target.removeListener || target.RemoveEventListener;
+  _console.assertWithError(removeEventListener, "no remove listener function found for target");
+  removeEventListener = removeEventListener.bind(target);
+  Object.entries(boundEventListeners).forEach(([eventType, eventListener]) => {
+    removeEventListener(eventType, eventListener);
+  });
+}

package/src/utils/MathUtils.ts

@@ -0,0 +1,53 @@
+import { createConsole } from "./Console.ts";
+
+const _console = createConsole("MathUtils", { log: true });
+
+export function getInterpolation(value: number, min: number, max: number, span: number) {
+  if (span == undefined) {
+    span = max - min;
+  }
+  return (value - min) / span;
+}
+
+export const Uint16Max = 2 ** 16;
+
+function removeLower2Bytes(number: number) {
+  const lower2Bytes = number % Uint16Max;
+  return number - lower2Bytes;
+}
+
+const timestampThreshold = 60_000;
+
+export function parseTimestamp(dataView: DataView, byteOffset: number) {
+  const now = Date.now();
+  const nowWithoutLower2Bytes = removeLower2Bytes(now);
+  const lower2Bytes = dataView.getUint16(byteOffset, true);
+  let timestamp = nowWithoutLower2Bytes + lower2Bytes;
+  if (Math.abs(now - timestamp) > timestampThreshold) {
+    _console.log("correcting timestamp delta");
+    timestamp += Uint16Max * Math.sign(now - timestamp);
+  }
+  return timestamp;
+}
+
+export interface Vector2 {
+  x: number;
+  y: number;
+}
+
+export interface Vector3 extends Vector2 {
+  z: number;
+}
+
+export interface Quaternion {
+  x: number;
+  y: number;
+  z: number;
+  w: number;
+}
+
+export interface Euler {
+  heading: number;
+  pitch: number;
+  roll: number;
+}

package/src/utils/ParseUtils.ts

@@ -0,0 +1,46 @@
+import { sliceDataView } from "./ArrayBufferUtils.ts";
+import { createConsole } from "./Console.ts";
+import { textDecoder } from "./Text.ts";
+
+const _console = createConsole("ParseUtils", { log: true });
+
+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)
+  );
+  byteOffset += stringLength;
+  return { string, byteOffset };
+}
+
+export function parseMessage<MessageType extends string>(
+  dataView: DataView,
+  messageTypes: readonly MessageType[],
+  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}`);
+    const messageType = messageTypes[messageTypeEnum];
+
+    let messageLength: number;
+    if (parseMessageLengthAsUint16) {
+      messageLength = dataView.getUint16(byteOffset, true);
+      byteOffset += 2;
+    } else {
+      messageLength = dataView.getUint8(byteOffset++);
+    }
+
+    _console.log({ messageTypeEnum, messageType, messageLength, dataView, byteOffset });
+
+    const _dataView = sliceDataView(dataView, byteOffset, messageLength);
+    _console.log({ _dataView });
+
+    callback(messageType, _dataView, context);
+
+    byteOffset += messageLength;
+  }
+}

package/src/utils/RangeHelper.ts

@@ -0,0 +1,38 @@
+import { getInterpolation } from "./MathUtils.ts";
+
+interface Range {
+  min: number;
+  max: number;
+  span: number;
+}
+
+const initialRange: Range = { min: Infinity, max: -Infinity, span: 0 };
+
+class RangeHelper {
+  #range: Range = Object.assign({}, initialRange);
+
+  reset() {
+    Object.assign(this.#range, initialRange);
+  }
+
+  update(value: number) {
+    this.#range.min = Math.min(value, this.#range.min);
+    this.#range.max = Math.max(value, this.#range.max);
+    this.#range.span = this.#range.max - this.#range.min;
+  }
+
+  getNormalization(value: number, weightByRange: boolean) {
+    let normalization = getInterpolation(value, this.#range.min, this.#range.max, this.#range.span);
+    if (weightByRange) {
+      normalization *= this.#range.span;
+    }
+    return normalization || 0;
+  }
+
+  updateAndGetNormalization(value: number, weightByRange: boolean) {
+    this.update(value);
+    return this.getNormalization(value, weightByRange);
+  }
+}
+
+export default RangeHelper;

package/src/utils/Text.ts

@@ -0,0 +1,30 @@
+var _TextEncoder;
+if (typeof TextEncoder == "undefined") {
+  _TextEncoder = class {
+    encode(string: string) {
+      const encoding = Array.from(string).map((char) => char.charCodeAt(0));
+      return Uint8Array.from(encoding);
+    }
+  };
+} else {
+  _TextEncoder = TextEncoder;
+}
+
+var _TextDecoder;
+if (typeof TextDecoder == "undefined") {
+  _TextDecoder = class {
+    decode(data: ArrayBuffer) {
+      const byteArray = Array.from(new Uint8Array(data));
+      return byteArray
+        .map((value) => {
+          return String.fromCharCode(value);
+        })
+        .join("");
+    }
+  };
+} else {
+  _TextDecoder = TextDecoder;
+}
+
+export const textEncoder = new _TextEncoder();
+export const textDecoder = new _TextDecoder();

package/src/utils/Timer.ts

@@ -0,0 +1,72 @@
+import { createConsole } from "./Console.ts";
+
+const _console = createConsole("Timer", { log: false });
+
+export async function wait(delay: number) {
+  _console.log(`waiting for ${delay} ms`);
+  return new Promise((resolve: Function) => {
+    setTimeout(() => resolve(), delay);
+  });
+}
+
+class Timer {
+  #callback!: Function;
+  get callback() {
+    return this.#callback;
+  }
+  set callback(newCallback) {
+    _console.assertTypeWithError(newCallback, "function");
+    _console.log({ newCallback });
+    this.#callback = newCallback;
+    if (this.isRunning) {
+      this.restart();
+    }
+  }
+
+  #interval!: number;
+  get interval() {
+    return this.#interval;
+  }
+  set interval(newInterval) {
+    _console.assertTypeWithError(newInterval, "number");
+    _console.assertWithError(newInterval > 0, "interval must be above 0");
+    _console.log({ newInterval });
+    this.#interval = newInterval;
+    if (this.isRunning) {
+      this.restart();
+    }
+  }
+
+  constructor(callback: Function, interval: number) {
+    this.interval = interval;
+    this.callback = callback;
+  }
+
+  #intervalId: number | undefined;
+  get isRunning() {
+    return this.#intervalId != undefined;
+  }
+
+  start() {
+    if (this.isRunning) {
+      _console.log("interval already running");
+      return;
+    }
+    _console.log("starting interval");
+    this.#intervalId = setInterval(this.#callback, this.#interval);
+  }
+  stop() {
+    if (!this.isRunning) {
+      _console.log("interval already not running");
+      return;
+    }
+    _console.log("stopping interval");
+    clearInterval(this.#intervalId);
+    this.#intervalId = undefined;
+  }
+  restart() {
+    this.stop();
+    this.start();
+  }
+}
+export default Timer;

package/src/utils/TypeScriptUtils.ts

@@ -0,0 +1,22 @@
+export type ValueOf<T> = T[keyof T];
+export type KeyOf<T> = keyof T;
+
+export type AddProperty<T, Key extends string, Value> = T & { [K in Key]: Value };
+export type AddPropertyToInterfaceValues<Interface, Key extends string, Value> = {
+  [_ in keyof Interface]: AddProperty<Interface[_], Key, Value>;
+};
+export type AddKeysAsPropertyToInterface<Interface, Key extends string> = {
+  [Value in keyof Interface]: AddProperty<Interface[Value], Key, Value>;
+};
+
+export type ExtendInterfaceValues<Interface, T> = {
+  [Key in keyof Interface]: Interface[Key] & T;
+};
+
+export type CapitalizeFirstLetter<S extends string> = S extends `${infer First}${infer Rest}`
+  ? `${Uppercase<First>}${Rest}`
+  : S;
+export type AddPrefix<P extends string, S extends string> = `${P}${CapitalizeFirstLetter<S>}`;
+export type AddPrefixToInterfaceKeys<Interface, P extends string> = {
+  [Key in keyof Interface as `${AddPrefix<P, Key & string>}`]: Interface[Key];
+};