@devries-cameron20 / t3code Mirror · read-only
Fork 0

The best way to control Claude Code, Codex and more from any computer or phone

Mirrored from https://github.com/Camo67/t3code.git

Synced Nov 21, 04:45 UTC

main
ts 261 lines 8.33 KB
Raw
1 // Adapted from opencode (MIT). Copyright (c) 2025 opencode. See LICENSE.opencode.
2 import type { XlsxAnchor } from "@betteroffice/xlsx";
3 import {
4 selectionAt,
5 type CellAddr,
6 type CellRange,
7 type Selection,
8 } from "@betteroffice/xlsx/headless";
9
10 /** The sheet's last cell, zero-based: row 1,048,576 in column XFD. */
11 export const lastCell = { row: 1048575, col: 16383 };
12
13 /** A column's letters, such as "A", "Z" or "AA". */
14 export function columnName(index: number): string {
15 return (
16 (index < 26 ? "" : columnName(Math.floor(index / 26) - 1)) +
17 String.fromCharCode(65 + (index % 26))
18 );
19 }
20
21 /** The cells an export anchor names: one range for a cell or range anchor, none for any other kind. */
22 export function anchorRange(anchor: XlsxAnchor): CellRange[] {
23 if (anchor.kind !== "cell" && anchor.kind !== "range") return [];
24
25 const range = parseRange(anchor.a1);
26
27 return range ? [range] : [];
28 }
29
30 /** An A1 cell or range, such as "B2" or "A1:F20"; undefined for anything else. */
31 export function parseRange(a1: string): CellRange | undefined {
32 // A lone cell is its own last corner; an empty one, as in "A1:", names no range.
33 const corners = a1.split(":");
34 const first = parseCell(corners[0] ?? "");
35 const last = corners.length === 1 ? first : parseCell(corners[1] ?? "");
36
37 if (!first || !last) return undefined;
38
39 return {
40 top: Math.min(first.row, last.row),
41 left: Math.min(first.col, last.col),
42 bottom: Math.max(first.row, last.row),
43 right: Math.max(first.col, last.col),
44 };
45 }
46
47 /** Grows a range until it covers every merged cell it touches, as Excel selects. */
48 export function coverMerges(range: CellRange, merges: readonly CellRange[]): CellRange {
49 let grown = range;
50 for (let pass = 0; pass < 2; pass++) {
51 const next = merges.reduce(
52 (current, merge) =>
53 overlaps(current, merge)
54 ? {
55 top: Math.min(current.top, merge.top),
56 left: Math.min(current.left, merge.left),
57 bottom: Math.max(current.bottom, merge.bottom),
58 right: Math.max(current.right, merge.right),
59 }
60 : current,
61 grown,
62 );
63 if (same(next, grown)) return next;
64 grown = next;
65 }
66
67 // Each overlap inequality becomes true only once as the selection grows. Sweep sorted
68 // edges so a chain of merges cannot force repeated full scans or recursive stack growth.
69 const sweeps = (
70 [
71 { mergeEdge: "top", rangeEdge: "bottom", direction: 1 },
72 { mergeEdge: "bottom", rangeEdge: "top", direction: -1 },
73 { mergeEdge: "left", rangeEdge: "right", direction: 1 },
74 { mergeEdge: "right", rangeEdge: "left", direction: -1 },
75 ] as const
76 ).map(({ mergeEdge, rangeEdge, direction }) => ({
77 rangeEdge,
78 direction,
79 position: 0,
80 edges: merges
81 .map((merge, index) => ({ index, value: direction * merge[mergeEdge] }))
82 .sort((a, b) => a.value - b.value),
83 }));
84 const crossed = new Uint8Array(merges.length);
85 let changed;
86 do {
87 changed = false;
88 for (const sweep of sweeps) {
89 let edge = sweep.edges[sweep.position];
90 while (edge && edge.value <= sweep.direction * grown[sweep.rangeEdge]) {
91 const index = edge.index;
92 crossed[index] = crossed[index]! + 1;
93 if (crossed[index] === 4) {
94 const merge = merges[index]!;
95 const next = {
96 top: Math.min(grown.top, merge.top),
97 left: Math.min(grown.left, merge.left),
98 bottom: Math.max(grown.bottom, merge.bottom),
99 right: Math.max(grown.right, merge.right),
100 };
101 changed ||= !same(grown, next);
102 grown = next;
103 }
104 edge = sweep.edges[++sweep.position];
105 }
106 }
107 } while (changed);
108
109 return grown;
110 }
111
112 /**
113 * Moves a collapsed selection the way Excel moves its active cell around merged cells: landing in one selects its
114 * first cell, and a step that stays inside the merged cell it started from steps past it.
115 */
116 export function settleMerges(
117 previous: Selection,
118 next: Selection,
119 merges: readonly CellRange[],
120 ): Selection {
121 if (!collapsed(next)) return next;
122
123 const merge = merges.find((candidate) => contains(candidate, next.focus));
124
125 if (!merge) return next;
126
127 if (!collapsed(previous) || !contains(merge, previous.focus))
128 return selectionAt({ row: merge.top, col: merge.left });
129
130 const cell = {
131 row: Math.min(
132 lastCell.row,
133 Math.max(0, past(previous.focus.row, next.focus.row, merge.top, merge.bottom)),
134 ),
135 col: Math.min(
136 lastCell.col,
137 Math.max(0, past(previous.focus.col, next.focus.col, merge.left, merge.right)),
138 ),
139 };
140
141 const landed = merges.find((candidate) => contains(candidate, cell));
142
143 return selectionAt(landed ? { row: landed.top, col: landed.left } : cell);
144 }
145
146 /** A run of hidden rows or columns, zero-based and inclusive. */
147 export type Span = { readonly start: number; readonly end: number };
148
149 /** Hidden row spans such as "5:7", or column spans such as "C:D", as the export lists them. */
150 export function parseSpans(spans: readonly string[], axis: "rows" | "columns"): Span[] {
151 return spans.flatMap((span) => {
152 const [first = "", last = first] = span.split(":");
153 const start = axis === "rows" ? Number(first) - 1 : columnIndex(first);
154 const end = axis === "rows" ? Number(last) - 1 : columnIndex(last);
155
156 return Number.isInteger(start) && Number.isInteger(end) && start >= 0 && end >= start
157 ? [{ start, end }]
158 : [];
159 });
160 }
161
162 /**
163 * Moves a selection's focus off hidden rows and columns, on in the direction it moved, as Excel's arrow keys skip
164 * them. A move that would leave the sheet stays where it started.
165 */
166 export function skipHidden(
167 from: CellAddr,
168 selection: Selection,
169 hidden: { readonly rows: readonly Span[]; readonly columns: readonly Span[] },
170 ): Selection {
171 const focus = {
172 row: clear(from.row, selection.focus.row, hidden.rows, lastCell.row),
173 col: clear(from.col, selection.focus.col, hidden.columns, lastCell.col),
174 };
175
176 if (focus.row === selection.focus.row && focus.col === selection.focus.col) return selection;
177
178 if (collapsed(selection)) return selectionAt(focus);
179
180 return { anchor: selection.anchor, focus };
181 }
182
183 /** Runs an engine call that throws on input it cannot take, such as a viewport with too many cells to draw. */
184 export function attempt<T>(run: () => T): T | undefined {
185 try {
186 return run();
187 } catch {
188 return undefined;
189 }
190 }
191
192 /** Whether a range holds a cell. */
193 export function contains(range: CellRange, cell: CellAddr) {
194 return (
195 cell.row >= range.top &&
196 cell.row <= range.bottom &&
197 cell.col >= range.left &&
198 cell.col <= range.right
199 );
200 }
201
202 function parseCell(a1: string): CellAddr | undefined {
203 const match = /^\$?([A-Z]{1,3})\$?([1-9]\d*)$/i.exec(a1);
204
205 if (!match) return undefined;
206
207 const col = columnIndex(match[1]!);
208 const row = Number(match[2]) - 1;
209
210 if (col > lastCell.col || row > lastCell.row) return undefined;
211
212 return { row, col };
213 }
214
215 /** A column's zero-based index from its letters; NaN for anything but one to three letters. */
216 function columnIndex(letters: string) {
217 if (!/^[A-Z]{1,3}$/i.test(letters)) return Number.NaN;
218
219 return (
220 [...letters.toUpperCase()].reduce(
221 (total, letter) => total * 26 + letter.charCodeAt(0) - 64,
222 0,
223 ) - 1
224 );
225 }
226
227 /** Where a move along one axis lands once past any hidden span it ended in. */
228 function clear(from: number, to: number, spans: readonly Span[], last: number): number {
229 const span = spans.find((candidate) => to >= candidate.start && to <= candidate.end);
230
231 if (!span || to === from) return to;
232
233 const next = to > from ? span.end + 1 : span.start - 1;
234
235 if (next < 0 || next > last) return from;
236
237 return clear(from, next, spans, last);
238 }
239
240 /** One step along an axis: past the merge's far edge in the direction of the move, or where it was. */
241 function past(from: number, to: number, low: number, high: number) {
242 if (to > from) return high + 1;
243
244 if (to < from) return low - 1;
245
246 return from;
247 }
248
249 function collapsed(selection: Selection) {
250 return (
251 selection.anchor.row === selection.focus.row && selection.anchor.col === selection.focus.col
252 );
253 }
254
255 function overlaps(a: CellRange, b: CellRange) {
256 return a.left <= b.right && a.right >= b.left && a.top <= b.bottom && a.bottom >= b.top;
257 }
258
259 function same(a: CellRange, b: CellRange) {
260 return a.top === b.top && a.left === b.left && a.bottom === b.bottom && a.right === b.right;
261 }