wip symfony style event dispatcher system

Author: Syndesi

src/Type/Definition/Event.ts

@@ -0,0 +1,74 @@
+import { EventIdentifier } from './EventIdentifier.js';
+
+interface EventInterface {
+  getIdentifier(): EventIdentifier;
+
+  isPropagationStopped(): boolean;
+  stopPropagation(): this;
+
+  getContextValue(key: string): unknown;
+  setContextValue(key: string, value: unknown): this;
+  hasContextValue(key: string): boolean;
+  clearContextValue(key: string): this;
+  getContext(): Readonly<Record<string, unknown>>;
+  setContext(context: Record<string, unknown>): this;
+  clearContext(): this;
+}
+
+class Event implements EventInterface {
+  private readonly identifier: EventIdentifier;
+  private stopped: boolean = false;
+  private context: Record<string, unknown>;
+
+  constructor(identifier: EventIdentifier, context: Record<string, unknown> = {}) {
+    this.identifier = identifier;
+    this.context = context;
+  }
+
+  getIdentifier(): EventIdentifier {
+    return this.identifier;
+  }
+
+  isPropagationStopped(): boolean {
+    return this.stopped;
+  }
+
+  stopPropagation(): this {
+    this.stopped = true;
+    return this;
+  }
+
+  getContextValue(key: string): unknown {
+    return this.context[key];
+  }
+
+  setContextValue(key: string, value: unknown): this {
+    this.context[key] = value;
+    return this;
+  }
+
+  hasContextValue(key: string): boolean {
+    return Object.prototype.hasOwnProperty.call(this.context, key);
+  }
+
+  clearContextValue(key: string): this {
+    delete this.context[key];
+    return this;
+  }
+
+  getContext(): Readonly<Record<string, unknown>> {
+    return { ...this.context };
+  }
+
+  setContext(context: Record<string, unknown>): this {
+    this.context = context;
+    return this;
+  }
+
+  clearContext(): this {
+    this.context = {};
+    return this;
+  }
+}
+
+export { EventInterface, Event };

src/Type/Definition/EventDispatcher.ts

@@ -0,0 +1,8 @@
+import {EventInterface} from "./Event";
+
+// todo: implement similar logic as in https://github.com/simshaun/ts-event-dispatcher/blob/master/src/index.ts
+interface EventDispatcher {
+  dispatchEvent(event: EventInterface): this;
+}
+
+export {EventDispatcher};

src/Type/Definition/EventIdentifier.ts

@@ -0,0 +1,18 @@
+import { Branded } from './Branded.js';
+import { ParseError } from '../../Error/index.js';
+
+/**
+ * Type safe variant of string containing event identifier.
+ */
+type EventIdentifier = Branded<string, 'eventIdentifier'>;
+
+const eventIdentifierRegex = /^([a-z][a-z0-9-]*)(\.([a-z][a-z0-9-]*))*$/;
+
+function validateEventIdentifierFromString(eventIdentifier: string): EventIdentifier {
+  if (!eventIdentifierRegex.test(eventIdentifier)) {
+    throw new ParseError('Passed variable is not a valid event identifier.');
+  }
+  return eventIdentifier as EventIdentifier;
+}
+
+export { EventIdentifier, validateEventIdentifierFromString, eventIdentifierRegex };

src/Type/Definition/EventListener.ts

@@ -0,0 +1,19 @@
+import { Branded } from './Branded.js';
+import { ParseError } from '../../Error/index.js';
+
+/**
+ * Type safe variant of string containing event identifier.
+ */
+type EventListenerIdentifier = Branded<string, 'eventListenerIdentifier'>;
+
+const eventListenerIdentifierRegex =
+  /^(?:([a-z][a-z0-9-]*)(\.([a-z][a-z0-9-]*))*|\*|([a-z][a-z0-9-]*)(\.([a-z][a-z0-9-]*))*(\.\*))$/;
+
+function validateEventListenerIdentifierFromString(eventListenerIdentifier: string): EventListenerIdentifier {
+  if (!eventListenerIdentifierRegex.test(eventListenerIdentifier)) {
+    throw new ParseError('Passed variable is not a valid event listener identifier.');
+  }
+  return eventListenerIdentifier as EventListenerIdentifier;
+}
+
+export { EventListenerIdentifier, validateEventListenerIdentifierFromString, eventListenerIdentifierRegex };