ssg 3

src/allocators/allocation_scope.zig

@@ -506,6 +506,12 @@ pub fn AllocationScopeIn(comptime Allocator: type) type {
         pub fn setPointerExtra(self: Self, ptr: *anyopaque, extra: Extra) void {
             return self.borrow().setPointerExtra(ptr, extra);
         }
+
+        pub fn leakSlice(self: Self, memory: anytype) void {
+            if (comptime !Self.enabled) return;
+            _ = @typeInfo(@TypeOf(memory)).pointer;
+            self.trackExternalFree(memory, null) catch @panic("tried to free memory that was not allocated by the allocation scope");
+        }
     };
 }
 

src/ast/P.zig

@@ -170,6 +170,21 @@ pub fn NewParser_(
         dirname_ref: Ref = Ref.None,
         import_meta_ref: Ref = Ref.None,
         hmr_api_ref: Ref = Ref.None,
+
+        /// If bake is enabled and this is a server-side file, we want to use
+        /// special `Response` class inside the `bun:app` built-in module to
+        /// support syntax like `return Response(<jsx />, {...})` or `return Response.render("/my-page")`
+        /// or `return Response.redirect("/other")`.
+        ///
+        /// So we'll need to add a `import { Response } from 'bun:app'` to the
+        /// top of the file
+        ///
+        /// We need to declare this `response_ref` upfront
+        response_ref: Ref = Ref.None,
+        /// We also need to declare the namespace ref for `bun:app` and attach
+        /// it to the symbol so the code generated `e_import_identifier`'s
+        bun_app_namespace_ref: Ref = Ref.None,
+
         scopes_in_order_visitor_index: usize = 0,
         has_classic_runtime_warned: bool = false,
         macro_call_count: MacroCallCountType = 0,
@@ -1220,14 +1235,89 @@ pub fn NewParser_(
             };
         }
 
+        pub fn generateImportStmtForBakeResponse(
+            noalias p: *P,
+            parts: *ListManaged(js_ast.Part),
+        ) !void {
+            bun.assert(!p.response_ref.isNull());
+            bun.assert(!p.bun_app_namespace_ref.isNull());
+            const allocator = p.allocator;
+
+            const import_path = "bun:app";
+
+            const import_record_i = p.addImportRecordByRange(.stmt, logger.Range.None, import_path);
+
+            var declared_symbols = DeclaredSymbol.List{};
+            try declared_symbols.ensureTotalCapacity(allocator, 2);
+
+            var stmts = try allocator.alloc(Stmt, 1);
+
+            declared_symbols.appendAssumeCapacity(
+                DeclaredSymbol{ .ref = p.bun_app_namespace_ref, .is_top_level = true },
+            );
+            try p.module_scope.generated.append(allocator, p.bun_app_namespace_ref);
+
+            const clause_items = try allocator.dupe(js_ast.ClauseItem, &.{
+                js_ast.ClauseItem{
+                    .alias = "Response",
+                    .original_name = "Response",
+                    .alias_loc = logger.Loc{},
+                    .name = LocRef{ .ref = p.response_ref, .loc = logger.Loc{} },
+                },
+            });
+
+            declared_symbols.appendAssumeCapacity(DeclaredSymbol{
+                .ref = p.response_ref,
+                .is_top_level = true,
+            });
+
+            // ensure every e_import_identifier holds the namespace
+            if (p.options.features.hot_module_reloading) {
+                const symbol = &p.symbols.items[p.response_ref.inner_index];
+                bun.assert(symbol.namespace_alias != null);
+                symbol.namespace_alias.?.import_record_index = import_record_i;
+            }
+
+            try p.is_import_item.put(allocator, p.response_ref, {});
+            try p.named_imports.put(allocator, p.response_ref, js_ast.NamedImport{
+                .alias = "Response",
+                .alias_loc = logger.Loc{},
+                .namespace_ref = p.bun_app_namespace_ref,
+                .import_record_index = import_record_i,
+            });
+
+            stmts[0] = p.s(
+                S.Import{
+                    .namespace_ref = p.bun_app_namespace_ref,
+                    .items = clause_items,
+                    .import_record_index = import_record_i,
+                    .is_single_line = true,
+                },
+                logger.Loc{},
+            );
+
+            var import_records = try allocator.alloc(u32, 1);
+            import_records[0] = import_record_i;
+
+            // This import is placed in a part before the main code, however
+            // the bundler ends up re-ordering this to be after... The order
+            // does not matter as ESM imports are always hoisted.
+            parts.append(js_ast.Part{
+                .stmts = stmts,
+                .declared_symbols = declared_symbols,
+                .import_record_indices = bun.BabyList(u32).fromOwnedSlice(import_records),
+                .tag = .runtime,
+            }) catch unreachable;
+        }
+
         pub fn generateImportStmt(
             noalias p: *P,
             import_path: string,
             imports: anytype,
             parts: *ListManaged(js_ast.Part),
             symbols: anytype,
             additional_stmt: ?Stmt,
-            comptime suffix: string,
+            comptime prefix: string,
             comptime is_internal: bool,
         ) anyerror!void {
             const allocator = p.allocator;
@@ -1237,13 +1327,13 @@ pub fn NewParser_(
                 import_record.path.namespace = "runtime";
             import_record.is_internal = is_internal;
             const import_path_identifier = try import_record.path.name.nonUniqueNameString(allocator);
-            var namespace_identifier = try allocator.alloc(u8, import_path_identifier.len + suffix.len);
+            var namespace_identifier = try allocator.alloc(u8, import_path_identifier.len + prefix.len);
             const clause_items = try allocator.alloc(js_ast.ClauseItem, imports.len);
             var stmts = try allocator.alloc(Stmt, 1 + if (additional_stmt != null) @as(usize, 1) else @as(usize, 0));
             var declared_symbols = DeclaredSymbol.List{};
             try declared_symbols.ensureTotalCapacity(allocator, imports.len + 1);
-            bun.copy(u8, namespace_identifier, suffix);
-            bun.copy(u8, namespace_identifier[suffix.len..], import_path_identifier);
+            bun.copy(u8, namespace_identifier, prefix);
+            bun.copy(u8, namespace_identifier[prefix.len..], import_path_identifier);
 
             const namespace_ref = try p.newSymbol(.other, namespace_identifier);
             declared_symbols.appendAssumeCapacity(.{
@@ -2014,6 +2104,25 @@ pub fn NewParser_(
                 .wrap_exports_for_server_reference => {},
             }
 
+            // Server-side components:
+            // Declare upfront the symbols for "Response" and "bun:app"
+            switch (p.options.features.server_components) {
+                .none, .client_side => {},
+                else => {
+                    p.response_ref = try p.declareGeneratedSymbol(.import, "Response");
+                    p.bun_app_namespace_ref = try p.newSymbol(
+                        .other,
+                        "import_bun_app",
+                    );
+                    const symbol = &p.symbols.items[p.response_ref.inner_index];
+                    symbol.namespace_alias = .{
+                        .namespace_ref = p.bun_app_namespace_ref,
+                        .alias = "Response",
+                        .import_record_index = std.math.maxInt(u32),
+                    };
+                },
+            }
+
             if (p.options.features.hot_module_reloading) {
                 p.hmr_api_ref = try p.declareCommonJSSymbol(.unbound, "hmr");
             }
@@ -3071,7 +3180,7 @@ pub fn NewParser_(
             return ref;
         }
 
-        fn declareGeneratedSymbol(p: *P, kind: Symbol.Kind, comptime name: string) !Ref {
+        pub fn declareGeneratedSymbol(p: *P, kind: Symbol.Kind, comptime name: string) !Ref {
             // The bundler runs the renamer, so it is ok to not append a hash
             if (p.options.bundle) {
                 return try declareSymbolMaybeGenerated(p, kind, logger.Loc.Empty, name, true);

src/ast/Parser.zig

@@ -1357,6 +1357,16 @@ pub const Parser = struct {
             );
         }
 
+        // Bake: transform global `Response` to use `import { Response } from 'bun:app'`
+        if (!p.response_ref.isNull() and is_used_and_has_no_links: {
+            // We only want to do this if the symbol is used and didn't get
+            // bound to some other value
+            const symbol: *const Symbol = &p.symbols.items[p.response_ref.innerIndex()];
+            break :is_used_and_has_no_links !symbol.hasLink() and symbol.use_count_estimate > 0;
+        }) {
+            try p.generateImportStmtForBakeResponse(&before);
+        }
+
         if (before.items.len > 0 or after.items.len > 0) {
             try parts.ensureUnusedCapacity(before.items.len + after.items.len);
             const parts_len = parts.items.len;

src/ast/visitExpr.zig

@@ -1445,9 +1445,20 @@ pub fn VisitExpr(
                     // Why? Because we *don't* want to check for uses of
                     // `useState` _inside_ React, and we know React uses
                     // commonjs so it will never be `.e_import_identifier`.
-                    e_.target.data == .e_import_identifier) {
+                    check_for_usestate: {
+                        if (e_.target.data == .e_import_identifier) break :check_for_usestate true;
+                        // Also check for `React.useState(...)`
+                        if (e_.target.data == .e_dot and e_.target.data.e_dot.target.data == .e_import_identifier) {
+                            const id = e_.target.data.e_dot.target.data.e_import_identifier;
+                            const name = p.symbols.items[id.ref.innerIndex()].original_name;
+                            break :check_for_usestate bun.strings.eqlComptime(name, "React");
+                        }
+                        break :check_for_usestate false;
+                    }) {
                         bun.assert(p.options.features.server_components.isServerSide());
-                        if (bun.strings.eqlComptime(original_name, "useState")) {
+                        if (!bun.strings.startsWith(p.source.path.pretty, "node_modules") and
+                            bun.strings.eqlComptime(original_name, "useState"))
+                        {
                             p.log.addError(
                                 p.source,
                                 expr.loc,

src/bake.zig

@@ -27,9 +27,6 @@ pub const UserOptions = struct {
 
     /// Currently, this function must run at the top of the event loop.
     pub fn fromJS(config: JSValue, global: *jsc.JSGlobalObject) !UserOptions {
-        if (!config.isObject()) {
-            return global.throwInvalidArguments("'" ++ api_name ++ "' is not an object", .{});
-        }
         var arena = std.heap.ArenaAllocator.init(bun.default_allocator);
         errdefer arena.deinit();
         const alloc = arena.allocator();
@@ -38,6 +35,38 @@ pub const UserOptions = struct {
         errdefer allocations.free();
         var bundler_options = SplitBundlerOptions.empty;
 
+        if (!config.isObject()) {
+            // Allow users to do `export default { app: 'react' }` for convenience
+            if (config.isString()) {
+                const bunstr = try config.toBunString(global);
+                defer bunstr.deref();
+                const utf8_string = bunstr.toUTF8(bun.default_allocator);
+                defer utf8_string.deinit();
+
+                if (bun.strings.eql(utf8_string.byteSlice(), "react")) {
+                    const root = bun.getcwdAlloc(alloc) catch |err| switch (err) {
+                        error.OutOfMemory => {
+                            return global.throwOutOfMemory();
+                        },
+                        else => {
+                            return global.throwError(err, "while querying current working directory");
+                        },
+                    };
+
+                    const framework = try Framework.react(alloc);
+
+                    return UserOptions{
+                        .arena = arena,
+                        .allocations = allocations,
+                        .root = root,
+                        .framework = framework,
+                        .bundler_options = bundler_options,
+                    };
+                }
+            }
+            return global.throwInvalidArguments("'" ++ api_name ++ "' is not an object", .{});
+        }
+
         if (try config.getOptional(global, "bundlerOptions", JSValue)) |js_options| {
             if (try js_options.getOptional(global, "server", JSValue)) |server_options| {
                 bundler_options.server = try BuildConfigSubset.fromJS(global, server_options);

src/bake/BakeSourceProvider.cpp

@@ -1,5 +1,6 @@
 // clang-format off
 #include "BakeSourceProvider.h"
+#include "DevServerSourceProvider.h"
 #include "BakeGlobalObject.h"
 #include "JavaScriptCore/CallData.h"
 #include "JavaScriptCore/Completion.h"
@@ -78,6 +79,34 @@ extern "C" JSC::EncodedJSValue BakeLoadServerHmrPatch(GlobalObject* global, BunS
   return JSC::JSValue::encode(result);
 }
 
+extern "C" JSC::EncodedJSValue BakeLoadServerHmrPatchWithSourceMap(GlobalObject* global, BunString source, const char* sourceMapJSONPtr, size_t sourceMapJSONLength) {
+  JSC::VM&vm = global->vm();
+  auto scope = DECLARE_THROW_SCOPE(vm);
+
+  String string = "bake://server.patch.js"_s;
+  JSC::SourceOrigin origin = JSC::SourceOrigin(WTF::URL(string));
+
+  // Use DevServerSourceProvider with the source map JSON
+  auto provider = DevServerSourceProvider::create(
+    global,
+    source.toWTFString(),
+    sourceMapJSONPtr,
+    sourceMapJSONLength,
+    origin,
+    WTFMove(string),
+    WTF::TextPosition(),
+    JSC::SourceProviderSourceType::Program
+  );
+
+  JSC::SourceCode sourceCode = JSC::SourceCode(provider);
+
+  JSC::JSValue result = vm.interpreter.executeProgram(sourceCode, global, global);
+  RETURN_IF_EXCEPTION(scope, {});
+
+  RELEASE_ASSERT(result);
+  return JSC::JSValue::encode(result);
+}
+
 extern "C" JSC::EncodedJSValue BakeGetModuleNamespace(
   JSC::JSGlobalObject* global,
   JSC::JSValue keyValue