// === Component インタフェース ===
interface DataSource {
  read(): string;
  write(data: string): void;
}
 
// === ConcreteComponent ===
class FileDataSource implements DataSource {
  private content = "";
 
  constructor(private filename: string) {}
 
  read(): string {
    console.log(`  [File] Reading from ${this.filename}`);
    return this.content;
  }
 
  write(data: string): void {
    console.log(`  [File] Writing to ${this.filename}: "${data}"`);
    this.content = data;
  }
}
 
// === BaseDecorator（オプション: 共通の委譲ロジック）===
abstract class DataSourceDecorator implements DataSource {
  constructor(protected wrapped: DataSource) {}
 
  read(): string {
    return this.wrapped.read();
  }
 
  write(data: string): void {
    this.wrapped.write(data);
  }
}
 
// === ConcreteDecorator 1: 暗号化 ===
class EncryptionDecorator extends DataSourceDecorator {
  read(): string {
    const data = super.read();
    const decrypted = this.decrypt(data);
    console.log(`  [Encrypt] Decrypted: "${data}" → "${decrypted}"`);
    return decrypted;
  }
 
  write(data: string): void {
    const encrypted = this.encrypt(data);
    console.log(`  [Encrypt] Encrypted: "${data}" → "${encrypted}"`);
    super.write(encrypted);
  }
 
  private encrypt(data: string): string {
    return Buffer.from(data).toString("base64");
  }
 
  private decrypt(data: string): string {
    return Buffer.from(data, "base64").toString("utf-8");
  }
}
 
// === ConcreteDecorator 2: 圧縮 ===
class CompressionDecorator extends DataSourceDecorator {
  read(): string {
    const data = super.read();
    const decompressed = this.decompress(data);
    console.log(`  [Compress] Decompressed`);
    return decompressed;
  }
 
  write(data: string): void {
    const compressed = this.compress(data);
    console.log(`  [Compress] Compressed: ${data.length} → ${compressed.length} chars`);
    super.write(compressed);
  }
 
  private compress(data: string): string {
    return `compressed(${data})`;
  }
 
  private decompress(data: string): string {
    return data.replace(/^compressed\(/, "").replace(/\)$/, "");
  }
}
 
// === ConcreteDecorator 3: ログ ===
class LoggingDecorator extends DataSourceDecorator {
  read(): string {
    console.log("[LOG] read() called");
    const start = Date.now();
    const result = super.read();
    console.log(`[LOG] read() completed in ${Date.now() - start}ms`);
    return result;
  }
 
  write(data: string): void {
    console.log(`[LOG] write("${data}") called`);
    const start = Date.now();
    super.write(data);
    console.log(`[LOG] write() completed in ${Date.now() - start}ms`);
  }
}
 
// === 使用例: デコレータの積み重ね ===
const source: DataSource = new LoggingDecorator(
  new CompressionDecorator(
    new EncryptionDecorator(
      new FileDataSource("secret.txt")
    )
  )
);
 
source.write("Hello, World!");
// [LOG] write("Hello, World!") called
//   [Compress] Compressed: 13 → 29 chars
//   [Encrypt] Encrypted: "compressed(Hello, World!)" → "Y29tcHJlc3NlZ..."
//   [File] Writing to secret.txt: "Y29tcHJlc3NlZ..."
// [LOG] write() completed in 1ms
 
const data = source.read();
// [LOG] read() called
//   [File] Reading from secret.txt
//   [Encrypt] Decrypted: ...
//   [Compress] Decompressed
// [LOG] read() completed in 0ms

// === Component ===
interface HttpClient {
  request(url: string, options?: RequestInit): Promise<Response>;
}
 
class FetchClient implements HttpClient {
  async request(url: string, options?: RequestInit): Promise<Response> {
    return fetch(url, options);
  }
}
 
// === Decorator 1: リトライ ===
class RetryDecorator implements HttpClient {
  constructor(
    private client: HttpClient,
    private maxRetries = 3,
    private baseDelay = 1000
  ) {}
 
  async request(url: string, options?: RequestInit): Promise<Response> {
    let lastError: Error | undefined;
    for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
      try {
        const response = await this.client.request(url, options);
        if (response.ok || response.status < 500) return response;
        throw new Error(`Server error: ${response.status}`);
      } catch (error) {
        lastError = error as Error;
        if (attempt < this.maxRetries) {
          const delay = this.baseDelay * Math.pow(2, attempt);
          console.log(`Retry ${attempt + 1}/${this.maxRetries} after ${delay}ms`);
          await new Promise(r => setTimeout(r, delay));
        }
      }
    }
    throw lastError;
  }
}
 
// === Decorator 2: タイムアウト ===
class TimeoutDecorator implements HttpClient {
  constructor(private client: HttpClient, private timeoutMs = 5000) {}
 
  async request(url: string, options?: RequestInit): Promise<Response> {
    const controller = new AbortController();
    const timer = setTimeout(() => controller.abort(), this.timeoutMs);
 
    try {
      return await this.client.request(url, {
        ...options,
        signal: controller.signal,
      });
    } finally {
      clearTimeout(timer);
    }
  }
}
 
// === Decorator 3: ロギング ===
class LoggingHttpDecorator implements HttpClient {
  constructor(private client: HttpClient) {}
 
  async request(url: string, options?: RequestInit): Promise<Response> {
    const method = options?.method ?? "GET";
    console.log(`→ ${method} ${url}`);
    const start = Date.now();
 
    try {
      const response = await this.client.request(url, options);
      console.log(`← ${response.status} (${Date.now() - start}ms)`);
      return response;
    } catch (error) {
      console.log(`✗ ERROR (${Date.now() - start}ms): ${error}`);
      throw error;
    }
  }
}
 
// === Decorator 4: 認証ヘッダー追加 ===
class AuthDecorator implements HttpClient {
  constructor(
    private client: HttpClient,
    private getToken: () => Promise<string>
  ) {}
 
  async request(url: string, options?: RequestInit): Promise<Response> {
    const token = await this.getToken();
    const headers = new Headers(options?.headers);
    headers.set("Authorization", `Bearer ${token}`);
    return this.client.request(url, { ...options, headers });
  }
}
 
// === Decorator 5: サーキットブレーカー ===
class CircuitBreakerDecorator implements HttpClient {
  private failures = 0;
  private lastFailure = 0;
  private state: "closed" | "open" | "half-open" = "closed";
 
  constructor(
    private client: HttpClient,
    private threshold = 5,
    private resetTimeout = 30000
  ) {}
 
  async request(url: string, options?: RequestInit): Promise<Response> {
    if (this.state === "open") {
      if (Date.now() - this.lastFailure > this.resetTimeout) {
        this.state = "half-open";
      } else {
        throw new Error("Circuit breaker is OPEN");
      }
    }
 
    try {
      const response = await this.client.request(url, options);
      this.onSuccess();
      return response;
    } catch (error) {
      this.onFailure();
      throw error;
    }
  }
 
  private onSuccess(): void {
    this.failures = 0;
    this.state = "closed";
  }
 
  private onFailure(): void {
    this.failures++;
    this.lastFailure = Date.now();
    if (this.failures >= this.threshold) {
      this.state = "open";
      console.log("Circuit breaker OPENED");
    }
  }
}
 
// === 組み立て ===
const httpClient: HttpClient = new LoggingHttpDecorator(
  new CircuitBreakerDecorator(
    new RetryDecorator(
      new TimeoutDecorator(
        new AuthDecorator(
          new FetchClient(),
          async () => "token-xxx"
        ),
        5000
      ),
      3
    )
  )
);
 
// 実行順: Logging → CircuitBreaker → Retry → Timeout → Auth → Fetch

// TC39 Stage 3 Decorators (TypeScript 5+)
// GoF の Decorator パターンとは異なるが、動機は共通
 
// === メソッドデコレータ: ログ出力 ===
function logged(
  target: any,
  context: ClassMethodDecoratorContext
) {
  const methodName = String(context.name);
  return function (this: any, ...args: any[]) {
    console.log(`→ ${methodName}(${args.map(a => JSON.stringify(a)).join(", ")})`);
    const result = target.call(this, ...args);
    console.log(`← ${methodName} = ${JSON.stringify(result)}`);
    return result;
  };
}
 
// === メソッドデコレータ: パフォーマンス計測 ===
function timed(
  target: any,
  context: ClassMethodDecoratorContext
) {
  const methodName = String(context.name);
  return function (this: any, ...args: any[]) {
    const start = performance.now();
    const result = target.call(this, ...args);
    const elapsed = performance.now() - start;
    console.log(`${methodName}: ${elapsed.toFixed(2)}ms`);
    return result;
  };
}
 
// === メソッドデコレータ: メモ化 ===
function memoize(
  target: any,
  context: ClassMethodDecoratorContext
) {
  const cache = new Map<string, any>();
  return function (this: any, ...args: any[]) {
    const key = JSON.stringify(args);
    if (cache.has(key)) return cache.get(key);
    const result = target.call(this, ...args);
    cache.set(key, result);
    return result;
  };
}
 
// === メソッドデコレータ: バリデーション ===
function validate(schema: Record<string, (v: any) => boolean>) {
  return function (
    target: any,
    context: ClassMethodDecoratorContext
  ) {
    return function (this: any, ...args: any[]) {
      // 最初の引数がオブジェクトの場合バリデーション
      const input = args[0];
      if (typeof input === "object" && input !== null) {
        for (const [key, validator] of Object.entries(schema)) {
          if (!validator(input[key])) {
            throw new Error(`Validation failed for field "${key}"`);
          }
        }
      }
      return target.call(this, ...args);
    };
  };
}
 
// === 使用例 ===
class Calculator {
  @logged
  @timed
  add(a: number, b: number): number {
    return a + b;
  }
 
  @memoize
  fibonacci(n: number): number {
    if (n <= 1) return n;
    return this.fibonacci(n - 1) + this.fibonacci(n - 2);
  }
}
 
class UserService {
  @validate({
    name: (v: any) => typeof v === "string" && v.length > 0,
    age: (v: any) => typeof v === "number" && v >= 0,
  })
  createUser(data: { name: string; age: number }): void {
    console.log(`Created user: ${data.name}`);
  }
}

import functools
import time
import logging
from typing import Callable, TypeVar, ParamSpec
 
P = ParamSpec("P")
R = TypeVar("R")
 
# === 関数デコレータ: リトライ ===
def retry(max_retries: int = 3, delay: float = 1.0, exceptions: tuple = (Exception,)):
    """指定回数までリトライするデコレータ"""
    def decorator(func: Callable[P, R]) -> Callable[P, R]:
        @functools.wraps(func)
        def wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
            last_exception = None
            for attempt in range(max_retries + 1):
                try:
                    return func(*args, **kwargs)
                except exceptions as e:
                    last_exception = e
                    if attempt < max_retries:
                        wait = delay * (2 ** attempt)
                        logging.warning(
                            f"Retry {attempt + 1}/{max_retries} for {func.__name__} "
                            f"after {wait}s: {e}"
                        )
                        time.sleep(wait)
            raise last_exception  # type: ignore
        return wrapper
    return decorator
 
 
# === 関数デコレータ: 実行時間計測 ===
def timed(func: Callable[P, R]) -> Callable[P, R]:
    """実行時間を計測するデコレータ"""
    @functools.wraps(func)
    def wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
        start = time.perf_counter()
        result = func(*args, **kwargs)
        elapsed = time.perf_counter() - start
        logging.info(f"{func.__name__}: {elapsed:.4f}s")
        return result
    return wrapper
 
 
# === 関数デコレータ: キャッシュ（TTL付き）===
def cache_with_ttl(ttl_seconds: float = 60.0):
    """TTL付きキャッシュデコレータ"""
    def decorator(func: Callable[P, R]) -> Callable[P, R]:
        _cache: dict[str, tuple[R, float]] = {}
 
        @functools.wraps(func)
        def wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
            key = str((args, tuple(sorted(kwargs.items()))))
            if key in _cache:
                value, expiry = _cache[key]
                if time.time() < expiry:
                    return value
            result = func(*args, **kwargs)
            _cache[key] = (result, time.time() + ttl_seconds)
            return result
        return wrapper
    return decorator
 
 
# === 関数デコレータ: 入力バリデーション ===
def validate_args(**validators: Callable):
    """引数のバリデーションデコレータ"""
    def decorator(func: Callable[P, R]) -> Callable[P, R]:
        @functools.wraps(func)
        def wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
            import inspect
            sig = inspect.signature(func)
            bound = sig.bind(*args, **kwargs)
            bound.apply_defaults()
 
            for param_name, validator in validators.items():
                if param_name in bound.arguments:
                    value = bound.arguments[param_name]
                    if not validator(value):
                        raise ValueError(
                            f"Validation failed for '{param_name}': {value}"
                        )
            return func(*args, **kwargs)
        return wrapper
    return decorator
 
 
# === 使用例 ===
@retry(max_retries=3, delay=0.5, exceptions=(ConnectionError, TimeoutError))
@timed
def fetch_data(url: str) -> dict:
    """外部APIからデータを取得"""
    import urllib.request
    response = urllib.request.urlopen(url)
    return {"status": response.status}
 
 
@cache_with_ttl(ttl_seconds=300)
def get_config(key: str) -> str:
    """設定値を取得（キャッシュ付き）"""
    return f"value_for_{key}"
 
 
@validate_args(
    name=lambda v: isinstance(v, str) and len(v) > 0,
    age=lambda v: isinstance(v, int) and 0 <= v <= 150,
)
def create_user(name: str, age: int) -> dict:
    return {"name": name, "age": age}
 
 
# クラスデコレータ: Singleton
def singleton(cls):
    """シングルトンにするクラスデコレータ"""
    instances: dict = {}
 
    @functools.wraps(cls)
    def get_instance(*args, **kwargs):
        if cls not in instances:
            instances[cls] = cls(*args, **kwargs)
        return instances[cls]
 
    return get_instance
 
 
@singleton
class DatabaseConnection:
    def __init__(self, url: str):
        self.url = url
        print(f"Connecting to {url}")

import React, { ComponentType, useEffect, useState } from "react";
 
// === HOC 1: ローディング状態の追加 ===
function withLoading<P extends object>(
  WrappedComponent: ComponentType<P>
): ComponentType<P & { isLoading?: boolean }> {
  return function WithLoadingComponent(props: P & { isLoading?: boolean }) {
    const { isLoading, ...rest } = props;
    if (isLoading) {
      return <div className="spinner">Loading...</div>;
    }
    return <WrappedComponent {...(rest as P)} />;
  };
}
 
// === HOC 2: 認証ガード ===
function withAuth<P extends object>(
  WrappedComponent: ComponentType<P>
): ComponentType<P> {
  return function WithAuthComponent(props: P) {
    const { user, isAuthenticated } = useAuth();
    if (!isAuthenticated) {
      return <Navigate to="/login" />;
    }
    return <WrappedComponent {...props} user={user} />;
  };
}
 
// === HOC 3: エラーバウンダリ ===
function withErrorBoundary<P extends object>(
  WrappedComponent: ComponentType<P>,
  FallbackComponent: ComponentType<{ error: Error }>
): ComponentType<P> {
  return class ErrorBoundaryWrapper extends React.Component<P, { error: Error | null }> {
    state = { error: null };
 
    static getDerivedStateFromError(error: Error) {
      return { error };
    }
 
    render() {
      if (this.state.error) {
        return <FallbackComponent error={this.state.error} />;
      }
      return <WrappedComponent {...this.props} />;
    }
  };
}
 
// === HOC 4: パフォーマンストラッキング ===
function withPerformanceTracking<P extends object>(
  WrappedComponent: ComponentType<P>,
  componentName: string
): ComponentType<P> {
  return function WithPerformanceTracking(props: P) {
    useEffect(() => {
      const start = performance.now();
      return () => {
        const elapsed = performance.now() - start;
        console.log(`${componentName} rendered for ${elapsed.toFixed(0)}ms`);
      };
    });
    return <WrappedComponent {...props} />;
  };
}
 
// === 積み重ね ===
const UserList: React.FC<{ users: User[] }> = ({ users }) => (
  <ul>{users.map(u => <li key={u.id}>{u.name}</li>)}</ul>
);
 
// デコレータの積み重ね（外側から内側へ適用）
const EnhancedUserList = withErrorBoundary(
  withAuth(
    withLoading(
      withPerformanceTracking(UserList, "UserList")
    )
  ),
  ErrorFallback
);
 
// 現代の React では Hooks が主流だが、
// HOC は条件付きレンダリングや Provider ラッピングでは依然有効

package main
 
import (
    "fmt"
    "log"
    "net/http"
    "time"
)
 
// === Middleware 型（Decorator の Go イディオム）===
type Middleware func(http.Handler) http.Handler
 
// === Middleware 1: ロギング ===
func LoggingMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        start := time.Now()
        log.Printf("→ %s %s", r.Method, r.URL.Path)
        next.ServeHTTP(w, r)
        log.Printf("← %s %s (%v)", r.Method, r.URL.Path, time.Since(start))
    })
}
 
// === Middleware 2: 認証 ===
func AuthMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        token := r.Header.Get("Authorization")
        if token == "" {
            http.Error(w, "Unauthorized", http.StatusUnauthorized)
            return
        }
        next.ServeHTTP(w, r)
    })
}
 
// === Middleware 3: リカバリ ===
func RecoveryMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        defer func() {
            if err := recover(); err != nil {
                log.Printf("Panic recovered: %v", err)
                http.Error(w, "Internal Server Error", http.StatusInternalServerError)
            }
        }()
        next.ServeHTTP(w, r)
    })
}
 
// === Middleware チェーン ===
func Chain(handler http.Handler, middlewares ...Middleware) http.Handler {
    // 逆順に適用（最初に指定したミドルウェアが最外側）
    for i := len(middlewares) - 1; i >= 0; i-- {
        handler = middlewaresi
    }
    return handler
}
 
// === 使用例 ===
func main() {
    handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        fmt.Fprintln(w, "Hello, World!")
    })
 
    // デコレータの積み重ね
    enhanced := Chain(handler,
        RecoveryMiddleware,
        LoggingMiddleware,
        AuthMiddleware,
    )
 
    http.Handle("/api/", enhanced)
    http.ListenAndServe(":8080", nil)
}

import java.io.*;
 
// Java の I/O ストリームは Decorator パターンの典型例
 
public class JavaIODecoratorExample {
 
    // === 読み込みの Decorator チェーン ===
    public static void readExample() throws IOException {
        // InputStream 階層:
        //   BufferedInputStream(Decorator)
        //     → DataInputStream(Decorator)
        //       → FileInputStream(ConcreteComponent)
 
        try (DataInputStream dis = new DataInputStream(
                new BufferedInputStream(
                    new FileInputStream("data.bin")))) {
            int value = dis.readInt();
            String text = dis.readUTF();
            System.out.println(value + " " + text);
        }
    }
 
    // === 書き込みの Decorator チェーン ===
    public static void writeExample() throws IOException {
        // OutputStream 階層:
        //   BufferedOutputStream(Decorator)
        //     → GZIPOutputStream(Decorator)
        //       → FileOutputStream(ConcreteComponent)
 
        try (var out = new BufferedOutputStream(
                new java.util.zip.GZIPOutputStream(
                    new FileOutputStream("output.gz")))) {
            out.write("Hello, compressed world!".getBytes());
        }
    }
 
    // === カスタム Decorator ===
    static class CountingInputStream extends FilterInputStream {
        private long bytesRead = 0;
 
        protected CountingInputStream(InputStream in) {
            super(in);
        }
 
        @Override
        public int read() throws IOException {
            int b = super.read();
            if (b != -1) bytesRead++;
            return b;
        }
 
        @Override
        public int read(byte[] b, int off, int len) throws IOException {
            int count = super.read(b, off, len);
            if (count > 0) bytesRead += count;
            return count;
        }
 
        public long getBytesRead() {
            return bytesRead;
        }
    }
}

// Kotlin のデリゲーションパターンで Decorator を実装
 
interface Logger {
    fun log(level: String, message: String)
    fun close()
}
 
class ConsoleLogger : Logger {
    override fun log(level: String, message: String) {
        println("[$level] $message")
    }
    override fun close() {}
}
 
// Kotlin の by キーワードによるデリゲーション
class TimestampLogger(private val inner: Logger) : Logger by inner {
    override fun log(level: String, message: String) {
        val timestamp = java.time.LocalDateTime.now()
        inner.log(level, "[$timestamp] $message")
    }
}
 
class FilterLogger(
    private val inner: Logger,
    private val minLevel: String
) : Logger by inner {
    private val levels = listOf("DEBUG", "INFO", "WARN", "ERROR")
 
    override fun log(level: String, message: String) {
        if (levels.indexOf(level) >= levels.indexOf(minLevel)) {
            inner.log(level, message)
        }
    }
}
 
// 積み重ね
fun main() {
    val logger: Logger = FilterLogger(
        TimestampLogger(ConsoleLogger()),
        "INFO"
    )
 
    logger.log("DEBUG", "This will be filtered")  // 出力なし
    logger.log("INFO", "Application started")      // 出力あり
    logger.log("ERROR", "Something went wrong")    // 出力あり
}

// クラスを使わず、関数合成でデコレータを実現
 
type AsyncFn<T> = (...args: any[]) => Promise<T>;
 
// === Decorator Factory 関数 ===
function withRetry<T>(fn: AsyncFn<T>, maxRetries = 3): AsyncFn<T> {
  return async (...args) => {
    for (let i = 0; i <= maxRetries; i++) {
      try {
        return await fn(...args);
      } catch (e) {
        if (i === maxRetries) throw e;
        await new Promise(r => setTimeout(r, 1000 * 2 ** i));
      }
    }
    throw new Error("Unreachable");
  };
}
 
function withTimeout<T>(fn: AsyncFn<T>, ms: number): AsyncFn<T> {
  return (...args) =>
    Promise.race([
      fn(...args),
      new Promise<never>((_, reject) =>
        setTimeout(() => reject(new Error("Timeout")), ms)
      ),
    ]);
}
 
function withLogging<T>(fn: AsyncFn<T>, name: string): AsyncFn<T> {
  return async (...args) => {
    console.log(`→ ${name}(${args.join(", ")})`);
    try {
      const result = await fn(...args);
      console.log(`← ${name}: success`);
      return result;
    } catch (e) {
      console.log(`✗ ${name}: ${e}`);
      throw e;
    }
  };
}
 
// === pipe ユーティリティ ===
function pipe<T>(
  fn: AsyncFn<T>,
  ...decorators: Array<(fn: AsyncFn<T>) => AsyncFn<T>>
): AsyncFn<T> {
  return decorators.reduce((acc, decorator) => decorator(acc), fn);
}
 
// === 使用例 ===
async function fetchUser(id: string): Promise<{ name: string }> {
  const res = await fetch(`/api/users/${id}`);
  return res.json();
}
 
// 関数合成でデコレータを積み重ね
const enhancedFetchUser = pipe(
  fetchUser,
  fn => withTimeout(fn, 5000),
  fn => withRetry(fn, 3),
  fn => withLogging(fn, "fetchUser"),
);
 
const user = await enhancedFetchUser("123");

import { Transform, TransformCallback, Readable, pipeline } from "stream";
import { promisify } from "util";
 
const pipelineAsync = promisify(pipeline);
 
// === Transform 1: JSON パース ===
class JsonParseTransform extends Transform {
  constructor() {
    super({ objectMode: true });
  }
 
  _transform(chunk: Buffer, _encoding: string, callback: TransformCallback): void {
    try {
      const parsed = JSON.parse(chunk.toString());
      this.push(parsed);
      callback();
    } catch (error) {
      callback(error as Error);
    }
  }
}
 
// === Transform 2: フィルタリング ===
class FilterTransform extends Transform {
  constructor(private predicate: (item: any) => boolean) {
    super({ objectMode: true });
  }
 
  _transform(chunk: any, _encoding: string, callback: TransformCallback): void {
    if (this.predicate(chunk)) {
      this.push(chunk);
    }
    callback();
  }
}
 
// === Transform 3: マッピング ===
class MapTransform extends Transform {
  constructor(private mapper: (item: any) => any) {
    super({ objectMode: true });
  }
 
  _transform(chunk: any, _encoding: string, callback: TransformCallback): void {
    try {
      this.push(this.mapper(chunk));
      callback();
    } catch (error) {
      callback(error as Error);
    }
  }
}
 
// === Transform 4: バッチ集約 ===
class BatchTransform extends Transform {
  private buffer: any[] = [];
 
  constructor(private batchSize: number) {
    super({ objectMode: true });
  }
 
  _transform(chunk: any, _encoding: string, callback: TransformCallback): void {
    this.buffer.push(chunk);
    if (this.buffer.length >= this.batchSize) {
      this.push([...this.buffer]);
      this.buffer = [];
    }
    callback();
  }
 
  _flush(callback: TransformCallback): void {
    if (this.buffer.length > 0) {
      this.push([...this.buffer]);
    }
    callback();
  }
}
 
// === パイプラインでデコレータをチェーン ===
async function processLogs(): Promise<void> {
  await pipelineAsync(
    Readable.from(logLines),           // ソース
    new JsonParseTransform(),           // JSON パース（Decorator 1）
    new FilterTransform(                // フィルタ（Decorator 2）
      log => log.level === "error"
    ),
    new MapTransform(                   // 変換（Decorator 3）
      log => ({ message: log.message, timestamp: log.ts })
    ),
    new BatchTransform(100),            // バッチ（Decorator 4）
    createWriteStream("errors.jsonl")   // 出力先
  );
}

// NG: 5層以上のデコレータ → デバッグ困難
const client = new MetricsDecorator(
  new CircuitBreakerDecorator(
    new RetryDecorator(
      new TimeoutDecorator(
        new LoggingDecorator(
          new AuthDecorator(
            new CacheDecorator(
              new FetchClient()
            )
          )
        )
      )
    )
  )
);
// 7層のネスト → スタックトレースが非常に深い

// OK: ミドルウェアパターンやパイプラインで宣言的に構成
const client = createHttpClient({
  middlewares: [
    metrics(),
    circuitBreaker({ threshold: 5 }),
    retry({ maxRetries: 3 }),
    timeout({ ms: 5000 }),
    logging(),
    auth({ tokenProvider }),
    cache({ ttl: 60000 }),
  ],
});

// NG: Component インタフェースにない getFilename() にキャストしてアクセス
class BadCachingDecorator implements DataSource {
  constructor(private wrapped: DataSource) {}
 
  read(): string {
    // 具象クラスに依存 → Decorator パターンの利点が失われる
    const name = (this.wrapped as FileDataSource).getFilename();
    const cached = this.cache.get(name);
    if (cached) return cached;
    return this.wrapped.read();
  }
 
  write(data: string): void {
    this.wrapped.write(data);
  }
}

// OK: Component インタフェースのみに依存
class GoodCachingDecorator implements DataSource {
  private cachedData: string | null = null;
 
  constructor(private wrapped: DataSource) {}
 
  read(): string {
    if (this.cachedData !== null) return this.cachedData;
    this.cachedData = this.wrapped.read();
    return this.cachedData;
  }
 
  write(data: string): void {
    this.cachedData = null; // キャッシュ無効化
    this.wrapped.write(data);
  }
}

// NG: デコレータの順序を間違えると壊れる
// 暗号化してから圧縮すると、暗号化データは圧縮効率が悪い
 
// 悪い順序（暗号化 → 圧縮: 圧縮効率が悪い）
const bad = new CompressionDecorator(
  new EncryptionDecorator(new FileDataSource("data.txt"))
);
 
// 良い順序（圧縮 → 暗号化: 圧縮効率が良い）
const good = new EncryptionDecorator(
  new CompressionDecorator(new FileDataSource("data.txt"))
);

// OK: Builder パターンで順序を制御し、ドキュメント化する
class DataSourceBuilder {
  private decorators: Array<(ds: DataSource) => DataSource> = [];
 
  constructor(private base: DataSource) {}
 
  // 圧縮 → 暗号化の順序を Builder が保証
  withCompressionAndEncryption(): this {
    this.decorators.push(ds => new CompressionDecorator(ds));
    this.decorators.push(ds => new EncryptionDecorator(ds));
    return this;
  }
 
  withLogging(): this {
    this.decorators.push(ds => new LoggingDecorator(ds));
    return this;
  }
 
  build(): DataSource {
    return this.decorators.reduce(
      (ds, decorator) => decorator(ds),
      this.base
    );
  }
}

// デコレータが例外を握りつぶすと、デバッグが困難になる
class SafeDecorator implements DataSource {
  constructor(private wrapped: DataSource) {}
 
  read(): string {
    try {
      return this.wrapped.read();
    } catch (error) {
      // NG: 例外を握りつぶして空文字を返す
      // return "";
 
      // OK: ログを出力してから再 throw
      console.error("Read failed:", error);
      throw error;
    }
  }
 
  write(data: string): void {
    this.wrapped.write(data);
  }
}

const base = new FileDataSource("data.txt");
const decorated = new LoggingDecorator(base);
 
// デコレータは元のオブジェクトとは別のインスタンス
console.log(decorated === base);           // false
console.log(decorated instanceof FileDataSource); // false
 
// Set や Map のキーとして使う場合に注意
const set = new Set<DataSource>();
set.add(base);
set.add(decorated);
console.log(set.size); // 2（同じ base を指すが別オブジェクト）

// 非同期デコレータでは、前後処理の順序に注意
class AsyncLoggingDecorator implements AsyncDataSource {
  constructor(private wrapped: AsyncDataSource) {}
 
  async read(): Promise<string> {
    console.log("Before read");
    const result = await this.wrapped.read();
    console.log("After read"); // await の後なので確実に後処理
    return result;
  }
}

// テスト
const processor: TextProcessor = new CensorDecorator(
  new TrimDecorator(
    new UpperCaseDecorator(
      new PlainTextProcessor()
    )
  ),
  ["bad", "ugly"]
);
 
console.log(processor.process("  Hello bad World  "));
// "HELLO *** WORLD"