@fairyhunter13/opentui-core 0.1.113 → 0.1.114

package/src/zig/tests/utf8_wcwidth_cursor_test.zig

@@ -0,0 +1,267 @@
+const std = @import("std");
+const testing = std.testing;
+const utf8 = @import("../utf8.zig");
+
+test "wcwidth: cursor movement through emoji with skin tone" {
+    const text = "👋🏿"; // Wave + dark skin tone = 4 columns
+
+    const width_wave = utf8.getWidthAt(text, 0, 4, .wcwidth);
+    try testing.expectEqual(@as(u32, 2), width_wave);
+
+    const width_skin = utf8.getWidthAt(text, 4, 4, .wcwidth);
+    try testing.expectEqual(@as(u32, 2), width_skin);
+
+    const total = utf8.calculateTextWidth(text, 4, false, .wcwidth);
+    try testing.expectEqual(@as(u32, 4), total);
+}
+
+test "wcwidth: cursor movement through ZWJ sequence" {
+    const text = "👩‍🚀"; // Woman + ZWJ + Rocket = 4 columns (2+0+2)
+
+    const total = utf8.calculateTextWidth(text, 4, false, .wcwidth);
+    try testing.expectEqual(@as(u32, 4), total);
+
+    const width_woman = utf8.getWidthAt(text, 0, 4, .wcwidth);
+    try testing.expectEqual(@as(u32, 2), width_woman);
+
+    const width_zwj = utf8.getWidthAt(text, 4, 4, .wcwidth);
+    try testing.expectEqual(@as(u32, 0), width_zwj);
+
+    const width_rocket = utf8.getWidthAt(text, 7, 4, .wcwidth);
+    try testing.expectEqual(@as(u32, 2), width_rocket);
+}
+
+test "wcwidth: cursor movement through family emoji" {
+    const text = "👨‍👩‍👧"; // Man + ZWJ + Woman + ZWJ + Girl = 6 columns (2+0+2+0+2)
+
+    const total = utf8.calculateTextWidth(text, 4, false, .wcwidth);
+    try testing.expectEqual(@as(u32, 6), total);
+
+    const width_man = utf8.getWidthAt(text, 0, 4, .wcwidth);
+    try testing.expectEqual(@as(u32, 2), width_man);
+
+    const width_zwj1 = utf8.getWidthAt(text, 4, 4, .wcwidth);
+    try testing.expectEqual(@as(u32, 0), width_zwj1);
+
+    const width_woman = utf8.getWidthAt(text, 7, 4, .wcwidth);
+    try testing.expectEqual(@as(u32, 2), width_woman);
+
+    const width_zwj2 = utf8.getWidthAt(text, 11, 4, .wcwidth);
+    try testing.expectEqual(@as(u32, 0), width_zwj2);
+
+    const width_girl = utf8.getWidthAt(text, 14, 4, .wcwidth);
+    try testing.expectEqual(@as(u32, 2), width_girl);
+}
+
+test "wcwidth: getPrevGraphemeStart through emoji with skin tone" {
+    const text = "A👋🏿B"; // A(1) + 👋(2) + 🏿(2) + B(1) = 6 columns
+
+    const r_end = utf8.getPrevGraphemeStart(text, text.len, 4, .wcwidth);
+    try testing.expect(r_end != null);
+    try testing.expectEqual(@as(u32, 1), r_end.?.width);
+
+    const r_b = utf8.getPrevGraphemeStart(text, r_end.?.start_offset, 4, .wcwidth);
+    try testing.expect(r_b != null);
+    try testing.expectEqual(@as(u32, 2), r_b.?.width);
+
+    const r_skin = utf8.getPrevGraphemeStart(text, r_b.?.start_offset, 4, .wcwidth);
+    try testing.expect(r_skin != null);
+    try testing.expectEqual(@as(u32, 2), r_skin.?.width);
+
+    const r_wave = utf8.getPrevGraphemeStart(text, r_skin.?.start_offset, 4, .wcwidth);
+    try testing.expect(r_wave != null);
+    try testing.expectEqual(@as(u32, 1), r_wave.?.width);
+}
+
+test "wcwidth: getPrevGraphemeStart through ZWJ sequence" {
+    const text = "X👩‍🚀Y"; // X(1) + 👩(2) + ZWJ(0) + 🚀(2) + Y(1) = 6 columns
+
+    const r_end = utf8.getPrevGraphemeStart(text, text.len, 4, .wcwidth);
+    try testing.expect(r_end != null);
+    try testing.expectEqual(@as(u32, 1), r_end.?.width);
+
+    const r_y = utf8.getPrevGraphemeStart(text, r_end.?.start_offset, 4, .wcwidth);
+    try testing.expect(r_y != null);
+    try testing.expectEqual(@as(u32, 2), r_y.?.width);
+
+    const r_rocket = utf8.getPrevGraphemeStart(text, r_y.?.start_offset, 4, .wcwidth);
+    try testing.expect(r_rocket != null);
+    try testing.expectEqual(@as(u32, 2), r_rocket.?.width);
+
+    const r_woman = utf8.getPrevGraphemeStart(text, r_rocket.?.start_offset, 4, .wcwidth);
+    try testing.expect(r_woman != null);
+    try testing.expectEqual(@as(u32, 1), r_woman.?.width);
+}
+
+test "wcwidth: findPosByWidth through emoji sequence" {
+    const text = "AB👋🏿CD"; // A(1) B(1) 👋(2) 🏿(2) C(1) D(1) = 8 columns
+
+    const pos_start = utf8.findPosByWidth(text, 3, 4, false, false, .wcwidth);
+    try testing.expectEqual(@as(u32, 2), pos_start.byte_offset);
+
+    const pos_end = utf8.findPosByWidth(text, 3, 4, false, true, .wcwidth);
+    try testing.expectEqual(@as(u32, 6), pos_end.byte_offset);
+}
+
+test "wcwidth: findWrapPosByWidth through emoji" {
+    const text = "Hi👋🏿Bye"; // H(1) i(1) 👋(2) 🏿(2) B(1) y(1) e(1) = 10 columns
+
+    const wrap_4 = utf8.findWrapPosByWidth(text, 4, 4, false, .wcwidth);
+    try testing.expectEqual(@as(u32, 6), wrap_4.byte_offset);
+    try testing.expectEqual(@as(u32, 4), wrap_4.columns_used);
+
+    const wrap_5 = utf8.findWrapPosByWidth(text, 5, 4, false, .wcwidth);
+    try testing.expectEqual(@as(u32, 6), wrap_5.byte_offset);
+    try testing.expectEqual(@as(u32, 4), wrap_5.columns_used);
+
+    const wrap_6 = utf8.findWrapPosByWidth(text, 6, 4, false, .wcwidth);
+    try testing.expectEqual(@as(u32, 10), wrap_6.byte_offset);
+    try testing.expectEqual(@as(u32, 6), wrap_6.columns_used);
+}
+
+test "wcwidth: combining marks have zero width" {
+    const text = "e\u{0301}"; // e + combining acute
+
+    const width_e = utf8.getWidthAt(text, 0, 4, .wcwidth);
+    try testing.expectEqual(@as(u32, 1), width_e);
+
+    const width_combining = utf8.getWidthAt(text, 1, 4, .wcwidth);
+    try testing.expectEqual(@as(u32, 0), width_combining);
+
+    const total = utf8.calculateTextWidth(text, 4, false, .wcwidth);
+    try testing.expectEqual(@as(u32, 1), total);
+}
+
+test "wcwidth: CJK characters have width 2" {
+    const text = "你好世界"; // 4 CJK characters
+
+    const total = utf8.calculateTextWidth(text, 4, false, .wcwidth);
+    try testing.expectEqual(@as(u32, 8), total);
+
+    const width_char1 = utf8.getWidthAt(text, 0, 4, .wcwidth);
+    try testing.expectEqual(@as(u32, 2), width_char1);
+
+    const width_char2 = utf8.getWidthAt(text, 3, 4, .wcwidth);
+    try testing.expectEqual(@as(u32, 2), width_char2);
+}
+
+test "wcwidth: variation selectors have zero width" {
+    const text = "☺\u{FE0F}"; // Smiling face + VS16
+
+    const width_face = utf8.getWidthAt(text, 0, 4, .wcwidth);
+    try testing.expectEqual(@as(u32, 1), width_face);
+
+    const width_vs = utf8.getWidthAt(text, 3, 4, .wcwidth);
+    try testing.expectEqual(@as(u32, 0), width_vs);
+
+    const total = utf8.calculateTextWidth(text, 4, false, .wcwidth);
+    try testing.expectEqual(@as(u32, 1), total);
+}
+
+test "wcwidth: flag emoji counts both regional indicators" {
+    const text = "🇺🇸"; // US flag (two regional indicators)
+
+    const width_ri1 = utf8.getWidthAt(text, 0, 4, .wcwidth);
+    try testing.expectEqual(@as(u32, 1), width_ri1);
+
+    const width_ri2 = utf8.getWidthAt(text, 4, 4, .wcwidth);
+    try testing.expectEqual(@as(u32, 1), width_ri2);
+
+    const total = utf8.calculateTextWidth(text, 4, false, .wcwidth);
+    try testing.expectEqual(@as(u32, 2), total);
+}
+
+test "wcwidth: mixed content with cursor movement" {
+    const text = "A👋🏿B世C"; // A(1) 👋(2) 🏿(2) B(1) 世(2) C(1) = 9 columns
+
+    const r_end = utf8.getPrevGraphemeStart(text, text.len, 4, .wcwidth);
+    try testing.expect(r_end != null);
+    try testing.expectEqual(@as(u32, 1), r_end.?.width);
+
+    const r_cjk = utf8.getPrevGraphemeStart(text, r_end.?.start_offset, 4, .wcwidth);
+    try testing.expect(r_cjk != null);
+    try testing.expectEqual(@as(u32, 2), r_cjk.?.width);
+
+    const r_b = utf8.getPrevGraphemeStart(text, r_cjk.?.start_offset, 4, .wcwidth);
+    try testing.expect(r_b != null);
+    try testing.expectEqual(@as(u32, 1), r_b.?.width);
+
+    const r_skin = utf8.getPrevGraphemeStart(text, r_b.?.start_offset, 4, .wcwidth);
+    try testing.expect(r_skin != null);
+    try testing.expectEqual(@as(u32, 2), r_skin.?.width);
+
+    const r_wave = utf8.getPrevGraphemeStart(text, r_skin.?.start_offset, 4, .wcwidth);
+    try testing.expect(r_wave != null);
+    try testing.expectEqual(@as(u32, 2), r_wave.?.width);
+
+    const r_a = utf8.getPrevGraphemeStart(text, r_wave.?.start_offset, 4, .wcwidth);
+    try testing.expect(r_a != null);
+    try testing.expectEqual(@as(u32, 1), r_a.?.width);
+}
+
+test "wcwidth: findGraphemeInfo with emoji" {
+    var result: std.ArrayListUnmanaged(utf8.GraphemeInfo) = .{};
+    defer result.deinit(testing.allocator);
+
+    const text = "👋🏿"; // Wave + skin tone modifier
+    try utf8.findGraphemeInfo(text, 4, false, .wcwidth, testing.allocator, &result);
+
+    try testing.expectEqual(@as(usize, 1), result.items.len);
+
+    try testing.expectEqual(@as(u32, 0), result.items[0].byte_offset);
+    try testing.expectEqual(@as(u8, 8), result.items[0].byte_len);
+    try testing.expectEqual(@as(u8, 4), result.items[0].width);
+}
+
+test "wcwidth: findGraphemeInfo with ZWJ sequence" {
+    var result: std.ArrayListUnmanaged(utf8.GraphemeInfo) = .{};
+    defer result.deinit(testing.allocator);
+
+    const text = "👩‍🚀"; // Woman + ZWJ + Rocket
+    try utf8.findGraphemeInfo(text, 4, false, .wcwidth, testing.allocator, &result);
+
+    try testing.expectEqual(@as(usize, 1), result.items.len);
+
+    try testing.expectEqual(@as(u32, 0), result.items[0].byte_offset);
+    try testing.expectEqual(@as(u8, 11), result.items[0].byte_len);
+    try testing.expectEqual(@as(u8, 4), result.items[0].width);
+}
+
+test "wcwidth: findGraphemeInfo with combining marks" {
+    var result: std.ArrayListUnmanaged(utf8.GraphemeInfo) = .{};
+    defer result.deinit(testing.allocator);
+
+    const text = "e\u{0301}"; // e + combining acute
+    try utf8.findGraphemeInfo(text, 4, false, .wcwidth, testing.allocator, &result);
+
+    try testing.expectEqual(@as(usize, 1), result.items.len);
+    try testing.expectEqual(@as(u32, 0), result.items[0].byte_offset);
+    try testing.expectEqual(@as(u8, 3), result.items[0].byte_len);
+    try testing.expectEqual(@as(u8, 1), result.items[0].width);
+}
+
+test "wcwidth: tab width handling" {
+    const text = "A\tB"; // A + tab + B
+
+    const total = utf8.calculateTextWidth(text, 4, false, .wcwidth);
+    try testing.expectEqual(@as(u32, 6), total);
+
+    const tab_width = utf8.getWidthAt(text, 1, 4, .wcwidth);
+    try testing.expectEqual(@as(u32, 4), tab_width);
+}
+
+test "wcwidth: boundary at wide character" {
+    const text = "世X"; // 世(2) X(1) = 3 columns
+
+    const pos_start = utf8.findPosByWidth(text, 2, 4, false, false, .wcwidth);
+    try testing.expectEqual(@as(u32, 3), pos_start.byte_offset);
+    try testing.expectEqual(@as(u32, 2), pos_start.columns_used);
+
+    const pos_end = utf8.findPosByWidth(text, 2, 4, false, true, .wcwidth);
+    try testing.expectEqual(@as(u32, 3), pos_end.byte_offset);
+    try testing.expectEqual(@as(u32, 2), pos_end.columns_used);
+
+    const pos_3 = utf8.findPosByWidth(text, 3, 4, false, true, .wcwidth);
+    try testing.expectEqual(@as(u32, 4), pos_3.byte_offset);
+    try testing.expectEqual(@as(u32, 3), pos_3.columns_used);
+}

package/src/zig/tests/utf8_wcwidth_test.zig

@@ -0,0 +1,357 @@
+const std = @import("std");
+const testing = std.testing;
+const utf8 = @import("../utf8.zig");
+
+test "findGraphemeInfo wcwidth: empty string" {
+    var result: std.ArrayListUnmanaged(utf8.GraphemeInfo) = .{};
+    defer result.deinit(testing.allocator);
+
+    try utf8.findGraphemeInfo("", 4, false, .wcwidth, testing.allocator, &result);
+    try testing.expectEqual(@as(usize, 0), result.items.len);
+}
+
+test "findGraphemeInfo wcwidth: ASCII-only returns empty" {
+    var result: std.ArrayListUnmanaged(utf8.GraphemeInfo) = .{};
+    defer result.deinit(testing.allocator);
+
+    try utf8.findGraphemeInfo("hello world", 4, true, .wcwidth, testing.allocator, &result);
+    try testing.expectEqual(@as(usize, 0), result.items.len);
+}
+
+test "findGraphemeInfo wcwidth: ASCII with tab" {
+    var result: std.ArrayListUnmanaged(utf8.GraphemeInfo) = .{};
+    defer result.deinit(testing.allocator);
+
+    try utf8.findGraphemeInfo("hello\tworld", 4, false, .wcwidth, testing.allocator, &result);
+
+    // Should have one entry for the tab
+    try testing.expectEqual(@as(usize, 1), result.items.len);
+    try testing.expectEqual(@as(u32, 5), result.items[0].byte_offset);
+    try testing.expectEqual(@as(u8, 1), result.items[0].byte_len);
+    try testing.expectEqual(@as(u8, 4), result.items[0].width);
+    try testing.expectEqual(@as(u32, 5), result.items[0].col_offset);
+}
+
+test "findGraphemeInfo wcwidth: CJK characters" {
+    var result: std.ArrayListUnmanaged(utf8.GraphemeInfo) = .{};
+    defer result.deinit(testing.allocator);
+
+    const text = "hello世界";
+    try utf8.findGraphemeInfo(text, 4, false, .wcwidth, testing.allocator, &result);
+
+    // Should have two entries for the CJK characters (each codepoint separately)
+    try testing.expectEqual(@as(usize, 2), result.items.len);
+
+    // First CJK char '世' at byte 5
+    try testing.expectEqual(@as(u32, 5), result.items[0].byte_offset);
+    try testing.expectEqual(@as(u8, 3), result.items[0].byte_len);
+    try testing.expectEqual(@as(u8, 2), result.items[0].width);
+    try testing.expectEqual(@as(u32, 5), result.items[0].col_offset);
+
+    // Second CJK char '界' at byte 8
+    try testing.expectEqual(@as(u32, 8), result.items[1].byte_offset);
+    try testing.expectEqual(@as(u8, 3), result.items[1].byte_len);
+    try testing.expectEqual(@as(u8, 2), result.items[1].width);
+    try testing.expectEqual(@as(u32, 7), result.items[1].col_offset);
+}
+
+test "findGraphemeInfo wcwidth: emoji with skin tone - single grapheme cluster" {
+    var result: std.ArrayListUnmanaged(utf8.GraphemeInfo) = .{};
+    defer result.deinit(testing.allocator);
+
+    const text = "👋🏿"; // Wave + skin tone modifier
+    try utf8.findGraphemeInfo(text, 4, false, .wcwidth, testing.allocator, &result);
+
+    try testing.expectEqual(@as(usize, 1), result.items.len);
+
+    try testing.expectEqual(@as(u32, 0), result.items[0].byte_offset);
+    try testing.expectEqual(@as(u8, 8), result.items[0].byte_len);
+    try testing.expectEqual(@as(u8, 4), result.items[0].width);
+}
+
+test "findGraphemeInfo wcwidth: emoji with ZWJ - single grapheme cluster" {
+    var result: std.ArrayListUnmanaged(utf8.GraphemeInfo) = .{};
+    defer result.deinit(testing.allocator);
+
+    const text = "👩‍🚀"; // Woman + ZWJ + Rocket (11 bytes total)
+    try utf8.findGraphemeInfo(text, 4, false, .wcwidth, testing.allocator, &result);
+
+    try testing.expectEqual(@as(usize, 1), result.items.len);
+
+    try testing.expectEqual(@as(u8, 11), result.items[0].byte_len);
+    try testing.expectEqual(@as(u8, 4), result.items[0].width);
+}
+
+test "findGraphemeInfo wcwidth: combining mark - part of base grapheme" {
+    var result: std.ArrayListUnmanaged(utf8.GraphemeInfo) = .{};
+    defer result.deinit(testing.allocator);
+
+    const text = "e\u{0301}test"; // e + combining acute accent + test
+    try utf8.findGraphemeInfo(text, 4, false, .wcwidth, testing.allocator, &result);
+
+    try testing.expectEqual(@as(usize, 1), result.items.len);
+    try testing.expectEqual(@as(u32, 0), result.items[0].byte_offset);
+    try testing.expectEqual(@as(u8, 3), result.items[0].byte_len);
+    try testing.expectEqual(@as(u8, 1), result.items[0].width);
+}
+
+test "findGraphemeInfo wcwidth vs unicode: emoji with skin tone" {
+    var result_wcwidth: std.ArrayListUnmanaged(utf8.GraphemeInfo) = .{};
+    defer result_wcwidth.deinit(testing.allocator);
+    var result_unicode: std.ArrayListUnmanaged(utf8.GraphemeInfo) = .{};
+    defer result_unicode.deinit(testing.allocator);
+
+    const text = "Hi👋🏿Bye";
+
+    try utf8.findGraphemeInfo(text, 4, false, .wcwidth, testing.allocator, &result_wcwidth);
+    try utf8.findGraphemeInfo(text, 4, false, .unicode, testing.allocator, &result_unicode);
+
+    try testing.expectEqual(@as(usize, 1), result_wcwidth.items.len);
+    try testing.expectEqual(@as(usize, 1), result_unicode.items.len);
+
+    try testing.expectEqual(@as(u32, 2), result_wcwidth.items[0].byte_offset);
+    try testing.expectEqual(@as(u8, 8), result_wcwidth.items[0].byte_len);
+
+    try testing.expectEqual(@as(u32, 2), result_unicode.items[0].byte_offset);
+    try testing.expectEqual(@as(u8, 8), result_unicode.items[0].byte_len);
+
+    try testing.expectEqual(@as(u8, 4), result_wcwidth.items[0].width);
+    try testing.expectEqual(@as(u8, 2), result_unicode.items[0].width);
+}
+
+test "findGraphemeInfo wcwidth vs unicode: flag emoji" {
+    var result_wcwidth: std.ArrayListUnmanaged(utf8.GraphemeInfo) = .{};
+    defer result_wcwidth.deinit(testing.allocator);
+    var result_unicode: std.ArrayListUnmanaged(utf8.GraphemeInfo) = .{};
+    defer result_unicode.deinit(testing.allocator);
+
+    const text = "🇺🇸"; // US flag (two regional indicators)
+
+    try utf8.findGraphemeInfo(text, 4, false, .wcwidth, testing.allocator, &result_wcwidth);
+    try utf8.findGraphemeInfo(text, 4, false, .unicode, testing.allocator, &result_unicode);
+
+    try testing.expectEqual(@as(usize, 1), result_wcwidth.items.len);
+    try testing.expectEqual(@as(usize, 1), result_unicode.items.len);
+
+    try testing.expectEqual(@as(u8, 2), result_wcwidth.items[0].width);
+    try testing.expectEqual(@as(u8, 2), result_unicode.items[0].width);
+}
+
+// ============================================================================
+// WIDTH CALCULATION TESTS - WCWIDTH MODE
+// ============================================================================
+
+test "getWidthAt wcwidth: combining mark has zero width" {
+    const text = "e\u{0301}"; // e + combining acute accent
+
+    // In wcwidth mode, combining mark is a separate codepoint
+    const width_e = utf8.getWidthAt(text, 0, 8, .wcwidth);
+    try testing.expectEqual(@as(u32, 1), width_e); // Just 'e'
+
+    const width_combining = utf8.getWidthAt(text, 1, 8, .wcwidth);
+    try testing.expectEqual(@as(u32, 0), width_combining); // Combining mark has width 0
+}
+
+test "calculateTextWidth wcwidth: emoji with skin tone counts both codepoints" {
+    const text = "👋🏿"; // Wave + dark skin tone
+
+    const width_wcwidth = utf8.calculateTextWidth(text, 4, false, .wcwidth);
+    const width_unicode = utf8.calculateTextWidth(text, 4, false, .unicode);
+
+    // wcwidth: counts both codepoints (2 + 2 = 4)
+    try testing.expectEqual(@as(u32, 4), width_wcwidth);
+
+    // unicode: single grapheme cluster (width 2)
+    try testing.expectEqual(@as(u32, 2), width_unicode);
+}
+
+test "calculateTextWidth wcwidth: flag emoji counts both RIs" {
+    const text = "🇺🇸"; // US flag
+
+    const width_wcwidth = utf8.calculateTextWidth(text, 4, false, .wcwidth);
+    const width_unicode = utf8.calculateTextWidth(text, 4, false, .unicode);
+
+    // wcwidth: counts both regional indicators (1 + 1 = 2)
+    try testing.expectEqual(@as(u32, 2), width_wcwidth);
+
+    // unicode: single flag grapheme (width 2)
+    try testing.expectEqual(@as(u32, 2), width_unicode);
+}
+
+// ============================================================================
+// FIND WRAP POS BY WIDTH TESTS - WCWIDTH MODE
+// ============================================================================
+
+test "findWrapPosByWidth wcwidth: emoji with skin tone stops earlier" {
+    const text = "Hi👋🏿Bye"; // H(1) i(1) wave(2) skin(2) B(1) y(1) e(1) = 10 cols wcwidth
+
+    const result_wcwidth = utf8.findWrapPosByWidth(text, 4, 4, false, .wcwidth);
+    const result_unicode = utf8.findWrapPosByWidth(text, 4, 4, false, .unicode);
+
+    // wcwidth: stops after "Hi👋" = 4 columns (1+1+2)
+    try testing.expectEqual(@as(u32, 6), result_wcwidth.byte_offset);
+    try testing.expectEqual(@as(u32, 4), result_wcwidth.columns_used);
+
+    // unicode: stops after "Hi👋🏿" = 4 columns (1+1+2 for whole grapheme)
+    try testing.expectEqual(@as(u32, 10), result_unicode.byte_offset);
+    try testing.expectEqual(@as(u32, 4), result_unicode.columns_used);
+}
+
+test "findPosByWidth wcwidth: emoji boundary behavior" {
+    const text = "AB👋🏿CD"; // A(1) B(1) wave(2) skin(2) C(1) D(1)
+
+    // With include_start_before=false (selection start)
+    const start3 = utf8.findPosByWidth(text, 3, 4, false, false, .wcwidth);
+    // wcwidth: stops after "AB" at 2 columns (wave would exceed)
+    try testing.expectEqual(@as(u32, 2), start3.byte_offset);
+
+    // With include_start_before=true (selection end)
+    const end3 = utf8.findPosByWidth(text, 3, 4, false, true, .wcwidth);
+    // wcwidth: includes wave since it starts at column 2 which is < 3
+    try testing.expectEqual(@as(u32, 6), end3.byte_offset);
+    try testing.expectEqual(@as(u32, 4), end3.columns_used);
+}
+
+test "getPrevGraphemeStart wcwidth: each codepoint separate" {
+    const text = "Hi👋🏿";
+
+    // From end of text (after skin tone)
+    const r_end = utf8.getPrevGraphemeStart(text, text.len, 4, .wcwidth);
+    try testing.expect(r_end != null);
+    try testing.expectEqual(@as(usize, 6), r_end.?.start_offset); // Skin tone starts at byte 6
+    try testing.expectEqual(@as(u32, 2), r_end.?.width);
+
+    // From start of skin tone (byte 6)
+    const r_wave = utf8.getPrevGraphemeStart(text, 6, 4, .wcwidth);
+    try testing.expect(r_wave != null);
+    try testing.expectEqual(@as(usize, 2), r_wave.?.start_offset); // Wave starts at byte 2
+    try testing.expectEqual(@as(u32, 2), r_wave.?.width);
+}
+
+// ============================================================================
+// ADDITIONAL COMPREHENSIVE WCWIDTH TESTS
+// ============================================================================
+
+test "wcwidth: zero-width characters are handled correctly" {
+    // ZWJ (Zero Width Joiner) should have width 0
+    const text_zwj = "\u{200D}";
+    const width_zwj = utf8.calculateTextWidth(text_zwj, 4, false, .wcwidth);
+    try testing.expectEqual(@as(u32, 0), width_zwj);
+
+    // Combining marks should have width 0
+    const text_combining = "e\u{0301}"; // e + combining acute
+    const width = utf8.calculateTextWidth(text_combining, 4, false, .wcwidth);
+    try testing.expectEqual(@as(u32, 1), width); // Only 'e' contributes
+}
+
+test "wcwidth: variation selectors" {
+    // VS15 (text presentation) and VS16 (emoji presentation)
+    const text_vs16 = "☺\u{FE0F}"; // Smiling face + VS16
+    const width_vs16 = utf8.calculateTextWidth(text_vs16, 4, false, .wcwidth);
+    try testing.expectEqual(@as(u32, 1), width_vs16); // Smiling face (1) + VS16 (0) = 1
+}
+
+test "wcwidth: regional indicators counted separately" {
+    // Each regional indicator should contribute width 1
+    const text = "🇺🇸"; // US flag = two regional indicators
+    const width = utf8.calculateTextWidth(text, 4, false, .wcwidth);
+    try testing.expectEqual(@as(u32, 2), width); // Each RI has width 1
+}
+
+test "wcwidth: emoji ZWJ sequences split" {
+    // Woman astronaut = woman + ZWJ + rocket
+    const text = "👩‍🚀";
+    const width = utf8.calculateTextWidth(text, 4, false, .wcwidth);
+    // Woman (2) + ZWJ (0) + Rocket (2) = 4
+    try testing.expectEqual(@as(u32, 4), width);
+}
+
+test "wcwidth: family emoji split into components" {
+    // Family emoji with ZWJ
+    const text = "👨‍👩‍👧"; // Man + ZWJ + Woman + ZWJ + Girl
+    const width = utf8.calculateTextWidth(text, 4, false, .wcwidth);
+    // Man (2) + ZWJ (0) + Woman (2) + ZWJ (0) + Girl (2) = 6
+    try testing.expectEqual(@as(u32, 6), width);
+}
+
+test "wcwidth: skin tone modifiers counted separately" {
+    // Emoji with skin tone modifier
+    const text = "👋🏻"; // Wave + light skin tone
+    const width = utf8.calculateTextWidth(text, 4, false, .wcwidth);
+    // Wave (2) + Skin tone modifier (2) = 4
+    try testing.expectEqual(@as(u32, 4), width);
+}
+
+test "wcwidth: CJK characters have width 2" {
+    const text = "你好世界"; // 4 CJK characters
+    const width = utf8.calculateTextWidth(text, 4, false, .wcwidth);
+    try testing.expectEqual(@as(u32, 8), width); // 4 * 2 = 8
+}
+
+test "wcwidth: mixed ASCII and emoji" {
+    const text = "Hello👋World";
+    // H(1) e(1) l(1) l(1) o(1) 👋(2) W(1) o(1) r(1) l(1) d(1) = 12
+    const width = utf8.calculateTextWidth(text, 4, false, .wcwidth);
+    try testing.expectEqual(@as(u32, 12), width);
+}
+
+test "wcwidth: findWrapPosByWidth with ZWJ sequences" {
+    const text = "AB👩‍🚀CD"; // A(1) B(1) woman(2) ZWJ(0) rocket(2) C(1) D(1) = 8
+
+    // Should wrap after woman emoji (before ZWJ)
+    const result = utf8.findWrapPosByWidth(text, 4, 4, false, .wcwidth);
+    try testing.expectEqual(@as(u32, 6), result.byte_offset); // After woman emoji
+    try testing.expectEqual(@as(u32, 4), result.columns_used);
+}
+
+test "wcwidth: findPosByWidth with skin tone modifier" {
+    const text = "AB👋🏻CD"; // A(1) B(1) wave(2) skin(2) C(1) D(1) = 8
+
+    // With include_start_before=false, include codepoints that end at or before max_columns
+    // Wave ends at column 4, which is at max_columns=4, so it's included
+    const start4 = utf8.findPosByWidth(text, 4, 4, false, false, .wcwidth);
+    try testing.expectEqual(@as(u32, 6), start4.byte_offset); // After wave
+    try testing.expectEqual(@as(u32, 4), start4.columns_used);
+
+    // With include_start_before=true, include codepoints that start before max_columns
+    // Wave starts at column 2 which is < 4, so it's included
+    const end4 = utf8.findPosByWidth(text, 4, 4, false, true, .wcwidth);
+    try testing.expectEqual(@as(u32, 6), end4.byte_offset); // After wave
+    try testing.expectEqual(@as(u32, 4), end4.columns_used);
+}
+
+test "wcwidth: getWidthAt with combining marks" {
+    const text = "e\u{0301}test"; // e + combining acute
+
+    // Width at 'e' should be 1
+    const width_e = utf8.getWidthAt(text, 0, 4, .wcwidth);
+    try testing.expectEqual(@as(u32, 1), width_e);
+
+    // Width at combining mark should be 0 (but next non-zero is 't')
+    const width_combining = utf8.getWidthAt(text, 1, 4, .wcwidth);
+    try testing.expectEqual(@as(u32, 0), width_combining);
+}
+
+test "wcwidth: getPrevGraphemeStart with ZWJ sequence" {
+    const text = "AB👩‍🚀"; // A B woman ZWJ rocket
+
+    // From end (after rocket)
+    const r1 = utf8.getPrevGraphemeStart(text, text.len, 4, .wcwidth);
+    try testing.expect(r1 != null);
+    // Should point to rocket emoji (after ZWJ)
+    try testing.expectEqual(@as(u32, 2), r1.?.width);
+
+    // From rocket start, should go to ZWJ
+    const r2 = utf8.getPrevGraphemeStart(text, r1.?.start_offset, 4, .wcwidth);
+    try testing.expect(r2 != null);
+
+    // Eventually should reach woman emoji
+    var pos = text.len;
+    var count: usize = 0;
+    while (utf8.getPrevGraphemeStart(text, pos, 4, .wcwidth)) |prev| {
+        pos = prev.start_offset;
+        count += 1;
+        if (count > 10) break; // Safety limit
+    }
+    try testing.expect(count >= 3); // At least rocket, ZWJ, woman
+}