Event System

/**
 * Create a type-safe event emitter
 * @returns Event emitter instance with on/off/emit methods
 */
function createEmitter<Events extends Record<EventType, unknown>>(): Emittable<Events>;

import { createEmitter, type Emittable } from "@intlify/shared";

// Define event types
interface MyEvents {
  userLogin: { userId: string; timestamp: number };
  userLogout: { userId: string };
  dataUpdate: { data: any[] };
}

// Create typed emitter
const emitter = createEmitter<MyEvents>();

// Type-safe event handling
emitter.on("userLogin", (payload) => {
  // payload is automatically typed as { userId: string; timestamp: number }
  console.log(`User ${payload?.userId} logged in at ${payload?.timestamp}`);
});

emitter.emit("userLogin", { userId: "123", timestamp: Date.now() });

/**
 * Register an event handler for specific event type
 * @param event - Event name or "*" for wildcard
 * @param handler - Event handler function
 */
on<Key extends keyof Events>(
  event: Key | '*',
  handler: EventHandler<Events[Key]> | WildcardEventHandler<Events>
): void;

import { createEmitter } from "@intlify/shared";

interface AppEvents {
  error: { message: string; code: number };
  success: { message: string };
}

const emitter = createEmitter<AppEvents>();

// Register specific event handler
emitter.on("error", (payload) => {
  console.error(`Error ${payload?.code}: ${payload?.message}`);
});

// Register wildcard handler for all events
emitter.on("*", (eventName, payload) => {
  console.log(`Event ${String(eventName)} fired:`, payload);
});

/**
 * Remove an event handler for specific event type
 * @param event - Event name or "*" for wildcard
 * @param handler - Event handler function to remove
 */
off<Key extends keyof Events>(
  event: Key | '*',
  handler: EventHandler<Events[Key]> | WildcardEventHandler<Events>
): void;

import { createEmitter } from "@intlify/shared";

const emitter = createEmitter<{ test: string }>();

const handler = (payload?: string) => {
  console.log("Received:", payload);
};

// Register handler
emitter.on("test", handler);

// Later, remove the same handler
emitter.off("test", handler);

/**
 * Emit an event to trigger all registered handlers
 * @param event - Event name to emit
 * @param payload - Optional event payload
 */
emit<Key extends keyof Events>(
  event: Key,
  payload?: Events[Key]
): void;

import { createEmitter } from "@intlify/shared";

interface NotificationEvents {
  notification: { 
    title: string; 
    body: string; 
    type: "info" | "warning" | "error" 
  };
}

const emitter = createEmitter<NotificationEvents>();

emitter.on("notification", (payload) => {
  if (payload) {
    showNotification(payload.title, payload.body, payload.type);
  }
});

// Emit notification event
emitter.emit("notification", {
  title: "Update Available",
  body: "A new version is available for download",
  type: "info"
});

/**
 * Valid event identifier types
 */
type EventType = string | symbol;

/**
 * Standard event handler function
 */
type EventHandler<T = unknown> = (payload?: T) => void;

/**
 * Wildcard event handler that receives event name and payload
 */
type WildcardEventHandler<T = Record<string, unknown>> = (
  event: keyof T,
  payload?: T[keyof T]
) => void;

/**
 * Array of event handlers for a specific event
 */
type EventHandlerList<T = unknown> = Array<EventHandler<T>>;

/**
 * Array of wildcard event handlers
 */
type WildcardEventHandlerList<T = Record<string, unknown>> = Array<
  WildcardEventHandler<T>
>;

/**
 * Map storing all event handlers by event name
 */
type EventHandlerMap<Events extends Record<EventType, unknown>> = Map<
  keyof Events | '*',
  EventHandlerList<Events[keyof Events]> | WildcardEventHandlerList<Events>
>;

/**
 * Core event emitter interface with type safety
 */
interface Emittable<Events extends Record<EventType, unknown> = {}> {
  /**
   * Map of registered event handlers by event name
   */
  events: EventHandlerMap<Events>;

  /**
   * Register an event handler
   * @param event - Event name or "*" for wildcard
   * @param handler - Handler function
   */
  on<Key extends keyof Events>(
    event: Key | '*',
    handler: EventHandler<Events[Key]> | WildcardEventHandler<Events>
  ): void;

  /**
   * Remove an event handler
   * @param event - Event name or "*" for wildcard  
   * @param handler - Handler function to remove
   */
  off<Key extends keyof Events>(
    event: Key | '*',
    handler: EventHandler<Events[Key]> | WildcardEventHandler<Events>
  ): void;

  /**
   * Emit an event to all registered handlers
   * @param event - Event name to emit
   * @param payload - Event payload
   */
  emit<Key extends keyof Events>(
    event: Key,
    payload?: Events[Key]
  ): void;
}

import { createEmitter } from "@intlify/shared";

interface LogEvents {
  log: { level: string; message: string; timestamp: number };
}

const logger = createEmitter<LogEvents>();

// Multiple handlers for same event
logger.on("log", (payload) => {
  console.log(`[${payload?.level}] ${payload?.message}`);
});

logger.on("log", (payload) => {
  if (payload?.level === "error") {
    sendToErrorReporting(payload);
  }
});

// Wildcard logger
logger.on("*", (eventName, payload) => {
  saveToDatabase(String(eventName), payload);
});

import { createEmitter } from "@intlify/shared";

const emitter = createEmitter<{ cleanup: void }>();

// Store handler reference for later cleanup
const cleanupHandler = () => {
  console.log("Cleaning up resources");
};

emitter.on("cleanup", cleanupHandler);

// Later, remove handler to prevent memory leaks
emitter.off("cleanup", cleanupHandler);