cool

Former-commit-id: 96ff169e46

src/api/schema.zig

@@ -0,0 +1,739 @@
+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 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: []u8,
+
+        /// runtime
+        runtime: JsxRuntime,
+
+        /// fragment
+        fragment: []u8,
+
+        /// production
+        production: bool = false,
+
+        /// import_source
+        import_source: []u8,
+
+        /// react_fast_refresh
+        react_fast_refresh: bool = false,
+
+        /// loader_keys
+        loader_keys: [][]u8,
+
+        /// loader_values
+        loader_values: []Loader,
+
+        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.production = (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);
+            {
+                var array_count = try reader.readIntNative(u32);
+                if (array_count != result.loader_keys.len) {
+                    result.loader_keys = try allocator.alloc([]u8, array_count);
+                }
+                length = try reader.readIntNative(u32);
+                for (result.loader_keys) |content, j| {
+                    if (result.loader_keys[j].len != length) {
+                        result.loader_keys[j] = try allocator.alloc(u8, length);
+                    }
+                    _ = try reader.readAll(result.loader_keys[j]);
+                }
+            }
+            length = try reader.readIntNative(u32);
+            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);
+                }
+            }
+            return;
+        }
+
+        pub fn encode(result: *const @This(), writer: anytype) anyerror!void {
+            var n: usize = 0;
+            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.production));
+
+            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));
+
+            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(result.loader_keys[j]));
+                }
+            }
+
+            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]));
+                }
+            }
+            return;
+        }
+    };
+
+    pub const TransformOptions = struct {
+        /// jsx
+        jsx: Jsx,
+
+        /// ts
+        ts: bool = false,
+
+        /// base_path
+        base_path: []u8,
+
+        /// define_keys
+        define_keys: [][]u8,
+
+        /// define_values
+        define_values: [][]u8,
+
+        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;
+            result.jsx = try Jsx.decode(allocator, reader);
+            result.ts = (try reader.readByte()) == @as(u8, 1);
+            length = try reader.readIntNative(u32);
+            if (result.base_path.len != length) {
+                result.base_path = try allocator.alloc(u8, length);
+            }
+            _ = try reader.readAll(result.base_path);
+            {
+                var array_count = try reader.readIntNative(u32);
+                if (array_count != result.define_keys.len) {
+                    result.define_keys = try allocator.alloc([]u8, array_count);
+                }
+                length = try reader.readIntNative(u32);
+                for (result.define_keys) |content, j| {
+                    if (result.define_keys[j].len != length) {
+                        result.define_keys[j] = try allocator.alloc(u8, length);
+                    }
+                    _ = try reader.readAll(result.define_keys[j]);
+                }
+            }
+            {
+                var array_count = try reader.readIntNative(u32);
+                if (array_count != result.define_values.len) {
+                    result.define_values = try allocator.alloc([]u8, array_count);
+                }
+                length = try reader.readIntNative(u32);
+                for (result.define_values) |content, j| {
+                    if (result.define_values[j].len != length) {
+                        result.define_values[j] = try allocator.alloc(u8, length);
+                    }
+                    _ = try reader.readAll(result.define_values[j]);
+                }
+            }
+            return;
+        }
+
+        pub fn encode(result: *const @This(), writer: anytype) anyerror!void {
+            var n: usize = 0;
+            try result.jsx.encode(writer);
+
+            try writer.writeByte(@boolToInt(result.ts));
+
+            try writer.writeIntNative(u32, @intCast(u32, result.base_path.len));
+            try writer.writeAll(std.mem.sliceAsBytes(result.base_path));
+
+            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(result.define_keys[j]));
+                }
+            }
+
+            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(result.define_values[j]));
+                }
+            }
+            return;
+        }
+    };
+
+    pub const FileHandle = struct {
+        /// path
+        path: []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: ?[]u8 = null,
+
+        /// contents
+        contents: ?[]u8 = null,
+
+        /// 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 = try reader.readIntNative(u32);
+                        if ((result.contents orelse &([_]u8{})).len != 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(std.mem.sliceAsBytes(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: []u8,
+
+        /// path
+        path: []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;
+            _ = 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.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: []u8,
+
+        /// namespace
+        namespace: []u8,
+
+        /// line
+        line: i32 = 0,
+
+        /// column
+        column: i32 = 0,
+
+        /// line_text
+        line_text: []u8,
+
+        /// suggestion
+        suggestion: []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: ?[]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;
+        }
+    };
+};