@north-light/crouter 0.3.200 → 0.3.202

package/dist/clients/attach/session/transcript-search.js

@@ -0,0 +1,151 @@
+// session/transcript-search.ts — incremental transcript search: the mode, its
+// one-row bar, and the keys that drive it.
+//
+// The viewer keeps the terminal in the normal buffer and renders exactly one
+// screenful per frame, so tmux copy-mode's `/` only ever sees what is already
+// on screen. Searching the transcript therefore has to happen here, against the
+// same rendered rows the viewport draws.
+//
+// Two states, both visible on the bar. EDITING owns typed characters and jumps
+// as you type; BROWSING owns only n/N (and `/` to edit again), and any other
+// printable key closes search and falls through to the editor, so getting back
+// to typing a prompt never needs a deliberate dismissal.
+import { truncateToWidth } from '@earendil-works/pi-tui';
+import { visibleWidth } from '../../../core/canvas/nav-render.js';
+import { formatBinding } from '../../../core/keybindings/index.js';
+import { matchesAttachBinding } from './bindings.js';
+/** A chunk is typed text only when every code point in it is printable — an
+ *  escape sequence, control byte, or paste of either is somebody else's. */
+function printableText(data) {
+    if (data === '')
+        return undefined;
+    for (const character of data) {
+        const code = character.codePointAt(0);
+        if (code < 0x20 || code === 0x7f)
+            return undefined;
+    }
+    return data;
+}
+export function createTranscriptSearch(tui, pal, viewport, model, hooks) {
+    let mode = 'closed';
+    /** Where the query search started from, so editing re-seeks from one place
+     *  instead of chasing its own jumps character by character. */
+    let anchor = 0;
+    let draft = '';
+    const width = () => tui.terminal.columns;
+    const jump = (match) => {
+        if (match !== undefined)
+            viewport.scrollToLine(match.line);
+        tui.requestRender();
+    };
+    const applyDraft = () => {
+        model.setQuery(draft, anchor);
+        jump(model.current(width()));
+    };
+    const close = () => {
+        mode = 'closed';
+        draft = '';
+        model.setQuery('', undefined);
+        tui.requestRender();
+    };
+    const open = () => {
+        if (mode === 'closed')
+            anchor = viewport.topLine() ?? 0;
+        mode = 'editing';
+        draft = model.query();
+        tui.requestRender();
+    };
+    const step = (direction) => {
+        const match = model.step(width(), direction);
+        if (match === undefined) {
+            hooks.setNotice(`No matches for “${model.query()}”`);
+            return;
+        }
+        jump(match);
+    };
+    const component = {
+        render(renderWidth) {
+            if (mode === 'closed')
+                return [];
+            const { index, total } = model.status(renderWidth);
+            const left = mode === 'editing'
+                ? `${pal.accent('⌕')} ${draft}${pal.accent('▌')}`
+                : `${pal.accent('⌕')} ${draft}`;
+            const count = total === 0
+                ? (model.query() === '' ? pal.faint('type to search what is on screen') : pal.error('no matches'))
+                : pal.info(`${index}/${total}`);
+            const hints = mode === 'editing'
+                ? pal.faint('enter browse · esc cancel')
+                : pal.faint([
+                    `${formatBinding(hooks.bindings(), 'crtr.attach.search.next')} next`,
+                    `${formatBinding(hooks.bindings(), 'crtr.attach.search.previous')} prev`,
+                    `${formatBinding(hooks.bindings(), 'crtr.attach.search.edit')} edit`,
+                    `${formatBinding(hooks.bindings(), 'crtr.attach.search.close')} close`,
+                ].join(' · '));
+            const right = `${count}  ${hints}`;
+            const gap = renderWidth - visibleWidth(left) - visibleWidth(right) - 2;
+            const line = gap < 1
+                ? truncateToWidth(` ${left}`, renderWidth, '', true)
+                : ` ${left}${' '.repeat(gap)}${right} `;
+            return [line];
+        },
+        invalidate() {
+            /* Rendered fresh from the model on every frame. */
+        },
+    };
+    const handleKey = (data) => {
+        if (mode === 'closed')
+            return false;
+        const bindings = hooks.bindings();
+        if (matchesAttachBinding(bindings, 'crtr.attach.search.close', data)) {
+            close();
+            return true;
+        }
+        if (mode === 'editing') {
+            if (data === '\x03') {
+                close();
+                return true;
+            }
+            if (data === '\r' || data === '\n') {
+                if (model.status(width()).total === 0) {
+                    hooks.setNotice(draft === '' ? 'Type something to search for' : `No matches for “${draft}”`);
+                    return true;
+                }
+                mode = 'browsing';
+                tui.requestRender();
+                return true;
+            }
+            if (data === '\x7f' || data === '\b') {
+                draft = [...draft].slice(0, -1).join('');
+                applyDraft();
+                return true;
+            }
+            const typed = printableText(data);
+            if (typed === undefined)
+                return false;
+            draft += typed;
+            applyDraft();
+            return true;
+        }
+        if (matchesAttachBinding(bindings, 'crtr.attach.search.next', data) || data === '\r' || data === '\n') {
+            step(1);
+            return true;
+        }
+        if (matchesAttachBinding(bindings, 'crtr.attach.search.previous', data)) {
+            step(-1);
+            return true;
+        }
+        if (matchesAttachBinding(bindings, 'crtr.attach.search.edit', data)) {
+            open();
+            return true;
+        }
+        // Browsing holds only its own gestures. Ordinary typing means the user is
+        // done searching: dismiss and let the chunk land in the editor as typed.
+        if (printableText(data) !== undefined) {
+            close();
+            return false;
+        }
+        return false;
+    };
+    return { component, open, close, handleKey };
+}