@simonklee/opentui-tex-native-source 0.2.0

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

@@ -0,0 +1,383 @@
+const std = @import("std");
+pub const c = @cImport({
+    @cDefine("HAVE_CWRAPPER", "");
+    @cInclude("stdbool.h");
+    @cInclude("wrapper/cwrapper.h");
+});
+
+pub const FontDescription = struct {
+    f: *c.FontDesc,
+};
+
+pub const TextLayoutBounds = struct {
+    b: *c.TextLayoutBounds,
+
+    pub fn setBounds(
+        self: TextLayoutBounds,
+        width: f32,
+        height: f32,
+        ascent: f32,
+    ) void {
+        c.microtex_setTextLayoutBounds(
+            self.b,
+            width,
+            height,
+            ascent,
+        );
+    }
+};
+
+pub const MicroTeX = struct {
+    const Self = @This();
+    allocator: std.mem.Allocator,
+    clm_data: []const u8,
+    font_meta: c.FontMetaPtr,
+
+    var ctx: *anyopaque = undefined;
+
+    pub fn initPath(
+        allocator: std.mem.Allocator,
+        clm_path: []const u8,
+        context: anytype,
+    ) !Self {
+        const stat = try std.fs.cwd().statFile(clm_path);
+        const content = try std.fs.cwd().readFileAlloc(
+            allocator,
+            clm_path,
+            stat.size,
+        );
+        defer allocator.free(content);
+        return try init(allocator, content, context);
+    }
+
+    pub fn init(allocator: std.mem.Allocator, clm_data: []const u8, context: anytype) !Self {
+        if (c.microtex_isInited()) {
+            return error.MicroTeXAlreadyInitialized;
+        }
+
+        const Ctx = @typeInfo(@TypeOf(context)).pointer.child;
+        ctx = context;
+
+        const CallbackWrapper = struct {
+            fn createTextLayout(
+                text: [*c]const u8,
+                f: [*c]c.FontDesc,
+            ) callconv(.c) c_uint {
+                const slice = std.mem.span(text);
+                const id: usize =
+                    Ctx.createTextLayout(
+                        @ptrCast(@alignCast(ctx)),
+                        slice,
+                        FontDescription{ .f = f },
+                    ) catch |err| {
+                        std.log.default.err("createTextLayout: {t}", .{err});
+                        return 0;
+                    };
+                return @intCast(id);
+            }
+            fn getTextLayoutBounds(
+                id: c_uint,
+                b: [*c]c.TextLayoutBounds,
+            ) callconv(.c) void {
+                Ctx.getTextLayoutBounds(
+                    @ptrCast(@alignCast(ctx)),
+                    @as(usize, @intCast(id)),
+                    TextLayoutBounds{ .b = b },
+                ) catch |err| {
+                    std.log.default.err("getTextlayoutBounds: {t}", .{err});
+                    return 0;
+                };
+            }
+            fn releaseTextLayout(id: c_uint) callconv(.c) void {
+                Ctx.releaseTextLayout(
+                    @ptrCast(@alignCast(ctx)),
+                    @as(usize, @intCast(id)),
+                );
+            }
+            fn isPathExists(id: c_uint) callconv(.c) bool {
+                return Ctx.isPathExists(
+                    @ptrCast(@alignCast(ctx)),
+                    @as(usize, @intCast(id)),
+                );
+            }
+        };
+
+        // register the callback functions
+        c.microtex_registerCallbacks(
+            CallbackWrapper.createTextLayout,
+            CallbackWrapper.getTextLayoutBounds,
+            CallbackWrapper.releaseTextLayout,
+            CallbackWrapper.isPathExists,
+        );
+
+        const content = try allocator.dupe(u8, clm_data);
+        const font_meta = c.microtex_init(@intCast(content.len), content.ptr);
+
+        const name = c.microtex_getFontName(font_meta);
+        c.microtex_setDefaultMainFont(name);
+        c.microtex_setDefaultMathFont(name);
+
+        return .{
+            .allocator = allocator,
+            .clm_data = content,
+            .font_meta = font_meta,
+        };
+    }
+
+    pub fn deinit(self: *Self) void {
+        c.microtex_release();
+        self.allocator.free(self.clm_data);
+        self.* = undefined;
+    }
+
+    pub const ParseOptions = struct {
+        width: u32 = 0,
+        text_size: f32 = 20,
+        line_space: f32 = 20 / 3,
+        /// 0xAARRGGBB
+        color: u32,
+        fill_width: bool = false,
+        override_syle: bool = true,
+        style: u32 = 0,
+    };
+
+    pub fn parseRender(
+        self: *const Self,
+        tex: [:0]const u8,
+        opts: ParseOptions,
+    ) !Render {
+        _ = self;
+        const ptr = c.microtex_parseRender(
+            tex.ptr,
+            @intCast(opts.width),
+            opts.text_size,
+            opts.line_space,
+            @intCast(opts.color),
+            opts.fill_width,
+            opts.override_syle,
+            @intCast(opts.style),
+        );
+        if (ptr == null) return error.FailedToRender;
+        return .{ .ptr = ptr };
+    }
+};
+
+fn getRawDrawingData(
+    data: c.DrawingData,
+    offset: usize,
+    size: usize,
+) []const u8 {
+    const ptr: [*]const u8 = @ptrCast(@alignCast(data.?));
+    return ptr[offset .. offset + size];
+}
+
+fn getRawDrawingDataT(
+    data: c.DrawingData,
+    offset: usize,
+    comptime T: type,
+) T {
+    const slice = getRawDrawingData(data, offset, @sizeOf(T));
+    return std.mem.bytesToValue(T, slice);
+}
+
+pub const Render = struct {
+    pub const Command = union(enum(u8)) {
+        set_color: u32,
+        set_stroke: struct { width: f32, miter_limit: f32, cap: u32, join: u32 },
+        set_dash: bool,
+        set_font: []const u8,
+        set_font_size: struct { size: f32 },
+        translate: struct { x: f32, y: f32 },
+        scale: struct { x: f32, y: f32 },
+        rotate: struct { x: f32, y: f32, angle: f32 },
+        reset: void,
+        draw_glyph: struct { a1: u16, x: f32, y: f32 },
+        // returns the id
+        begin_path: i32,
+        move_to: struct { x: f32, y: f32 },
+        line_to: struct { x: f32, y: f32 },
+        cubic_to: struct { x1: f32, y1: f32, x2: f32, y2: f32, x3: f32, y3: f32 },
+        quad_to: struct { x1: f32, y1: f32, x2: f32, y2: f32 },
+        close_path: void,
+        // returns the id
+        fill_path: i32,
+        draw_line: struct { x1: f32, y1: f32, x2: f32, y2: f32 },
+        draw_rect: struct { x: f32, y: f32, width: f32, height: f32 },
+        fill_rect: struct { x: f32, y: f32, width: f32, height: f32 },
+        draw_round_rect: struct {
+            x: f32,
+            y: f32,
+            width: f32,
+            height: f32,
+            a1: f32,
+            a2: f32,
+        },
+        fill_round_rect: struct {
+            x: f32,
+            y: f32,
+            width: f32,
+            height: f32,
+            a1: f32,
+            a2: f32,
+        },
+        drawTextLayout: struct { id: u32, x: f32, y: f32 },
+    };
+
+    pub const DrawingData = struct {
+        // offset is already advanced because we read in the length
+        offset: usize = @sizeOf(u32),
+        data: []const u8,
+        ptr: c.DrawingData,
+
+        fn init(ptr: c.DrawingData) DrawingData {
+            const len = getRawDrawingDataT(ptr, 0, u32);
+            return .{
+                .ptr = ptr,
+                .data = getRawDrawingData(ptr, 0, len),
+            };
+        }
+
+        fn getSlice(self: *DrawingData, size: usize) ?[]const u8 {
+            if (self.offset + size > self.data.len) {
+                return null;
+            }
+            const s = self.data[self.offset .. self.offset + size];
+            self.offset += size;
+            return s;
+        }
+
+        fn getT(self: *DrawingData, comptime T: type) ?T {
+            const data = self.getSlice(@sizeOf(T)) orelse
+                return null;
+            return std.mem.bytesToValue(T, data);
+        }
+
+        fn readOp(
+            self: *DrawingData,
+            comptime op: std.meta.Tag(Command),
+        ) Command {
+            const name = @tagName(op);
+            const info = @typeInfo(Command).@"union";
+            const T = comptime b: {
+                for (info.fields) |field| {
+                    if (std.mem.eql(u8, field.name, name)) {
+                        break :b field.type;
+                    }
+                }
+                @compileError("This should be unreachable");
+            };
+
+            var cmd: T = undefined;
+            switch (@typeInfo(T)) {
+                .@"struct" => {
+                    inline for (@typeInfo(T).@"struct".fields) |field| {
+                        @field(cmd, field.name) = self.getT(field.type).?;
+                    }
+                },
+                .int, .float => {
+                    cmd = self.getT(T).?;
+                },
+                else => {},
+            }
+            return @unionInit(Command, name, cmd);
+        }
+
+        pub fn next(self: *DrawingData) ?Command {
+            const opcode = self.getT(u8) orelse
+                return null;
+            switch (opcode) {
+                inline 0...22 => |i| {
+                    const op: std.meta.Tag(Command) = @enumFromInt(i);
+                    return self.readOp(op);
+                },
+                else => {
+                    std.log.default.warn("Unhandled opcode: {d}\n", .{opcode});
+                },
+            }
+            return null;
+        }
+    };
+
+    ptr: c.RenderPtr,
+    drawing_data: ?DrawingData = null,
+
+    pub fn deinit(self: *Render) void {
+        if (self.drawing_data) |d| {
+            c.microtex_freeDrawingData(d.ptr);
+        }
+        c.microtex_deleteRender(self.ptr);
+        self.* = undefined;
+    }
+
+    pub fn getDrawingData(self: *Render, x: u32, y: u32) DrawingData {
+        return self.drawing_data orelse {
+            const ptr = c.microtex_getDrawingData(
+                self.ptr,
+                @intCast(x),
+                @intCast(y),
+            );
+            self.drawing_data = DrawingData.init(ptr);
+            return self.drawing_data.?;
+        };
+    }
+};
+
+pub const FontContext = struct {
+    const FontText = struct {
+        font: FontDescription,
+        text: []const u8,
+    };
+    const FontMap = std.AutoHashMap(usize, FontText);
+
+    id: usize = 0,
+    fontmap: FontMap,
+
+    fn createTextLayout(
+        self: *FontContext,
+        text: []const u8,
+        font: FontDescription,
+    ) !usize {
+        const id = self.id;
+        self.id += 1;
+
+        try self.fontmap.put(id, .{ .text = text, .font = font });
+        return id;
+    }
+
+    fn getTextLayoutBounds(
+        self: *FontContext,
+        id: usize,
+        bounds: TextLayoutBounds,
+    ) !void {
+        const value = self.fontmap.get(id).?;
+        _ = value;
+        // TODO: would need a way of measuring how big this is going to be
+        bounds.setBounds(200, 100, 10);
+    }
+
+    fn releaseTextLayout(self: *FontContext, id: usize) void {
+        if (!self.fontmap.remove(id)) {
+            std.log.default.debug("Failed to remove text layout: {d}", .{id});
+        }
+    }
+
+    fn isPathExists(self: *FontContext, id: usize) bool {
+        _ = self;
+        _ = id;
+        return false;
+    }
+
+    pub fn init(allocator: std.mem.Allocator) FontContext {
+        const map = FontMap.init(allocator);
+        return .{ .fontmap = map };
+    }
+
+    pub fn deinit(self: *FontContext) void {
+        self.fontmap.deinit();
+        self.* = undefined;
+    }
+};
+
+pub fn setRenderGlyphUsePath(use: bool) void {
+    c.microtex_setRenderGlyphUsePath(use);
+}

package/native/zigtex-0.16.patch

@@ -0,0 +1,35 @@
+diff --git a/src/svg.zig b/src/svg.zig
+--- a/src/svg.zig
++++ b/src/svg.zig
+@@ -45,6 +45,7 @@ pub const Svg = struct {
+                 try self.path.append(allocator, ' ');
+             }
+-            var path_writer = self.path.writer(allocator).adaptToNewApi(&.{});
+-            try path_writer.new_interface.print(fmt, args);
++            var path_writer = std.Io.Writer.Allocating.fromArrayList(allocator, &self.path);
++            defer self.path = path_writer.toArrayList();
++            try path_writer.writer.print(fmt, args);
+         }
+     };
+diff --git a/src/root.zig b/src/root.zig
+--- a/src/root.zig
++++ b/src/root.zig
+@@ -112,14 +112,13 @@ pub const TexSvgRender = struct {
+                 },
+             }
+         }
+-        var buf = std.ArrayList(u8).empty;
+-        defer buf.deinit(allocator);
+-        var buf_writer = buf.writer(allocator).adaptToNewApi(&.{});
+-        try s.write(&buf_writer.new_interface, .{
++        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.toOwnedSlice(allocator);
++        return buf_writer.toOwnedSlice();
+     }
+ };

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@simonklee/opentui-tex-native-source",
+  "version": "0.2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/simonklee/opentui-tex.git"
+  },
+  "homepage": "https://github.com/simonklee/opentui-tex#readme",
+  "bugs": {
+    "url": "https://github.com/simonklee/opentui-tex/issues"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "description": "Complete corresponding source for @simonklee/opentui-tex native binaries",
+  "license": "GPL-3.0-only",
+  "files": [
+    "build.zig",
+    "build.zig.zon",
+    "native",
+    "scripts",
+    "LICENSE",
+    "LICENSE-PROJECT",
+    "README.md"
+  ]
+}

package/scripts/bootstrap-native

@@ -0,0 +1,89 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+cd "$(dirname "$0")/.."
+
+readonly vendor=native/vendor
+readonly stamp="$vendor/.bootstrap-v5"
+readonly stamp_value='zigtex=fda2819e45f57ca2071810c47249a46bfc782cdf microtex=74e8fee9e47edc3a777e64fb2eff9a85a01defac nanosvg=239e102ec2c691f2902e20ace2ed36ee4a35cfe6 zig=0.16-v5'
+mkdir -p "$vendor"
+
+download() {
+  local url=$1 output=$2
+  curl --fail --location --silent --show-error --retry 3 --retry-all-errors \
+    --connect-timeout 20 --max-time 180 "$url" --output "$output"
+}
+
+fetch_file() {
+  local name=$1 url=$2 expected=$3 path="$vendor/$1" temporary
+  if [[ -f "$path" ]] && echo "$expected  $path" | sha256sum --check --status; then
+    return
+  fi
+  temporary=$(mktemp "$vendor/.download.XXXXXX")
+  trap 'rm -f "$temporary"' RETURN
+  download "$url" "$temporary"
+  echo "$expected  $temporary" | sha256sum --check --status
+  mv "$temporary" "$path"
+  trap - RETURN
+}
+
+fetch_archive() {
+  local name=$1 url=$2 expected=$3 archive temporary
+  archive=$(mktemp "$vendor/.archive.XXXXXX")
+  temporary=$(mktemp -d "$vendor/.extract.XXXXXX")
+  trap 'rm -rf "$archive" "$temporary"' RETURN
+  download "$url" "$archive"
+  echo "$expected  $archive" | sha256sum --check --status
+  tar --extract --gzip --file "$archive" --directory "$temporary" --strip-components=1
+  rm -rf "$vendor/$name"
+  mv "$temporary" "$vendor/$name"
+  rm -f "$archive"
+  trap - RETURN
+}
+
+fetch_file nanosvg.h \
+  https://raw.githubusercontent.com/memononen/nanosvg/239e102ec2c691f2902e20ace2ed36ee4a35cfe6/src/nanosvg.h \
+  e34fd5d084be106cea972d19ce5d27fd96d17ba89f8d06bdceee058420c8b2b0
+fetch_file nanosvgrast.h \
+  https://raw.githubusercontent.com/memononen/nanosvg/239e102ec2c691f2902e20ace2ed36ee4a35cfe6/src/nanosvgrast.h \
+  79a9c5f4db19debf9f3a648a1589e96d92854f245a5cb4f3d823f263785234d8
+fetch_file LICENSE-NANOSVG \
+  https://raw.githubusercontent.com/memononen/nanosvg/239e102ec2c691f2902e20ace2ed36ee4a35cfe6/LICENSE.txt \
+  e82bc3dd03400aecabe12201219ba14750dbc4b36faab58663a7a6068548d372
+
+if [[ ! -f "$stamp" ]] || [[ "$(<"$stamp")" != "$stamp_value" ]]; then
+  fetch_archive zigtex \
+    https://github.com/fjebaker/zigtex/archive/fda2819e45f57ca2071810c47249a46bfc782cdf.tar.gz \
+    ea2923b8a731e80820b2f0ded97a3c57a5933da46fde7ab1350fe79aff3e00cc
+  fetch_archive microtex \
+    https://github.com/fjebaker/MicroTeX/archive/74e8fee9e47edc3a777e64fb2eff9a85a01defac.tar.gz \
+    8da1600f75a674d465715b1d3e0c2bfd84adab128b45e91253ecfa46f856a963
+
+  sed -i \
+    -e 's#            .url = .*#            .path = "../microtex",#' \
+    -e '/            .hash = /d' \
+    "$vendor/zigtex/build.zig.zon"
+  sed -i \
+    -e 's/conf_header.getOutput()/conf_header.getOutputFile()/' \
+    -e 's/lib.linkLibCpp();/lib.root_module.link_libcpp = true;/' \
+    -e 's/lib.addConfigHeader/lib.root_module.addConfigHeader/g' \
+    -e 's/lib.addIncludePath/lib.root_module.addIncludePath/g' \
+    -e 's/lib.addCSourceFiles/lib.root_module.addCSourceFiles/g' \
+    -e 's/exe.addIncludePath/exe.root_module.addIncludePath/g' \
+    -e 's/exe.addCSourceFiles/exe.root_module.addCSourceFiles/g' \
+    -e 's/exe.linkLibrary/exe.root_module.linkLibrary/g' \
+    -e '/            .optimize = optimize,/a\            .pic = true,' \
+    "$vendor/microtex/build.zig"
+  patch --directory "$vendor/zigtex" --strip 1 < native/zigtex-0.16.patch
+  sed -i \
+    's/c.microtex_init(content.len, content.ptr)/c.microtex_init(@intCast(content.len), content.ptr)/' \
+    "$vendor/zigtex/src/tex.zig"
+  printf '%s\n' "$stamp_value" > "$stamp"
+fi
+
+for required in \
+  "$vendor/zigtex/LICENSE" \
+  "$vendor/microtex/LICENSE" \
+  "$vendor/microtex/res/lm-math/README"; do
+  [[ -s "$required" ]] || { echo "required vendor file is missing: $required" >&2; exit 1; }
+done