fix: Removed need for stored offset for directory rendering. This change removes the stored offset from the List component and moves offset calculation to the render.

src/directories.zig

···
 const vaxis = @import("vaxis");
 const fuzzig = @import("fuzzig");
 
-const History = struct {
-    selected: usize,
-    offset: usize,
-};
-
 const history_len: usize = 100;
 
 const Self = @This();
···
 file_contents: [4096]u8 = undefined,
 pdf_contents: ?[]u8 = null,
 entries: List(std.fs.Dir.Entry),
-history: CircStack(History, history_len),
+history: CircStack(usize, history_len),
 child_entries: List([]const u8),
 searcher: fuzzig.Ascii,
 
···
         .alloc = alloc,
         .dir = try std.fs.cwd().openDir(".", .{ .iterate = true }),
         .entries = List(std.fs.Dir.Entry).init(alloc),
-        .history = CircStack(History, history_len).init(),
+        .history = CircStack(usize, history_len).init(),
         .child_entries = List([]const u8).init(alloc),
         .searcher = try fuzzig.Ascii.init(
             alloc,
···
     selected_list_item_style: vaxis.Style,
     list_item_style: vaxis.Style,
 ) !void {
-    for (self.entries.all()[self.entries.offset..], 0..) |item, i| {
-        const selected = self.entries.selected - self.entries.offset;
+    const win_height = window.height;
+    var offset: usize = 0;
+
+    while (self.entries.all()[offset..].len > win_height and
+        self.entries.selected >= offset + (win_height / 2))
+    {
+        offset += 1;
+    }
+
+    for (self.entries.all()[offset..], 0..) |item, i| {
+        const selected = self.entries.selected - offset;
         const is_selected = selected == i;
 
         if (i > window.height) continue;

src/event_handlers.zig

···
                         };
 
                         for (app.directories.entries.all()) |entry| {
-                            // Update offset as we search for last selected entry.
-                            app.directories.entries.updateOffset(app.last_known_height, .next);
                             if (std.mem.eql(u8, entry.name, prev_selected_name)) return;
                             app.directories.entries.selected += 1;
                         }
···
                         app.state = .command;
                     },
                     .jump_bottom => {
-                        app.directories.entries.selectLast(app.last_known_height);
+                        app.directories.entries.selectLast();
                     },
                     .jump_top => app.directories.entries.selectFirst(),
                     .toggle_verbose_file_information => app.drawer.verbose = !app.drawer.verbose,
···
                             };
 
                             if (app.directories.history.pop()) |history| {
-                                if (history.selected < app.directories.entries.len()) {
-                                    app.directories.entries.selected = history.selected;
-                                    app.directories.entries.offset = history.offset;
+                                if (history < app.directories.entries.len()) {
+                                    app.directories.entries.selected = history;
                                 }
                             }
                         } else |err| {
···
                                     app.directories.dir.close();
                                     app.directories.dir = dir;
 
-                                    _ = app.directories.history.push(.{
-                                        .selected = app.directories.entries.selected,
-                                        .offset = app.directories.entries.offset,
-                                    });
+                                    _ = app.directories.history.push(app.directories.entries.selected);
 
                                     app.directories.clearEntries();
                                     const fuzzy = inputToSlice(app);
···
                         }
                     },
                     'j', Key.down => {
-                        app.directories.entries.next(app.last_known_height);
+                        app.directories.entries.next();
                     },
                     'k', Key.up => {
-                        app.directories.entries.previous(app.last_known_height);
+                        app.directories.entries.previous();
                     },
                     'u' => {
                         if (app.actions.pop()) |action| {

src/list.zig

···
         alloc: std.mem.Allocator,
         items: std.ArrayList(T),
         selected: usize,
-        offset: usize,
 
         pub fn init(alloc: std.mem.Allocator) Self {
             return Self{
                 .alloc = alloc,
                 .items = std.ArrayList(T).init(alloc),
                 .selected = 0,
-                .offset = 0,
             };
         }
 
···
         pub fn clear(self: *Self) void {
             self.items.clearAndFree();
             self.selected = 0;
-            self.offset = 0;
         }
 
         pub fn get(self: Self, index: usize) !T {
···
             return self.items.items.len;
         }
 
-        pub fn next(self: *Self, win_height: usize) void {
+        pub fn next(self: *Self) void {
             if (self.selected + 1 < self.len()) {
                 self.selected += 1;
-                self.updateOffset(win_height, .next);
             }
         }
 
-        pub fn previous(self: *Self, win_height: usize) void {
+        pub fn previous(self: *Self) void {
             if (self.selected > 0) {
                 self.selected -= 1;
-                self.updateOffset(win_height, .previous);
             }
         }
 
-        pub fn updateOffset(self: *Self, win_height: usize, direction: enum { next, previous }) void {
-            if (direction == .next) {
-                if (self.all()[self.offset..].len > win_height and self.selected >= self.offset + (win_height / 2)) {
-                    self.offset += 1;
-                }
-            } else if (direction == .previous) {
-                if (self.offset > 0 and self.selected < self.offset + (win_height / 2)) {
-                    self.offset -= 1;
-                }
-            }
-        }
-
-        pub fn selectLast(self: *Self, win_height: usize) void {
+        pub fn selectLast(self: *Self) void {
             self.selected = self.len() - 1;
-            if (self.selected >= win_height) {
-                self.offset = self.selected - (win_height - 1);
-            }
         }
 
         pub fn selectFirst(self: *Self) void {
             self.selected = 0;
-            self.offset = 0;
         }
     };
 }