feat: introduce AbstractEvent and upgrade to node 20.x

Author: CMCDragonkai

.eslintrc

@@ -39,6 +39,7 @@
         "message": "Use `globalThis` instead"
       }
     ],
+    "prefer-rest-params": 0,
     "require-yield": 0,
     "eqeqeq": ["error", "smart"],
     "spaced-comment": [

package-lock.json

@@ -47,5 +47,8 @@
     "tsconfig-paths": "^3.9.0",
     "typedoc": "^0.23.21",
     "typescript": "^4.9.3"
+  },
+  "engines": {
+    "node": ">=19.0.0"
   }
 }

package.json

@@ -1,4 +1,4 @@
 import (
-  let rev = "f294325aed382b66c7a188482101b0f336d1d7db"; in
+  let rev = "ea5234e7073d5f44728c499192544a84244bf35a"; in
   builtins.fetchTarball "https://github.com/NixOS/nixpkgs/archive/${rev}.tar.gz"
 )

pkgs.nix

@@ -3,7 +3,7 @@
 with pkgs;
 mkShell {
   nativeBuildInputs = [
-    nodejs
+    nodejs_20
     shellcheck
     gitAndTools.gh
   ];

shell.nix

@@ -0,0 +1,52 @@
+/**
+ * By default the `detail` property of `CustomEvent` is `null`.
+ * So the default type has to be `null` too.
+ */
+class AbstractEvent<T = null> extends CustomEvent<T> {
+  protected constructorParams: IArguments;
+
+  public constructor(
+    type?: string,
+    options?: CustomEventInit<T>,
+    constructorParams?: IArguments,
+  );
+  public constructor(
+    options: CustomEventInit<T>,
+    constructorParams?: IArguments,
+  );
+  public constructor(
+    type: string | CustomEventInit<T> = new.target.name,
+    options?: CustomEventInit<T> | IArguments,
+    constructorParams?: IArguments,
+  ) {
+    if (typeof type === 'string') {
+      super(type, options as CustomEventInit<T> | undefined);
+    } else {
+      super(new.target.name, type);
+      constructorParams = options as IArguments | undefined;
+    }
+    this.constructorParams = constructorParams ?? arguments;
+  }
+
+  /**
+   * Events cannot be re-dispatched. This was probably to prevent infinite
+   * loops. So instead of re-dispatching the same instance, we re-dispatch
+   * a clone of the instance.
+   */
+  public clone(): this {
+    try {
+      return new (this.constructor as any)(...this.constructorParams);
+    } catch (e) {
+      // Normally we would check `instanceof TypeError`
+      // However jest appears to choke on that
+      if (e.name === 'TypeError') {
+        throw new TypeError(
+          `Cloning ${this.constructor.name} requires the original constructor arguments to be passed into super`,
+        );
+      }
+      throw e;
+    }
+  }
+}
+
+export default AbstractEvent;

src/AbstractEvent.ts

@@ -1,12 +1,11 @@
-// @ts-ignore package.json is outside rootDir
+import AbstractEvent from './AbstractEvent';
+// @ts-ignore package.json is outside root dir
 import { name } from '../package.json';
 
-class EventAny extends Event {
+class EventAny extends AbstractEvent<Event> {
   public static type = `${name}/${this.name}`;
-  public detail: Event;
-  constructor(options: EventInit & { detail: Event }) {
-    super(EventAny.type, options);
-    this.detail = options.detail;
+  public constructor(options: EventInit & { detail: Event }) {
+    super(EventAny.type, options, arguments);
   }
 }
 

src/EventAny.ts

@@ -11,7 +11,6 @@ interface Evented {
     callback: EventListenerOrEventListenerObject | null,
     options?: AddEventListenerOptions | boolean,
   ): void;
-  dispatchEvent(event: Event): boolean;
   removeEventListener(
     callback: EventListenerOrEventListenerObject | null,
     options?: EventListenerOptions | boolean,
@@ -21,6 +20,7 @@ interface Evented {
     callback: EventListenerOrEventListenerObject | null,
     options?: EventListenerOptions | boolean,
   ): void;
+  dispatchEvent(event: Event): boolean;
 }
 
 function Evented() {

src/Evented.ts

@@ -1,3 +1,4 @@
-export { Evented } from './Evented';
+export { default as AbstractEvent } from './AbstractEvent';
 export { default as EventAny } from './EventAny';
+export { Evented } from './Evented';
 export * as utils from './utils';

src/index.ts

@@ -1,6 +1,47 @@
-import { Evented, EventAny, utils } from '@';
+import { AbstractEvent, EventAny, Evented, utils } from '@';
 
-describe('Evented', () => {
+describe('index', () => {
+  test('abstract event subclasses', () => {
+    class Event0 extends AbstractEvent {}
+    class Event1<T> extends AbstractEvent<T> {}
+    class Event2 extends AbstractEvent<string> {}
+    class Event3 extends AbstractEvent<object> {}
+    const e0 = new Event0();
+    expect(e0.detail).toBeNull();
+    const e1 = new Event1();
+    expect(e1.detail).toBeNull();
+    const e1_ = new Event1({ detail: 'string' });
+    expect(e1_.detail).toBe('string');
+    // This is not caught by the type system
+    const e2 = new Event2();
+    expect(e2.detail).toBeNull();
+    const e2_ = new Event2({ detail: 'string' });
+    expect(e2_.detail).toBe('string');
+    const e11 = e1.clone();
+    expect(e11.type).toBe(e1.type);
+    expect(e11.detail).toBe(e1.detail);
+    const e22 = e2.clone();
+    expect(e22.type).toBe(e2.type);
+    expect(e22.detail).toBe(e2.detail);
+    const e3 = new Event3({ detail: { a: 1 } });
+    expect(e3.detail).toBe(e3.clone().detail);
+  });
+  test('abstract event subclasses with different constructors', () => {
+    class EventCustom1 extends AbstractEvent<string> {
+      constructor(options: CustomEventInit<string>) {
+        super(EventCustom1.name, options);
+      }
+    }
+    class EventCustom2 extends AbstractEvent<string> {
+      constructor(options: CustomEventInit<string>) {
+        super(EventCustom2.name, options, arguments);
+      }
+    }
+    const e1 = new EventCustom1({ detail: 'string' });
+    expect(() => e1.clone()).toThrow(TypeError);
+    const e2 = new EventCustom2({ detail: 'string' });
+    expect(() => e2.clone()).not.toThrowError();
+  });
   test('can access event target via symbol', () => {
     interface X extends Evented {}
     @Evented()