font: move shaper into comptime interface

src/font/main.zig

@@ -10,7 +10,8 @@ pub const Face = face.Face;
 pub const Group = @import("Group.zig");
 pub const GroupCache = @import("GroupCache.zig");
 pub const Glyph = @import("Glyph.zig");
-pub const Shaper = @import("Shaper.zig");
+pub const shape = @import("shape.zig");
+pub const Shaper = shape.Shaper;
 pub const sprite = @import("sprite.zig");
 pub const Sprite = sprite.Sprite;
 pub const Descriptor = discovery.Descriptor;

src/font/shape.zig

@@ -0,0 +1,14 @@
+const builtin = @import("builtin");
+const options = @import("main.zig").options;
+const harfbuzz = @import("shaper/harfbuzz.zig");
+
+/// Shaper implementation for our compile options.
+pub const Shaper = switch (options.backend) {
+    .freetype,
+    .fontconfig_freetype,
+    .coretext_freetype,
+    .coretext,
+    => harfbuzz.Shaper,
+
+    .web_canvas => harfbuzz.Shaper,
+};

src/font/shaper/harfbuzz.zig

@@ -1,58 +1,57 @@
-//! This struct handles text shaping.
-const Shaper = @This();
-
 const std = @import("std");
 const assert = std.debug.assert;
 const Allocator = std.mem.Allocator;
 const harfbuzz = @import("harfbuzz");
 const trace = @import("tracy").trace;
-const font = @import("main.zig");
-const Face = @import("main.zig").Face;
-const DeferredFace = @import("main.zig").DeferredFace;
-const Group = @import("main.zig").Group;
-const GroupCache = @import("main.zig").GroupCache;
-const Library = @import("main.zig").Library;
-const Style = @import("main.zig").Style;
-const Presentation = @import("main.zig").Presentation;
-const terminal = @import("../terminal/main.zig");
+const font = @import("../main.zig");
+const Face = font.Face;
+const DeferredFace = font.DeferredFace;
+const Group = font.Group;
+const GroupCache = font.GroupCache;
+const Library = font.Library;
+const Style = font.Style;
+const Presentation = font.Presentation;
+const terminal = @import("../../terminal/main.zig");
 
 const log = std.log.scoped(.font_shaper);
 
-/// The buffer used for text shaping. We reuse it across multiple shaping
-/// calls to prevent allocations.
-hb_buf: harfbuzz.Buffer,
+/// Shaper that uses Harfbuzz.
+pub const Shaper = struct {
+    /// The buffer used for text shaping. We reuse it across multiple shaping
+    /// calls to prevent allocations.
+    hb_buf: harfbuzz.Buffer,
 
-/// The shared memory used for shaping results.
-cell_buf: []Cell,
+    /// The shared memory used for shaping results.
+    cell_buf: []Cell,
 
-/// The cell_buf argument is the buffer to use for storing shaped results.
-/// This should be at least the number of columns in the terminal.
-pub fn init(cell_buf: []Cell) !Shaper {
+    /// The cell_buf argument is the buffer to use for storing shaped results.
+    /// This should be at least the number of columns in the terminal.
+    pub fn init(cell_buf: []Cell) !Shaper {
         return Shaper{
             .hb_buf = try harfbuzz.Buffer.create(),
             .cell_buf = cell_buf,
         };
-}
+    }
 
-pub fn deinit(self: *Shaper) void {
+    pub fn deinit(self: *Shaper) void {
         self.hb_buf.destroy();
-}
+    }
 
-/// Returns an iterator that returns one text run at a time for the
-/// given terminal row. Note that text runs are are only valid one at a time
-/// for a Shaper struct since they share state.
-pub fn runIterator(self: *Shaper, group: *GroupCache, row: terminal.Screen.Row) RunIterator {
+    /// Returns an iterator that returns one text run at a time for the
+    /// given terminal row. Note that text runs are are only valid one at a time
+    /// for a Shaper struct since they share state.
+    pub fn runIterator(self: *Shaper, group: *GroupCache, row: terminal.Screen.Row) RunIterator {
         return .{ .shaper = self, .group = group, .row = row };
-}
+    }
 
-/// Shape the given text run. The text run must be the immediately previous
-/// text run that was iterated since the text run does share state with the
-/// Shaper struct.
-///
-/// The return value is only valid until the next shape call is called.
-///
-/// If there is not enough space in the cell buffer, an error is returned.
-pub fn shape(self: *Shaper, run: TextRun) ![]Cell {
+    /// Shape the given text run. The text run must be the immediately previous
+    /// text run that was iterated since the text run does share state with the
+    /// Shaper struct.
+    ///
+    /// The return value is only valid until the next shape call is called.
+    ///
+    /// If there is not enough space in the cell buffer, an error is returned.
+    pub fn shape(self: *Shaper, run: TextRun) ![]Cell {
         const tracy = trace(@src());
         defer tracy.end();
 
@@ -93,9 +92,9 @@ pub fn shape(self: *Shaper, run: TextRun) ![]Cell {
         }
 
         return self.cell_buf[0..info.len];
-}
+    }
 
-pub const Cell = struct {
+    pub const Cell = struct {
         /// The column that this cell occupies. Since a set of shaper cells is
         /// always on the same line, only the X is stored. It is expected the
         /// caller has access to the original screen cell.
@@ -104,11 +103,11 @@ pub const Cell = struct {
         /// The glyph index for this cell. The font index to use alongside
         /// this cell is available in the text run.
         glyph_index: u32,
-};
+    };
 
-/// A single text run. A text run is only valid for one Shaper and
-/// until the next run is created.
-pub const TextRun = struct {
+    /// A single text run. A text run is only valid for one Shaper and
+    /// until the next run is created.
+    pub const TextRun = struct {
         /// The offset in the row where this run started
         offset: u16,
 
@@ -120,9 +119,9 @@ pub const TextRun = struct {
 
         /// The font index to use for the glyphs of this run.
         font_index: Group.FontIndex,
-};
+    };
 
-pub const RunIterator = struct {
+    pub const RunIterator = struct {
         shaper: *Shaper,
         group: *GroupCache,
         row: terminal.Screen.Row,
@@ -225,6 +224,7 @@ pub const RunIterator = struct {
                 .font_index = current_font,
             };
         }
+    };
 };
 
 test "run iterator" {
@@ -619,7 +619,7 @@ const TestShaper = struct {
     shaper: Shaper,
     cache: *GroupCache,
     lib: Library,
-    cell_buf: []Cell,
+    cell_buf: []Shaper.Cell,
 
     pub fn deinit(self: *TestShaper) void {
         self.shaper.deinit();
@@ -632,9 +632,9 @@ const TestShaper = struct {
 
 /// Helper to return a fully initialized shaper.
 fn testShaper(alloc: Allocator) !TestShaper {
-    const testFont = @import("test.zig").fontRegular;
-    const testEmoji = @import("test.zig").fontEmoji;
-    const testEmojiText = @import("test.zig").fontEmojiText;
+    const testFont = @import("../test.zig").fontRegular;
+    const testEmoji = @import("../test.zig").fontEmoji;
+    const testEmojiText = @import("../test.zig").fontEmojiText;
 
     var lib = try Library.init();
     errdefer lib.deinit();
@@ -653,10 +653,10 @@ fn testShaper(alloc: Allocator) !TestShaper {
     try cache_ptr.group.addFace(alloc, .regular, DeferredFace.initLoaded(try Face.init(lib, testEmoji, .{ .points = 12 })));
     try cache_ptr.group.addFace(alloc, .regular, DeferredFace.initLoaded(try Face.init(lib, testEmojiText, .{ .points = 12 })));
 
-    var cell_buf = try alloc.alloc(Cell, 80);
+    var cell_buf = try alloc.alloc(Shaper.Cell, 80);
     errdefer alloc.free(cell_buf);
 
-    var shaper = try init(cell_buf);
+    var shaper = try Shaper.init(cell_buf);
     errdefer shaper.deinit();
 
     return TestShaper{