536 lines
22 KiB
Zig
536 lines
22 KiB
Zig
const std = @import("std");
|
|
const vaxis = @import("vaxis");
|
|
const zfin = @import("../root.zig");
|
|
const fmt = @import("../format.zig");
|
|
const Money = @import("../Money.zig");
|
|
const theme = @import("theme.zig");
|
|
const tui = @import("../tui.zig");
|
|
const framework = @import("tab_framework.zig");
|
|
|
|
const App = tui.App;
|
|
const StyledLine = tui.StyledLine;
|
|
const OptionsRow = tui.OptionsRow;
|
|
|
|
// ── Tab-local action enum ─────────────────────────────────────
|
|
//
|
|
// Options tab keybinds:
|
|
// - Enter : expand/collapse the row at the cursor.
|
|
// - `c` / `p` : collapse-or-expand all calls / puts.
|
|
// - Ctrl-1 .. Ctrl-9 : set NTM filter to N strikes around ATM.
|
|
|
|
pub const Action = enum {
|
|
/// Toggle the row at the cursor: expand/collapse an expiration,
|
|
/// or collapse/expand the calls/puts subsection at the cursor.
|
|
/// Mouse single-click on a row dispatches the same action.
|
|
expand_collapse,
|
|
collapse_all_calls,
|
|
collapse_all_puts,
|
|
filter_1,
|
|
filter_2,
|
|
filter_3,
|
|
filter_4,
|
|
filter_5,
|
|
filter_6,
|
|
filter_7,
|
|
filter_8,
|
|
filter_9,
|
|
};
|
|
|
|
// ── Tab-private state ─────────────────────────────────────────
|
|
|
|
pub const State = struct {
|
|
/// Loaded options chains for the active symbol. Owned by State;
|
|
/// freed via `deinit` and `reload`.
|
|
chains: ?[]zfin.OptionsChain = null,
|
|
/// Whether `activate` has populated `chains` (or set `disabled`).
|
|
/// The chains slice is null until the first successful fetch
|
|
/// even if `loaded == true` (failed fetches still mark loaded).
|
|
loaded: bool = false,
|
|
/// Timestamp of the chains fetch — drives the "data Xs ago"
|
|
/// header readout.
|
|
timestamp: i64 = 0,
|
|
/// Cursor position in the flattened options rows view.
|
|
cursor: usize = 0,
|
|
/// Per-expiration: is the expiration expanded (showing calls
|
|
/// + puts subsections)?
|
|
expanded: [64]bool = @splat(false),
|
|
/// Per-expiration: when expanded, are the calls collapsed?
|
|
calls_collapsed: [64]bool = @splat(false),
|
|
/// Per-expiration: when expanded, are the puts collapsed?
|
|
puts_collapsed: [64]bool = @splat(false),
|
|
/// Number of strikes around ATM to show. Adjusted with Ctrl-1..9.
|
|
near_the_money: usize = 8,
|
|
/// Flattened display rows (expirations + headers + contracts).
|
|
/// Rebuilt by `rebuildRows` whenever `expanded` or
|
|
/// `near_the_money` changes.
|
|
rows: std.ArrayList(OptionsRow) = .empty,
|
|
/// Number of styled lines emitted before the first data row.
|
|
/// Used by mouse-click handling to map screen rows to data rows.
|
|
header_lines: usize = 0,
|
|
};
|
|
|
|
// ── Tab framework contract ────────────────────────────────────
|
|
|
|
pub const tab = struct {
|
|
pub const ActionT = Action;
|
|
pub const StateT = State;
|
|
|
|
pub const default_bindings: []const framework.TabBinding(Action) = &.{
|
|
.{ .action = .expand_collapse, .key = .{ .codepoint = vaxis.Key.enter } },
|
|
.{ .action = .collapse_all_calls, .key = .{ .codepoint = 'c' } },
|
|
.{ .action = .collapse_all_puts, .key = .{ .codepoint = 'p' } },
|
|
.{ .action = .filter_1, .key = .{ .codepoint = '1', .mods = .{ .ctrl = true } } },
|
|
.{ .action = .filter_2, .key = .{ .codepoint = '2', .mods = .{ .ctrl = true } } },
|
|
.{ .action = .filter_3, .key = .{ .codepoint = '3', .mods = .{ .ctrl = true } } },
|
|
.{ .action = .filter_4, .key = .{ .codepoint = '4', .mods = .{ .ctrl = true } } },
|
|
.{ .action = .filter_5, .key = .{ .codepoint = '5', .mods = .{ .ctrl = true } } },
|
|
.{ .action = .filter_6, .key = .{ .codepoint = '6', .mods = .{ .ctrl = true } } },
|
|
.{ .action = .filter_7, .key = .{ .codepoint = '7', .mods = .{ .ctrl = true } } },
|
|
.{ .action = .filter_8, .key = .{ .codepoint = '8', .mods = .{ .ctrl = true } } },
|
|
.{ .action = .filter_9, .key = .{ .codepoint = '9', .mods = .{ .ctrl = true } } },
|
|
};
|
|
|
|
pub const action_labels = std.enums.EnumArray(Action, []const u8).init(.{
|
|
.expand_collapse = "Expand/collapse row",
|
|
.collapse_all_calls = "Toggle all calls",
|
|
.collapse_all_puts = "Toggle all puts",
|
|
.filter_1 = "Filter +/- 1 NTM",
|
|
.filter_2 = "Filter +/- 2 NTM",
|
|
.filter_3 = "Filter +/- 3 NTM",
|
|
.filter_4 = "Filter +/- 4 NTM",
|
|
.filter_5 = "Filter +/- 5 NTM",
|
|
.filter_6 = "Filter +/- 6 NTM",
|
|
.filter_7 = "Filter +/- 7 NTM",
|
|
.filter_8 = "Filter +/- 8 NTM",
|
|
.filter_9 = "Filter +/- 9 NTM",
|
|
});
|
|
|
|
pub const status_hints: []const Action = &.{
|
|
.collapse_all_calls,
|
|
.collapse_all_puts,
|
|
};
|
|
|
|
pub fn init(state: *State, app: *App) !void {
|
|
_ = app;
|
|
state.* = .{};
|
|
}
|
|
|
|
pub fn deinit(state: *State, app: *App) void {
|
|
if (state.chains) |chains| {
|
|
zfin.OptionsChain.freeSlice(app.allocator, chains);
|
|
}
|
|
state.rows.deinit(app.allocator);
|
|
state.* = .{};
|
|
}
|
|
|
|
pub fn activate(state: *State, app: *App) !void {
|
|
if (app.symbol.len == 0) return;
|
|
if (state.loaded) return;
|
|
loadData(state, app);
|
|
}
|
|
|
|
pub const deactivate = framework.noopDeactivate(State);
|
|
|
|
pub fn reload(state: *State, app: *App) !void {
|
|
// Drop chains first so loadData starts clean.
|
|
if (state.chains) |chains| {
|
|
zfin.OptionsChain.freeSlice(app.allocator, chains);
|
|
}
|
|
// Preserve user UX choices across refresh: cursor, expanded
|
|
// sections, near-the-money filter. Just clear the data.
|
|
state.chains = null;
|
|
state.loaded = false;
|
|
state.timestamp = 0;
|
|
loadData(state, app);
|
|
}
|
|
|
|
pub const tick = framework.noopTick(State);
|
|
|
|
pub fn handleAction(state: *State, app: *App, action: Action) void {
|
|
switch (action) {
|
|
.collapse_all_calls => toggleAllCallsPuts(state, app, true),
|
|
.collapse_all_puts => toggleAllCallsPuts(state, app, false),
|
|
.expand_collapse => toggleExpandAtCursor(state, app),
|
|
.filter_1, .filter_2, .filter_3, .filter_4, .filter_5, .filter_6, .filter_7, .filter_8, .filter_9 => {
|
|
const n = @intFromEnum(action) - @intFromEnum(Action.filter_1) + 1;
|
|
state.near_the_money = n;
|
|
rebuildRows(state, app);
|
|
var status_buf: [32]u8 = undefined;
|
|
const msg = std.fmt.bufPrint(&status_buf, "+/- {d} NTM strikes", .{n}) catch "Filter changed";
|
|
app.setStatus(msg);
|
|
},
|
|
}
|
|
}
|
|
|
|
/// Mouse handling: a single-click on a data row moves the
|
|
/// cursor to that row and toggles expand/collapse — same effect
|
|
/// as pressing Enter on the row. Returns `true` if the click
|
|
/// landed on a data row (consumed); `false` otherwise (unhandled,
|
|
/// e.g. clicks above the table or on blank lines).
|
|
pub fn handleMouse(state: *State, app: *App, mouse: vaxis.Mouse) bool {
|
|
if (mouse.button != .left) return false;
|
|
if (mouse.type != .press) return false;
|
|
const content_row = @as(usize, @intCast(mouse.row)) + app.scroll_offset;
|
|
if (content_row < state.header_lines) return false;
|
|
if (state.rows.items.len == 0) return false;
|
|
|
|
// Walk rows tracking styled line position to find which row
|
|
// was clicked. Each row = 1 styled line, except `puts_header`
|
|
// which emits an extra blank line before it.
|
|
const target_line = content_row - state.header_lines;
|
|
var current_line: usize = 0;
|
|
for (state.rows.items, 0..) |orow, oi| {
|
|
if (orow.kind == .puts_header) current_line += 1; // extra blank
|
|
if (current_line == target_line) {
|
|
state.cursor = oi;
|
|
toggleExpandAtCursor(state, app);
|
|
return true;
|
|
}
|
|
current_line += 1;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
pub fn isDisabled(app: *App) bool {
|
|
_ = app;
|
|
return false;
|
|
}
|
|
|
|
/// Symbol-change reset. Drops chains + display rows, clears
|
|
/// cursor + per-expiration collapse flags. Preserves
|
|
/// `near_the_money` because that's a persistent UX choice
|
|
/// (not symbol-bound).
|
|
pub fn onSymbolChange(state: *State, app: *App) void {
|
|
if (state.chains) |chains| {
|
|
zfin.OptionsChain.freeSlice(app.allocator, chains);
|
|
}
|
|
state.chains = null;
|
|
state.loaded = false;
|
|
state.timestamp = 0;
|
|
state.cursor = 0;
|
|
state.expanded = @splat(false);
|
|
state.calls_collapsed = @splat(false);
|
|
state.puts_collapsed = @splat(false);
|
|
state.rows.clearRetainingCapacity();
|
|
state.header_lines = 0;
|
|
// near_the_money preserved.
|
|
}
|
|
|
|
/// Sync the row cursor to the new scroll extreme. The framework
|
|
/// updates `app.scroll_offset` itself; this hook just keeps the
|
|
/// tab's own cursor consistent with what's now visible.
|
|
pub fn onScroll(state: *State, app: *App, where: framework.ScrollEdge) void {
|
|
_ = app;
|
|
switch (where) {
|
|
.top => state.cursor = 0,
|
|
.bottom => {
|
|
if (state.rows.items.len > 0) {
|
|
state.cursor = state.rows.items.len - 1;
|
|
}
|
|
},
|
|
}
|
|
}
|
|
|
|
/// Step the row cursor by one row in `delta`'s direction. The
|
|
/// magnitude of `delta` is ignored — keys and wheel events
|
|
/// both move by a single row (matching legacy behavior). Returns
|
|
/// `false` when there are no rows to navigate so the framework
|
|
/// falls through to scrolling the viewport instead.
|
|
pub fn onCursorMove(state: *State, app: *App, delta: isize) bool {
|
|
if (state.rows.items.len == 0) return false;
|
|
stepCursor(&state.cursor, state.rows.items.len, delta);
|
|
ensureCursorVisible(state, &app.scroll_offset, app.visible_height);
|
|
return true;
|
|
}
|
|
};
|
|
|
|
// ── Cursor movement / visibility (private; called from onCursorMove) ──
|
|
|
|
fn stepCursor(cursor: *usize, row_count: usize, direction: isize) void {
|
|
if (direction > 0) {
|
|
if (row_count > 0 and cursor.* < row_count - 1) cursor.* += 1;
|
|
} else {
|
|
if (cursor.* > 0) cursor.* -= 1;
|
|
}
|
|
}
|
|
|
|
fn ensureCursorVisible(state: *const State, scroll_offset: *usize, visible_height: usize) void {
|
|
const cursor_row = state.cursor + state.header_lines;
|
|
if (cursor_row < scroll_offset.*) {
|
|
scroll_offset.* = cursor_row;
|
|
}
|
|
if (cursor_row >= scroll_offset.* + visible_height) {
|
|
scroll_offset.* = cursor_row - visible_height + 1;
|
|
}
|
|
}
|
|
|
|
// ── Data loading ──────────────────────────────────────────────
|
|
|
|
fn loadData(state: *State, app: *App) void {
|
|
state.loaded = true;
|
|
if (state.chains) |chains| {
|
|
zfin.OptionsChain.freeSlice(app.allocator, chains);
|
|
}
|
|
state.chains = null;
|
|
|
|
const result = app.svc.getOptions(app.symbol) catch |err| {
|
|
switch (err) {
|
|
zfin.DataError.FetchFailed => app.setStatus("CBOE fetch failed (network error)"),
|
|
else => app.setStatus("Error loading options"),
|
|
}
|
|
return;
|
|
};
|
|
state.chains = result.data;
|
|
state.timestamp = result.timestamp;
|
|
state.cursor = 0;
|
|
state.expanded = @splat(false);
|
|
state.calls_collapsed = @splat(false);
|
|
state.puts_collapsed = @splat(false);
|
|
rebuildRows(state, app);
|
|
app.setStatus(if (result.source == .cached) "Cached (1hr TTL) | r/F5 to refresh" else "Fetched | r/F5 to refresh");
|
|
}
|
|
|
|
// ── Expand/collapse the row at the cursor ─────────────────────
|
|
//
|
|
// Called both from the keybind handler (`expand_collapse` action,
|
|
// bound to Enter) and from the mouse handler (single-click on a
|
|
// row). The behavior depends on the row kind:
|
|
// - `expiration` row: toggle the expiration's expanded flag
|
|
// (showing/hiding the calls + puts subsections).
|
|
// - `calls_header`/`puts_header`: toggle that subsection's
|
|
// collapsed flag.
|
|
// - call/put contract rows: no-op (clicking a contract is
|
|
// reserved for future per-contract actions).
|
|
//
|
|
// After any change, rebuilds the flat row list to reflect the new
|
|
// layout. No-op if the cursor is out of range or rows are empty.
|
|
|
|
fn toggleExpandAtCursor(state: *State, app: *App) void {
|
|
if (state.rows.items.len == 0) return;
|
|
if (state.cursor >= state.rows.items.len) return;
|
|
const row = state.rows.items[state.cursor];
|
|
switch (row.kind) {
|
|
.expiration => {
|
|
if (row.exp_idx < state.expanded.len) {
|
|
state.expanded[row.exp_idx] = !state.expanded[row.exp_idx];
|
|
rebuildRows(state, app);
|
|
}
|
|
},
|
|
.calls_header => {
|
|
if (row.exp_idx < state.calls_collapsed.len) {
|
|
state.calls_collapsed[row.exp_idx] = !state.calls_collapsed[row.exp_idx];
|
|
rebuildRows(state, app);
|
|
}
|
|
},
|
|
.puts_header => {
|
|
if (row.exp_idx < state.puts_collapsed.len) {
|
|
state.puts_collapsed[row.exp_idx] = !state.puts_collapsed[row.exp_idx];
|
|
rebuildRows(state, app);
|
|
}
|
|
},
|
|
// Clicking on a contract does nothing (yet).
|
|
else => {},
|
|
}
|
|
}
|
|
|
|
// ── Row rebuilding (after expansion/collapse changes) ────────
|
|
|
|
pub fn rebuildRows(state: *State, app: *App) void {
|
|
state.rows.clearRetainingCapacity();
|
|
const chains = state.chains orelse return;
|
|
const atm_price = if (chains.len > 0) chains[0].underlying_price orelse 0 else @as(f64, 0);
|
|
|
|
for (chains, 0..) |chain, ci| {
|
|
state.rows.append(app.allocator, .{
|
|
.kind = .expiration,
|
|
.exp_idx = ci,
|
|
}) catch continue;
|
|
|
|
if (ci < state.expanded.len and state.expanded[ci]) {
|
|
// Calls header (always shown when expanded, acts as toggle)
|
|
state.rows.append(app.allocator, .{
|
|
.kind = .calls_header,
|
|
.exp_idx = ci,
|
|
}) catch continue;
|
|
|
|
// Calls contracts (only if not collapsed)
|
|
if (!(ci < state.calls_collapsed.len and state.calls_collapsed[ci])) {
|
|
const filtered_calls = fmt.filterNearMoney(chain.calls, atm_price, state.near_the_money);
|
|
for (filtered_calls) |cc| {
|
|
state.rows.append(app.allocator, .{
|
|
.kind = .call,
|
|
.exp_idx = ci,
|
|
.contract = cc,
|
|
}) catch continue;
|
|
}
|
|
}
|
|
|
|
// Puts header
|
|
state.rows.append(app.allocator, .{
|
|
.kind = .puts_header,
|
|
.exp_idx = ci,
|
|
}) catch continue;
|
|
|
|
// Puts contracts (only if not collapsed)
|
|
if (!(ci < state.puts_collapsed.len and state.puts_collapsed[ci])) {
|
|
const filtered_puts = fmt.filterNearMoney(chain.puts, atm_price, state.near_the_money);
|
|
for (filtered_puts) |p| {
|
|
state.rows.append(app.allocator, .{
|
|
.kind = .put,
|
|
.exp_idx = ci,
|
|
.contract = p,
|
|
}) catch continue;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// ── All-calls / all-puts toggle ──────────────────────────────
|
|
|
|
fn toggleAllCallsPuts(state: *State, app: *App, is_calls: bool) void {
|
|
const chains = state.chains orelse return;
|
|
// Determine whether to collapse or expand: if any expanded chain
|
|
// has this section visible, collapse all; otherwise expand all.
|
|
var any_visible = false;
|
|
for (chains, 0..) |_, ci| {
|
|
if (ci >= state.expanded.len) break;
|
|
if (!state.expanded[ci]) continue; // only count expanded expirations
|
|
if (is_calls) {
|
|
if (ci < state.calls_collapsed.len and !state.calls_collapsed[ci]) {
|
|
any_visible = true;
|
|
break;
|
|
}
|
|
} else {
|
|
if (ci < state.puts_collapsed.len and !state.puts_collapsed[ci]) {
|
|
any_visible = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
const new_state = any_visible;
|
|
for (chains, 0..) |_, ci| {
|
|
if (ci >= 64) break;
|
|
if (is_calls) {
|
|
state.calls_collapsed[ci] = new_state;
|
|
} else {
|
|
state.puts_collapsed[ci] = new_state;
|
|
}
|
|
}
|
|
rebuildRows(state, app);
|
|
if (is_calls) {
|
|
app.setStatus(if (new_state) "All calls collapsed" else "All calls expanded");
|
|
} else {
|
|
app.setStatus(if (new_state) "All puts collapsed" else "All puts expanded");
|
|
}
|
|
}
|
|
|
|
// ── Rendering ─────────────────────────────────────────────────
|
|
|
|
pub fn buildStyledLines(app: *App, arena: std.mem.Allocator) ![]const StyledLine {
|
|
const state = &app.states.options;
|
|
const th = app.theme;
|
|
var lines: std.ArrayList(StyledLine) = .empty;
|
|
|
|
try lines.append(arena, .{ .text = "", .style = th.contentStyle() });
|
|
|
|
if (app.symbol.len == 0) {
|
|
try lines.append(arena, .{ .text = " No symbol selected. Press / to enter a symbol.", .style = th.mutedStyle() });
|
|
return lines.toOwnedSlice(arena);
|
|
}
|
|
|
|
const chains = state.chains orelse {
|
|
try lines.append(arena, .{ .text = " Loading options data...", .style = th.mutedStyle() });
|
|
return lines.toOwnedSlice(arena);
|
|
};
|
|
|
|
if (chains.len == 0) {
|
|
try lines.append(arena, .{ .text = " No options data found.", .style = th.mutedStyle() });
|
|
return lines.toOwnedSlice(arena);
|
|
}
|
|
|
|
var opt_ago_buf: [16]u8 = undefined;
|
|
// wall-clock required: per-frame "now" for the "refreshed Xs ago"
|
|
// readout. Captured here rather than on `app` so it refreshes every
|
|
// time this tab renders.
|
|
const now_s = std.Io.Timestamp.now(app.io, .real).toSeconds();
|
|
const opt_ago = fmt.fmtTimeAgo(&opt_ago_buf, state.timestamp, now_s);
|
|
if (opt_ago.len > 0) {
|
|
try lines.append(arena, .{ .text = try std.fmt.allocPrint(arena, " Options: {s} (data {s}, 15 min delay)", .{ app.symbol, opt_ago }), .style = th.headerStyle() });
|
|
} else {
|
|
try lines.append(arena, .{ .text = try std.fmt.allocPrint(arena, " Options: {s}", .{app.symbol}), .style = th.headerStyle() });
|
|
}
|
|
|
|
if (chains[0].underlying_price) |price| {
|
|
try lines.append(arena, .{ .text = try std.fmt.allocPrint(arena, " Underlying: {f} {d} expiration(s) +/- {d} strikes NTM (Ctrl+1-9 to change)", .{ Money.from(price), chains.len, state.near_the_money }), .style = th.contentStyle() });
|
|
}
|
|
|
|
try lines.append(arena, .{ .text = "", .style = th.contentStyle() });
|
|
|
|
// Track header line count for mouse click mapping (after all non-data lines)
|
|
state.header_lines = lines.items.len;
|
|
|
|
// Flat list of options rows with inline expand/collapse
|
|
for (state.rows.items, 0..) |row, ri| {
|
|
const is_cursor = ri == state.cursor;
|
|
switch (row.kind) {
|
|
.expiration => {
|
|
if (row.exp_idx < chains.len) {
|
|
const chain = chains[row.exp_idx];
|
|
const is_expanded = row.exp_idx < state.expanded.len and state.expanded[row.exp_idx];
|
|
const is_monthly = fmt.isMonthlyExpiration(chain.expiration);
|
|
const arrow: []const u8 = if (is_expanded) "v " else "> ";
|
|
const text = try std.fmt.allocPrint(arena, " {s}{f} ({d} calls, {d} puts)", .{
|
|
arrow,
|
|
chain.expiration,
|
|
chain.calls.len,
|
|
chain.puts.len,
|
|
});
|
|
const style = if (is_cursor) th.selectStyle() else if (is_monthly) th.contentStyle() else th.mutedStyle();
|
|
try lines.append(arena, .{ .text = text, .style = style });
|
|
}
|
|
},
|
|
.calls_header => {
|
|
const calls_collapsed = row.exp_idx < state.calls_collapsed.len and state.calls_collapsed[row.exp_idx];
|
|
const arrow: []const u8 = if (calls_collapsed) " > " else " v ";
|
|
const style = if (is_cursor) th.selectStyle() else th.headerStyle();
|
|
try lines.append(arena, .{ .text = try std.fmt.allocPrint(arena, "{s}{s:>10} {s:>10} {s:>10} {s:>10} {s:>10} {s:>8} {s:>8} Calls", .{
|
|
arrow, "Strike", "Last", "Bid", "Ask", "Volume", "OI", "IV",
|
|
}), .style = style });
|
|
},
|
|
.puts_header => {
|
|
const puts_collapsed = row.exp_idx < state.puts_collapsed.len and state.puts_collapsed[row.exp_idx];
|
|
const arrow: []const u8 = if (puts_collapsed) " > " else " v ";
|
|
try lines.append(arena, .{ .text = "", .style = th.contentStyle() });
|
|
const style = if (is_cursor) th.selectStyle() else th.headerStyle();
|
|
try lines.append(arena, .{ .text = try std.fmt.allocPrint(arena, "{s}{s:>10} {s:>10} {s:>10} {s:>10} {s:>10} {s:>8} {s:>8} Puts", .{
|
|
arrow, "Strike", "Last", "Bid", "Ask", "Volume", "OI", "IV",
|
|
}), .style = style });
|
|
},
|
|
.call => {
|
|
if (row.contract) |cc| {
|
|
const atm_price = chains[0].underlying_price orelse 0;
|
|
const itm = cc.strike <= atm_price;
|
|
const prefix: []const u8 = if (itm) " |" else " ";
|
|
var contract_buf: [128]u8 = undefined;
|
|
const text = try arena.dupe(u8, fmt.fmtContractLine(&contract_buf, prefix, cc));
|
|
const style = if (is_cursor) th.selectStyle() else th.contentStyle();
|
|
try lines.append(arena, .{ .text = text, .style = style });
|
|
}
|
|
},
|
|
.put => {
|
|
if (row.contract) |p| {
|
|
const atm_price = chains[0].underlying_price orelse 0;
|
|
const itm = p.strike >= atm_price;
|
|
const prefix: []const u8 = if (itm) " |" else " ";
|
|
var contract_buf: [128]u8 = undefined;
|
|
const text = try arena.dupe(u8, fmt.fmtContractLine(&contract_buf, prefix, p));
|
|
const style = if (is_cursor) th.selectStyle() else th.contentStyle();
|
|
try lines.append(arena, .{ .text = text, .style = style });
|
|
}
|
|
},
|
|
}
|
|
}
|
|
|
|
return lines.toOwnedSlice(arena);
|
|
}
|