@cueloop/client 0.1.0-alpha.66 → 0.1.0-alpha.67

package/src/test-support.ts

@@ -1,7 +1,7 @@
 /**
- * Shared driving helpers for the virtual-terminal App suites: key presses
- * settle through a macrotask yield (input parser + React scheduler), one
- * render pass, and the renderer's visual-idle wait - no fixed-duration
+ * Shared driving helpers for the virtual-terminal App suites: an input settles
+ * when its painted frame stops changing across consecutive event-loop turns
+ * (macrotask yield, render pass, visual-idle wait per turn) - no fixed-duration
  * sleeps. Waits on daemon round-trips go through waitForFrame/waitFor with
  * generous pass budgets.
  */
@@ -40,15 +40,44 @@ export function allowEventLoopUpdates(): void {
   globalThis.IS_REACT_ACT_ENVIRONMENT = false;
 }
 
+/** Turns of the event loop a frame must survive unchanged before an input counts as settled. */
+const SETTLE_QUIET_TURNS = 2;
+
+/** Upper bound on settle turns, so a surface that keeps changing never stalls a test. */
+const SETTLE_MAX_TURNS = 40;
+
+/** The painted frame with its colors, so a caret cell (background only) counts as a change. */
+function paintedFrame(setup: TestRendererSetup): string {
+  return JSON.stringify(
+    setup
+      .captureSpans()
+      .lines.map((line) =>
+        line.spans.map((span) => [span.text, span.fg?.toInts(), span.bg?.toInts()]),
+      ),
+  );
+}
+
 /**
- * One macrotask yield lets the input parser and the React scheduler run,
- * then a render pass commits the result before the visual-idle wait.
+ * Wait for an input to land: React commits its state on its own scheduler, which the renderer's
+ * idle check cannot see, so on a slow machine a single idle wait returns between the key and its
+ * paint. Instead, run turns of the loop until the painted frame is unchanged across
+ * `SETTLE_QUIET_TURNS` consecutive turns.
  */
 export async function settle(setup: TestRendererSetup): Promise<void> {
   allowEventLoopUpdates();
-  await new Promise((resolve) => setTimeout(resolve, 0));
-  await setup.renderOnce();
-  await setup.waitForVisualIdle();
+  let previous = "";
+  let quietTurns = 0;
+
+  for (let turn = 0; turn < SETTLE_MAX_TURNS; turn++) {
+    await new Promise((resolve) => setTimeout(resolve, 0));
+    await setup.renderOnce();
+    await setup.waitForVisualIdle();
+    const frame = paintedFrame(setup);
+
+    quietTurns = frame === previous ? quietTurns + 1 : 0;
+    if (quietTurns >= SETTLE_QUIET_TURNS) return;
+    previous = frame;
+  }
 }
 
 /** Drive one key press: letters type as text; named keys use KeyCodes ids. */
@@ -58,6 +87,8 @@ export async function press(setup: TestRendererSetup, key: string): Promise<void
   else if (key === "backspace") setup.mockInput.pressKey("BACKSPACE");
   else if (key === "left") setup.mockInput.pressKey("ARROW_LEFT");
   else if (key === "right") setup.mockInput.pressKey("ARROW_RIGHT");
+  else if (key === "up") setup.mockInput.pressKey("ARROW_UP");
+  else if (key === "down") setup.mockInput.pressKey("ARROW_DOWN");
   else return typeText(setup, key);
   await settle(setup);
 }

package/src/thread-chords.test.ts

@@ -21,8 +21,31 @@ describe("resolveThreadChord", () => {
     // Assert
     expect(resolveThreadChord({ name: "e", ctrl: true }, owner)).toEqual({ type: "edit" });
     expect(resolveThreadChord({ name: "s", ctrl: true }, owner)).toEqual({ type: "share" });
-    expect(resolveThreadChord({ name: "r", ctrl: true }, owner)).toEqual({
-      type: "cycleReviewPanel",
+  });
+
+  test("in a diff, option chords act on the caret's row and file; the rest still reach the rail", () => {
+    // Arrange
+    const diff = { ...owner, isDiff: true };
+
+    // Assert - the code-row primitives
+    expect(resolveThreadChord({ name: "x", meta: true }, diff)).toEqual({ type: "rejectChange" });
+    expect(resolveThreadChord({ name: "X", meta: true }, diff)).toEqual({ type: "rejectHunk" });
+    expect(resolveThreadChord({ name: "u", meta: true }, diff)).toEqual({
+      type: "restoreCuration",
+    });
+    expect(resolveThreadChord({ name: "c", meta: true }, diff)).toEqual({ type: "foldFile" });
+    expect(resolveThreadChord({ name: "d", meta: true }, diff)).toEqual({ type: "toggleDiffView" });
+    expect(resolveThreadChord({ name: "k", meta: true }, diff)).toEqual({ type: "walkStart" });
+    // the rail letters are untouched
+    expect(resolveThreadChord({ name: "n", meta: true }, diff)).toEqual({ type: "nextAnnotation" });
+    // rejecting is the owner's, and closed once resolved
+    expect(resolveThreadChord({ name: "x", meta: true }, { ...diff, isOwner: false })).toEqual({
+      type: "status",
+      message: "observer - read-only",
+    });
+    expect(resolveThreadChord({ name: "k", meta: true }, { ...diff, resolved: true })).toEqual({
+      type: "status",
+      message: "review submitted - read-only",
     });
   });
 
@@ -43,10 +66,6 @@ describe("resolveThreadChord", () => {
     expect(resolveThreadChord({ name: "u", meta: true }, owner)).toEqual({
       type: "restoreCuration",
     });
-    expect(resolveThreadChord({ name: "w", meta: true }, owner)).toEqual({
-      type: "resizeReviewPanel",
-      direction: 1,
-    });
     expect(resolveThreadChord({ name: "x", meta: true }, { ...owner, isOwner: false })).toEqual({
       type: "status",
       message: "observer - read-only",
@@ -76,9 +95,6 @@ describe("resolveThreadChord", () => {
     expect(resolveThreadChord({ name: "return", ctrl: true }, collaborator)).toEqual(readOnly);
     expect(resolveThreadChord({ name: "e", ctrl: true }, collaborator)).toEqual(readOnly);
     expect(resolveThreadChord({ name: "s", ctrl: true }, collaborator)).toEqual(readOnly);
-    expect(resolveThreadChord({ name: "r", ctrl: true }, collaborator)).toEqual({
-      type: "cycleReviewPanel",
-    });
     expect(
       resolveThreadChord({ name: "return", ctrl: true }, { ...owner, resolved: true }),
     ).toBeNull();

package/src/thread-chords.ts

@@ -24,8 +24,19 @@ export interface ThreadChordContext {
   resolved: boolean;
   /** The rail shows the tree: next / previous move its selection instead of the cards. */
   treeActive: boolean;
+  /** A diff review: the block chords act on the code row under the caret (reject, fold, walk). */
+  isDiff?: boolean;
 }
 
+/** The diff-review chords: option plus a letter, acting on the caret's row or file. */
+export const DIFF_CHORD_ENTRIES = [
+  { keys: "⌥x / ⌥X", label: "reject the change / the hunk" },
+  { keys: "⌥u", label: "restore the last rejection" },
+  { keys: "⌥c", label: "collapse the file to its band" },
+  { keys: "⌥d", label: "unified / split (when zoomed)" },
+  { keys: "⌥k", label: "start the guided walk" },
+] as const;
+
 /** The cheatsheet rows for the chords, in the same order they are resolved. */
 export const THREAD_CHORD_ENTRIES = [
   { keys: "⌃enter", label: "submit the review" },
@@ -70,11 +81,32 @@ export function resolveThreadChord(
     return context.resolved ? null : { type: "openSubmit" };
   }
   if (key.ctrl) return resolveSessionChord(key.name, context);
-  if (key.meta) return resolveRailChord(key.name, context);
+  if (key.meta)
+    return (
+      (context.isDiff && resolveDiffChord(key.name, context)) || resolveRailChord(key.name, context)
+    );
 
   return null;
 }
 
+/** The diff's row and file chords; null lets the rail chords answer the letter. */
+function resolveDiffChord(name: string, context: ThreadChordContext): Intent | null {
+  switch (name) {
+    case "x":
+      return mutating({ type: "rejectChange" }, context);
+    case "X":
+      return mutating({ type: "rejectHunk" }, context);
+    case "c":
+      return { type: "foldFile" };
+    case "d":
+      return { type: "toggleDiffView" };
+    case "k":
+      return context.resolved ? RESOLVED : { type: "walkStart" };
+    default:
+      return null;
+  }
+}
+
 /** The answers a blocked primitive gets - the same words the keymap uses. */
 const READ_ONLY: Intent = { type: "status", message: "observer - read-only" };
 const RESOLVED: Intent = { type: "status", message: "review submitted - read-only" };
@@ -93,8 +125,6 @@ function resolveSessionChord(name: string, context: ThreadChordContext): Intent
       return mutating({ type: "edit" }, context);
     case "s":
       return context.isOwner ? { type: "share" } : READ_ONLY;
-    case "r":
-      return { type: "cycleReviewPanel" };
     default:
       return null;
   }
@@ -133,11 +163,6 @@ function resolveRailChord(name: string, context: ThreadChordContext): Intent | n
       return mutating({ type: "cut" }, context);
     case "u":
       return mutating({ type: "restoreCuration" }, context);
-    // letters only: escape-prefixed punctuation reads as control sequences, not keys
-    case "w":
-      return { type: "resizeReviewPanel", direction: 1 };
-    case "s":
-      return { type: "resizeReviewPanel", direction: -1 };
     default:
       return null;
   }