linecraft 0.1.0

package/src/ts/types/ffi-napi.d.ts

@@ -0,0 +1,11 @@
+declare module 'ffi-napi' {
+  export interface Library {
+    [key: string]: (...args: any[]) => any;
+  }
+  
+  export function Library(
+    path: string,
+    functions: Record<string, [string, string[]]>
+  ): Library;
+}
+

package/src/ts/types/ref-napi.d.ts

@@ -0,0 +1,5 @@
+declare module 'ref-napi' {
+  export function alloc(size: number): Buffer;
+  export function alloc(type: string, size: number): Buffer;
+}
+

package/src/ts/types.ts

@@ -0,0 +1,53 @@
+export type Color = 
+  | 'black'
+  | 'red'
+  | 'green'
+  | 'yellow'
+  | 'blue'
+  | 'magenta'
+  | 'cyan'
+  | 'white'
+  | 'brightBlack'
+  | 'brightRed'
+  | 'brightGreen'
+  | 'brightYellow'
+  | 'brightBlue'
+  | 'brightMagenta'
+  | 'brightCyan'
+  | 'brightWhite';
+
+export interface TextStyle {
+  color?: Color;
+  backgroundColor?: Color;
+  bold?: boolean;
+  italic?: boolean;
+  underline?: boolean;
+}
+
+export interface LineContent {
+  text: string;
+  style?: TextStyle;
+}
+
+export interface RegionOptions {
+  x?: number; // Default: 0
+  y?: number; // Default: 0
+  width?: number; // Default: terminal width
+  height?: number; // Default: 1 (expands as needed)
+}
+
+export interface ProgressBarOptions {
+  label?: string;
+  width?: number;
+  style?: {
+    complete?: string;
+    incomplete?: string;
+    brackets?: [string, string];
+  };
+}
+
+export interface SpinnerOptions {
+  frames?: string[];
+  interval?: number;
+}
+

package/src/ts/utils/colors.ts

@@ -0,0 +1,72 @@
+import { Color, TextStyle } from '../types.js';
+
+const ANSI_COLORS: Record<Color, string> = {
+  black: '30',
+  red: '31',
+  green: '32',
+  yellow: '33',
+  blue: '34',
+  magenta: '35',
+  cyan: '36',
+  white: '37',
+  brightBlack: '90',
+  brightRed: '91',
+  brightGreen: '92',
+  brightYellow: '93',
+  brightBlue: '94',
+  brightMagenta: '95',
+  brightCyan: '96',
+  brightWhite: '97',
+};
+
+const ANSI_BG_COLORS: Record<Color, string> = {
+  black: '40',
+  red: '41',
+  green: '42',
+  yellow: '43',
+  blue: '44',
+  magenta: '45',
+  cyan: '46',
+  white: '47',
+  brightBlack: '100',
+  brightRed: '101',
+  brightGreen: '102',
+  brightYellow: '103',
+  brightBlue: '104',
+  brightMagenta: '105',
+  brightCyan: '106',
+  brightWhite: '107',
+};
+
+export function applyStyle(text: string, style?: TextStyle): string {
+  if (!style) return text;
+
+  const codes: string[] = [];
+
+  if (style.color) {
+    codes.push(ANSI_COLORS[style.color]);
+  }
+
+  if (style.backgroundColor) {
+    codes.push(ANSI_BG_COLORS[style.backgroundColor]);
+  }
+
+  if (style.bold) {
+    codes.push('1');
+  }
+
+  if (style.italic) {
+    codes.push('3');
+  }
+
+  if (style.underline) {
+    codes.push('4');
+  }
+
+  if (codes.length === 0) {
+    return text;
+  }
+
+  return `\x1b[${codes.join(';')}m${text}\x1b[0m`;
+}
+

package/src/zig/ansi.zig

@@ -0,0 +1,21 @@
+// ANSI escape code generation
+const std = @import("std");
+const Allocator = std.mem.Allocator;
+
+pub fn move_cursor_to(allocator: Allocator, x: u32, y: u32) ![]u8 {
+    return try std.fmt.allocPrint(allocator, "\x1b[{d};{d}H", .{ y, x });
+}
+
+pub fn move_cursor_up(allocator: Allocator, n: u32) ![]u8 {
+    return try std.fmt.allocPrint(allocator, "\x1b[{d}A", .{n});
+}
+
+pub fn move_cursor_down(allocator: Allocator, n: u32) ![]u8 {
+    return try std.fmt.allocPrint(allocator, "\x1b[{d}B", .{n});
+}
+
+pub const CLEAR_LINE = "\x1b[2K";
+pub const HIDE_CURSOR = "\x1b[?25l";
+pub const SHOW_CURSOR = "\x1b[?25h";
+pub const SAVE_CURSOR = "\x1b[s";
+pub const RESTORE_CURSOR = "\x1b[u";

package/src/zig/buffer.zig

@@ -0,0 +1,37 @@
+// Render buffer for batching ANSI operations
+const std = @import("std");
+const Allocator = std.mem.Allocator;
+
+pub const RenderBuffer = struct {
+    data: std.ArrayList(u8),
+    allocator: Allocator,
+    stdout: std.fs.File,
+
+    pub fn init(allocator: Allocator, stdout: std.fs.File) RenderBuffer {
+        return .{
+            .data = std.ArrayList(u8){},
+            .allocator = allocator,
+            .stdout = stdout,
+        };
+    }
+
+    pub fn deinit(self: *RenderBuffer) void {
+        self.data.deinit(self.allocator);
+    }
+
+    pub fn write(self: *RenderBuffer, bytes: []const u8) !void {
+        try self.data.appendSlice(self.allocator, bytes);
+    }
+
+    pub fn flush(self: *RenderBuffer) !void {
+        if (self.data.items.len > 0) {
+            // Write all data
+            try self.stdout.writeAll(self.data.items);
+            self.data.clearRetainingCapacity();
+        }
+    }
+
+    pub fn clear(self: *RenderBuffer) void {
+        self.data.clearRetainingCapacity();
+    }
+};

package/src/zig/diff.zig

@@ -0,0 +1,43 @@
+// Diffing algorithm for efficient updates
+const std = @import("std");
+const Allocator = std.mem.Allocator;
+
+pub const DiffOp = union(enum) {
+    no_change: void,
+    update_line: struct { line: u32, content: []u8 },
+    delete_line: u32,
+    insert_line: struct { line: u32, content: []u8 },
+};
+
+pub fn diff_frames(
+    prev: [][]u8,
+    curr: [][]u8,
+    allocator: Allocator,
+) ![]DiffOp {
+    var ops = std.ArrayList(DiffOp){};
+    errdefer ops.deinit(allocator);
+
+    const max_len = @max(prev.len, curr.len);
+
+    for (0..max_len) |i| {
+        const prev_line = if (i < prev.len) prev[i] else null;
+        const curr_line = if (i < curr.len) curr[i] else null;
+
+        if (prev_line == null and curr_line != null) {
+            // Line inserted
+            try ops.append(allocator, .{ .insert_line = .{ .line = @intCast(i), .content = curr_line.? } });
+        } else if (prev_line != null and curr_line == null) {
+            // Line deleted
+            try ops.append(allocator, .{ .delete_line = @intCast(i) });
+        } else if (prev_line != null and curr_line != null) {
+            // Check if line changed
+            if (!std.mem.eql(u8, prev_line.?, curr_line.?)) {
+                try ops.append(allocator, .{ .update_line = .{ .line = @intCast(i), .content = curr_line.? } });
+            } else {
+                try ops.append(allocator, .no_change);
+            }
+        }
+    }
+
+    return try ops.toOwnedSlice(allocator);
+}

package/src/zig/region.zig

@@ -0,0 +1,292 @@
+// Region management for terminal rendering
+const std = @import("std");
+const Allocator = std.mem.Allocator;
+const ansi = @import("ansi.zig");
+const diff = @import("diff.zig");
+const buffer = @import("buffer.zig");
+const throttle = @import("throttle.zig");
+
+pub const Region = struct {
+    allocator: Allocator,
+    x: u32,
+    y: u32,
+    width: u32,
+    height: u32,
+    pending_frame: std.ArrayList([]u8),
+    previous_frame: std.ArrayList([]u8),
+    render_scheduled: bool,
+    throttle_state: throttle.Throttle,
+    render_buffer: buffer.RenderBuffer,
+    stdout: std.fs.File,
+    disable_rendering: bool = false, // For tests - skip actual rendering
+
+    pub fn init(
+        allocator: Allocator,
+        x: u32,
+        y: u32,
+        width: u32,
+        height: u32,
+        stdout: std.fs.File,
+    ) !Region {
+        var pending = std.ArrayList([]u8){};
+        var previous = std.ArrayList([]u8){};
+
+        // Initialize with empty lines
+        try pending.ensureTotalCapacity(allocator, height);
+        try previous.ensureTotalCapacity(allocator, height);
+        for (0..height) |_| {
+            try pending.append(allocator, try allocator.dupe(u8, ""));
+            try previous.append(allocator, try allocator.dupe(u8, ""));
+        }
+
+        return .{
+            .allocator = allocator,
+            .x = x,
+            .y = y,
+            .width = width,
+            .height = height,
+            .pending_frame = pending,
+            .previous_frame = previous,
+            .render_scheduled = false,
+            .throttle_state = throttle.Throttle.init(60),
+            .render_buffer = buffer.RenderBuffer.init(allocator, stdout),
+            .stdout = stdout,
+        };
+    }
+
+    pub fn deinit(self: *Region) void {
+        // Free frame buffers
+        for (self.pending_frame.items) |line| {
+            self.allocator.free(line);
+        }
+        self.pending_frame.deinit(self.allocator);
+
+        for (self.previous_frame.items) |line| {
+            self.allocator.free(line);
+        }
+        self.previous_frame.deinit(self.allocator);
+
+        self.render_buffer.deinit();
+    }
+
+    pub fn expand_to(self: *Region, new_height: u32) !void {
+        const old_height = self.height;
+        _ = old_height; // autofix
+        self.height = new_height;
+
+        // Expand pending_frame
+        try self.pending_frame.ensureTotalCapacity(self.allocator, new_height);
+        while (self.pending_frame.items.len < new_height) {
+            try self.pending_frame.append(self.allocator, try self.allocator.dupe(u8, ""));
+        }
+
+        // Expand previous_frame
+        try self.previous_frame.ensureTotalCapacity(self.allocator, new_height);
+        while (self.previous_frame.items.len < new_height) {
+            try self.previous_frame.append(self.allocator, try self.allocator.dupe(u8, ""));
+        }
+    }
+
+    pub fn set_line(self: *Region, line_number: u32, content: []const u8) !void {
+        // Convert 1-based to 0-based
+        if (line_number == 0) {
+            return error.InvalidLineNumber;
+        }
+        const line_index = line_number - 1;
+
+        // Expand if needed
+        if (line_index >= self.height) {
+            try self.expand_to(line_index + 1);
+        }
+
+        // Ensure pending_frame has enough lines
+        while (self.pending_frame.items.len <= line_index) {
+            try self.pending_frame.append(self.allocator, try self.allocator.dupe(u8, ""));
+        }
+
+        // Free old line and set new one
+        self.allocator.free(self.pending_frame.items[line_index]);
+        self.pending_frame.items[line_index] = try self.allocator.dupe(u8, content);
+
+        // Schedule render
+        self.schedule_render();
+    }
+
+    pub fn set(self: *Region, content: []const u8) !void {
+        // Split by \n to get lines
+        var lines = std.ArrayList([]const u8){};
+        defer lines.deinit(self.allocator);
+
+        var it = std.mem.splitScalar(u8, content, '\n');
+        while (it.next()) |line| {
+            try lines.append(self.allocator, line);
+        }
+
+        // Expand region if needed
+        if (lines.items.len > self.height) {
+            try self.expand_to(@intCast(lines.items.len));
+        }
+
+        // Free old pending frame
+        for (self.pending_frame.items) |line| {
+            self.allocator.free(line);
+        }
+        self.pending_frame.clearRetainingCapacity();
+
+        // Update all lines in pending_frame
+        try self.pending_frame.ensureTotalCapacity(self.allocator, lines.items.len);
+        for (lines.items) |line| {
+            try self.pending_frame.append(self.allocator, try self.allocator.dupe(u8, line));
+        }
+
+        // Schedule render
+        self.schedule_render();
+    }
+
+    pub fn schedule_render(self: *Region) void {
+        // Skip rendering if disabled (for tests)
+        if (self.disable_rendering) {
+            // Just copy pending to previous without actually rendering
+            self.copy_pending_to_previous() catch {};
+            return;
+        }
+
+        if (self.throttle_state.should_render()) {
+            self.render_now() catch |e| {
+                std.log.err("Render error: {}", .{e});
+            };
+        } else {
+            self.render_scheduled = true;
+        }
+    }
+
+    fn copy_pending_to_previous(self: *Region) !void {
+        // Free old previous_frame
+        for (self.previous_frame.items) |line| {
+            self.allocator.free(line);
+        }
+        self.previous_frame.clearRetainingCapacity();
+
+        // Copy pending to previous
+        try self.previous_frame.ensureTotalCapacity(self.allocator, self.pending_frame.items.len);
+        for (self.pending_frame.items) |line| {
+            try self.previous_frame.append(self.allocator, try self.allocator.dupe(u8, line));
+        }
+    }
+
+    pub fn render_now(self: *Region) !void {
+        // Hide cursor
+        try self.render_buffer.write(ansi.HIDE_CURSOR);
+
+        // Move to region start
+        const move_seq = try ansi.move_cursor_to(self.allocator, self.x, self.y);
+        defer self.allocator.free(move_seq);
+        try self.render_buffer.write(move_seq);
+
+        // Diff and render
+        const diff_ops = try diff.diff_frames(
+            self.previous_frame.items,
+            self.pending_frame.items,
+            self.allocator,
+        );
+        defer {
+            for (diff_ops) |_| {}
+            self.allocator.free(diff_ops);
+        }
+
+        var current_line: u32 = 0;
+        for (diff_ops) |op| {
+            switch (op) {
+                .update_line => |update| {
+                    // Move to line if needed
+                    if (update.line != current_line) {
+                        const move = try ansi.move_cursor_to(
+                            self.allocator,
+                            self.x,
+                            self.y + update.line,
+                        );
+                        defer self.allocator.free(move);
+                        try self.render_buffer.write(move);
+                        current_line = update.line;
+                    }
+
+                    // Clear line and write new content
+                    try self.render_buffer.write(ansi.CLEAR_LINE);
+                    try self.render_buffer.write(update.content);
+                    current_line += 1;
+                },
+                .insert_line => |insert| {
+                    // Move to line
+                    const move = try ansi.move_cursor_to(
+                        self.allocator,
+                        self.x,
+                        self.y + insert.line,
+                    );
+                    defer self.allocator.free(move);
+                    try self.render_buffer.write(move);
+
+                    // Write content
+                    try self.render_buffer.write(insert.content);
+                    current_line = insert.line + 1;
+                },
+                .delete_line => |del| {
+                    // Move to line and clear it
+                    const move = try ansi.move_cursor_to(
+                        self.allocator,
+                        self.x,
+                        self.y + del,
+                    );
+                    defer self.allocator.free(move);
+                    try self.render_buffer.write(move);
+                    try self.render_buffer.write(ansi.CLEAR_LINE);
+                },
+                .no_change => {
+                    // Skip unchanged lines
+                    current_line += 1;
+                },
+            }
+        }
+
+        // Show cursor
+        try self.render_buffer.write(ansi.SHOW_CURSOR);
+
+        // Flush buffer
+        try self.render_buffer.flush();
+
+        // Copy pending_frame to previous_frame
+        for (self.previous_frame.items) |line| {
+            self.allocator.free(line);
+        }
+        self.previous_frame.clearRetainingCapacity();
+
+        try self.previous_frame.ensureTotalCapacity(self.allocator, self.pending_frame.items.len);
+        for (self.pending_frame.items) |line| {
+            try self.previous_frame.append(self.allocator, try self.allocator.dupe(u8, line));
+        }
+
+        self.render_scheduled = false;
+    }
+
+    pub fn flush(self: *Region) !void {
+        // Force immediate render
+        try self.render_now();
+    }
+
+    pub fn set_throttle_fps(self: *Region, fps: u32) void {
+        self.throttle_state.set_fps(fps);
+    }
+
+    pub fn clear_line(self: *Region, line_number: u32) !void {
+        if (line_number == 0) {
+            return error.InvalidLineNumber;
+        }
+        try self.set_line(line_number, "");
+    }
+
+    pub fn clear(self: *Region) !void {
+        // Clear all lines
+        for (0..self.height) |i| {
+            try self.set_line(@intCast(i + 1), "");
+        }
+    }
+};

package/src/zig/renderer.zig

@@ -0,0 +1,92 @@
+// Main renderer with N-API bindings
+const std = @import("std");
+const region = @import("region.zig");
+
+var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+const allocator = gpa.allocator();
+
+var regions = std.ArrayList(*region.Region){};
+var region_mutex = std.Thread.Mutex{};
+
+// Get stdout file handle
+fn get_stdout() std.fs.File {
+    return std.fs.File{ .handle = 1 }; // stdout handle
+}
+
+export fn create_region(x: u32, y: u32, width: u32, height: u32) u64 {
+    region_mutex.lock();
+    defer region_mutex.unlock();
+
+    const r = allocator.create(region.Region) catch return 0;
+    r.* = region.Region.init(allocator, x, y, width, height, get_stdout()) catch {
+        allocator.destroy(r);
+        return 0;
+    };
+
+    regions.append(allocator, r) catch {
+        r.deinit();
+        allocator.destroy(r);
+        return 0;
+    };
+
+    return @intFromPtr(r);
+}
+
+export fn destroy_region(handle: u64) void {
+    region_mutex.lock();
+    defer region_mutex.unlock();
+
+    const r = @as(*region.Region, @ptrFromInt(handle));
+    r.deinit();
+    allocator.destroy(r);
+
+    // Remove from regions list
+    for (regions.items, 0..) |reg, i| {
+        if (reg == r) {
+            _ = regions.swapRemove(i);
+            break;
+        }
+    }
+}
+
+export fn set_line(handle: u64, line_number: u32, content: [*]const u8, len: usize) void {
+    const r = @as(*region.Region, @ptrFromInt(handle));
+    const content_slice = content[0..len];
+    r.set_line(line_number, content_slice) catch |e| {
+        std.log.err("set_line error: {}", .{e});
+    };
+}
+
+export fn set(handle: u64, content: [*]const u8, len: usize) void {
+    const r = @as(*region.Region, @ptrFromInt(handle));
+    const content_slice = content[0..len];
+    r.set(content_slice) catch |e| {
+        std.log.err("set error: {}", .{e});
+    };
+}
+
+export fn clear_line(handle: u64, line_number: u32) void {
+    const r = @as(*region.Region, @ptrFromInt(handle));
+    r.clear_line(line_number) catch |e| {
+        std.log.err("clear_line error: {}", .{e});
+    };
+}
+
+export fn clear_region(handle: u64) void {
+    const r = @as(*region.Region, @ptrFromInt(handle));
+    r.clear() catch |e| {
+        std.log.err("clear_region error: {}", .{e});
+    };
+}
+
+export fn flush(handle: u64) void {
+    const r = @as(*region.Region, @ptrFromInt(handle));
+    r.flush() catch |e| {
+        std.log.err("flush error: {}", .{e});
+    };
+}
+
+export fn set_throttle_fps(handle: u64, fps: u32) void {
+    const r = @as(*region.Region, @ptrFromInt(handle));
+    r.set_throttle_fps(fps);
+}

package/src/zig/test_ansi.zig

@@ -0,0 +1,66 @@
+const std = @import("std");
+const ansi = @import("ansi.zig");
+const testing = std.testing;
+
+test "ANSI: move_cursor_to generates correct ANSI" {
+    const allocator = testing.allocator;
+    const seq = try ansi.move_cursor_to(allocator, 10, 5);
+    defer allocator.free(seq);
+
+    try testing.expectEqualStrings("\x1b[5;10H", seq);
+    std.debug.print("  ✓ move_cursor_to(10, 5): {s}\n", .{seq});
+}
+
+test "ANSI: move_cursor_up generates correct ANSI" {
+    const allocator = testing.allocator;
+    const seq = try ansi.move_cursor_up(allocator, 3);
+    defer allocator.free(seq);
+
+    try testing.expectEqualStrings("\x1b[3A", seq);
+    std.debug.print("  ✓ move_cursor_up(3): {s}\n", .{seq});
+}
+
+test "ANSI: move_cursor_down generates correct ANSI" {
+    const allocator = testing.allocator;
+    const seq = try ansi.move_cursor_down(allocator, 2);
+    defer allocator.free(seq);
+
+    try testing.expectEqualStrings("\x1b[2B", seq);
+    std.debug.print("  ✓ move_cursor_down(2): {s}\n", .{seq});
+}
+
+test "ANSI: constants are correct" {
+    try testing.expectEqualStrings("\x1b[2K", ansi.CLEAR_LINE);
+    try testing.expectEqualStrings("\x1b[?25l", ansi.HIDE_CURSOR);
+    try testing.expectEqualStrings("\x1b[?25h", ansi.SHOW_CURSOR);
+    try testing.expectEqualStrings("\x1b[s", ansi.SAVE_CURSOR);
+    try testing.expectEqualStrings("\x1b[u", ansi.RESTORE_CURSOR);
+    std.debug.print("  ✓ All ANSI constants verified\n", .{});
+}
+
+test "ANSI: move_cursor_to with zero coordinates" {
+    const allocator = testing.allocator;
+    const seq = try ansi.move_cursor_to(allocator, 0, 0);
+    defer allocator.free(seq);
+
+    try testing.expectEqualStrings("\x1b[0;0H", seq);
+    std.debug.print("  ✓ move_cursor_to(0, 0): {s}\n", .{seq});
+}
+
+test "ANSI: move_cursor_to with large coordinates" {
+    const allocator = testing.allocator;
+    const seq = try ansi.move_cursor_to(allocator, 200, 100);
+    defer allocator.free(seq);
+
+    try testing.expectEqualStrings("\x1b[100;200H", seq);
+    std.debug.print("  ✓ move_cursor_to(200, 100): {s}\n", .{seq});
+}
+
+test "ANSI: move_cursor_up with zero" {
+    const allocator = testing.allocator;
+    const seq = try ansi.move_cursor_up(allocator, 0);
+    defer allocator.free(seq);
+
+    try testing.expectEqualStrings("\x1b[0A", seq);
+    std.debug.print("  ✓ move_cursor_up(0): {s}\n", .{seq});
+}