第8章：类的高级能力 —— 继承、抽象、混入与装饰器

async function checkout(method: PaymentMethod, amount: number): Promise<string> {
  return method.pay(amount);
}

class Session {
  public readonly id: string;
  protected expiresAt: Date;
  private token: string;

  constructor(id: string, token: string, expiresAt: Date) {
    this.id = id;
    this.token = token;
    this.expiresAt = expiresAt;
  }
}

class SecureSession {
  #token: string;

  constructor(token: string) {
    this.#token = token;
  }
}

abstract class Job {
  async run(): Promise<void> {
    await this.beforeRun();
    await this.execute();
    await this.afterRun();
  }

  protected async beforeRun(): Promise<void> {}
  protected abstract execute(): Promise<void>;
  protected async afterRun(): Promise<void> {}
}

interface Logger {
  log(message: string): void;
}

interface Repository<T> {
  save(value: T): Promise<void>;
}

class UserService {
  constructor(
    private readonly repository: Repository<User>,
    private readonly logger: Logger
  ) {}
}

type Constructor<T = object> = new (...args: any[]) => T;

function Timestamped<TBase extends Constructor>(Base: TBase) {
  return class extends Base {
    createdAt = new Date();
  };
}

class Entity {
  constructor(public id: string) {}
}

class TimestampedEntity extends Timestamped(Entity) {}

function logged<This, Args extends unknown[], Return>(
  original: (this: This, ...args: Args) => Return,
  context: ClassMethodDecoratorContext<This, (this: This, ...args: Args) => Return>
) {
  return function (this: This, ...args: Args): Return {
    console.log(`调用 ${String(context.name)}`);
    return original.call(this, ...args);
  };
}

class Calculator {
  @logged
  add(left: number, right: number): number {
    return left + right;
  }
}

function createPayment(kind: "card" | "wallet"): PaymentMethod {
  return kind === "card" ? new CardPayment() : new WalletPayment();
}

type DiscountStrategy = (amount: number) => number;

type Listener<T> = (event: T) => void;

class EventBus<T> {
  private listeners = new Set<Listener<T>>();

  subscribe(listener: Listener<T>): () => void {
    this.listeners.add(listener);
    return () => this.listeners.delete(listener);
  }

  emit(event: T): void {
    for (const listener of this.listeners) listener(event);
  }
}

if (method instanceof CardPayment) {
  // 运行时可判断
}