@ccheever/exact-ibex-runtime 0.1.0

package/src/events/EventTarget.ts

@@ -0,0 +1,280 @@
+// @ts-nocheck
+/**
+ * EventTarget - Web Standard EventTarget Implementation
+ *
+ * @see https://dom.spec.whatwg.org/#interface-eventtarget
+ */
+
+import { Event } from "./Event";
+
+export type EventListener = (event: Event) => void;
+
+export interface EventListenerObject {
+  handleEvent(event: Event): void;
+}
+
+export type EventListenerOrEventListenerObject =
+  | EventListener
+  | EventListenerObject;
+
+export interface AddEventListenerOptions {
+  capture?: boolean;
+  once?: boolean;
+  passive?: boolean;
+  signal?: any; // AbortSignal - use 'any' to avoid circular dependency
+}
+
+export interface EventListenerOptions {
+  capture?: boolean;
+}
+
+interface ListenerEntry {
+  callback: EventListenerOrEventListenerObject;
+  capture: boolean;
+  once: boolean;
+  passive: boolean;
+  removed: boolean;
+  signal?: any; // AbortSignal - use 'any' to avoid circular dependency
+}
+
+export class EventTarget {
+  private _listeners: Map<string, ListenerEntry[]> = new Map();
+  private compactListeners(type: string): void {
+    const listeners = this._listeners.get(type);
+    if (!listeners) {
+      return;
+    }
+
+    const activeListeners = listeners.filter((l) => !l.removed);
+    if (activeListeners.length === 0) {
+      this._listeners.delete(type);
+    } else if (activeListeners.length !== listeners.length) {
+      this._listeners.set(type, activeListeners);
+    }
+  }
+
+  addEventListener(
+    type: string,
+    callback: EventListenerOrEventListenerObject | null,
+    options?: AddEventListenerOptions | boolean
+  ): void {
+    if (callback === null) {
+      return;
+    }
+
+    const capture =
+      typeof options === "boolean" ? options : options?.capture ?? false;
+    const once = typeof options === "object" ? options?.once ?? false : false;
+    const passive =
+      typeof options === "object" ? options?.passive ?? false : false;
+    const signal =
+      typeof options === "object" ? options?.signal : undefined;
+
+    // If signal is already aborted, don't add
+    if (signal?.aborted) {
+      return;
+    }
+
+    let listeners = this._listeners.get(type);
+    if (!listeners) {
+      listeners = [];
+      this._listeners.set(type, listeners);
+    }
+
+    // Check if already exists (same callback and capture)
+    const exists = listeners.some(
+      (l) =>
+        l.callback === callback && l.capture === capture && !l.removed
+    );
+    if (exists) {
+      return;
+    }
+
+    const entry: ListenerEntry = {
+      callback,
+      capture,
+      once,
+      passive,
+      removed: false,
+      signal,
+    };
+
+    listeners.push(entry);
+
+    // Handle abort signal
+    if (signal) {
+      const removeOnAbort = () => {
+        entry.removed = true;
+        this.compactListeners(type);
+      };
+      signal.addEventListener("abort", removeOnAbort, { once: true });
+    }
+  }
+
+  removeEventListener(
+    type: string,
+    callback: EventListenerOrEventListenerObject | null,
+    options?: EventListenerOptions | boolean
+  ): void {
+    if (callback === null) {
+      return;
+    }
+
+    const capture =
+      typeof options === "boolean" ? options : options?.capture ?? false;
+
+    const listeners = this._listeners.get(type);
+    if (!listeners) {
+      return;
+    }
+
+    const index = listeners.findIndex(
+      (l) => l.callback === callback && l.capture === capture && !l.removed
+    );
+
+    if (index !== -1) {
+      listeners[index].removed = true;
+      this.compactListeners(type);
+    }
+  }
+
+  dispatchEvent(event: Event | string | { type: string; [key: string]: unknown }): boolean {
+    const dispatchEvent = this.normalizeDispatchEventArgument(event);
+
+    // Set target
+    (dispatchEvent as any)._setTarget(this);
+    (dispatchEvent as any)._setCurrentTarget(this);
+    (dispatchEvent as any)._setEventPhase(Event.AT_TARGET);
+
+    const listeners = this._listeners.get(dispatchEvent.type);
+    if (listeners) {
+      // Create a copy to iterate (listeners may be modified during iteration)
+      const listenersCopy = [...listeners];
+
+      for (const entry of listenersCopy) {
+        if (entry.removed) {
+          continue;
+        }
+
+        if ((dispatchEvent as any)._isImmediatePropagationStopped()) {
+          break;
+        }
+
+        // Mark for removal if once
+        if (entry.once) {
+          entry.removed = true;
+        }
+
+        // Set passive flag before calling listener
+        (dispatchEvent as any)._setInPassiveListener(entry.passive);
+
+        try {
+          if (typeof entry.callback === "function") {
+            entry.callback.call(this, dispatchEvent);
+          } else {
+            entry.callback.handleEvent(dispatchEvent);
+          }
+        } catch (error) {
+          // Report error but continue with other listeners
+          console.error("Error in event listener:", error);
+        } finally {
+          // Reset passive flag after listener
+          (dispatchEvent as any)._setInPassiveListener(false);
+        }
+      }
+
+      this.compactListeners(dispatchEvent.type);
+    }
+
+    // Reset event state for potential re-dispatch
+    (dispatchEvent as any)._setCurrentTarget(null);
+    (dispatchEvent as any)._setEventPhase(Event.NONE);
+    
+    const result = !dispatchEvent.defaultPrevented;
+    
+    // Reset flags after dispatch so event can be re-dispatched
+    (dispatchEvent as any)._resetFlags();
+
+    return result;
+  }
+
+  private normalizeDispatchEventArgument(
+    event: Event | string | { type: string; [key: string]: unknown }
+  ): Event {
+    if (!event) {
+      throw new TypeError(
+        "Failed to execute 'dispatchEvent' on 'EventTarget': parameter 1 is not of type 'Event'."
+      );
+    }
+
+    if (typeof event === "string") {
+      event = new Event(event) as unknown as Event;
+    }
+
+    if (
+      typeof (event as any)._setTarget === "function" &&
+      typeof (event as any)._setCurrentTarget === "function" &&
+      typeof (event as any)._setEventPhase === "function" &&
+      typeof (event as any)._resetFlags === "function"
+    ) {
+      return event;
+    }
+
+    if (typeof (event as any).type !== "string") {
+      throw new TypeError(
+        "Failed to execute 'dispatchEvent' on 'EventTarget': parameter 1 is not of type 'Event'."
+      );
+    }
+
+    const source = event as Event & {
+      bubbles?: boolean;
+      cancelable?: boolean;
+      composed?: boolean;
+    };
+    const wrapped = new Event(source.type, {
+      bubbles: source.bubbles ?? false,
+      cancelable: source.cancelable ?? false,
+      composed: source.composed ?? false,
+    }) as Event;
+
+    for (const key of Object.keys(source as Record<string, unknown>)) {
+      if (
+        key === "type" ||
+        key === "bubbles" ||
+        key === "cancelable" ||
+        key === "composed" ||
+        key === "defaultPrevented" ||
+        key === "isTrusted" ||
+        key === "timeStamp" ||
+        key === "target" ||
+        key === "currentTarget" ||
+        key === "eventPhase" ||
+        key === "detail"
+      ) {
+        continue;
+      }
+
+      const wrappedDescriptor =
+        Object.getOwnPropertyDescriptor(wrapped, key) ||
+        Object.getOwnPropertyDescriptor(Object.getPrototypeOf(wrapped), key);
+      if (
+        wrappedDescriptor &&
+        ((wrappedDescriptor.writable === false && wrappedDescriptor.set === undefined) ||
+          wrappedDescriptor.get !== undefined)
+      ) {
+        continue;
+      }
+      (wrapped as any)[key] = (source as Record<string, unknown>)[key];
+    }
+
+    return wrapped;
+  }
+
+  /**
+   * Helper to check if there are any listeners for a type
+   */
+  protected hasListeners(type: string): boolean {
+    const listeners = this._listeners.get(type);
+    return listeners ? listeners.some((l) => !l.removed) : false;
+  }
+}

package/src/events/FocusEvent.ts

@@ -0,0 +1,27 @@
+/**
+ * FocusEvent - Minimal DOM-compatible focus event implementation.
+ *
+ * The DOM shim uses this for focus/blur/focusin/focusout payload wrapping so
+ * handlers can read `relatedTarget` without special Exact-specific branching.
+ */
+
+import { Event, type EventInit } from './Event';
+
+export interface FocusEventInit extends EventInit {
+  relatedTarget?: EventTarget | null;
+}
+
+export class FocusEvent extends Event {
+  readonly relatedTarget: EventTarget | null;
+
+  constructor(type: string, eventInitDict?: FocusEventInit) {
+    super(type, eventInitDict);
+    this.relatedTarget = eventInitDict?.relatedTarget ?? null;
+  }
+
+  get [Symbol.toStringTag](): string {
+    return 'FocusEvent';
+  }
+}
+
+export default FocusEvent;

package/src/events/KeyboardEvent.ts

@@ -0,0 +1,46 @@
+/**
+ * KeyboardEvent - Minimal DOM-compatible keyboard event implementation.
+ *
+ * The DOM shim only needs the standard readonly keyboard fields that framework
+ * event handlers commonly read (`key`, `code`, and modifier flags). The base
+ * Event implementation already handles cancelation and dispatch bookkeeping.
+ */
+
+import { Event, type EventInit } from './Event';
+
+export interface KeyboardEventInit extends EventInit {
+  key?: string;
+  code?: string;
+  altKey?: boolean;
+  ctrlKey?: boolean;
+  metaKey?: boolean;
+  shiftKey?: boolean;
+  repeat?: boolean;
+}
+
+export class KeyboardEvent extends Event {
+  readonly key: string;
+  readonly code: string;
+  readonly altKey: boolean;
+  readonly ctrlKey: boolean;
+  readonly metaKey: boolean;
+  readonly shiftKey: boolean;
+  readonly repeat: boolean;
+
+  constructor(type: string, eventInitDict?: KeyboardEventInit) {
+    super(type, eventInitDict);
+    this.key = eventInitDict?.key ?? '';
+    this.code = eventInitDict?.code ?? '';
+    this.altKey = eventInitDict?.altKey === true;
+    this.ctrlKey = eventInitDict?.ctrlKey === true;
+    this.metaKey = eventInitDict?.metaKey === true;
+    this.shiftKey = eventInitDict?.shiftKey === true;
+    this.repeat = eventInitDict?.repeat === true;
+  }
+
+  get [Symbol.toStringTag](): string {
+    return 'KeyboardEvent';
+  }
+}
+
+export default KeyboardEvent;

package/src/events/MessageEvent.ts

@@ -0,0 +1,61 @@
+/**
+ * MessageEvent - Event for messaging APIs
+ * 
+ * Used by WebSocket, MessagePort, BroadcastChannel, and postMessage.
+ * @see https://html.spec.whatwg.org/multipage/comms.html#messageevent
+ */
+
+import { Event, EventInit } from './Event';
+
+export interface MessageEventInit<T = any> extends EventInit {
+  data?: T;
+  origin?: string;
+  lastEventId?: string;
+  source?: MessageEventSource | null;
+  ports?: MessagePort[];
+}
+
+// MessageEventSource can be WindowProxy, MessagePort, or ServiceWorker
+// In our runtime, we only support MessagePort
+export type MessageEventSource = MessagePort | null;
+
+export class MessageEvent<T = any> extends Event {
+  readonly data: T;
+  readonly origin: string;
+  readonly lastEventId: string;
+  readonly source: MessageEventSource;
+  readonly ports: ReadonlyArray<MessagePort>;
+
+  constructor(type: string, eventInitDict?: MessageEventInit<T>) {
+    super(type, eventInitDict);
+    this.data = eventInitDict?.data as T;
+    this.origin = eventInitDict?.origin ?? '';
+    this.lastEventId = eventInitDict?.lastEventId ?? '';
+    this.source = eventInitDict?.source ?? null;
+    this.ports = Object.freeze(eventInitDict?.ports ? [...eventInitDict.ports] : []);
+  }
+
+  /**
+   * Legacy method for initializing a MessageEvent.
+   * @deprecated Use the constructor instead.
+   */
+  initMessageEvent(
+    type: string,
+    bubbles?: boolean,
+    cancelable?: boolean,
+    data?: T,
+    origin?: string,
+    lastEventId?: string,
+    source?: MessageEventSource,
+    ports?: MessagePort[]
+  ): void {
+    // This is a no-op in modern implementations since events are immutable
+    // Included for compatibility only
+  }
+
+  get [Symbol.toStringTag](): string {
+    return 'MessageEvent';
+  }
+}
+
+export default MessageEvent;

package/src/events/ProgressEvent.ts

@@ -0,0 +1,33 @@
+/**
+ * ProgressEvent - Event for tracking progress of operations
+ * 
+ * Used by XMLHttpRequest, FileReader, and fetch progress tracking.
+ * @see https://xhr.spec.whatwg.org/#interface-progressevent
+ */
+
+import { Event, EventInit } from './Event';
+
+export interface ProgressEventInit extends EventInit {
+  lengthComputable?: boolean;
+  loaded?: number;
+  total?: number;
+}
+
+export class ProgressEvent extends Event {
+  readonly lengthComputable: boolean;
+  readonly loaded: number;
+  readonly total: number;
+
+  constructor(type: string, eventInitDict?: ProgressEventInit) {
+    super(type, eventInitDict);
+    this.lengthComputable = eventInitDict?.lengthComputable ?? false;
+    this.loaded = eventInitDict?.loaded ?? 0;
+    this.total = eventInitDict?.total ?? 0;
+  }
+
+  get [Symbol.toStringTag](): string {
+    return 'ProgressEvent';
+  }
+}
+
+export default ProgressEvent;

package/src/events/PromiseRejectionEvent.ts

@@ -0,0 +1,31 @@
+/**
+ * PromiseRejectionEvent - Event for unhandled promise rejections
+ *
+ * Fired when a Promise is rejected and no rejection handler is attached,
+ * or when a previously unhandled rejection becomes handled.
+ * @see https://html.spec.whatwg.org/multipage/webappapis.html#promiserejectionevent
+ */
+
+import { Event, EventInit } from './Event';
+
+export interface PromiseRejectionEventInit extends EventInit {
+  promise: Promise<any>;
+  reason?: any;
+}
+
+export class PromiseRejectionEvent extends Event {
+  readonly promise: Promise<any>;
+  readonly reason: any;
+
+  constructor(type: string, eventInitDict: PromiseRejectionEventInit) {
+    super(type, eventInitDict);
+    this.promise = eventInitDict.promise;
+    this.reason = 'reason' in eventInitDict ? eventInitDict.reason : undefined;
+  }
+
+  get [Symbol.toStringTag](): string {
+    return 'PromiseRejectionEvent';
+  }
+}
+
+export default PromiseRejectionEvent;

package/src/events/index.ts

@@ -0,0 +1,52 @@
+// @ts-nocheck
+/**
+ * Events module - EventTarget, Event, CustomEvent, DOMException, and specialized events
+ */
+
+export { Event, CustomEvent } from "./Event";
+export type { EventInit, CustomEventInit } from "./Event";
+
+export { EventTarget } from "./EventTarget";
+export type {
+  EventListener,
+  EventListenerObject,
+  EventListenerOrEventListenerObject,
+  AddEventListenerOptions,
+  EventListenerOptions,
+} from "./EventTarget";
+
+export {
+  DOMException,
+  createAbortError,
+  createNetworkError,
+  createTimeoutError,
+  createQuotaExceededError,
+  createDataCloneError,
+  createInvalidStateError,
+  createNotSupportedError,
+  createSyntaxError,
+  createSecurityError,
+  createOperationError,
+} from "./DOMException";
+
+// Specialized event types
+export { MessageEvent } from "./MessageEvent";
+export type { MessageEventInit, MessageEventSource } from "./MessageEvent";
+
+export { CloseEvent } from "./CloseEvent";
+export type { CloseEventInit } from "./CloseEvent";
+
+export { ErrorEvent } from "./ErrorEvent";
+export type { ErrorEventInit } from "./ErrorEvent";
+
+export { ProgressEvent } from "./ProgressEvent";
+export type { ProgressEventInit } from "./ProgressEvent";
+
+export { KeyboardEvent } from "./KeyboardEvent";
+export type { KeyboardEventInit } from "./KeyboardEvent";
+
+export { FocusEvent } from "./FocusEvent";
+export type { FocusEventInit } from "./FocusEvent";
+
+export { PromiseRejectionEvent } from "./PromiseRejectionEvent";
+export type { PromiseRejectionEventInit } from "./PromiseRejectionEvent";