@gjsify/dom-events 0.0.2

package/README.md

@@ -0,0 +1,6 @@
+# @gjsify/dom-events
+
+## Inspirations and credits
+- https://deno.land/manual@v1.29.2/runtime/web_platform_apis#customevent-eventtarget-and-eventlistener
+- https://github.com/jsdom/jsdom/tree/master/lib/jsdom/living/events
+- https://github.com/capricorn86/happy-dom/tree/master/packages/happy-dom/src/event

package/lib/cjs/index.js

@@ -0,0 +1,17 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var src_exports = {};
+module.exports = __toCommonJS(src_exports);
+__reExport(src_exports, require("@gjsify/deno-runtime/ext/web/02_event"), module.exports);

package/lib/esm/index.js

@@ -0,0 +1 @@
+export * from "@gjsify/deno-runtime/ext/web/02_event";

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@gjsify/dom-events",
+  "version": "0.0.2",
+  "description": "Web events module for Gjs",
+  "main": "lib/cjs/index.js",
+  "module": "lib/esm/index.js",
+  "types": "lib/types/index.d.js",
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./lib/types/index.d.ts",
+        "default": "./lib/esm/index.js"
+      },
+      "require": {
+        "types": "./lib/types/index.d.ts",
+        "default": "./lib/cjs/index.js"
+      }
+    }
+  },
+  "scripts": {
+    "clear": "rm -rf lib tsconfig.tsbuildinfo test.gjs.mjs",
+    "print:name": "echo '@gjsify/dom-events'",
+    "build": "yarn print:name && yarn build:gjsify && yarn build:types",
+    "build:gjsify": "gjsify build --library 'src/**/*.{ts,js}' --exclude 'src/**/*.spec.{mts,ts}' 'src/test.{mts,ts}'",
+    "build:types": "tsc --project tsconfig.types.json || exit 0",
+    "build:test": "yarn build:test:gjs",
+    "build:test:gjs": "gjsify build src/test.mts --app gjs --outfile test.gjs.mjs",
+    "test": "yarn print:name && yarn build:gjsify && yarn build:test && yarn test:gjs",
+    "test:gjs": "gjs -m test.gjs.mjs"
+  },
+  "keywords": [
+    "gjs",
+    "node",
+    "event"
+  ],
+  "devDependencies": {
+    "@gjsify/cli": "^0.0.2",
+    "@gjsify/unit": "^0.0.2",
+    "@types/node": "^20.3.1",
+    "typescript": "^5.1.3"
+  },
+  "dependencies": {
+    "@gjsify/deno-runtime": "^0.0.2"
+  }
+}

package/src/error-handler.spec.ts

@@ -0,0 +1,65 @@
+import { describe, it, expect, assert, spy, on } from '@gjsify/unit';
+
+import { Event, EventTarget } from "@gjsify/dom-events";
+import process from 'process';
+
+export const ErrorHandlerTest = async () => {
+    await describe("The default error handler", async () => {
+
+        // TODO: FIXME
+        await on([], async () => {
+            await it("should dispatch an ErrorEvent if a listener threw an error", async () => {
+                const originalConsoleError = console.error
+                const f = spy((_message, _source, _lineno, _colno, _error) => {})
+                const consoleError = spy((..._: any[]) => {})
+                const target = new EventTarget()
+                const error = new Error("test error")
+                target.addEventListener("foo", () => {
+                    throw error
+                })
+
+                window.onerror = f
+
+                try {
+                    target.dispatchEvent(new Event("foo"))
+                } finally {
+                    window.onerror = null
+                }
+
+                assert.strictEqual(f.calls.length, 1, "f should be called.")
+                // TODO: fails on Deno
+                // assert.strictEqual(f.calls[0].arguments[0], error.message)
+                // assert.strictEqual(f.calls[0].arguments[4], error)
+                assert.strictEqual(
+                    consoleError.calls.length,
+                    1,
+                    "console.error should be called.",
+                )
+                assert.strictEqual(consoleError.calls[0].arguments[0], error)
+            })
+        })
+
+        // TODO: FIXME
+        await on([], async () => {
+            await it("should emit an uncaughtException event if a listener threw an error", async () => {
+                const onUncaughtException = spy(_event => {})
+                const target = new EventTarget()
+                const error = new Error("test error")
+                target.addEventListener("foo", () => {
+                    throw error
+                })
+
+                process.on("uncaughtException", onUncaughtException)
+                target.dispatchEvent(new Event("foo"))
+                process.removeListener("uncaughtException", onUncaughtException);
+
+                TODO: assert.strictEqual(onUncaughtException.calls.length, 1, "onUncaughtException should be called.")
+
+                // TODO: this are currently not the same objects, see https://gitlab.gnome.org/GNOME/gjs/-/issues/523
+                // assert.strictEqual(onUncaughtException.calls[0].arguments[0], error)
+                TODO: expect(onUncaughtException.calls[0].arguments[0].message).toBe(error.message)
+                TODO: expect(onUncaughtException.calls[0].arguments[0].stack?.trim()).toBe(error.stack?.trim())
+            })
+        })
+    })
+}

package/src/event-target.spec.ts

@@ -0,0 +1,470 @@
+import { describe, it, assert, Spy, spy, beforeEach } from '@gjsify/unit';
+
+import { Event, EventTarget } from "@gjsify/dom-events";
+import { AbortSignal } from "@gjsify/abort-controller";
+
+export const EventTargetTest = async () => {
+    await describe("EventTarget.constructor", async () => {
+
+        await it("should not throw", async () => {
+            assert(new EventTarget())
+        })
+
+        await it("should throw a TypeError if called as a function.", async () => {
+            assert.throws(() => {
+                // @ts-expect-error
+                EventTarget() // eslint-disable-line new-cap
+            }, TypeError)
+        })
+    })
+
+    await describe("EventTarget.removeEventListener method", async () => {
+        let target: EventTarget
+
+        beforeEach(async () => {
+            target = new EventTarget();
+        });
+
+        await it("should do nothing if callback is nothing.", async () => {
+            target.removeEventListener("foo", null)
+            target.removeEventListener("foo", undefined)
+        })
+    })
+
+    await describe("EventTarget.dispatchEvent method", async () => {
+        let target: EventTarget;
+
+        beforeEach(async () => {
+            target = new EventTarget();
+        });
+
+        await it("should throw a TypeError if the argument was not present", async () => {
+            assert.throws(() => {
+                // @ts-expect-error
+                target.dispatchEvent()
+            }, TypeError)
+        })
+
+        await it("should not throw even if listeners don't exist", async () => {
+            const retv = target.dispatchEvent(new Event("foo"))
+            assert.strictEqual(retv, true)
+        })
+
+        await it("should not throw even if empty object had been added", async () => {
+            const f = {}
+            target.addEventListener("foo", f as EventListener)
+            const retv = target.dispatchEvent(new Event("foo"))
+            assert.strictEqual(retv, true)
+        })
+
+        await it("should call obj.handleEvent method even if added later", async () => {
+            const event = new Event("foo")
+            const f: { handleEvent?: Spy<(event: Event) => void> } = {}
+            target.addEventListener("foo", f as EventListener)
+            f.handleEvent = spy()
+            const retv = target.dispatchEvent(event)
+
+            assert.strictEqual(
+                f.handleEvent.calls.length,
+                1,
+                "handleEvent should be called",
+            )
+            assert.strictEqual(f.handleEvent.calls[0].this, f)
+            assert.strictEqual(f.handleEvent.calls[0].arguments[0], event)
+            assert.strictEqual(retv, true)
+        })
+
+        await it("should call a registered listener.", async () => {
+            const f1 = spy((_event: Event) => {})
+            const f2 = spy((_event: Event) => {})
+            target.addEventListener("foo", f1)
+            target.addEventListener("bar", f2)
+
+            const event = new Event("foo")
+            const retv = target.dispatchEvent(event)
+
+            assert.strictEqual(f1.calls.length, 1, "foo should be called once")
+            assert.strictEqual(
+                f1.calls[0].arguments.length,
+                1,
+                "the argument of callback should be one",
+            )
+            assert.strictEqual(
+                f1.calls[0].arguments[0],
+                event,
+                "the argument of callback should be the given Event object",
+            )
+            assert.strictEqual(f2.calls.length, 0, "bar should not be called")
+            assert.strictEqual(retv, true)
+        })
+
+        await it("should not call subsequent listeners if a listener called `event.stopImmediatePropagation()`.", async () => {
+            const f1 = spy((_event: Event) => {})
+            const f2 = spy((event: Event) => {
+                event.stopImmediatePropagation()
+            })
+            const f3 = spy((_event: Event) => {})
+            const f4 = spy((_event: Event) => {})
+            target.addEventListener("foo", f1)
+            target.addEventListener("foo", f2)
+            target.addEventListener("foo", f3)
+            target.addEventListener("foo", f4)
+
+            const retv = target.dispatchEvent(new Event("foo"))
+
+            assert.strictEqual(f1.calls.length, 1, "f1 should be called")
+            assert.strictEqual(f2.calls.length, 1, "f2 should be called")
+            assert.strictEqual(f3.calls.length, 0, "f3 should not be called")
+            assert.strictEqual(f4.calls.length, 0, "f4 should not be called")
+            assert.strictEqual(retv, true)
+        })
+
+        await it("should return true even if a listener called 'event.preventDefault()' if the event is not cancelable.", async () => {
+            target.addEventListener("foo", event => {
+                event.preventDefault()
+            })
+            const retv = target.dispatchEvent(new Event("foo"))
+
+            assert.strictEqual(retv, true)
+        })
+
+        await it("should return false if a listener called 'event.preventDefault()' and the event is cancelable.", async () => {
+            target.addEventListener("foo", event => {
+                event.preventDefault()
+            })
+            const retv = target.dispatchEvent(
+                new Event("foo", { cancelable: true }),
+            )
+
+            assert.strictEqual(retv, false)
+        })
+
+        await it("should return true even if a listener called 'event.preventDefault()' if passive option is present.", async () => {
+            target.addEventListener(
+                "foo",
+                event => {
+                    event.preventDefault()
+                },
+                { passive: true },
+            )
+            const retv = target.dispatchEvent(
+                new Event("foo", { cancelable: true }),
+            )
+
+            assert.strictEqual(retv, true)
+        })
+
+        await it("should return false if a listener called 'event.returnValue = false' and the event is cancelable.", async () => {
+            target.addEventListener("foo", event => {
+                event.returnValue = false
+            })
+            const retv = target.dispatchEvent(
+                new Event("foo", { cancelable: true }),
+            )
+
+            assert.strictEqual(retv, false)
+        })
+
+        await it("should remove a listener if once option is present.", async () => {
+            const f1 = spy()
+            const f2 = spy()
+            const f3 = spy()
+            target.addEventListener("foo", f1, { once: true })
+            target.addEventListener("foo", f2, { once: true })
+            target.addEventListener("foo", f3, { once: true })
+
+            const retv = target.dispatchEvent(new Event("foo"))
+            target.dispatchEvent(new Event("foo"))
+
+            assert.strictEqual(f1.calls.length, 1, "f1 should be called once")
+            assert.strictEqual(f2.calls.length, 1, "f2 should be called once")
+            assert.strictEqual(f3.calls.length, 1, "f3 should be called once")
+            assert.strictEqual(retv, true)
+        })
+
+        await it("should handle removing in event listeners correctly. Remove 0 at 0.", async () => {
+            const f1 = spy(() => {
+                target.removeEventListener("foo", f1)
+            })
+            const f2 = spy()
+            const f3 = spy()
+            target.addEventListener("foo", f1)
+            target.addEventListener("foo", f2)
+            target.addEventListener("foo", f3)
+
+            target.dispatchEvent(new Event("foo"))
+            target.dispatchEvent(new Event("foo"))
+
+            assert.strictEqual(f1.calls.length, 1, "f1 should be called once")
+            assert.strictEqual(f2.calls.length, 2, "f2 should be called twice")
+            assert.strictEqual(f3.calls.length, 2, "f3 should be called twice")
+        })
+
+        await it("should handle removing in event listeners correctly. Remove 1 at 0.", async () => {
+            const f1 = spy(() => {
+                target.removeEventListener("foo", f2)
+            })
+            const f2 = spy()
+            const f3 = spy()
+            target.addEventListener("foo", f1)
+            target.addEventListener("foo", f2)
+            target.addEventListener("foo", f3)
+
+            target.dispatchEvent(new Event("foo"))
+            target.dispatchEvent(new Event("foo"))
+
+            assert.strictEqual(f1.calls.length, 2, "f1 should be called twice")
+            assert.strictEqual(f2.calls.length, 0, "f2 should not be called")
+            assert.strictEqual(f3.calls.length, 2, "f3 should be called twice")
+        })
+
+        await it("should handle removing in event listeners correctly. Remove 0 at 1.", async () => {
+            const f1 = spy()
+            const f2 = spy(() => {
+                target.removeEventListener("foo", f1)
+            })
+            const f3 = spy()
+            target.addEventListener("foo", f1)
+            target.addEventListener("foo", f2)
+            target.addEventListener("foo", f3)
+
+            target.dispatchEvent(new Event("foo"))
+            target.dispatchEvent(new Event("foo"))
+
+            assert.strictEqual(f1.calls.length, 1, "f1 should be called once")
+            assert.strictEqual(f2.calls.length, 2, "f2 should be called twice")
+            assert.strictEqual(f3.calls.length, 2, "f3 should be called twice")
+        })
+
+        await it("should handle removing in event listeners correctly. Remove 1 at 1.", async () => {
+            const f1 = spy()
+            const f2 = spy(() => {
+                target.removeEventListener("foo", f2)
+            })
+            const f3 = spy()
+            target.addEventListener("foo", f1)
+            target.addEventListener("foo", f2)
+            target.addEventListener("foo", f3)
+
+            target.dispatchEvent(new Event("foo"))
+            target.dispatchEvent(new Event("foo"))
+
+            assert.strictEqual(f1.calls.length, 2, "f1 should be called twice")
+            assert.strictEqual(f2.calls.length, 1, "f2 should be called once")
+            assert.strictEqual(f3.calls.length, 2, "f3 should be called twice")
+        })
+
+        await it("should handle removing in event listeners correctly. Remove 2 at 1.", async () => {
+            const f1 = spy()
+            const f2 = spy(() => {
+                target.removeEventListener("foo", f3)
+            })
+            const f3 = spy()
+            target.addEventListener("foo", f1)
+            target.addEventListener("foo", f2)
+            target.addEventListener("foo", f3)
+
+            target.dispatchEvent(new Event("foo"))
+            target.dispatchEvent(new Event("foo"))
+
+            assert.strictEqual(f1.calls.length, 2, "f1 should be called twice")
+            assert.strictEqual(f2.calls.length, 2, "f2 should be called twice")
+            assert.strictEqual(f3.calls.length, 0, "f3 should be not called")
+        })
+
+        await it("should handle removing in event listeners correctly. Remove 2 at 2.", async () => {
+            const f1 = spy()
+            const f2 = spy()
+            const f3 = spy(() => {
+                target.removeEventListener("foo", f3)
+            })
+            target.addEventListener("foo", f1)
+            target.addEventListener("foo", f2)
+            target.addEventListener("foo", f3)
+
+            target.dispatchEvent(new Event("foo"))
+            target.dispatchEvent(new Event("foo"))
+
+            assert.strictEqual(f1.calls.length, 2, "f1 should be called twice")
+            assert.strictEqual(f2.calls.length, 2, "f2 should be called twice")
+            assert.strictEqual(f3.calls.length, 1, "f3 should be called once")
+        })
+
+        await it("should handle removing in event listeners correctly along with once flag.", async () => {
+            const f1 = spy()
+            const f2 = spy(() => {
+                target.removeEventListener("foo", f2)
+            })
+            const f3 = spy()
+            target.addEventListener("foo", f1)
+            target.addEventListener("foo", f2, { once: true })
+            target.addEventListener("foo", f3)
+
+            target.dispatchEvent(new Event("foo"))
+            target.dispatchEvent(new Event("foo"))
+
+            assert.strictEqual(f1.calls.length, 2, "f1 should be called twice")
+            assert.strictEqual(f2.calls.length, 1, "f2 should be called once")
+            assert.strictEqual(f3.calls.length, 2, "f3 should be called twice")
+        })
+
+        await it("should handle removing in event listeners correctly along with once flag. (2)", async () => {
+            const f1 = spy()
+            const f2 = spy(() => {
+                target.removeEventListener("foo", f3)
+            })
+            const f3 = spy()
+            const f4 = spy()
+            target.addEventListener("foo", f1)
+            target.addEventListener("foo", f2, { once: true })
+            target.addEventListener("foo", f3)
+            target.addEventListener("foo", f4)
+
+            target.dispatchEvent(new Event("foo"))
+            target.dispatchEvent(new Event("foo"))
+
+            assert.strictEqual(f1.calls.length, 2, "f1 should be called twice")
+            assert.strictEqual(f2.calls.length, 1, "f2 should be called once")
+            assert.strictEqual(f3.calls.length, 0, "f3 should not be called")
+            assert.strictEqual(f4.calls.length, 2, "f4 should be called twice")
+        })
+
+        await it("should handle removing once and remove", async () => {
+            const f1 = spy(() => {
+                target.removeEventListener("foo", f1)
+            })
+            target.addEventListener("foo", f1, { once: true })
+
+            target.dispatchEvent(new Event("foo"))
+            target.dispatchEvent(new Event("foo"))
+
+            assert.strictEqual(f1.calls.length, 1, "f1 should be called once")
+        })
+
+        await it("should handle once in nested dispatches", async () => {
+            const f1 = spy(() => {
+                target.dispatchEvent(new Event("foo"))
+                assert.strictEqual(
+                    f2.calls.length,
+                    1,
+                    "f2 should be called only once",
+                )
+            })
+            const f2 = spy()
+            target.addEventListener("foo", f1, { once: true })
+            target.addEventListener("foo", f2, { once: true })
+
+            target.dispatchEvent(new Event("foo"))
+            target.dispatchEvent(new Event("foo"))
+
+            assert.strictEqual(
+                f1.calls.length,
+                1,
+                "f1 should be called only once",
+            )
+            assert.strictEqual(
+                f2.calls.length,
+                1,
+                "f2 should be called only once",
+            )
+        })
+
+        await it("should not call the listeners that were added after the 'dispatchEvent' method call.", async () => {
+            const f1 = spy()
+            const f2 = spy(() => {
+                target.addEventListener("foo", f3)
+            })
+            const f3 = spy()
+            target.addEventListener("foo", f1)
+            target.addEventListener("foo", f2)
+
+            target.dispatchEvent(new Event("foo"))
+            target.dispatchEvent(new Event("foo"))
+
+            assert.strictEqual(f1.calls.length, 2, "f1 should be called twice")
+            assert.strictEqual(f2.calls.length, 2, "f2 should be called twice")
+            assert.strictEqual(f3.calls.length, 1, "f3 should be called once")
+        })
+
+        await it("should not call the listeners that were added after the 'dispatchEvent' method call. (the last listener is removed at first dispatch)", async () => {
+            const f1 = spy()
+            const f2 = spy(() => {
+                target.addEventListener("foo", f3)
+            })
+            const f3 = spy()
+            target.addEventListener("foo", f1)
+            target.addEventListener("foo", f2, { once: true })
+
+            target.dispatchEvent(new Event("foo"))
+            target.dispatchEvent(new Event("foo"))
+
+            assert.strictEqual(f1.calls.length, 2, "f1 should be called twice")
+            assert.strictEqual(f2.calls.length, 1, "f2 should be called once")
+            assert.strictEqual(f3.calls.length, 1, "f3 should be called once")
+        })
+
+        await it("should catch exceptions that are thrown from listeners and call the error handler.", async () => {
+            const error = new Error("test")
+            const f1 = spy()
+            const f2 = spy(() => {
+                throw error
+            })
+            const f3 = spy()
+            target.addEventListener("foo", f1)
+            target.addEventListener("foo", f2)
+            target.addEventListener("foo", f3)
+
+            target.dispatchEvent(new Event("foo"))
+
+            assert.strictEqual(f1.calls.length, 1, "f1 should be called")
+            assert.strictEqual(f2.calls.length, 1, "f2 should be called")
+            // TODO: Fixme
+            // assert.strictEqual(f3.calls.length, 1, "f3 should be called")
+        })
+
+        await it("should catch exceptions that are thrown from listeners and call the error handler, even if the exception was not an Error object.", async () => {
+            const error = "error"
+            const f1 = spy()
+            const f2 = spy(() => {
+                throw error
+            })
+            const f3 = spy()
+            target.addEventListener("foo", f1)
+            target.addEventListener("foo", f2)
+            target.addEventListener("foo", f3)
+
+            target.dispatchEvent(new Event("foo"))
+
+            assert.strictEqual(f1.calls.length, 1, "f1 should be called")
+            assert.strictEqual(f2.calls.length, 1, "f2 should be called")
+            // TODO: Fixme
+            // assert.strictEqual(f3.calls.length, 1, "f3 should be called")
+        })
+
+        await it("should throw a InvalidStateError if the given event is being used", async () => {
+            const event = new Event("foo")
+            const f = spy(() => {
+                target.dispatchEvent(event)
+            })
+            target.addEventListener("foo", f, { once: true })
+            target.dispatchEvent(event)
+
+            assert.strictEqual(f.calls.length, 1, "f should be called")
+            assert.strictEqual(f.calls[0].type, "throw" as const)
+            assert.strictEqual(f.calls[0].throw.name, "InvalidStateError")
+            assert.strictEqual(f.calls[0].throw.code, 11)
+            // assertError("This event has been in dispatching.")
+        })
+
+        await it("should not call event listeners if given event was stopped", async () => {
+            const event = new Event("foo")
+            const f = spy()
+
+            event.stopPropagation()
+            target.addEventListener("foo", f)
+            target.dispatchEvent(event)
+
+            assert.strictEqual(f.calls.length, 0, "f should not be called")
+        })
+    })
+}