@muspellheim/shared 0.16.0 → 0.18.0

package/dist/mod.js

@@ -0,0 +1,524 @@
+// src/common/clock.ts
+class Clock {
+  static system() {
+    return new Clock;
+  }
+  static fixed(date) {
+    return new Clock(new Date(date));
+  }
+  static offset(clock, offsetMillis) {
+    return new Clock(new Date(clock.millis() + offsetMillis));
+  }
+  #date;
+  constructor(date) {
+    this.#date = date;
+  }
+  date() {
+    return this.#date ? new Date(this.#date) : new Date;
+  }
+  millis() {
+    return this.date().getTime();
+  }
+}
+// src/common/event_tracker.ts
+class EventTracker {
+  static create(eventTarget, ...event) {
+    return new EventTracker(eventTarget, event);
+  }
+  #eventTarget;
+  #event;
+  #events;
+  #tracker;
+  constructor(eventTarget, event) {
+    this.#eventTarget = eventTarget;
+    this.#event = event;
+    this.#events = [];
+    this.#tracker = (event2) => this.#events.push(event2);
+    this.#event.forEach((event2) => this.#eventTarget.addEventListener(event2, this.#tracker));
+  }
+  get events() {
+    return this.#events;
+  }
+  clear() {
+    const result = [...this.#events];
+    this.#events.length = 0;
+    return result;
+  }
+  stop() {
+    this.#event.forEach((event) => this.#eventTarget.removeEventListener(event, this.#tracker));
+  }
+  async waitFor(count = 1) {
+    return new Promise((resolve) => {
+      const checkEvents = () => {
+        if (this.#events.length >= count) {
+          this.#event.forEach((event) => this.#eventTarget.removeEventListener(event, checkEvents));
+          resolve(this.events);
+        }
+      };
+      this.#event.forEach((event) => this.#eventTarget.addEventListener(event, checkEvents));
+      checkEvents();
+    });
+  }
+}
+// src/domain/messages.ts
+class Success {
+  isSuccess = true;
+  result;
+  constructor(result) {
+    this.result = result;
+  }
+}
+
+class Failure {
+  isSuccess = false;
+  errorMessage;
+  constructor(errorMessage) {
+    this.errorMessage = errorMessage;
+  }
+}
+// src/infrastructure/configurable_responses.ts
+class ConfigurableResponses {
+  static create(responses, name) {
+    return new ConfigurableResponses(responses, name);
+  }
+  static mapObject(responseObject, name) {
+    const entries = Object.entries(responseObject);
+    const translatedEntries = entries.map(([key, value]) => {
+      const translatedName = name === undefined ? undefined : `${name}: ${key}`;
+      return [key, ConfigurableResponses.create(value, translatedName)];
+    });
+    return Object.fromEntries(translatedEntries);
+  }
+  #description;
+  #responses;
+  constructor(responses, name) {
+    this.#description = name == null ? "" : ` in ${name}`;
+    this.#responses = Array.isArray(responses) ? [...responses] : responses;
+  }
+  next() {
+    const response = Array.isArray(this.#responses) ? this.#responses.shift() : this.#responses;
+    if (response === undefined) {
+      throw new Error(`No more responses configured${this.#description}.`);
+    }
+    return response;
+  }
+}
+// src/infrastructure/output_tracker.ts
+class OutputTracker {
+  static create(eventTarget, event) {
+    return new OutputTracker(eventTarget, event);
+  }
+  #eventTarget;
+  #event;
+  #data;
+  #tracker;
+  constructor(eventTarget, event) {
+    this.#eventTarget = eventTarget;
+    this.#event = event;
+    this.#data = [];
+    this.#tracker = (event2) => this.#data.push(event2.detail);
+    this.#eventTarget.addEventListener(this.#event, this.#tracker);
+  }
+  get data() {
+    return this.#data;
+  }
+  clear() {
+    const result = [...this.#data];
+    this.#data.length = 0;
+    return result;
+  }
+  stop() {
+    this.#eventTarget.removeEventListener(this.#event, this.#tracker);
+  }
+}
+
+// src/infrastructure/console_log.ts
+var MESSAGE_EVENT = "message";
+
+class ConsoleLog extends EventTarget {
+  static create({ name } = {}) {
+    return new ConsoleLog(globalThis.console, name);
+  }
+  static createNull({ name } = {}) {
+    return new ConsoleLog(new ConsoleStub, name);
+  }
+  name;
+  level = "info";
+  #console;
+  constructor(console, name) {
+    super();
+    this.name = name;
+    this.#console = console;
+  }
+  log(...data) {
+    if (!this.isLoggable("log")) {
+      return;
+    }
+    data = this.#applyName(data);
+    this.#console.log(...data);
+    this.dispatchEvent(new CustomEvent(MESSAGE_EVENT, {
+      detail: { level: "log", message: data }
+    }));
+  }
+  error(...data) {
+    if (!this.isLoggable("error")) {
+      return;
+    }
+    data = this.#applyName(data);
+    this.#console.error(...data);
+    this.dispatchEvent(new CustomEvent(MESSAGE_EVENT, {
+      detail: { level: "error", message: data }
+    }));
+  }
+  warn(...data) {
+    if (!this.isLoggable("warn")) {
+      return;
+    }
+    data = this.#applyName(data);
+    this.#console.warn(...data);
+    this.dispatchEvent(new CustomEvent(MESSAGE_EVENT, {
+      detail: { level: "warn", message: data }
+    }));
+  }
+  info(...data) {
+    if (!this.isLoggable("info")) {
+      return;
+    }
+    data = this.#applyName(data);
+    this.#console.info(...data);
+    this.dispatchEvent(new CustomEvent(MESSAGE_EVENT, {
+      detail: { level: "info", message: data }
+    }));
+  }
+  debug(...data) {
+    if (!this.isLoggable("debug")) {
+      return;
+    }
+    data = this.#applyName(data);
+    this.#console.debug(...data);
+    this.dispatchEvent(new CustomEvent(MESSAGE_EVENT, {
+      detail: { level: "debug", message: data }
+    }));
+  }
+  trace(...data) {
+    if (!this.isLoggable("trace")) {
+      return;
+    }
+    data = this.#applyName(data);
+    this.#console.trace(...data);
+    this.dispatchEvent(new CustomEvent(MESSAGE_EVENT, {
+      detail: { level: "trace", message: data }
+    }));
+  }
+  trackMessages() {
+    return new OutputTracker(this, MESSAGE_EVENT);
+  }
+  isLoggable(level) {
+    const normalize = (level2) => level2 === "log" ? "info" : level2;
+    const levels = [
+      "off",
+      "error",
+      "warn",
+      "info",
+      "debug",
+      "trace"
+    ];
+    const currentLevelIndex = levels.indexOf(normalize(this.level));
+    const messageLevelIndex = levels.indexOf(normalize(level));
+    return messageLevelIndex <= currentLevelIndex;
+  }
+  #applyName(data) {
+    if (this.name == null) {
+      return data;
+    }
+    return [`${this.name}`, ...data];
+  }
+}
+
+class ConsoleStub {
+  log(..._data) {}
+  error(..._data) {}
+  warn(..._data) {}
+  info(..._data) {}
+  debug(..._data) {}
+  trace(..._data) {}
+}
+// src/infrastructure/fetch_stub.ts
+function createFetchStub(responses) {
+  const configurableResponses = ConfigurableResponses.create(responses);
+  return async function() {
+    const response = configurableResponses.next();
+    if (response instanceof Error) {
+      throw response;
+    }
+    let body = response?.body;
+    if (body != null && !(body instanceof Blob) && !(typeof body === "string")) {
+      body = JSON.stringify(body);
+    }
+    return new Response(body, {
+      status: response.status,
+      statusText: response.statusText
+    });
+  };
+}
+// src/infrastructure/sse_client.ts
+class SseClient extends EventTarget {
+  static create() {
+    return new SseClient(EventSource);
+  }
+  static createNull() {
+    return new SseClient(EventSourceStub);
+  }
+  #eventSourceConstructor;
+  #eventSource;
+  constructor(eventSourceConstructor) {
+    super();
+    this.#eventSourceConstructor = eventSourceConstructor;
+  }
+  get isConnected() {
+    return this.#eventSource?.readyState === this.#eventSourceConstructor.OPEN;
+  }
+  get url() {
+    return this.#eventSource?.url;
+  }
+  async connect(url, eventName = "message", ...otherEvents) {
+    await new Promise((resolve, reject) => {
+      if (this.isConnected) {
+        reject(new Error("Already connected."));
+        return;
+      }
+      try {
+        this.#eventSource = new this.#eventSourceConstructor(url);
+        this.#eventSource.addEventListener("open", (e) => {
+          this.#handleOpen(e);
+          resolve();
+        });
+        this.#eventSource.addEventListener(eventName, (e) => this.#handleMessage(e));
+        for (const otherEvent of otherEvents) {
+          this.#eventSource.addEventListener(otherEvent, (e) => this.#handleMessage(e));
+        }
+        this.#eventSource.addEventListener("error", (e) => this.#handleError(e));
+      } catch (error) {
+        reject(error);
+      }
+    });
+  }
+  async send(_message, _type) {
+    throw new Error("unsupported method");
+  }
+  async close() {
+    await new Promise((resolve, reject) => {
+      if (!this.isConnected) {
+        resolve();
+        return;
+      }
+      try {
+        this.#eventSource.close();
+        resolve();
+      } catch (error) {
+        reject(error);
+      }
+    });
+  }
+  simulateMessage(message, eventName = "message", lastEventId) {
+    if (typeof message !== "string") {
+      message = JSON.stringify(message);
+    }
+    this.#handleMessage(new MessageEvent(eventName, { data: message, lastEventId }));
+  }
+  simulateError() {
+    this.#handleError(new Event("error"));
+  }
+  #handleOpen(event) {
+    this.dispatchEvent(new Event(event.type, event));
+  }
+  #handleMessage(event) {
+    this.dispatchEvent(new MessageEvent(event.type, event));
+  }
+  #handleError(event) {
+    this.dispatchEvent(new Event(event.type, event));
+  }
+}
+
+class EventSourceStub extends EventTarget {
+  static CONNECTING = 0;
+  static OPEN = 1;
+  static CLOSED = 2;
+  url;
+  readyState = EventSourceStub.CONNECTING;
+  constructor(url) {
+    super();
+    this.url = url.toString();
+    setTimeout(() => {
+      this.readyState = EventSourceStub.OPEN;
+      this.dispatchEvent(new Event("open"));
+    }, 0);
+  }
+  close() {
+    this.readyState = EventSourceStub.CLOSED;
+  }
+}
+// src/infrastructure/web_socket_client.ts
+var HEARTBEAT_TYPE = "heartbeat";
+var MESSAGE_SENT_EVENT = "message-sent";
+
+class WebSocketClient extends EventTarget {
+  static create({
+    heartbeat = 30000,
+    retry = 1000
+  } = {}) {
+    return new WebSocketClient(heartbeat, retry, WebSocket);
+  }
+  static createNull({ heartbeat = 0, retry = 0 } = {}) {
+    return new WebSocketClient(heartbeat, retry, WebSocketStub);
+  }
+  #heartbeat;
+  #retry;
+  #webSocketConstructor;
+  #webSocket;
+  #heartbeatId;
+  #retryId;
+  constructor(heartbeat, retry, webSocketConstructor) {
+    super();
+    this.#heartbeat = heartbeat;
+    this.#retry = retry;
+    this.#webSocketConstructor = webSocketConstructor;
+  }
+  get isConnected() {
+    return this.#webSocket?.readyState === WebSocket.OPEN;
+  }
+  get url() {
+    return this.#webSocket?.url;
+  }
+  async connect(url) {
+    await new Promise((resolve, reject) => {
+      this.#stopRetry();
+      if (this.isConnected) {
+        reject(new Error("Already connected."));
+        return;
+      }
+      try {
+        this.#webSocket = new this.#webSocketConstructor(url);
+        this.#webSocket.addEventListener("open", (e) => {
+          this.#handleOpen(e);
+          resolve();
+        });
+        this.#webSocket.addEventListener("message", (e) => this.#handleMessage(e));
+        this.#webSocket.addEventListener("close", (e) => this.#handleClose(e));
+        this.#webSocket.addEventListener("error", (e) => this.#handleError(e));
+      } catch (error) {
+        reject(error);
+      }
+    });
+  }
+  async send(message) {
+    if (!this.isConnected) {
+      throw new Error("Not connected.");
+    }
+    this.#webSocket.send(message);
+    this.dispatchEvent(new CustomEvent(MESSAGE_SENT_EVENT, { detail: message }));
+    await Promise.resolve();
+  }
+  trackMessageSent() {
+    return OutputTracker.create(this, MESSAGE_SENT_EVENT);
+  }
+  async close(code, reason) {
+    await new Promise((resolve) => {
+      this.#stopRetry();
+      if (!this.isConnected) {
+        resolve();
+        return;
+      }
+      this.#webSocket.addEventListener("close", () => resolve());
+      this.#webSocket.close(code, reason);
+    });
+  }
+  simulateMessage(message) {
+    if (typeof message !== "string" && !(message instanceof Blob) && !(message instanceof ArrayBuffer)) {
+      message = JSON.stringify(message);
+    }
+    this.#handleMessage(new MessageEvent("message", { data: message }));
+  }
+  simulateHeartbeat() {
+    this.#sendHeartbeat();
+  }
+  simulateClose(code, reason) {
+    this.#handleClose(new CloseEvent("close", { code, reason }));
+  }
+  simulateError() {
+    this.#webSocket?.close();
+    this.#handleError(new Event("error"));
+  }
+  #handleOpen(event) {
+    this.dispatchEvent(new Event(event.type, event));
+    this.#startHeartbeat();
+  }
+  #handleMessage(event) {
+    this.dispatchEvent(new MessageEvent(event.type, event));
+  }
+  #handleClose(event) {
+    this.#stopHeartbeat();
+    this.dispatchEvent(new CloseEvent(event.type, event));
+  }
+  #handleError(event) {
+    this.dispatchEvent(new Event(event.type, event));
+    this.#startRetry();
+  }
+  #startRetry() {
+    if (this.#retry <= 0) {
+      return;
+    }
+    this.#retryId = setInterval(() => this.connect(this.#webSocket.url), this.#retry);
+  }
+  #stopRetry() {
+    clearInterval(this.#retryId);
+    this.#retryId = undefined;
+  }
+  #startHeartbeat() {
+    if (this.#heartbeat <= 0) {
+      return;
+    }
+    this.#heartbeatId = setInterval(() => this.#sendHeartbeat(), this.#heartbeat);
+  }
+  #stopHeartbeat() {
+    clearInterval(this.#heartbeatId);
+    this.#heartbeatId = undefined;
+  }
+  #sendHeartbeat() {
+    if (this.#heartbeatId == null) {
+      return;
+    }
+    this.send(HEARTBEAT_TYPE);
+  }
+}
+
+class WebSocketStub extends EventTarget {
+  url;
+  readyState = WebSocket.CONNECTING;
+  constructor(url) {
+    super();
+    this.url = url.toString();
+    setTimeout(() => {
+      this.readyState = WebSocket.OPEN;
+      this.dispatchEvent(new Event("open"));
+    }, 0);
+  }
+  send() {}
+  close() {
+    this.readyState = WebSocket.CLOSED;
+    this.dispatchEvent(new Event("close"));
+  }
+}
+export {
+  createFetchStub,
+  WebSocketClient,
+  Success,
+  SseClient,
+  OutputTracker,
+  HEARTBEAT_TYPE,
+  Failure,
+  EventTracker,
+  ConsoleLog,
+  ConfigurableResponses,
+  Clock
+};

package/dist/types/common/clock.d.ts

@@ -0,0 +1,40 @@
+/**
+ * A clock provides access to the current timestamp.
+ */
+export declare class Clock {
+    #private;
+    /**
+     * Create a clock using system the clock.
+     *
+     * @return A clock that uses the system clock.
+     */
+    static system(): Clock;
+    /**
+     * Create a clock using a fixed date.
+     *
+     * @param date The fixed date of the clock.
+     * @return A clock that always returns a fixed date.
+     */
+    static fixed(date: Date | string | number): Clock;
+    /**
+     * Create a clock that returns a fixed offset from the given clock.
+     *
+     * @param clock The clock to offset from.
+     * @param offsetMillis The offset in milliseconds.
+     * @return A clock that returns a fixed offset from the given clock.
+     */
+    static offset(clock: Clock, offsetMillis: number): Clock;
+    private constructor();
+    /**
+     * Return the current timestamp of the clock.
+     *
+     * @return The current timestamp.
+     */
+    date(): Date;
+    /**
+     * Return the current timestamp of the clock in milliseconds.
+     *
+     * @return The current timestamp in milliseconds.
+     */
+    millis(): number;
+}

package/dist/types/common/event_tracker.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Track events from an event target.
+ *
+ * Wait asynchronously for events. Useful in test code.
+ */
+export declare class EventTracker<T extends Event> {
+    #private;
+    /**
+     * Create a tracker for a specific event of an event target.
+     *
+     * @param eventTarget The target to track.
+     * @param event The event name to track.
+     */
+    static create<T extends Event>(eventTarget: EventTarget, ...event: string[]): EventTracker<T>;
+    /**
+     * Create a tracker for a specific event of an event target.
+     *
+     * @param eventTarget The target to track.
+     * @param event The event name to track.
+     */
+    constructor(eventTarget: EventTarget, event: string[]);
+    /**
+     * Return the tracked events.
+     *
+     * @return The tracked events.
+     */
+    get events(): T[];
+    /**
+     * Clear the tracked events and return the cleared events.
+     *
+     * @return The cleared events.
+     */
+    clear(): T[];
+    /**
+     * Stop tracking.
+     */
+    stop(): void;
+    /**
+     * Wait asynchronously for a number of events.
+     *
+     * @param count number of events, default 1.
+     */
+    waitFor(count?: number): Promise<T[]>;
+}

package/dist/types/common/log.d.ts

@@ -0,0 +1,17 @@
+/** Defines level for setting a log level in a `Log` implementation. */
+export type LogLevel = "log" | "error" | "warn" | "info" | "debug" | "trace" | "off";
+/**
+ * A simple logging facade.
+ *
+ * This is a subset of the `Console` interface.
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/Console_API
+ */
+export interface Log {
+    log(...data: unknown[]): void;
+    error(...data: unknown[]): void;
+    warn(...data: unknown[]): void;
+    info(...data: unknown[]): void;
+    debug(...data: unknown[]): void;
+    trace(...data: unknown[]): void;
+}

package/{src/common/mod.ts → dist/types/common/mod.d.ts}

@@ -1,5 +1,3 @@
-// Copyright (c) 2025 Falko Schumann. All rights reserved. MIT license.
-
 export * from "./clock";
 export * from "./event_tracker";
 export * from "./log";

package/{src/domain/messages.ts → dist/types/domain/messages.d.ts}

@@ -1,5 +1,3 @@
-// Copyright (c) 2025 Falko Schumann. All rights reserved. MIT license.
-
 /**
  * Provides CQNS features.
  *
@@ -22,37 +20,28 @@
  * @see https://ralfw.de/command-query-notification-separation-cqns/
  * @module
  */
-
 /**
  * The status returned by a command handler.
  */
 export type CommandStatus = Success | Failure;
-
 /**
  * A successful status.
  */
-export class Success<T = unknown> {
-  readonly isSuccess = true;
-  readonly result?: T;
-
-  constructor(result?: T) {
-    this.result = result;
-  }
+export declare class Success<T = unknown> {
+    readonly isSuccess = true;
+    readonly result?: T;
+    constructor(result?: T);
 }
-
 /**
  * A failed status.
  */
-export class Failure<T = string> {
-  readonly isSuccess = false;
-  readonly errorMessage: T;
-
-  /**
-   * Creates a failed status.
-   *
-   * @param errorMessage
-   */
-  constructor(errorMessage: T) {
-    this.errorMessage = errorMessage;
-  }
+export declare class Failure<T = string> {
+    readonly isSuccess = false;
+    readonly errorMessage: T;
+    /**
+     * Creates a failed status.
+     *
+     * @param errorMessage
+     */
+    constructor(errorMessage: T);
 }

package/dist/types/domain/mod.d.ts

@@ -0,0 +1 @@
+export * from "./messages";