-
Notifications
You must be signed in to change notification settings - Fork 3k
/
Copy pathtranspiler.zig
1611 lines (1436 loc) · 66.8 KB
/
transpiler.zig
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
const bun = @import("bun");
const string = bun.string;
const Output = bun.Output;
const Global = bun.Global;
const Environment = bun.Environment;
const strings = bun.strings;
const MutableString = bun.MutableString;
const stringZ = bun.stringZ;
const default_allocator = bun.default_allocator;
const StoredFileDescriptorType = bun.StoredFileDescriptorType;
const FeatureFlags = bun.FeatureFlags;
const C = bun.C;
const std = @import("std");
const lex = bun.js_lexer;
const logger = bun.logger;
pub const options = @import("options.zig");
const js_parser = bun.js_parser;
const JSON = bun.JSON;
const js_printer = bun.js_printer;
const js_ast = bun.JSAst;
const linker = @import("linker.zig");
const Ref = @import("ast/base.zig").Ref;
const Define = @import("defines.zig").Define;
const DebugOptions = @import("./cli.zig").Command.DebugOptions;
const ThreadPoolLib = @import("./thread_pool.zig");
const Fs = @import("fs.zig");
const schema = @import("api/schema.zig");
const Api = schema.Api;
const _resolver = @import("./resolver/resolver.zig");
const sync = @import("sync.zig");
const ImportRecord = @import("./import_record.zig").ImportRecord;
const allocators = @import("./allocators.zig");
const MimeType = @import("./http/mime_type.zig");
const resolve_path = @import("./resolver/resolve_path.zig");
const runtime = @import("./runtime.zig");
const PackageJSON = @import("./resolver/package_json.zig").PackageJSON;
const MacroRemap = @import("./resolver/package_json.zig").MacroMap;
const DebugLogs = _resolver.DebugLogs;
const Router = @import("./router.zig");
const isPackagePath = _resolver.isPackagePath;
const Css = @import("css_scanner.zig");
const DotEnv = @import("./env_loader.zig");
const Lock = bun.Mutex;
const NodeFallbackModules = @import("./node_fallbacks.zig");
const CacheEntry = @import("./cache.zig").FsCacheEntry;
const Analytics = @import("./analytics/analytics_thread.zig");
const URL = @import("./url.zig").URL;
const Linker = linker.Linker;
const Resolver = _resolver.Resolver;
const TOML = @import("./toml/toml_parser.zig").TOML;
const JSC = bun.JSC;
const PackageManager = @import("./install/install.zig").PackageManager;
const DataURL = @import("./resolver/data_url.zig").DataURL;
pub const MacroJSValueType = JSC.JSValue;
const default_macro_js_value = JSC.JSValue.zero;
pub const EntryPoints = @import("./bundler/entry_points.zig");
const SystemTimer = @import("./system_timer.zig").Timer;
pub const ParseResult = struct {
source: logger.Source,
loader: options.Loader,
ast: js_ast.Ast,
already_bundled: AlreadyBundled = .none,
input_fd: ?StoredFileDescriptorType = null,
empty: bool = false,
pending_imports: _resolver.PendingResolution.List = .{},
runtime_transpiler_cache: ?*bun.JSC.RuntimeTranspilerCache = null,
pub const AlreadyBundled = union(enum) {
none: void,
source_code: void,
source_code_cjs: void,
bytecode: []u8,
bytecode_cjs: []u8,
pub fn bytecodeSlice(this: AlreadyBundled) []u8 {
return switch (this) {
inline .bytecode, .bytecode_cjs => |slice| slice,
else => &.{},
};
}
pub fn isBytecode(this: AlreadyBundled) bool {
return this == .bytecode or this == .bytecode_cjs;
}
pub fn isCommonJS(this: AlreadyBundled) bool {
return this == .source_code_cjs or this == .bytecode_cjs;
}
};
pub fn isPendingImport(this: *const ParseResult, id: u32) bool {
const import_record_ids = this.pending_imports.items(.import_record_id);
return std.mem.indexOfScalar(u32, import_record_ids, id) != null;
}
/// **DO NOT CALL THIS UNDER NORMAL CIRCUMSTANCES**
/// Normally, we allocate each AST in an arena and free all at once
/// So this function only should be used when we globally allocate an AST
pub fn deinit(this: *ParseResult) void {
_resolver.PendingResolution.deinitListItems(this.pending_imports, bun.default_allocator);
this.pending_imports.deinit(bun.default_allocator);
this.ast.deinit();
bun.default_allocator.free(@constCast(this.source.contents));
}
};
pub const PluginRunner = struct {
global_object: *JSC.JSGlobalObject,
allocator: std.mem.Allocator,
pub fn extractNamespace(specifier: string) string {
const colon = strings.indexOfChar(specifier, ':') orelse return "";
if (Environment.isWindows and
colon == 1 and
specifier.len > 3 and
bun.path.isSepAny(specifier[2]) and
((specifier[0] > 'a' and specifier[0] < 'z') or (specifier[0] > 'A' and specifier[0] < 'Z')))
return "";
return specifier[0..colon];
}
pub fn couldBePlugin(specifier: string) bool {
if (strings.lastIndexOfChar(specifier, '.')) |last_dor| {
const ext = specifier[last_dor + 1 ..];
// '.' followed by either a letter or a non-ascii character
// maybe there are non-ascii file extensions?
// we mostly want to cheaply rule out "../" and ".." and "./"
if (ext.len > 0 and ((ext[0] >= 'a' and ext[0] <= 'z') or (ext[0] >= 'A' and ext[0] <= 'Z') or ext[0] > 127))
return true;
}
return (!std.fs.path.isAbsolute(specifier) and strings.containsChar(specifier, ':'));
}
pub fn onResolve(
this: *PluginRunner,
specifier: []const u8,
importer: []const u8,
log: *logger.Log,
loc: logger.Loc,
target: JSC.JSGlobalObject.BunPluginTarget,
) bun.JSError!?Fs.Path {
var global = this.global_object;
const namespace_slice = extractNamespace(specifier);
const namespace = if (namespace_slice.len > 0 and !strings.eqlComptime(namespace_slice, "file"))
bun.String.init(namespace_slice)
else
bun.String.empty;
const on_resolve_plugin = global.runOnResolvePlugins(
namespace,
bun.String.init(specifier).substring(if (namespace.length() > 0) namespace.length() + 1 else 0),
bun.String.init(importer),
target,
) orelse return null;
const path_value = try on_resolve_plugin.get(global, "path") orelse return null;
if (path_value.isEmptyOrUndefinedOrNull()) return null;
if (!path_value.isString()) {
log.addError(null, loc, "Expected \"path\" to be a string") catch unreachable;
return null;
}
const file_path = try path_value.toBunString(global);
defer file_path.deref();
if (file_path.length() == 0) {
log.addError(
null,
loc,
"Expected \"path\" to be a non-empty string in onResolve plugin",
) catch unreachable;
return null;
} else if
// TODO: validate this better
(file_path.eqlComptime(".") or
file_path.eqlComptime("..") or
file_path.eqlComptime("...") or
file_path.eqlComptime(" "))
{
log.addError(
null,
loc,
"Invalid file path from onResolve plugin",
) catch unreachable;
return null;
}
var static_namespace = true;
const user_namespace: bun.String = brk: {
if (try on_resolve_plugin.get(global, "namespace")) |namespace_value| {
if (!namespace_value.isString()) {
log.addError(null, loc, "Expected \"namespace\" to be a string") catch unreachable;
return null;
}
const namespace_str = try namespace_value.toBunString(global);
if (namespace_str.length() == 0) {
namespace_str.deref();
break :brk bun.String.init("file");
}
if (namespace_str.eqlComptime("file")) {
namespace_str.deref();
break :brk bun.String.init("file");
}
if (namespace_str.eqlComptime("bun")) {
namespace_str.deref();
break :brk bun.String.init("bun");
}
if (namespace_str.eqlComptime("node")) {
namespace_str.deref();
break :brk bun.String.init("node");
}
static_namespace = false;
break :brk namespace_str;
}
break :brk bun.String.init("file");
};
defer user_namespace.deref();
if (static_namespace) {
return Fs.Path.initWithNamespace(
std.fmt.allocPrint(this.allocator, "{any}", .{file_path}) catch unreachable,
user_namespace.byteSlice(),
);
} else {
return Fs.Path.initWithNamespace(
std.fmt.allocPrint(this.allocator, "{any}", .{file_path}) catch unreachable,
std.fmt.allocPrint(this.allocator, "{any}", .{user_namespace}) catch unreachable,
);
}
}
pub fn onResolveJSC(this: *const PluginRunner, namespace: bun.String, specifier: bun.String, importer: bun.String, target: JSC.JSGlobalObject.BunPluginTarget) bun.JSError!?JSC.ErrorableString {
var global = this.global_object;
const on_resolve_plugin = global.runOnResolvePlugins(
if (namespace.length() > 0 and !namespace.eqlComptime("file"))
namespace
else
bun.String.static(""),
specifier,
importer,
target,
) orelse return null;
if (!on_resolve_plugin.isObject()) return null;
const path_value = try on_resolve_plugin.get(global, "path") orelse return null;
if (path_value.isEmptyOrUndefinedOrNull()) return null;
if (!path_value.isString()) {
return JSC.ErrorableString.err(
error.JSErrorObject,
bun.String.static("Expected \"path\" to be a string in onResolve plugin").toErrorInstance(this.global_object).asVoid(),
);
}
const file_path = try path_value.toBunString(global);
if (file_path.length() == 0) {
return JSC.ErrorableString.err(
error.JSErrorObject,
bun.String.static("Expected \"path\" to be a non-empty string in onResolve plugin").toErrorInstance(this.global_object).asVoid(),
);
} else if
// TODO: validate this better
(file_path.eqlComptime(".") or
file_path.eqlComptime("..") or
file_path.eqlComptime("...") or
file_path.eqlComptime(" "))
{
return JSC.ErrorableString.err(
error.JSErrorObject,
bun.String.static("\"path\" is invalid in onResolve plugin").toErrorInstance(this.global_object).asVoid(),
);
}
var static_namespace = true;
const user_namespace: bun.String = brk: {
if (try on_resolve_plugin.get(global, "namespace")) |namespace_value| {
if (!namespace_value.isString()) {
return JSC.ErrorableString.err(
error.JSErrorObject,
bun.String.static("Expected \"namespace\" to be a string").toErrorInstance(this.global_object).asVoid(),
);
}
const namespace_str = try namespace_value.toBunString(global);
if (namespace_str.length() == 0) {
break :brk bun.String.static("file");
}
if (namespace_str.eqlComptime("file")) {
defer namespace_str.deref();
break :brk bun.String.static("file");
}
if (namespace_str.eqlComptime("bun")) {
defer namespace_str.deref();
break :brk bun.String.static("bun");
}
if (namespace_str.eqlComptime("node")) {
defer namespace_str.deref();
break :brk bun.String.static("node");
}
static_namespace = false;
break :brk namespace_str;
}
break :brk bun.String.static("file");
};
defer user_namespace.deref();
// Our super slow way of cloning the string into memory owned by JSC
const combined_string = std.fmt.allocPrint(this.allocator, "{any}:{any}", .{ user_namespace, file_path }) catch unreachable;
var out_ = bun.String.init(combined_string);
const jsval = out_.toJS(this.global_object);
const out = jsval.toBunString(this.global_object) catch @panic("unreachable");
this.allocator.free(combined_string);
return JSC.ErrorableString.ok(out);
}
};
/// This structure was the JavaScript transpiler before bundle_v2 was written. It now
/// acts mostly as a configuration object, but it also contains stateful logic around
/// logging errors (.log) and module resolution (.resolve_queue)
///
/// This object is not exclusive to bundle_v2/Bun.build, one of these is stored
/// on every VM so that the options can be used for transpilation.
pub const Transpiler = struct {
options: options.BundleOptions,
log: *logger.Log,
allocator: std.mem.Allocator,
result: options.TransformResult,
resolver: Resolver,
fs: *Fs.FileSystem,
output_files: std.ArrayList(options.OutputFile),
resolve_results: *ResolveResults,
resolve_queue: ResolveQueue,
elapsed: u64 = 0,
needs_runtime: bool = false,
router: ?Router = null,
source_map: options.SourceMapOption = .none,
linker: Linker,
timer: SystemTimer,
env: *DotEnv.Loader,
macro_context: ?js_ast.Macro.MacroContext = null,
pub const isCacheEnabled = false;
pub inline fn getPackageManager(this: *Transpiler) *PackageManager {
return this.resolver.getPackageManager();
}
pub fn setLog(this: *Transpiler, log: *logger.Log) void {
this.log = log;
this.linker.log = log;
this.resolver.log = log;
}
// TODO: remove this method. it does not make sense
pub fn setAllocator(this: *Transpiler, allocator: std.mem.Allocator) void {
this.allocator = allocator;
this.linker.allocator = allocator;
this.resolver.allocator = allocator;
}
fn _resolveEntryPoint(transpiler: *Transpiler, entry_point: string) !_resolver.Result {
return transpiler.resolver.resolveWithFramework(transpiler.fs.top_level_dir, entry_point, .entry_point_build) catch |err| {
// Relative entry points that were not resolved to a node_modules package are
// interpreted as relative to the current working directory.
if (!std.fs.path.isAbsolute(entry_point) and
!(strings.hasPrefix(entry_point, "./") or strings.hasPrefix(entry_point, ".\\")))
{
brk: {
return transpiler.resolver.resolve(
transpiler.fs.top_level_dir,
try strings.append(transpiler.allocator, "./", entry_point),
.entry_point_build,
) catch {
// return the original error
break :brk;
};
}
}
return err;
};
}
pub fn resolveEntryPoint(transpiler: *Transpiler, entry_point: string) !_resolver.Result {
return _resolveEntryPoint(transpiler, entry_point) catch |err| {
var cache_bust_buf: bun.PathBuffer = undefined;
// Bust directory cache and try again
const buster_name = name: {
if (std.fs.path.isAbsolute(entry_point)) {
if (std.fs.path.dirname(entry_point)) |dir| {
// Normalized with trailing slash
break :name bun.strings.normalizeSlashesOnly(&cache_bust_buf, dir, std.fs.path.sep);
}
}
var parts = [_]string{
entry_point,
bun.pathLiteral(".."),
};
break :name bun.path.joinAbsStringBufZ(
transpiler.fs.top_level_dir,
&cache_bust_buf,
&parts,
.auto,
);
};
// Only re-query if we previously had something cached.
if (transpiler.resolver.bustDirCache(bun.strings.withoutTrailingSlashWindowsPath(buster_name))) {
if (_resolveEntryPoint(transpiler, entry_point)) |result|
return result
else |_| {
// ignore this error, we will print the original error
}
}
transpiler.log.addErrorFmt(null, logger.Loc.Empty, transpiler.allocator, "{s} resolving \"{s}\" (entry point)", .{ @errorName(err), entry_point }) catch bun.outOfMemory();
return err;
};
}
pub fn init(
allocator: std.mem.Allocator,
log: *logger.Log,
opts: Api.TransformOptions,
env_loader_: ?*DotEnv.Loader,
) !Transpiler {
js_ast.Expr.Data.Store.create();
js_ast.Stmt.Data.Store.create();
const fs = try Fs.FileSystem.init(opts.absolute_working_dir);
const bundle_options = try options.BundleOptions.fromApi(
allocator,
fs,
log,
opts,
);
var env_loader: *DotEnv.Loader = env_loader_ orelse DotEnv.instance orelse brk: {
const map = try allocator.create(DotEnv.Map);
map.* = DotEnv.Map.init(allocator);
const loader = try allocator.create(DotEnv.Loader);
loader.* = DotEnv.Loader.init(map, allocator);
break :brk loader;
};
if (DotEnv.instance == null) {
DotEnv.instance = env_loader;
}
// hide elapsed time when loglevel is warn or error
env_loader.quiet = !log.level.atLeast(.info);
// var pool = try allocator.create(ThreadPool);
// try pool.init(ThreadPool.InitConfig{
// .allocator = allocator,
// });
const resolve_results = try allocator.create(ResolveResults);
resolve_results.* = ResolveResults.init(allocator);
return Transpiler{
.options = bundle_options,
.fs = fs,
.allocator = allocator,
.timer = SystemTimer.start() catch @panic("Timer fail"),
.resolver = Resolver.init1(allocator, log, fs, bundle_options),
.log = log,
// .thread_pool = pool,
.linker = undefined,
.result = options.TransformResult{ .outbase = bundle_options.output_dir },
.resolve_results = resolve_results,
.resolve_queue = ResolveQueue.init(allocator),
.output_files = std.ArrayList(options.OutputFile).init(allocator),
.env = env_loader,
};
}
pub fn configureLinkerWithAutoJSX(transpiler: *Transpiler, auto_jsx: bool) void {
transpiler.linker = Linker.init(
transpiler.allocator,
transpiler.log,
&transpiler.resolve_queue,
&transpiler.options,
&transpiler.resolver,
transpiler.resolve_results,
transpiler.fs,
);
if (auto_jsx) {
// Most of the time, this will already be cached
if (transpiler.resolver.readDirInfo(transpiler.fs.top_level_dir) catch null) |root_dir| {
if (root_dir.tsconfig_json) |tsconfig| {
// If we don't explicitly pass JSX, try to get it from the root tsconfig
if (transpiler.options.transform_options.jsx == null) {
transpiler.options.jsx = tsconfig.jsx;
}
transpiler.options.emit_decorator_metadata = tsconfig.emit_decorator_metadata;
}
}
}
}
pub fn configureLinker(transpiler: *Transpiler) void {
transpiler.configureLinkerWithAutoJSX(true);
}
pub fn runEnvLoader(this: *Transpiler, skip_default_env: bool) !void {
switch (this.options.env.behavior) {
.prefix, .load_all, .load_all_without_inlining => {
// Step 1. Load the project root.
const dir_info = this.resolver.readDirInfo(this.fs.top_level_dir) catch return orelse return;
if (dir_info.tsconfig_json) |tsconfig| {
this.options.jsx = tsconfig.mergeJSX(this.options.jsx);
}
const dir = dir_info.getEntries(this.resolver.generation) orelse return;
// Process always has highest priority.
const was_production = this.options.production;
this.env.loadProcess();
const has_production_env = this.env.isProduction();
if (!was_production and has_production_env) {
this.options.setProduction(true);
this.resolver.opts.setProduction(true);
}
if (this.options.isTest() or this.env.isTest()) {
try this.env.load(dir, this.options.env.files, .@"test", skip_default_env);
} else if (this.options.production) {
try this.env.load(dir, this.options.env.files, .production, skip_default_env);
} else {
try this.env.load(dir, this.options.env.files, .development, skip_default_env);
}
},
.disable => {
this.env.loadProcess();
if (this.env.isProduction()) {
this.options.setProduction(true);
this.resolver.opts.setProduction(true);
}
},
else => {},
}
if (strings.eqlComptime(this.env.get("BUN_DISABLE_TRANSPILER") orelse "0", "1")) {
this.options.disable_transpilation = true;
}
}
// This must be run after a framework is configured, if a framework is enabled
pub fn configureDefines(this: *Transpiler) !void {
if (this.options.defines_loaded) {
return;
}
if (this.options.target == .bun_macro) {
this.options.env.behavior = .prefix;
this.options.env.prefix = "BUN_";
}
try this.runEnvLoader(false);
var is_production = this.env.isProduction();
js_ast.Expr.Data.Store.create();
js_ast.Stmt.Data.Store.create();
defer js_ast.Expr.Data.Store.reset();
defer js_ast.Stmt.Data.Store.reset();
try this.options.loadDefines(this.allocator, this.env, &this.options.env);
var is_development = false;
if (this.options.define.dots.get("NODE_ENV")) |NODE_ENV| {
if (NODE_ENV.len > 0 and NODE_ENV[0].data.value == .e_string) {
if (NODE_ENV[0].data.value.e_string.eqlComptime("production")) {
is_production = true;
} else if (NODE_ENV[0].data.value.e_string.eqlComptime("development")) {
is_development = true;
}
}
}
if (is_development) {
this.options.setProduction(false);
this.resolver.opts.setProduction(false);
this.options.force_node_env = .development;
this.resolver.opts.force_node_env = .development;
} else if (is_production) {
this.options.setProduction(true);
this.resolver.opts.setProduction(true);
}
}
pub fn resetStore(_: *const Transpiler) void {
js_ast.Expr.Data.Store.reset();
js_ast.Stmt.Data.Store.reset();
}
pub noinline fn dumpEnvironmentVariables(transpiler: *const Transpiler) void {
@branchHint(.cold);
const opts = std.json.StringifyOptions{
.whitespace = .indent_2,
};
Output.flush();
std.json.stringify(transpiler.env.map.*, opts, Output.writer()) catch unreachable;
Output.flush();
}
pub const BuildResolveResultPair = struct {
written: usize,
input_fd: ?StoredFileDescriptorType,
empty: bool = false,
};
fn buildWithResolveResultEager(
transpiler: *Transpiler,
resolve_result: _resolver.Result,
comptime import_path_format: options.BundleOptions.ImportPathFormat,
comptime Outstream: type,
outstream: Outstream,
client_entry_point_: ?*EntryPoints.ClientEntryPoint,
) !?options.OutputFile {
_ = outstream;
if (resolve_result.is_external) {
return null;
}
var file_path = (resolve_result.pathConst() orelse return null).*;
// Step 1. Parse & scan
const loader = transpiler.options.loader(file_path.name.ext);
if (client_entry_point_) |client_entry_point| {
file_path = client_entry_point.source.path;
}
file_path.pretty = Linker.relative_paths_list.append(string, transpiler.fs.relativeTo(file_path.text)) catch unreachable;
var output_file = options.OutputFile{
.src_path = file_path,
.loader = loader,
.value = undefined,
.side = null,
.entry_point_index = null,
.output_kind = .chunk,
};
switch (loader) {
.jsx, .tsx, .js, .ts, .json, .jsonc, .toml, .text => {
var result = transpiler.parse(
ParseOptions{
.allocator = transpiler.allocator,
.path = file_path,
.loader = loader,
.dirname_fd = resolve_result.dirname_fd,
.file_descriptor = null,
.file_hash = null,
.macro_remappings = transpiler.options.macro_remap,
.jsx = resolve_result.jsx,
.emit_decorator_metadata = resolve_result.emit_decorator_metadata,
},
client_entry_point_,
) orelse {
return null;
};
if (!transpiler.options.transform_only) {
if (!transpiler.options.target.isBun())
try transpiler.linker.link(
file_path,
&result,
transpiler.options.origin,
import_path_format,
false,
false,
)
else
try transpiler.linker.link(
file_path,
&result,
transpiler.options.origin,
import_path_format,
false,
true,
);
}
const buffer_writer = js_printer.BufferWriter.init(transpiler.allocator);
var writer = js_printer.BufferPrinter.init(buffer_writer);
output_file.size = switch (transpiler.options.target) {
.browser, .node => try transpiler.print(
result,
*js_printer.BufferPrinter,
&writer,
.esm,
),
.bun, .bun_macro, .bake_server_components_ssr => try transpiler.print(
result,
*js_printer.BufferPrinter,
&writer,
.esm_ascii,
),
};
output_file.value = .{
.buffer = .{
.allocator = transpiler.allocator,
.bytes = writer.ctx.written,
},
};
},
.dataurl, .base64 => {
Output.panic("TODO: dataurl, base64", .{}); // TODO
},
.css => {
const alloc = transpiler.allocator;
const entry = transpiler.resolver.caches.fs.readFileWithAllocator(
transpiler.allocator,
transpiler.fs,
file_path.text,
resolve_result.dirname_fd,
false,
null,
) catch |err| {
transpiler.log.addErrorFmt(null, logger.Loc.Empty, transpiler.allocator, "{s} reading \"{s}\"", .{ @errorName(err), file_path.pretty }) catch {};
return null;
};
var opts = bun.css.ParserOptions.default(alloc, transpiler.log);
const css_module_suffix = ".module.css";
const enable_css_modules = file_path.text.len > css_module_suffix.len and
strings.eqlComptime(file_path.text[file_path.text.len - css_module_suffix.len ..], css_module_suffix);
if (enable_css_modules) {
opts.filename = bun.path.basename(file_path.text);
opts.css_modules = bun.css.CssModuleConfig{};
}
var sheet, var extra = switch (bun.css.StyleSheet(bun.css.DefaultAtRule).parse(
alloc,
entry.contents,
opts,
null,
// TODO: DO WE EVEN HAVE SOURCE INDEX IN THIS TRANSPILER.ZIG file??
bun.bundle_v2.Index.invalid,
)) {
.result => |v| v,
.err => |e| {
transpiler.log.addErrorFmt(null, logger.Loc.Empty, transpiler.allocator, "{} parsing", .{e}) catch unreachable;
return null;
},
};
if (sheet.minify(alloc, bun.css.MinifyOptions.default(), &extra).asErr()) |e| {
transpiler.log.addErrorFmt(null, logger.Loc.Empty, transpiler.allocator, "{} while minifying", .{e.kind}) catch bun.outOfMemory();
return null;
}
const symbols = bun.JSAst.Symbol.Map{};
const result = switch (sheet.toCss(
alloc,
bun.css.PrinterOptions{
.targets = bun.css.Targets.forBundlerTarget(transpiler.options.target),
.minify = transpiler.options.minify_whitespace,
},
null,
null,
&symbols,
)) {
.result => |v| v,
.err => |e| {
transpiler.log.addErrorFmt(null, logger.Loc.Empty, transpiler.allocator, "{} while printing", .{e}) catch bun.outOfMemory();
return null;
},
};
output_file.value = .{ .buffer = .{ .allocator = alloc, .bytes = result.code } };
},
.html, .bunsh, .sqlite_embedded, .sqlite, .wasm, .file, .napi => {
const hashed_name = try transpiler.linker.getHashedFilename(file_path, null);
var pathname = try transpiler.allocator.alloc(u8, hashed_name.len + file_path.name.ext.len);
bun.copy(u8, pathname, hashed_name);
bun.copy(u8, pathname[hashed_name.len..], file_path.name.ext);
output_file.value = .{
.copy = options.OutputFile.FileOperation{
.pathname = pathname,
.dir = if (transpiler.options.output_dir_handle) |output_handle|
.fromStdDir(output_handle)
else
.invalid,
.is_outdir = true,
},
};
},
}
return output_file;
}
fn printWithSourceMapMaybe(
transpiler: *Transpiler,
ast: js_ast.Ast,
source: *const logger.Source,
comptime Writer: type,
writer: Writer,
comptime format: js_printer.Format,
comptime enable_source_map: bool,
source_map_context: ?js_printer.SourceMapHandler,
runtime_transpiler_cache: ?*bun.JSC.RuntimeTranspilerCache,
) !usize {
const tracer = if (enable_source_map)
bun.perf.trace("JSPrinter.printWithSourceMap")
else
bun.perf.trace("JSPrinter.print");
defer tracer.end();
const symbols = js_ast.Symbol.NestedList.init(&[_]js_ast.Symbol.List{ast.symbols});
return switch (format) {
.cjs => try js_printer.printCommonJS(
Writer,
writer,
ast,
js_ast.Symbol.Map.initList(symbols),
source,
false,
.{
.bundling = false,
.runtime_imports = ast.runtime_imports,
.require_ref = ast.require_ref,
.css_import_behavior = transpiler.options.cssImportBehavior(),
.source_map_handler = source_map_context,
.minify_whitespace = transpiler.options.minify_whitespace,
.minify_syntax = transpiler.options.minify_syntax,
.minify_identifiers = transpiler.options.minify_identifiers,
.transform_only = transpiler.options.transform_only,
.runtime_transpiler_cache = runtime_transpiler_cache,
.print_dce_annotations = transpiler.options.emit_dce_annotations,
.hmr_ref = ast.wrapper_ref,
},
enable_source_map,
),
.esm => try js_printer.printAst(
Writer,
writer,
ast,
js_ast.Symbol.Map.initList(symbols),
source,
false,
.{
.bundling = false,
.runtime_imports = ast.runtime_imports,
.require_ref = ast.require_ref,
.source_map_handler = source_map_context,
.css_import_behavior = transpiler.options.cssImportBehavior(),
.minify_whitespace = transpiler.options.minify_whitespace,
.minify_syntax = transpiler.options.minify_syntax,
.minify_identifiers = transpiler.options.minify_identifiers,
.transform_only = transpiler.options.transform_only,
.import_meta_ref = ast.import_meta_ref,
.runtime_transpiler_cache = runtime_transpiler_cache,
.print_dce_annotations = transpiler.options.emit_dce_annotations,
.hmr_ref = ast.wrapper_ref,
.mangled_props = null,
},
enable_source_map,
),
.esm_ascii => switch (transpiler.options.target.isBun()) {
inline else => |is_bun| try js_printer.printAst(
Writer,
writer,
ast,
js_ast.Symbol.Map.initList(symbols),
source,
is_bun,
.{
.bundling = false,
.runtime_imports = ast.runtime_imports,
.require_ref = ast.require_ref,
.css_import_behavior = transpiler.options.cssImportBehavior(),
.source_map_handler = source_map_context,
.minify_whitespace = transpiler.options.minify_whitespace,
.minify_syntax = transpiler.options.minify_syntax,
.minify_identifiers = transpiler.options.minify_identifiers,
.transform_only = transpiler.options.transform_only,
.module_type = if (is_bun and transpiler.options.transform_only)
// this is for when using `bun build --no-bundle`
// it should copy what was passed for the cli
transpiler.options.output_format
else if (ast.exports_kind == .cjs)
.cjs
else
.esm,
.inline_require_and_import_errors = false,
.import_meta_ref = ast.import_meta_ref,
.runtime_transpiler_cache = runtime_transpiler_cache,
.target = transpiler.options.target,
.print_dce_annotations = transpiler.options.emit_dce_annotations,
.hmr_ref = ast.wrapper_ref,
.mangled_props = null,
},
enable_source_map,
),
},
else => unreachable,
};
}
pub fn print(
transpiler: *Transpiler,
result: ParseResult,
comptime Writer: type,
writer: Writer,
comptime format: js_printer.Format,
) !usize {
return transpiler.printWithSourceMapMaybe(
result.ast,
&result.source,
Writer,
writer,
format,
false,
null,
null,
);
}
pub fn printWithSourceMap(
transpiler: *Transpiler,
result: ParseResult,
comptime Writer: type,
writer: Writer,
comptime format: js_printer.Format,
handler: js_printer.SourceMapHandler,
) !usize {
if (bun.getRuntimeFeatureFlag("BUN_FEATURE_FLAG_DISABLE_SOURCE_MAPS")) {
return transpiler.printWithSourceMapMaybe(
result.ast,
&result.source,
Writer,
writer,
format,
false,
handler,
result.runtime_transpiler_cache,
);
}
return transpiler.printWithSourceMapMaybe(
result.ast,
&result.source,
Writer,
writer,
format,
true,
handler,
result.runtime_transpiler_cache,
);
}
pub const ParseOptions = struct {
allocator: std.mem.Allocator,
dirname_fd: StoredFileDescriptorType,
file_descriptor: ?StoredFileDescriptorType = null,
file_hash: ?u32 = null,
/// On exception, we might still want to watch the file.
file_fd_ptr: ?*StoredFileDescriptorType = null,
path: Fs.Path,
loader: options.Loader,
jsx: options.JSX.Pragma,
macro_remappings: MacroRemap,
macro_js_ctx: MacroJSValueType = default_macro_js_value,
virtual_source: ?*const logger.Source = null,
replace_exports: runtime.Runtime.Features.ReplaceableExport.Map = .{},
inject_jest_globals: bool = false,
set_breakpoint_on_first_line: bool = false,
emit_decorator_metadata: bool = false,
remove_cjs_module_wrapper: bool = false,
dont_bundle_twice: bool = false,
allow_commonjs: bool = false,
/// `"type"` from `package.json`. Used to make sure the parser defaults