3 files changed, 76 insertions, 41 deletions

diff --git a/packages/idb-bridge/src/util/FakeEvent.ts b/packages/idb-bridge/src/util/FakeEvent.ts
index 4457498f6..207607886 100644
--- a/packages/idb-bridge/src/util/FakeEvent.ts
+++ b/packages/idb-bridge/src/util/FakeEvent.ts
@@ -16,8 +16,9 @@
 
 import FakeEventTarget from "./FakeEventTarget";
 import { EventType } from "./types";
+import { Event, EventTarget } from "../idbtypes";
 
-export class Event {
+export class FakeEvent implements Event {
   public eventPath: FakeEventTarget[] = [];
   public type: EventType;
 
@@ -57,6 +58,18 @@ export class Event {
     this.cancelable =
       eventInitDict.cancelable !== undefined ? eventInitDict.cancelable : false;
   }
+  cancelBubble: boolean = false;
+  composed: boolean = false;
+  returnValue: boolean = false;
+  get srcElement(): EventTarget | null {
+    return this.target;
+  }
+  composedPath(): EventTarget[] {
+    throw new Error("Method not implemented.");
+  }
+  initEvent(type: string, bubbles?: boolean | undefined, cancelable?: boolean | undefined): void {
+    throw new Error("Method not implemented.");
+  }
 
   public preventDefault() {
     if (this.cancelable) {
@@ -74,4 +87,4 @@ export class Event {
   }
 }
 
-export default Event;
+export default FakeEvent;
diff --git a/packages/idb-bridge/src/util/FakeEventTarget.ts b/packages/idb-bridge/src/util/FakeEventTarget.ts
index 291eaca7d..da5a5466a 100644
--- a/packages/idb-bridge/src/util/FakeEventTarget.ts
+++ b/packages/idb-bridge/src/util/FakeEventTarget.ts
@@ -16,7 +16,8 @@
 
 import { InvalidStateError } from "./errors";
 import FakeEvent from "./FakeEvent";
-import { EventCallback, EventType } from "./types";
+import { EventType } from "./types";
+import { EventTarget, Event, EventListenerOrEventListenerObject, EventListener } from "../idbtypes";
 
 type EventTypeProp =
   | "onabort"
@@ -27,8 +28,9 @@ type EventTypeProp =
   | "onupgradeneeded"
   | "onversionchange";
 
-interface Listener {
-  callback: EventCallback;
+/** @public */
+export interface Listener {
+  callback: EventListenerOrEventListenerObject;
   capture: boolean;
   type: EventType;
 }
@@ -86,35 +88,44 @@ const invokeEventListeners = (event: FakeEvent, obj: FakeEventTarget) => {
   }
 };
 
-abstract class FakeEventTarget {
+/** @public */
+abstract class FakeEventTarget implements EventTarget {
   public readonly listeners: Listener[] = [];
 
   // These will be overridden in individual subclasses and made not readonly
-  public readonly onabort: EventCallback | null | undefined;
-  public readonly onblocked: EventCallback | null | undefined;
-  public readonly oncomplete: EventCallback | null | undefined;
-  public readonly onerror: EventCallback | null | undefined;
-  public readonly onsuccess: EventCallback | null | undefined;
-  public readonly onupgradeneeded: EventCallback | null | undefined;
-  public readonly onversionchange: EventCallback | null | undefined;
+  public readonly onabort: EventListener | null | undefined;
+  public readonly onblocked: EventListener | null | undefined;
+  public readonly oncomplete: EventListener | null | undefined;
+  public readonly onerror: EventListener | null | undefined;
+  public readonly onsuccess: EventListener | null | undefined;
+  public readonly onupgradeneeded: EventListener | null | undefined;
+  public readonly onversionchange: EventListener | null | undefined;
 
   static enableTracing: boolean = false;
 
   public addEventListener(
     type: EventType,
-    callback: EventCallback,
+    listener: EventListenerOrEventListenerObject | null,
     capture = false,
   ) {
-    this.listeners.push({
-      callback,
-      capture,
-      type,
-    });
+    if (typeof listener === "function") {
+      this.listeners.push({
+        callback: listener,
+        capture,
+        type,
+      });
+    } else if (typeof listener === "object" && listener != null) {
+      this.listeners.push({
+        callback: (e: Event) => listener.handleEvent(e),
+        capture,
+        type,
+      });
+    }
   }
 
   public removeEventListener(
     type: EventType,
-    callback: EventCallback,
+    callback: EventListenerOrEventListenerObject,
     capture = false,
   ) {
     const i = this.listeners.findIndex((listener) => {
@@ -129,17 +140,21 @@ abstract class FakeEventTarget {
   }
 
   // http://www.w3.org/TR/dom/#dispatching-events
-  public dispatchEvent(event: FakeEvent) {
+  public dispatchEvent(event: Event): boolean {
+    if (!(event instanceof FakeEvent)) {
+      throw Error("dispatchEvent only works with FakeEvent");
+    }
+    const fe = event as FakeEvent;
     if (event.dispatched || !event.initialized) {
       throw new InvalidStateError("The object is in an invalid state.");
     }
-    event.isTrusted = false;
+    fe.isTrusted = false;
 
-    event.dispatched = true;
-    event.target = this;
+    fe.dispatched = true;
+    fe.target = this;
     // NOT SURE WHEN THIS SHOULD BE SET        event.eventPath = [];
 
-    event.eventPhase = event.CAPTURING_PHASE;
+    fe.eventPhase = event.CAPTURING_PHASE;
     if (FakeEventTarget.enableTracing) {
       console.log(
         `dispatching '${event.type}' event along path with ${event.eventPath.length} elements`,
@@ -151,15 +166,15 @@ abstract class FakeEventTarget {
       }
     }
 
-    event.eventPhase = event.AT_TARGET;
+    fe.eventPhase = event.AT_TARGET;
     if (!event.propagationStopped) {
-      invokeEventListeners(event, event.target);
+      invokeEventListeners(event, fe.target);
     }
 
     if (event.bubbles) {
-      event.eventPath.reverse();
-      event.eventPhase = event.BUBBLING_PHASE;
-      if (event.eventPath.length === 0 && event.type === "error") {
+      fe.eventPath.reverse();
+      fe.eventPhase = event.BUBBLING_PHASE;
+      if (fe.eventPath.length === 0 && event.type === "error") {
         console.error("Unhandled error event: ", event.target);
       }
       for (const obj of event.eventPath) {
@@ -169,9 +184,9 @@ abstract class FakeEventTarget {
       }
     }
 
-    event.dispatched = false;
-    event.eventPhase = event.NONE;
-    event.currentTarget = null;
+    fe.dispatched = false;
+    fe.eventPhase = event.NONE;
+    fe.currentTarget = null;
 
     if (event.canceled) {
       return false;
diff --git a/packages/idb-bridge/src/util/types.ts b/packages/idb-bridge/src/util/types.ts
index b0142b0d8..b07f5ad00 100644
--- a/packages/idb-bridge/src/util/types.ts
+++ b/packages/idb-bridge/src/util/types.ts
@@ -18,16 +18,10 @@
 import { BridgeIDBRequest } from "../BridgeIDBRequest";
 import { BridgeIDBKeyRange } from "../BridgeIDBKeyRange";
 import { BridgeIDBIndex } from "../BridgeIDBIndex";
-import { Event } from "../util/FakeEvent";
 import { BridgeIDBObjectStore } from "../BridgeIDBObjectStore";
+import { Event } from "../idbtypes";
 
-interface EventInCallback extends Event {
-  target: any;
-  error: Error | null;
-}
-
-export type EventCallback = (event: EventInCallback) => void;
-
+/** @public */
 export type EventType =
   | "abort"
   | "blocked"
@@ -37,39 +31,52 @@ export type EventType =
   | "upgradeneeded"
   | "versionchange";
 
+/** @public */
 export type CursorSource = BridgeIDBIndex | BridgeIDBObjectStore;
 
+/** @public */
 export interface FakeDOMStringList extends Array<string> {
   contains: (value: string) => boolean;
   item: (i: number) => string | undefined;
 }
 
+/**
+ * @public
+ */
 export type BridgeIDBCursorDirection =
   | "next"
   | "nextunique"
   | "prev"
   | "prevunique";
 
+/** @public */
 export type KeyPath = string | string[];
 
+/** @public */
 export type Key = any;
 
+/** @public */
 export type CursorRange = Key | BridgeIDBKeyRange | undefined;
 
+/** @public */
 export type Value = any;
 
+/** @public */
 export interface Record {
   key: Key;
   value: Key | Value; // For indexes, will be Key. For object stores, will be Value.
 }
 
+/** @public */
 export type TransactionMode = "readonly" | "readwrite" | "versionchange";
 
+/** @public */
 export interface BridgeIDBDatabaseInfo {
   name: string;
   version: number;
 }
 
+/** @public */
 export interface RequestObj {
   operation: () => Promise<any>;
   request?: BridgeIDBRequest | undefined;