@itookit/dsht 0.3.3 → 0.3.7

package/dist/ui/input/viewport.js

@@ -0,0 +1,173 @@
+/** Multi-row composer geometry: wrapping, tab stops, block folding and the cursor window.
+ *
+ * The draft keeps exactly the bytes the user typed or pasted; nothing here mutates it. Display rows
+ * and folded blocks are derived on every render, so an edit never has to rebase a stored span.
+ */
+import stringWidth from 'string-width';
+/** Cells a tab advances to; every stop is a multiple of this width. */
+export const TAB_WIDTH = 4;
+const segments = new Intl.Segmenter(undefined, { granularity: 'grapheme' });
+/** Spaces a tab adds to reach the next stop after the given column.
+ * @param column - Cells already used on the row.
+ * @param width - Tab stop width in cells.
+ * @returns Cell count for one tab, always at least one.
+ */
+export function tabStop(column, width = TAB_WIDTH) { return width - (column % width); }
+/** Byte length of draft text, used for the folded-block size label.
+ * @param text - Source text.
+ * @returns UTF-8 byte length.
+ */
+export function byteLength(text) { return Buffer.byteLength(text, 'utf8'); }
+/** Compact size label for a folded block.
+ * @param bytes - UTF-8 byte length.
+ * @returns Bytes, kilobytes or megabytes with one decimal.
+ */
+export function formatBytes(bytes) {
+    if (bytes < 1024)
+        return `${bytes} B`;
+    return bytes < 1024 * 1024 ? `${(bytes / 1024).toFixed(1)} KB` : `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+/** Offsets where each newline-separated line begins.
+ * @param text - Source text.
+ * @returns One offset per logical line, always at least the offset zero.
+ */
+function lineStarts(text) {
+    const starts = [0];
+    for (let index = 0; index < text.length;) {
+        const next = text.indexOf('\n', index);
+        if (next === -1)
+            break;
+        starts.push(next + 1);
+        index = next + 1;
+    }
+    return starts;
+}
+/** Wrap a draft into display rows, expanding tabs and hard-breaking long segments.
+ *
+ * A newline belongs to the end of the row it closes, so a cursor parked on it renders at that row's
+ * end and a cursor just after it renders at the next row's start.
+ * @param text - Source text, including newlines and tabs.
+ * @param width - Row width in cells.
+ * @param tabWidth - Tab stop width in cells.
+ * @returns One entry per rendered row, in order.
+ */
+export function wrapDraft(text, width, tabWidth = TAB_WIDTH) {
+    const limit = Math.max(1, Math.floor(width));
+    const rows = [];
+    let row = { text: '', start: 0, end: 0, map: [0] };
+    let column = 0;
+    let offset = 0;
+    const close = (end) => { row.end = end; rows.push(row); };
+    const open = (start) => { row = { text: '', start, end: start, map: [0] }; column = 0; };
+    for (const { segment } of segments.segment(text)) {
+        const length = segment.length;
+        if (segment === '\n') {
+            row.map.push(row.text.length);
+            close(offset + length);
+            open(offset + length);
+            offset += length;
+            continue;
+        }
+        const display = segment === '\t' ? ' '.repeat(tabStop(column, tabWidth)) : segment;
+        const cells = segment === '\t' ? display.length : stringWidth(segment);
+        if (column > 0 && column + cells > limit) {
+            close(offset);
+            open(offset);
+        }
+        row.text += display;
+        column += cells;
+        offset += length;
+        row.map.push(row.text.length);
+    }
+    close(offset);
+    return rows;
+}
+/** Locate the cursor among rendered rows.
+ * @param rows - Rendered rows from `wrapDraft`.
+ * @param cursor - Source offset of the cursor.
+ * @returns Row index, display index within that row, and its cell column.
+ */
+export function cursorPlace(rows, cursor) {
+    for (let row = 0; row < rows.length; row++) {
+        const current = rows[row];
+        if (cursor >= current.start && cursor < current.end) {
+            const index = current.map[cursor - current.start] ?? current.text.length;
+            return { row, index, column: stringWidth(current.text.slice(0, index)) };
+        }
+    }
+    const row = rows.length - 1;
+    const last = rows[row];
+    return { row, index: last.text.length, column: stringWidth(last.text) };
+}
+/** Choose the visible slice of rows that keeps the cursor on screen.
+ * @param count - Total rendered row count.
+ * @param cursorRow - Row index the cursor occupies.
+ * @param maxRows - Content rows the composer may show.
+ * @returns Half-open row range to render.
+ */
+export function windowRows(count, cursorRow, maxRows) {
+    const size = Math.max(1, Math.floor(maxRows));
+    if (count <= size)
+        return { start: 0, end: count };
+    const start = Math.min(Math.max(0, cursorRow - size + 1), count - size);
+    return { start, end: start + size };
+}
+/** Shift a wrapped slice back to the source offsets it was cut from.
+ * @param rows - Rows wrapped from a slice.
+ * @param base - Source offset the slice started at.
+ * @returns The same rows with absolute offsets.
+ */
+function rebase(rows, base) {
+    return base === 0 ? rows : rows.map(row => ({ ...row, start: row.start + base, end: row.end + base }));
+}
+/** Summary row for a folded interior.
+ * @param text - Whole draft.
+ * @param starts - Logical line starts.
+ * @param from - First folded source offset.
+ * @param to - One past the last folded source offset.
+ * @returns The row that replaces the interior.
+ */
+function summary(text, starts, from, to) {
+    return { text: '', start: from, end: to, map: [],
+        fold: { from, to, lines: starts.length - 2, bytes: byteLength(text.slice(from, to)) } };
+}
+/** Wrap and fold a draft for display.
+ *
+ * A block is folded only when the draft has interior lines to hide and its whole wrapped height
+ * exceeds the composer window. The decision reads the unfolded height, so folding can never feed
+ * back into itself and oscillate. When the logical line count alone already exceeds the window the
+ * interior is never wrapped, which keeps a very large paste cheap to re-plan on every keystroke.
+ * @param text - Source text, including newlines and tabs.
+ * @param width - Row width in cells.
+ * @param maxRows - Content rows the composer may show.
+ * @param tabWidth - Tab stop width in cells.
+ * @returns Rows to render and the source range of every folded block.
+ */
+export function planDraft(text, width, maxRows, tabWidth = TAB_WIDTH) {
+    const starts = lineStarts(text);
+    const size = Math.max(1, Math.floor(maxRows));
+    if (starts.length >= 3 && starts.length > size) {
+        const from = starts[1];
+        const to = starts[starts.length - 1];
+        // The head slice ends with the newline that closes its last line, so the empty row that
+        // newline opens belongs to the block being folded, not to the head.
+        const head = wrapDraft(text.slice(0, from), width, tabWidth);
+        head.pop();
+        return { rows: [...head, summary(text, starts, from, to),
+                ...rebase(wrapDraft(text.slice(to), width, tabWidth), to)], regions: [{ start: from, end: to }] };
+    }
+    const rows = wrapDraft(text, width, tabWidth);
+    if (starts.length < 3 || rows.length <= size)
+        return { rows, regions: [] };
+    const from = starts[1];
+    const to = starts[starts.length - 1];
+    return { rows: [...rows.filter(row => row.start < from), summary(text, starts, from, to), ...rows.filter(row => row.start >= to)],
+        regions: [{ start: from, end: to }] };
+}
+/** Display label for a folded block.
+ * @param fold - Folded-block facts.
+ * @returns A single-line summary such as `[84 lines · 6.1 KB]`.
+ */
+export function foldLabel(fold) {
+    return `[${fold.lines} lines · ${formatBytes(fold.bytes)}]`;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@itookit/dsht",
-  "version": "0.3.3",
+  "version": "0.3.7",
   "type": "module",
   "description": "Remote-first TUI for DeepSeek Harness with SSH-friendly mobile access and request-level cost tracking",
   "engines": {
@@ -25,8 +25,8 @@
     "access": "public"
   },
   "scripts": {
-    "start": "tsx src/cli/index.tsx",
-    "start:profile": "node -e \"require('node:fs').mkdirSync('.diagnostics',{recursive:true})\" && NODE_OPTIONS=\"--expose-gc --heapsnapshot-signal=SIGUSR2 --diagnostic-dir=.diagnostics\" tsx src/cli/index.tsx",
+    "start": "tsx src/cli/index.ts",
+    "start:profile": "node -e \"require('node:fs').mkdirSync('.diagnostics',{recursive:true})\" && NODE_OPTIONS=\"--expose-gc --heapsnapshot-signal=SIGUSR2 --diagnostic-dir=.diagnostics\" tsx src/cli/index.ts",
     "build": "node -e \"require('node:fs').rmSync('dist',{recursive:true,force:true})\" && tsc",
     "typecheck": "tsc --noEmit && tsc -p tsconfig.tests.json",
     "test": "tsx --test tests/*/*.test.ts tests/*/*.test.tsx",

package/dist/ui/input/history.d.ts

@@ -1,19 +0,0 @@
-/** Bounded, process-local recall history; never stores transcripts or writes prompt text to disk. */
-export declare class InputHistory {
-    private entries;
-    private bytes;
-    private position;
-    private draft;
-    /** Remember submitted input, coalescing consecutive duplicates and enforcing both budgets.
-     * @param value - Submitted command or prompt, excluding interaction answers.
-     */
-    record(value: string): void;
-    /** Leave recall navigation when the composer is edited or otherwise replaced. */
-    reset(): void;
-    /** Recall older/newer input, restoring the original unsent draft at the end.
-     * @param direction - Negative for older input, positive for newer input.
-     * @param current - Current composer content before beginning recall.
-     * @returns Recalled input, or the original draft when returning to the newest position.
-     */
-    move(direction: -1 | 1, current: string): string;
-}

package/dist/ui/input/history.js

@@ -1,43 +0,0 @@
-/** Bounded, process-local recall history; never stores transcripts or writes prompt text to disk. */
-export class InputHistory {
-    entries = [];
-    bytes = 0;
-    position;
-    draft = '';
-    /** Remember submitted input, coalescing consecutive duplicates and enforcing both budgets.
-     * @param value - Submitted command or prompt, excluding interaction answers.
-     */
-    record(value) {
-        this.reset();
-        if (!value || this.entries.at(-1) === value || value.length * 2 > 256 * 1024)
-            return;
-        this.entries.push(value);
-        this.bytes += value.length * 2;
-        while (this.entries.length > 200 || this.bytes > 256 * 1024)
-            this.bytes -= this.entries.shift().length * 2;
-    }
-    /** Leave recall navigation when the composer is edited or otherwise replaced. */
-    reset() { this.position = undefined; this.draft = ''; }
-    /** Recall older/newer input, restoring the original unsent draft at the end.
-     * @param direction - Negative for older input, positive for newer input.
-     * @param current - Current composer content before beginning recall.
-     * @returns Recalled input, or the original draft when returning to the newest position.
-     */
-    move(direction, current) {
-        if (!this.entries.length)
-            return current;
-        if (this.position === undefined) {
-            if (direction > 0)
-                return current;
-            this.position = this.entries.length;
-            this.draft = current;
-        }
-        this.position = Math.max(0, Math.min(this.entries.length, this.position + direction));
-        if (this.position === this.entries.length) {
-            const draft = this.draft;
-            this.reset();
-            return draft;
-        }
-        return this.entries[this.position];
-    }
-}