@timurproko/a1 0.1.8-dev.137 → 0.1.8-dev.151

package/dist/ui/components/text-selection.d.ts

@@ -0,0 +1,53 @@
+export interface TextSelectionPoint {
+    readonly line: number;
+    readonly column: number;
+}
+export interface TextSelection {
+    readonly anchor: TextSelectionPoint;
+    readonly head: TextSelectionPoint;
+    readonly selecting: boolean;
+    readonly cell?: boolean;
+    readonly fullRow?: boolean;
+    /** Paint an edge whitespace run through the viewport's overlaid rail cell. */
+    readonly throughFinalColumn?: boolean;
+}
+export interface TextSelectionClick {
+    readonly time: number;
+    readonly line: number;
+    readonly column: number;
+    readonly count: number;
+}
+export interface TextSelectionLineContent {
+    readonly from?: number;
+    readonly to?: number;
+    readonly selectable?: boolean;
+}
+export interface OrderedTextSelection {
+    readonly start: TextSelectionPoint;
+    readonly end: TextSelectionPoint;
+    readonly fullRow?: boolean;
+    readonly throughFinalColumn?: boolean;
+}
+export interface TextSelectionPressInput {
+    readonly line: number;
+    readonly column: number;
+    readonly contentWidth: number;
+    readonly lineText: string;
+    readonly lineContent?: TextSelectionLineContent;
+    readonly previousClick?: TextSelectionClick;
+    readonly now?: number;
+}
+export declare const TEXT_SELECTION_MULTI_CLICK_MS = 500;
+export declare function orderedTextSelection(selection: TextSelection | undefined): OrderedTextSelection | undefined;
+export declare function pressTextSelection(input: TextSelectionPressInput): {
+    readonly selection?: TextSelection;
+    readonly click: TextSelectionClick;
+    readonly kind: "point" | "word" | "line";
+};
+export declare function extendTextSelection(selection: TextSelection | undefined, point: TextSelectionPoint): TextSelection | undefined;
+export declare function releaseTextSelection(selection: TextSelection | undefined): TextSelection | undefined;
+export declare function textSelectionLineExtendColumn(selection: TextSelection, line: number, contentWidth: number): number;
+export declare function textSelectionText(selection: OrderedTextSelection, rows: readonly string[], lineContent?: (line: number) => TextSelectionLineContent | undefined): string;
+/** Returns the plain cells covered by [from,to), using terminal grapheme widths. */
+export declare function plainTextBetweenColumns(line: string, from: number, to: number): string;
+export declare function usefulTextLineContent(line: string, from?: number): TextSelectionLineContent;

package/dist/ui/components/text-selection.js

@@ -0,0 +1,168 @@
+import { displayWidth, stripAnsi } from "./text.js";
+const GRAPHEMES = new Intl.Segmenter(undefined, { granularity: "grapheme" });
+export const TEXT_SELECTION_MULTI_CLICK_MS = 500;
+export function orderedTextSelection(selection) {
+    if (selection === undefined)
+        return undefined;
+    const { anchor, head } = selection;
+    if (anchor.line === head.line && anchor.column === head.column && !selection.cell && !selection.fullRow)
+        return undefined;
+    const anchorFirst = anchor.line < head.line || (anchor.line === head.line && anchor.column <= head.column);
+    const ordered = anchorFirst
+        ? { start: anchor, end: head }
+        : { start: head, end: anchor };
+    return {
+        ...ordered,
+        ...(selection.fullRow ? { fullRow: true } : {}),
+        ...(selection.throughFinalColumn ? { throughFinalColumn: true } : {}),
+    };
+}
+export function pressTextSelection(input) {
+    const now = input.now ?? Date.now();
+    const previous = input.previousClick;
+    const count = previous !== undefined
+        && now - previous.time <= TEXT_SELECTION_MULTI_CLICK_MS
+        && previous.line === input.line
+        && Math.abs(previous.column - input.column) <= 1
+        ? previous.count + 1
+        : 1;
+    const click = { time: now, line: input.line, column: input.column, count };
+    const column = clamp(input.column, 1, Math.max(1, input.contentWidth));
+    const kind = ((count - 1) % 3) + 1;
+    if (kind === 2) {
+        const selection = selectWord(input.line, column, input.contentWidth, input.lineText);
+        return selection === undefined ? { click, kind: "word" } : { selection, click, kind: "word" };
+    }
+    if (kind === 3) {
+        if (input.lineContent?.selectable === false)
+            return { click, kind: "line" };
+        const from = clamp(input.lineContent?.from ?? 1, 1, Math.max(1, input.contentWidth));
+        const to = clamp(input.lineContent?.to ?? input.contentWidth, from, Math.max(1, input.contentWidth));
+        return {
+            selection: {
+                anchor: { line: input.line, column: from },
+                head: { line: input.line, column: to },
+                selecting: true,
+                cell: true,
+                fullRow: true,
+            },
+            click,
+            kind: "line",
+        };
+    }
+    return {
+        selection: {
+            anchor: { line: input.line, column },
+            head: { line: input.line, column },
+            selecting: true,
+            cell: false,
+        },
+        click,
+        kind: "point",
+    };
+}
+export function extendTextSelection(selection, point) {
+    if (selection?.selecting !== true)
+        return selection;
+    if (selection.fullRow) {
+        if (point.line === selection.anchor.line && selection.head.line === selection.anchor.line)
+            return selection;
+        const edge = point.line < selection.anchor.line ? Number.MAX_SAFE_INTEGER : 1;
+        if (selection.anchor.column !== edge) {
+            return { ...selection, anchor: { line: selection.anchor.line, column: edge }, head: point };
+        }
+    }
+    return { ...selection, head: point };
+}
+export function releaseTextSelection(selection) {
+    if (selection === undefined)
+        return undefined;
+    const released = selection.selecting ? { ...selection, selecting: false } : selection;
+    return orderedTextSelection(released) === undefined ? undefined : released;
+}
+export function textSelectionLineExtendColumn(selection, line, contentWidth) {
+    return line < selection.anchor.line ? 1 : Math.max(1, contentWidth);
+}
+export function textSelectionText(selection, rows, lineContent) {
+    const parts = [];
+    for (let line = selection.start.line; line <= selection.end.line && line < rows.length; line += 1) {
+        const plain = stripAnsi(rows[line] ?? "");
+        const content = lineContent?.(line);
+        if (content?.selectable === false) {
+            parts.push("");
+            continue;
+        }
+        const baseFrom = line === selection.start.line ? selection.start.column - 1 : 0;
+        const baseTo = line === selection.end.line ? selection.end.column : Number.MAX_SAFE_INTEGER;
+        const from = Math.max(baseFrom, Math.max(0, (content?.from ?? 1) - 1));
+        const to = Math.max(from, Math.min(baseTo, content?.to ?? Number.MAX_SAFE_INTEGER));
+        parts.push(plain.slice(indexAtDisplayWidth(plain, from), indexAtDisplayWidth(plain, to)).trimEnd());
+    }
+    return parts.join("\n");
+}
+/** Returns the plain cells covered by [from,to), using terminal grapheme widths. */
+export function plainTextBetweenColumns(line, from, to) {
+    const plain = stripAnsi(line);
+    return plain.slice(indexAtDisplayWidth(plain, from), indexAtDisplayWidth(plain, to));
+}
+export function usefulTextLineContent(line, from = 1) {
+    const start = Math.max(1, from);
+    const end = displayWidth(stripAnsi(line).replace(/\s+$/, "")) + 1;
+    return { from: start, to: Math.max(start, end) };
+}
+function selectWord(line, column, contentWidth, lineText) {
+    const plain = stripAnsi(lineText);
+    const segments = [];
+    let width = 0;
+    for (const { segment } of GRAPHEMES.segment(plain)) {
+        const cellWidth = displayWidth(segment);
+        if (cellWidth <= 0)
+            continue;
+        segments.push({ cls: characterClass(segment), from: width, to: width + cellWidth });
+        width += cellWidth;
+    }
+    const at = clamp(column, 1, Math.max(1, contentWidth)) - 1;
+    const index = segments.findIndex(segment => at >= segment.from && at < segment.to);
+    if (index < 0)
+        return undefined;
+    let low = index;
+    let high = index;
+    while (low > 0 && segments[low - 1]?.cls === segments[index]?.cls)
+        low -= 1;
+    while (high + 1 < segments.length && segments[high + 1]?.cls === segments[index]?.cls)
+        high += 1;
+    const end = segments[high]?.to ?? 1;
+    return {
+        anchor: { line, column: (segments[low]?.from ?? 0) + 1 },
+        head: { line, column: end },
+        selecting: true,
+        cell: true,
+        throughFinalColumn: segments[index]?.cls === 0 && end >= contentWidth,
+    };
+}
+function characterClass(character) {
+    if (/\s/u.test(character))
+        return 0;
+    if (/[\p{L}\p{N}_]/u.test(character))
+        return 1;
+    return 2;
+}
+function indexAtDisplayWidth(plain, column) {
+    if (column <= 0)
+        return 0;
+    let width = 0;
+    let index = 0;
+    for (const { segment } of GRAPHEMES.segment(plain)) {
+        const cellWidth = displayWidth(segment);
+        if (width + cellWidth > column)
+            break;
+        width += cellWidth;
+        index += segment.length;
+        if (width >= column)
+            break;
+    }
+    return index;
+}
+function clamp(value, minimum, maximum) {
+    return Math.max(minimum, Math.min(value, maximum));
+}

package/dist/ui/components/text.d.ts

@@ -6,6 +6,20 @@
  */
 /** Removes styling sequences so only visible characters remain. */
 export declare function stripAnsi(text: string): string;
+export interface DisplayColumnRange {
+    readonly from: number;
+    readonly to: number;
+}
+/** Visible-column segment (word, whitespace, or punctuation) under a pointer column. */
+export declare function displayWordColumnRange(text: string, pointerColumn: number): DisplayColumnRange | null;
+export interface DisplayColumnSlice {
+    /** Grapheme-aligned visible bounds in the source row. */
+    readonly from: number;
+    readonly to: number;
+    readonly text: string;
+}
+/** Plain graphemes intersecting a visible-column range, expanded at wide-character edges. */
+export declare function displayColumnSlice(text: string, requestedFrom: number, requestedTo: number): DisplayColumnSlice;
 /** Columns this text occupies once styling is removed. */
 export declare function displayWidth(text: string): number;
 /**

package/dist/ui/components/text.js

@@ -6,6 +6,7 @@
  */
 const ANSI_PATTERN = /\[[0-9;:?]*[ -/]*[@-~]|\][^]*(?:|\\)|[@-Z\\-_]/g;
 const SEGMENTER = new Intl.Segmenter(undefined, { granularity: "grapheme" });
+const WORD_SEGMENTER = new Intl.Segmenter(undefined, { granularity: "word" });
 /** Removes styling sequences so only visible characters remain. */
 export function stripAnsi(text) {
     return text.replace(ANSI_PATTERN, "");
@@ -62,6 +63,45 @@ function graphemeWidth(grapheme) {
     }
     return width;
 }
+/** Visible-column segment (word, whitespace, or punctuation) under a pointer column. */
+export function displayWordColumnRange(text, pointerColumn) {
+    const plain = stripAnsi(text);
+    const pointer = Math.max(0, pointerColumn);
+    let column = 0;
+    for (const { segment } of WORD_SEGMENTER.segment(plain)) {
+        const width = displayWidth(segment);
+        const from = column;
+        const to = column + width;
+        if (pointer >= from && pointer < to)
+            return { from, to };
+        column = to;
+    }
+    return null;
+}
+/** Plain graphemes intersecting a visible-column range, expanded at wide-character edges. */
+export function displayColumnSlice(text, requestedFrom, requestedTo) {
+    const plain = stripAnsi(text);
+    const from = Math.max(0, requestedFrom);
+    const to = Math.max(from, requestedTo);
+    let column = 0;
+    let actualFrom;
+    let actualTo = from;
+    let selected = "";
+    for (const { segment } of SEGMENTER.segment(plain)) {
+        const width = graphemeWidth(segment);
+        const start = column;
+        const end = column + width;
+        if (end > from && start < to) {
+            actualFrom ??= start;
+            actualTo = end;
+            selected += segment;
+        }
+        column = end;
+        if (start >= to)
+            break;
+    }
+    return { from: actualFrom ?? from, to: actualFrom === undefined ? from : actualTo, text: selected };
+}
 /** Columns this text occupies once styling is removed. */
 export function displayWidth(text) {
     let width = 0;

package/dist/ui/components/transcript-viewport.d.ts

@@ -0,0 +1,104 @@
+import { type ScrollbarAppearance, type ScrollbarGeometry, type ScrollbarStyle } from "./scrollbar.js";
+export interface TranscriptPromptAnchor {
+    readonly id: string;
+    readonly firstRow: number;
+    readonly lastRow: number;
+    /** The source first row, including its submitted-prompt styling and timestamp. */
+    readonly sourceRow: string;
+}
+export interface TranscriptViewportConfig {
+    readonly scrollbarAppearance: ScrollbarAppearance;
+    readonly scrollbarStyle: ScrollbarStyle;
+}
+export interface TranscriptViewportTheme {
+    readonly track: (text: string) => string;
+    readonly thumb: (text: string, active: boolean) => string;
+    readonly sticky: (text: string, hovered: boolean) => string;
+    readonly quietSticky: (text: string) => string;
+    readonly bottomControl: (text: string, hovered: boolean) => string;
+    readonly selection: (line: string, from: number, to: number) => string;
+}
+export interface TranscriptViewportFrameInput {
+    readonly documentRows: readonly string[];
+    /** Optional paint-only transform; semantic selection and copying keep documentRows exact. */
+    readonly paintDocumentRow?: (row: string) => string;
+    /** Leading document rows that participate in pointer selection and copying. */
+    readonly selectableDocumentRowCount?: number;
+    readonly dockRows: readonly string[];
+    readonly promptAnchors: readonly TranscriptPromptAnchor[];
+    readonly width: number;
+    readonly height: number;
+    /**
+     * Optional zero-based terminal row for the floating bottom control. The shell
+     * supplies a stable anchor above its editor group so transient status and
+     * notification rows cannot make the control jump vertically.
+     */
+    readonly bottomControlRow?: number;
+    readonly now?: number;
+    readonly theme?: TranscriptViewportTheme;
+}
+export interface TranscriptViewportHitRegions {
+    readonly viewportHeight: number;
+    readonly rail: {
+        readonly column: number;
+        /** One-based terminal row. The one-row top inset is intentionally excluded. */
+        readonly rowStart: number;
+        readonly trackHeight: number;
+        readonly geometry: ScrollbarGeometry;
+    } | null;
+    readonly sticky: {
+        readonly row: number;
+        readonly target: number;
+        readonly width: number;
+    } | null;
+    readonly bottom: {
+        readonly row: number;
+        readonly columnStart: number;
+        readonly columnEnd: number;
+    } | null;
+}
+export interface TranscriptViewportFrame {
+    readonly rows: readonly string[];
+    readonly contentWidth: number;
+    readonly scrollTop: number;
+    readonly maxScroll: number;
+    readonly followingEnd: boolean;
+    readonly hits: TranscriptViewportHitRegions;
+}
+/**
+ * A1-owned viewport state. It knows only rows and semantic prompt anchors; Pi
+ * components and transcript payloads remain outside this neutral boundary.
+ */
+export declare class TranscriptViewport {
+    #private;
+    get scrollTop(): number;
+    get maxScroll(): number;
+    get followingEnd(): boolean;
+    get newMessages(): number;
+    get frame(): TranscriptViewportFrame | null;
+    /** Counts one completed assistant reply while detached; tool rows never call this. */
+    noteNewMessage(): boolean;
+    setConfig(config: TranscriptViewportConfig): void;
+    noteScrollActivity(now?: number, lingerMs?: number): void;
+    setRailHovered(hovered: boolean): void;
+    setRailDragging(dragging: boolean): void;
+    setStickyHovered(hovered: boolean): void;
+    setBottomHovered(hovered: boolean): void;
+    get selectionActive(): boolean;
+    get hasSelection(): boolean;
+    pressSelection(column: number, viewportRow: number, now?: number): boolean;
+    extendSelection(column: number, viewportRow: number, now?: number, autoScroll?: boolean): boolean;
+    releaseSelection(): boolean;
+    clearSelection(): boolean;
+    selectedText(): string | null;
+    scrollBy(lines: number, now?: number): boolean;
+    scrollTo(position: number, now?: number): boolean;
+    scrollToEnd(now?: number): boolean;
+    /** Jumps to the pinned prompt governing this position, then earlier prompts. */
+    scrollToPreviousPrompt(now?: number): boolean;
+    /** Jumps to the next submitted prompt after the prompt at the current stop. */
+    scrollToNextPrompt(now?: number): boolean;
+    reset(): void;
+    clearTransient(): void;
+    compose(input: TranscriptViewportFrameInput): TranscriptViewportFrame;
+}