@simonklee/opentui-tex-native-source 0.2.0

package/native/vendor/zigtex/README.md

@@ -0,0 +1,52 @@
+<p align="center">
+    <img src=".github/assets/example.svg" style="max-height: 150px; background-color: white;"/>
+    <h1 style="text-align: center;">ZigTeX</h1>
+</p>
+
+ZigTeX is a wrapper around [MicroTeX](https://github.com/NanoMichael/MicroTeX/tree/openmath) with a custom SVG renderer. ZigTeX principally gives you one function, which takes some LaTeX code and spits out an SVG:
+
+```zig
+const std = @import("std");
+const ztex = @import("zigtex");
+
+pub fn main() !void {
+    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+    defer _ = gpa.deinit();
+    const allocator = gpa.allocator();
+
+    var render = try ztex.TexSvgRender.init(allocator, .{});
+    defer render.deinit();
+
+    const tex =
+        \\\begin{equation}
+        \\    \hat{F}(\nu) = \int_{-\infty}^\infty e^{-i 2\pi t \nu} f(t) \text{d}t
+        \\\end{equation}
+    ;
+
+    const output = try render.parseRender(allocator, tex, .{});
+    defer allocator.free(output);
+
+    var f = try std.fs.cwd().createFile("example.svg", .{});
+    defer f.close();
+    try f.writeAll(output);
+}
+```
+This produces the title image on a transparent background.
+
+## Usage
+
+To use in your Zig project, add this project as a dependency
+```bash
+zig fetch --save https://github.com/fjebaker/zigtex/archive/main.tar.gz
+```
+
+Then modify your `build.zig` in the usual way:
+```zig
+const zigtex_dep = b.dependency(
+    "zigtex",
+    .{.optimize = optimize, .target = target},
+);
+
+// ...
+exe.root_module.addImport("zigtex", zigtex_dep.module("zigtex"));
+```

package/native/vendor/zigtex/build.zig

@@ -0,0 +1,52 @@
+const std = @import("std");
+
+pub fn build(b: *std.Build) void {
+    const target = b.standardTargetOptions(.{});
+    const optimize = b.standardOptimizeOption(.{});
+
+    const microtex_dep = b.dependency(
+        "microtex",
+        .{ .target = target },
+    );
+
+    const mod = b.addModule("zigtex", .{
+        .root_source_file = b.path("src/root.zig"),
+        .optimize = optimize,
+        .target = target,
+    });
+    mod.linkLibrary(microtex_dep.artifact("microtex"));
+    mod.addAnonymousImport(
+        "@DEFAULT_FONT@",
+        .{ .root_source_file = b.path("./fonts/latinmodern-math.clm2") },
+    );
+
+    const exe = b.addExecutable(.{
+        .name = "texample",
+        .root_module = b.createModule(.{
+            .root_source_file = b.path("src/main.zig"),
+            .target = target,
+            .optimize = optimize,
+        }),
+    });
+    exe.root_module.addImport("zigtex", mod);
+
+    const install_exe = b.addInstallArtifact(exe, .{});
+    const run_cmd = b.addRunArtifact(exe);
+    run_cmd.step.dependOn(&install_exe.step);
+
+    if (b.args) |args| {
+        run_cmd.addArgs(args);
+    }
+
+    const run_step = b.step("run", "Run the app");
+    run_step.dependOn(&run_cmd.step);
+
+    const exe_unit_tests = b.addTest(.{
+        .root_module = exe.root_module,
+    });
+
+    const run_exe_unit_tests = b.addRunArtifact(exe_unit_tests);
+
+    const test_step = b.step("test", "Run unit tests");
+    test_step.dependOn(&run_exe_unit_tests.step);
+}

package/native/vendor/zigtex/build.zig.zon

@@ -0,0 +1,16 @@
+.{
+    .name = .zigtex,
+    .fingerprint = 0x3c04f3e228832fde,
+    .version = "0.1.0",
+    .dependencies = .{
+        .microtex = .{
+            .path = "../microtex",
+        },
+    },
+    .paths = .{
+        "build.zig",
+        "build.zig.zon",
+        "src",
+        "fonts",
+    },
+}

package/native/vendor/zigtex/src/main.zig

@@ -0,0 +1,22 @@
+const std = @import("std");
+const ztex = @import("zigtex");
+
+pub fn main() !void {
+    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+    defer _ = gpa.deinit();
+    const allocator = gpa.allocator();
+
+    var render = try ztex.TexSvgRender.init(allocator, .{});
+    defer render.deinit();
+
+    const tex =
+        \\\frac{\text{d}}{\text{d} t} \left( \frac{\partial L}{\partial \dot{q}} \right) = \frac{\partial L}{\partial q}.
+    ;
+
+    const output = try render.parseRender(allocator, tex, .{});
+    defer allocator.free(output);
+
+    var f = try std.fs.cwd().createFile("example.svg", .{});
+    defer f.close();
+    try f.writeAll(output);
+}

package/native/vendor/zigtex/src/root.zig

@@ -0,0 +1,124 @@
+const std = @import("std");
+pub const microtex = @import("tex.zig");
+pub const svg = @import("svg.zig");
+
+const DEFAULT_FONT = @embedFile("@DEFAULT_FONT@");
+
+pub const TexSvgRender = struct {
+    pub const Options = struct {
+        font_data: []const u8 = DEFAULT_FONT,
+    };
+
+    context: microtex.FontContext,
+    mtex: microtex.MicroTeX,
+
+    pub fn init(
+        allocator: std.mem.Allocator,
+        opts: Options,
+    ) !TexSvgRender {
+        microtex.setRenderGlyphUsePath(true);
+        var context = microtex.FontContext.init(allocator);
+        errdefer context.deinit();
+
+        const mtex = try microtex.MicroTeX.init(
+            allocator,
+            opts.font_data,
+            &context,
+        );
+        errdefer mtex.deinit();
+        return .{
+            .context = context,
+            .mtex = mtex,
+        };
+    }
+
+    pub fn deinit(self: *TexSvgRender) void {
+        self.mtex.deinit();
+        self.context.deinit();
+        self.* = undefined;
+    }
+
+    pub const RenderOptions = struct {
+        size: usize = 20,
+        spacing: usize = 6,
+        style: ?enum { display, in_line } = null,
+        x_pad: u32 = 3,
+        y_pad: u32 = 3,
+        full_header: bool = true,
+        class: ?[]const u8 = null,
+        /// RBGA
+        default_color: []const u8 = "#3b3b3b",
+    };
+
+    pub fn parseRender(
+        self: *TexSvgRender,
+        allocator: std.mem.Allocator,
+        tex: []const u8,
+        opts: RenderOptions,
+    ) ![]const u8 {
+        const null_term = try allocator.dupeZ(u8, tex);
+        defer allocator.free(null_term);
+
+        const style: u32 = b: {
+            if (opts.style) |s| {
+                break :b switch (s) {
+                    .display => 1,
+                    .in_line => 0,
+                };
+            }
+            break :b 0;
+        };
+
+        var r = try self.mtex.parseRender(null_term, .{
+            .text_size = @floatFromInt(opts.size),
+            .line_space = @floatFromInt(opts.spacing),
+            .override_syle = opts.style == null,
+            .style = style,
+            .color = 0,
+        });
+        defer r.deinit();
+
+        var data = r.getDrawingData(opts.x_pad, opts.y_pad);
+
+        var s = svg.Svg.init(allocator);
+        defer s.deinit();
+
+        s.x_pad = @floatFromInt(opts.x_pad);
+        s.y_pad = @floatFromInt(opts.y_pad);
+        s.setColor(opts.default_color);
+
+        var color: [9]u8 = undefined;
+        while (data.next()) |cmd| {
+            switch (cmd) {
+                .set_color => |c| {
+                    if (c == 0) {
+                        s.setColor(opts.default_color);
+                    } else {
+                        s.setColor(try std.fmt.bufPrint(&color, "#{x:0>6}", .{c >> 8}));
+                    }
+                },
+                .translate => |i| s.translate(i.x, i.y),
+                .scale => |i| s.scale(i.x, i.y),
+                .move_to => |i| try s.moveTo(i.x, i.y),
+                .line_to => |i| try s.lineTo(i.x, i.y),
+                .cubic_to => |i| try s.cubicTo(i.x1, i.y1, i.x2, i.y2, i.x3, i.y3),
+                .begin_path => |id| try s.beginPath(@intCast(id)),
+                .close_path => try s.closePath(),
+                .fill_path => try s.fillPath(),
+                .draw_line => |i| try s.drawLine(i.x1, i.y1, i.x2, i.y2),
+                .set_stroke => |i| try s.setStroke(i.width),
+                else => {
+                    std.log.default.warn("Unhandled opcopde: {any}", .{cmd});
+                },
+            }
+        }
+        var buf_writer: std.Io.Writer.Allocating = .init(allocator);
+        defer buf_writer.deinit();
+        try s.write(&buf_writer.writer, .{
+            .full_header = opts.full_header,
+            .svg_content = tex,
+            .class = opts.class,
+        });
+        return buf_writer.toOwnedSlice();
+    }
+};

package/native/vendor/zigtex/src/svg.zig

@@ -0,0 +1,273 @@
+const std = @import("std");
+
+pub const Svg = struct {
+    const AttrMap = std.StringHashMap([]const u8);
+
+    pub const Tag = struct {
+        name: []const u8,
+        id: usize,
+        attr: AttrMap,
+        style: AttrMap,
+        path: std.ArrayList(u8) = .empty,
+
+        pub fn write(self: *const Tag, writer: *std.Io.Writer) !void {
+            try writer.print("<{s}", .{self.name});
+            if (self.path.items.len > 0) {
+                try writer.print(" d=\"{s}\"", .{self.path.items});
+            }
+            if (self.style.count() > 0) {
+                try writer.writeAll(" style=\"");
+                var itt = self.style.iterator();
+                while (itt.next()) |item| {
+                    try writer.print(
+                        " {s}:{s};",
+                        .{ item.key_ptr.*, item.value_ptr.* },
+                    );
+                }
+                try writer.writeAll("\"");
+            }
+            var itt = self.attr.iterator();
+            while (itt.next()) |item| {
+                try writer.print(
+                    " {s}=\"{s}\"",
+                    .{ item.key_ptr.*, item.value_ptr.* },
+                );
+            }
+            try writer.writeAll("/>");
+        }
+
+        pub fn appendPath(
+            self: *Tag,
+            comptime fmt: []const u8,
+            args: anytype,
+        ) !void {
+            const allocator = self.attr.allocator;
+            if (self.path.items.len > 0) {
+                try self.path.append(allocator, ' ');
+            }
+            var path_writer = std.Io.Writer.Allocating.fromArrayList(allocator, &self.path);
+            defer self.path = path_writer.toArrayList();
+            try path_writer.writer.print(fmt, args);
+        }
+    };
+
+    pub const State = enum {
+        none,
+        in_path,
+        path_done,
+    };
+
+    arena: std.heap.ArenaAllocator,
+    allocator: std.mem.Allocator,
+    tags: std.ArrayList(Tag) = .empty,
+
+    state: State = .none,
+    color: []const u8 = "#3b3b3bff",
+    stroke: struct {
+        width: f32 = 1,
+    } = .{},
+    // translation
+    tx: f32 = 0,
+    ty: f32 = 0,
+    // scaling
+    sx: f32 = 1,
+    sy: f32 = 1,
+
+    x_min: f32 = std.math.floatMax(f32),
+    y_min: f32 = std.math.floatMax(f32),
+    x_max: f32 = std.math.floatMin(f32),
+    y_max: f32 = std.math.floatMin(f32),
+
+    x_pad: f32 = 0,
+    y_pad: f32 = 0,
+
+    pub fn init(allocator: std.mem.Allocator) Svg {
+        return .{
+            .arena = std.heap.ArenaAllocator.init(allocator),
+            .allocator = allocator,
+        };
+    }
+
+    fn newTag(self: *Svg, name: []const u8, id: usize) !*Tag {
+        const ptr = try self.tags.addOne(self.allocator);
+        ptr.* = .{
+            .attr = AttrMap.init(self.arena.allocator()),
+            .name = name,
+            .id = id,
+            .style = AttrMap.init(self.arena.allocator()),
+            .path = .empty,
+        };
+        return ptr;
+    }
+
+    pub fn deinit(self: *Svg) void {
+        self.tags.deinit(self.allocator);
+        self.arena.deinit();
+        self.* = undefined;
+    }
+
+    inline fn current(self: *const Svg) *Tag {
+        std.debug.assert(self.tags.items.len > 0);
+        return &self.tags.items[self.tags.items.len - 1];
+    }
+    inline fn xfmXNoSave(self: *const Svg, x: f32) f32 {
+        return x * self.sx + self.tx;
+    }
+    inline fn xfmYNoSave(self: *const Svg, y: f32) f32 {
+        return y * self.sy + self.ty;
+    }
+    inline fn xfmX(self: *Svg, x: f32) f32 {
+        const new_x = self.xfmXNoSave(x);
+        self.x_min = @min(new_x, self.x_min);
+        self.x_max = @max(new_x, self.x_max);
+        return new_x;
+    }
+    inline fn xfmY(self: *Svg, y: f32) f32 {
+        const new_y = self.xfmYNoSave(y);
+        self.y_min = @min(new_y, self.y_min);
+        self.y_max = @max(new_y, self.y_max);
+        return new_y;
+    }
+
+    pub fn setColor(self: *Svg, string: []const u8) void {
+        self.color = string;
+    }
+
+    pub fn moveTo(self: *Svg, x: f32, y: f32) !void {
+        try self.current().appendPath("M{d} {d}", .{
+            self.xfmX(x),
+            self.xfmY(y),
+        });
+    }
+
+    pub fn lineTo(self: *Svg, x: f32, y: f32) !void {
+        try self.current().appendPath("L{d} {d}", .{
+            self.xfmX(x),
+            self.xfmY(y),
+        });
+    }
+
+    pub fn cubicTo(
+        self: *Svg,
+        dx1: f32,
+        dy1: f32,
+        dx2: f32,
+        dy2: f32,
+        x: f32,
+        y: f32,
+    ) !void {
+        try self.current().appendPath("C{d} {d}, {d} {d}, {d} {d}", .{
+            self.xfmX(dx1),
+            self.xfmY(dy1),
+            self.xfmX(dx2),
+            self.xfmY(dy2),
+            self.xfmX(x),
+            self.xfmY(y),
+        });
+    }
+
+    pub fn beginPath(self: *Svg, id: usize) !void {
+        _ = try self.newTag("path", id);
+    }
+
+    pub fn closePath(self: *Svg) !void {
+        try self.current().appendPath("Z", .{});
+    }
+
+    pub fn drawLine(self: *Svg, x1: f32, y1: f32, x2: f32, y2: f32) !void {
+        const ptr = try self.newTag("path", 0);
+        const alloc = self.arena.allocator();
+        try ptr.appendPath(
+            "M {d} {d} L {d} {d}",
+            .{ x1 * self.sx, y1 * self.sy, x2 * self.sx, y2 * self.sy },
+        );
+        try ptr.attr.put("stroke", try alloc.dupe(u8, self.color));
+        try ptr.attr.put(
+            "stroke-width",
+            try std.fmt.allocPrint(alloc, "{d}", .{self.stroke.width * self.sx}),
+        );
+    }
+
+    pub fn setStroke(self: *Svg, width: f32) !void {
+        self.stroke.width = width;
+    }
+
+    pub fn fillPath(self: *Svg) !void {
+        const alloc = self.arena.allocator();
+        try self.current().attr.put("fill", try alloc.dupe(u8, self.color));
+    }
+
+    pub fn translate(self: *Svg, x: f32, y: f32) void {
+        self.tx = x * self.sx;
+        self.ty = y * self.sy;
+    }
+
+    pub fn scale(self: *Svg, x: f32, y: f32) void {
+        self.sx *= x;
+        self.sy *= y;
+    }
+
+    pub const WriteOptions = struct {
+        svg_content: ?[]const u8 = null,
+        full_header: bool = true,
+        class: ?[]const u8 = null,
+    };
+
+    pub fn write(self: *const Svg, writer: *std.Io.Writer, opts: WriteOptions) !void {
+        try self.writeHeader(writer, opts.class, opts.full_header);
+        try writer.writeByte('\n');
+
+        const indent: usize = 1;
+        if (opts.svg_content) |content| {
+            try writer.splatByteAll(' ', indent * 2);
+            try writer.print(
+                "<desc>{s}</desc>\n",
+                .{std.mem.trim(u8, content, "\n\t ")},
+            );
+        }
+
+        for (self.tags.items) |tag| {
+            try writer.splatByteAll(' ', indent * 2);
+            try tag.write(writer);
+            try writer.writeByte('\n');
+        }
+
+        try self.writeFooter(writer);
+    }
+
+    fn writeHeader(
+        self: *const Svg,
+        writer: anytype,
+        class: ?[]const u8,
+        full_header: bool,
+    ) !void {
+        if (self.x_min >= self.x_max) return error.BadViewbox;
+        if (self.y_min >= self.y_max) return error.BadViewbox;
+
+        if (full_header) {
+            try writer.writeAll(
+                \\<?xml version="1.0" encoding="UTF-8"?>
+                \\  <!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
+            );
+            try writer.writeAll("\n  ");
+        }
+        const xlow = self.x_min - self.x_pad;
+        const ylow = self.y_min - self.x_pad;
+        const xhigh = self.x_max + 2 * self.x_pad;
+        const yhigh = self.y_max + 2 * self.y_pad;
+
+        try writer.print(
+            \\<svg xmlns="http://www.w3.org/2000/svg" viewBox="{d} {d} {d} {d}" width="{d}" height="{d}"
+        , .{
+            xlow, ylow, xhigh, yhigh, xhigh - xlow, yhigh - ylow,
+        });
+        if (class) |cls| {
+            try writer.print(" class=\"{s}\"", .{cls});
+        }
+        try writer.writeAll(">");
+    }
+
+    fn writeFooter(_: *const Svg, writer: anytype) !void {
+        try writer.writeAll("</svg>");
+    }
+};