motion-master-client 0.0.55 → 0.0.56

package/src/lib/motion-master-req-res-socket.ts

@@ -0,0 +1,68 @@
+import { BehaviorSubject, Observable } from "rxjs";
+import { IMotionMasterMessage } from "./types";
+
+export interface MotionMasterReqResSocket {
+  /**
+   * Emits a boolean value when socket gets opened or closed.
+   */
+  readonly opened$: BehaviorSubject<boolean>;
+
+  /**
+   * Emits close events with code and reason data.
+   * @link https://developer.mozilla.org/en-US/docs/Web/API/WebSocket/close_event
+   */
+  readonly close$: Observable<{ code: number; reason: string; }>
+
+  /**
+   * Motion Master is considered alive when it sends messages in regular time interval.
+   */
+  readonly alive$: BehaviorSubject<boolean>;
+
+  /**
+   * Decoded message instances coming from Motion Master.
+   */
+  readonly message$: Observable<IMotionMasterMessage>;
+
+  /**
+   * URL set in call to open.
+   */
+  get url(): string | undefined;
+
+  /**
+   * Send ping system messages to Motion Master with a fixed time delay between each call.
+   */
+  get pingSystemInterval(): number | undefined;
+
+  /**
+   * How long in milliseconds to consider Motion Master alive.
+   */
+  get systemAliveTimeout(): number | undefined;
+
+  /**
+   * Open socket.
+   *
+   * The connected$ and eventually alive$ observables will emit true values.
+   */
+  open(url: string, pingSystemInterval?: number, systemAliveTimeout?: number): void;
+
+  /**
+   * Close socket.
+   *
+   * The opened$ and alive$ observables will emit false values.
+   */
+  close(): void;
+
+  /**
+   * Reopen socket.
+   *
+   * Reopen if closed using the same url, pingSystemInterval, and systemAliveTimeout previously set in open.
+   */
+  reopen(): void;
+
+  /**
+   * Send an instance of a message.
+   *
+   * Subscribe to the message$ observable in order to receive the response messages.
+   */
+  send(message: IMotionMasterMessage): void;
+}

package/src/lib/motion-master-req-res-web-socket.ts

@@ -0,0 +1,123 @@
+import { BehaviorSubject, filter, interval, map, Subject, Subscription, tap } from "rxjs";
+import { webSocket, WebSocketSubject, WebSocketSubjectConfig } from "rxjs/webSocket";
+import { logger } from "./logger";
+import { MotionMasterReqResSocket } from "./motion-master-req-res-socket";
+import { IMotionMasterMessage, MotionMasterMessage } from "./types";
+import { convertMotionMasterMessageToLoggerContext, createPlainObjectFromMotionMasterMessage } from "./util";
+
+export class MotionMasterReqResWebSocket implements MotionMasterReqResSocket {
+
+  readonly opened$ = new BehaviorSubject<boolean>(false);
+
+  readonly close$ = new Subject<{ code: number; reason: string; }>;
+
+  readonly alive$ = new BehaviorSubject<boolean>(false);
+
+  readonly message$ = new Subject<IMotionMasterMessage>();
+
+  private aliveTimeoutId = 0;
+
+  private pingSystemObserver = { next: () => this.send({ request: { pingSystem: {} } }) };
+
+  private pingSystemSubscription?: Subscription;
+
+  private webSocket$?: WebSocketSubject<Uint8Array>;
+
+  private _url?: string;
+  private _pingSystemInterval?: number;
+  private _systemAliveTimeout?: number;
+
+  get url(): string | undefined {
+    return this._url;
+  }
+
+  get pingSystemInterval(): number | undefined {
+    return this._pingSystemInterval;
+  }
+
+  get systemAliveTimeout(): number | undefined {
+    return this._systemAliveTimeout;
+  }
+
+  open(url: string, pingSystemInterval = 250, systemAliveTimeout = 1000): void {
+    this._url = url;
+    this._pingSystemInterval = pingSystemInterval;
+    this._systemAliveTimeout = systemAliveTimeout;
+
+    this.webSocket$ = this.createWebSocket(url, pingSystemInterval);
+
+    this.webSocket$?.pipe(
+      map((data: Uint8Array) => MotionMasterMessage.decode(data)),
+      tap(() => this.keepalive(systemAliveTimeout)),
+      filter((message) => !(message.status?.systemPong)),
+      map(message => createPlainObjectFromMotionMasterMessage(message)),
+      tap((message) => {
+        const context = convertMotionMasterMessageToLoggerContext(message);
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        logger.info(context as any, `Received ${context.name}`);
+      }),
+    ).subscribe({
+      next: (message) => this.message$.next(message),
+      error: () => {
+        // ignore, clients will receive close$ event instead
+      },
+    });
+  }
+
+  close(): void {
+    this.webSocket$?.complete();
+  }
+
+  reopen() {
+    if (this.url && this.opened$.value === false) {
+      this.open(this.url, this.pingSystemInterval, this.systemAliveTimeout);
+    }
+  }
+
+  send(message: IMotionMasterMessage): void {
+    if (!message.request?.pingSystem) {
+      const context = convertMotionMasterMessageToLoggerContext(message);
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      logger.info(context as any, `Send ${context.name}`);
+    }
+
+    this.webSocket$?.next(MotionMasterMessage.encode(message).finish());
+  }
+
+  private createWebSocket(url: string, pingSystemInterval = 250) {
+    const webSocketConfig: WebSocketSubjectConfig<Uint8Array> = {
+      binaryType: 'arraybuffer',
+      closeObserver: {
+        next: (ev: CloseEvent) => {
+          this.pingSystemSubscription?.unsubscribe();
+          clearTimeout(this.aliveTimeoutId);
+          this.alive$.next(false);
+          this.opened$.next(false);
+          this.close$.next({ code: ev.code, reason: ev.reason });
+          logger.info(`Connection closed ${url}`);
+        },
+      },
+      deserializer: (e: MessageEvent) => new Uint8Array(e.data as unknown as Iterable<number>),
+      openObserver: {
+        next: () => {
+          this.pingSystemSubscription = interval(pingSystemInterval).subscribe(this.pingSystemObserver);
+          this.opened$.next(true);
+          logger.info(`Connection opened ${url}`);
+        },
+      },
+      serializer: (value: Uint8Array) => value,
+      url,
+    };
+
+    return webSocket(webSocketConfig);
+  }
+
+  private keepalive(systemAliveTimeout = 1000) {
+    if (this.alive$.getValue() === false) {
+      this.alive$.next(true);
+    }
+    clearTimeout(this.aliveTimeoutId);
+    this.aliveTimeoutId = setTimeout(() => this.alive$.next(false), systemAliveTimeout) as unknown as number;
+  }
+
+}

package/src/lib/motion-master-req-res-worker-socket.ts

@@ -0,0 +1,89 @@
+import { BehaviorSubject, Subject } from "rxjs";
+import { logger } from "./logger";
+import { MotionMasterReqResSocket } from "./motion-master-req-res-socket";
+import { IMotionMasterMessage } from "./types";
+import { convertMotionMasterMessageToLoggerContext } from "./util";
+
+export class MotionMasterReqResWorkerSocket implements MotionMasterReqResSocket {
+
+  readonly opened$ = new BehaviorSubject<boolean>(false);
+
+  readonly close$ = new Subject<{ code: number, reason: string }>();
+
+  readonly alive$ = new BehaviorSubject<boolean>(false);
+
+  readonly message$ = new Subject<IMotionMasterMessage>();
+
+  private _url?: string;
+  private _pingSystemInterval?: number;
+  private _systemAliveTimeout?: number;
+
+  constructor(
+    public readonly worker: Worker,
+  ) { }
+
+  get url(): string | undefined {
+    return this._url;
+  }
+
+  get pingSystemInterval(): number | undefined {
+    return this._pingSystemInterval;
+  }
+
+  get systemAliveTimeout(): number | undefined {
+    return this._systemAliveTimeout;
+  }
+
+  open(url: string, pingSystemInterval = 250, systemAliveTimeout = 1000): void {
+    this._url = url;
+    this._pingSystemInterval = pingSystemInterval;
+    this._systemAliveTimeout = systemAliveTimeout;
+
+    this.worker.onmessage = ({ data }) => {
+      if ('opened' in data) {
+        const { opened } = data;
+        this.opened$.next(opened);
+        logger.info(opened ? `Opened req/res 🔌 ${url}` : `Closed req/res 🔌 ${url}`);
+      } else if ('alive' in data) {
+        const { alive } = data;
+        this.alive$.next(alive);
+        logger.info(alive ? `System is alive 💓` : 'System is as dead as 🦤');
+      } else if ('message' in data) {
+        const { message } = data;
+
+        const context = convertMotionMasterMessageToLoggerContext(message);
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        logger.info(context as any, `Received ${context.name}`);
+
+        this.message$.next(message);
+      } else if ('close' in data) {
+        const { close } = data;
+        this.close$.next(close);
+        logger.info(`Close event received on req/res 🔌 ${url} ${JSON.stringify(close)}`);
+      }
+    }
+
+    this.worker.postMessage({
+      open: { url, pingSystemInterval, systemAliveTimeout },
+    });
+  }
+
+  reopen() {
+    if (this.url && this.opened$.value === false) {
+      this.open(this.url, this.pingSystemInterval, this.systemAliveTimeout);
+    }
+  }
+
+  close(): void {
+    this.worker.postMessage({ close: true });
+  }
+
+  send(message: IMotionMasterMessage): void {
+    const context = convertMotionMasterMessageToLoggerContext(message);
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    logger.info(context as any, `Send ${context.name}`);
+
+    this.worker.postMessage({ message });
+  }
+
+}