// typed-event-emitter.ts — TypeScript で型安全な Observer パターン
 
// イベントマップ: イベント名とそのデータ型を定義
type EventMap = {
  userCreated: { id: string; name: string; email: string };
  userDeleted: { id: string; reason: string };
  userUpdated: { id: string; changes: Partial<{ name: string; email: string }> };
  orderPlaced: { orderId: string; userId: string; total: number };
};
 
class TypedEventEmitter<T extends Record<string, any>> {
  private listeners = new Map<keyof T, Set<Function>>();
  private onceListeners = new Map<keyof T, Set<Function>>();
 
  /**
   * イベントを購読する
   * @returns unsubscribe 関数
   */
  on<K extends keyof T>(event: K, handler: (data: T[K]) => void): () => void {
    if (!this.listeners.has(event)) {
      this.listeners.set(event, new Set());
    }
    this.listeners.get(event)!.add(handler);
 
    // unsubscribe 関数を返す（クリーンアップ用）
    return () => {
      this.listeners.get(event)?.delete(handler);
    };
  }
 
  /**
   * 一度だけ購読する
   */
  once<K extends keyof T>(event: K, handler: (data: T[K]) => void): () => void {
    if (!this.onceListeners.has(event)) {
      this.onceListeners.set(event, new Set());
    }
    this.onceListeners.get(event)!.add(handler);
 
    return () => {
      this.onceListeners.get(event)?.delete(handler);
    };
  }
 
  /**
   * イベントを発行する
   */
  emit<K extends keyof T>(event: K, data: T[K]): void {
    // 通常のリスナー
    this.listeners.get(event)?.forEach(fn => fn(data));
 
    // once リスナー（実行後に削除）
    const onceHandlers = this.onceListeners.get(event);
    if (onceHandlers) {
      onceHandlers.forEach(fn => fn(data));
      onceHandlers.clear();
    }
  }
 
  /**
   * 特定イベントの全リスナーを解除
   */
  removeAllListeners<K extends keyof T>(event?: K): void {
    if (event) {
      this.listeners.delete(event);
      this.onceListeners.delete(event);
    } else {
      this.listeners.clear();
      this.onceListeners.clear();
    }
  }
 
  /**
   * リスナー数を取得（デバッグ・監視用）
   */
  listenerCount<K extends keyof T>(event: K): number {
    return (this.listeners.get(event)?.size ?? 0) +
           (this.onceListeners.get(event)?.size ?? 0);
  }
}
 
// --- 使用例 ---
const bus = new TypedEventEmitter<EventMap>();
 
// 型安全: handler の引数は自動推論される
const unsubUser = bus.on("userCreated", (user) => {
  console.log(`Welcome, ${user.name}! (${user.email})`);
  // user.id, user.name, user.email が型安全にアクセス可能
});
 
bus.on("orderPlaced", (order) => {
  console.log(`Order ${order.orderId}: $${order.total}`);
});
 
// once: 最初の1回だけ
bus.once("userCreated", (user) => {
  console.log(`First user bonus for ${user.name}!`);
});
 
bus.emit("userCreated", { id: "1", name: "Taro", email: "taro@example.com" });
// "Welcome, Taro! (taro@example.com)"
// "First user bonus for Taro!"
 
bus.emit("userCreated", { id: "2", name: "Hanako", email: "hanako@example.com" });
// "Welcome, Hanako! (hanako@example.com)"
// (once は実行されない)
 
unsubUser(); // 購読解除
 
bus.emit("userCreated", { id: "3", name: "Jiro", email: "jiro@example.com" });
// (何も出力されない — 解除済み)

// use-observable.ts — React でリアクティブデータを扱う Hook
import { useState, useEffect, useRef, useCallback } from 'react';
 
// Observable インタフェース
interface Observable<T> {
  subscribe(observer: (value: T) => void): { unsubscribe: () => void };
  getValue(): T;
}
 
// SimpleObservable 実装
class SimpleObservable<T> implements Observable<T> {
  private observers = new Set<(value: T) => void>();
  private currentValue: T;
 
  constructor(initialValue: T) {
    this.currentValue = initialValue;
  }
 
  getValue(): T {
    return this.currentValue;
  }
 
  next(value: T): void {
    this.currentValue = value;
    this.observers.forEach(observer => observer(value));
  }
 
  subscribe(observer: (value: T) => void): { unsubscribe: () => void } {
    this.observers.add(observer);
    return {
      unsubscribe: () => this.observers.delete(observer),
    };
  }
}
 
// React Hook
function useObservable<T>(observable$: Observable<T>): T {
  const [value, setValue] = useState<T>(() => observable$.getValue());
 
  useEffect(() => {
    // 値が変わっている可能性があるので同期
    setValue(observable$.getValue());
 
    const subscription = observable$.subscribe(setValue);
    return () => subscription.unsubscribe(); // クリーンアップ
  }, [observable$]);
 
  return value;
}
 
// 複数の Observable を組み合わせる Hook
function useCombinedObservable<T extends Record<string, Observable<any>>>(
  observables: T
): { [K in keyof T]: T[K] extends Observable<infer U> ? U : never } {
  const keys = Object.keys(observables) as (keyof T)[];
  const [values, setValues] = useState(() => {
    const initial: any = {};
    keys.forEach(key => {
      initial[key] = observables[key].getValue();
    });
    return initial;
  });
 
  useEffect(() => {
    const subscriptions = keys.map(key =>
      observables[key].subscribe((val: any) => {
        setValues((prev: any) => ({ ...prev, [key]: val }));
      })
    );
    return () => subscriptions.forEach(sub => sub.unsubscribe());
  }, []);
 
  return values;
}
 
// --- 使用例 ---
// グローバルな Observable ストア
const priceStore = new SimpleObservable<number>(100);
const statusStore = new SimpleObservable<string>("idle");
 
function StockPrice({ symbol }: { symbol: string }) {
  const price = useObservable(priceStore);
  const status = useObservable(statusStore);
 
  return (
    <div>
      <span>{symbol}: ${price}</span>
      <span>Status: {status}</span>
    </div>
  );
}
 
// 外部から値を更新
priceStore.next(105); // 全ての購読コンポーネントが自動再描画

// order-service.ts — Node.js EventEmitter を使ったドメインイベント
import { EventEmitter } from "events";
 
interface Order {
  id: string;
  userId: string;
  items: { productId: string; quantity: number; price: number }[];
  total: number;
  status: string;
}
 
// ドメインサービス: 注文処理
class OrderService extends EventEmitter {
  private orders = new Map<string, Order>();
 
  async placeOrder(userId: string, items: Order["items"]): Promise<Order> {
    const order: Order = {
      id: `ORD-${Date.now()}`,
      userId,
      items,
      total: items.reduce((sum, i) => sum + i.price * i.quantity, 0),
      status: "confirmed",
    };
 
    this.orders.set(order.id, order);
 
    // ドメインイベントを発行（OrderService は後続処理を知らない）
    this.emit("orderPlaced", order);
    return order;
  }
 
  async cancelOrder(orderId: string): Promise<void> {
    const order = this.orders.get(orderId);
    if (!order) throw new Error(`Order not found: ${orderId}`);
 
    order.status = "cancelled";
    this.emit("orderCancelled", order);
  }
}
 
// --- Observer の登録（アプリケーション起動時） ---
const orderService = new OrderService();
 
// メール送信
orderService.on("orderPlaced", (order: Order) => {
  console.log(`[Email] Sending confirmation for order ${order.id}`);
  // emailService.sendConfirmation(order);
});
 
// 在庫管理
orderService.on("orderPlaced", (order: Order) => {
  console.log(`[Inventory] Decrementing stock for ${order.items.length} items`);
  // order.items.forEach(item => inventoryService.decrement(item.productId, item.quantity));
});
 
// 分析
orderService.on("orderPlaced", (order: Order) => {
  console.log(`[Analytics] Recording purchase: $${order.total}`);
  // analyticsService.trackPurchase(order);
});
 
// キャンセル時のハンドラ
orderService.on("orderCancelled", (order: Order) => {
  console.log(`[Email] Sending cancellation notice for ${order.id}`);
  console.log(`[Inventory] Restoring stock for ${order.items.length} items`);
});
 
// --- 使用例 ---
orderService.placeOrder("user-1", [
  { productId: "p-1", quantity: 2, price: 1000 },
  { productId: "p-2", quantity: 1, price: 3000 },
]);
// [Email] Sending confirmation for order ORD-...
// [Inventory] Decrementing stock for 2 items
// [Analytics] Recording purchase: $5000

# event_bus.py — WeakRef でメモリリークを防ぐ Observer パターン
from __future__ import annotations
import weakref
from typing import Any, Callable, Dict, List, Optional
from dataclasses import dataclass
from datetime import datetime
 
 
@dataclass
class Event:
    """イベントの基底クラス"""
    timestamp: datetime
    source: str
 
 
@dataclass
class UserCreatedEvent(Event):
    user_id: str
    name: str
    email: str
 
 
@dataclass
class OrderPlacedEvent(Event):
    order_id: str
    user_id: str
    total: float
 
 
class EventBus:
    """WeakRef 対応の EventBus"""
 
    def __init__(self) -> None:
        self._subscribers: Dict[str, List[weakref.ref]] = {}
        self._function_subscribers: Dict[str, List[Callable]] = {}
 
    def subscribe(self, event_type: str, handler: Callable) -> Callable[[], None]:
        """
        イベントを購読する。
        handler がメソッドの場合は WeakRef で保持し、
        GC 時に自動的に解除される。
        """
        if hasattr(handler, '__self__'):
            # バウンドメソッドの場合: WeakRef で保持
            if event_type not in self._subscribers:
                self._subscribers[event_type] = []
            ref = weakref.ref(handler.__self__)
            method_name = handler.__func__.__name__
            self._subscribers[event_type].append(ref)
        else:
            # 通常の関数の場合
            if event_type not in self._function_subscribers:
                self._function_subscribers[event_type] = []
            self._function_subscribers[event_type].append(handler)
 
        def unsubscribe() -> None:
            if event_type in self._function_subscribers:
                try:
                    self._function_subscribers[event_type].remove(handler)
                except ValueError:
                    pass
 
        return unsubscribe
 
    def publish(self, event_type: str, data: Any = None) -> None:
        """イベントを発行する"""
        # 通常の関数ハンドラ
        for handler in self._function_subscribers.get(event_type, []):
            handler(data)
 
        # WeakRef ハンドラ（GC 済みのものを除去）
        if event_type in self._subscribers:
            alive_refs = []
            for ref in self._subscribers[event_type]:
                obj = ref()
                if obj is not None:
                    alive_refs.append(ref)
                    # handle メソッドを呼び出す
                    if hasattr(obj, 'handle_event'):
                        obj.handle_event(event_type, data)
            self._subscribers[event_type] = alive_refs
 
 
# --- 使用例 ---
bus = EventBus()
 
 
def on_user_created(event: UserCreatedEvent) -> None:
    print(f"[Handler] Welcome email sent to {event.email}")
 
 
unsub = bus.subscribe("user.created", on_user_created)
 
bus.publish("user.created", UserCreatedEvent(
    timestamp=datetime.now(),
    source="user-service",
    user_id="u-1",
    name="Taro",
    email="taro@example.com",
))
# [Handler] Welcome email sent to taro@example.com
 
unsub()  # 購読解除
 
bus.publish("user.created", UserCreatedEvent(
    timestamp=datetime.now(),
    source="user-service",
    user_id="u-2",
    name="Hanako",
    email="hanako@example.com",
))
# (何も出力されない)

// async-event-emitter.ts — 非同期 Observer の実装
type AsyncHandler<T> = (data: T) => Promise<void> | void;
 
interface EmitOptions {
  /** 並列実行か順次実行か */
  mode: 'parallel' | 'sequential';
  /** タイムアウト（ms） */
  timeout?: number;
  /** エラー時に他のハンドラを継続するか */
  continueOnError?: boolean;
}
 
class AsyncEventEmitter<T extends Record<string, any>> {
  private listeners = new Map<keyof T, Set<AsyncHandler<any>>>();
 
  on<K extends keyof T>(event: K, handler: AsyncHandler<T[K]>): () => void {
    if (!this.listeners.has(event)) {
      this.listeners.set(event, new Set());
    }
    this.listeners.get(event)!.add(handler);
    return () => this.listeners.get(event)?.delete(handler);
  }
 
  /**
   * 並列実行: 全ハンドラを同時に実行
   * 順序保証は不要だがスループットを最大化したい場合に使用
   */
  async emitParallel<K extends keyof T>(
    event: K,
    data: T[K],
    options?: { timeout?: number; continueOnError?: boolean }
  ): Promise<{ successes: number; errors: Error[] }> {
    const handlers = this.listeners.get(event);
    if (!handlers) return { successes: 0, errors: [] };
 
    const errors: Error[] = [];
    let successes = 0;
 
    const promises = [...handlers].map(async (fn) => {
      try {
        const promise = fn(data);
        if (options?.timeout && promise instanceof Promise) {
          await Promise.race([
            promise,
            new Promise((_, reject) =>
              setTimeout(() => reject(new Error('Handler timeout')), options.timeout)
            ),
          ]);
        } else {
          await promise;
        }
        successes++;
      } catch (error) {
        errors.push(error as Error);
        if (!options?.continueOnError) throw error;
      }
    });
 
    if (options?.continueOnError) {
      await Promise.allSettled(promises);
    } else {
      await Promise.all(promises);
    }
 
    return { successes, errors };
  }
 
  /**
   * 順次実行: ハンドラを登録順に1つずつ実行
   * 順序保証が必要な場合に使用
   */
  async emitSequential<K extends keyof T>(
    event: K,
    data: T[K]
  ): Promise<void> {
    const handlers = this.listeners.get(event);
    if (!handlers) return;
 
    for (const fn of handlers) {
      await fn(data);
    }
  }
}
 
// --- 使用例 ---
type AppEvents = {
  orderPlaced: { orderId: string; total: number };
  paymentProcessed: { orderId: string; amount: number };
};
 
const emitter = new AsyncEventEmitter<AppEvents>();
 
emitter.on("orderPlaced", async (order) => {
  await new Promise(resolve => setTimeout(resolve, 100));
  console.log(`[Email] Sent for ${order.orderId}`);
});
 
emitter.on("orderPlaced", async (order) => {
  await new Promise(resolve => setTimeout(resolve, 50));
  console.log(`[Inventory] Updated for ${order.orderId}`);
});
 
// 並列実行: 全ハンドラが同時に開始、最も遅いもので完了
const result = await emitter.emitParallel(
  "orderPlaced",
  { orderId: "ORD-1", total: 5000 },
  { timeout: 3000, continueOnError: true }
);
console.log(`Success: ${result.successes}, Errors: ${result.errors.length}`);
 
// 順次実行: Email -> Inventory の順番で実行
await emitter.emitSequential("orderPlaced", { orderId: "ORD-2", total: 3000 });

// abort-event-emitter.ts — AbortController で一括解除
class ManagedEventEmitter<T extends Record<string, any>> {
  private listeners = new Map<keyof T, Set<Function>>();
 
  on<K extends keyof T>(
    event: K,
    handler: (data: T[K]) => void,
    signal?: AbortSignal
  ): () => void {
    if (!this.listeners.has(event)) {
      this.listeners.set(event, new Set());
    }
    this.listeners.get(event)!.add(handler);
 
    const unsubscribe = () => {
      this.listeners.get(event)?.delete(handler);
    };
 
    // AbortSignal と連携: signal が abort されたら自動解除
    if (signal) {
      signal.addEventListener('abort', unsubscribe, { once: true });
    }
 
    return unsubscribe;
  }
 
  emit<K extends keyof T>(event: K, data: T[K]): void {
    this.listeners.get(event)?.forEach(fn => fn(data));
  }
}
 
// --- 使用例: コンポーネントのライフサイクルで一括管理 ---
class DashboardComponent {
  private abortController = new AbortController();
 
  constructor(private emitter: ManagedEventEmitter<AppEvents>) {
    // AbortController の signal を渡す
    const signal = this.abortController.signal;
 
    emitter.on("orderPlaced", (order) => {
      console.log(`Dashboard: New order ${order.orderId}`);
    }, signal);
 
    emitter.on("paymentProcessed", (payment) => {
      console.log(`Dashboard: Payment ${payment.amount}`);
    }, signal);
  }
 
  destroy(): void {
    // 全ての購読を一括解除
    this.abortController.abort();
    console.log("Dashboard: All subscriptions removed");
  }
}
 
const emitter = new ManagedEventEmitter<AppEvents>();
const dashboard = new DashboardComponent(emitter);
 
emitter.emit("orderPlaced", { orderId: "1", total: 100 });
// Dashboard: New order 1
 
dashboard.destroy();
// Dashboard: All subscriptions removed
 
emitter.emit("orderPlaced", { orderId: "2", total: 200 });
// (何も出力されない — 全て解除済み)

// reactive-store.ts — Observer パターンで状態管理
type Reducer<S, A> = (state: S, action: A) => S;
type Listener = () => void;
type Middleware<S, A> = (store: Store<S, A>) =>
  (next: (action: A) => void) => (action: A) => void;
 
class Store<S, A extends { type: string }> {
  private state: S;
  private listeners = new Set<Listener>();
  private reducer: Reducer<S, A>;
  private dispatch: (action: A) => void;
 
  constructor(
    reducer: Reducer<S, A>,
    initialState: S,
    middlewares: Middleware<S, A>[] = []
  ) {
    this.reducer = reducer;
    this.state = initialState;
 
    // ミドルウェアチェーンの構築
    let dispatch = (action: A) => {
      this.state = this.reducer(this.state, action);
      this.listeners.forEach(listener => listener()); // 全 Observer に通知
    };
 
    // ミドルウェアを逆順に適用
    for (let i = middlewares.length - 1; i >= 0; i--) {
      dispatch = middlewaresi(dispatch);
    }
 
    this.dispatch = dispatch;
  }
 
  getState(): S {
    return this.state;
  }
 
  subscribe(listener: Listener): () => void {
    this.listeners.add(listener);
    return () => this.listeners.delete(listener);
  }
 
  send(action: A): void {
    this.dispatch(action);
  }
}
 
// --- 使用例: カウンターストア ---
type CounterState = { count: number; history: number[] };
type CounterAction =
  | { type: 'INCREMENT'; amount: number }
  | { type: 'DECREMENT'; amount: number }
  | { type: 'RESET' };
 
const counterReducer: Reducer<CounterState, CounterAction> = (state, action) => {
  switch (action.type) {
    case 'INCREMENT':
      return {
        count: state.count + action.amount,
        history: [...state.history, state.count + action.amount]
      };
    case 'DECREMENT':
      return {
        count: state.count - action.amount,
        history: [...state.history, state.count - action.amount]
      };
    case 'RESET':
      return { count: 0, history: [0] };
    default:
      return state;
  }
};
 
// ロギングミドルウェア
const logger: Middleware<CounterState, CounterAction> =
  (store) => (next) => (action) => {
    console.log(`[Logger] Action: ${action.type}, Before: ${store.getState().count}`);
    next(action);
    console.log(`[Logger] After: ${store.getState().count}`);
  };
 
const store = new Store(counterReducer, { count: 0, history: [0] }, [logger]);
 
// Observer (購読者) の登録
const unsub = store.subscribe(() => {
  console.log(`[UI] Count changed to: ${store.getState().count}`);
});
 
store.send({ type: 'INCREMENT', amount: 5 });
// [Logger] Action: INCREMENT, Before: 0
// [UI] Count changed to: 5
// [Logger] After: 5
 
store.send({ type: 'DECREMENT', amount: 2 });
// [Logger] Action: DECREMENT, Before: 5
// [UI] Count changed to: 3
// [Logger] After: 3
 
unsub(); // UI の購読解除
 
store.send({ type: 'RESET' });
// [Logger] Action: RESET, Before: 3
// [Logger] After: 0
// (UI には通知されない)

// NG: コンポーネント破棄後もリスナーが残る
class BadComponent {
  constructor(private emitter: EventEmitter) {
    // 登録はするが、解除しない！
    emitter.on("data", this.handleData);
  }
 
  handleData = (data: any) => {
    this.element.textContent = data; // 破棄済みの要素にアクセス → エラー
  };
 
  destroy(): void {
    // handleData の解除を忘れている
    this.element.remove();
  }
}
 
// OK: 確実に購読解除する（複数の方法）
class GoodComponent {
  private unsubscribers: (() => void)[] = [];
 
  constructor(private emitter: TypedEventEmitter<AppEvents>) {
    // 方法1: unsubscribe 関数を保持
    this.unsubscribers.push(
      emitter.on("orderPlaced", this.handleOrder)
    );
    this.unsubscribers.push(
      emitter.on("paymentProcessed", this.handlePayment)
    );
  }
 
  handleOrder = (order: any) => { /* ... */ };
  handlePayment = (payment: any) => { /* ... */ };
 
  destroy(): void {
    // 全ての購読を一括解除
    this.unsubscribers.forEach(unsub => unsub());
    this.unsubscribers = [];
    this.element.remove();
  }
}
 
// OK: React での正しいクリーンアップ
function GoodReactComponent() {
  useEffect(() => {
    const unsub = emitter.on("data", handleData);
    return () => unsub(); // useEffect のクリーンアップで確実に解除
  }, []);
}
 
// OK: AbortController による一括管理
class BetterComponent {
  private controller = new AbortController();
 
  constructor(private emitter: ManagedEventEmitter<AppEvents>) {
    const signal = this.controller.signal;
    emitter.on("orderPlaced", this.handleOrder, signal);
    emitter.on("paymentProcessed", this.handlePayment, signal);
  }
 
  handleOrder = (order: any) => { /* ... */ };
  handlePayment = (payment: any) => { /* ... */ };
 
  destroy(): void {
    this.controller.abort(); // 全購読を一括解除
  }
}

// NG: A の変更が B に通知 -> B の変更が A に通知 -> ...
const emitter = new TypedEventEmitter<{
  priceChanged: { price: number };
  taxChanged: { tax: number };
}>();
 
emitter.on("priceChanged", ({ price }) => {
  const newTax = price * 0.1;
  emitter.emit("taxChanged", { tax: newTax }); // taxChanged を発行
});
 
emitter.on("taxChanged", ({ tax }) => {
  const newPrice = tax / 0.1;
  emitter.emit("priceChanged", { price: newPrice }); // priceChanged を再発行！
  // -> 無限ループ
});
 
// OK: 循環検出ガード付き EventEmitter
class SafeEventEmitter<T extends Record<string, any>> {
  private listeners = new Map<keyof T, Set<Function>>();
  private emitting = new Set<keyof T>(); // 現在発行中のイベント
 
  on<K extends keyof T>(event: K, handler: (data: T[K]) => void): () => void {
    if (!this.listeners.has(event)) {
      this.listeners.set(event, new Set());
    }
    this.listeners.get(event)!.add(handler);
    return () => this.listeners.get(event)?.delete(handler);
  }
 
  emit<K extends keyof T>(event: K, data: T[K]): void {
    if (this.emitting.has(event)) {
      console.warn(`[SafeEmitter] Circular emit detected for "${String(event)}". Skipping.`);
      return; // 循環を防止
    }
 
    this.emitting.add(event);
    try {
      this.listeners.get(event)?.forEach(fn => fn(data));
    } finally {
      this.emitting.delete(event);
    }
  }
}

// NG: 1つの巨大な handler が全イベントを処理
class GodObserver {
  handle(eventType: string, data: any): void {
    switch (eventType) {
      case "userCreated":
        this.sendWelcomeEmail(data);
        this.createDefaultSettings(data);
        this.notifyAdmin(data);
        break;
      case "orderPlaced":
        this.sendConfirmation(data);
        this.updateInventory(data);
        this.processPayment(data);
        break;
      // ... 数十のイベントタイプ
    }
  }
}
 
// OK: 責務ごとに Observer を分離
class EmailObserver {
  constructor(private emitter: EventEmitter) {
    emitter.on("userCreated", this.sendWelcome);
    emitter.on("orderPlaced", this.sendConfirmation);
    emitter.on("orderCancelled", this.sendCancellation);
  }
 
  private sendWelcome = (data: any) => { /* メール送信のみ */ };
  private sendConfirmation = (data: any) => { /* メール送信のみ */ };
  private sendCancellation = (data: any) => { /* メール送信のみ */ };
}
 
class InventoryObserver {
  constructor(private emitter: EventEmitter) {
    emitter.on("orderPlaced", this.decrementStock);
    emitter.on("orderCancelled", this.restoreStock);
  }
 
  private decrementStock = (data: any) => { /* 在庫管理のみ */ };
  private restoreStock = (data: any) => { /* 在庫管理のみ */ };
}

type Events = {
  message: { text: string; from: string };
  error: { code: number; message: string };
};
 
const emitter = new TypedEventEmitter<Events>();
 
const unsub = emitter.on("message", (msg) => {
  console.log(`${msg.from}: ${msg.text}`);
});
 
emitter.once("error", (err) => {
  console.log(`Error ${err.code}: ${err.message}`);
});
 
emitter.emit("message", { text: "Hello", from: "Alice" });
// "Alice: Hello"
 
console.log(emitter.listenerCount("message")); // 1
console.log(emitter.listenerCount("error"));   // 1
 
emitter.emit("error", { code: 404, message: "Not Found" });
// "Error 404: Not Found"
 
console.log(emitter.listenerCount("error"));   // 0 (once は消費済み)
 
unsub();
console.log(emitter.listenerCount("message")); // 0

type State = { count: number; name: string };
type Action =
  | { type: 'INCREMENT' }
  | { type: 'SET_NAME'; name: string };
 
const store = new Store<State, Action>(
  (state, action) => {
    switch (action.type) {
      case 'INCREMENT': return { ...state, count: state.count + 1 };
      case 'SET_NAME': return { ...state, name: action.name };
      default: return state;
    }
  },
  { count: 0, name: "initial" }
);
 
// count だけを監視
const unsubCount = store.select(
  s => s.count,
  (count) => console.log(`Count: ${count}`)
);
 
store.dispatch({ type: 'SET_NAME', name: 'Taro' });
// (count は変わっていないので何も出力されない)
 
store.dispatch({ type: 'INCREMENT' });
// "Count: 1"
 
unsubCount();

const bus = new ResilientEventBus();
 
let callCount = 0;
bus.on("process", async (data: { id: string }) => {
  callCount++;
  if (callCount < 3) {
    throw new Error("Temporary failure");
  }
  console.log(`Processed: ${data.id}`);
});
 
await bus.emit("process", { id: "item-1" }, {
  mode: 'sequential',
  retry: { maxAttempts: 3, backoffMs: 100 },
  timeoutMs: 5000,
});
// 1回目: 失敗 (100ms 待機)
// 2回目: 失敗 (200ms 待機)
// 3回目: "Processed: item-1"
 
console.log(bus.getDeadLetterQueue().length); // 0 (成功したため)