Design Patterns

Typescript implementation of design patterns:

• Singleton
• Channel
• Subscriber
• EventHandler

Class Diagram

The diagram below shows the relation between the different classes and interfaces.

@startuml

skin rose

title Event Handler

class Singleton {

• private static instance: object;
• protected constructor() {}

• public static getInstance = () => object; }

interface IChannel<MessageType, ReturnType> <> { + name: string; + subscribers: ISubscriber<MessageType, ReturnType>[]; + subscribe: (sub: ISubscriber<MessageType, ReturnType>) => void; + unsubscribe: (sub: ISubscriber<MessageType, ReturnType>) => void; + notify: (msg: MessageType) => Promise<PromiseSettledResult<Awaited>[]>; }

interface IEventHandler<MessageType, ReturnType> <> {

• channels: Array<IChannel<MessageType, ReturnType>>;
• createChannel: (name: string) => void;
• getChannel: (name: string) => IChannel<MessageType, ReturnType> | undefined;
• getChannels: () => Array<IChannel<MessageType, ReturnType>>;
• subscribe: (chName: string, o: ISubscriber<MessageType, ReturnType>) => void;
• unsubscribe: (chName: string, o: ISubscriber<MessageType, ReturnType>) => void;
• notify: (chName: string, msg: MessageType) => Promise<PromiseSettledResult<Awaited>[]>; }

interface ISubscriber<MessageType, ReturnType> <> {

• readonly id: string;
• update: SubscriberCallback<MessageType, ReturnType>;
• cb: SubscriberCallback<MessageType, ReturnType>; }

IChannel _-- ISubscriber IEventHandler _-- Singleton IEventHandler *-- IChannel

@enduml

Usage

Instantiating the Event Handler

To get a reference to the Singleton Event Handler, we can use the static getInstance() class method:

const eventHandler = EventHandler.getInstance<MessageType, ReturnType>();

Indeed, the constructor is declared protected and cannot (in TS at least) and shouldn't be invoked:

export default class EventHandler<MessageType, ReturnType> implements IEventHandler<MessageType, ReturnType> {
  ...

  private static instance: object;

  ...

  /**
   * constructor: Declared protected to defeat instantiation outside of class or child class (Singleton pattern)
   */
  protected constructor() {}

  /**
   * Returns the instance of the EventHandler class (Singleton pattern)
   * @returns the instance of the EventHandler class
   */
  public static getInstance = <MessageType, ReturnType>(): EventHandler<MessageType, ReturnType> =>
    !EventHandler.instance
      ? (EventHandler.instance = new EventHandler<MessageType, ReturnType>())
      : (EventHandler.instance as EventHandler<MessageType, ReturnType>);

  ...
};

Creating Channels

eventHandler.createChannel("keyboard-inputs");
eventHandler.createChannel("mouse-inputs");

Instantiating Subscriber and setting callback

const cb = () => {}
const sub = new Subscriber<MessageType, ReturnType>();
sub.setCallBack(cb)

Subscribing/Unsubscribing to Channel

eventHandler.subscribe("keyboard-inputs", sub);
eventHandler.unsubscribe("keyboard-inputs", sub);

Notifying the Event Handler

eventHandler.notify("keyboard-inputs", message)