fix: implement node:tty

ext/node/lib.rs

@@ -489,7 +489,7 @@ deno_core::extension!(deno_node,
     "timers.ts" with_specifier "node:timers",
     "timers/promises.ts" with_specifier "node:timers/promises",
     "tls.ts" with_specifier "node:tls",
-    "tty.ts" with_specifier "node:tty",
+    "tty.js" with_specifier "node:tty",
     "url.ts" with_specifier "node:url",
     "util.ts" with_specifier "node:util",
     "util/types.ts" with_specifier "node:util/types",

ext/node/polyfills/process.ts

@@ -33,8 +33,6 @@ export { _nextTick as nextTick, chdir, cwd, env, version, versions };
 import {
   createWritableStdioStream,
   initStdin,
-  Readable,
-  Writable,
 } from "ext:deno_node/_process/streams.mjs";
 import {
   enableNextTick,
@@ -54,41 +52,14 @@ export let platform = "";
 // TODO(kt3k): This should be set at start up time
 export let pid = 0;
 
-// We want streams to be as lazy as possible, but we cannot export a getter in a module. To
-// work around this we make these proxies that eagerly instantiate the underlying object on
-// first access of any property/method.
-function makeLazyStream<T>(objectFactory: () => T): T {
-  return new Proxy({}, {
-    get: function (_, prop, receiver) {
-      // deno-lint-ignore no-explicit-any
-      return Reflect.get(objectFactory() as any, prop, receiver);
-    },
-    has: function (_, prop) {
-      // deno-lint-ignore no-explicit-any
-      return Reflect.has(objectFactory() as any, prop);
-    },
-    ownKeys: function (_) {
-      // deno-lint-ignore no-explicit-any
-      return Reflect.ownKeys(objectFactory() as any);
-    },
-    set: function (_, prop, value, receiver) {
-      // deno-lint-ignore no-explicit-any
-      return Reflect.set(objectFactory() as any, prop, value, receiver);
-    },
-    getPrototypeOf: function (_) {
-      // deno-lint-ignore no-explicit-any
-      return Reflect.getPrototypeOf(objectFactory() as any);
-    },
-    getOwnPropertyDescriptor(_, prop) {
-      // deno-lint-ignore no-explicit-any
-      return Reflect.getOwnPropertyDescriptor(objectFactory() as any, prop);
-    },
-  }) as T;
-}
+// deno-lint-ignore no-explicit-any
+let stderr = null as any;
+// deno-lint-ignore no-explicit-any
+let stdin = null as any;
+// deno-lint-ignore no-explicit-any
+let stdout = null as any;
 
-export let stderr = makeLazyStream(getStderr);
-export let stdin = makeLazyStream(getStdin);
-export let stdout = makeLazyStream(getStdout);
+export { stderr, stdin, stdout };
 
 import { getBinding } from "ext:deno_node/internal_binding/mod.ts";
 import * as constants from "ext:deno_node/internal_binding/constants.ts";
@@ -634,19 +605,13 @@ class Process extends EventEmitter {
   memoryUsage = memoryUsage;
 
   /** https://nodejs.org/api/process.html#process_process_stderr */
-  get stderr(): Writable {
-    return getStderr();
-  }
+  stderr = stderr;
 
   /** https://nodejs.org/api/process.html#process_process_stdin */
-  get stdin(): Readable {
-    return getStdin();
-  }
+  stdin = stdin;
 
   /** https://nodejs.org/api/process.html#process_process_stdout */
-  get stdout(): Writable {
-    return getStdout();
-  }
+  stdout = stdout;
 
   /** https://nodejs.org/api/process.html#process_process_version */
   version = version;
@@ -892,52 +857,67 @@ internals.__bootstrapNodeProcess = function (
   core.setMacrotaskCallback(runNextTicks);
   enableNextTick();
 
+  // Install special "unhandledrejection" handler, that will be called
+  // last.
+  internals.nodeProcessUnhandledRejectionCallback = (event) => {
+    if (process.listenerCount("unhandledRejection") === 0) {
+      // The Node.js default behavior is to raise an uncaught exception if
+      // an unhandled rejection occurs and there are no unhandledRejection
+      // listeners.
+      if (process.listenerCount("uncaughtException") === 0) {
+        throw event.reason;
+      }
+
+      event.preventDefault();
+      uncaughtExceptionHandler(event.reason, "unhandledRejection");
+      return;
+    }
+
+    event.preventDefault();
+    process.emit("unhandledRejection", event.reason, event.promise);
+  };
+
+  globalThis.addEventListener("error", (event) => {
+    if (process.listenerCount("uncaughtException") > 0) {
+      event.preventDefault();
+    }
+
+    uncaughtExceptionHandler(event.error, "uncaughtException");
+  });
+
+  globalThis.addEventListener("beforeunload", (e) => {
+    process.emit("beforeExit", process.exitCode || 0);
+    processTicksAndRejections();
+    if (core.eventLoopHasMoreWork()) {
+      e.preventDefault();
+    }
+  });
+
+  globalThis.addEventListener("unload", () => {
+    if (!process._exiting) {
+      process._exiting = true;
+      process.emit("exit", process.exitCode || 0);
+    }
+  });
+
+  // Initializes stdin
+  stdin = process.stdin = initStdin();
+
+  /** https://nodejs.org/api/process.html#process_process_stderr */
+  stderr = process.stderr = createWritableStdioStream(
+    io.stderr,
+    "stderr",
+  );
+
+  /** https://nodejs.org/api/process.html#process_process_stdout */
+  stdout = process.stdout = createWritableStdioStream(
+    io.stdout,
+    "stdout",
+  );
   process.setStartTime(Date.now());
   // @ts-ignore Remove setStartTime and #startTime is not modifiable
   delete process.setStartTime;
   delete internals.__bootstrapNodeProcess;
 };
 
-// deno-lint-ignore no-explicit-any
-let stderr_ = null as any;
-// deno-lint-ignore no-explicit-any
-let stdin_ = null as any;
-// deno-lint-ignore no-explicit-any
-let stdout_ = null as any;
-
-function getStdin(): Readable {
-  if (!stdin_) {
-    stdin_ = initStdin();
-    stdin = stdin_;
-    Object.defineProperty(process, "stdin", { get: () => stdin_ });
-  }
-  return stdin_;
-}
-
-/** https://nodejs.org/api/process.html#process_process_stdout */
-function getStdout(): Writable {
-  if (!stdout_) {
-    stdout_ = createWritableStdioStream(
-      io.stdout,
-      "stdout",
-    );
-    stdout = stdout_;
-    Object.defineProperty(process, "stdout", { get: () => stdout_ });
-  }
-  return stdout_;
-}
-
-/** https://nodejs.org/api/process.html#process_process_stderr */
-function getStderr(): Writable {
-  if (!stderr_) {
-    stderr_ = createWritableStdioStream(
-      io.stderr,
-      "stderr",
-    );
-    stderr = stderr_;
-    Object.defineProperty(process, "stderr", { get: () => stderr_ });
-  }
-  return stderr_;
-}
-
 export default process;

ext/node/polyfills/tty.js

@@ -0,0 +1,84 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+
+import { Socket } from "node:net";
+import { ERR_INVALID_FD } from "ext:deno_node/internal/errors.ts";
+import { LibuvStreamWrap } from "ext:deno_node/internal_binding/stream_wrap.ts";
+import { providerType } from "ext:deno_node/internal_binding/async_wrap.ts";
+
+const { Error } = globalThis.__bootstrap.primordials;
+
+// Returns true when the given numeric fd is associated with a TTY and false otherwise.
+function isatty(fd) {
+  if (typeof fd !== "number") {
+    return false;
+  }
+  try {
+    return Deno.isatty(fd);
+  } catch (_) {
+    return false;
+  }
+}
+
+class TTY extends LibuvStreamWrap {
+  constructor(handle) {
+    super(providerType.TTYWRAP, handle);
+  }
+}
+
+export class ReadStream extends Socket {
+  constructor(fd, options) {
+    if (fd >> 0 !== fd || fd < 0) {
+      throw new ERR_INVALID_FD(fd);
+    }
+
+    // We only support `stdin`.
+    if (fd != 0) throw new Error("Only fd 0 is supported.");
+
+    const tty = new TTY(Deno.stdin);
+    super({
+      readableHighWaterMark: 0,
+      handle: tty,
+      manualStart: true,
+      ...options,
+    });
+
+    this.isRaw = false;
+    this.isTTY = true;
+  }
+
+  setRawMode(flag) {
+    flag = !!flag;
+    this._handle.setRaw(flag);
+
+    this.isRaw = flag;
+    return this;
+  }
+}
+
+export class WriteStream extends Socket {
+  constructor(fd) {
+    if (fd >> 0 !== fd || fd < 0) {
+      throw new ERR_INVALID_FD(fd);
+    }
+
+    // We only support `stdin`, `stdout` and `stderr`.
+    if (fd > 2) throw new Error("Only fd 0, 1 and 2 are supported.");
+
+    const tty = new TTY(
+      fd === 0 ? Deno.stdin : (fd === 1 ? Deno.stdout : Deno.stderr),
+    );
+
+    super({
+      readableHighWaterMark: 0,
+      handle: tty,
+      manualStart: true,
+    });
+
+    const { columns, rows } = Deno.consoleSize();
+    this.columns = columns;
+    this.rows = rows;
+  }
+}
+
+export { isatty };
+export default { isatty, WriteStream, ReadStream };