mirror of
https://github.com/oven-sh/bun
synced 2026-02-09 10:28:47 +00:00
1092 lines
39 KiB
Zig
1092 lines
39 KiB
Zig
const std = @import("std");
|
|
|
|
pub const Api = struct {
|
|
pub const Loader = enum(u8) {
|
|
_none,
|
|
/// jsx
|
|
jsx,
|
|
|
|
/// js
|
|
js,
|
|
|
|
/// ts
|
|
ts,
|
|
|
|
/// tsx
|
|
tsx,
|
|
|
|
/// css
|
|
css,
|
|
|
|
/// file
|
|
file,
|
|
|
|
/// json
|
|
json,
|
|
|
|
_,
|
|
|
|
pub fn jsonStringify(self: *const @This(), opts: anytype, o: anytype) !void {
|
|
return try std.json.stringify(@tagName(self), opts, o);
|
|
}
|
|
};
|
|
|
|
pub const ResolveMode = enum(u8) {
|
|
_none,
|
|
/// disable
|
|
disable,
|
|
|
|
/// lazy
|
|
lazy,
|
|
|
|
/// dev
|
|
dev,
|
|
|
|
/// bundle
|
|
bundle,
|
|
|
|
_,
|
|
|
|
pub fn jsonStringify(self: *const @This(), opts: anytype, o: anytype) !void {
|
|
return try std.json.stringify(@tagName(self), opts, o);
|
|
}
|
|
};
|
|
|
|
pub const Platform = enum(u8) {
|
|
_none,
|
|
/// browser
|
|
browser,
|
|
|
|
/// node
|
|
node,
|
|
|
|
_,
|
|
|
|
pub fn jsonStringify(self: *const @This(), opts: anytype, o: anytype) !void {
|
|
return try std.json.stringify(@tagName(self), opts, o);
|
|
}
|
|
};
|
|
|
|
pub const JsxRuntime = enum(u8) {
|
|
_none,
|
|
/// automatic
|
|
automatic,
|
|
|
|
/// classic
|
|
classic,
|
|
|
|
_,
|
|
|
|
pub fn jsonStringify(self: *const @This(), opts: anytype, o: anytype) !void {
|
|
return try std.json.stringify(@tagName(self), opts, o);
|
|
}
|
|
};
|
|
|
|
pub const Jsx = struct {
|
|
/// factory
|
|
factory: []const u8,
|
|
|
|
/// runtime
|
|
runtime: JsxRuntime,
|
|
|
|
/// fragment
|
|
fragment: []const u8,
|
|
|
|
/// development
|
|
development: bool = false,
|
|
|
|
/// import_source
|
|
import_source: []const u8,
|
|
|
|
/// react_fast_refresh
|
|
react_fast_refresh: bool = false,
|
|
|
|
pub fn decode(allocator: *std.mem.Allocator, reader: anytype) anyerror!Jsx {
|
|
var obj = std.mem.zeroes(Jsx);
|
|
try update(&obj, allocator, reader);
|
|
return obj;
|
|
}
|
|
pub fn update(result: *Jsx, allocator: *std.mem.Allocator, reader: anytype) anyerror!void {
|
|
var length: usize = 0;
|
|
length = try reader.readIntNative(u32);
|
|
if (result.factory.len != length) {
|
|
result.factory = try allocator.alloc(u8, length);
|
|
}
|
|
_ = try reader.readAll(result.factory);
|
|
result.runtime = try reader.readEnum(JsxRuntime, .Little);
|
|
length = try reader.readIntNative(u32);
|
|
if (result.fragment.len != length) {
|
|
result.fragment = try allocator.alloc(u8, length);
|
|
}
|
|
_ = try reader.readAll(result.fragment);
|
|
result.development = (try reader.readByte()) == @as(u8, 1);
|
|
length = try reader.readIntNative(u32);
|
|
if (result.import_source.len != length) {
|
|
result.import_source = try allocator.alloc(u8, length);
|
|
}
|
|
_ = try reader.readAll(result.import_source);
|
|
result.react_fast_refresh = (try reader.readByte()) == @as(u8, 1);
|
|
return;
|
|
}
|
|
|
|
pub fn encode(result: *const @This(), writer: anytype) anyerror!void {
|
|
try writer.writeIntNative(u32, @intCast(u32, result.factory.len));
|
|
try writer.writeAll(std.mem.sliceAsBytes(result.factory));
|
|
|
|
try writer.writeIntNative(@TypeOf(@enumToInt(result.runtime)), @enumToInt(result.runtime));
|
|
|
|
try writer.writeIntNative(u32, @intCast(u32, result.fragment.len));
|
|
try writer.writeAll(std.mem.sliceAsBytes(result.fragment));
|
|
|
|
try writer.writeByte(@boolToInt(result.development));
|
|
|
|
try writer.writeIntNative(u32, @intCast(u32, result.import_source.len));
|
|
try writer.writeAll(std.mem.sliceAsBytes(result.import_source));
|
|
|
|
try writer.writeByte(@boolToInt(result.react_fast_refresh));
|
|
return;
|
|
}
|
|
};
|
|
|
|
pub const TransformOptions = struct {
|
|
/// jsx
|
|
jsx: ?Jsx = null,
|
|
|
|
/// tsconfig_override
|
|
tsconfig_override: ?[]const u8 = null,
|
|
|
|
/// resolve
|
|
resolve: ?ResolveMode = null,
|
|
|
|
/// public_url
|
|
public_url: ?[]const u8 = null,
|
|
|
|
/// absolute_working_dir
|
|
absolute_working_dir: ?[]const u8 = null,
|
|
|
|
/// define_keys
|
|
define_keys: []const []const u8,
|
|
|
|
/// define_values
|
|
define_values: []const []const u8,
|
|
|
|
/// preserve_symlinks
|
|
preserve_symlinks: ?bool = null,
|
|
|
|
/// entry_points
|
|
entry_points: []const []const u8,
|
|
|
|
/// write
|
|
write: ?bool = null,
|
|
|
|
/// inject
|
|
inject: []const []const u8,
|
|
|
|
/// output_dir
|
|
output_dir: ?[]const u8 = null,
|
|
|
|
/// external
|
|
external: []const []const u8,
|
|
|
|
/// loader_keys
|
|
loader_keys: []const []const u8,
|
|
|
|
/// loader_values
|
|
loader_values: []const Loader,
|
|
|
|
/// main_fields
|
|
main_fields: []const []const u8,
|
|
|
|
/// platform
|
|
platform: ?Platform = null,
|
|
|
|
/// serve
|
|
serve: ?bool = null,
|
|
|
|
/// extension_order
|
|
extension_order: []const []const u8,
|
|
|
|
/// public_dir
|
|
public_dir: ?[]const u8 = null,
|
|
|
|
pub fn decode(allocator: *std.mem.Allocator, reader: anytype) anyerror!TransformOptions {
|
|
var obj = std.mem.zeroes(TransformOptions);
|
|
try update(&obj, allocator, reader);
|
|
return obj;
|
|
}
|
|
pub fn update(result: *TransformOptions, allocator: *std.mem.Allocator, reader: anytype) anyerror!void {
|
|
var length: usize = 0;
|
|
while (true) {
|
|
const field_type: u8 = try reader.readByte();
|
|
switch (field_type) {
|
|
0 => {
|
|
return;
|
|
},
|
|
|
|
1 => {
|
|
result.jsx = try Jsx.decode(allocator, reader);
|
|
},
|
|
2 => {
|
|
length = try reader.readIntNative(u32);
|
|
if ((result.tsconfig_override orelse &([_]u8{})).len != length) {
|
|
result.tsconfig_override = try allocator.alloc(u8, length);
|
|
}
|
|
_ = try reader.readAll(result.tsconfig_override.?);
|
|
},
|
|
3 => {
|
|
result.resolve = try reader.readEnum(ResolveMode, .Little);
|
|
},
|
|
4 => {
|
|
length = try reader.readIntNative(u32);
|
|
if ((result.public_url orelse &([_]u8{})).len != length) {
|
|
result.public_url = try allocator.alloc(u8, length);
|
|
}
|
|
_ = try reader.readAll(result.public_url.?);
|
|
},
|
|
5 => {
|
|
length = try reader.readIntNative(u32);
|
|
if ((result.absolute_working_dir orelse &([_]u8{})).len != length) {
|
|
result.absolute_working_dir = try allocator.alloc(u8, length);
|
|
}
|
|
_ = try reader.readAll(result.absolute_working_dir.?);
|
|
},
|
|
6 => {
|
|
{
|
|
var array_count = try reader.readIntNative(u32);
|
|
if (array_count != result.define_keys.len) {
|
|
result.define_keys = try allocator.alloc([]const u8, array_count);
|
|
}
|
|
length = try reader.readIntNative(u32);
|
|
for (result.define_keys) |content, j| {
|
|
if (result.define_keys[j].len != length and length > 0) {
|
|
result.define_keys[j] = try allocator.alloc(u8, length);
|
|
}
|
|
_ = try reader.readAll(result.define_keys[j].?);
|
|
}
|
|
}
|
|
},
|
|
7 => {
|
|
{
|
|
var array_count = try reader.readIntNative(u32);
|
|
if (array_count != result.define_values.len) {
|
|
result.define_values = try allocator.alloc([]const u8, array_count);
|
|
}
|
|
length = try reader.readIntNative(u32);
|
|
for (result.define_values) |content, j| {
|
|
if (result.define_values[j].len != length and length > 0) {
|
|
result.define_values[j] = try allocator.alloc(u8, length);
|
|
}
|
|
_ = try reader.readAll(result.define_values[j].?);
|
|
}
|
|
}
|
|
},
|
|
8 => {
|
|
result.preserve_symlinks = (try reader.readByte()) == @as(u8, 1);
|
|
},
|
|
9 => {
|
|
{
|
|
var array_count = try reader.readIntNative(u32);
|
|
if (array_count != result.entry_points.len) {
|
|
result.entry_points = try allocator.alloc([]const u8, array_count);
|
|
}
|
|
length = try reader.readIntNative(u32);
|
|
for (result.entry_points) |content, j| {
|
|
if (result.entry_points[j].len != length and length > 0) {
|
|
result.entry_points[j] = try allocator.alloc(u8, length);
|
|
}
|
|
_ = try reader.readAll(result.entry_points[j].?);
|
|
}
|
|
}
|
|
},
|
|
10 => {
|
|
result.write = (try reader.readByte()) == @as(u8, 1);
|
|
},
|
|
11 => {
|
|
{
|
|
var array_count = try reader.readIntNative(u32);
|
|
if (array_count != result.inject.len) {
|
|
result.inject = try allocator.alloc([]const u8, array_count);
|
|
}
|
|
length = try reader.readIntNative(u32);
|
|
for (result.inject) |content, j| {
|
|
if (result.inject[j].len != length and length > 0) {
|
|
result.inject[j] = try allocator.alloc(u8, length);
|
|
}
|
|
_ = try reader.readAll(result.inject[j].?);
|
|
}
|
|
}
|
|
},
|
|
12 => {
|
|
length = try reader.readIntNative(u32);
|
|
if ((result.output_dir orelse &([_]u8{})).len != length) {
|
|
result.output_dir = try allocator.alloc(u8, length);
|
|
}
|
|
_ = try reader.readAll(result.output_dir.?);
|
|
},
|
|
13 => {
|
|
{
|
|
var array_count = try reader.readIntNative(u32);
|
|
if (array_count != result.external.len) {
|
|
result.external = try allocator.alloc([]const u8, array_count);
|
|
}
|
|
length = try reader.readIntNative(u32);
|
|
for (result.external) |content, j| {
|
|
if (result.external[j].len != length and length > 0) {
|
|
result.external[j] = try allocator.alloc(u8, length);
|
|
}
|
|
_ = try reader.readAll(result.external[j].?);
|
|
}
|
|
}
|
|
},
|
|
14 => {
|
|
{
|
|
var array_count = try reader.readIntNative(u32);
|
|
if (array_count != result.loader_keys.len) {
|
|
result.loader_keys = try allocator.alloc([]const u8, array_count);
|
|
}
|
|
length = try reader.readIntNative(u32);
|
|
for (result.loader_keys) |content, j| {
|
|
if (result.loader_keys[j].len != length and length > 0) {
|
|
result.loader_keys[j] = try allocator.alloc(u8, length);
|
|
}
|
|
_ = try reader.readAll(result.loader_keys[j].?);
|
|
}
|
|
}
|
|
},
|
|
15 => {
|
|
length = try reader.readIntNative(u32);
|
|
if (result.loader_values != length) {
|
|
result.loader_values = try allocator.alloc(Loader, length);
|
|
}
|
|
{
|
|
var j: usize = 0;
|
|
while (j < length) : (j += 1) {
|
|
result.loader_values[j] = try reader.readEnum(Loader, .Little);
|
|
}
|
|
}
|
|
},
|
|
16 => {
|
|
{
|
|
var array_count = try reader.readIntNative(u32);
|
|
if (array_count != result.main_fields.len) {
|
|
result.main_fields = try allocator.alloc([]const u8, array_count);
|
|
}
|
|
length = try reader.readIntNative(u32);
|
|
for (result.main_fields) |content, j| {
|
|
if (result.main_fields[j].len != length and length > 0) {
|
|
result.main_fields[j] = try allocator.alloc(u8, length);
|
|
}
|
|
_ = try reader.readAll(result.main_fields[j].?);
|
|
}
|
|
}
|
|
},
|
|
17 => {
|
|
result.platform = try reader.readEnum(Platform, .Little);
|
|
},
|
|
18 => {
|
|
result.serve = (try reader.readByte()) == @as(u8, 1);
|
|
},
|
|
19 => {
|
|
{
|
|
var array_count = try reader.readIntNative(u32);
|
|
if (array_count != result.extension_order.len) {
|
|
result.extension_order = try allocator.alloc([]const u8, array_count);
|
|
}
|
|
length = try reader.readIntNative(u32);
|
|
for (result.extension_order) |content, j| {
|
|
if (result.extension_order[j].len != length and length > 0) {
|
|
result.extension_order[j] = try allocator.alloc(u8, length);
|
|
}
|
|
_ = try reader.readAll(result.extension_order[j].?);
|
|
}
|
|
}
|
|
},
|
|
20 => {
|
|
length = try reader.readIntNative(u32);
|
|
if ((result.public_dir orelse &([_]u8{})).len != length) {
|
|
result.public_dir = try allocator.alloc(u8, length);
|
|
}
|
|
_ = try reader.readAll(result.public_dir.?);
|
|
},
|
|
else => {
|
|
return error.InvalidMessage;
|
|
},
|
|
}
|
|
}
|
|
}
|
|
|
|
pub fn encode(result: *const @This(), writer: anytype) anyerror!void {
|
|
var n: usize = 0;
|
|
if (result.jsx) |jsx| {
|
|
try writer.writeByte(1);
|
|
try jsx.encode(writer);
|
|
}
|
|
|
|
if (result.tsconfig_override) |tsconfig_override| {
|
|
try writer.writeByte(2);
|
|
try writer.writeIntNative(u32, @intCast(u32, tsconfig_override.len));
|
|
try writer.writeAll(std.mem.sliceAsBytes(tsconfig_override));
|
|
}
|
|
|
|
if (result.resolve) |resolve| {
|
|
try writer.writeByte(3);
|
|
try writer.writeIntNative(@TypeOf(@enumToInt(result.resolve orelse unreachable)), @enumToInt(result.resolve orelse unreachable));
|
|
}
|
|
|
|
if (result.public_url) |public_url| {
|
|
try writer.writeByte(4);
|
|
try writer.writeIntNative(u32, @intCast(u32, public_url.len));
|
|
try writer.writeAll(std.mem.sliceAsBytes(public_url));
|
|
}
|
|
|
|
if (result.absolute_working_dir) |absolute_working_dir| {
|
|
try writer.writeByte(5);
|
|
try writer.writeIntNative(u32, @intCast(u32, absolute_working_dir.len));
|
|
try writer.writeAll(std.mem.sliceAsBytes(absolute_working_dir));
|
|
}
|
|
|
|
if (result.define_keys) |define_keys| {
|
|
try writer.writeByte(6);
|
|
n = result.define_keys.len;
|
|
_ = try writer.writeIntNative(u32, @intCast(u32, n));
|
|
{
|
|
var j: usize = 0;
|
|
while (j < n) : (j += 1) {
|
|
_ = try writer.writeIntNative(u32, @intCast(u32, result.define_keys[j].len));
|
|
try writer.writeAll(std.mem.sliceAsBytes(define_keys[j]));
|
|
}
|
|
}
|
|
}
|
|
|
|
if (result.define_values) |define_values| {
|
|
try writer.writeByte(7);
|
|
n = result.define_values.len;
|
|
_ = try writer.writeIntNative(u32, @intCast(u32, n));
|
|
{
|
|
var j: usize = 0;
|
|
while (j < n) : (j += 1) {
|
|
_ = try writer.writeIntNative(u32, @intCast(u32, result.define_values[j].len));
|
|
try writer.writeAll(std.mem.sliceAsBytes(define_values[j]));
|
|
}
|
|
}
|
|
}
|
|
|
|
if (result.preserve_symlinks) |preserve_symlinks| {
|
|
try writer.writeByte(8);
|
|
try writer.writeByte(@boolToInt(preserve_symlinks));
|
|
}
|
|
|
|
if (result.entry_points) |entry_points| {
|
|
try writer.writeByte(9);
|
|
n = result.entry_points.len;
|
|
_ = try writer.writeIntNative(u32, @intCast(u32, n));
|
|
{
|
|
var j: usize = 0;
|
|
while (j < n) : (j += 1) {
|
|
_ = try writer.writeIntNative(u32, @intCast(u32, result.entry_points[j].len));
|
|
try writer.writeAll(std.mem.sliceAsBytes(entry_points[j]));
|
|
}
|
|
}
|
|
}
|
|
|
|
if (result.write) |write| {
|
|
try writer.writeByte(10);
|
|
try writer.writeByte(@boolToInt(write));
|
|
}
|
|
|
|
if (result.inject) |inject| {
|
|
try writer.writeByte(11);
|
|
n = result.inject.len;
|
|
_ = try writer.writeIntNative(u32, @intCast(u32, n));
|
|
{
|
|
var j: usize = 0;
|
|
while (j < n) : (j += 1) {
|
|
_ = try writer.writeIntNative(u32, @intCast(u32, result.inject[j].len));
|
|
try writer.writeAll(std.mem.sliceAsBytes(inject[j]));
|
|
}
|
|
}
|
|
}
|
|
|
|
if (result.output_dir) |output_dir| {
|
|
try writer.writeByte(12);
|
|
try writer.writeIntNative(u32, @intCast(u32, output_dir.len));
|
|
try writer.writeAll(std.mem.sliceAsBytes(output_dir));
|
|
}
|
|
|
|
if (result.external) |external| {
|
|
try writer.writeByte(13);
|
|
n = result.external.len;
|
|
_ = try writer.writeIntNative(u32, @intCast(u32, n));
|
|
{
|
|
var j: usize = 0;
|
|
while (j < n) : (j += 1) {
|
|
_ = try writer.writeIntNative(u32, @intCast(u32, result.external[j].len));
|
|
try writer.writeAll(std.mem.sliceAsBytes(external[j]));
|
|
}
|
|
}
|
|
}
|
|
|
|
if (result.loader_keys) |loader_keys| {
|
|
try writer.writeByte(14);
|
|
n = result.loader_keys.len;
|
|
_ = try writer.writeIntNative(u32, @intCast(u32, n));
|
|
{
|
|
var j: usize = 0;
|
|
while (j < n) : (j += 1) {
|
|
_ = try writer.writeIntNative(u32, @intCast(u32, result.loader_keys[j].len));
|
|
try writer.writeAll(std.mem.sliceAsBytes(loader_keys[j]));
|
|
}
|
|
}
|
|
}
|
|
|
|
if (result.loader_values) |loader_values| {
|
|
try writer.writeByte(15);
|
|
n = result.loader_values.len;
|
|
_ = try writer.writeIntNative(u32, @intCast(u32, n));
|
|
{
|
|
var j: usize = 0;
|
|
while (j < n) : (j += 1) {
|
|
try writer.writeByte(@enumToInt(result.loader_values[j] orelse unreachable));
|
|
}
|
|
}
|
|
}
|
|
|
|
if (result.main_fields) |main_fields| {
|
|
try writer.writeByte(16);
|
|
n = result.main_fields.len;
|
|
_ = try writer.writeIntNative(u32, @intCast(u32, n));
|
|
{
|
|
var j: usize = 0;
|
|
while (j < n) : (j += 1) {
|
|
_ = try writer.writeIntNative(u32, @intCast(u32, result.main_fields[j].len));
|
|
try writer.writeAll(std.mem.sliceAsBytes(main_fields[j]));
|
|
}
|
|
}
|
|
}
|
|
|
|
if (result.platform) |platform| {
|
|
try writer.writeByte(17);
|
|
try writer.writeIntNative(@TypeOf(@enumToInt(result.platform orelse unreachable)), @enumToInt(result.platform orelse unreachable));
|
|
}
|
|
|
|
if (result.serve) |serve| {
|
|
try writer.writeByte(18);
|
|
try writer.writeByte(@boolToInt(serve));
|
|
}
|
|
|
|
if (result.extension_order) |extension_order| {
|
|
try writer.writeByte(19);
|
|
n = result.extension_order.len;
|
|
_ = try writer.writeIntNative(u32, @intCast(u32, n));
|
|
{
|
|
var j: usize = 0;
|
|
while (j < n) : (j += 1) {
|
|
_ = try writer.writeIntNative(u32, @intCast(u32, result.extension_order[j].len));
|
|
try writer.writeAll(std.mem.sliceAsBytes(extension_order[j]));
|
|
}
|
|
}
|
|
}
|
|
|
|
if (result.public_dir) |public_dir| {
|
|
try writer.writeByte(20);
|
|
try writer.writeIntNative(u32, @intCast(u32, public_dir.len));
|
|
try writer.writeAll(std.mem.sliceAsBytes(public_dir));
|
|
}
|
|
try writer.writeByte(0);
|
|
return;
|
|
}
|
|
};
|
|
|
|
pub const FileHandle = struct {
|
|
/// path
|
|
path: []const u8,
|
|
|
|
/// size
|
|
size: u32 = 0,
|
|
|
|
/// fd
|
|
fd: u32 = 0,
|
|
|
|
pub fn decode(allocator: *std.mem.Allocator, reader: anytype) anyerror!FileHandle {
|
|
var obj = std.mem.zeroes(FileHandle);
|
|
try update(&obj, allocator, reader);
|
|
return obj;
|
|
}
|
|
pub fn update(result: *FileHandle, allocator: *std.mem.Allocator, reader: anytype) anyerror!void {
|
|
var length: usize = 0;
|
|
length = try reader.readIntNative(u32);
|
|
if (result.path.len != length) {
|
|
result.path = try allocator.alloc(u8, length);
|
|
}
|
|
_ = try reader.readAll(result.path);
|
|
_ = try reader.readAll(std.mem.asBytes(&result.size));
|
|
_ = try reader.readAll(std.mem.asBytes(&result.fd));
|
|
return;
|
|
}
|
|
|
|
pub fn encode(result: *const @This(), writer: anytype) anyerror!void {
|
|
try writer.writeIntNative(u32, @intCast(u32, result.path.len));
|
|
try writer.writeAll(std.mem.sliceAsBytes(result.path));
|
|
|
|
try writer.writeIntNative(u32, result.size);
|
|
|
|
try writer.writeIntNative(u32, result.fd);
|
|
return;
|
|
}
|
|
};
|
|
|
|
pub const Transform = struct {
|
|
/// handle
|
|
handle: ?FileHandle = null,
|
|
|
|
/// path
|
|
path: ?[]const u8 = null,
|
|
|
|
/// contents
|
|
contents: []const u8,
|
|
|
|
/// loader
|
|
loader: ?Loader = null,
|
|
|
|
/// options
|
|
options: ?TransformOptions = null,
|
|
|
|
pub fn decode(allocator: *std.mem.Allocator, reader: anytype) anyerror!Transform {
|
|
var obj = std.mem.zeroes(Transform);
|
|
try update(&obj, allocator, reader);
|
|
return obj;
|
|
}
|
|
pub fn update(result: *Transform, allocator: *std.mem.Allocator, reader: anytype) anyerror!void {
|
|
var length: usize = 0;
|
|
while (true) {
|
|
const field_type: u8 = try reader.readByte();
|
|
switch (field_type) {
|
|
0 => {
|
|
return;
|
|
},
|
|
|
|
1 => {
|
|
result.handle = try FileHandle.decode(allocator, reader);
|
|
},
|
|
2 => {
|
|
length = try reader.readIntNative(u32);
|
|
if ((result.path orelse &([_]u8{})).len != length) {
|
|
result.path = try allocator.alloc(u8, length);
|
|
}
|
|
_ = try reader.readAll(result.path.?);
|
|
},
|
|
3 => {
|
|
length = @intCast(usize, try reader.readIntNative(u32));
|
|
if (result.contents != length) {
|
|
result.contents = try allocator.alloc(u8, length);
|
|
}
|
|
_ = try reader.readAll(result.contents);
|
|
},
|
|
4 => {
|
|
result.loader = try reader.readEnum(Loader, .Little);
|
|
},
|
|
5 => {
|
|
result.options = try TransformOptions.decode(allocator, reader);
|
|
},
|
|
else => {
|
|
return error.InvalidMessage;
|
|
},
|
|
}
|
|
}
|
|
}
|
|
|
|
pub fn encode(result: *const @This(), writer: anytype) anyerror!void {
|
|
if (result.handle) |handle| {
|
|
try writer.writeByte(1);
|
|
try handle.encode(writer);
|
|
}
|
|
|
|
if (result.path) |path| {
|
|
try writer.writeByte(2);
|
|
try writer.writeIntNative(u32, @intCast(u32, path.len));
|
|
try writer.writeAll(std.mem.sliceAsBytes(path));
|
|
}
|
|
|
|
if (result.contents) |contents| {
|
|
try writer.writeByte(3);
|
|
try writer.writeIntNative(u32, @intCast(u32, contents.len));
|
|
try writer.writeAll(contents);
|
|
}
|
|
|
|
if (result.loader) |loader| {
|
|
try writer.writeByte(4);
|
|
try writer.writeIntNative(@TypeOf(@enumToInt(result.loader orelse unreachable)), @enumToInt(result.loader orelse unreachable));
|
|
}
|
|
|
|
if (result.options) |options| {
|
|
try writer.writeByte(5);
|
|
try options.encode(writer);
|
|
}
|
|
try writer.writeByte(0);
|
|
return;
|
|
}
|
|
};
|
|
|
|
pub const TransformResponseStatus = enum(u32) {
|
|
_none,
|
|
/// success
|
|
success,
|
|
|
|
/// fail
|
|
fail,
|
|
|
|
_,
|
|
|
|
pub fn jsonStringify(self: *const @This(), opts: anytype, o: anytype) !void {
|
|
return try std.json.stringify(@tagName(self), opts, o);
|
|
}
|
|
};
|
|
|
|
pub const OutputFile = struct {
|
|
/// data
|
|
data: []const u8,
|
|
|
|
/// path
|
|
path: []const u8,
|
|
|
|
pub fn decode(allocator: *std.mem.Allocator, reader: anytype) anyerror!OutputFile {
|
|
var obj = std.mem.zeroes(OutputFile);
|
|
try update(&obj, allocator, reader);
|
|
return obj;
|
|
}
|
|
pub fn update(result: *OutputFile, allocator: *std.mem.Allocator, reader: anytype) anyerror!void {
|
|
var length: usize = 0;
|
|
length = @intCast(usize, try reader.readIntNative(u32));
|
|
if (result.data != length) {
|
|
result.data = try allocator.alloc(u8, length);
|
|
}
|
|
_ = try reader.readAll(result.data);
|
|
length = try reader.readIntNative(u32);
|
|
if (result.path.len != length) {
|
|
result.path = try allocator.alloc(u8, length);
|
|
}
|
|
_ = try reader.readAll(result.path);
|
|
return;
|
|
}
|
|
|
|
pub fn encode(result: *const @This(), writer: anytype) anyerror!void {
|
|
try writer.writeIntNative(u32, @intCast(u32, result.data.len));
|
|
try writer.writeAll(result.data);
|
|
|
|
try writer.writeIntNative(u32, @intCast(u32, result.path.len));
|
|
try writer.writeAll(std.mem.sliceAsBytes(result.path));
|
|
return;
|
|
}
|
|
};
|
|
|
|
pub const TransformResponse = struct {
|
|
/// status
|
|
status: TransformResponseStatus,
|
|
|
|
/// files
|
|
files: []OutputFile,
|
|
|
|
/// errors
|
|
errors: []Message,
|
|
|
|
pub fn decode(allocator: *std.mem.Allocator, reader: anytype) anyerror!TransformResponse {
|
|
var obj = std.mem.zeroes(TransformResponse);
|
|
try update(&obj, allocator, reader);
|
|
return obj;
|
|
}
|
|
pub fn update(result: *TransformResponse, allocator: *std.mem.Allocator, reader: anytype) anyerror!void {
|
|
var length: usize = 0;
|
|
result.status = try reader.readEnum(TransformResponseStatus, .Little);
|
|
length = try reader.readIntNative(u32);
|
|
result.files = try allocator.alloc(OutputFile, length);
|
|
{
|
|
var j: usize = 0;
|
|
while (j < length) : (j += 1) {
|
|
result.files[j] = try OutputFile.decode(allocator, reader);
|
|
}
|
|
}
|
|
length = try reader.readIntNative(u32);
|
|
result.errors = try allocator.alloc(Message, length);
|
|
{
|
|
var j: usize = 0;
|
|
while (j < length) : (j += 1) {
|
|
result.errors[j] = try Message.decode(allocator, reader);
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
|
|
pub fn encode(result: *const @This(), writer: anytype) anyerror!void {
|
|
var n: usize = 0;
|
|
try writer.writeIntNative(@TypeOf(@enumToInt(result.status)), @enumToInt(result.status));
|
|
|
|
n = result.files.len;
|
|
_ = try writer.writeIntNative(u32, @intCast(u32, n));
|
|
{
|
|
var j: usize = 0;
|
|
while (j < n) : (j += 1) {
|
|
try result.files[j].encode(writer);
|
|
}
|
|
}
|
|
|
|
n = result.errors.len;
|
|
_ = try writer.writeIntNative(u32, @intCast(u32, n));
|
|
{
|
|
var j: usize = 0;
|
|
while (j < n) : (j += 1) {
|
|
try result.errors[j].encode(writer);
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
};
|
|
|
|
pub const MessageKind = enum(u32) {
|
|
_none,
|
|
/// err
|
|
err,
|
|
|
|
/// warn
|
|
warn,
|
|
|
|
/// note
|
|
note,
|
|
|
|
/// debug
|
|
debug,
|
|
|
|
_,
|
|
|
|
pub fn jsonStringify(self: *const @This(), opts: anytype, o: anytype) !void {
|
|
return try std.json.stringify(@tagName(self), opts, o);
|
|
}
|
|
};
|
|
|
|
pub const Location = struct {
|
|
/// file
|
|
file: []const u8,
|
|
|
|
/// namespace
|
|
namespace: []const u8,
|
|
|
|
/// line
|
|
line: i32 = 0,
|
|
|
|
/// column
|
|
column: i32 = 0,
|
|
|
|
/// line_text
|
|
line_text: []const u8,
|
|
|
|
/// suggestion
|
|
suggestion: []const u8,
|
|
|
|
/// offset
|
|
offset: u32 = 0,
|
|
|
|
pub fn decode(allocator: *std.mem.Allocator, reader: anytype) anyerror!Location {
|
|
var obj = std.mem.zeroes(Location);
|
|
try update(&obj, allocator, reader);
|
|
return obj;
|
|
}
|
|
pub fn update(result: *Location, allocator: *std.mem.Allocator, reader: anytype) anyerror!void {
|
|
var length: usize = 0;
|
|
length = try reader.readIntNative(u32);
|
|
if (result.file.len != length) {
|
|
result.file = try allocator.alloc(u8, length);
|
|
}
|
|
_ = try reader.readAll(result.file);
|
|
length = try reader.readIntNative(u32);
|
|
if (result.namespace.len != length) {
|
|
result.namespace = try allocator.alloc(u8, length);
|
|
}
|
|
_ = try reader.readAll(result.namespace);
|
|
_ = try reader.readAll(std.mem.asBytes(&result.line));
|
|
_ = try reader.readAll(std.mem.asBytes(&result.column));
|
|
length = try reader.readIntNative(u32);
|
|
if (result.line_text.len != length) {
|
|
result.line_text = try allocator.alloc(u8, length);
|
|
}
|
|
_ = try reader.readAll(result.line_text);
|
|
length = try reader.readIntNative(u32);
|
|
if (result.suggestion.len != length) {
|
|
result.suggestion = try allocator.alloc(u8, length);
|
|
}
|
|
_ = try reader.readAll(result.suggestion);
|
|
_ = try reader.readAll(std.mem.asBytes(&result.offset));
|
|
return;
|
|
}
|
|
|
|
pub fn encode(result: *const @This(), writer: anytype) anyerror!void {
|
|
try writer.writeIntNative(u32, @intCast(u32, result.file.len));
|
|
try writer.writeAll(std.mem.sliceAsBytes(result.file));
|
|
|
|
try writer.writeIntNative(u32, @intCast(u32, result.namespace.len));
|
|
try writer.writeAll(std.mem.sliceAsBytes(result.namespace));
|
|
|
|
try writer.writeIntNative(i32, result.line);
|
|
|
|
try writer.writeIntNative(i32, result.column);
|
|
|
|
try writer.writeIntNative(u32, @intCast(u32, result.line_text.len));
|
|
try writer.writeAll(std.mem.sliceAsBytes(result.line_text));
|
|
|
|
try writer.writeIntNative(u32, @intCast(u32, result.suggestion.len));
|
|
try writer.writeAll(std.mem.sliceAsBytes(result.suggestion));
|
|
|
|
try writer.writeIntNative(u32, result.offset);
|
|
return;
|
|
}
|
|
};
|
|
|
|
pub const MessageData = struct {
|
|
/// text
|
|
text: ?[]const u8 = null,
|
|
|
|
/// location
|
|
location: ?Location = null,
|
|
|
|
pub fn decode(allocator: *std.mem.Allocator, reader: anytype) anyerror!MessageData {
|
|
var obj = std.mem.zeroes(MessageData);
|
|
try update(&obj, allocator, reader);
|
|
return obj;
|
|
}
|
|
pub fn update(result: *MessageData, allocator: *std.mem.Allocator, reader: anytype) anyerror!void {
|
|
var length: usize = 0;
|
|
while (true) {
|
|
const field_type: u8 = try reader.readByte();
|
|
switch (field_type) {
|
|
0 => {
|
|
return;
|
|
},
|
|
|
|
1 => {
|
|
length = try reader.readIntNative(u32);
|
|
if ((result.text orelse &([_]u8{})).len != length) {
|
|
result.text = try allocator.alloc(u8, length);
|
|
}
|
|
_ = try reader.readAll(result.text.?);
|
|
},
|
|
2 => {
|
|
result.location = try Location.decode(allocator, reader);
|
|
},
|
|
else => {
|
|
return error.InvalidMessage;
|
|
},
|
|
}
|
|
}
|
|
}
|
|
|
|
pub fn encode(result: *const @This(), writer: anytype) anyerror!void {
|
|
if (result.text) |text| {
|
|
try writer.writeByte(1);
|
|
try writer.writeIntNative(u32, @intCast(u32, text.len));
|
|
try writer.writeAll(std.mem.sliceAsBytes(text));
|
|
}
|
|
|
|
if (result.location) |location| {
|
|
try writer.writeByte(2);
|
|
try location.encode(writer);
|
|
}
|
|
try writer.writeByte(0);
|
|
return;
|
|
}
|
|
};
|
|
|
|
pub const Message = struct {
|
|
/// kind
|
|
kind: MessageKind,
|
|
|
|
/// data
|
|
data: MessageData,
|
|
|
|
/// notes
|
|
notes: []MessageData,
|
|
|
|
pub fn decode(allocator: *std.mem.Allocator, reader: anytype) anyerror!Message {
|
|
var obj = std.mem.zeroes(Message);
|
|
try update(&obj, allocator, reader);
|
|
return obj;
|
|
}
|
|
pub fn update(result: *Message, allocator: *std.mem.Allocator, reader: anytype) anyerror!void {
|
|
var length: usize = 0;
|
|
result.kind = try reader.readEnum(MessageKind, .Little);
|
|
result.data = try MessageData.decode(allocator, reader);
|
|
length = try reader.readIntNative(u32);
|
|
result.notes = try allocator.alloc(MessageData, length);
|
|
{
|
|
var j: usize = 0;
|
|
while (j < length) : (j += 1) {
|
|
result.notes[j] = try MessageData.decode(allocator, reader);
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
|
|
pub fn encode(result: *const @This(), writer: anytype) anyerror!void {
|
|
var n: usize = 0;
|
|
try writer.writeIntNative(@TypeOf(@enumToInt(result.kind)), @enumToInt(result.kind));
|
|
|
|
try result.data.encode(writer);
|
|
|
|
n = result.notes.len;
|
|
_ = try writer.writeIntNative(u32, @intCast(u32, n));
|
|
{
|
|
var j: usize = 0;
|
|
while (j < n) : (j += 1) {
|
|
try result.notes[j].encode(writer);
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
};
|
|
|
|
pub const Log = struct {
|
|
/// warnings
|
|
warnings: u32 = 0,
|
|
|
|
/// errors
|
|
errors: u32 = 0,
|
|
|
|
/// msgs
|
|
msgs: []Message,
|
|
|
|
pub fn decode(allocator: *std.mem.Allocator, reader: anytype) anyerror!Log {
|
|
var obj = std.mem.zeroes(Log);
|
|
try update(&obj, allocator, reader);
|
|
return obj;
|
|
}
|
|
pub fn update(result: *Log, allocator: *std.mem.Allocator, reader: anytype) anyerror!void {
|
|
var length: usize = 0;
|
|
_ = try reader.readAll(std.mem.asBytes(&result.warnings));
|
|
_ = try reader.readAll(std.mem.asBytes(&result.errors));
|
|
length = try reader.readIntNative(u32);
|
|
result.msgs = try allocator.alloc(Message, length);
|
|
{
|
|
var j: usize = 0;
|
|
while (j < length) : (j += 1) {
|
|
result.msgs[j] = try Message.decode(allocator, reader);
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
|
|
pub fn encode(result: *const @This(), writer: anytype) anyerror!void {
|
|
var n: usize = 0;
|
|
try writer.writeIntNative(u32, result.warnings);
|
|
|
|
try writer.writeIntNative(u32, result.errors);
|
|
|
|
n = result.msgs.len;
|
|
_ = try writer.writeIntNative(u32, @intCast(u32, n));
|
|
{
|
|
var j: usize = 0;
|
|
while (j < n) : (j += 1) {
|
|
try result.msgs[j].encode(writer);
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
};
|
|
};
|