Rewrite built-in modules to use CommonJS over ESM (#3814)

* stfdsafsd sadffdsa stuff finish commonjs stuff asdf not done but work not done but work not done yet but this is how far i am remove files lol update built files uncomment everything in events lol export default stuff * afdsafsd * its not perfect but almost done * okay * cool * remove temp file * finish rebase * revert settings.json * a * ch-ch-ch-ch-changes * okay * remove this check in release for now * sxdcfghnjm, * lkjhgf * fmt * filename can be null * Update NodeModuleModule.h * weee * fmt --------- Co-authored-by: Jarred Sumner <709451+Jarred-Sumner@users.noreply.github.com>
2026-02-14 12:51:54 +00:00 · 2023-08-02 16:27:36 -07:00
parent 7656b4b17e
commit c2a77cf7ec
199 changed files with 11153 additions and 31396 deletions
--- a/src/bun.js/modules/_NativeModule.h
+++ b/src/bun.js/modules/_NativeModule.h
@@ -0,0 +1,90 @@
+// clang-format off
+#pragma once
+#include "JSBuffer.h"
+#include "JavaScriptCore/JSGlobalObject.h"
+#include "JavaScriptCore/ObjectConstructor.h"
+#include "ZigGlobalObject.h"
+
+// These modules are implemented in native code as a function which writes ESM
+// export key+value pairs. The following macros help simplify the implementation
+// of these functions.
+
+// To add a new native module
+//   1. Add a new line to `BUN_FOREACH_NATIVE_MODULE`
+//   2. Add a case to `module_loader.zig` that resolves the import.
+//   3. Add a new file in this folder named after the module, camelcase and suffixed with Module,
+//      like "NodeBufferModule.h" or "BunJSCModule.h". It should call DEFINE_NATIVE_MODULE(name).
+//
+//      The native module function is called to create the module object:
+//      - INIT_NATIVE_MODULE(n) is called with the number of exports
+//      - put(id, jsvalue) adds an export
+//      - putNativeFn(id, nativefn) lets you quickly add from `JSC_DEFINE_HOST_FUNCTION`
+//      - NATIVE_MODULE_FINISH() do asserts and finalize everything.
+// If you decide to not use INIT_NATIVE_MODULE. make sure the first property
+// given is the default export
+
+#define BUN_FOREACH_NATIVE_MODULE(macro) \
+    macro("bun:jsc"_s, BunJSC) \
+    macro("node:buffer"_s, NodeBuffer) \
+    macro("node:constants"_s, NodeConstants) \
+    macro("node:module"_s, NodeModule) \
+    macro("node:process"_s, NodeProcess) \
+    macro("node:string_decoder"_s, NodeStringDecoder) \
+    macro("node:tty"_s, NodeTTY) \
+    macro("node:util/types"_s, NodeUtilTypes) \
+
+#if ASSERT_ENABLED
+
+// This function is a lie. It doesnt return, but rather it performs an assertion
+// that what you passed to INIT_NATIVE_MODULE is indeed correct.
+#define RETURN_NATIVE_MODULE()                                                 \
+  ASSERT_WITH_MESSAGE(numberOfActualExportNames == passedNumberOfExportNames,  \
+                      "NATIVE_MODULE_START() was given the incorrect value.");
+
+#define __NATIVE_MODULE_ASSERT_DECL                                            \
+  int numberOfActualExportNames = 0;                                           \
+  int passedNumberOfExportNames = numberOfExportNames;                         \
+#define __NATIVE_MODULE_ASSERT_INCR numberOfActualExportNames++;
+
+#else
+
+#define RETURN_NATIVE_MODULE() ;
+#define __NATIVE_MODULE_ASSERT_INCR ;
+#define __NATIVE_MODULE_ASSERT_DECL ;
+
+#endif
+
+#define DEFINE_NATIVE_MODULE(name)                                             \
+  inline void generateNativeModule_##name(                                     \
+      JSC::JSGlobalObject *lexicalGlobalObject, JSC::Identifier moduleKey,     \
+      Vector<JSC::Identifier, 4> &exportNames,                                 \
+      JSC::MarkedArgumentBuffer &exportValues)
+
+#define INIT_NATIVE_MODULE(numberOfExportNames)                                \
+  Zig::GlobalObject *globalObject =                                            \
+      reinterpret_cast<Zig::GlobalObject *>(lexicalGlobalObject);              \
+  JSC::VM &vm = globalObject->vm();                                            \
+  JSC::JSObject *defaultObject = JSC::constructEmptyObject(                    \
+      globalObject, globalObject->objectPrototype(), numberOfExportNames);     \
+  __NATIVE_MODULE_ASSERT_DECL                                                  \
+  auto put = [&](JSC::Identifier name, JSC::JSValue value) {                   \
+    defaultObject->putDirect(vm, name, value);                                 \
+    exportNames.append(name);                                                  \
+    exportValues.append(value);                                                \
+    __NATIVE_MODULE_ASSERT_INCR                                                \
+  };                                                                           \
+  auto putNativeFn = [&](JSC::Identifier name, JSC::NativeFunction ptr) {      \
+    JSC::JSFunction *value = JSC::JSFunction::create(                          \
+        vm, globalObject, 1, name.string(), ptr,                               \
+        JSC::ImplementationVisibility::Public, JSC::NoIntrinsic, ptr);         \
+    defaultObject->putDirect(vm, name, value);                                 \
+    exportNames.append(name);                                                  \
+    exportValues.append(value);                                                \
+    __NATIVE_MODULE_ASSERT_INCR                                                \
+  };                                                                           \
+  exportNames.reserveCapacity(numberOfExportNames + 1);                        \
+  exportValues.ensureCapacity(numberOfExportNames + 1);                        \
+  exportNames.append(vm.propertyNames->defaultKeyword);                        \
+  exportValues.append(defaultObject);                                          \
+  while (0) {                                                                  \
+  }