设计tracer

src/tracers.ts/commander/index.ts

@@ -1,7 +1,7 @@
 import type { TracerCommand } from "../types/command";
 
 export class Commander {
-  private commands: TracerCommand[];
+  private commands: TracerCommand<unknown>[];
 
   private constructor() {
     this.commands = [];
@@ -16,7 +16,7 @@ export class Commander {
     return this.instance;
   }
 
-  public command(command: TracerCommand) {
+  public command<T = never>(command: TracerCommand<T>) {
     this.commands.push(command);
   }
 

src/tracers.ts/tracers/array-tracer.ts

@@ -21,8 +21,8 @@ export class ArrayTracer<T> {
     registry.register("ArrayTracer", arrayTracer.tracerId);
     const commander = Commander.getInstance();
     commander.command({
-      tracer: null,
       action: "define",
+      tracer: null,
       params: {
         type: "ArrayTracer",
         id: arrayTracer.tracerId,
@@ -35,21 +35,63 @@ export class ArrayTracer<T> {
   public preset(array: T[]) {
     const commander = Commander.getInstance();
     commander.command({
-      tracer: this.tracerId,
       action: "preset",
+      tracer: this.tracerId,
       params: array,
     });
   }
 
-  public expand(size: number) {}
+  public extend(size: number) {
+    const commander = Commander.getInstance();
+    commander.command({
+      action: "extend",
+      tracer: this.tracerId,
+      params: { size },
+    });
+  }
 
-  public reduce(size: number) {}
+  public shrink(size: number) {
+    const commander = Commander.getInstance();
+    commander.command({
+      action: "shrink",
+      tracer: this.tracerId,
+      params: { size },
+    });
+  }
 
-  public pick(index: number) {}
+  public pick(index: number) {
+    const commander = Commander.getInstance();
+    commander.command({
+      action: "pick",
+      tracer: this.tracerId,
+      params: { index },
+    });
+  }
 
-  public drop(index: number) {}
+  public drop(index: number) {
+    const commander = Commander.getInstance();
+    commander.command({
+      action: "drop",
+      tracer: this.tracerId,
+      params: { index },
+    });
+  }
 
-  public patch(index: number, value: T) {}
+  public patch(index: number, value: T) {
+    const commander = Commander.getInstance();
+    commander.command({
+      action: "patch",
+      tracer: this.tracerId,
+      params: { index, value },
+    });
+  }
 
-  public reset(index: number) {}
+  public reset(index: number) {
+    const commander = Commander.getInstance();
+    commander.command({
+      action: "reset",
+      tracer: this.tracerId,
+      params: { index },
+    });
+  }
 }

src/tracers.ts/types/command/array-tracer-command.ts

@@ -1,52 +1,52 @@
 export type ArrayTracerDefineCommand = {
-  tracer: null;
   action: "define";
+  tracer: null;
   params: { type: "ArrayTracer"; id: string; desc?: string };
 };
 
 export type ArrayTracerPresetCommand<T = unknown> = {
-  tracer: string;
   action: "preset";
+  tracer: string;
   params: T[];
 };
 
 export type ArrayTracerExtendCommand = {
-  tracer: string;
   action: "extend";
+  tracer: string;
   params: { size: number };
 };
 
 export type ArrayTracerShrinkCommand = {
-  tracer: string;
   action: "shrink";
+  tracer: string;
   params: { size: number };
 };
 
 export type ArrayTracerPickCommand = {
-  tracer: string;
   action: "pick";
+  tracer: string;
   params: { index: number };
 };
 
 export type ArrayTracerDropCommand = {
-  tracer: string;
   action: "drop";
+  tracer: string;
   params: { index: number };
 };
 
 export type ArrayTracerPatchCommand<T = unknown> = {
-  tracer: string;
   action: "patch";
+  tracer: string;
   params: { index: number; value: T };
 };
 
 export type ArrayTracerResetCommand = {
-  tracer: string;
   action: "reset";
-  params: null;
+  tracer: string;
+  params: { index: number };
 };
 
-export type ArrayTracerCommand<T = unknown> =
+export type ArrayTracerCommand<T = never> =
   | ArrayTracerDefineCommand
   | ArrayTracerPresetCommand<T>
   | ArrayTracerExtendCommand

src/tracers.ts/types/command/index.ts

@@ -2,4 +2,4 @@ import type { ArrayTracerCommand } from "./array-tracer-command";
 
 export * from "./array-tracer-command";
 
-export type TracerCommand = ArrayTracerCommand
+export type TracerCommand<T = never> = ArrayTracerCommand<T>;