feat(ext/node): embed std/node into the snapshot (#17724)

This commit moves "deno_std/node" in "ext/node" crate. The code is
transpiled and snapshotted during the build process.

During the first pass a minimal amount of work was done to create the
snapshot, a lot of code in "ext/node" depends on presence of "Deno"
global. This code will be gradually fixed in the follow up PRs to migrate
it to import relevant APIs from "internal:" modules.

Currently the code from snapshot is not used in any way, and all
Node/npm compatibility still uses code from 
"https://deno.land/std/node" (or from the location specified by 
"DENO_NODE_COMPAT_URL"). This will also be handled in a follow 
up PRs.

---------

Co-authored-by: crowlkats <crowlkats@toaxl.com>
Co-authored-by: Divy Srivastava <dj.srivastava23@gmail.com>
Co-authored-by: Yoshiya Hinosawa <stibium121@gmail.com>

1 files changed, 141 insertions, 0 deletions

diff --git a/ext/node/polyfills/internal/util.mjs b/ext/node/polyfills/internal/util.mjs
new file mode 100644
index 000000000..ba26c6a6a
--- /dev/null
+++ b/ext/node/polyfills/internal/util.mjs
@@ -0,0 +1,141 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+import { validateFunction } from "internal:deno_node/polyfills/internal/validators.mjs";
+import { normalizeEncoding, slowCases } from "internal:deno_node/polyfills/internal/normalize_encoding.mjs";
+export { normalizeEncoding, slowCases };
+import { ObjectCreate, StringPrototypeToUpperCase } from "internal:deno_node/polyfills/internal/primordials.mjs";
+import { ERR_UNKNOWN_SIGNAL } from "internal:deno_node/polyfills/internal/errors.ts";
+import { os } from "internal:deno_node/polyfills/internal_binding/constants.ts";
+
+export const customInspectSymbol = Symbol.for("nodejs.util.inspect.custom");
+export const kEnumerableProperty = Object.create(null);
+kEnumerableProperty.enumerable = true;
+
+export const kEmptyObject = Object.freeze(Object.create(null));
+
+export function once(callback) {
+  let called = false;
+  return function (...args) {
+    if (called) return;
+    called = true;
+    Reflect.apply(callback, this, args);
+  };
+}
+
+export function createDeferredPromise() {
+  let resolve;
+  let reject;
+  const promise = new Promise((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+
+  return { promise, resolve, reject };
+}
+
+// In addition to being accessible through util.promisify.custom,
+// this symbol is registered globally and can be accessed in any environment as
+// Symbol.for('nodejs.util.promisify.custom').
+const kCustomPromisifiedSymbol = Symbol.for("nodejs.util.promisify.custom");
+// This is an internal Node symbol used by functions returning multiple
+// arguments, e.g. ['bytesRead', 'buffer'] for fs.read().
+const kCustomPromisifyArgsSymbol = Symbol.for(
+  "nodejs.util.promisify.customArgs",
+);
+
+export const customPromisifyArgs = kCustomPromisifyArgsSymbol;
+
+export function promisify(
+  original,
+) {
+  validateFunction(original, "original");
+  if (original[kCustomPromisifiedSymbol]) {
+    const fn = original[kCustomPromisifiedSymbol];
+
+    validateFunction(fn, "util.promisify.custom");
+
+    return Object.defineProperty(fn, kCustomPromisifiedSymbol, {
+      value: fn,
+      enumerable: false,
+      writable: false,
+      configurable: true,
+    });
+  }
+
+  // Names to create an object from in case the callback receives multiple
+  // arguments, e.g. ['bytesRead', 'buffer'] for fs.read.
+  const argumentNames = original[kCustomPromisifyArgsSymbol];
+  function fn(...args) {
+    return new Promise((resolve, reject) => {
+      args.push((err, ...values) => {
+        if (err) {
+          return reject(err);
+        }
+        if (argumentNames !== undefined && values.length > 1) {
+          const obj = {};
+          for (let i = 0; i < argumentNames.length; i++) {
+            obj[argumentNames[i]] = values[i];
+          }
+          resolve(obj);
+        } else {
+          resolve(values[0]);
+        }
+      });
+      Reflect.apply(original, this, args);
+    });
+  }
+
+  Object.setPrototypeOf(fn, Object.getPrototypeOf(original));
+
+  Object.defineProperty(fn, kCustomPromisifiedSymbol, {
+    value: fn,
+    enumerable: false,
+    writable: false,
+    configurable: true,
+  });
+  return Object.defineProperties(
+    fn,
+    Object.getOwnPropertyDescriptors(original),
+  );
+}
+
+let signalsToNamesMapping;
+function getSignalsToNamesMapping() {
+  if (signalsToNamesMapping !== undefined) {
+    return signalsToNamesMapping;
+  }
+
+  signalsToNamesMapping = ObjectCreate(null);
+  for (const key in os.signals) {
+    signalsToNamesMapping[os.signals[key]] = key;
+  }
+
+  return signalsToNamesMapping;
+}
+
+export function convertToValidSignal(signal) {
+  if (typeof signal === "number" && getSignalsToNamesMapping()[signal]) {
+    return signal;
+  }
+
+  if (typeof signal === "string") {
+    const signalName = os.signals[StringPrototypeToUpperCase(signal)];
+    if (signalName) return signalName;
+  }
+
+  throw new ERR_UNKNOWN_SIGNAL(signal);
+}
+
+promisify.custom = kCustomPromisifiedSymbol;
+
+export default {
+  convertToValidSignal,
+  createDeferredPromise,
+  customInspectSymbol,
+  customPromisifyArgs,
+  kEmptyObject,
+  kEnumerableProperty,
+  normalizeEncoding,
+  once,
+  promisify,
+  slowCases,
+};