tiny.pretty.json

1pub const Field = struct {2    first: bool = false,3};

1pub const Style = enum {2    minified,3    indent_2,4};

1/// An open array scope on one `Writer`.2/// Nested scopes share the writer and must end before their parent continues.3pub const Array = struct {4    writer: *Writer,56    pub fn element(self: Array, value: anytype) !void {7        try self.writer.write(value);8    }910    pub fn object(self: Array) !Object {11        return try self.writer.object();12    }1314    pub fn array(self: Array) !Array {15        return try self.writer.array();16    }1718    pub fn stringParts(self: Array, parts: []const []const u8) !void {19        try self.writer.stringParts(parts);20    }2122    pub fn byteString(self: Array, bytes: []const u8) !void {23        try self.writer.byteString(bytes);24    }2526    pub fn hexString(self: Array, bytes: []const u8) !void {27        try self.writer.hexString(bytes);28    }2930    pub fn base64String(self: Array, bytes: []const u8) !void {31        try self.writer.base64String(bytes);32    }3334    pub fn formattedString(35        self: Array,36        comptime capacity: usize,37        comptime fmt: []const u8,38        args: anytype,39    ) !void {40        try self.writer.formattedString(capacity, fmt, args);41    }4243    pub fn raw(self: Array, value: []const u8) !void {44        try self.writer.raw(value);45    }4647    pub fn print(self: Array, comptime fmt: []const u8, args: anytype) !void {48        try self.writer.print(fmt, args);49    }5051    pub fn end(self: Array) !void {52        try self.writer.endArray();53    }5455    pub fn endLine(self: Array) !void {56        try self.end();57        try self.writer.newline();58    }59};

1/// An open object scope on one `Writer`.2/// Nested scopes share the writer and must end before their parent continues.3pub const Object = struct {4    writer: *Writer,56    pub fn field(self: Object, name: []const u8, value: anytype) !void {7        try self.writer.objectField(name);8        try self.writer.write(value);9    }1011    pub fn fields(self: Object, values: anytype) !void {12        const info = switch (@typeInfo(@TypeOf(values))) {13            .@"struct" => |value| value,14            else => @compileError("JSON object fields require a named struct"),15        };16        if (info.is_tuple) {17            @compileError("JSON object fields require a named struct");18        }19        inline for (info.field_names) |name| {20            try self.field(name, @field(values, name));21        }22    }2324    pub fn fieldParts(25        self: Object,26        name_parts: []const []const u8,27        value: anytype,28    ) !void {29        try self.writer.objectFieldParts(name_parts);30        try self.writer.write(value);31    }3233    pub fn formattedField(34        self: Object,35        comptime capacity: usize,36        comptime fmt: []const u8,37        args: anytype,38        value: anytype,39    ) !void {40        var buffer: [capacity]u8 = undefined;41        const name = try std.fmt.bufPrint(&buffer, fmt, args);42        try self.field(name, value);43    }4445    pub fn object(self: Object, name: []const u8) !Object {46        try self.writer.objectField(name);47        return try self.writer.object();48    }4950    pub fn formattedObject(51        self: Object,52        comptime capacity: usize,53        comptime fmt: []const u8,54        args: anytype,55    ) !Object {56        var buffer: [capacity]u8 = undefined;57        const name = try std.fmt.bufPrint(&buffer, fmt, args);58        return try self.object(name);59    }6061    pub fn array(self: Object, name: []const u8) !Array {62        try self.writer.objectField(name);63        return try self.writer.array();64    }6566    pub fn formattedArray(67        self: Object,68        comptime capacity: usize,69        comptime fmt: []const u8,70        args: anytype,71    ) !Array {72        var buffer: [capacity]u8 = undefined;73        const name = try std.fmt.bufPrint(&buffer, fmt, args);74        return try self.array(name);75    }7677    pub fn stringParts(78        self: Object,79        name: []const u8,80        parts: []const []const u8,81    ) !void {82        try self.writer.objectField(name);83        try self.writer.stringParts(parts);84    }8586    pub fn byteString(self: Object, name: []const u8, bytes: []const u8) !void {87        try self.writer.objectField(name);88        try self.writer.byteString(bytes);89    }9091    pub fn hexString(self: Object, name: []const u8, bytes: []const u8) !void {92        try self.writer.objectField(name);93        try self.writer.hexString(bytes);94    }9596    pub fn base64String(self: Object, name: []const u8, bytes: []const u8) !void {97        try self.writer.objectField(name);98        try self.writer.base64String(bytes);99    }100101    pub fn formattedString(102        self: Object,103        name: []const u8,104        comptime capacity: usize,105        comptime fmt: []const u8,106        args: anytype,107    ) !void {108        try self.writer.objectField(name);109        try self.writer.formattedString(capacity, fmt, args);110    }111112    pub fn raw(self: Object, name: []const u8, value: []const u8) !void {113        try self.writer.objectField(name);114        try self.writer.raw(value);115    }116117    pub fn print(118        self: Object,119        name: []const u8,120        comptime fmt: []const u8,121        args: anytype,122    ) !void {123        try self.writer.objectField(name);124        try self.writer.print(fmt, args);125    }126127    pub fn end(self: Object) !void {128        try self.writer.endObject();129    }130131    pub fn endLine(self: Object) !void {132        try self.end();133        try self.writer.newline();134    }135};

1/// Streams one JSON value at a time without intermediate string allocations.2/// `newline` resets completed top-level state so the same writer can emit JSONL.3pub const Writer = struct {4    stringify: std.json.Stringify,56    pub fn init(writer: *std.Io.Writer, style: format.Style) Writer {7        return .{ .stringify = .{8            .writer = writer,9            .options = format.stringifyOptions(style),10        } };11    }1213    pub fn beginObject(self: *Writer) !void {14        try self.stringify.beginObject();15    }1617    pub fn object(self: *Writer) !Object {18        try self.beginObject();19        return .{ .writer = self };20    }2122    pub fn endObject(self: *Writer) !void {23        try self.stringify.endObject();24    }2526    pub fn objectField(self: *Writer, name: []const u8) !void {27        try self.stringify.objectField(name);28    }2930    fn objectFieldParts(self: *Writer, parts: []const []const u8) !void {31        try self.stringify.beginObjectFieldRaw();32        try escape.writeStringParts(self.stringify.writer, parts);33        self.stringify.endObjectFieldRaw();34    }3536    pub fn beginArray(self: *Writer) !void {37        try self.stringify.beginArray();38    }3940    pub fn array(self: *Writer) !Array {41        try self.beginArray();42        return .{ .writer = self };43    }4445    pub fn endArray(self: *Writer) !void {46        try self.stringify.endArray();47    }4849    pub fn write(self: *Writer, value: anytype) !void {50        try self.stringify.write(value);51    }5253    pub fn stringParts(self: *Writer, parts: []const []const u8) !void {54        const raw_writer = try self.beginRaw();55        try escape.writeStringParts(raw_writer, parts);56        self.endRaw();57    }5859    pub fn byteString(self: *Writer, bytes: []const u8) !void {60        const raw_writer = try self.beginRaw();61        try escape.writeByteString(raw_writer, bytes);62        self.endRaw();63    }6465    pub fn hexString(self: *Writer, bytes: []const u8) !void {66        const hex = "0123456789abcdef";67        const raw_writer = try self.beginRaw();68        try raw_writer.writeByte('"');69        for (bytes) |byte| {70            try raw_writer.writeByte(hex[byte >> 4]);71            try raw_writer.writeByte(hex[byte & 0x0f]);72        }73        try raw_writer.writeByte('"');74        self.endRaw();75    }7677    pub fn base64String(self: *Writer, bytes: []const u8) !void {78        const raw_writer = try self.beginRaw();79        try raw_writer.writeByte('"');80        try std.base64.standard.Encoder.encodeWriter(raw_writer, bytes);81        try raw_writer.writeByte('"');82        self.endRaw();83    }8485    pub fn formattedString(86        self: *Writer,87        comptime capacity: usize,88        comptime fmt: []const u8,89        args: anytype,90    ) !void {91        if (capacity == 0) @compileError("formatted JSON string capacity must be positive");92        var buffer: [capacity]u8 = undefined;93        try self.write(try std.fmt.bufPrint(&buffer, fmt, args));94    }9596    pub fn raw(self: *Writer, value: []const u8) !void {97        try self.stringify.beginWriteRaw();98        try self.stringify.writer.writeAll(value);99        self.stringify.endWriteRaw();100    }101102    pub fn beginRaw(self: *Writer) !*std.Io.Writer {103        try self.stringify.beginWriteRaw();104        return self.stringify.writer;105    }106107    pub fn endRaw(self: *Writer) void {108        self.stringify.endWriteRaw();109    }110111    pub fn print(self: *Writer, comptime fmt: []const u8, args: anytype) !void {112        try self.stringify.print(fmt, args);113    }114115    pub fn newline(self: *Writer) !void {116        try self.stringify.writer.writeByte('\n');117        if (self.stringify.indent_level != 0) return;118        if (self.stringify.next_punctuation != .comma) return;119        self.stringify = .{120            .writer = self.stringify.writer,121            .options = self.stringify.options,122        };123    }124};

1pub fn renderValueAlloc(2    allocator: std.mem.Allocator,3    value: std.json.Value,4    options: LayoutOptions,5) ![]u8 {6    var arena_state = std.heap.ArenaAllocator.init(allocator);7    defer arena_state.deinit();8    const builder = Builder.init(arena_state.allocator());9    return try pretty.renderAlloc(allocator, try valueDoc(builder, value), options);10}

1pub fn valueDoc(builder: Builder, value: std.json.Value) anyerror!Doc {2    return switch (value) {3        .null => try builder.styledText(.keyword, "null"),4        .bool => |item| try builder.styledText(.keyword, if (item) "true" else "false"),5        .integer => |item| try builder.styledFmt(.number, "{d}", .{item}),6        .float => |item| try builder.styledFmt(.number, "{d}", .{item}),7        .number_string => |item| try builder.styledText(.number, item),8        .string => |item| try builder.styledText(.string, try escape.stringAlloc(builder.allocator, item)),9        .array => |items| try arrayDoc(builder, items.items),10        .object => |object| try objectDoc(builder, object),11    };12}

1pub fn writeValue(2    writer: anytype,3    allocator: std.mem.Allocator,4    value: std.json.Value,5    options: LayoutOptions,6) !void {7    try writeValueWithState(writer, allocator, value, options, .{});8}

1pub fn writeValueWithState(2    writer: anytype,3    allocator: std.mem.Allocator,4    value: std.json.Value,5    options: LayoutOptions,6    state: WriteState,7) !void {8    var arena_state = std.heap.ArenaAllocator.init(allocator);9    defer arena_state.deinit();10    const builder = Builder.init(arena_state.allocator());11    try pretty.writeWithState(writer, try valueDoc(builder, value), options, state);12}

1pub fn stringAlloc(allocator: std.mem.Allocator, value: []const u8) ![]const u8 {2    return try std.json.Stringify.valueAlloc(allocator, value, .{});3}

1pub fn writeString(writer: anytype, value: []const u8) !void {2    try std.json.Stringify.value(value, .{}, writer);3}

1pub fn writeStringParts(writer: anytype, parts: []const []const u8) !void {2    for (parts) |part| {3        if (!std.unicode.utf8ValidateSlice(part)) return error.InvalidUtf8;4    }5    try writer.writeByte('"');6    for (parts) |part| try writeStringContent(writer, part);7    try writer.writeByte('"');8}

1pub fn writeFieldBool(writer: anytype, name: []const u8, value: bool, field: Field) !void {2    try writeFieldName(writer, name, field);3    try scalar.writeBool(writer, value);4}

1pub fn writeFieldInt(writer: anytype, name: []const u8, value: anytype, field: Field) !void {2    try writeFieldName(writer, name, field);3    try scalar.writeInt(writer, value);4}

1pub fn writeFieldName(writer: anytype, name: []const u8, field: Field) !void {2    if (!field.first) try writer.writeByte(',');3    try escape.writeString(writer, name);4    try writer.writeByte(':');5}

1pub fn writeFieldOptionalString(writer: anytype, name: []const u8, value: ?[]const u8, field: Field) !void {2    try writeFieldName(writer, name, field);3    if (value) |inner| try escape.writeString(writer, inner) else try scalar.writeNull(writer);4}

1pub fn writeFieldRaw(writer: anytype, name: []const u8, raw_json: []const u8, field: Field) !void {2    try writeFieldName(writer, name, field);3    try writer.writeAll(raw_json);4}

1pub fn writeFieldString(writer: anytype, name: []const u8, value: []const u8, field: Field) !void {2    try writeFieldName(writer, name, field);3    try escape.writeString(writer, value);4}

1pub fn renderIndentedAlloc(allocator: std.mem.Allocator, value: anytype) ![]u8 {2    var out: std.Io.Writer.Allocating = .init(allocator);3    errdefer out.deinit();4    try writeIndented(&out.writer, value);5    return try out.toOwnedSlice();6}

1pub fn renderMinifiedAlloc(2    allocator: std.mem.Allocator,3    value: anytype,4) std.mem.Allocator.Error![]u8 {5    var out: std.Io.Writer.Allocating = .init(allocator);6    errdefer out.deinit();7    writeMinified(&out.writer, value) catch return error.OutOfMemory;8    return try out.toOwnedSlice();9}

1pub fn renderMinifiedLineAlloc(2    allocator: std.mem.Allocator,3    value: anytype,4) std.mem.Allocator.Error![]u8 {5    var out: std.Io.Writer.Allocating = .init(allocator);6    errdefer out.deinit();7    writeMinifiedLine(&out.writer, value) catch return error.OutOfMemory;8    return try out.toOwnedSlice();9}

1pub fn writeIndented(writer: anytype, value: anytype) !void {2    try std.json.Stringify.value(value, stringifyOptions(.indent_2), writer);3}

1pub fn writeMinified(writer: anytype, value: anytype) !void {2    try std.json.Stringify.value(value, stringifyOptions(.minified), writer);3}

1pub fn writeMinifiedLine(writer: anytype, value: anytype) !void {2    try writeMinified(writer, value);3    try writer.writeByte('\n');4}

1pub fn writeBool(writer: anytype, value: bool) !void {2    try writer.writeAll(if (value) "true" else "false");3}

1pub fn writeInt(writer: anytype, value: anytype) !void {2    try writer.print("{d}", .{value});3}

1pub fn writeNull(writer: anytype) !void {2    try writer.writeAll("null");3}

1pub fn writeNumberString(writer: anytype, value: []const u8) !void {2    try writer.writeAll(value);3}

1pub fn renderSortedMinifiedAlloc(allocator: std.mem.Allocator, value: std.json.Value) ![]u8 {2    var out: std.Io.Writer.Allocating = .init(allocator);3    errdefer out.deinit();4    try writeSortedMinified(&out.writer, allocator, value);5    return try out.toOwnedSlice();6}

1pub fn writeSortedMinified(writer: anytype, allocator: std.mem.Allocator, value: std.json.Value) !void {2    switch (value) {3        .null => try scalar.writeNull(writer),4        .bool => |inner| try scalar.writeBool(writer, inner),5        .integer => |inner| try scalar.writeInt(writer, inner),6        .float => |inner| try writer.print("{d}", .{inner}),7        .number_string => |inner| try scalar.writeNumberString(writer, inner),8        .string => |inner| try escape.writeString(writer, inner),9        .array => |inner| {10            try writer.writeByte('[');11            for (inner.items, 0..) |item, index| {12                if (index != 0) try writer.writeByte(',');13                try writeSortedMinified(writer, allocator, item);14            }15            try writer.writeByte(']');16        },17        .object => |inner| {18            var entries: std.ArrayList(Entry) = .empty;19            defer entries.deinit(allocator);20            var iterator = inner.iterator();21            while (iterator.next()) |entry| {22                try entries.append(allocator, .{23                    .key = entry.key_ptr.*,24                    .value = entry.value_ptr,25                });26            }27            std.sort.insertion(Entry, entries.items, {}, lessEntry);28            try writer.writeByte('{');29            for (entries.items, 0..) |entry, index| {30                if (index != 0) try writer.writeByte(',');31                try escape.writeString(writer, entry.key);32                try writer.writeByte(':');33                try writeSortedMinified(writer, allocator, entry.value.*);34            }35            try writer.writeByte('}');36        },37    }38}

1//! Deterministic JSON escaping, tree rendering, and allocation-free streaming.2//! Streaming scopes own punctuation and escaping; callers close every scope with `end`.34const document = @import("document.zig");5const escape = @import("escape.zig");6const field = @import("field.zig");7const format = @import("format.zig");8const scalar = @import("scalar.zig");9const sort = @import("sort.zig");10const stream = @import("stream.zig");1112pub const Field = field.Field;13pub const Style = format.Style;14pub const Writer = stream.Writer;15pub const Object = stream.Object;16pub const Array = stream.Array;1718pub const writeString = escape.writeString;19pub const writeStringParts = escape.writeStringParts;20pub const stringAlloc = escape.stringAlloc;2122pub const writeMinified = format.writeMinified;23pub const writeMinifiedLine = format.writeMinifiedLine;24pub const renderMinifiedAlloc = format.renderMinifiedAlloc;25pub const renderMinifiedLineAlloc = format.renderMinifiedLineAlloc;26pub const writeIndented = format.writeIndented;27pub const renderIndentedAlloc = format.renderIndentedAlloc;2829pub const writeSortedMinified = sort.writeSortedMinified;30pub const renderSortedMinifiedAlloc = sort.renderSortedMinifiedAlloc;3132pub const writeNull = scalar.writeNull;33pub const writeBool = scalar.writeBool;34pub const writeInt = scalar.writeInt;35pub const writeNumberString = scalar.writeNumberString;3637pub const writeFieldName = field.writeFieldName;38pub const writeFieldString = field.writeFieldString;39pub const writeFieldOptionalString = field.writeFieldOptionalString;40pub const writeFieldBool = field.writeFieldBool;41pub const writeFieldInt = field.writeFieldInt;42pub const writeFieldRaw = field.writeFieldRaw;4344pub const valueDoc = document.valueDoc;45pub const renderValueAlloc = document.renderValueAlloc;46pub const writeValue = document.writeValue;47pub const writeValueWithState = document.writeValueWithState;

1pub const json = @import("json/root.zig");