diff options
Diffstat (limited to 'src')
| -rw-r--r-- | src/bundler.zig | 35 | ||||
| -rw-r--r-- | src/cli.zig | 71 | ||||
| -rw-r--r-- | src/logger.zig | 22 | ||||
| -rw-r--r-- | src/options.zig | 18 |
4 files changed, 123 insertions, 23 deletions
diff --git a/src/bundler.zig b/src/bundler.zig index 817dca8db..cf971dc6e 100644 --- a/src/bundler.zig +++ b/src/bundler.zig @@ -22,6 +22,12 @@ pub const Bundler = struct { allocator: *std.mem.Allocator, result: ?options.TransformResult = null, + pub fn init( + allocator: *std.mem.Allocator, + log: *logger.Log, + opts: Api.TransformOptions, + ) !Bundler {} + pub fn bundle( allocator: *std.mem.Allocator, log: *logger.Log, @@ -54,6 +60,8 @@ pub const Transformer = struct { ); const cwd = opts.absolute_working_dir orelse try std.process.getCwdAlloc(allocator); + const output_dir_parts = [_]string{ cwd, opts.output_dir orelse "out" }; + const output_dir = try std.fs.path.join(allocator, &output_dir_parts); var output_files = try std.ArrayList(options.OutputFile).initCapacity(allocator, opts.entry_points.len); var loader_values = try allocator.alloc(options.Loader, opts.loader_values.len); for (loader_values) |_, i| { @@ -78,8 +86,11 @@ pub const Transformer = struct { var use_default_loaders = loader_map.count() == 0; var jsx = if (opts.jsx) |_jsx| options.JSX.Pragma.fromApi(_jsx) else options.JSX.Pragma{}; + var output_i: usize = 0; for (opts.entry_points) |entry_point, i| { + var _log = logger.Log.init(allocator); + var __log = &_log; var paths = [_]string{ cwd, entry_point }; const absolutePath = try std.fs.path.resolve(alloc.dynamic, &paths); @@ -88,6 +99,13 @@ pub const Transformer = struct { const stat = try file.stat(); const code = try file.readToEndAlloc(alloc.dynamic, stat.size); + defer { + if (_log.msgs.items.len == 0) { + allocator.free(code); + } + alloc.dynamic.free(absolutePath); + _log.appendTo(log) catch {}; + } const _file = fs.File{ .path = fs.Path.init(entry_point), .contents = code }; var source = try logger.Source.initFile(_file, alloc.dynamic); var loader: options.Loader = undefined; @@ -100,10 +118,16 @@ pub const Transformer = struct { ) orelse continue; } + jsx.parse = loader.isJSX(); + const parser_opts = js_parser.Parser.Options.init(jsx, loader); var _source = &source; - const res = _transform(allocator, log, parser_opts, loader, define, _source) catch continue; - try output_files.append(options.OutputFile{ .path = absolutePath, .contents = res.js }); + const res = _transform(allocator, allocator, __log, parser_opts, loader, define, _source) catch continue; + + const relative_path = try std.fs.path.relative(allocator, cwd, absolutePath); + var out_parts = [_]string{ output_dir, relative_path }; + const out_path = try std.fs.path.join(allocator, &out_parts); + try output_files.append(options.OutputFile{ .path = out_path, .contents = res.js }); } return try options.TransformResult.init(output_files.toOwnedSlice(), log, allocator); @@ -111,6 +135,7 @@ pub const Transformer = struct { pub fn _transform( allocator: *std.mem.Allocator, + result_allocator: *std.mem.Allocator, log: *logger.Log, opts: js_parser.Parser.Options, loader: options.Loader, @@ -121,8 +146,8 @@ pub const Transformer = struct { switch (loader) { .json => { - var expr = try json_parser.ParseJSON(source, log, alloc.dynamic); - var stmt = js_ast.Stmt.alloc(alloc.dynamic, js_ast.S.ExportDefault{ + var expr = try json_parser.ParseJSON(source, log, allocator); + var stmt = js_ast.Stmt.alloc(allocator, js_ast.S.ExportDefault{ .value = js_ast.StmtOrExpr{ .expr = expr }, .default_name = js_ast.LocRef{ .loc = logger.Loc{}, .ref = Ref{} }, }, logger.Loc{ .start = 0 }); @@ -147,7 +172,7 @@ pub const Transformer = struct { var symbols: [][]js_ast.Symbol = &([_][]js_ast.Symbol{ast.symbols}); return try js_printer.printAst( - alloc.dynamic, + result_allocator, ast, js_ast.Symbol.Map.initList(symbols), source, diff --git a/src/cli.zig b/src/cli.zig index a650aad75..19537e515 100644 --- a/src/cli.zig +++ b/src/cli.zig @@ -150,9 +150,9 @@ pub const Cli = struct { var loader_keys = loader_tuple.keys; var loader_values = loader_tuple.values; var entry_points = args.positionals(); - var write = entry_points.len > 1; var inject = args.options("--inject"); var output_dir = args.option("--outdir"); + var write = entry_points.len > 1 or output_dir != null; if (write and output_dir == null) { var _paths = [_]string{ cwd, "out" }; output_dir = try std.fs.path.resolve(allocator, &_paths); @@ -276,6 +276,7 @@ pub const Cli = struct { } pub fn startTransform(allocator: *std.mem.Allocator, args: Api.TransformOptions, log: *logger.Log) anyerror!void {} pub fn start(allocator: *std.mem.Allocator, stdout: anytype, stderr: anytype, comptime MainPanicHandler: type) anyerror!void { + const start_time = std.time.nanoTimestamp(); var log = logger.Log.init(alloc.dynamic); var panicker = MainPanicHandler.init(&log); MainPanicHandler.Singleton = &panicker; @@ -298,9 +299,73 @@ pub const Cli = struct { ); }, } + var did_write = false; - for (result.output_files) |file| { - try stdout.writer().writeAll(file.contents); + var writer = stdout.writer(); + + if (args.write) |write| { + if (write) { + did_write = true; + var root_dir = try std.fs.openDirAbsolute(args.absolute_working_dir.?, std.fs.Dir.OpenDirOptions{}); + defer root_dir.close(); + for (result.output_files) |f| { + try root_dir.makePath(std.fs.path.dirname(f.path) orelse unreachable); + + var _handle = try std.fs.createFileAbsolute(f.path, std.fs.File.CreateFlags{ + .truncate = true, + }); + try _handle.seekTo(0); + + defer _handle.close(); + + try _handle.writeAll(f.contents); + } + + var max_path_len: usize = 0; + var max_padded_size: usize = 0; + for (result.output_files) |file| { + max_path_len = std.math.max(file.path.len, max_path_len); + } + + _ = try writer.write("\n"); + for (result.output_files) |file| { + const padding_count = 2 + (max_path_len - file.path.len); + + try writer.writeByteNTimes(' ', 2); + try writer.writeAll(file.path); + try writer.writeByteNTimes(' ', padding_count); + const size = @intToFloat(f64, file.contents.len) / 1000.0; + try std.fmt.formatFloatDecimal(size, .{ .precision = 2 }, writer); + try writer.writeAll(" KB\n"); + } + } + } + + if (!did_write) { + for (result.output_files) |file, i| { + try writer.writeAll(file.contents); + if (i > 0) { + _ = try writer.write("\n\n"); + } + } + } + + var err_writer = stderr.writer(); + for (result.errors) |err| { + try err.writeFormat(err_writer); + _ = try err_writer.write("\n"); + } + + for (result.warnings) |err| { + try err.writeFormat(err_writer); + _ = try err_writer.write("\n"); + } + + const duration = std.time.nanoTimestamp() - start_time; + + if (did_write and duration < @as(i128, @as(i128, std.time.ns_per_s) * @as(i128, 2))) { + var elapsed = @divFloor(duration, @as(i128, std.time.ns_per_ms)); + try writer.print("\nCompleted in {d}ms", .{elapsed}); } } }; diff --git a/src/logger.zig b/src/logger.zig index cbf86b63c..77fad57c0 100644 --- a/src/logger.zig +++ b/src/logger.zig @@ -133,7 +133,23 @@ pub const Msg = struct { } msg.notes = null; } - pub fn doFormat(msg: *const Msg, to: anytype, formatterFunc: @TypeOf(std.fmt.format)) !void { + + pub fn writeFormat( + msg: *const Msg, + to: anytype, + ) !void { + try std.fmt.format(to, "\n\n{s}: {s}\n{s}\n{s}:{}:{} {d}", .{ + msg.kind.string(), + msg.data.text, + msg.data.location.?.line_text, + msg.data.location.?.file, + msg.data.location.?.line, + msg.data.location.?.column, + msg.data.location.?.offset, + }); + } + + pub fn doFormat(msg: *const Msg, to: anytype, formatterFunc: anytype) !void { try formatterFunc(to, "\n\n{s}: {s}\n{s}\n{s}:{}:{} {d}", .{ msg.kind.string(), msg.data.text, @@ -204,7 +220,7 @@ pub const Log = struct { } pub fn appendTo(self: *Log, other: *Log) !void { - other.msgs.appendSlice(self.msgs.items); + try other.msgs.appendSlice(self.msgs.items); other.warnings += self.warnings; other.errors += self.errors; self.msgs.deinit(); @@ -295,7 +311,7 @@ pub const Log = struct { } pub fn addRangeDebugWithNotes(log: *Log, source: ?*Source, r: Range, text: string, notes: []Data) !void { - log.errors += 1; + // log.de += 1; try log.addMsg(Msg{ .kind = Kind.debug, .data = rangeData(source, r, text), diff --git a/src/options.zig b/src/options.zig index c95486a5c..59cb11573 100644 --- a/src/options.zig +++ b/src/options.zig @@ -362,21 +362,15 @@ pub const TransformResult = struct { log: *logger.Log, allocator: *std.mem.Allocator, ) !TransformResult { - var errors = try allocator.alloc(logger.Msg, log.errors); - var warnings = try allocator.alloc(logger.Msg, log.warnings); - var error_i: usize = 0; - var warning_i: usize = 0; + var errors = try std.ArrayList(logger.Msg).initCapacity(allocator, log.errors); + var warnings = try std.ArrayList(logger.Msg).initCapacity(allocator, log.warnings); for (log.msgs.items) |msg| { switch (msg.kind) { logger.Kind.err => { - std.debug.assert(warnings.len > warning_i); - errors[error_i] = msg; - error_i += 1; + errors.append(msg) catch unreachable; }, logger.Kind.warn => { - std.debug.assert(warnings.len > warning_i); - warnings[warning_i] = msg; - warning_i += 1; + warnings.append(msg) catch unreachable; }, else => {}, } @@ -384,8 +378,8 @@ pub const TransformResult = struct { return TransformResult{ .output_files = output_files, - .errors = errors, - .warnings = warnings, + .errors = errors.toOwnedSlice(), + .warnings = warnings.toOwnedSlice(), }; } }; |