@hraness/dawg 0.0.0-stage → 0.3.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,80 @@
+/**
+ * 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";
+import { samplerLanes } from "./drums.ts";
+import type { Sampler } from "../core/score.ts";
+
+export interface LayerTrack {
+  id: string;
+  name: string;
+  instrument: string;
+  muted: boolean;
+  solo?: boolean | undefined;
+  sampler?: Sampler | 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 sampled = drum ? undefined : samplerLanes(track);
+    const own = [];
+    for (const note of notes) {
+      if (note.trackId !== track.id) continue;
+      if (budget <= 0) break;
+      const lane = drum
+        ? drumLane(note.pitch)
+        : sampled
+          ? sampled.laneOf(note.pitch)
+          : undefined;
+      if (sampled && lane === undefined) continue;
+      budget -= 1;
+      own.push({
+        startBeat: note.startTick / tpb,
+        durationBeats: note.durationTicks / tpb,
+        pitch: note.pitch,
+        velocity: note.velocity,
+        ...(lane !== undefined ? { lane } : {}),
+      });
+    }
+    return {
+      trackId: track.id,
+      trackName: track.name,
+      notes: own,
+      projection: drum
+        ? drumLaneProjection(DRUM_VOICES.map((info) => info.label))
+        : sampled
+          ? drumLaneProjection(sampled.labels)
+          : undefined,
+    };
+  });
+}

package/tui/play-strip.ts

@@ -0,0 +1,143 @@
+/**
+ * Play mode's two fixed rows: the header (`PLAY  C3–F4  vel 100  ● REC
+ * click ✓` plus a beat flash) and a one-line keyboard strip with the keys
+ * that are sounding lit. Both repaint in place every frame, so playing never
+ * scrolls the transcript.
+ */
+import type { CellBuffer } from "./screen.ts";
+import { displayWidth, truncate } from "./text.ts";
+import { onBackground, type Theme } from "./theme.ts";
+
+export type PlayStripKey = Readonly<{
+  key: string;
+  label: string;
+  black: boolean;
+  lit: boolean;
+}>;
+
+export type PlayHeaderView = Readonly<{
+  /** `C3–F4`. */
+  range: string;
+  velocity: number;
+  /** Record armed. */
+  armed: boolean;
+  /** Recording right now (armed and the transport is running). */
+  recording: boolean;
+  replace: boolean;
+  click: boolean;
+  sustain: boolean;
+  /** `count-in 3` while counting in. */
+  countIn?: string | undefined;
+  /** Beat within the bar (1-based) and whether it is the flash window. */
+  beat?: Readonly<{ index: number; of: number; flash: boolean }> | undefined;
+  /** `grid 1/16`. */
+  grid: string;
+  /** Short status (`octave C2`, `no audio`). */
+  status?: string | undefined;
+  keys: readonly PlayStripKey[];
+}>;
+
+/** Text of the header row, for tests and narrow terminals. */
+export function playHeaderText(view: PlayHeaderView, unicode = true): string {
+  const parts = [
+    "PLAY",
+    view.range,
+    `vel ${view.velocity}`,
+    view.armed
+      ? `${unicode ? "●" : "*"} ${view.recording ? "REC" : "rec armed"}${view.replace ? " replace" : ""}`
+      : "",
+    `click ${view.click ? (unicode ? "✓" : "on") : "off"}`,
+    view.sustain ? "SUSTAIN" : "",
+    view.grid,
+    view.countIn ?? "",
+  ].filter(Boolean);
+  return parts.join("  ");
+}
+
+export function paintPlayHeader(
+  buffer: CellBuffer,
+  y: number,
+  width: number,
+  view: PlayHeaderView,
+  theme: Theme,
+  unicode: boolean,
+): void {
+  const roles = theme.roles;
+  const panel = roles.panel;
+  buffer.fill(0, y, width, 1, panel);
+  let x = 1;
+  const put = (text: string, style = roles.text) => {
+    if (x >= width - 1) return;
+    x += buffer.text(
+      x,
+      y,
+      truncate(text, Math.max(1, width - x - 1)),
+      onBackground(style, panel),
+    );
+    x += buffer.text(x, y, "  ", panel);
+  };
+  put(" PLAY ", roles.pillSteer);
+  put(view.range, { ...roles.text, bold: true });
+  put(`vel ${view.velocity}`);
+  if (view.armed)
+    put(
+      `${unicode ? "●" : "*"} ${view.recording ? "REC" : "rec armed"}${view.replace ? " replace" : ""}`,
+      view.recording ? roles.error : roles.warning,
+    );
+  put(
+    `click ${view.click ? (unicode ? "✓" : "on") : "off"}`,
+    view.click ? roles.success : roles.muted,
+  );
+  if (view.sustain) put("SUSTAIN", roles.pillQueue);
+  if (view.countIn) put(view.countIn, roles.warning);
+  if (view.beat) {
+    const cells = Array.from({ length: view.beat.of }, (_, index) =>
+      index + 1 === view.beat!.index
+        ? unicode
+          ? "●"
+          : "o"
+        : unicode
+          ? "·"
+          : ".",
+    ).join("");
+    put(
+      cells,
+      view.beat.flash
+        ? view.beat.index === 1
+          ? roles.error
+          : roles.hit
+        : roles.muted,
+    );
+  }
+  put(view.grid, roles.muted);
+  if (view.status) put(view.status, roles.muted);
+  // Mode keys at the right edge while there is room.
+  const hint = "z/x oct · c/v vel · r rec · m click · esc exit";
+  const room = width - 1 - displayWidth(hint);
+  if (room > x) buffer.text(room, y, hint, onBackground(roles.faint, panel));
+}
+
+/** `a C3 │ w C#3 …`: each key with its note; lit keys reversed. */
+export function paintPlayStrip(
+  buffer: CellBuffer,
+  y: number,
+  width: number,
+  keys: readonly PlayStripKey[],
+  theme: Theme,
+): void {
+  const roles = theme.roles;
+  buffer.fill(0, y, width, 1, roles.canvas);
+  let x = 1;
+  for (const key of keys) {
+    const cell = `${key.key.toUpperCase()} ${key.label}`;
+    const cellWidth = displayWidth(cell) + 1;
+    if (x + cellWidth > width - 1) break;
+    const style = key.lit
+      ? { ...(key.black ? roles.selected : roles.hit), reverse: true }
+      : key.black
+        ? roles.muted
+        : roles.text;
+    buffer.text(x, y, cell, style);
+    x += cellWidth;
+  }
+}