mirror of
https://github.com/oven-sh/bun
synced 2026-02-13 04:18:58 +00:00
d8350c2c59
Add `jsc.DecodedJSValue`, an extern struct which is ABI-compatible with `JSC::JSValue`. (By contrast, `jsc.JSValue` is ABI-compatible with `JSC::EncodedJSValue`.) This enables `jsc.Strong.get` to be more efficient: it no longer has to call into C++. (For internal tracking: fixes ENG-20748) --------- Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>
3116 lines
123 KiB
Zig
3116 lines
123 KiB
Zig
const ModuleLoader = @This();
|
|
|
|
pub const node_fallbacks = @import("../node_fallbacks.zig");
|
|
|
|
transpile_source_code_arena: ?*bun.ArenaAllocator = null,
|
|
eval_source: ?*logger.Source = null,
|
|
|
|
comptime {
|
|
_ = Bun__transpileVirtualModule;
|
|
_ = Bun__runVirtualModule;
|
|
_ = Bun__transpileFile;
|
|
_ = Bun__fetchBuiltinModule;
|
|
_ = Bun__getDefaultLoader;
|
|
}
|
|
|
|
pub var is_allowed_to_use_internal_testing_apis = false;
|
|
|
|
/// This must be called after calling transpileSourceCode
|
|
pub fn resetArena(this: *ModuleLoader, jsc_vm: *VirtualMachine) void {
|
|
bun.assert(&jsc_vm.module_loader == this);
|
|
if (this.transpile_source_code_arena) |arena| {
|
|
if (jsc_vm.smol) {
|
|
_ = arena.reset(.free_all);
|
|
} else {
|
|
_ = arena.reset(.{ .retain_with_limit = 8 * 1024 * 1024 });
|
|
}
|
|
}
|
|
}
|
|
|
|
pub fn resolveEmbeddedFile(vm: *VirtualMachine, input_path: []const u8, extname: []const u8) ?[]const u8 {
|
|
if (input_path.len == 0) return null;
|
|
var graph = vm.standalone_module_graph orelse return null;
|
|
const file = graph.find(input_path) orelse return null;
|
|
|
|
if (comptime Environment.isLinux) {
|
|
// TODO: use /proc/fd/12346 instead! Avoid the copy!
|
|
}
|
|
|
|
// atomically write to a tmpfile and then move it to the final destination
|
|
var tmpname_buf: bun.PathBuffer = undefined;
|
|
const tmpfilename = bun.sliceTo(bun.fs.FileSystem.instance.tmpname(extname, &tmpname_buf, bun.hash(file.name)) catch return null, 0);
|
|
|
|
const tmpdir: bun.FD = .fromStdDir(bun.fs.FileSystem.instance.tmpdir() catch return null);
|
|
|
|
// First we open the tmpfile, to avoid any other work in the event of failure.
|
|
const tmpfile = bun.Tmpfile.create(tmpdir, tmpfilename).unwrap() catch return null;
|
|
defer tmpfile.fd.close();
|
|
|
|
switch (bun.api.node.fs.NodeFS.writeFileWithPathBuffer(
|
|
&tmpname_buf, // not used
|
|
|
|
.{
|
|
.data = .{
|
|
.encoded_slice = ZigString.Slice.fromUTF8NeverFree(file.contents),
|
|
},
|
|
.dirfd = tmpdir,
|
|
.file = .{ .fd = tmpfile.fd },
|
|
.encoding = .buffer,
|
|
},
|
|
)) {
|
|
.err => {
|
|
return null;
|
|
},
|
|
else => {},
|
|
}
|
|
return bun.path.joinAbs(bun.fs.FileSystem.instance.fs.tmpdirPath(), .auto, tmpfilename);
|
|
}
|
|
|
|
pub const AsyncModule = struct {
|
|
// This is all the state used by the printer to print the module
|
|
parse_result: ParseResult,
|
|
promise: jsc.Strong.Optional = .empty,
|
|
path: Fs.Path,
|
|
specifier: string = "",
|
|
referrer: string = "",
|
|
string_buf: []u8 = &[_]u8{},
|
|
fd: ?StoredFileDescriptorType = null,
|
|
package_json: ?*PackageJSON = null,
|
|
loader: api.Loader,
|
|
hash: u32 = std.math.maxInt(u32),
|
|
globalThis: *JSGlobalObject = undefined,
|
|
arena: *bun.ArenaAllocator,
|
|
|
|
// This is the specific state for making it async
|
|
poll_ref: Async.KeepAlive = .{},
|
|
any_task: jsc.AnyTask = undefined,
|
|
|
|
pub const Id = u32;
|
|
|
|
const PackageDownloadError = struct {
|
|
name: []const u8,
|
|
resolution: Install.Resolution,
|
|
err: anyerror,
|
|
url: []const u8,
|
|
};
|
|
|
|
const PackageResolveError = struct {
|
|
name: []const u8,
|
|
err: anyerror,
|
|
url: []const u8,
|
|
version: Dependency.Version,
|
|
};
|
|
|
|
pub const Queue = struct {
|
|
map: Map = .{},
|
|
scheduled: u32 = 0,
|
|
concurrent_task_count: std.atomic.Value(u32) = std.atomic.Value(u32).init(0),
|
|
|
|
const DeferredDependencyError = struct {
|
|
dependency: Dependency,
|
|
root_dependency_id: Install.DependencyID,
|
|
err: anyerror,
|
|
};
|
|
|
|
pub const Map = std.ArrayListUnmanaged(AsyncModule);
|
|
|
|
pub fn enqueue(this: *Queue, globalObject: *JSGlobalObject, opts: anytype) void {
|
|
debug("enqueue: {s}", .{opts.specifier});
|
|
var module = AsyncModule.init(opts, globalObject) catch unreachable;
|
|
module.poll_ref.ref(this.vm());
|
|
|
|
this.map.append(this.vm().allocator, module) catch unreachable;
|
|
this.vm().packageManager().drainDependencyList();
|
|
}
|
|
|
|
pub fn onDependencyError(ctx: *anyopaque, dependency: Dependency, root_dependency_id: Install.DependencyID, err: anyerror) void {
|
|
var this = bun.cast(*Queue, ctx);
|
|
debug("onDependencyError: {s}", .{this.vm().packageManager().lockfile.str(&dependency.name)});
|
|
|
|
var modules: []AsyncModule = this.map.items;
|
|
var i: usize = 0;
|
|
outer: for (modules) |module_| {
|
|
var module = module_;
|
|
const root_dependency_ids = module.parse_result.pending_imports.items(.root_dependency_id);
|
|
for (root_dependency_ids, 0..) |dep, dep_i| {
|
|
if (dep != root_dependency_id) continue;
|
|
module.resolveError(
|
|
this.vm(),
|
|
module.parse_result.pending_imports.items(.import_record_id)[dep_i],
|
|
.{
|
|
.name = this.vm().packageManager().lockfile.str(&dependency.name),
|
|
.err = err,
|
|
.url = "",
|
|
.version = dependency.version,
|
|
},
|
|
) catch unreachable;
|
|
continue :outer;
|
|
}
|
|
|
|
modules[i] = module;
|
|
i += 1;
|
|
}
|
|
this.map.items.len = i;
|
|
}
|
|
pub fn onWakeHandler(ctx: *anyopaque, _: *PackageManager) void {
|
|
debug("onWake", .{});
|
|
var this = bun.cast(*Queue, ctx);
|
|
this.vm().enqueueTaskConcurrent(jsc.ConcurrentTask.createFrom(this));
|
|
}
|
|
|
|
pub fn onPoll(this: *Queue) void {
|
|
debug("onPoll", .{});
|
|
this.runTasks();
|
|
this.pollModules();
|
|
}
|
|
|
|
pub fn runTasks(this: *Queue) void {
|
|
var pm = this.vm().packageManager();
|
|
|
|
if (Output.enable_ansi_colors_stderr) {
|
|
pm.startProgressBarIfNone();
|
|
pm.runTasks(
|
|
*Queue,
|
|
this,
|
|
.{
|
|
.onExtract = {},
|
|
.onResolve = onResolve,
|
|
.onPackageManifestError = onPackageManifestError,
|
|
.onPackageDownloadError = onPackageDownloadError,
|
|
.progress_bar = true,
|
|
},
|
|
true,
|
|
PackageManager.Options.LogLevel.default,
|
|
) catch unreachable;
|
|
} else {
|
|
pm.runTasks(
|
|
*Queue,
|
|
this,
|
|
.{
|
|
.onExtract = {},
|
|
.onResolve = onResolve,
|
|
.onPackageManifestError = onPackageManifestError,
|
|
.onPackageDownloadError = onPackageDownloadError,
|
|
},
|
|
true,
|
|
PackageManager.Options.LogLevel.default_no_progress,
|
|
) catch unreachable;
|
|
}
|
|
}
|
|
|
|
pub fn onResolve(_: *Queue) void {
|
|
debug("onResolve", .{});
|
|
}
|
|
|
|
pub fn onPackageManifestError(
|
|
this: *Queue,
|
|
name: []const u8,
|
|
err: anyerror,
|
|
url: []const u8,
|
|
) void {
|
|
debug("onPackageManifestError: {s}", .{name});
|
|
|
|
var modules: []AsyncModule = this.map.items;
|
|
var i: usize = 0;
|
|
outer: for (modules) |module_| {
|
|
var module = module_;
|
|
const tags = module.parse_result.pending_imports.items(.tag);
|
|
for (tags, 0..) |tag, tag_i| {
|
|
if (tag == .resolve) {
|
|
const esms = module.parse_result.pending_imports.items(.esm);
|
|
const esm = esms[tag_i];
|
|
const string_bufs = module.parse_result.pending_imports.items(.string_buf);
|
|
|
|
if (!strings.eql(esm.name.slice(string_bufs[tag_i]), name)) continue;
|
|
|
|
const versions = module.parse_result.pending_imports.items(.dependency);
|
|
|
|
module.resolveError(
|
|
this.vm(),
|
|
module.parse_result.pending_imports.items(.import_record_id)[tag_i],
|
|
.{
|
|
.name = name,
|
|
.err = err,
|
|
.url = url,
|
|
.version = versions[tag_i],
|
|
},
|
|
) catch unreachable;
|
|
continue :outer;
|
|
}
|
|
}
|
|
|
|
modules[i] = module;
|
|
i += 1;
|
|
}
|
|
this.map.items.len = i;
|
|
}
|
|
|
|
pub fn onPackageDownloadError(
|
|
this: *Queue,
|
|
package_id: Install.PackageID,
|
|
name: []const u8,
|
|
resolution: *const Install.Resolution,
|
|
err: anyerror,
|
|
url: []const u8,
|
|
) void {
|
|
debug("onPackageDownloadError: {s}", .{name});
|
|
|
|
const resolution_ids = this.vm().packageManager().lockfile.buffers.resolutions.items;
|
|
var modules: []AsyncModule = this.map.items;
|
|
var i: usize = 0;
|
|
outer: for (modules) |module_| {
|
|
var module = module_;
|
|
const record_ids = module.parse_result.pending_imports.items(.import_record_id);
|
|
const root_dependency_ids = module.parse_result.pending_imports.items(.root_dependency_id);
|
|
for (root_dependency_ids, 0..) |dependency_id, import_id| {
|
|
if (resolution_ids[dependency_id] != package_id) continue;
|
|
module.downloadError(
|
|
this.vm(),
|
|
record_ids[import_id],
|
|
.{
|
|
.name = name,
|
|
.resolution = resolution.*,
|
|
.err = err,
|
|
.url = url,
|
|
},
|
|
) catch unreachable;
|
|
continue :outer;
|
|
}
|
|
|
|
modules[i] = module;
|
|
i += 1;
|
|
}
|
|
this.map.items.len = i;
|
|
}
|
|
|
|
pub fn pollModules(this: *Queue) void {
|
|
var pm = this.vm().packageManager();
|
|
if (pm.pending_tasks.load(.monotonic) > 0) return;
|
|
|
|
var modules: []AsyncModule = this.map.items;
|
|
var i: usize = 0;
|
|
|
|
for (modules) |mod| {
|
|
var module = mod;
|
|
var tags = module.parse_result.pending_imports.items(.tag);
|
|
const root_dependency_ids = module.parse_result.pending_imports.items(.root_dependency_id);
|
|
// var esms = module.parse_result.pending_imports.items(.esm);
|
|
// var versions = module.parse_result.pending_imports.items(.dependency);
|
|
var done_count: usize = 0;
|
|
for (tags, 0..) |tag, tag_i| {
|
|
const root_id = root_dependency_ids[tag_i];
|
|
const resolution_ids = pm.lockfile.buffers.resolutions.items;
|
|
if (root_id >= resolution_ids.len) continue;
|
|
const package_id = resolution_ids[root_id];
|
|
|
|
switch (tag) {
|
|
.resolve => {
|
|
if (package_id == Install.invalid_package_id) {
|
|
continue;
|
|
}
|
|
|
|
// if we get here, the package has already been resolved.
|
|
tags[tag_i] = .download;
|
|
},
|
|
.download => {
|
|
if (package_id == Install.invalid_package_id) {
|
|
unreachable;
|
|
}
|
|
},
|
|
.done => {
|
|
done_count += 1;
|
|
continue;
|
|
},
|
|
}
|
|
|
|
if (package_id == Install.invalid_package_id) {
|
|
continue;
|
|
}
|
|
|
|
const package = pm.lockfile.packages.get(package_id);
|
|
bun.assert(package.resolution.tag != .root);
|
|
|
|
var name_and_version_hash: ?u64 = null;
|
|
var patchfile_hash: ?u64 = null;
|
|
switch (pm.determinePreinstallState(package, pm.lockfile, &name_and_version_hash, &patchfile_hash)) {
|
|
.done => {
|
|
// we are only truly done if all the dependencies are done.
|
|
const current_tasks = pm.total_tasks;
|
|
// so if enqueuing all the dependencies produces no new tasks, we are done.
|
|
pm.enqueueDependencyList(package.dependencies);
|
|
if (current_tasks == pm.total_tasks) {
|
|
tags[tag_i] = .done;
|
|
done_count += 1;
|
|
}
|
|
},
|
|
.extracting => {
|
|
// we are extracting the package
|
|
// we need to wait for the next poll
|
|
continue;
|
|
},
|
|
.extract => {},
|
|
else => {},
|
|
}
|
|
}
|
|
|
|
if (done_count == tags.len) {
|
|
module.done(this.vm());
|
|
} else {
|
|
modules[i] = module;
|
|
i += 1;
|
|
}
|
|
}
|
|
this.map.items.len = i;
|
|
if (i == 0) {
|
|
// ensure we always end the progress bar
|
|
this.vm().packageManager().endProgressBar();
|
|
}
|
|
}
|
|
|
|
pub fn vm(this: *Queue) *VirtualMachine {
|
|
return @alignCast(@fieldParentPtr("modules", this));
|
|
}
|
|
};
|
|
|
|
pub fn init(opts: anytype, globalObject: *JSGlobalObject) !AsyncModule {
|
|
// var stmt_blocks = js_ast.Stmt.Data.toOwnedSlice();
|
|
// var expr_blocks = js_ast.Expr.Data.toOwnedSlice();
|
|
const this_promise = JSValue.createInternalPromise(globalObject);
|
|
const promise = jsc.Strong.Optional.create(this_promise, globalObject);
|
|
|
|
var buf = bun.StringBuilder{};
|
|
buf.count(opts.referrer);
|
|
buf.count(opts.specifier);
|
|
buf.count(opts.path.text);
|
|
|
|
try buf.allocate(bun.default_allocator);
|
|
opts.promise_ptr.?.* = this_promise.asInternalPromise().?;
|
|
const referrer = buf.append(opts.referrer);
|
|
const specifier = buf.append(opts.specifier);
|
|
const path = Fs.Path.init(buf.append(opts.path.text));
|
|
|
|
return AsyncModule{
|
|
.parse_result = opts.parse_result,
|
|
.promise = promise,
|
|
.path = path,
|
|
.specifier = specifier,
|
|
.referrer = referrer,
|
|
.fd = opts.fd,
|
|
.package_json = opts.package_json,
|
|
.loader = opts.loader.toAPI(),
|
|
.string_buf = buf.allocatedSlice(),
|
|
// .stmt_blocks = stmt_blocks,
|
|
// .expr_blocks = expr_blocks,
|
|
.globalThis = globalObject,
|
|
.arena = opts.arena,
|
|
};
|
|
}
|
|
|
|
pub fn done(this: *AsyncModule, jsc_vm: *VirtualMachine) void {
|
|
var clone = jsc_vm.allocator.create(AsyncModule) catch unreachable;
|
|
clone.* = this.*;
|
|
jsc_vm.modules.scheduled += 1;
|
|
clone.any_task = jsc.AnyTask.New(AsyncModule, onDone).init(clone);
|
|
jsc_vm.enqueueTask(jsc.Task.init(&clone.any_task));
|
|
}
|
|
|
|
pub fn onDone(this: *AsyncModule) void {
|
|
jsc.markBinding(@src());
|
|
var jsc_vm = this.globalThis.bunVM();
|
|
jsc_vm.modules.scheduled -= 1;
|
|
if (jsc_vm.modules.scheduled == 0) {
|
|
jsc_vm.packageManager().endProgressBar();
|
|
}
|
|
var log = logger.Log.init(jsc_vm.allocator);
|
|
defer log.deinit();
|
|
var errorable: jsc.ErrorableResolvedSource = undefined;
|
|
this.poll_ref.unref(jsc_vm);
|
|
outer: {
|
|
errorable = jsc.ErrorableResolvedSource.ok(this.resumeLoadingModule(&log) catch |err| {
|
|
switch (err) {
|
|
error.JSError => {
|
|
errorable = .err(error.JSError, this.globalThis.takeError(error.JSError));
|
|
break :outer;
|
|
},
|
|
else => {
|
|
VirtualMachine.processFetchLog(
|
|
this.globalThis,
|
|
bun.String.init(this.specifier),
|
|
bun.String.init(this.referrer),
|
|
&log,
|
|
&errorable,
|
|
err,
|
|
);
|
|
break :outer;
|
|
},
|
|
}
|
|
});
|
|
}
|
|
|
|
var spec = bun.String.init(ZigString.init(this.specifier).withEncoding());
|
|
var ref = bun.String.init(ZigString.init(this.referrer).withEncoding());
|
|
bun.jsc.fromJSHostCallGeneric(this.globalThis, @src(), Bun__onFulfillAsyncModule, .{
|
|
this.globalThis,
|
|
this.promise.get().?,
|
|
&errorable,
|
|
&spec,
|
|
&ref,
|
|
}) catch {};
|
|
this.deinit();
|
|
jsc_vm.allocator.destroy(this);
|
|
}
|
|
|
|
pub fn fulfill(
|
|
globalThis: *JSGlobalObject,
|
|
promise: JSValue,
|
|
resolved_source: *ResolvedSource,
|
|
err: ?anyerror,
|
|
specifier_: bun.String,
|
|
referrer_: bun.String,
|
|
log: *logger.Log,
|
|
) bun.JSError!void {
|
|
jsc.markBinding(@src());
|
|
var specifier = specifier_;
|
|
var referrer = referrer_;
|
|
var scope: jsc.CatchScope = undefined;
|
|
scope.init(globalThis, @src());
|
|
defer {
|
|
specifier.deref();
|
|
referrer.deref();
|
|
scope.deinit();
|
|
}
|
|
|
|
var errorable: jsc.ErrorableResolvedSource = undefined;
|
|
if (err) |e| {
|
|
defer {
|
|
if (resolved_source.source_code_needs_deref) {
|
|
resolved_source.source_code_needs_deref = false;
|
|
resolved_source.source_code.deref();
|
|
}
|
|
}
|
|
|
|
if (e == error.JSError) {
|
|
errorable = jsc.ErrorableResolvedSource.err(error.JSError, globalThis.takeError(error.JSError));
|
|
} else {
|
|
VirtualMachine.processFetchLog(
|
|
globalThis,
|
|
specifier,
|
|
referrer,
|
|
log,
|
|
&errorable,
|
|
e,
|
|
);
|
|
}
|
|
} else {
|
|
errorable = jsc.ErrorableResolvedSource.ok(resolved_source.*);
|
|
}
|
|
log.deinit();
|
|
|
|
debug("fulfill: {any}", .{specifier});
|
|
|
|
try bun.jsc.fromJSHostCallGeneric(globalThis, @src(), Bun__onFulfillAsyncModule, .{
|
|
globalThis,
|
|
promise,
|
|
&errorable,
|
|
&specifier,
|
|
&referrer,
|
|
});
|
|
}
|
|
|
|
pub fn resolveError(this: *AsyncModule, vm: *VirtualMachine, import_record_id: u32, result: PackageResolveError) !void {
|
|
const globalThis = this.globalThis;
|
|
|
|
const msg: []u8 = try switch (result.err) {
|
|
error.PackageManifestHTTP400 => std.fmt.allocPrint(
|
|
bun.default_allocator,
|
|
"HTTP 400 while resolving package '{s}' at '{s}'",
|
|
.{ result.name, result.url },
|
|
),
|
|
error.PackageManifestHTTP401 => std.fmt.allocPrint(
|
|
bun.default_allocator,
|
|
"HTTP 401 while resolving package '{s}' at '{s}'",
|
|
.{ result.name, result.url },
|
|
),
|
|
error.PackageManifestHTTP402 => std.fmt.allocPrint(
|
|
bun.default_allocator,
|
|
"HTTP 402 while resolving package '{s}' at '{s}'",
|
|
.{ result.name, result.url },
|
|
),
|
|
error.PackageManifestHTTP403 => std.fmt.allocPrint(
|
|
bun.default_allocator,
|
|
"HTTP 403 while resolving package '{s}' at '{s}'",
|
|
.{ result.name, result.url },
|
|
),
|
|
error.PackageManifestHTTP404 => std.fmt.allocPrint(
|
|
bun.default_allocator,
|
|
"Package '{s}' was not found",
|
|
.{result.name},
|
|
),
|
|
error.PackageManifestHTTP4xx => std.fmt.allocPrint(
|
|
bun.default_allocator,
|
|
"HTTP 4xx while resolving package '{s}' at '{s}'",
|
|
.{ result.name, result.url },
|
|
),
|
|
error.PackageManifestHTTP5xx => std.fmt.allocPrint(
|
|
bun.default_allocator,
|
|
"HTTP 5xx while resolving package '{s}' at '{s}'",
|
|
.{ result.name, result.url },
|
|
),
|
|
error.DistTagNotFound, error.NoMatchingVersion => brk: {
|
|
const prefix: []const u8 = if (result.err == error.NoMatchingVersion and result.version.tag == .npm and result.version.value.npm.version.isExact())
|
|
"Version not found"
|
|
else if (result.version.tag == .npm and !result.version.value.npm.version.isExact())
|
|
"No matching version found"
|
|
else
|
|
"No match found";
|
|
|
|
break :brk std.fmt.allocPrint(
|
|
bun.default_allocator,
|
|
"{s} '{s}' for package '{s}' (but package exists)",
|
|
.{ prefix, vm.packageManager().lockfile.str(&result.version.literal), result.name },
|
|
);
|
|
},
|
|
else => |err| std.fmt.allocPrint(
|
|
bun.default_allocator,
|
|
"{s} resolving package '{s}' at '{s}'",
|
|
.{ bun.asByteSlice(@errorName(err)), result.name, result.url },
|
|
),
|
|
};
|
|
|
|
const name: []const u8 = switch (result.err) {
|
|
error.NoMatchingVersion => "PackageVersionNotFound",
|
|
error.DistTagNotFound => "PackageTagNotFound",
|
|
error.PackageManifestHTTP403 => "PackageForbidden",
|
|
error.PackageManifestHTTP404 => "PackageNotFound",
|
|
else => "PackageResolveError",
|
|
};
|
|
|
|
var error_instance = ZigString.init(msg).withEncoding().toErrorInstance(globalThis);
|
|
if (result.url.len > 0)
|
|
error_instance.put(globalThis, ZigString.static("url"), ZigString.init(result.url).withEncoding().toJS(globalThis));
|
|
error_instance.put(globalThis, ZigString.static("name"), ZigString.init(name).withEncoding().toJS(globalThis));
|
|
error_instance.put(globalThis, ZigString.static("pkg"), ZigString.init(result.name).withEncoding().toJS(globalThis));
|
|
error_instance.put(globalThis, ZigString.static("specifier"), ZigString.init(this.specifier).withEncoding().toJS(globalThis));
|
|
const location = logger.rangeData(&this.parse_result.source, this.parse_result.ast.import_records.at(import_record_id).range, "").location.?;
|
|
error_instance.put(globalThis, ZigString.static("sourceURL"), ZigString.init(this.parse_result.source.path.text).withEncoding().toJS(globalThis));
|
|
error_instance.put(globalThis, ZigString.static("line"), JSValue.jsNumber(location.line));
|
|
if (location.line_text) |line_text| {
|
|
error_instance.put(globalThis, ZigString.static("lineText"), ZigString.init(line_text).withEncoding().toJS(globalThis));
|
|
}
|
|
error_instance.put(globalThis, ZigString.static("column"), JSValue.jsNumber(location.column));
|
|
if (this.referrer.len > 0 and !strings.eqlComptime(this.referrer, "undefined")) {
|
|
error_instance.put(globalThis, ZigString.static("referrer"), ZigString.init(this.referrer).withEncoding().toJS(globalThis));
|
|
}
|
|
|
|
const promise_value = this.promise.swap();
|
|
var promise = promise_value.asInternalPromise().?;
|
|
promise_value.ensureStillAlive();
|
|
this.poll_ref.unref(vm);
|
|
this.deinit();
|
|
promise.rejectAsHandled(globalThis, error_instance);
|
|
}
|
|
pub fn downloadError(this: *AsyncModule, vm: *VirtualMachine, import_record_id: u32, result: PackageDownloadError) !void {
|
|
const globalThis = this.globalThis;
|
|
|
|
const msg_args = .{
|
|
result.name,
|
|
result.resolution.fmt(vm.packageManager().lockfile.buffers.string_bytes.items, .any),
|
|
};
|
|
|
|
const msg: []u8 = try switch (result.err) {
|
|
error.TarballHTTP400 => std.fmt.allocPrint(
|
|
bun.default_allocator,
|
|
"HTTP 400 downloading package '{s}@{any}'",
|
|
msg_args,
|
|
),
|
|
error.TarballHTTP401 => std.fmt.allocPrint(
|
|
bun.default_allocator,
|
|
"HTTP 401 downloading package '{s}@{any}'",
|
|
msg_args,
|
|
),
|
|
error.TarballHTTP402 => std.fmt.allocPrint(
|
|
bun.default_allocator,
|
|
"HTTP 402 downloading package '{s}@{any}'",
|
|
msg_args,
|
|
),
|
|
error.TarballHTTP403 => std.fmt.allocPrint(
|
|
bun.default_allocator,
|
|
"HTTP 403 downloading package '{s}@{any}'",
|
|
msg_args,
|
|
),
|
|
error.TarballHTTP404 => std.fmt.allocPrint(
|
|
bun.default_allocator,
|
|
"HTTP 404 downloading package '{s}@{any}'",
|
|
msg_args,
|
|
),
|
|
error.TarballHTTP4xx => std.fmt.allocPrint(
|
|
bun.default_allocator,
|
|
"HTTP 4xx downloading package '{s}@{any}'",
|
|
msg_args,
|
|
),
|
|
error.TarballHTTP5xx => std.fmt.allocPrint(
|
|
bun.default_allocator,
|
|
"HTTP 5xx downloading package '{s}@{any}'",
|
|
msg_args,
|
|
),
|
|
error.TarballFailedToExtract => std.fmt.allocPrint(
|
|
bun.default_allocator,
|
|
"Failed to extract tarball for package '{s}@{any}'",
|
|
msg_args,
|
|
),
|
|
else => |err| std.fmt.allocPrint(
|
|
bun.default_allocator,
|
|
"{s} downloading package '{s}@{any}'",
|
|
.{
|
|
bun.asByteSlice(@errorName(err)),
|
|
result.name,
|
|
result.resolution.fmt(vm.packageManager().lockfile.buffers.string_bytes.items, .any),
|
|
},
|
|
),
|
|
};
|
|
|
|
const name: []const u8 = switch (result.err) {
|
|
error.TarballFailedToExtract => "PackageExtractionError",
|
|
error.TarballHTTP403 => "TarballForbiddenError",
|
|
error.TarballHTTP404 => "TarballNotFoundError",
|
|
else => "TarballDownloadError",
|
|
};
|
|
|
|
var error_instance = ZigString.init(msg).withEncoding().toErrorInstance(globalThis);
|
|
if (result.url.len > 0)
|
|
error_instance.put(globalThis, ZigString.static("url"), ZigString.init(result.url).withEncoding().toJS(globalThis));
|
|
error_instance.put(globalThis, ZigString.static("name"), ZigString.init(name).withEncoding().toJS(globalThis));
|
|
error_instance.put(globalThis, ZigString.static("pkg"), ZigString.init(result.name).withEncoding().toJS(globalThis));
|
|
if (this.specifier.len > 0 and !strings.eqlComptime(this.specifier, "undefined")) {
|
|
error_instance.put(globalThis, ZigString.static("referrer"), ZigString.init(this.specifier).withEncoding().toJS(globalThis));
|
|
}
|
|
|
|
const location = logger.rangeData(&this.parse_result.source, this.parse_result.ast.import_records.at(import_record_id).range, "").location.?;
|
|
error_instance.put(globalThis, ZigString.static("specifier"), ZigString.init(
|
|
this.parse_result.ast.import_records.at(import_record_id).path.text,
|
|
).withEncoding().toJS(globalThis));
|
|
error_instance.put(globalThis, ZigString.static("sourceURL"), ZigString.init(this.parse_result.source.path.text).withEncoding().toJS(globalThis));
|
|
error_instance.put(globalThis, ZigString.static("line"), JSValue.jsNumber(location.line));
|
|
if (location.line_text) |line_text| {
|
|
error_instance.put(globalThis, ZigString.static("lineText"), ZigString.init(line_text).withEncoding().toJS(globalThis));
|
|
}
|
|
error_instance.put(globalThis, ZigString.static("column"), JSValue.jsNumber(location.column));
|
|
|
|
const promise_value = this.promise.swap();
|
|
var promise = promise_value.asInternalPromise().?;
|
|
promise_value.ensureStillAlive();
|
|
this.poll_ref.unref(vm);
|
|
this.deinit();
|
|
promise.rejectAsHandled(globalThis, error_instance);
|
|
}
|
|
|
|
pub fn resumeLoadingModule(this: *AsyncModule, log: *logger.Log) !ResolvedSource {
|
|
debug("resumeLoadingModule: {s}", .{this.specifier});
|
|
var parse_result = this.parse_result;
|
|
const path = this.path;
|
|
var jsc_vm = VirtualMachine.get();
|
|
const specifier = this.specifier;
|
|
const old_log = jsc_vm.log;
|
|
|
|
jsc_vm.transpiler.linker.log = log;
|
|
jsc_vm.transpiler.log = log;
|
|
jsc_vm.transpiler.resolver.log = log;
|
|
jsc_vm.packageManager().log = log;
|
|
defer {
|
|
jsc_vm.transpiler.linker.log = old_log;
|
|
jsc_vm.transpiler.log = old_log;
|
|
jsc_vm.transpiler.resolver.log = old_log;
|
|
jsc_vm.packageManager().log = old_log;
|
|
}
|
|
|
|
// We _must_ link because:
|
|
// - node_modules bundle won't be properly
|
|
try jsc_vm.transpiler.linker.link(
|
|
path,
|
|
&parse_result,
|
|
jsc_vm.origin,
|
|
.absolute_path,
|
|
false,
|
|
true,
|
|
);
|
|
this.parse_result = parse_result;
|
|
|
|
var printer = VirtualMachine.source_code_printer.?.*;
|
|
printer.ctx.reset();
|
|
|
|
{
|
|
var mapper = jsc_vm.sourceMapHandler(&printer);
|
|
defer VirtualMachine.source_code_printer.?.* = printer;
|
|
_ = try jsc_vm.transpiler.printWithSourceMap(
|
|
parse_result,
|
|
@TypeOf(&printer),
|
|
&printer,
|
|
.esm_ascii,
|
|
mapper.get(),
|
|
);
|
|
}
|
|
|
|
if (comptime Environment.dump_source) {
|
|
dumpSource(jsc_vm, specifier, &printer);
|
|
}
|
|
|
|
if (jsc_vm.isWatcherEnabled()) {
|
|
var resolved_source = jsc_vm.refCountedResolvedSource(printer.ctx.written, bun.String.init(specifier), path.text, null, false);
|
|
|
|
if (parse_result.input_fd) |fd_| {
|
|
if (std.fs.path.isAbsolute(path.text) and !strings.contains(path.text, "node_modules")) {
|
|
_ = jsc_vm.bun_watcher.addFile(
|
|
fd_,
|
|
path.text,
|
|
this.hash,
|
|
options.Loader.fromAPI(this.loader),
|
|
.invalid,
|
|
this.package_json,
|
|
true,
|
|
);
|
|
}
|
|
}
|
|
|
|
resolved_source.is_commonjs_module = parse_result.ast.has_commonjs_export_names or parse_result.ast.exports_kind == .cjs;
|
|
|
|
return resolved_source;
|
|
}
|
|
|
|
return ResolvedSource{
|
|
.allocator = null,
|
|
.source_code = bun.String.cloneLatin1(printer.ctx.getWritten()),
|
|
.specifier = String.init(specifier),
|
|
.source_url = String.init(path.text),
|
|
.is_commonjs_module = parse_result.ast.has_commonjs_export_names or parse_result.ast.exports_kind == .cjs,
|
|
};
|
|
}
|
|
|
|
pub fn deinit(this: *AsyncModule) void {
|
|
this.promise.deinit();
|
|
this.parse_result.deinit();
|
|
this.arena.deinit();
|
|
this.globalThis.bunVM().allocator.destroy(this.arena);
|
|
// bun.default_allocator.free(this.stmt_blocks);
|
|
// bun.default_allocator.free(this.expr_blocks);
|
|
|
|
bun.default_allocator.free(this.string_buf);
|
|
}
|
|
|
|
extern "c" fn Bun__onFulfillAsyncModule(
|
|
globalObject: *JSGlobalObject,
|
|
promiseValue: JSValue,
|
|
res: *jsc.ErrorableResolvedSource,
|
|
specifier: *bun.String,
|
|
referrer: *bun.String,
|
|
) void;
|
|
};
|
|
|
|
pub export fn Bun__getDefaultLoader(global: *JSGlobalObject, str: *const bun.String) api.Loader {
|
|
var jsc_vm = global.bunVM();
|
|
const filename = str.toUTF8(jsc_vm.allocator);
|
|
defer filename.deinit();
|
|
const loader = jsc_vm.transpiler.options.loader(Fs.PathName.init(filename.slice()).ext).toAPI();
|
|
if (loader == .file) {
|
|
return api.Loader.js;
|
|
}
|
|
|
|
return loader;
|
|
}
|
|
|
|
pub fn transpileSourceCode(
|
|
jsc_vm: *VirtualMachine,
|
|
specifier: string,
|
|
referrer: string,
|
|
input_specifier: String,
|
|
path: Fs.Path,
|
|
loader: options.Loader,
|
|
module_type: options.ModuleType,
|
|
log: *logger.Log,
|
|
virtual_source: ?*const logger.Source,
|
|
promise_ptr: ?*?*jsc.JSInternalPromise,
|
|
source_code_printer: *js_printer.BufferPrinter,
|
|
globalObject: ?*JSGlobalObject,
|
|
comptime flags: FetchFlags,
|
|
) !ResolvedSource {
|
|
const disable_transpilying = comptime flags.disableTranspiling();
|
|
|
|
if (comptime disable_transpilying) {
|
|
if (!(loader.isJavaScriptLike() or loader == .toml or loader == .yaml or loader == .text or loader == .json or loader == .jsonc)) {
|
|
// Don't print "export default <file path>"
|
|
return ResolvedSource{
|
|
.allocator = null,
|
|
.source_code = bun.String.empty,
|
|
.specifier = input_specifier,
|
|
.source_url = input_specifier.createIfDifferent(path.text),
|
|
};
|
|
}
|
|
}
|
|
|
|
switch (loader) {
|
|
.js, .jsx, .ts, .tsx, .json, .jsonc, .toml, .yaml, .text => {
|
|
// Ensure that if there was an ASTMemoryAllocator in use, it's not used anymore.
|
|
var ast_scope = js_ast.ASTMemoryAllocator.Scope{};
|
|
ast_scope.enter();
|
|
defer ast_scope.exit();
|
|
|
|
jsc_vm.transpiled_count += 1;
|
|
jsc_vm.transpiler.resetStore();
|
|
const hash = bun.Watcher.getHash(path.text);
|
|
const is_main = jsc_vm.main.len == path.text.len and
|
|
jsc_vm.main_hash == hash and
|
|
strings.eqlLong(jsc_vm.main, path.text, false);
|
|
|
|
var arena_: ?*bun.ArenaAllocator = brk: {
|
|
// Attempt to reuse the Arena from the parser when we can
|
|
// This code is potentially re-entrant, so only one Arena can be reused at a time
|
|
// That's why we have to check if the Arena is null
|
|
//
|
|
// Using an Arena here is a significant memory optimization when loading many files
|
|
if (jsc_vm.module_loader.transpile_source_code_arena) |shared| {
|
|
jsc_vm.module_loader.transpile_source_code_arena = null;
|
|
break :brk shared;
|
|
}
|
|
|
|
// we must allocate the arena so that the pointer it points to is always valid.
|
|
const arena = try jsc_vm.allocator.create(bun.ArenaAllocator);
|
|
arena.* = bun.ArenaAllocator.init(bun.default_allocator);
|
|
break :brk arena;
|
|
};
|
|
|
|
var give_back_arena = true;
|
|
defer {
|
|
if (give_back_arena) {
|
|
if (jsc_vm.module_loader.transpile_source_code_arena == null) {
|
|
// when .print_source is used
|
|
// caller is responsible for freeing the arena
|
|
if (flags != .print_source) {
|
|
if (jsc_vm.smol) {
|
|
_ = arena_.?.reset(.free_all);
|
|
} else {
|
|
_ = arena_.?.reset(.{ .retain_with_limit = 8 * 1024 * 1024 });
|
|
}
|
|
}
|
|
|
|
jsc_vm.module_loader.transpile_source_code_arena = arena_;
|
|
} else {
|
|
arena_.?.deinit();
|
|
jsc_vm.allocator.destroy(arena_.?);
|
|
}
|
|
}
|
|
}
|
|
|
|
var arena = arena_.?;
|
|
const allocator = arena.allocator();
|
|
|
|
var fd: ?StoredFileDescriptorType = null;
|
|
var package_json: ?*PackageJSON = null;
|
|
|
|
if (jsc_vm.bun_watcher.indexOf(hash)) |index| {
|
|
fd = jsc_vm.bun_watcher.watchlist().items(.fd)[index].unwrapValid();
|
|
package_json = jsc_vm.bun_watcher.watchlist().items(.package_json)[index];
|
|
}
|
|
|
|
var cache = jsc.RuntimeTranspilerCache{
|
|
.output_code_allocator = allocator,
|
|
.sourcemap_allocator = bun.default_allocator,
|
|
};
|
|
|
|
const old = jsc_vm.transpiler.log;
|
|
jsc_vm.transpiler.log = log;
|
|
jsc_vm.transpiler.linker.log = log;
|
|
jsc_vm.transpiler.resolver.log = log;
|
|
if (jsc_vm.transpiler.resolver.package_manager) |pm| {
|
|
pm.log = log;
|
|
}
|
|
|
|
defer {
|
|
jsc_vm.transpiler.log = old;
|
|
jsc_vm.transpiler.linker.log = old;
|
|
jsc_vm.transpiler.resolver.log = old;
|
|
if (jsc_vm.transpiler.resolver.package_manager) |pm| {
|
|
pm.log = old;
|
|
}
|
|
}
|
|
|
|
// this should be a cheap lookup because 24 bytes == 8 * 3 so it's read 3 machine words
|
|
const is_node_override = strings.hasPrefixComptime(specifier, node_fallbacks.import_path);
|
|
|
|
const macro_remappings = if (jsc_vm.macro_mode or !jsc_vm.has_any_macro_remappings or is_node_override)
|
|
MacroRemap{}
|
|
else
|
|
jsc_vm.transpiler.options.macro_remap;
|
|
|
|
var fallback_source: logger.Source = undefined;
|
|
|
|
// Usually, we want to close the input file automatically.
|
|
//
|
|
// If we're re-using the file descriptor from the fs watcher
|
|
// Do not close it because that will break the kqueue-based watcher
|
|
//
|
|
var should_close_input_file_fd = fd == null;
|
|
|
|
// We don't want cjs wrappers around non-js files
|
|
const module_type_only_for_wrappables = switch (loader) {
|
|
.js, .jsx, .ts, .tsx => module_type,
|
|
else => .unknown,
|
|
};
|
|
|
|
var input_file_fd: StoredFileDescriptorType = bun.invalid_fd;
|
|
var parse_options = Transpiler.ParseOptions{
|
|
.allocator = allocator,
|
|
.path = path,
|
|
.loader = loader,
|
|
.dirname_fd = bun.invalid_fd,
|
|
.file_descriptor = fd,
|
|
.file_fd_ptr = &input_file_fd,
|
|
.file_hash = hash,
|
|
.macro_remappings = macro_remappings,
|
|
.jsx = jsc_vm.transpiler.options.jsx,
|
|
.emit_decorator_metadata = jsc_vm.transpiler.options.emit_decorator_metadata,
|
|
.virtual_source = virtual_source,
|
|
.dont_bundle_twice = true,
|
|
.allow_commonjs = true,
|
|
.module_type = module_type_only_for_wrappables,
|
|
.inject_jest_globals = jsc_vm.transpiler.options.rewrite_jest_for_tests,
|
|
.keep_json_and_toml_as_one_statement = true,
|
|
.allow_bytecode_cache = true,
|
|
.set_breakpoint_on_first_line = is_main and
|
|
jsc_vm.debugger != null and
|
|
jsc_vm.debugger.?.set_breakpoint_on_first_line and
|
|
setBreakPointOnFirstLine(),
|
|
.runtime_transpiler_cache = if (!disable_transpilying and !jsc.RuntimeTranspilerCache.is_disabled) &cache else null,
|
|
.remove_cjs_module_wrapper = is_main and jsc_vm.module_loader.eval_source != null,
|
|
};
|
|
defer {
|
|
if (should_close_input_file_fd and input_file_fd != bun.invalid_fd) {
|
|
input_file_fd.close();
|
|
input_file_fd = bun.invalid_fd;
|
|
}
|
|
}
|
|
|
|
if (is_node_override) {
|
|
if (node_fallbacks.contentsFromPath(specifier)) |code| {
|
|
const fallback_path = Fs.Path.initWithNamespace(specifier, "node");
|
|
fallback_source = logger.Source{ .path = fallback_path, .contents = code };
|
|
parse_options.virtual_source = &fallback_source;
|
|
}
|
|
}
|
|
|
|
var parse_result: ParseResult = switch (disable_transpilying or
|
|
(loader == .json)) {
|
|
inline else => |return_file_only| brk: {
|
|
break :brk jsc_vm.transpiler.parseMaybeReturnFileOnly(
|
|
parse_options,
|
|
null,
|
|
return_file_only,
|
|
) orelse {
|
|
if (comptime !disable_transpilying) {
|
|
if (jsc_vm.isWatcherEnabled()) {
|
|
if (input_file_fd.isValid()) {
|
|
if (!is_node_override and std.fs.path.isAbsolute(path.text) and !strings.contains(path.text, "node_modules")) {
|
|
should_close_input_file_fd = false;
|
|
_ = jsc_vm.bun_watcher.addFile(
|
|
input_file_fd,
|
|
path.text,
|
|
hash,
|
|
loader,
|
|
.invalid,
|
|
package_json,
|
|
true,
|
|
);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
give_back_arena = false;
|
|
return error.ParseError;
|
|
};
|
|
},
|
|
};
|
|
|
|
const source = &parse_result.source;
|
|
|
|
if (parse_result.loader == .wasm) {
|
|
return transpileSourceCode(
|
|
jsc_vm,
|
|
specifier,
|
|
referrer,
|
|
input_specifier,
|
|
path,
|
|
.wasm,
|
|
.unknown, // cjs/esm don't make sense for wasm
|
|
log,
|
|
&parse_result.source,
|
|
promise_ptr,
|
|
source_code_printer,
|
|
globalObject,
|
|
flags,
|
|
);
|
|
}
|
|
|
|
if (comptime !disable_transpilying) {
|
|
if (jsc_vm.isWatcherEnabled()) {
|
|
if (input_file_fd.isValid()) {
|
|
if (!is_node_override and std.fs.path.isAbsolute(path.text) and !strings.contains(path.text, "node_modules")) {
|
|
should_close_input_file_fd = false;
|
|
_ = jsc_vm.bun_watcher.addFile(
|
|
input_file_fd,
|
|
path.text,
|
|
hash,
|
|
loader,
|
|
.invalid,
|
|
package_json,
|
|
true,
|
|
);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (jsc_vm.transpiler.log.errors > 0) {
|
|
give_back_arena = false;
|
|
return error.ParseError;
|
|
}
|
|
|
|
if (loader == .json) {
|
|
return ResolvedSource{
|
|
.allocator = null,
|
|
.source_code = bun.String.cloneUTF8(source.contents),
|
|
.specifier = input_specifier,
|
|
.source_url = input_specifier.createIfDifferent(path.text),
|
|
.tag = ResolvedSource.Tag.json_for_object_loader,
|
|
};
|
|
}
|
|
|
|
if (comptime disable_transpilying) {
|
|
return ResolvedSource{
|
|
.allocator = null,
|
|
.source_code = switch (comptime flags) {
|
|
.print_source_and_clone => bun.String.init(jsc_vm.allocator.dupe(u8, source.contents) catch unreachable),
|
|
.print_source => bun.String.init(source.contents),
|
|
else => @compileError("unreachable"),
|
|
},
|
|
.specifier = input_specifier,
|
|
.source_url = input_specifier.createIfDifferent(path.text),
|
|
};
|
|
}
|
|
|
|
if (loader == .json or loader == .jsonc or loader == .toml or loader == .yaml) {
|
|
if (parse_result.empty) {
|
|
return ResolvedSource{
|
|
.allocator = null,
|
|
.specifier = input_specifier,
|
|
.source_url = input_specifier.createIfDifferent(path.text),
|
|
.jsvalue_for_export = JSValue.createEmptyObject(jsc_vm.global, 0),
|
|
.tag = .exports_object,
|
|
};
|
|
}
|
|
|
|
return ResolvedSource{
|
|
.allocator = null,
|
|
.specifier = input_specifier,
|
|
.source_url = input_specifier.createIfDifferent(path.text),
|
|
.jsvalue_for_export = parse_result.ast.parts.at(0).stmts[0].data.s_expr.value.toJS(allocator, globalObject orelse jsc_vm.global) catch |e| panic("Unexpected JS error: {s}", .{@errorName(e)}),
|
|
.tag = .exports_object,
|
|
};
|
|
}
|
|
|
|
if (parse_result.already_bundled != .none) {
|
|
const bytecode_slice = parse_result.already_bundled.bytecodeSlice();
|
|
return ResolvedSource{
|
|
.allocator = null,
|
|
.source_code = bun.String.cloneLatin1(source.contents),
|
|
.specifier = input_specifier,
|
|
.source_url = input_specifier.createIfDifferent(path.text),
|
|
.already_bundled = true,
|
|
.bytecode_cache = if (bytecode_slice.len > 0) bytecode_slice.ptr else null,
|
|
.bytecode_cache_size = bytecode_slice.len,
|
|
.is_commonjs_module = parse_result.already_bundled.isCommonJS(),
|
|
};
|
|
}
|
|
|
|
if (parse_result.empty) {
|
|
const was_cjs = (loader == .js or loader == .ts) and brk: {
|
|
const ext = std.fs.path.extension(source.path.text);
|
|
break :brk strings.eqlComptime(ext, ".cjs") or strings.eqlComptime(ext, ".cts");
|
|
};
|
|
if (was_cjs) {
|
|
return .{
|
|
.allocator = null,
|
|
.source_code = bun.String.static("(function(){})"),
|
|
.specifier = input_specifier,
|
|
.source_url = input_specifier.createIfDifferent(path.text),
|
|
.is_commonjs_module = true,
|
|
.tag = .javascript,
|
|
};
|
|
}
|
|
}
|
|
|
|
if (cache.entry) |*entry| {
|
|
jsc_vm.source_mappings.putMappings(source, .{
|
|
.list = .{ .items = @constCast(entry.sourcemap), .capacity = entry.sourcemap.len },
|
|
.allocator = bun.default_allocator,
|
|
}) catch {};
|
|
|
|
if (comptime Environment.allow_assert) {
|
|
dumpSourceString(jsc_vm, specifier, entry.output_code.byteSlice());
|
|
}
|
|
|
|
return ResolvedSource{
|
|
.allocator = null,
|
|
.source_code = switch (entry.output_code) {
|
|
.string => entry.output_code.string,
|
|
.utf8 => brk: {
|
|
const result = bun.String.cloneUTF8(entry.output_code.utf8);
|
|
cache.output_code_allocator.free(entry.output_code.utf8);
|
|
entry.output_code.utf8 = "";
|
|
break :brk result;
|
|
},
|
|
},
|
|
.specifier = input_specifier,
|
|
.source_url = input_specifier.createIfDifferent(path.text),
|
|
.is_commonjs_module = entry.metadata.module_type == .cjs,
|
|
.tag = brk: {
|
|
if (entry.metadata.module_type == .cjs and source.path.isFile()) {
|
|
const actual_package_json: *PackageJSON = package_json orelse brk2: {
|
|
// this should already be cached virtually always so it's fine to do this
|
|
const dir_info = (jsc_vm.transpiler.resolver.readDirInfo(source.path.name.dir) catch null) orelse
|
|
break :brk .javascript;
|
|
|
|
break :brk2 dir_info.package_json orelse dir_info.enclosing_package_json;
|
|
} orelse break :brk .javascript;
|
|
|
|
if (actual_package_json.module_type == .esm) {
|
|
break :brk ResolvedSource.Tag.package_json_type_module;
|
|
}
|
|
}
|
|
|
|
break :brk ResolvedSource.Tag.javascript;
|
|
},
|
|
};
|
|
}
|
|
|
|
const start_count = jsc_vm.transpiler.linker.import_counter;
|
|
|
|
// We _must_ link because:
|
|
// - node_modules bundle won't be properly
|
|
try jsc_vm.transpiler.linker.link(
|
|
path,
|
|
&parse_result,
|
|
jsc_vm.origin,
|
|
.absolute_path,
|
|
false,
|
|
true,
|
|
);
|
|
|
|
if (parse_result.pending_imports.len > 0) {
|
|
if (promise_ptr == null) {
|
|
return error.UnexpectedPendingResolution;
|
|
}
|
|
|
|
if (source.contents_is_recycled) {
|
|
// this shared buffer is about to become owned by the AsyncModule struct
|
|
jsc_vm.transpiler.resolver.caches.fs.resetSharedBuffer(
|
|
jsc_vm.transpiler.resolver.caches.fs.sharedBuffer(),
|
|
);
|
|
}
|
|
|
|
jsc_vm.modules.enqueue(
|
|
globalObject.?,
|
|
.{
|
|
.parse_result = parse_result,
|
|
.path = path,
|
|
.loader = loader,
|
|
.fd = fd,
|
|
.package_json = package_json,
|
|
.hash = hash,
|
|
.promise_ptr = promise_ptr,
|
|
.specifier = specifier,
|
|
.referrer = referrer,
|
|
.arena = arena,
|
|
},
|
|
);
|
|
give_back_arena = false;
|
|
return error.AsyncModule;
|
|
}
|
|
|
|
if (!jsc_vm.macro_mode)
|
|
jsc_vm.resolved_count += jsc_vm.transpiler.linker.import_counter - start_count;
|
|
jsc_vm.transpiler.linker.import_counter = 0;
|
|
|
|
var printer = source_code_printer.*;
|
|
printer.ctx.reset();
|
|
defer source_code_printer.* = printer;
|
|
_ = brk: {
|
|
var mapper = jsc_vm.sourceMapHandler(&printer);
|
|
|
|
break :brk try jsc_vm.transpiler.printWithSourceMap(
|
|
parse_result,
|
|
@TypeOf(&printer),
|
|
&printer,
|
|
.esm_ascii,
|
|
mapper.get(),
|
|
);
|
|
};
|
|
|
|
if (comptime Environment.dump_source) {
|
|
dumpSource(jsc_vm, specifier, &printer);
|
|
}
|
|
|
|
defer {
|
|
if (is_main) {
|
|
jsc_vm.has_loaded = true;
|
|
}
|
|
}
|
|
|
|
if (jsc_vm.isWatcherEnabled()) {
|
|
var resolved_source = jsc_vm.refCountedResolvedSource(printer.ctx.written, input_specifier, path.text, null, false);
|
|
resolved_source.is_commonjs_module = parse_result.ast.has_commonjs_export_names or parse_result.ast.exports_kind == .cjs;
|
|
return resolved_source;
|
|
}
|
|
|
|
// Pass along package.json type "module" if set.
|
|
const tag: ResolvedSource.Tag = switch (loader) {
|
|
.json, .jsonc => .json_for_object_loader,
|
|
.js, .jsx, .ts, .tsx => brk: {
|
|
const module_type_ = if (package_json) |pkg| pkg.module_type else module_type;
|
|
|
|
break :brk switch (module_type_) {
|
|
.esm => .package_json_type_module,
|
|
.cjs => .package_json_type_commonjs,
|
|
else => .javascript,
|
|
};
|
|
},
|
|
else => .javascript,
|
|
};
|
|
|
|
return .{
|
|
.allocator = null,
|
|
.source_code = brk: {
|
|
const written = printer.ctx.getWritten();
|
|
const result = cache.output_code orelse bun.String.cloneLatin1(written);
|
|
|
|
if (written.len > 1024 * 1024 * 2 or jsc_vm.smol) {
|
|
printer.ctx.buffer.deinit();
|
|
}
|
|
|
|
break :brk result;
|
|
},
|
|
.specifier = input_specifier,
|
|
.source_url = input_specifier.createIfDifferent(path.text),
|
|
.is_commonjs_module = parse_result.ast.has_commonjs_export_names or parse_result.ast.exports_kind == .cjs,
|
|
.tag = tag,
|
|
};
|
|
},
|
|
// provideFetch() should be called
|
|
.napi => unreachable,
|
|
// .wasm => {
|
|
// jsc_vm.transpiled_count += 1;
|
|
// var fd: ?StoredFileDescriptorType = null;
|
|
|
|
// var allocator = if (jsc_vm.has_loaded) jsc_vm.arena.allocator() else jsc_vm.allocator;
|
|
|
|
// const hash = http.Watcher.getHash(path.text);
|
|
// if (jsc_vm.watcher) |watcher| {
|
|
// if (watcher.indexOf(hash)) |index| {
|
|
// const _fd = watcher.watchlist().items(.fd)[index];
|
|
// fd = if (_fd > 0) _fd else null;
|
|
// }
|
|
// }
|
|
|
|
// var parse_options = Transpiler.ParseOptions{
|
|
// .allocator = allocator,
|
|
// .path = path,
|
|
// .loader = loader,
|
|
// .dirname_fd = 0,
|
|
// .file_descriptor = fd,
|
|
// .file_hash = hash,
|
|
// .macro_remappings = MacroRemap{},
|
|
// .jsx = jsc_vm.transpiler.options.jsx,
|
|
// };
|
|
|
|
// var parse_result = jsc_vm.transpiler.parse(
|
|
// parse_options,
|
|
// null,
|
|
// ) orelse {
|
|
// return error.ParseError;
|
|
// };
|
|
|
|
// return ResolvedSource{
|
|
// .allocator = if (jsc_vm.has_loaded) &jsc_vm.allocator else null,
|
|
// .source_code = ZigString.init(jsc_vm.allocator.dupe(u8, source.contents) catch unreachable),
|
|
// .specifier = ZigString.init(specifier),
|
|
// .source_url = input_specifier.createIfDifferent(path.text),
|
|
// .tag = ResolvedSource.Tag.wasm,
|
|
// };
|
|
// },
|
|
.wasm => {
|
|
if (strings.eqlComptime(referrer, "undefined") and strings.eqlLong(jsc_vm.main, path.text, true)) {
|
|
if (virtual_source) |source| {
|
|
if (globalObject) |globalThis| {
|
|
// attempt to avoid reading the WASM file twice.
|
|
const decoded: jsc.DecodedJSValue = .{
|
|
.u = .{ .ptr = @ptrCast(globalThis) },
|
|
};
|
|
const globalValue = decoded.encode();
|
|
globalValue.put(
|
|
globalThis,
|
|
ZigString.static("wasmSourceBytes"),
|
|
try jsc.ArrayBuffer.create(globalThis, source.contents, .Uint8Array),
|
|
);
|
|
}
|
|
}
|
|
return ResolvedSource{
|
|
.allocator = null,
|
|
.source_code = bun.String.static(@embedFile("../js/wasi-runner.js")),
|
|
.specifier = input_specifier,
|
|
.source_url = input_specifier.createIfDifferent(path.text),
|
|
.tag = .esm,
|
|
};
|
|
}
|
|
|
|
return transpileSourceCode(
|
|
jsc_vm,
|
|
specifier,
|
|
referrer,
|
|
input_specifier,
|
|
path,
|
|
.file,
|
|
.unknown, // cjs/esm don't make sense for wasm
|
|
log,
|
|
virtual_source,
|
|
promise_ptr,
|
|
source_code_printer,
|
|
globalObject,
|
|
flags,
|
|
);
|
|
},
|
|
|
|
.sqlite_embedded, .sqlite => {
|
|
const sqlite_module_source_code_string = brk: {
|
|
if (jsc_vm.hot_reload == .hot) {
|
|
break :brk
|
|
\\// Generated code
|
|
\\import {Database} from 'bun:sqlite';
|
|
\\const {path} = import.meta;
|
|
\\
|
|
\\// Don't reload the database if it's already loaded
|
|
\\const registry = (globalThis[Symbol.for("bun:sqlite:hot")] ??= new Map());
|
|
\\
|
|
\\export let db = registry.get(path);
|
|
\\export const __esModule = true;
|
|
\\if (!db) {
|
|
\\ // Load the database
|
|
\\ db = new Database(path);
|
|
\\ registry.set(path, db);
|
|
\\}
|
|
\\
|
|
\\export default db;
|
|
;
|
|
}
|
|
|
|
break :brk
|
|
\\// Generated code
|
|
\\import {Database} from 'bun:sqlite';
|
|
\\export const db = new Database(import.meta.path);
|
|
\\
|
|
\\export const __esModule = true;
|
|
\\export default db;
|
|
;
|
|
};
|
|
|
|
return ResolvedSource{
|
|
.allocator = null,
|
|
.source_code = bun.String.cloneUTF8(sqlite_module_source_code_string),
|
|
.specifier = input_specifier,
|
|
.source_url = input_specifier.createIfDifferent(path.text),
|
|
.tag = .esm,
|
|
};
|
|
},
|
|
|
|
.html => {
|
|
if (flags.disableTranspiling()) {
|
|
return ResolvedSource{
|
|
.allocator = null,
|
|
.source_code = bun.String.empty,
|
|
.specifier = input_specifier,
|
|
.source_url = input_specifier.createIfDifferent(path.text),
|
|
.tag = .esm,
|
|
};
|
|
}
|
|
|
|
if (globalObject == null) {
|
|
return error.NotSupported;
|
|
}
|
|
|
|
const html_bundle = try jsc.API.HTMLBundle.init(globalObject.?, path.text);
|
|
return ResolvedSource{
|
|
.allocator = &jsc_vm.allocator,
|
|
.jsvalue_for_export = html_bundle.toJS(globalObject.?),
|
|
.specifier = input_specifier,
|
|
.source_url = input_specifier.createIfDifferent(path.text),
|
|
.tag = .export_default_object,
|
|
};
|
|
},
|
|
|
|
else => {
|
|
if (flags.disableTranspiling()) {
|
|
return ResolvedSource{
|
|
.allocator = null,
|
|
.source_code = bun.String.empty,
|
|
.specifier = input_specifier,
|
|
.source_url = input_specifier.createIfDifferent(path.text),
|
|
.tag = .esm,
|
|
};
|
|
}
|
|
|
|
if (virtual_source == null) {
|
|
if (jsc_vm.isWatcherEnabled()) auto_watch: {
|
|
if (std.fs.path.isAbsolute(path.text) and !strings.contains(path.text, "node_modules")) {
|
|
const input_fd: bun.StoredFileDescriptorType = brk: {
|
|
// on macOS, we need a file descriptor to receive event notifications on it.
|
|
// so we use O_EVTONLY to open the file descriptor without asking any additional permissions.
|
|
if (bun.Watcher.requires_file_descriptors) {
|
|
switch (bun.sys.open(
|
|
&(std.posix.toPosixPath(path.text) catch break :auto_watch),
|
|
bun.c.O_EVTONLY,
|
|
0,
|
|
)) {
|
|
.err => break :auto_watch,
|
|
.result => |fd| break :brk fd,
|
|
}
|
|
} else {
|
|
// Otherwise, don't even bother opening it.
|
|
break :brk .invalid;
|
|
}
|
|
};
|
|
const hash = bun.Watcher.getHash(path.text);
|
|
switch (jsc_vm.bun_watcher.addFile(
|
|
input_fd,
|
|
path.text,
|
|
hash,
|
|
loader,
|
|
.invalid,
|
|
null,
|
|
true,
|
|
)) {
|
|
.err => {
|
|
if (comptime Environment.isMac) {
|
|
// If any error occurs and we just
|
|
// opened the file descriptor to
|
|
// receive event notifications on
|
|
// it, we should close it.
|
|
if (input_fd.isValid()) {
|
|
input_fd.close();
|
|
}
|
|
}
|
|
|
|
// we don't consider it a failure if we cannot watch the file
|
|
// they didn't open the file
|
|
},
|
|
.result => {},
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
const value = brk: {
|
|
if (!jsc_vm.origin.isEmpty()) {
|
|
var buf = bun.handleOom(MutableString.init2048(jsc_vm.allocator));
|
|
defer buf.deinit();
|
|
var writer = buf.writer();
|
|
jsc.API.Bun.getPublicPath(specifier, jsc_vm.origin, @TypeOf(&writer), &writer);
|
|
break :brk try bun.String.createUTF8ForJS(globalObject.?, buf.slice());
|
|
}
|
|
|
|
break :brk try bun.String.createUTF8ForJS(globalObject.?, path.text);
|
|
};
|
|
|
|
return ResolvedSource{
|
|
.allocator = null,
|
|
.jsvalue_for_export = value,
|
|
.specifier = input_specifier,
|
|
.source_url = input_specifier.createIfDifferent(path.text),
|
|
.tag = .export_default_object,
|
|
};
|
|
},
|
|
}
|
|
}
|
|
|
|
pub export fn Bun__resolveAndFetchBuiltinModule(
|
|
jsc_vm: *VirtualMachine,
|
|
specifier: *bun.String,
|
|
ret: *jsc.ErrorableResolvedSource,
|
|
) bool {
|
|
jsc.markBinding(@src());
|
|
var log = logger.Log.init(jsc_vm.transpiler.allocator);
|
|
defer log.deinit();
|
|
|
|
const alias = HardcodedModule.Alias.bun_aliases.getWithEql(specifier.*, bun.String.eqlComptime) orelse
|
|
return false;
|
|
const hardcoded = HardcodedModule.map.get(alias.path) orelse {
|
|
bun.debugAssert(false);
|
|
return false;
|
|
};
|
|
ret.* = .ok(
|
|
getHardcodedModule(jsc_vm, specifier.*, hardcoded) orelse
|
|
return false,
|
|
);
|
|
return true;
|
|
}
|
|
|
|
pub export fn Bun__fetchBuiltinModule(
|
|
jsc_vm: *VirtualMachine,
|
|
globalObject: *JSGlobalObject,
|
|
specifier: *bun.String,
|
|
referrer: *bun.String,
|
|
ret: *jsc.ErrorableResolvedSource,
|
|
) bool {
|
|
jsc.markBinding(@src());
|
|
var log = logger.Log.init(jsc_vm.transpiler.allocator);
|
|
defer log.deinit();
|
|
|
|
if (ModuleLoader.fetchBuiltinModule(
|
|
jsc_vm,
|
|
specifier.*,
|
|
) catch |err| {
|
|
if (err == error.AsyncModule) {
|
|
unreachable;
|
|
}
|
|
|
|
VirtualMachine.processFetchLog(globalObject, specifier.*, referrer.*, &log, ret, err);
|
|
return true;
|
|
}) |builtin| {
|
|
ret.* = jsc.ErrorableResolvedSource.ok(builtin);
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
const always_sync_modules = .{"reflect-metadata"};
|
|
|
|
pub export fn Bun__transpileFile(
|
|
jsc_vm: *VirtualMachine,
|
|
globalObject: *JSGlobalObject,
|
|
specifier_ptr: *bun.String,
|
|
referrer: *bun.String,
|
|
type_attribute: ?*const bun.String,
|
|
ret: *jsc.ErrorableResolvedSource,
|
|
allow_promise: bool,
|
|
is_commonjs_require: bool,
|
|
force_loader_type: bun.options.Loader.Optional,
|
|
) ?*anyopaque {
|
|
jsc.markBinding(@src());
|
|
var log = logger.Log.init(jsc_vm.transpiler.allocator);
|
|
defer log.deinit();
|
|
|
|
var _specifier = specifier_ptr.toUTF8(jsc_vm.allocator);
|
|
var referrer_slice = referrer.toUTF8(jsc_vm.allocator);
|
|
defer _specifier.deinit();
|
|
defer referrer_slice.deinit();
|
|
|
|
var type_attribute_str: ?string = null;
|
|
if (type_attribute) |attribute| if (attribute.asUTF8()) |attr_utf8| {
|
|
type_attribute_str = attr_utf8;
|
|
};
|
|
|
|
var virtual_source_to_use: ?logger.Source = null;
|
|
var blob_to_deinit: ?jsc.WebCore.Blob = null;
|
|
var lr = options.getLoaderAndVirtualSource(_specifier.slice(), jsc_vm, &virtual_source_to_use, &blob_to_deinit, type_attribute_str) catch {
|
|
ret.* = jsc.ErrorableResolvedSource.err(error.JSErrorObject, globalObject.ERR(.MODULE_NOT_FOUND, "Blob not found", .{}).toJS());
|
|
return null;
|
|
};
|
|
defer if (blob_to_deinit) |*blob| blob.deinit();
|
|
|
|
if (force_loader_type.unwrap()) |loader_type| {
|
|
@branchHint(.unlikely);
|
|
bun.assert(!is_commonjs_require);
|
|
lr.loader = loader_type;
|
|
} else if (is_commonjs_require and jsc_vm.has_mutated_built_in_extensions > 0) {
|
|
@branchHint(.unlikely);
|
|
if (node_module_module.findLongestRegisteredExtension(jsc_vm, _specifier.slice())) |entry| {
|
|
switch (entry) {
|
|
.loader => |loader| {
|
|
lr.loader = loader;
|
|
},
|
|
.custom => |strong| {
|
|
ret.* = jsc.ErrorableResolvedSource.ok(ResolvedSource{
|
|
.allocator = null,
|
|
.source_code = bun.String.empty,
|
|
.specifier = .empty,
|
|
.source_url = .empty,
|
|
.cjs_custom_extension_index = strong.get(),
|
|
.tag = .common_js_custom_extension,
|
|
});
|
|
return null;
|
|
},
|
|
}
|
|
}
|
|
}
|
|
|
|
const module_type: options.ModuleType = brk: {
|
|
const ext = lr.path.name.ext;
|
|
// regular expression /.[cm][jt]s$/
|
|
if (ext.len == ".cjs".len) {
|
|
if (strings.eqlComptimeIgnoreLen(ext, ".cjs"))
|
|
break :brk .cjs;
|
|
if (strings.eqlComptimeIgnoreLen(ext, ".mjs"))
|
|
break :brk .esm;
|
|
if (strings.eqlComptimeIgnoreLen(ext, ".cts"))
|
|
break :brk .cjs;
|
|
if (strings.eqlComptimeIgnoreLen(ext, ".mts"))
|
|
break :brk .esm;
|
|
}
|
|
// regular expression /.[jt]s$/
|
|
if (ext.len == ".ts".len) {
|
|
if (strings.eqlComptimeIgnoreLen(ext, ".js") or
|
|
strings.eqlComptimeIgnoreLen(ext, ".ts"))
|
|
{
|
|
// Use the package.json module type if it exists
|
|
break :brk if (lr.package_json) |pkg|
|
|
pkg.module_type
|
|
else
|
|
.unknown;
|
|
}
|
|
}
|
|
// For JSX TSX and other extensions, let the file contents.
|
|
break :brk .unknown;
|
|
};
|
|
const pkg_name: ?[]const u8 = if (lr.package_json) |pkg|
|
|
if (pkg.name.len > 0) pkg.name else null
|
|
else
|
|
null;
|
|
|
|
// We only run the transpiler concurrently when we can.
|
|
// Today, that's:
|
|
//
|
|
// Import Statements (import 'foo')
|
|
// Import Expressions (import('foo'))
|
|
//
|
|
transpile_async: {
|
|
if (comptime bun.FeatureFlags.concurrent_transpiler) {
|
|
const concurrent_loader = lr.loader orelse .file;
|
|
if (blob_to_deinit == null and
|
|
allow_promise and
|
|
(jsc_vm.has_loaded or jsc_vm.is_in_preload) and
|
|
concurrent_loader.isJavaScriptLike() and
|
|
!lr.is_main and
|
|
// Plugins make this complicated,
|
|
// TODO: allow running concurrently when no onLoad handlers match a plugin.
|
|
jsc_vm.plugin_runner == null and jsc_vm.transpiler_store.enabled)
|
|
{
|
|
// This absolutely disgusting hack is a workaround in cases
|
|
// where an async import is made to a CJS file with side
|
|
// effects that other modules depend on, without incurring
|
|
// the cost of transpiling/loading CJS modules synchronously.
|
|
//
|
|
// The cause of this comes from the fact that we immediately
|
|
// and synchronously evaluate CJS modules after they've been
|
|
// transpiled, but transpiling (which, for async imports,
|
|
// happens in a thread pool), can resolve in whatever order.
|
|
// This messes up module execution order.
|
|
//
|
|
// This is only _really_ important for
|
|
// import("some-polyfill") cases, the most impactful of
|
|
// which is `reflect-metadata`. People could also use
|
|
// require or just preload their polyfills, but they aren't
|
|
// doing this. This hack makes important polyfills work without
|
|
// incurring the cost of transpiling/loading CJS modules
|
|
// synchronously. The proper fix is to evaluate CJS modules
|
|
// at the same time as ES modules. This is blocked by the
|
|
// fact that we need exports from CJS modules and our parser
|
|
// doesn't record them.
|
|
if (pkg_name) |pkg_name_| {
|
|
inline for (always_sync_modules) |always_sync_specifier| {
|
|
if (bun.strings.eqlComptime(pkg_name_, always_sync_specifier)) {
|
|
break :transpile_async;
|
|
}
|
|
}
|
|
}
|
|
|
|
// TODO: check if the resolved source must be transpiled synchronously
|
|
return jsc_vm.transpiler_store.transpile(
|
|
jsc_vm,
|
|
globalObject,
|
|
specifier_ptr.dupeRef(),
|
|
lr.path,
|
|
referrer.dupeRef(),
|
|
concurrent_loader,
|
|
lr.package_json,
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
const synchronous_loader: options.Loader = lr.loader orelse loader: {
|
|
if (jsc_vm.has_loaded or jsc_vm.is_in_preload) {
|
|
// Extensionless files in this context are treated as the JS loader
|
|
if (lr.path.name.ext.len == 0) {
|
|
break :loader .tsx;
|
|
}
|
|
|
|
// Unknown extensions are to be treated as file loader
|
|
if (is_commonjs_require) {
|
|
if (jsc_vm.commonjs_custom_extensions.entries.len > 0 and
|
|
jsc_vm.has_mutated_built_in_extensions == 0)
|
|
{
|
|
@branchHint(.unlikely);
|
|
if (node_module_module.findLongestRegisteredExtension(jsc_vm, lr.path.text)) |entry| {
|
|
switch (entry) {
|
|
.loader => |loader| break :loader loader,
|
|
.custom => |strong| {
|
|
ret.* = jsc.ErrorableResolvedSource.ok(ResolvedSource{
|
|
.allocator = null,
|
|
.source_code = bun.String.empty,
|
|
.specifier = .empty,
|
|
.source_url = .empty,
|
|
.cjs_custom_extension_index = strong.get(),
|
|
.tag = .common_js_custom_extension,
|
|
});
|
|
return null;
|
|
},
|
|
}
|
|
}
|
|
}
|
|
|
|
// For Node.js compatibility, requiring a file with an
|
|
// unknown extension will be treated as a JS file
|
|
break :loader .ts;
|
|
}
|
|
|
|
// For ESM, Bun treats unknown extensions as file loader
|
|
break :loader .file;
|
|
} else {
|
|
// Unless it's potentially the main module
|
|
// This is important so that "bun run ./foo-i-have-no-extension" works
|
|
break :loader .tsx;
|
|
}
|
|
};
|
|
|
|
if (comptime Environment.allow_assert)
|
|
debug("transpile({s}, {s}, sync)", .{ lr.specifier, @tagName(synchronous_loader) });
|
|
|
|
defer jsc_vm.module_loader.resetArena(jsc_vm);
|
|
|
|
var promise: ?*jsc.JSInternalPromise = null;
|
|
ret.* = jsc.ErrorableResolvedSource.ok(
|
|
ModuleLoader.transpileSourceCode(
|
|
jsc_vm,
|
|
lr.specifier,
|
|
referrer_slice.slice(),
|
|
specifier_ptr.*,
|
|
lr.path,
|
|
synchronous_loader,
|
|
module_type,
|
|
&log,
|
|
lr.virtual_source,
|
|
if (allow_promise) &promise else null,
|
|
VirtualMachine.source_code_printer.?,
|
|
globalObject,
|
|
FetchFlags.transpile,
|
|
) catch |err| {
|
|
switch (err) {
|
|
error.AsyncModule => {
|
|
bun.assert(promise != null);
|
|
return promise;
|
|
},
|
|
error.PluginError => return null,
|
|
error.JSError => {
|
|
ret.* = jsc.ErrorableResolvedSource.err(error.JSError, globalObject.takeError(error.JSError));
|
|
return null;
|
|
},
|
|
else => {
|
|
VirtualMachine.processFetchLog(globalObject, specifier_ptr.*, referrer.*, &log, ret, err);
|
|
return null;
|
|
},
|
|
}
|
|
},
|
|
);
|
|
return promise;
|
|
}
|
|
|
|
export fn Bun__runVirtualModule(globalObject: *JSGlobalObject, specifier_ptr: *const bun.String) JSValue {
|
|
jsc.markBinding(@src());
|
|
if (globalObject.bunVM().plugin_runner == null) return JSValue.zero;
|
|
|
|
const specifier_slice = specifier_ptr.toUTF8(bun.default_allocator);
|
|
defer specifier_slice.deinit();
|
|
const specifier = specifier_slice.slice();
|
|
|
|
if (!PluginRunner.couldBePlugin(specifier)) {
|
|
return JSValue.zero;
|
|
}
|
|
|
|
const namespace = PluginRunner.extractNamespace(specifier);
|
|
const after_namespace = if (namespace.len == 0)
|
|
specifier
|
|
else
|
|
specifier[@min(namespace.len + 1, specifier.len)..];
|
|
|
|
return globalObject.runOnLoadPlugins(bun.String.init(namespace), bun.String.init(after_namespace), .bun) catch {
|
|
return JSValue.zero;
|
|
} orelse return .zero;
|
|
}
|
|
|
|
fn getHardcodedModule(jsc_vm: *VirtualMachine, specifier: bun.String, hardcoded: HardcodedModule) ?ResolvedSource {
|
|
analytics.Features.builtin_modules.insert(hardcoded);
|
|
return switch (hardcoded) {
|
|
.@"bun:main" => .{
|
|
.allocator = null,
|
|
.source_code = bun.String.cloneUTF8(jsc_vm.entry_point.source.contents),
|
|
.specifier = specifier,
|
|
.source_url = specifier,
|
|
.tag = .esm,
|
|
.source_code_needs_deref = true,
|
|
},
|
|
.@"bun:internal-for-testing" => {
|
|
if (!Environment.isDebug) {
|
|
if (!is_allowed_to_use_internal_testing_apis)
|
|
return null;
|
|
}
|
|
return jsSyntheticModule(.@"bun:internal-for-testing", specifier);
|
|
},
|
|
.@"bun:wrap" => .{
|
|
.allocator = null,
|
|
.source_code = String.init(Runtime.Runtime.sourceCode()),
|
|
.specifier = specifier,
|
|
.source_url = specifier,
|
|
},
|
|
inline else => |tag| jsSyntheticModule(@field(ResolvedSource.Tag, @tagName(tag)), specifier),
|
|
};
|
|
}
|
|
|
|
pub fn fetchBuiltinModule(jsc_vm: *VirtualMachine, specifier: bun.String) !?ResolvedSource {
|
|
if (HardcodedModule.map.getWithEql(specifier, bun.String.eqlComptime)) |hardcoded| {
|
|
return getHardcodedModule(jsc_vm, specifier, hardcoded);
|
|
}
|
|
|
|
if (specifier.hasPrefixComptime(js_ast.Macro.namespaceWithColon)) {
|
|
const spec = specifier.toUTF8(bun.default_allocator);
|
|
defer spec.deinit();
|
|
if (jsc_vm.macro_entry_points.get(MacroEntryPoint.generateIDFromSpecifier(spec.slice()))) |entry| {
|
|
return .{
|
|
.allocator = null,
|
|
.source_code = bun.String.cloneUTF8(entry.source.contents),
|
|
.specifier = specifier,
|
|
.source_url = specifier.dupeRef(),
|
|
};
|
|
}
|
|
} else if (jsc_vm.standalone_module_graph) |graph| {
|
|
const specifier_utf8 = specifier.toUTF8(bun.default_allocator);
|
|
defer specifier_utf8.deinit();
|
|
if (graph.files.getPtr(specifier_utf8.slice())) |file| {
|
|
if (file.loader == .sqlite or file.loader == .sqlite_embedded) {
|
|
const code =
|
|
\\/* Generated code */
|
|
\\import {Database} from 'bun:sqlite';
|
|
\\import {readFileSync} from 'node:fs';
|
|
\\export const db = new Database(readFileSync(import.meta.path));
|
|
\\
|
|
\\export const __esModule = true;
|
|
\\export default db;
|
|
;
|
|
return .{
|
|
.allocator = null,
|
|
.source_code = bun.String.static(code),
|
|
.specifier = specifier,
|
|
.source_url = specifier.dupeRef(),
|
|
.source_code_needs_deref = false,
|
|
};
|
|
}
|
|
|
|
return .{
|
|
.allocator = null,
|
|
.source_code = file.toWTFString(),
|
|
.specifier = specifier,
|
|
.source_url = specifier.dupeRef(),
|
|
.source_code_needs_deref = false,
|
|
.bytecode_cache = if (file.bytecode.len > 0) file.bytecode.ptr else null,
|
|
.bytecode_cache_size = file.bytecode.len,
|
|
.is_commonjs_module = file.module_format == .cjs,
|
|
};
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
export fn Bun__transpileVirtualModule(
|
|
globalObject: *JSGlobalObject,
|
|
specifier_ptr: *const bun.String,
|
|
referrer_ptr: *const bun.String,
|
|
source_code: *ZigString,
|
|
loader_: api.Loader,
|
|
ret: *jsc.ErrorableResolvedSource,
|
|
) bool {
|
|
jsc.markBinding(@src());
|
|
const jsc_vm = globalObject.bunVM();
|
|
// Plugin runner is not required for virtual modules created via build.module()
|
|
// bun.assert(jsc_vm.plugin_runner != null);
|
|
|
|
var specifier_slice = specifier_ptr.toUTF8(jsc_vm.allocator);
|
|
const specifier = specifier_slice.slice();
|
|
defer specifier_slice.deinit();
|
|
var source_code_slice = source_code.toSlice(jsc_vm.allocator);
|
|
defer source_code_slice.deinit();
|
|
var referrer_slice = referrer_ptr.toUTF8(jsc_vm.allocator);
|
|
defer referrer_slice.deinit();
|
|
|
|
var virtual_source = logger.Source.initPathString(specifier, source_code_slice.slice());
|
|
var log = logger.Log.init(jsc_vm.allocator);
|
|
const path = Fs.Path.init(specifier);
|
|
|
|
const loader = if (loader_ != ._none)
|
|
options.Loader.fromAPI(loader_)
|
|
else
|
|
jsc_vm.transpiler.options.loaders.get(path.name.ext) orelse brk: {
|
|
if (strings.eqlLong(specifier, jsc_vm.main, true)) {
|
|
break :brk options.Loader.js;
|
|
}
|
|
|
|
break :brk options.Loader.file;
|
|
};
|
|
|
|
defer log.deinit();
|
|
defer jsc_vm.module_loader.resetArena(jsc_vm);
|
|
|
|
ret.* = jsc.ErrorableResolvedSource.ok(
|
|
ModuleLoader.transpileSourceCode(
|
|
jsc_vm,
|
|
specifier_slice.slice(),
|
|
referrer_slice.slice(),
|
|
specifier_ptr.*,
|
|
path,
|
|
loader,
|
|
.unknown,
|
|
&log,
|
|
&virtual_source,
|
|
null,
|
|
VirtualMachine.source_code_printer.?,
|
|
globalObject,
|
|
FetchFlags.transpile,
|
|
) catch |err| {
|
|
switch (err) {
|
|
error.PluginError => return true,
|
|
error.JSError => {
|
|
ret.* = jsc.ErrorableResolvedSource.err(error.JSError, globalObject.takeError(error.JSError));
|
|
return true;
|
|
},
|
|
else => {
|
|
VirtualMachine.processFetchLog(globalObject, specifier_ptr.*, referrer_ptr.*, &log, ret, err);
|
|
return true;
|
|
},
|
|
}
|
|
},
|
|
);
|
|
analytics.Features.virtual_modules += 1;
|
|
return true;
|
|
}
|
|
|
|
inline fn jsSyntheticModule(name: ResolvedSource.Tag, specifier: String) ResolvedSource {
|
|
return ResolvedSource{
|
|
.allocator = null,
|
|
.source_code = bun.String.empty,
|
|
.specifier = specifier,
|
|
.source_url = bun.String.static(@tagName(name)),
|
|
.tag = name,
|
|
.source_code_needs_deref = false,
|
|
};
|
|
}
|
|
|
|
/// Dumps the module source to a file in /tmp/bun-debug-src/{filepath}
|
|
///
|
|
/// This can technically fail if concurrent access across processes happens, or permission issues.
|
|
/// Errors here should always be ignored.
|
|
fn dumpSource(vm: *VirtualMachine, specifier: string, printer: anytype) void {
|
|
dumpSourceString(vm, specifier, printer.ctx.getWritten());
|
|
}
|
|
|
|
fn dumpSourceString(vm: *VirtualMachine, specifier: string, written: []const u8) void {
|
|
dumpSourceStringFailiable(vm, specifier, written) catch |e| {
|
|
Output.debugWarn("Failed to dump source string: {}", .{e});
|
|
};
|
|
}
|
|
|
|
fn dumpSourceStringFailiable(vm: *VirtualMachine, specifier: string, written: []const u8) !void {
|
|
if (!Environment.isDebug) return;
|
|
if (bun.getRuntimeFeatureFlag(.BUN_DEBUG_NO_DUMP)) return;
|
|
|
|
const BunDebugHolder = struct {
|
|
pub var dir: ?std.fs.Dir = null;
|
|
pub var lock: bun.Mutex = .{};
|
|
};
|
|
|
|
BunDebugHolder.lock.lock();
|
|
defer BunDebugHolder.lock.unlock();
|
|
|
|
const dir = BunDebugHolder.dir orelse dir: {
|
|
const base_name = switch (Environment.os) {
|
|
else => "/tmp/bun-debug-src/",
|
|
.windows => brk: {
|
|
const temp = bun.fs.FileSystem.RealFS.platformTempDir();
|
|
var win_temp_buffer: bun.PathBuffer = undefined;
|
|
@memcpy(win_temp_buffer[0..temp.len], temp);
|
|
const suffix = "\\bun-debug-src";
|
|
@memcpy(win_temp_buffer[temp.len .. temp.len + suffix.len], suffix);
|
|
win_temp_buffer[temp.len + suffix.len] = 0;
|
|
break :brk win_temp_buffer[0 .. temp.len + suffix.len :0];
|
|
},
|
|
};
|
|
const dir = try std.fs.cwd().makeOpenPath(base_name, .{});
|
|
BunDebugHolder.dir = dir;
|
|
break :dir dir;
|
|
};
|
|
|
|
if (std.fs.path.dirname(specifier)) |dir_path| {
|
|
const root_len = switch (Environment.os) {
|
|
else => "/".len,
|
|
.windows => bun.path.windowsFilesystemRoot(dir_path).len,
|
|
};
|
|
var parent = try dir.makeOpenPath(dir_path[root_len..], .{});
|
|
defer parent.close();
|
|
parent.writeFile(.{
|
|
.sub_path = std.fs.path.basename(specifier),
|
|
.data = written,
|
|
}) catch |e| {
|
|
Output.debugWarn("Failed to dump source string: writeFile {}", .{e});
|
|
return;
|
|
};
|
|
if (vm.source_mappings.get(specifier)) |mappings| {
|
|
defer mappings.deref();
|
|
const map_path = bun.handleOom(std.mem.concat(bun.default_allocator, u8, &.{ std.fs.path.basename(specifier), ".map" }));
|
|
defer bun.default_allocator.free(map_path);
|
|
const file = try parent.createFile(map_path, .{});
|
|
defer file.close();
|
|
|
|
const source_file = parent.readFileAlloc(
|
|
bun.default_allocator,
|
|
specifier,
|
|
std.math.maxInt(u64),
|
|
) catch "";
|
|
defer bun.default_allocator.free(source_file);
|
|
|
|
var bufw = std.io.bufferedWriter(file.writer());
|
|
const w = bufw.writer();
|
|
try w.print(
|
|
\\{{
|
|
\\ "version": 3,
|
|
\\ "file": {},
|
|
\\ "sourceRoot": "",
|
|
\\ "sources": [{}],
|
|
\\ "sourcesContent": [{}],
|
|
\\ "names": [],
|
|
\\ "mappings": "{}"
|
|
\\}}
|
|
, .{
|
|
bun.fmt.formatJSONStringUTF8(std.fs.path.basename(specifier), .{}),
|
|
bun.fmt.formatJSONStringUTF8(specifier, .{}),
|
|
bun.fmt.formatJSONStringUTF8(source_file, .{}),
|
|
mappings.formatVLQs(),
|
|
});
|
|
try bufw.flush();
|
|
}
|
|
} else {
|
|
dir.writeFile(.{
|
|
.sub_path = std.fs.path.basename(specifier),
|
|
.data = written,
|
|
}) catch return;
|
|
}
|
|
}
|
|
|
|
fn setBreakPointOnFirstLine() bool {
|
|
const s = struct {
|
|
var set_break_point: bool = true;
|
|
};
|
|
const ret = s.set_break_point;
|
|
s.set_break_point = false;
|
|
return ret;
|
|
}
|
|
|
|
pub const RuntimeTranspilerStore = struct {
|
|
generation_number: std.atomic.Value(u32) = std.atomic.Value(u32).init(0),
|
|
store: TranspilerJob.Store,
|
|
enabled: bool = true,
|
|
queue: Queue = Queue{},
|
|
|
|
pub const Queue = bun.UnboundedQueue(TranspilerJob, .next);
|
|
|
|
pub fn init() RuntimeTranspilerStore {
|
|
return RuntimeTranspilerStore{
|
|
.store = TranspilerJob.Store.init(bun.typedAllocator(TranspilerJob)),
|
|
};
|
|
}
|
|
|
|
pub fn runFromJSThread(this: *RuntimeTranspilerStore, event_loop: *jsc.EventLoop, global: *jsc.JSGlobalObject, vm: *jsc.VirtualMachine) void {
|
|
var batch = this.queue.popBatch();
|
|
const jsc_vm = vm.jsc_vm;
|
|
var iter = batch.iterator();
|
|
if (iter.next()) |job| {
|
|
// we run just one job first to see if there are more
|
|
job.runFromJSThread() catch |err| global.reportUncaughtExceptionFromError(err);
|
|
} else {
|
|
return;
|
|
}
|
|
while (iter.next()) |job| {
|
|
// if there are more, we need to drain the microtasks from the previous run
|
|
event_loop.drainMicrotasksWithGlobal(global, jsc_vm) catch return;
|
|
job.runFromJSThread() catch |err| global.reportUncaughtExceptionFromError(err);
|
|
}
|
|
|
|
// immediately after this is called, the microtasks will be drained again.
|
|
}
|
|
|
|
pub fn transpile(
|
|
this: *RuntimeTranspilerStore,
|
|
vm: *VirtualMachine,
|
|
globalObject: *JSGlobalObject,
|
|
input_specifier: bun.String,
|
|
path: Fs.Path,
|
|
referrer: bun.String,
|
|
loader: bun.options.Loader,
|
|
package_json: ?*const PackageJSON,
|
|
) *anyopaque {
|
|
var job: *TranspilerJob = this.store.get();
|
|
const owned_path = Fs.Path.init(bun.default_allocator.dupe(u8, path.text) catch unreachable);
|
|
const promise = jsc.JSInternalPromise.create(globalObject);
|
|
|
|
// NOTE: DirInfo should already be cached since module loading happens
|
|
// after module resolution, so this should be cheap
|
|
var resolved_source = ResolvedSource{};
|
|
if (package_json) |pkg| {
|
|
switch (pkg.module_type) {
|
|
.cjs => {
|
|
resolved_source.tag = .package_json_type_commonjs;
|
|
resolved_source.is_commonjs_module = true;
|
|
},
|
|
.esm => resolved_source.tag = .package_json_type_module,
|
|
.unknown => {},
|
|
}
|
|
}
|
|
|
|
job.* = TranspilerJob{
|
|
.non_threadsafe_input_specifier = input_specifier,
|
|
.path = owned_path,
|
|
.globalThis = globalObject,
|
|
.non_threadsafe_referrer = referrer,
|
|
.vm = vm,
|
|
.log = logger.Log.init(bun.default_allocator),
|
|
.loader = loader,
|
|
.promise = .create(JSValue.fromCell(promise), globalObject),
|
|
.poll_ref = .{},
|
|
.fetcher = TranspilerJob.Fetcher{
|
|
.file = {},
|
|
},
|
|
.resolved_source = resolved_source,
|
|
};
|
|
if (comptime Environment.allow_assert)
|
|
debug("transpile({s}, {s}, async)", .{ path.text, @tagName(job.loader) });
|
|
job.schedule();
|
|
return promise;
|
|
}
|
|
|
|
pub const TranspilerJob = struct {
|
|
path: Fs.Path,
|
|
non_threadsafe_input_specifier: String,
|
|
non_threadsafe_referrer: String,
|
|
loader: options.Loader,
|
|
promise: jsc.Strong.Optional = .empty,
|
|
vm: *VirtualMachine,
|
|
globalThis: *JSGlobalObject,
|
|
fetcher: Fetcher,
|
|
poll_ref: Async.KeepAlive = .{},
|
|
generation_number: u32 = 0,
|
|
log: logger.Log,
|
|
parse_error: ?anyerror = null,
|
|
resolved_source: ResolvedSource = ResolvedSource{},
|
|
work_task: jsc.WorkPoolTask = .{ .callback = runFromWorkerThread },
|
|
next: ?*TranspilerJob = null,
|
|
|
|
pub const Store = bun.HiveArray(TranspilerJob, if (bun.heap_breakdown.enabled) 0 else 64).Fallback;
|
|
|
|
pub const Fetcher = union(enum) {
|
|
virtual_module: bun.String,
|
|
file: void,
|
|
|
|
pub fn deinit(this: *@This()) void {
|
|
if (this.* == .virtual_module) {
|
|
this.virtual_module.deref();
|
|
}
|
|
}
|
|
};
|
|
|
|
pub fn deinit(this: *TranspilerJob) void {
|
|
bun.default_allocator.free(this.path.text);
|
|
|
|
this.poll_ref.disable();
|
|
this.fetcher.deinit();
|
|
this.loader = options.Loader.file;
|
|
this.non_threadsafe_input_specifier.deref();
|
|
this.non_threadsafe_referrer.deref();
|
|
this.path = Fs.Path.empty;
|
|
this.log.deinit();
|
|
this.promise.deinit();
|
|
this.globalThis = undefined;
|
|
}
|
|
|
|
threadlocal var ast_memory_store: ?*js_ast.ASTMemoryAllocator = null;
|
|
threadlocal var source_code_printer: ?*js_printer.BufferPrinter = null;
|
|
|
|
pub fn dispatchToMainThread(this: *TranspilerJob) void {
|
|
this.vm.transpiler_store.queue.push(this);
|
|
this.vm.eventLoop().enqueueTaskConcurrent(jsc.ConcurrentTask.createFrom(&this.vm.transpiler_store));
|
|
}
|
|
|
|
pub fn runFromJSThread(this: *TranspilerJob) bun.JSError!void {
|
|
var vm = this.vm;
|
|
const promise = this.promise.swap();
|
|
const globalThis = this.globalThis;
|
|
this.poll_ref.unref(vm);
|
|
|
|
const referrer = this.non_threadsafe_referrer;
|
|
this.non_threadsafe_referrer = String.empty;
|
|
var log = this.log;
|
|
this.log = logger.Log.init(bun.default_allocator);
|
|
var resolved_source = this.resolved_source;
|
|
const specifier = brk: {
|
|
if (this.parse_error != null) {
|
|
break :brk bun.String.cloneUTF8(this.path.text);
|
|
}
|
|
|
|
const out = this.non_threadsafe_input_specifier;
|
|
this.non_threadsafe_input_specifier = String.empty;
|
|
|
|
bun.debugAssert(resolved_source.source_url.isEmpty());
|
|
bun.debugAssert(resolved_source.specifier.isEmpty());
|
|
resolved_source.source_url = out.createIfDifferent(this.path.text);
|
|
resolved_source.specifier = out.dupeRef();
|
|
break :brk out;
|
|
};
|
|
|
|
const parse_error = this.parse_error;
|
|
|
|
this.promise.deinit();
|
|
this.deinit();
|
|
|
|
_ = vm.transpiler_store.store.put(this);
|
|
|
|
try ModuleLoader.AsyncModule.fulfill(globalThis, promise, &resolved_source, parse_error, specifier, referrer, &log);
|
|
}
|
|
|
|
pub fn schedule(this: *TranspilerJob) void {
|
|
this.poll_ref.ref(this.vm);
|
|
jsc.WorkPool.schedule(&this.work_task);
|
|
}
|
|
|
|
pub fn runFromWorkerThread(work_task: *jsc.WorkPoolTask) void {
|
|
@as(*TranspilerJob, @fieldParentPtr("work_task", work_task)).run();
|
|
}
|
|
|
|
pub fn run(this: *TranspilerJob) void {
|
|
var arena = bun.ArenaAllocator.init(bun.default_allocator);
|
|
defer arena.deinit();
|
|
const allocator = arena.allocator();
|
|
|
|
defer this.dispatchToMainThread();
|
|
if (this.generation_number != this.vm.transpiler_store.generation_number.load(.monotonic)) {
|
|
this.parse_error = error.TranspilerJobGenerationMismatch;
|
|
return;
|
|
}
|
|
|
|
if (ast_memory_store == null) {
|
|
ast_memory_store = bun.handleOom(bun.default_allocator.create(js_ast.ASTMemoryAllocator));
|
|
ast_memory_store.?.* = js_ast.ASTMemoryAllocator{
|
|
.allocator = allocator,
|
|
.previous = null,
|
|
};
|
|
}
|
|
|
|
var ast_scope = ast_memory_store.?.enter(allocator);
|
|
defer ast_scope.exit();
|
|
|
|
const path = this.path;
|
|
const specifier = this.path.text;
|
|
const loader = this.loader;
|
|
|
|
var cache = jsc.RuntimeTranspilerCache{
|
|
.output_code_allocator = allocator,
|
|
.sourcemap_allocator = bun.default_allocator,
|
|
};
|
|
var log = logger.Log.init(allocator);
|
|
defer {
|
|
this.log = logger.Log.init(bun.default_allocator);
|
|
bun.handleOom(log.cloneToWithRecycled(&this.log, true));
|
|
}
|
|
var vm = this.vm;
|
|
var transpiler: bun.Transpiler = undefined;
|
|
transpiler = vm.transpiler;
|
|
transpiler.setAllocator(allocator);
|
|
transpiler.setLog(&log);
|
|
transpiler.resolver.opts = transpiler.options;
|
|
transpiler.macro_context = null;
|
|
transpiler.linker.resolver = &transpiler.resolver;
|
|
|
|
var fd: ?StoredFileDescriptorType = null;
|
|
var package_json: ?*PackageJSON = null;
|
|
const hash = bun.Watcher.getHash(path.text);
|
|
|
|
switch (vm.bun_watcher) {
|
|
.hot, .watch => {
|
|
if (vm.bun_watcher.indexOf(hash)) |index| {
|
|
const watcher_fd = vm.bun_watcher.watchlist().items(.fd)[index];
|
|
fd = if (watcher_fd.stdioTag() == null) watcher_fd else null;
|
|
package_json = vm.bun_watcher.watchlist().items(.package_json)[index];
|
|
}
|
|
},
|
|
else => {},
|
|
}
|
|
|
|
// this should be a cheap lookup because 24 bytes == 8 * 3 so it's read 3 machine words
|
|
const is_node_override = strings.hasPrefixComptime(specifier, node_fallbacks.import_path);
|
|
|
|
const macro_remappings = if (vm.macro_mode or !vm.has_any_macro_remappings or is_node_override)
|
|
MacroRemap{}
|
|
else
|
|
transpiler.options.macro_remap;
|
|
|
|
var fallback_source: logger.Source = undefined;
|
|
|
|
// Usually, we want to close the input file automatically.
|
|
//
|
|
// If we're re-using the file descriptor from the fs watcher
|
|
// Do not close it because that will break the kqueue-based watcher
|
|
//
|
|
var should_close_input_file_fd = fd == null;
|
|
|
|
var input_file_fd: StoredFileDescriptorType = .invalid;
|
|
|
|
const is_main = vm.main.len == path.text.len and
|
|
vm.main_hash == hash and
|
|
strings.eqlLong(vm.main, path.text, false);
|
|
|
|
const module_type: ModuleType = switch (this.resolved_source.tag) {
|
|
.package_json_type_commonjs => .cjs,
|
|
.package_json_type_module => .esm,
|
|
else => .unknown,
|
|
};
|
|
|
|
var parse_options = Transpiler.ParseOptions{
|
|
.allocator = allocator,
|
|
.path = path,
|
|
.loader = loader,
|
|
.dirname_fd = .invalid,
|
|
.file_descriptor = fd,
|
|
.file_fd_ptr = &input_file_fd,
|
|
.file_hash = hash,
|
|
.macro_remappings = macro_remappings,
|
|
.jsx = transpiler.options.jsx,
|
|
.emit_decorator_metadata = transpiler.options.emit_decorator_metadata,
|
|
.virtual_source = null,
|
|
.dont_bundle_twice = true,
|
|
.allow_commonjs = true,
|
|
.inject_jest_globals = transpiler.options.rewrite_jest_for_tests,
|
|
.set_breakpoint_on_first_line = vm.debugger != null and
|
|
vm.debugger.?.set_breakpoint_on_first_line and
|
|
is_main and
|
|
setBreakPointOnFirstLine(),
|
|
.runtime_transpiler_cache = if (!jsc.RuntimeTranspilerCache.is_disabled) &cache else null,
|
|
.remove_cjs_module_wrapper = is_main and vm.module_loader.eval_source != null,
|
|
.module_type = module_type,
|
|
.allow_bytecode_cache = true,
|
|
};
|
|
|
|
defer {
|
|
if (should_close_input_file_fd and input_file_fd.isValid()) {
|
|
input_file_fd.close();
|
|
input_file_fd = .invalid;
|
|
}
|
|
}
|
|
|
|
if (is_node_override) {
|
|
if (node_fallbacks.contentsFromPath(specifier)) |code| {
|
|
const fallback_path = Fs.Path.initWithNamespace(specifier, "node");
|
|
fallback_source = logger.Source{ .path = fallback_path, .contents = code };
|
|
parse_options.virtual_source = &fallback_source;
|
|
}
|
|
}
|
|
|
|
var parse_result: bun.transpiler.ParseResult = transpiler.parseMaybeReturnFileOnlyAllowSharedBuffer(
|
|
parse_options,
|
|
null,
|
|
false,
|
|
false,
|
|
) orelse {
|
|
if (vm.isWatcherEnabled()) {
|
|
if (input_file_fd.isValid()) {
|
|
if (!is_node_override and std.fs.path.isAbsolute(path.text) and !strings.contains(path.text, "node_modules")) {
|
|
should_close_input_file_fd = false;
|
|
_ = vm.bun_watcher.addFile(
|
|
input_file_fd,
|
|
path.text,
|
|
hash,
|
|
loader,
|
|
.invalid,
|
|
package_json,
|
|
true,
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
this.parse_error = error.ParseError;
|
|
|
|
return;
|
|
};
|
|
|
|
if (vm.isWatcherEnabled()) {
|
|
if (input_file_fd.isValid()) {
|
|
if (!is_node_override and
|
|
std.fs.path.isAbsolute(path.text) and !strings.contains(path.text, "node_modules"))
|
|
{
|
|
should_close_input_file_fd = false;
|
|
_ = vm.bun_watcher.addFile(
|
|
input_file_fd,
|
|
path.text,
|
|
hash,
|
|
loader,
|
|
.invalid,
|
|
package_json,
|
|
true,
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (cache.entry) |*entry| {
|
|
vm.source_mappings.putMappings(&parse_result.source, .{
|
|
.list = .{ .items = @constCast(entry.sourcemap), .capacity = entry.sourcemap.len },
|
|
.allocator = bun.default_allocator,
|
|
}) catch {};
|
|
|
|
if (comptime Environment.dump_source) {
|
|
dumpSourceString(vm, specifier, entry.output_code.byteSlice());
|
|
}
|
|
|
|
this.resolved_source = ResolvedSource{
|
|
.allocator = null,
|
|
.source_code = switch (entry.output_code) {
|
|
.string => entry.output_code.string,
|
|
.utf8 => brk: {
|
|
const result = bun.String.cloneUTF8(entry.output_code.utf8);
|
|
cache.output_code_allocator.free(entry.output_code.utf8);
|
|
entry.output_code.utf8 = "";
|
|
break :brk result;
|
|
},
|
|
},
|
|
.is_commonjs_module = entry.metadata.module_type == .cjs,
|
|
.tag = this.resolved_source.tag,
|
|
};
|
|
|
|
return;
|
|
}
|
|
|
|
if (parse_result.already_bundled != .none) {
|
|
const bytecode_slice = parse_result.already_bundled.bytecodeSlice();
|
|
this.resolved_source = ResolvedSource{
|
|
.allocator = null,
|
|
.source_code = bun.String.cloneLatin1(parse_result.source.contents),
|
|
.already_bundled = true,
|
|
.bytecode_cache = if (bytecode_slice.len > 0) bytecode_slice.ptr else null,
|
|
.bytecode_cache_size = bytecode_slice.len,
|
|
.is_commonjs_module = parse_result.already_bundled.isCommonJS(),
|
|
.tag = this.resolved_source.tag,
|
|
};
|
|
this.resolved_source.source_code.ensureHash();
|
|
return;
|
|
}
|
|
|
|
for (parse_result.ast.import_records.slice()) |*import_record_| {
|
|
var import_record: *bun.ImportRecord = import_record_;
|
|
|
|
if (jsc.ModuleLoader.HardcodedModule.Alias.get(import_record.path.text, transpiler.options.target)) |replacement| {
|
|
import_record.path.text = replacement.path;
|
|
import_record.tag = replacement.tag;
|
|
import_record.is_external_without_side_effects = true;
|
|
continue;
|
|
}
|
|
|
|
if (transpiler.options.rewrite_jest_for_tests) {
|
|
if (strings.eqlComptime(
|
|
import_record.path.text,
|
|
"@jest/globals",
|
|
) or strings.eqlComptime(
|
|
import_record.path.text,
|
|
"vitest",
|
|
)) {
|
|
import_record.path.namespace = "bun";
|
|
import_record.tag = .bun_test;
|
|
import_record.path.text = "test";
|
|
import_record.is_external_without_side_effects = true;
|
|
continue;
|
|
}
|
|
}
|
|
|
|
if (strings.hasPrefixComptime(import_record.path.text, "bun:")) {
|
|
import_record.path = Fs.Path.init(import_record.path.text["bun:".len..]);
|
|
import_record.path.namespace = "bun";
|
|
import_record.is_external_without_side_effects = true;
|
|
|
|
if (strings.eqlComptime(import_record.path.text, "test")) {
|
|
import_record.tag = .bun_test;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (source_code_printer == null) {
|
|
const writer = js_printer.BufferWriter.init(bun.default_allocator);
|
|
source_code_printer = bun.default_allocator.create(js_printer.BufferPrinter) catch unreachable;
|
|
source_code_printer.?.* = js_printer.BufferPrinter.init(writer);
|
|
source_code_printer.?.ctx.append_null_byte = false;
|
|
}
|
|
|
|
var printer = source_code_printer.?.*;
|
|
printer.ctx.reset();
|
|
|
|
{
|
|
var mapper = vm.sourceMapHandler(&printer);
|
|
defer source_code_printer.?.* = printer;
|
|
_ = transpiler.printWithSourceMap(
|
|
parse_result,
|
|
@TypeOf(&printer),
|
|
&printer,
|
|
.esm_ascii,
|
|
mapper.get(),
|
|
) catch |err| {
|
|
this.parse_error = err;
|
|
return;
|
|
};
|
|
}
|
|
|
|
if (comptime Environment.dump_source) {
|
|
dumpSource(this.vm, specifier, &printer);
|
|
}
|
|
|
|
const source_code = brk: {
|
|
const written = printer.ctx.getWritten();
|
|
|
|
const result = cache.output_code orelse bun.String.cloneLatin1(written);
|
|
|
|
if (written.len > 1024 * 1024 * 2 or vm.smol) {
|
|
printer.ctx.buffer.deinit();
|
|
source_code_printer.?.* = printer;
|
|
}
|
|
|
|
// In a benchmarking loading @babel/standalone 100 times:
|
|
//
|
|
// After ensureHash:
|
|
// 354.00 ms 4.2% 354.00 ms WTF::StringImpl::hashSlowCase() const
|
|
//
|
|
// Before ensureHash:
|
|
// 506.00 ms 6.1% 506.00 ms WTF::StringImpl::hashSlowCase() const
|
|
//
|
|
result.ensureHash();
|
|
|
|
break :brk result;
|
|
};
|
|
this.resolved_source = ResolvedSource{
|
|
.allocator = null,
|
|
.source_code = source_code,
|
|
.is_commonjs_module = parse_result.ast.has_commonjs_export_names or parse_result.ast.exports_kind == .cjs,
|
|
.tag = this.resolved_source.tag,
|
|
};
|
|
}
|
|
};
|
|
};
|
|
|
|
pub const FetchFlags = enum {
|
|
transpile,
|
|
print_source,
|
|
print_source_and_clone,
|
|
|
|
pub fn disableTranspiling(this: FetchFlags) bool {
|
|
return this != .transpile;
|
|
}
|
|
};
|
|
|
|
pub const HardcodedModule = enum {
|
|
bun,
|
|
@"abort-controller",
|
|
@"bun:app",
|
|
@"bun:ffi",
|
|
@"bun:jsc",
|
|
@"bun:main",
|
|
@"bun:test", // usually replaced by the transpiler but `await import("bun:" + "test")` has to work
|
|
@"bun:wrap",
|
|
@"bun:sqlite",
|
|
@"node:assert",
|
|
@"node:assert/strict",
|
|
@"node:async_hooks",
|
|
@"node:buffer",
|
|
@"node:child_process",
|
|
@"node:console",
|
|
@"node:constants",
|
|
@"node:crypto",
|
|
@"node:dns",
|
|
@"node:dns/promises",
|
|
@"node:domain",
|
|
@"node:events",
|
|
@"node:fs",
|
|
@"node:fs/promises",
|
|
@"node:http",
|
|
@"node:https",
|
|
@"node:module",
|
|
@"node:net",
|
|
@"node:os",
|
|
@"node:path",
|
|
@"node:path/posix",
|
|
@"node:path/win32",
|
|
@"node:perf_hooks",
|
|
@"node:process",
|
|
@"node:querystring",
|
|
@"node:readline",
|
|
@"node:readline/promises",
|
|
@"node:stream",
|
|
@"node:stream/consumers",
|
|
@"node:stream/promises",
|
|
@"node:stream/web",
|
|
@"node:string_decoder",
|
|
@"node:test",
|
|
@"node:timers",
|
|
@"node:timers/promises",
|
|
@"node:tls",
|
|
@"node:tty",
|
|
@"node:url",
|
|
@"node:util",
|
|
@"node:util/types",
|
|
@"node:vm",
|
|
@"node:wasi",
|
|
@"node:zlib",
|
|
@"node:worker_threads",
|
|
@"node:punycode",
|
|
undici,
|
|
ws,
|
|
@"isomorphic-fetch",
|
|
@"node-fetch",
|
|
vercel_fetch,
|
|
@"utf-8-validate",
|
|
@"node:v8",
|
|
@"node:trace_events",
|
|
@"node:repl",
|
|
@"node:inspector",
|
|
@"node:http2",
|
|
@"node:diagnostics_channel",
|
|
@"node:dgram",
|
|
@"node:cluster",
|
|
@"node:_stream_duplex",
|
|
@"node:_stream_passthrough",
|
|
@"node:_stream_readable",
|
|
@"node:_stream_transform",
|
|
@"node:_stream_wrap",
|
|
@"node:_stream_writable",
|
|
@"node:_tls_common",
|
|
@"node:_http_agent",
|
|
@"node:_http_client",
|
|
@"node:_http_common",
|
|
@"node:_http_incoming",
|
|
@"node:_http_outgoing",
|
|
@"node:_http_server",
|
|
/// This is gated behind '--expose-internals'
|
|
@"bun:internal-for-testing",
|
|
|
|
/// The module loader first uses `Aliases` to get a single string during
|
|
/// resolution, then maps that single string to the actual module.
|
|
/// Do not include aliases here; Those go in `Aliases`.
|
|
pub const map = bun.ComptimeStringMap(HardcodedModule, [_]struct { []const u8, HardcodedModule }{
|
|
// Bun
|
|
.{ "bun", .bun },
|
|
.{ "bun:app", .@"bun:app" },
|
|
.{ "bun:ffi", .@"bun:ffi" },
|
|
.{ "bun:jsc", .@"bun:jsc" },
|
|
.{ "bun:main", .@"bun:main" },
|
|
.{ "bun:test", .@"bun:test" },
|
|
.{ "bun:sqlite", .@"bun:sqlite" },
|
|
.{ "bun:wrap", .@"bun:wrap" },
|
|
.{ "bun:internal-for-testing", .@"bun:internal-for-testing" },
|
|
// Node.js
|
|
.{ "node:assert", .@"node:assert" },
|
|
.{ "node:assert/strict", .@"node:assert/strict" },
|
|
.{ "node:async_hooks", .@"node:async_hooks" },
|
|
.{ "node:buffer", .@"node:buffer" },
|
|
.{ "node:child_process", .@"node:child_process" },
|
|
.{ "node:cluster", .@"node:cluster" },
|
|
.{ "node:console", .@"node:console" },
|
|
.{ "node:constants", .@"node:constants" },
|
|
.{ "node:crypto", .@"node:crypto" },
|
|
.{ "node:dgram", .@"node:dgram" },
|
|
.{ "node:diagnostics_channel", .@"node:diagnostics_channel" },
|
|
.{ "node:dns", .@"node:dns" },
|
|
.{ "node:dns/promises", .@"node:dns/promises" },
|
|
.{ "node:domain", .@"node:domain" },
|
|
.{ "node:events", .@"node:events" },
|
|
.{ "node:fs", .@"node:fs" },
|
|
.{ "node:fs/promises", .@"node:fs/promises" },
|
|
.{ "node:http", .@"node:http" },
|
|
.{ "node:http2", .@"node:http2" },
|
|
.{ "node:https", .@"node:https" },
|
|
.{ "node:inspector", .@"node:inspector" },
|
|
.{ "node:module", .@"node:module" },
|
|
.{ "node:net", .@"node:net" },
|
|
.{ "node:readline", .@"node:readline" },
|
|
.{ "node:test", .@"node:test" },
|
|
.{ "node:os", .@"node:os" },
|
|
.{ "node:path", .@"node:path" },
|
|
.{ "node:path/posix", .@"node:path/posix" },
|
|
.{ "node:path/win32", .@"node:path/win32" },
|
|
.{ "node:perf_hooks", .@"node:perf_hooks" },
|
|
.{ "node:process", .@"node:process" },
|
|
.{ "node:punycode", .@"node:punycode" },
|
|
.{ "node:querystring", .@"node:querystring" },
|
|
.{ "node:readline", .@"node:readline" },
|
|
.{ "node:readline/promises", .@"node:readline/promises" },
|
|
.{ "node:repl", .@"node:repl" },
|
|
.{ "node:stream", .@"node:stream" },
|
|
.{ "node:stream/consumers", .@"node:stream/consumers" },
|
|
.{ "node:stream/promises", .@"node:stream/promises" },
|
|
.{ "node:stream/web", .@"node:stream/web" },
|
|
.{ "node:string_decoder", .@"node:string_decoder" },
|
|
.{ "node:timers", .@"node:timers" },
|
|
.{ "node:timers/promises", .@"node:timers/promises" },
|
|
.{ "node:tls", .@"node:tls" },
|
|
.{ "node:trace_events", .@"node:trace_events" },
|
|
.{ "node:tty", .@"node:tty" },
|
|
.{ "node:url", .@"node:url" },
|
|
.{ "node:util", .@"node:util" },
|
|
.{ "node:util/types", .@"node:util/types" },
|
|
.{ "node:v8", .@"node:v8" },
|
|
.{ "node:vm", .@"node:vm" },
|
|
.{ "node:wasi", .@"node:wasi" },
|
|
.{ "node:worker_threads", .@"node:worker_threads" },
|
|
.{ "node:zlib", .@"node:zlib" },
|
|
.{ "node:_stream_duplex", .@"node:_stream_duplex" },
|
|
.{ "node:_stream_passthrough", .@"node:_stream_passthrough" },
|
|
.{ "node:_stream_readable", .@"node:_stream_readable" },
|
|
.{ "node:_stream_transform", .@"node:_stream_transform" },
|
|
.{ "node:_stream_wrap", .@"node:_stream_wrap" },
|
|
.{ "node:_stream_writable", .@"node:_stream_writable" },
|
|
.{ "node:_tls_common", .@"node:_tls_common" },
|
|
.{ "node:_http_agent", .@"node:_http_agent" },
|
|
.{ "node:_http_client", .@"node:_http_client" },
|
|
.{ "node:_http_common", .@"node:_http_common" },
|
|
.{ "node:_http_incoming", .@"node:_http_incoming" },
|
|
.{ "node:_http_outgoing", .@"node:_http_outgoing" },
|
|
.{ "node:_http_server", .@"node:_http_server" },
|
|
|
|
.{ "node-fetch", HardcodedModule.@"node-fetch" },
|
|
.{ "isomorphic-fetch", HardcodedModule.@"isomorphic-fetch" },
|
|
.{ "undici", HardcodedModule.undici },
|
|
.{ "ws", HardcodedModule.ws },
|
|
.{ "@vercel/fetch", HardcodedModule.vercel_fetch },
|
|
.{ "utf-8-validate", HardcodedModule.@"utf-8-validate" },
|
|
.{ "abort-controller", HardcodedModule.@"abort-controller" },
|
|
});
|
|
|
|
/// Contains the list of built-in modules from the perspective of the module
|
|
/// loader. This logic is duplicated for `isBuiltinModule` and the like.
|
|
pub const Alias = struct {
|
|
path: [:0]const u8,
|
|
tag: ImportRecord.Tag = .builtin,
|
|
node_builtin: bool = false,
|
|
node_only_prefix: bool = false,
|
|
|
|
fn nodeEntry(path: [:0]const u8) struct { string, Alias } {
|
|
return .{
|
|
path,
|
|
.{
|
|
.path = if (path.len > 5 and std.mem.eql(u8, path[0..5], "node:")) path else "node:" ++ path,
|
|
.node_builtin = true,
|
|
},
|
|
};
|
|
}
|
|
fn nodeEntryOnlyPrefix(path: [:0]const u8) struct { string, Alias } {
|
|
return .{
|
|
path,
|
|
.{
|
|
.path = if (path.len > 5 and std.mem.eql(u8, path[0..5], "node:")) path else "node:" ++ path,
|
|
.node_builtin = true,
|
|
.node_only_prefix = true,
|
|
},
|
|
};
|
|
}
|
|
fn entry(path: [:0]const u8) struct { string, Alias } {
|
|
return .{ path, .{ .path = path } };
|
|
}
|
|
|
|
// Applied to both --target=bun and --target=node
|
|
const common_alias_kvs = [_]struct { string, Alias }{
|
|
nodeEntry("node:assert"),
|
|
nodeEntry("node:assert/strict"),
|
|
nodeEntry("node:async_hooks"),
|
|
nodeEntry("node:buffer"),
|
|
nodeEntry("node:child_process"),
|
|
nodeEntry("node:cluster"),
|
|
nodeEntry("node:console"),
|
|
nodeEntry("node:constants"),
|
|
nodeEntry("node:crypto"),
|
|
nodeEntry("node:dgram"),
|
|
nodeEntry("node:diagnostics_channel"),
|
|
nodeEntry("node:dns"),
|
|
nodeEntry("node:dns/promises"),
|
|
nodeEntry("node:domain"),
|
|
nodeEntry("node:events"),
|
|
nodeEntry("node:fs"),
|
|
nodeEntry("node:fs/promises"),
|
|
nodeEntry("node:http"),
|
|
nodeEntry("node:http2"),
|
|
nodeEntry("node:https"),
|
|
nodeEntry("node:inspector"),
|
|
nodeEntry("node:module"),
|
|
nodeEntry("node:net"),
|
|
nodeEntry("node:os"),
|
|
nodeEntry("node:path"),
|
|
nodeEntry("node:path/posix"),
|
|
nodeEntry("node:path/win32"),
|
|
nodeEntry("node:perf_hooks"),
|
|
nodeEntry("node:process"),
|
|
nodeEntry("node:punycode"),
|
|
nodeEntry("node:querystring"),
|
|
nodeEntry("node:readline"),
|
|
nodeEntry("node:readline/promises"),
|
|
nodeEntry("node:repl"),
|
|
nodeEntry("node:stream"),
|
|
nodeEntry("node:stream/consumers"),
|
|
nodeEntry("node:stream/promises"),
|
|
nodeEntry("node:stream/web"),
|
|
nodeEntry("node:string_decoder"),
|
|
nodeEntry("node:timers"),
|
|
nodeEntry("node:timers/promises"),
|
|
nodeEntry("node:tls"),
|
|
nodeEntry("node:trace_events"),
|
|
nodeEntry("node:tty"),
|
|
nodeEntry("node:url"),
|
|
nodeEntry("node:util"),
|
|
nodeEntry("node:util/types"),
|
|
nodeEntry("node:v8"),
|
|
nodeEntry("node:vm"),
|
|
nodeEntry("node:wasi"),
|
|
nodeEntry("node:worker_threads"),
|
|
nodeEntry("node:zlib"),
|
|
// New Node.js builtins only resolve from the prefixed one.
|
|
nodeEntryOnlyPrefix("node:test"),
|
|
|
|
nodeEntry("assert"),
|
|
nodeEntry("assert/strict"),
|
|
nodeEntry("async_hooks"),
|
|
nodeEntry("buffer"),
|
|
nodeEntry("child_process"),
|
|
nodeEntry("cluster"),
|
|
nodeEntry("console"),
|
|
nodeEntry("constants"),
|
|
nodeEntry("crypto"),
|
|
nodeEntry("dgram"),
|
|
nodeEntry("diagnostics_channel"),
|
|
nodeEntry("dns"),
|
|
nodeEntry("dns/promises"),
|
|
nodeEntry("domain"),
|
|
nodeEntry("events"),
|
|
nodeEntry("fs"),
|
|
nodeEntry("fs/promises"),
|
|
nodeEntry("http"),
|
|
nodeEntry("http2"),
|
|
nodeEntry("https"),
|
|
nodeEntry("inspector"),
|
|
nodeEntry("module"),
|
|
nodeEntry("net"),
|
|
nodeEntry("os"),
|
|
nodeEntry("path"),
|
|
nodeEntry("path/posix"),
|
|
nodeEntry("path/win32"),
|
|
nodeEntry("perf_hooks"),
|
|
nodeEntry("process"),
|
|
nodeEntry("punycode"),
|
|
nodeEntry("querystring"),
|
|
nodeEntry("readline"),
|
|
nodeEntry("readline/promises"),
|
|
nodeEntry("repl"),
|
|
nodeEntry("stream"),
|
|
nodeEntry("stream/consumers"),
|
|
nodeEntry("stream/promises"),
|
|
nodeEntry("stream/web"),
|
|
nodeEntry("string_decoder"),
|
|
nodeEntry("timers"),
|
|
nodeEntry("timers/promises"),
|
|
nodeEntry("tls"),
|
|
nodeEntry("trace_events"),
|
|
nodeEntry("tty"),
|
|
nodeEntry("url"),
|
|
nodeEntry("util"),
|
|
nodeEntry("util/types"),
|
|
nodeEntry("v8"),
|
|
nodeEntry("vm"),
|
|
nodeEntry("wasi"),
|
|
nodeEntry("worker_threads"),
|
|
nodeEntry("zlib"),
|
|
|
|
nodeEntry("node:_http_agent"),
|
|
nodeEntry("node:_http_client"),
|
|
nodeEntry("node:_http_common"),
|
|
nodeEntry("node:_http_incoming"),
|
|
nodeEntry("node:_http_outgoing"),
|
|
nodeEntry("node:_http_server"),
|
|
|
|
nodeEntry("_http_agent"),
|
|
nodeEntry("_http_client"),
|
|
nodeEntry("_http_common"),
|
|
nodeEntry("_http_incoming"),
|
|
nodeEntry("_http_outgoing"),
|
|
nodeEntry("_http_server"),
|
|
|
|
// sys is a deprecated alias for util
|
|
.{ "sys", .{ .path = "node:util", .node_builtin = true } },
|
|
.{ "node:sys", .{ .path = "node:util", .node_builtin = true } },
|
|
|
|
// These are returned in builtinModules, but probably not many
|
|
// packages use them so we will just alias them.
|
|
.{ "node:_stream_duplex", .{ .path = "node:_stream_duplex", .node_builtin = true } },
|
|
.{ "node:_stream_passthrough", .{ .path = "node:_stream_passthrough", .node_builtin = true } },
|
|
.{ "node:_stream_readable", .{ .path = "node:_stream_readable", .node_builtin = true } },
|
|
.{ "node:_stream_transform", .{ .path = "node:_stream_transform", .node_builtin = true } },
|
|
.{ "node:_stream_wrap", .{ .path = "node:_stream_wrap", .node_builtin = true } },
|
|
.{ "node:_stream_writable", .{ .path = "node:_stream_writable", .node_builtin = true } },
|
|
.{ "node:_tls_wrap", .{ .path = "node:tls", .node_builtin = true } },
|
|
.{ "node:_tls_common", .{ .path = "node:_tls_common", .node_builtin = true } },
|
|
.{ "_stream_duplex", .{ .path = "node:_stream_duplex", .node_builtin = true } },
|
|
.{ "_stream_passthrough", .{ .path = "node:_stream_passthrough", .node_builtin = true } },
|
|
.{ "_stream_readable", .{ .path = "node:_stream_readable", .node_builtin = true } },
|
|
.{ "_stream_transform", .{ .path = "node:_stream_transform", .node_builtin = true } },
|
|
.{ "_stream_wrap", .{ .path = "node:_stream_wrap", .node_builtin = true } },
|
|
.{ "_stream_writable", .{ .path = "node:_stream_writable", .node_builtin = true } },
|
|
.{ "_tls_wrap", .{ .path = "node:tls", .node_builtin = true } },
|
|
.{ "_tls_common", .{ .path = "node:_tls_common", .node_builtin = true } },
|
|
};
|
|
|
|
const bun_extra_alias_kvs = [_]struct { string, Alias }{
|
|
.{ "bun", .{ .path = "bun", .tag = .bun } },
|
|
.{ "bun:test", .{ .path = "bun:test", .tag = .bun_test } },
|
|
.{ "bun:app", .{ .path = "bun:app" } },
|
|
.{ "bun:ffi", .{ .path = "bun:ffi" } },
|
|
.{ "bun:jsc", .{ .path = "bun:jsc" } },
|
|
.{ "bun:sqlite", .{ .path = "bun:sqlite" } },
|
|
.{ "bun:wrap", .{ .path = "bun:wrap" } },
|
|
.{ "bun:internal-for-testing", .{ .path = "bun:internal-for-testing" } },
|
|
.{ "ffi", .{ .path = "bun:ffi" } },
|
|
|
|
// inspector/promises is not implemented, it is an alias of inspector
|
|
.{ "node:inspector/promises", .{ .path = "node:inspector", .node_builtin = true } },
|
|
.{ "inspector/promises", .{ .path = "node:inspector", .node_builtin = true } },
|
|
|
|
// Thirdparty packages we override
|
|
.{ "@vercel/fetch", .{ .path = "@vercel/fetch" } },
|
|
.{ "isomorphic-fetch", .{ .path = "isomorphic-fetch" } },
|
|
.{ "node-fetch", .{ .path = "node-fetch" } },
|
|
.{ "undici", .{ .path = "undici" } },
|
|
.{ "utf-8-validate", .{ .path = "utf-8-validate" } },
|
|
.{ "ws", .{ .path = "ws" } },
|
|
.{ "ws/lib/websocket", .{ .path = "ws" } },
|
|
|
|
// Polyfills we force to native
|
|
.{ "abort-controller", .{ .path = "abort-controller" } },
|
|
.{ "abort-controller/polyfill", .{ .path = "abort-controller" } },
|
|
|
|
// To force Next.js to not use bundled dependencies.
|
|
.{ "next/dist/compiled/ws", .{ .path = "ws" } },
|
|
.{ "next/dist/compiled/node-fetch", .{ .path = "node-fetch" } },
|
|
.{ "next/dist/compiled/undici", .{ .path = "undici" } },
|
|
};
|
|
|
|
const node_extra_alias_kvs = [_]struct { string, Alias }{
|
|
nodeEntry("node:inspector/promises"),
|
|
nodeEntry("inspector/promises"),
|
|
};
|
|
|
|
const node_aliases = bun.ComptimeStringMap(Alias, common_alias_kvs ++ node_extra_alias_kvs);
|
|
const bun_aliases = bun.ComptimeStringMap(Alias, common_alias_kvs ++ bun_extra_alias_kvs);
|
|
|
|
pub fn has(name: []const u8, target: options.Target) bool {
|
|
return get(name, target) != null;
|
|
}
|
|
|
|
pub fn get(name: []const u8, target: options.Target) ?Alias {
|
|
if (target.isBun()) {
|
|
return bun_aliases.get(name);
|
|
} else if (target.isNode()) {
|
|
return node_aliases.get(name);
|
|
}
|
|
return null;
|
|
}
|
|
};
|
|
};
|
|
|
|
/// Support embedded .node files
|
|
export fn Bun__resolveEmbeddedNodeFile(vm: *VirtualMachine, in_out_str: *bun.String) bool {
|
|
if (vm.standalone_module_graph == null) return false;
|
|
|
|
const input_path = in_out_str.toUTF8(bun.default_allocator);
|
|
defer input_path.deinit();
|
|
const result = ModuleLoader.resolveEmbeddedFile(vm, input_path.slice(), "node") orelse return false;
|
|
in_out_str.* = bun.String.cloneUTF8(result);
|
|
return true;
|
|
}
|
|
|
|
export fn ModuleLoader__isBuiltin(data: [*]const u8, len: usize) bool {
|
|
const str = data[0..len];
|
|
return HardcodedModule.Alias.bun_aliases.get(str) != null;
|
|
}
|
|
|
|
const debug = Output.scoped(.ModuleLoader, .hidden);
|
|
|
|
const string = []const u8;
|
|
|
|
const Dependency = @import("../install/dependency.zig");
|
|
const Fs = @import("../fs.zig");
|
|
const Runtime = @import("../runtime.zig");
|
|
const node_module_module = @import("./bindings/NodeModuleModule.zig");
|
|
const std = @import("std");
|
|
const panic = std.debug.panic;
|
|
|
|
const ast = @import("../import_record.zig");
|
|
const ImportRecord = ast.ImportRecord;
|
|
|
|
const Install = @import("../install/install.zig");
|
|
const PackageManager = @import("../install/install.zig").PackageManager;
|
|
|
|
const options = @import("../options.zig");
|
|
const ModuleType = options.ModuleType;
|
|
|
|
const MacroRemap = @import("../resolver/package_json.zig").MacroMap;
|
|
const PackageJSON = @import("../resolver/package_json.zig").PackageJSON;
|
|
|
|
const bun = @import("bun");
|
|
const Async = bun.Async;
|
|
const Environment = bun.Environment;
|
|
const MutableString = bun.MutableString;
|
|
const Output = bun.Output;
|
|
const StoredFileDescriptorType = bun.StoredFileDescriptorType;
|
|
const String = bun.String;
|
|
const Transpiler = bun.Transpiler;
|
|
const analytics = bun.analytics;
|
|
const js_ast = bun.ast;
|
|
const js_printer = bun.js_printer;
|
|
const logger = bun.logger;
|
|
const strings = bun.strings;
|
|
const Arena = bun.allocators.MimallocArena;
|
|
const api = bun.schema.api;
|
|
|
|
const jsc = bun.jsc;
|
|
const JSGlobalObject = bun.jsc.JSGlobalObject;
|
|
const JSValue = bun.jsc.JSValue;
|
|
const ResolvedSource = bun.jsc.ResolvedSource;
|
|
const VirtualMachine = bun.jsc.VirtualMachine;
|
|
const ZigString = bun.jsc.ZigString;
|
|
const Bun = jsc.API.Bun;
|
|
|
|
const ParseResult = bun.transpiler.ParseResult;
|
|
const PluginRunner = bun.transpiler.PluginRunner;
|
|
const MacroEntryPoint = bun.transpiler.EntryPoints.MacroEntryPoint;
|