@hraness/dawg 0.0.0-stage → 0.2.0

package/tui/input.ts

@@ -0,0 +1,63 @@
+/**
+ * Incremental decoder for the small set of terminal sequences dawg accepts.
+ * PTYs may split one CSI sequence across reads or combine several key events
+ * into one read, so the main loop must consume framed events rather than raw
+ * chunks.
+ */
+export type TerminalInputEvent =
+  string | Readonly<{ type: "paste"; text: string }>;
+
+export class TerminalInputDecoder {
+  private buffer = "";
+
+  push(chunk: string): TerminalInputEvent[] {
+    this.buffer += chunk;
+    const events: TerminalInputEvent[] = [];
+    while (this.buffer.length > 0) {
+      if (this.buffer.startsWith("\u001b[200~")) {
+        const end = this.buffer.indexOf("\u001b[201~", 6);
+        if (end < 0) break;
+        events.push({ type: "paste", text: this.buffer.slice(6, end) });
+        this.buffer = this.buffer.slice(end + 6);
+        continue;
+      }
+
+      if (this.buffer[0] === "\u001b") {
+        const sequence = this.readEscapeSequence();
+        if (sequence === undefined) break;
+        events.push(sequence);
+        this.buffer = this.buffer.slice(sequence.length);
+        continue;
+      }
+
+      const codePoint = Array.from(this.buffer)[0];
+      if (codePoint === undefined) break;
+      events.push(codePoint);
+      this.buffer = this.buffer.slice(codePoint.length);
+    }
+    return events;
+  }
+
+  flush(): TerminalInputEvent[] {
+    if (this.buffer === "\u001b") {
+      this.buffer = "";
+      return ["\u001b"];
+    }
+    return [];
+  }
+
+  private readEscapeSequence(): string | undefined {
+    if (this.buffer.length === 1) return undefined;
+    if (this.buffer.startsWith("\u001b\r")) return "\u001b\r";
+    // ESC followed by another control key (or ESC) is a lone Esc press that
+    // shared a read with the next key, e.g. Esc then Ctrl+Z.
+    const next = this.buffer.charCodeAt(1);
+    if (next < 0x20 || next === 0x7f) return "\u001b";
+    const final = this.buffer.match(/^\u001b\[[\x20-?]*[\x40-~]/)?.[0];
+    if (final !== undefined) return final;
+    // An unrecognised Alt-prefixed character is still one complete event.
+    if (this.buffer.length >= 2 && this.buffer[1] !== "[")
+      return this.buffer.slice(0, 2);
+    return undefined;
+  }
+}

package/tui/keys.ts

@@ -0,0 +1,102 @@
+/**
+ * Map decoded terminal sequences to prompt keys and TUI commands.
+ *
+ * The prompt is always focused, so printable keys always type.  Control
+ * chords carry the global actions:
+ *   Ctrl+C quit · Ctrl+Q toggle STEER/QUEUE · Ctrl+Z undo · Ctrl+Y redo
+ *   Ctrl+O transcript overlay · Esc closes the overlay
+ */
+
+import type { PromptKey } from "./prompt.ts";
+
+export type UiCommand =
+  "quit" | "undo" | "redo" | "toggle-log" | "close-overlay" | "redraw";
+
+export type KeyResult =
+  | { type: "prompt"; key: PromptKey }
+  | { type: "text"; text: string }
+  | { type: "ui"; command: UiCommand }
+  | { type: "ignore" };
+
+const PROMPT_SEQUENCES: Record<string, string> = {
+  "\u001b[13;2u": "SHIFT+ENTER",
+  "\u001b[27;2;13~": "SHIFT+ENTER",
+  // Many terminals send ESC CR (Alt+Enter) for Shift+Enter when configured;
+  // dawg treats Alt+Enter as "queue this prompt".
+  "\u001b\r": "ALT+ENTER",
+  "\u0011": "CTRL+Q",
+  "\u007f": "BACKSPACE",
+  "\b": "BACKSPACE",
+  "\r": "ENTER",
+  "\n": "SHIFT+ENTER",
+  "\u001b[A": "UP",
+  "\u001bOA": "UP",
+  "\u001b[B": "DOWN",
+  "\u001bOB": "DOWN",
+  "\u001b[C": "RIGHT",
+  "\u001bOC": "RIGHT",
+  "\u001b[D": "LEFT",
+  "\u001bOD": "LEFT",
+  "\u001b[H": "HOME",
+  "\u001b[1~": "HOME",
+  "\u0001": "HOME",
+  "\u001b[F": "END",
+  "\u001b[4~": "END",
+  "\u0005": "END",
+  "\u001b[3~": "DELETE",
+  "\u001b[1;5D": "CTRL+LEFT",
+  "\u001bb": "CTRL+LEFT",
+  "\u001b[1;5C": "CTRL+RIGHT",
+  "\u001bf": "CTRL+RIGHT",
+  "\u001b[1;5H": "CTRL+HOME",
+  "\u001b[1;5F": "CTRL+END",
+};
+
+const UI_SEQUENCES: Record<string, UiCommand> = {
+  "\u0003": "quit",
+  "\u001a": "undo",
+  "\u0019": "redo",
+  "\u000f": "toggle-log",
+  "\u000c": "redraw",
+};
+
+export function classifyKey(value: string): KeyResult {
+  const ui = UI_SEQUENCES[value];
+  if (ui) return { type: "ui", command: ui };
+  if (value.startsWith("\u001b[200~") && value.endsWith("\u001b[201~"))
+    return { type: "prompt", key: { type: "paste", text: value.slice(6, -6) } };
+  const key = PROMPT_SEQUENCES[value];
+  if (key) return { type: "prompt", key };
+  if (value === "\u001b") return { type: "ui", command: "close-overlay" };
+  if (value.startsWith("\u001b")) return { type: "ignore" };
+  // Strip other C0 controls so stray chords never insert garbage.
+  const text = Array.from(value)
+    .filter((character) => {
+      const code = character.codePointAt(0) ?? 0;
+      return code >= 0x20 && code !== 0x7f;
+    })
+    .join("");
+  return text ? { type: "text", text } : { type: "ignore" };
+}
+
+export type OverlayKey =
+  "up" | "down" | "pgup" | "pgdn" | "home" | "end" | "enter";
+
+const OVERLAY_SEQUENCES: Record<string, OverlayKey> = {
+  "\u001b[A": "up",
+  "\u001bOA": "up",
+  "\u001b[B": "down",
+  "\u001bOB": "down",
+  "\u001b[5~": "pgup",
+  "\u001b[6~": "pgdn",
+  "\u001b[H": "home",
+  "\u001b[1~": "home",
+  "\u001b[F": "end",
+  "\u001b[4~": "end",
+  "\r": "enter",
+};
+
+/** Navigation keys an open overlay (transcript, picker) consumes. */
+export function overlayKey(value: string): OverlayKey | undefined {
+  return OVERLAY_SEQUENCES[value];
+}

package/tui/layers.ts

@@ -0,0 +1,68 @@
+/**
+ * Multi-track highway: every other audible track as a dimmed overlay layer.
+ * Solo rules match the mixer: when any track is soloed, only soloed unmuted
+ * tracks are drawn.
+ */
+import { DRUM_VOICES, drumLane, isDrumInstrument } from "../core/drums.ts";
+import {
+  drumLaneProjection,
+  MAX_LAYER_NOTES,
+  type HighwayLayer,
+} from "./highway.ts";
+
+export interface LayerTrack {
+  id: string;
+  name: string;
+  instrument: string;
+  muted: boolean;
+  solo?: boolean | undefined;
+}
+
+export interface LayerNote {
+  trackId: string;
+  startTick: number;
+  durationTicks: number;
+  pitch: number;
+  velocity: number;
+}
+
+export function highwayLayers(
+  tracks: readonly LayerTrack[],
+  notes: readonly LayerNote[],
+  ticksPerBeat: number,
+  focusedTrackId: string,
+): HighwayLayer[] {
+  const soloing = tracks.some((track) => track.solo && !track.muted);
+  const audible = tracks.filter(
+    (track) =>
+      track.id !== focusedTrackId &&
+      !track.muted &&
+      (!soloing || track.solo === true),
+  );
+  const tpb = Math.max(1, ticksPerBeat);
+  let budget = MAX_LAYER_NOTES;
+  return audible.map((track) => {
+    const drum = isDrumInstrument(track.instrument);
+    const own = [];
+    for (const note of notes) {
+      if (note.trackId !== track.id) continue;
+      if (budget <= 0) break;
+      budget -= 1;
+      own.push({
+        startBeat: note.startTick / tpb,
+        durationBeats: note.durationTicks / tpb,
+        pitch: note.pitch,
+        velocity: note.velocity,
+        ...(drum ? { lane: drumLane(note.pitch) } : {}),
+      });
+    }
+    return {
+      trackId: track.id,
+      trackName: track.name,
+      notes: own,
+      projection: drum
+        ? drumLaneProjection(DRUM_VOICES.map((info) => info.label))
+        : undefined,
+    };
+  });
+}