Event System

/**
 * Base class for all objects that can receive events
 */
class EventTarget {
  /** Add event listener */
  addEventListener(type: string, listener: TEventListener, options?: AddEventListenerOptions): void;
  
  /** Remove event listener */
  removeEventListener(type: string, listener: TEventListener, options?: EventListenerOptions): void;
  
  /** Dispatch event */
  dispatchEvent(event: Event): boolean;
}

type TEventListener = (event: Event) => void | { handleEvent(event: Event): void };

interface AddEventListenerOptions extends EventListenerOptions {
  once?: boolean;
  passive?: boolean;
  signal?: AbortSignal;
}

interface EventListenerOptions {
  capture?: boolean;
}

/**
 * Base event class for all DOM events
 */
class Event {
  constructor(type: string, eventInitDict?: IEventInit);
  
  /** Event type */
  readonly type: string;
  
  /** Event target */
  readonly target: EventTarget | null;
  
  /** Current event target */
  readonly currentTarget: EventTarget | null;
  
  /** Composed path */
  readonly composedPath: EventTarget[];
  
  /** Event phase */
  readonly eventPhase: number;
  
  /** Bubbles flag */
  readonly bubbles: boolean;
  
  /** Cancelable flag */
  readonly cancelable: boolean;
  
  /** Composed flag */
  readonly composed: boolean;
  
  /** Default prevented flag */
  readonly defaultPrevented: boolean;
  
  /** Is trusted flag */
  readonly isTrusted: boolean;
  
  /** Time stamp */
  readonly timeStamp: number;
  
  /** Prevent default behavior */
  preventDefault(): void;
  
  /** Stop event propagation */
  stopPropagation(): void;
  
  /** Stop immediate propagation */
  stopImmediatePropagation(): void;
}

interface IEventInit {
  bubbles?: boolean;
  cancelable?: boolean;
  composed?: boolean;
}

/**
 * Event phase constants
 */
enum EventPhaseEnum {
  NONE = 0,
  CAPTURING_PHASE = 1,
  AT_TARGET = 2,
  BUBBLING_PHASE = 3
}

/**
 * Custom events with custom data
 */
class CustomEvent extends Event {
  constructor(type: string, eventInitDict?: ICustomEventInit);
  
  /** Custom event data */
  readonly detail: any;
}

interface ICustomEventInit extends IEventInit {
  detail?: any;
}

/**
 * Base class for user interface events
 */
class UIEvent extends Event {
  constructor(type: string, eventInitDict?: IUIEventInit);
  
  /** Related view */
  readonly view: Window | null;
  
  /** Event detail */
  readonly detail: number;
}

interface IUIEventInit extends IEventInit {
  view?: Window | null;
  detail?: number;
}

/**
 * Mouse interaction events
 */
class MouseEvent extends UIEvent {
  constructor(type: string, eventInitDict?: IMouseEventInit);
  
  /** Screen X coordinate */
  readonly screenX: number;
  
  /** Screen Y coordinate */
  readonly screenY: number;
  
  /** Client X coordinate */
  readonly clientX: number;
  
  /** Client Y coordinate */
  readonly clientY: number;
  
  /** Ctrl key pressed */
  readonly ctrlKey: boolean;
  
  /** Shift key pressed */
  readonly shiftKey: boolean;
  
  /** Alt key pressed */
  readonly altKey: boolean;
  
  /** Meta key pressed */
  readonly metaKey: boolean;
  
  /** Mouse button */
  readonly button: number;
  
  /** Mouse buttons mask */
  readonly buttons: number;
  
  /** Related target */
  readonly relatedTarget: EventTarget | null;
  
  /** Get modifier state */
  getModifierState(key: string): boolean;
}

interface IMouseEventInit extends IUIEventInit {
  screenX?: number;
  screenY?: number;
  clientX?: number;
  clientY?: number;
  ctrlKey?: boolean;
  shiftKey?: boolean;
  altKey?: boolean;
  metaKey?: boolean;
  button?: number;
  buttons?: number;
  relatedTarget?: EventTarget | null;
}

/**
 * Keyboard interaction events
 */
class KeyboardEvent extends UIEvent {
  constructor(type: string, eventInitDict?: IKeyboardEventInit);
  
  /** Key value */
  readonly key: string;
  
  /** Key code */
  readonly code: string;
  
  /** Key location */
  readonly location: number;
  
  /** Ctrl key pressed */
  readonly ctrlKey: boolean;
  
  /** Shift key pressed */
  readonly shiftKey: boolean;
  
  /** Alt key pressed */
  readonly altKey: boolean;
  
  /** Meta key pressed */
  readonly metaKey: boolean;
  
  /** Repeat flag */
  readonly repeat: boolean;
  
  /** Composing flag */
  readonly isComposing: boolean;
  
  /** Get modifier state */
  getModifierState(key: string): boolean;
}

interface IKeyboardEventInit extends IUIEventInit {
  key?: string;
  code?: string;
  location?: number;
  ctrlKey?: boolean;
  shiftKey?: boolean;
  altKey?: boolean;
  metaKey?: boolean;
  repeat?: boolean;
  isComposing?: boolean;
}

/**
 * Mouse wheel events
 */
class WheelEvent extends MouseEvent {
  constructor(type: string, eventInitDict?: IWheelEventInit);
  
  /** Delta X */
  readonly deltaX: number;
  
  /** Delta Y */
  readonly deltaY: number;
  
  /** Delta Z */
  readonly deltaZ: number;
  
  /** Delta mode */
  readonly deltaMode: number;
}

interface IWheelEventInit extends IMouseEventInit {
  deltaX?: number;
  deltaY?: number;
  deltaZ?: number;
  deltaMode?: number;
}

/**
 * Focus and blur events
 */
class FocusEvent extends UIEvent {
  constructor(type: string, eventInitDict?: IFocusEventInit);
  
  /** Related target */
  readonly relatedTarget: EventTarget | null;
}

interface IFocusEventInit extends IUIEventInit {
  relatedTarget?: EventTarget | null;
}

/**
 * Input and text modification events
 */
class InputEvent extends UIEvent {
  constructor(type: string, eventInitDict?: IInputEventInit);
  
  /** Input data */
  readonly data: string | null;
  
  /** Input type */
  readonly inputType: string;
}

interface IInputEventInit extends IUIEventInit {
  data?: string | null;
  inputType?: string;
}

/**
 * Form submission events
 */
class SubmitEvent extends Event {
  constructor(type: string, eventInitDict?: ISubmitEventInit);
  
  /** Form submitter element */
  readonly submitter: HTMLElement | null;
}

interface ISubmitEventInit extends IEventInit {
  submitter?: HTMLElement | null;
}

/**
 * Touch interaction events for mobile devices
 */
class TouchEvent extends UIEvent {
  constructor(type: string, eventInitDict?: ITouchEventInit);
  
  /** Active touches */
  readonly touches: TouchList;
  
  /** Target touches */
  readonly targetTouches: TouchList;
  
  /** Changed touches */
  readonly changedTouches: TouchList;
  
  /** Alt key pressed */
  readonly altKey: boolean;
  
  /** Meta key pressed */
  readonly metaKey: boolean;
  
  /** Ctrl key pressed */
  readonly ctrlKey: boolean;
  
  /** Shift key pressed */
  readonly shiftKey: boolean;
}

interface ITouchEventInit extends IUIEventInit {
  touches?: Touch[];
  targetTouches?: Touch[];
  changedTouches?: Touch[];
  altKey?: boolean;
  metaKey?: boolean;
  ctrlKey?: boolean;
  shiftKey?: boolean;
}

/**
 * Touch point data
 */
class Touch {
  constructor(initDict: ITouchInit);
  
  /** Touch identifier */
  readonly identifier: number;
  
  /** Touch target */
  readonly target: EventTarget;
  
  /** Screen X coordinate */
  readonly screenX: number;
  
  /** Screen Y coordinate */
  readonly screenY: number;
  
  /** Client X coordinate */
  readonly clientX: number;
  
  /** Client Y coordinate */
  readonly clientY: number;
  
  /** Page X coordinate */
  readonly pageX: number;
  
  /** Page Y coordinate */
  readonly pageY: number;
}

interface ITouchInit {
  identifier: number;
  target: EventTarget;
  clientX?: number;
  clientY?: number;
  screenX?: number;
  screenY?: number;
  pageX?: number;
  pageY?: number;
}

/**
 * Pointer device events (mouse, pen, touch)
 */
class PointerEvent extends MouseEvent {
  constructor(type: string, eventInitDict?: IPointerEventInit);
  
  /** Pointer ID */
  readonly pointerId: number;
  
  /** Pointer width */
  readonly width: number;
  
  /** Pointer height */
  readonly height: number;
  
  /** Pressure */
  readonly pressure: number;
  
  /** Tangential pressure */
  readonly tangentialPressure: number;
  
  /** Tilt X */
  readonly tiltX: number;
  
  /** Tilt Y */
  readonly tiltY: number;
  
  /** Twist */
  readonly twist: number;
  
  /** Pointer type */
  readonly pointerType: string;
  
  /** Is primary */
  readonly isPrimary: boolean;
}

interface IPointerEventInit extends IMouseEventInit {
  pointerId?: number;
  width?: number;
  height?: number;
  pressure?: number;
  tangentialPressure?: number;
  tiltX?: number;
  tiltY?: number;
  twist?: number;
  pointerType?: string;
  isPrimary?: boolean;
}

/**
 * Error events
 */
class ErrorEvent extends Event {
  constructor(type: string, eventInitDict?: IErrorEventInit);
  
  /** Error message */
  readonly message: string;
  
  /** Error filename */
  readonly filename: string;
  
  /** Error line number */
  readonly lineno: number;
  
  /** Error column number */
  readonly colno: number;
  
  /** Error object */
  readonly error: any;
}

interface IErrorEventInit extends IEventInit {
  message?: string;
  filename?: string;
  lineno?: number;
  colno?: number;
  error?: any;
}

/**
 * Progress events for loading operations
 */
class ProgressEvent extends Event {
  constructor(type: string, eventInitDict?: IProgressEventInit);
  
  /** Length computable flag */
  readonly lengthComputable: boolean;
  
  /** Loaded bytes */
  readonly loaded: number;
  
  /** Total bytes */
  readonly total: number;
}

interface IProgressEventInit extends IEventInit {
  lengthComputable?: boolean;
  loaded?: number;
  total?: number;
}

/**
 * Hash change events for navigation
 */
class HashChangeEvent extends Event {
  constructor(type: string, eventInitDict?: IHashChangeEventInit);
  
  /** New URL */
  readonly newURL: string;
  
  /** Old URL */
  readonly oldURL: string;
}

interface IHashChangeEventInit extends IEventInit {
  newURL?: string;
  oldURL?: string;
}

/**
 * CSS animation events
 */
class AnimationEvent extends Event {
  constructor(type: string, eventInitDict?: IAnimationEventInit);
  
  /** Animation name */
  readonly animationName: string;
  
  /** Elapsed time */
  readonly elapsedTime: number;
  
  /** Pseudo element */
  readonly pseudoElement: string;
}

interface IAnimationEventInit extends IEventInit {
  animationName?: string;
  elapsedTime?: number;
  pseudoElement?: string;
}

/**
 * Clipboard operation events
 */
class ClipboardEvent extends Event {
  constructor(type: string, eventInitDict?: IClipboardEventInit);
  
  /** Clipboard data */
  readonly clipboardData: DataTransfer | null;
}

interface IClipboardEventInit extends IEventInit {
  clipboardData?: DataTransfer | null;
}

import { Window } from "happy-dom";

const window = new Window();
const document = window.document;

// Create element
const button = document.createElement('button');
button.textContent = 'Click me';

// Add event listener
button.addEventListener('click', (event) => {
  console.log('Button clicked!');
  console.log('Event type:', event.type);
  console.log('Target:', event.target);
});

// Dispatch event programmatically
const clickEvent = new MouseEvent('click', {
  bubbles: true,
  cancelable: true,
  clientX: 100,
  clientY: 200
});

button.dispatchEvent(clickEvent);

import { CustomEvent } from "happy-dom";

// Create custom event
const customEvent = new CustomEvent('user-action', {
  detail: {
    action: 'save',
    data: { id: 123, name: 'Document' }
  },
  bubbles: true
});

// Listen for custom event
element.addEventListener('user-action', (event) => {
  console.log('Custom event:', event.detail);
});

// Dispatch custom event
element.dispatchEvent(customEvent);

import { Window } from "happy-dom";

const window = new Window();
const document = window.document;

document.addEventListener('keydown', (event) => {
  console.log('Key pressed:', event.key);
  console.log('Key code:', event.code);
  console.log('Ctrl key:', event.ctrlKey);
  console.log('Shift key:', event.shiftKey);
  
  // Handle specific keys
  if (event.key === 'Enter') {
    console.log('Enter key pressed');
  }
  
  if (event.ctrlKey && event.key === 's') {
    event.preventDefault();
    console.log('Save shortcut detected');
  }
});