examples use node: api

Author: jbolda

examples/README.md

@@ -6,7 +6,8 @@ with information about your terminal, shell, operating system and any other
 information that could be pertinent to reproducing the issue.
 
 > [!NOTE]
-> Run the commands in this document from the repository root.
+> Run the commands in this document from the repository root. These examples use
+> `node:` terminal APIs so the same files can be run with either Deno or Node.
 
 ## Prerequisites
 
@@ -24,6 +25,8 @@ Run it with:
 
 ```sh
 deno run examples/keyboard/index.ts
+# or
+node examples/keyboard/index.ts
 ```
 
 What it shows:
@@ -48,6 +51,8 @@ Run it with:
 
 ```sh
 deno run examples/inline-regions/index.ts
+# or
+node examples/inline-regions/index.ts
 ```
 
 What it shows:

examples/inline-regions/index.ts

@@ -8,7 +8,10 @@
  *   4. Commit — restore cursor past region, advance with \n
  */
 
-import { main, type Operation, sleep, until } from "effection";
+import { Buffer } from "node:buffer";
+import { readSync } from "node:fs";
+import process from "node:process";
+import { ensure, main, type Operation, sleep, until } from "effection";
 import {
   close,
   createInput,
@@ -28,8 +31,23 @@ import {
 import { cursor, settings } from "../../settings.ts";
 import { validated } from "../../validate.ts";
 
+function terminalSize(): { columns: number; rows: number } {
+  return process.stdout.isTTY
+    ? {
+      columns: process.stdout.columns ?? 80,
+      rows: process.stdout.rows ?? 24,
+    }
+    : { columns: 80, rows: 24 };
+}
+
+function setRawMode(enabled: boolean): void {
+  if (process.stdin.isTTY && typeof process.stdin.setRawMode === "function") {
+    process.stdin.setRawMode(enabled);
+  }
+}
+
 const encode = (s: string) => new TextEncoder().encode(s);
-const write = (b: Uint8Array) => Deno.stdout.writeSync(b);
+const write = (b: Uint8Array) => process.stdout.write(Buffer.from(b));
 
 const GREEN = rgba(80, 250, 123);
 const GRAY = rgba(100, 100, 100);
@@ -49,10 +67,10 @@ function* queryCursor(): Operation<CursorEvent> {
   let parser = yield* until(createInput({ escLatency: 100 }));
   write(DSR());
 
-  let buf = new Uint8Array(32);
+  let buf = Buffer.allocUnsafe(32);
   while (true) {
-    let n = Deno.stdin.readSync(buf);
-    if (n === null) continue;
+    let n = readSync(process.stdin.fd, buf, 0, buf.length, null);
+    if (n === 0) continue;
     let result = parser.scan(buf.subarray(0, n));
     for (let ev of result.events) {
       if (ev.type === "cursor") {
@@ -62,16 +80,16 @@ function* queryCursor(): Operation<CursorEvent> {
   }
 }
 
-function waitKey() {
-  let buf = new Uint8Array(32);
+function waitKey(): void {
+  let buf = Buffer.allocUnsafe(32);
   while (true) {
-    let n = Deno.stdin.readSync(buf);
-    if (n === null) continue;
+    let n = readSync(process.stdin.fd, buf, 0, buf.length, null);
+    if (n === 0) continue;
     for (let i = 0; i < n; i++) {
       if (buf[i] === 0x03) {
-        Deno.stdin.setRaw(false);
+        setRawMode(false);
         write(SHOWCURSOR());
-        Deno.exit(0);
+        process.exit(0);
       }
     }
     return;
@@ -112,7 +130,7 @@ function* transaction(
   frames: number,
   interval: number,
 ): Operation<void> {
-  let { columns } = Deno.consoleSize();
+  let { columns } = terminalSize();
 
   write(encode("\n".repeat(height)));
 
@@ -142,17 +160,23 @@ function say(msg: string) {
   write(encode(msg + "\n"));
 }
 
-function pause() {
+function pause(): void {
   waitKey();
   write(encode("\n"));
 }
 
 await main(function* () {
-  let { columns } = Deno.consoleSize();
-  Deno.stdin.setRaw(true);
+  let { columns } = terminalSize();
+  setRawMode(true);
   let tty = settings(cursor(false));
   write(tty.apply);
 
+  yield* ensure(() => {
+    setRawMode(false);
+    write(CSI("0m"));
+    write(tty.revert);
+  });
+
   // Introduction
   say("Clayterm can render entire scenes, but it can also render");
   say('"inline" for a streaming UI. This is useful for semi-interactive');
@@ -338,6 +362,4 @@ await main(function* () {
 
   write(CSI("0m"));
   write(encode("\n"));
-  write(tty.revert);
-  Deno.stdin.setRaw(false);
 });

examples/keyboard/index.ts

@@ -1,4 +1,6 @@
 // deno-lint-ignore-file no-fallthrough
+import { Buffer } from "node:buffer";
+import process from "node:process";
 import {
   createChannel,
   each,
@@ -33,6 +35,54 @@ import {
 import { useInput } from "./use-input.ts";
 import { useStdin } from "./use-stdin.ts";
 
+function terminalSize(): { columns: number; rows: number } {
+  return process.stdout.isTTY
+    ? {
+      columns: process.stdout.columns ?? 80,
+      rows: process.stdout.rows ?? 24,
+    }
+    : { columns: 80, rows: 24 };
+}
+
+function setRawMode(enabled: boolean): void {
+  if (process.stdin.isTTY && typeof process.stdin.setRawMode === "function") {
+    process.stdin.setRawMode(enabled);
+  }
+}
+
+function writeStdout(bytes: Uint8Array): void {
+  process.stdout.write(Buffer.from(bytes));
+}
+
+function equalBytes(a: Uint8Array, b: Uint8Array): boolean {
+  if (a.length !== b.length) {
+    return false;
+  }
+  for (let i = 0; i < a.length; i++) {
+    if (a[i] !== b[i]) {
+      return false;
+    }
+  }
+  return true;
+}
+
+function equalSetting(a: Setting, b: Setting): boolean {
+  return equalBytes(a.apply, b.apply) && equalBytes(a.revert, b.revert);
+}
+
+// Avoid rewriting terminal input modes on every mousemove. Deno's `node:` TTY
+// compatibility layer on Windows is sensitive to that churn even when the
+// effective settings are unchanged.
+function updateFlagsIfChanged(current: Setting, next: Setting): Setting {
+  if (equalSetting(current, next)) {
+    return current;
+  }
+
+  writeStdout(current.revert);
+  writeStdout(next.apply);
+  return next;
+}
+
 const active = rgba(60, 120, 220);
 const inactive = rgba(50, 50, 60);
 const on = rgba(40, 180, 80);
@@ -563,34 +613,33 @@ function ttyFlags(ctx: AppContext): Setting {
 }
 
 await main(function* () {
-  let { columns, rows } = Deno.stdout.isTerminal()
-    ? Deno.consoleSize()
-    : { columns: 80, rows: 24 };
+  let { columns, rows } = terminalSize();
 
-  Deno.stdin.setRaw(true);
+  setRawMode(true);
 
   let stdin = yield* useStdin();
   let input = useInput(stdin);
 
   let term = yield* until(createTerm({ width: columns, height: rows }));
 
   let tty = settings(alternateBuffer(), cursor(false));
-  Deno.stdout.writeSync(tty.apply);
+  writeStdout(tty.apply);
 
   let modality = recognizer();
   let context = modality.next().value;
 
   let flags = ttyFlags(context);
-  Deno.stdout.writeSync(flags.apply);
+  writeStdout(flags.apply);
 
   yield* ensure(() => {
-    Deno.stdout.writeSync(flags.revert);
-    Deno.stdout.writeSync(tty.revert);
+    setRawMode(false);
+    writeStdout(flags.revert);
+    writeStdout(tty.revert);
   });
 
   let { output } = term.render(keyboard(context));
 
-  Deno.stdout.writeSync(output);
+  writeStdout(output);
 
   let pointer = {
     events: createChannel<PointerEvent, void>(),
@@ -616,9 +665,7 @@ await main(function* () {
       context = { ...context, logged: prev };
     }
 
-    Deno.stdout.writeSync(flags.revert);
-    flags = ttyFlags(context);
-    Deno.stdout.writeSync(flags.apply);
+    flags = updateFlagsIfChanged(flags, ttyFlags(context));
 
     if (context["Capture mouse events"]) {
       if ("x" in event) {
@@ -640,7 +687,7 @@ await main(function* () {
       yield* pointer.events.send(event);
     }
 
-    Deno.stdout.writeSync(output);
+    writeStdout(output);
 
     yield* each.next();
   }

examples/keyboard/use-stdin.ts

@@ -8,12 +8,12 @@ import {
   type Stream,
   until,
 } from "effection";
+import process from "node:process";
 
 export function useStdin(): Operation<Stream<Uint8Array, void>> {
   return resource(function* (provide) {
     let channel = createChannel<Uint8Array, void>();
-
-    let iterator = Deno.stdin.readable[Symbol.asyncIterator]();
+    let iterator = process.stdin.iterator() as AsyncIterator<Uint8Array>;
 
     yield* spawn(function* () {
       let next = yield* until(iterator.next());