项目实战：类型安全的任务 CLI

class NaiveBus {
  on(type: string, fn: (payload: any) => void): void { /* ... */ }
  emit(type: string, payload: any): void { /* ... */ }
}

type AppEvents = {
  "user:login": { id: number; name: string };
  "user:logout": { id: number };
};

type EventMap = Record<string, unknown>;
 
class EventBus<E extends EventMap> {
  private readonly handlers = new Map<keyof E, ((payload: never) => void)[]>();
 
  on<K extends keyof E>(type: K, fn: (payload: E[K]) => void): () => void {
    const list: ((payload: never) => void)[] = this.handlers.get(type) ?? [];
    list.push(fn);
    this.handlers.set(type, list);
    return () => {
      this.off(type, fn);
    };
  }
 
  once<K extends keyof E>(type: K, fn: (payload: E[K]) => void): void {
    const wrapper: (payload: E[K]) => void = (payload) => {
      this.off(type, wrapper);
      fn(payload);
    };
    this.on(type, wrapper);
  }
 
  off<K extends keyof E>(type: K, fn: (payload: E[K]) => void): void {
    const list = this.handlers.get(type);
    if (list === undefined) return;
    const i = list.indexOf(fn);
    if (i >= 0) list.splice(i, 1);
  }
 
  emit<K extends keyof E>(type: K, payload: E[K]): void {
    const list = this.handlers.get(type);
    if (list === undefined) return;
    for (const fn of list.slice()) {
      (fn as unknown as (p: E[K]) => void)(payload);
    }
  }
 
  count(type: keyof E): number {
    return this.handlers.get(type)?.length ?? 0;
  }
}
 
// ---- 使用 ----
type AppEvents = {
  "user:login": { id: number; name: string };
  "user:logout": { id: number };
  "metric": { key: string; value: number };
};
 
const bus = new EventBus<AppEvents>();
 
const offLogin = bus.on("user:login", (p) => {
  console.log("登录:", p.name, "id=" + p.id);
});
bus.on("metric", (p) => {
  console.log("指标:", p.key, "=", p.value);
});
bus.once("user:logout", (p) => {
  console.log("登出（只触发一次）:", p.id);
});
 
bus.emit("user:login", { id: 1, name: "Ada" });
bus.emit("metric", { key: "latency_ms", value: 12 });
bus.emit("user:logout", { id: 1 });
bus.emit("user:logout", { id: 1 });
 
offLogin();
bus.emit("user:login", { id: 2, name: "Grace" });
 
console.log("剩余订阅: login =", bus.count("user:login"), ", metric =", bus.count("metric"));
 
// 下面几行如果取消注释，都会在编译期被拦下：
// bus.emit("user:login", { id: 3 });     // 缺少 name
// bus.emit("user:signup", { id: 3 });    // 事件名不存在
// bus.on("metric", (p) => p.missing);    // 载荷上没有这个字段
console.log("类型契约生效");

type Task = {
  readonly id: number;
  readonly title: string;
  readonly done: boolean;
  readonly tags: readonly string[];
};
 
type Ok<T> = { ok: true; value: T };
type Err = { ok: false; error: string };
type Result<T> = Ok<T> | Err;
 
function ok<T>(value: T): Ok<T> {
  return { ok: true, value };
}
function err(error: string): Err {
  return { ok: false, error };
}
 
type Filter = { done?: boolean; tag?: string };
 
class TaskStore {
  private readonly tasks = new Map<number, Task>();
  private nextId = 1;
 
  add(title: string, tags: readonly string[] = []): Result<Task> {
    const trimmed = title.trim();
    if (trimmed === "") return err("标题不能为空");
    if (trimmed.length > 60) return err("标题最多 60 个字符");
    const task: Task = { id: this.nextId, title: trimmed, done: false, tags: [...tags] };
    this.nextId += 1;
    this.tasks.set(task.id, task);
    return ok(task);
  }
 
  complete(id: number): Result<Task> {
    const cur = this.tasks.get(id);
    if (cur === undefined) return err("任务 " + id + " 不存在");
    if (cur.done) return err("任务 " + id + " 已经完成过了");
    const updated: Task = { ...cur, done: true };
    this.tasks.set(id, updated);
    return ok(updated);
  }
 
  remove(id: number): Result<number> {
    if (!this.tasks.delete(id)) return err("任务 " + id + " 不存在");
    return ok(id);
  }
 
  list(filter?: Filter): Task[] {
    let items = [...this.tasks.values()];
    if (filter !== undefined) {
      const wantDone = filter.done;
      if (wantDone !== undefined) items = items.filter((t) => t.done === wantDone);
      const tag = filter.tag;
      if (tag !== undefined) items = items.filter((t) => t.tags.includes(tag));
    }
    return items;
  }
 
  stats(): { total: number; done: number; pending: number } {
    const all = [...this.tasks.values()];
    const done = all.filter((t) => t.done).length;
    return { total: all.length, done, pending: all.length - done };
  }
}
 
// ---- 演示 ----
const store = new TaskStore();
 
const inputs: { title: string; tags: string[] }[] = [
  { title: "写完 TypeScript 教程", tags: ["docs", "ts"] },
  { title: "准备周会材料", tags: ["work"] },
  { title: "   ", tags: [] },
];
 
for (const input of inputs) {
  const r = store.add(input.title, input.tags);
  console.log(r.ok ? "添加成功 #" + r.value.id + " " + r.value.title : "添加失败: " + r.error);
}
 
const done1 = store.complete(1);
console.log(done1.ok ? "已完成: " + done1.value.title : "错误: " + done1.error);
 
const done2 = store.complete(1);
console.log(done2.ok ? "已完成: " + done2.value.title : "错误: " + done2.error);
 
const gone = store.remove(99);
console.log(gone.ok ? "已删除" : "错误: " + gone.error);
 
console.log("全部:", store.list().map((t) => t.title).join(" / "));
console.log("已完成:", store.list({ done: true }).map((t) => t.title).join(" / "));
console.log("按标签 work:", store.list({ tag: "work" }).map((t) => t.title).join(" / "));
console.log("统计:", JSON.stringify(store.stats()));

type CommandSpec<A> = {
  name: string;
  usage: string;
  parse: (argv: readonly string[]) => Result<A>;
  run: (args: A, ctx: Ctx) => Result<string[]>;
};
 
type AnyCommand = {
  name: string;
  usage: string;
  exec: (argv: readonly string[], ctx: Ctx) => Result<string[]>;
};
 
function defineCommand<A>(spec: CommandSpec<A>): AnyCommand {
  return {
    name: spec.name,
    usage: spec.usage,
    exec: (argv, ctx) => {
      const parsed = spec.parse(argv);
      return parsed.ok ? spec.run(parsed.value, ctx) : parsed;
    },
  };
}

// ===================== 1. Result =====================
type Ok<T> = { ok: true; value: T };
type Err = { ok: false; error: string };
type Result<T> = Ok<T> | Err;
 
function ok<T>(value: T): Ok<T> {
  return { ok: true, value };
}
function err(error: string): Err {
  return { ok: false, error };
}
 
// 安全取下标，兼容开启 noUncheckedIndexedAccess 的项目
function at(argv: readonly string[], i: number): string | undefined {
  return i < argv.length ? argv[i] : undefined;
}
 
// ===================== 2. 事件总线 =====================
class EventBus<E extends Record<string, unknown>> {
  private readonly handlers = new Map<keyof E, ((payload: never) => void)[]>();
 
  on<K extends keyof E>(type: K, fn: (payload: E[K]) => void): void {
    const list: ((payload: never) => void)[] = this.handlers.get(type) ?? [];
    list.push(fn);
    this.handlers.set(type, list);
  }
 
  emit<K extends keyof E>(type: K, payload: E[K]): void {
    const list = this.handlers.get(type);
    if (list === undefined) return;
    for (const fn of list.slice()) {
      (fn as unknown as (p: E[K]) => void)(payload);
    }
  }
}
 
// ===================== 3. 领域模型 =====================
type Task = {
  readonly id: number;
  readonly title: string;
  readonly done: boolean;
  readonly tags: readonly string[];
};
 
type AppEvents = {
  "task:added": { task: Task };
  "task:completed": { task: Task };
  "task:removed": { id: number };
  "command:failed": { command: string; reason: string };
};
 
type Filter = { done?: boolean; tag?: string };
 
class TaskStore {
  private readonly tasks = new Map<number, Task>();
  private nextId = 1;
 
  constructor(private readonly bus: EventBus<AppEvents>) {}
 
  add(title: string, tags: readonly string[]): Result<Task> {
    const trimmed = title.trim();
    if (trimmed === "") return err("标题不能为空");
    if (trimmed.length > 60) return err("标题最多 60 个字符");
    const task: Task = { id: this.nextId, title: trimmed, done: false, tags: [...tags] };
    this.nextId += 1;
    this.tasks.set(task.id, task);
    this.bus.emit("task:added", { task });
    return ok(task);
  }
 
  complete(id: number): Result<Task> {
    const cur = this.tasks.get(id);
    if (cur === undefined) return err("任务 " + id + " 不存在");
    if (cur.done) return err("任务 " + id + " 已经完成过了");
    const updated: Task = { ...cur, done: true };
    this.tasks.set(id, updated);
    this.bus.emit("task:completed", { task: updated });
    return ok(updated);
  }
 
  remove(id: number): Result<number> {
    if (!this.tasks.delete(id)) return err("任务 " + id + " 不存在");
    this.bus.emit("task:removed", { id });
    return ok(id);
  }
 
  list(filter: Filter): Task[] {
    let items = [...this.tasks.values()];
    const wantDone = filter.done;
    if (wantDone !== undefined) items = items.filter((t) => t.done === wantDone);
    const tag = filter.tag;
    if (tag !== undefined) items = items.filter((t) => t.tags.includes(tag));
    return items;
  }
 
  stats(): { total: number; done: number; pending: number } {
    const all = [...this.tasks.values()];
    const done = all.filter((t) => t.done).length;
    return { total: all.length, done, pending: all.length - done };
  }
}
 
// ===================== 4. 命令注册表 =====================
type Ctx = { store: TaskStore; bus: EventBus<AppEvents> };
 
type CommandSpec<A> = {
  name: string;
  usage: string;
  parse: (argv: readonly string[]) => Result<A>;
  run: (args: A, ctx: Ctx) => Result<string[]>;
};
 
type AnyCommand = {
  name: string;
  usage: string;
  exec: (argv: readonly string[], ctx: Ctx) => Result<string[]>;
};
 
function defineCommand<A>(spec: CommandSpec<A>): AnyCommand {
  return {
    name: spec.name,
    usage: spec.usage,
    exec: (argv, ctx) => {
      const parsed = spec.parse(argv);
      return parsed.ok ? spec.run(parsed.value, ctx) : parsed;
    },
  };
}
 
function render(t: Task): string {
  const box = t.done ? "[x]" : "[ ]";
  const tags = t.tags.length > 0 ? "  " + t.tags.map((x) => "#" + x).join(" ") : "";
  return box + " #" + t.id + " " + t.title + tags;
}
 
const commands: AnyCommand[] = [];
 
const addCmd = defineCommand<{ title: string; tags: string[] }>({
  name: "add",
  usage: "add 标题文字 [#标签...]     新增任务",
  parse: (argv) => {
    const tags = argv.filter((w) => w.startsWith("#")).map((w) => w.slice(1));
    const title = argv.filter((w) => !w.startsWith("#")).join(" ").trim();
    if (title === "") return err("add 需要一个标题");
    return ok({ title, tags });
  },
  run: (args, ctx) => {
    const r = ctx.store.add(args.title, args.tags);
    return r.ok ? ok(["已新增 " + render(r.value)]) : err(r.error);
  },
});
 
const doneCmd = defineCommand<{ id: number }>({
  name: "done",
  usage: "done 编号                  标记完成",
  parse: (argv) => {
    const raw = at(argv, 0);
    if (raw === undefined) return err("done 需要一个任务编号");
    const id = Number(raw);
    if (!Number.isInteger(id) || id <= 0) return err("非法编号: " + raw);
    return ok({ id });
  },
  run: (args, ctx) => {
    const r = ctx.store.complete(args.id);
    return r.ok ? ok(["已完成 " + render(r.value)]) : err(r.error);
  },
});
 
const rmCmd = defineCommand<{ id: number }>({
  name: "rm",
  usage: "rm 编号                    删除任务",
  parse: (argv) => {
    const raw = at(argv, 0);
    if (raw === undefined) return err("rm 需要一个任务编号");
    const id = Number(raw);
    if (!Number.isInteger(id) || id <= 0) return err("非法编号: " + raw);
    return ok({ id });
  },
  run: (args, ctx) => {
    const r = ctx.store.remove(args.id);
    return r.ok ? ok(["已删除 #" + r.value]) : err(r.error);
  },
});
 
const lsCmd = defineCommand<Filter>({
  name: "ls",
  usage: "ls [--done|--pending] [#标签]  列出任务",
  parse: (argv) => {
    const filter: Filter = {};
    for (const a of argv) {
      if (a === "--done") filter.done = true;
      else if (a === "--pending") filter.done = false;
      else if (a.startsWith("#")) filter.tag = a.slice(1);
      else return err("ls 不认识的参数: " + a);
    }
    return ok(filter);
  },
  run: (args, ctx) => {
    const items = ctx.store.list(args);
    return ok(items.length === 0 ? ["(没有匹配的任务)"] : items.map(render));
  },
});
 
const statsCmd = defineCommand<null>({
  name: "stats",
  usage: "stats                      查看统计",
  parse: () => ok(null),
  run: (_args, ctx) => {
    const s = ctx.store.stats();
    return ok(["共 " + s.total + " 条，已完成 " + s.done + " 条，待办 " + s.pending + " 条"]);
  },
});
 
const helpCmd = defineCommand<null>({
  name: "help",
  usage: "help                       显示帮助",
  parse: () => ok(null),
  run: () => ok(["可用命令:", ...commands.map((c) => "  " + c.usage)]),
});
 
commands.push(addCmd, doneCmd, rmCmd, lsCmd, statsCmd, helpCmd);
 
// ===================== 5. 调度器 =====================
class Cli {
  private readonly table = new Map<string, AnyCommand>();
 
  constructor(private readonly ctx: Ctx, cmds: readonly AnyCommand[]) {
    for (const c of cmds) this.table.set(c.name, c);
  }
 
  dispatch(line: string): void {
    const parts = line.trim().split(" ").filter((p) => p !== "");
    const name = at(parts, 0);
    if (name === undefined) return;
    const cmd = this.table.get(name);
    if (cmd === undefined) {
      console.log("  [错误] 未知命令 " + name + "，输入 help 查看用法");
      this.ctx.bus.emit("command:failed", { command: name, reason: "未知命令" });
      return;
    }
    const res = cmd.exec(parts.slice(1), this.ctx);
    if (res.ok) {
      for (const out of res.value) console.log("  " + out);
    } else {
      console.log("  [错误] " + res.error);
      this.ctx.bus.emit("command:failed", { command: name, reason: res.error });
    }
  }
}
 
// ===================== 6. 组装并运行 =====================
const bus = new EventBus<AppEvents>();
bus.on("task:added", (p) => console.log("  · 事件 task:added -> " + p.task.title));
bus.on("task:completed", (p) => console.log("  · 事件 task:completed -> " + p.task.title));
bus.on("task:removed", (p) => console.log("  · 事件 task:removed -> #" + p.id));
bus.on("command:failed", (p) => console.log("  · 事件 command:failed -> " + p.command + ": " + p.reason));
 
const store = new TaskStore(bus);
const cli = new Cli({ store, bus }, commands);
 
const script: string[] = [
  "add 写完 TypeScript 教程 #docs #ts",
  "add 准备周会材料 #work",
  "add 买咖啡豆",
  "ls",
  "done 2",
  "done 2",
  "rm 3",
  "rm 99",
  "ls --pending",
  "ls #ts",
  "stats",
  "fly",
  "help",
];
 
for (const line of script) {
  console.log("$ " + line);
  cli.dispatch(line);
}
console.log("脚本执行完毕");