@timurproko/a1 0.2.6 → 0.2.7-dev.1222

package/dist/features/owned-ui/project-trust-prompt.js

@@ -1,4 +1,5 @@
 import { EMERGENCY_TERMINAL_RESET } from "../../foundation/terminal-cleanup/terminal-reset.js";
+import { preTrustPalette, preTrustTerminalAppearance, preTrustTerminalColorMode, readPreTrustAccent } from "../../ui/settings/early-accent.js";
 const ENTER_ALTERNATE_SCREEN = "\u001b[?1049h";
 const HIDE_CURSOR = "\u001b[?25l";
 const CLEAR_HOME = "\u001b[2J\u001b[H";
@@ -34,8 +35,8 @@ export function createConsoleProjectTrustPrompt(options = {}) {
         if (choices.length === 0)
             throw new Error("project trust choices are unavailable");
         const comparison = options.presentation === "comparison";
-        const renderBareDialog = comparison
-            ? undefined : (await import("./project-trust-dialog.js")).renderProjectTrustDialog;
+        const renderBareDialog = comparison ? undefined : (await import("./project-trust-dialog.js")).renderProjectTrustDialog;
+        const palette = comparison ? null : trustPaletteOptions(options.environment ?? process.env);
         const wasRaw = input.isRaw === true;
         let selected = 0;
         let restored = false;
@@ -66,7 +67,7 @@ export function createConsoleProjectTrustPrompt(options = {}) {
         const render = () => {
             const width = Math.max(renderBareDialog ? 1 : 20, output.columns ?? 80);
             const rows = Math.max(1, output.rows ?? 24);
-            const lines = (renderBareDialog?.(cwd, choices.map(choice => choice.label), selected, width, rows) ?? [
+            const lines = (renderBareDialog?.(cwd, choices.map(choice => choice.label), selected, width, rows, palette.accent, palette.border) ?? [
                 `${BOLD}${ACCENT}Trust project folder?${RESET_FG}${RESET_BOLD}`,
                 cwd,
                 "",
@@ -179,6 +180,9 @@ export function createConsoleProjectTrustPrompt(options = {}) {
         }
     };
 }
+function trustPaletteOptions(environment) {
+    return preTrustPalette(readPreTrustAccent(environment), preTrustTerminalAppearance(environment), preTrustTerminalColorMode(environment));
+}
 function optionRow(label, selected) {
     return selected
         ? `${ACCENT}→ ${label}${RESET_FG}`

package/dist/features/owned-ui/reference-document-selection.d.ts

@@ -0,0 +1,30 @@
+import { type PaneMouseEvent, type UiTheme } from "../../ui/components/index.js";
+export interface ReferenceDocumentSelectionOptions {
+    readonly copyOnSelect: () => boolean;
+    readonly copyText: (text: string) => boolean | void;
+}
+interface ReferenceSelectionFrame {
+    readonly bodyRowStart: number;
+    readonly contentWidth: number;
+    readonly documentRows: readonly string[];
+    readonly visibleDocumentRows: readonly (number | undefined)[];
+}
+/** Selection state for an opted-in read-only reference document. */
+export declare class ReferenceDocumentSelection {
+    #private;
+    constructor(options: ReferenceDocumentSelectionOptions);
+    get selecting(): boolean;
+    get hasSelection(): boolean;
+    updateFrame(frame: ReferenceSelectionFrame): void;
+    paintVisibleRow(visibleRow: number, line: string, theme: UiTheme): string;
+    handleInput(data: string): {
+        readonly consumed: boolean;
+        readonly cleared: boolean;
+    };
+    handleMouse(event: PaneMouseEvent, requestRender?: () => void): {
+        readonly consumed: boolean;
+        readonly changed: boolean;
+    };
+    clear(): void;
+}
+export {};

package/dist/features/owned-ui/reference-document-selection.js

@@ -0,0 +1,179 @@
+import { COPY_ACKNOWLEDGEMENT_DURATION_MS, copyAcknowledgementText, displayWidth, extendTextSelection, orderedTextSelection, overlaySpan, paintTextSelection, padToWidth, pressTextSelection, releaseTextSelection, stripAnsi, textSelectionLineExtendColumn, textSelectionPointAt, textSelectionText, truncateToWidth, usefulTextLineContent, } from "../../ui/components/index.js";
+const INTERRUPT = "\u0003";
+class CopyAcknowledgement {
+    #message;
+    #timer;
+    paint(line, finalRow, width, theme) {
+        if (!finalRow || this.#message === undefined || width === 0)
+            return line;
+        const message = truncateToWidth(theme.fg("accent", this.#message), width);
+        return overlaySpan(line, width - displayWidth(message), width, message, { inheritStartStyle: true });
+    }
+    show(characters, requestRender) {
+        this.#message = copyAcknowledgementText(characters);
+        this.#clearTimer();
+        this.#timer = setTimeout(() => {
+            this.#timer = undefined;
+            this.#message = undefined;
+            requestRender();
+        }, COPY_ACKNOWLEDGEMENT_DURATION_MS);
+        this.#timer.unref?.();
+        requestRender();
+    }
+    clear() {
+        this.#clearTimer();
+        this.#message = undefined;
+    }
+    #clearTimer() {
+        if (this.#timer !== undefined)
+            clearTimeout(this.#timer);
+        this.#timer = undefined;
+    }
+}
+/** Selection state for an opted-in read-only reference document. */
+export class ReferenceDocumentSelection {
+    #copyOnSelect;
+    #copyText;
+    #selection;
+    #click;
+    #frame;
+    #acknowledgement = new CopyAcknowledgement();
+    constructor(options) {
+        this.#copyOnSelect = options.copyOnSelect;
+        this.#copyText = options.copyText;
+    }
+    get selecting() {
+        return this.#selection?.selecting === true;
+    }
+    get hasSelection() {
+        return orderedTextSelection(this.#selection) !== undefined;
+    }
+    updateFrame(frame) {
+        const previous = this.#frame;
+        if (this.#selection !== undefined && previous !== undefined && !selectionStillMaps(this.#selection, previous.documentRows, frame.documentRows)) {
+            this.#selection = undefined;
+            this.#click = undefined;
+        }
+        this.#frame = frame;
+    }
+    paintVisibleRow(visibleRow, line, theme) {
+        const frame = this.#frame;
+        const documentRow = frame?.visibleDocumentRows[visibleRow];
+        const ordered = orderedTextSelection(this.#selection);
+        const width = frame?.contentWidth ?? 0;
+        let painted = padToWidth(line, width);
+        if (documentRow !== undefined && ordered !== undefined
+            && documentRow >= ordered.start.line && documentRow <= ordered.end.line) {
+            const from = documentRow === ordered.start.line ? ordered.start.column : 0;
+            const to = documentRow === ordered.end.line ? ordered.end.column : width;
+            painted = paintTextSelection(painted, Math.max(0, from), Math.min(width, to));
+        }
+        return this.#acknowledgement.paint(painted, visibleRow === (frame?.visibleDocumentRows.length ?? 0) - 1, width, theme);
+    }
+    handleInput(data) {
+        if (data === INTERRUPT && this.hasSelection) {
+            this.#submitSelection();
+            this.#selection = undefined;
+            this.#click = undefined;
+            return { consumed: true, cleared: true };
+        }
+        if (this.#selection === undefined)
+            return { consumed: false, cleared: false };
+        this.#selection = undefined;
+        this.#click = undefined;
+        return { consumed: false, cleared: true };
+    }
+    handleMouse(event, requestRender) {
+        const frame = this.#frame;
+        if (frame === undefined)
+            return { consumed: false, changed: false };
+        if (event.kind === "motion" && this.selecting) {
+            const row = documentRowAt(frame, event.row, true);
+            if (row === undefined)
+                return { consumed: true, changed: false };
+            this.#extend(row, event.column);
+            return { consumed: true, changed: true };
+        }
+        if (event.kind === "release" && this.selecting) {
+            this.#selection = releaseTextSelection(this.#selection);
+            const copiedCharacters = this.hasSelection && this.#copyOnSelect() ? this.#submitSelection() : undefined;
+            if (copiedCharacters !== undefined && requestRender !== undefined) {
+                this.#acknowledgement.show(copiedCharacters, requestRender);
+            }
+            return { consumed: true, changed: true };
+        }
+        if (event.kind !== "press" || event.button !== 0)
+            return { consumed: false, changed: false };
+        const row = documentRowAt(frame, event.row, false);
+        if (row === undefined || event.column < 1 || event.column > frame.contentWidth) {
+            const changed = this.#selection !== undefined;
+            this.#selection = undefined;
+            this.#click = undefined;
+            return { consumed: false, changed };
+        }
+        const source = frame.documentRows[row] ?? "";
+        const pressed = pressTextSelection({
+            line: row,
+            column: event.column,
+            contentWidth: frame.contentWidth,
+            lineText: source,
+            lineContent: usefulTextLineContent(source),
+            ...(this.#click === undefined ? {} : { previousClick: this.#click }),
+        });
+        this.#selection = pressed.selection;
+        this.#click = pressed.click;
+        return { consumed: true, changed: true };
+    }
+    clear() {
+        this.#selection = undefined;
+        this.#click = undefined;
+        this.#frame = undefined;
+        this.#acknowledgement.clear();
+    }
+    #extend(row, column) {
+        const selection = this.#selection;
+        const frame = this.#frame;
+        if (selection?.selecting !== true || frame === undefined)
+            return;
+        const targetColumn = selection.fullRow
+            ? textSelectionLineExtendColumn(selection, row, frame.contentWidth)
+            : Math.max(1, Math.min(column, frame.contentWidth));
+        this.#selection = extendTextSelection(selection, selection.fullRow
+            ? { line: row, column: targetColumn }
+            : textSelectionPointAt(row, targetColumn, frame.documentRows[row] ?? ""));
+    }
+    #submitSelection() {
+        const frame = this.#frame;
+        const ordered = orderedTextSelection(this.#selection);
+        if (frame === undefined || ordered === undefined)
+            return undefined;
+        const text = textSelectionText(ordered, frame.documentRows, line => usefulTextLineContent(frame.documentRows[line] ?? "")).trim();
+        if (text.length === 0 || this.#copyText(text) === false)
+            return undefined;
+        return text.length;
+    }
+}
+function documentRowAt(frame, screenRow, clampToDocument) {
+    const visible = frame.visibleDocumentRows;
+    let index = screenRow - frame.bodyRowStart;
+    if (!clampToDocument)
+        return visible[index];
+    index = Math.max(0, Math.min(index, visible.length - 1));
+    if (visible[index] !== undefined)
+        return visible[index];
+    const defined = visible.flatMap(row => row === undefined ? [] : [row]);
+    if (defined.length === 0)
+        return undefined;
+    return screenRow < frame.bodyRowStart ? defined[0] : defined.at(-1);
+}
+function selectionStillMaps(selection, previous, next) {
+    const first = Math.min(selection.anchor.line, selection.head.line);
+    const last = Math.max(selection.anchor.line, selection.head.line);
+    if (last >= previous.length || last >= next.length)
+        return false;
+    for (let line = first; line <= last; line += 1) {
+        if (stripAnsi(previous[line] ?? "") !== stripAnsi(next[line] ?? ""))
+            return false;
+    }
+    return true;
+}

package/dist/features/owned-ui/reference-screen-app.d.ts

@@ -1,4 +1,5 @@
 import type { OwnedUiViewportSettings } from "../../contracts/owned-ui/index.js";
+import { type ReferenceDocumentSelectionOptions } from "./reference-document-selection.js";
 import type { AppHostServices, UiApp } from "../../ui/apps/index.js";
 import { ShortcutRegistry, type PaneInputResult, type PaneMouseEvent, type PaneRect } from "../../ui/components/index.js";
 type Action = "up" | "down" | "page-up" | "page-down" | "first" | "last" | "close";
@@ -24,6 +25,10 @@ export interface ReferenceScreenOptions {
     readonly document: ReferenceDocumentProvider;
     /** The reader's scroll settings, read on every frame so a live change is honored. */
     readonly scrollSettings: () => OwnedUiViewportSettings;
+    /** The screen is a resident tab, such as the Changelog tab: it offers no screen-level close. */
+    readonly pinned?: boolean;
+    /** Enables owned text selection for document routes that explicitly opt in. */
+    readonly selection?: ReferenceDocumentSelectionOptions;
 }
 /**
  * Presents one read-only document full screen between two accent rules: the bold
@@ -40,6 +45,6 @@ export declare class ReferenceScreenApp implements UiApp {
     onClose(_host: AppHostServices): void;
     render(rect: PaneRect, host: AppHostServices): readonly string[];
     onInput(data: string, host: AppHostServices): PaneInputResult;
-    onMouse(event: PaneMouseEvent, _host: AppHostServices): PaneInputResult;
+    onMouse(event: PaneMouseEvent, host: AppHostServices): PaneInputResult;
 }
 export {};

package/dist/features/owned-ui/reference-screen-app.js

@@ -1,3 +1,4 @@
+import { ReferenceDocumentSelection } from "./reference-document-selection.js";
 import { DIALOG_CLOSE_SHORTCUT_HINT } from "../../contracts/presentation/index.js";
 import { GLOBAL_SCOPE, PLAIN_THEME, RAIL_COLUMNS, ShortcutRegistry, ScrollbarRails, assertNoShortcutConflicts, displayWidth, layoutList, padToWidth, renderGroupHeader, renderShortcutHintsWithClose, scrollForTrackPage, scrollbarGeometry, scrollbarPresentation, scrollbarWheelRows, truncateToWidth, withScrollbarRail, } from "../../ui/components/index.js";
 const SCOPE = "reference-screen";
@@ -48,6 +49,8 @@ export class ReferenceScreenApp {
     #title;
     #document;
     #scrollSettings;
+    #pinned;
+    #selection;
     #scroll = 0;
     #interruptArmed = false;
     #failure = null;
@@ -57,7 +60,6 @@ export class ReferenceScreenApp {
     #rails = new ScrollbarRails();
     // Rationale: the rail as drawn in the last frame, or null when nothing can be pointed at.
     #railFrame = null;
-    #bodyHeight = 0;
     // Invariant: a scroll lights the rail until this time; the timer repaints once it has passed.
     #activeUntil = 0;
     #activityTimer;
@@ -67,6 +69,8 @@ export class ReferenceScreenApp {
         this.#title = options.title;
         this.#document = options.document;
         this.#scrollSettings = options.scrollSettings;
+        this.#pinned = options.pinned === true;
+        this.#selection = options.selection === undefined ? undefined : new ReferenceDocumentSelection(options.selection);
     }
     onActivate(host) {
         const ready = this.#document.ready;
@@ -83,6 +87,7 @@ export class ReferenceScreenApp {
     onClose(_host) {
         this.#clearActivityTimer();
         this.#rails.clear();
+        this.#selection?.clear();
     }
     render(rect, host) {
         const theme = host.theme ?? PLAIN_THEME;
@@ -91,9 +96,9 @@ export class ReferenceScreenApp {
         const reservesRail = settings.scrollbarAppearance !== "hidden";
         const contentWidth = reservesRail ? Math.max(0, rect.width - RAIL_COLUMNS) : rect.width;
         const bodyHeight = Math.max(0, rect.height - HEADER_ROWS - FOOTER_ROWS);
-        this.#bodyHeight = bodyHeight;
         const content = this.#content(contentWidth, theme);
         const body = [];
+        const visibleDocumentRows = [];
         let contentLength;
         let viewportLength = bodyHeight;
         if (content.kind === "sections") {
@@ -113,10 +118,22 @@ export class ReferenceScreenApp {
             for (let index = this.#scroll; index < this.#scroll + bodyHeight; index++) {
                 const row = content.rows[index] ?? "";
                 body.push(displayWidth(row) > contentWidth ? truncateToWidth(row, contentWidth) : row);
+                visibleDocumentRows.push(index < content.rows.length ? index : undefined);
             }
         }
         while (body.length < bodyHeight)
             body.push("");
+        while (visibleDocumentRows.length < bodyHeight)
+            visibleDocumentRows.push(undefined);
+        this.#selection?.updateFrame({
+            bodyRowStart: HEADER_ROWS + 1,
+            contentWidth,
+            documentRows: content.kind === "flat" ? content.rows : [],
+            visibleDocumentRows,
+        });
+        const paintedBody = this.#selection === undefined
+            ? body
+            : body.map((row, index) => this.#selection.paintVisibleRow(index, row, theme));
         const now = Date.now();
         // Rationale: every way of scrolling ends in this frame, so a moved document is noticed here
         // once rather than at each wheel, drag, and key branch.
@@ -136,10 +153,10 @@ export class ReferenceScreenApp {
         this.#railFrame = reservesRail && geometry !== null
             ? { rail: { key: this.id, column: rect.width, rowStart: HEADER_ROWS, trackHeight: geometry.trackHeight }, geometry, page: viewportLength }
             : null;
-        const withRail = withScrollbarRail(body.slice(0, bodyHeight), geometry, contentWidth, theme, { presentation });
+        const withRail = withScrollbarRail(paintedBody.slice(0, bodyHeight), geometry, contentWidth, theme, { presentation });
         const hint = this.#interruptArmed
             ? theme.fg("dim", " press ctrl+c again to exit a1")
-            : renderShortcutHintsWithClose(REFERENCE_SCREEN_SHORTCUTS.hintEntries(SCOPE), theme, rect.width, 1);
+            : renderShortcutHintsWithClose(this.#hintEntries(), theme, rect.width, 1);
         // Compatibility: the v2 reference screen frames its document between two border-coloured rules.
         const rule = theme.fg("border", "─".repeat(rect.width));
         // Invariant: dialog chrome shares the title's one-cell inset; document content keeps its own layout.
@@ -148,12 +165,21 @@ export class ReferenceScreenApp {
         return frame.slice(0, rect.height).concat(Array(Math.max(0, rect.height - frame.length)).fill(""));
     }
     onInput(data, host) {
+        const explicitCopy = data === "\u0003" ? this.#selection?.handleInput(data) : undefined;
+        if (explicitCopy?.consumed === true)
+            return { consumed: true };
         const action = REFERENCE_SCREEN_SHORTCUTS.resolve(KEYS[data] ?? data, SCOPE);
-        if (action === null)
+        if (action === null) {
+            const cleared = explicitCopy?.cleared ?? (this.#selection?.handleInput(data).cleared === true);
+            if (cleared)
+                host.requestRender();
             return { consumed: false };
+        }
         switch (action) {
             case "close":
-                host.close();
+                this.#selection?.handleInput(data);
+                if (!this.#pinned)
+                    host.close();
                 return { consumed: true };
             case "up":
                 this.#scrollBy(-1);
@@ -162,10 +188,10 @@ export class ReferenceScreenApp {
                 this.#scrollBy(1);
                 return { consumed: true };
             case "page-up":
-                this.#scrollBy(-Math.max(1, this.#bodyHeight));
+                this.#scrollBy(-Math.max(1, host.getSize().height - HEADER_ROWS - FOOTER_ROWS));
                 return { consumed: true };
             case "page-down":
-                this.#scrollBy(Math.max(1, this.#bodyHeight));
+                this.#scrollBy(Math.max(1, host.getSize().height - HEADER_ROWS - FOOTER_ROWS));
                 return { consumed: true };
             case "first":
                 this.#scroll = 0;
@@ -175,17 +201,25 @@ export class ReferenceScreenApp {
                 return { consumed: true };
         }
     }
-    onMouse(event, _host) {
+    onMouse(event, host) {
         if (event.kind === "wheel-up" || event.kind === "wheel-down") {
             // Invariant: the whole screen owns wheel scrolling; it must not depend on the pointer's row.
             const distance = scrollbarWheelRows(this.#scrollSettings().scrollbarSpeed);
             this.#scrollBy(event.kind === "wheel-down" ? distance : -distance);
             return { consumed: true };
         }
+        if (this.#selection?.selecting === true) {
+            const selection = this.#selection.handleMouse(event, () => host.requestRender());
+            if (selection.consumed)
+                return { consumed: true, render: selection.changed };
+        }
         const rail = this.#railPointer(event);
         if (rail.owned)
             return { consumed: true };
-        return { consumed: event.kind !== "motion", render: rail.changed };
+        const selection = this.#selection?.handleMouse(event, () => host.requestRender());
+        if (selection?.consumed === true)
+            return { consumed: true, render: selection.changed || rail.changed };
+        return { consumed: event.kind !== "motion", render: selection?.changed === true || rail.changed };
     }
     // Rationale: the rail takes its share of a pointer report first: hover, a thumb drag, or a
     // track page. Owned means the document must not see the report; changed means the rail looks different.
@@ -216,6 +250,13 @@ export class ReferenceScreenApp {
         }
         return { owned: true, changed: true };
     }
+    // Invariant: a pinned screen is its tab and `Esc` does not close it, so it shows no close hint.
+    #hintEntries() {
+        const entries = REFERENCE_SCREEN_SHORTCUTS.hintEntries(SCOPE);
+        if (!this.#pinned)
+            return entries;
+        return entries.filter(entry => entry.key !== DIALOG_CLOSE_SHORTCUT_HINT.key || entry.action !== DIALOG_CLOSE_SHORTCUT_HINT.action);
+    }
     // Invariant: the title is the first document row, as in v2, so it scrolls with the document.
     #content(width, theme) {
         // Compatibility: one leading space, so the title lines up with the padded Markdown rows as in v2.

package/dist/features/owned-ui/settings-app.d.ts

@@ -1,8 +1,9 @@
 import type { AppHostServices, UiApp } from "../../ui/apps/index.js";
 import { ShortcutRegistry, type PaneInputResult, type PaneMouseEvent, type PaneRect } from "../../ui/components/index.js";
 import type { OwnedSettingsManager } from "../../ui/settings/index.js";
+import type { SettingsSearchInputFactory } from "./settings-search-input.js";
 export { SETTINGS_APP_ID, SETTINGS_ROUTE } from "./settings-route.js";
-type Action = "move-up" | "move-down" | "block-up" | "block-down" | "first" | "last" | "page-up" | "page-down" | "previous-value" | "next-value" | "activate" | "open-filter" | "close" | "undo" | "part-previous" | "part-next" | "part-change";
+type Action = "move-up" | "move-down" | "block-up" | "block-down" | "first" | "last" | "page-up" | "page-down" | "previous-value" | "next-value" | "activate" | "edit-filter" | "close" | "undo" | "part-previous" | "part-next" | "part-change";
 export declare const SETTINGS_SHORTCUTS: ShortcutRegistry<Action>;
 /**
  * The settings screen. Rows, sticky headers, scrolling, and the keymap come from
@@ -12,7 +13,17 @@ export declare const SETTINGS_SHORTCUTS: ShortcutRegistry<Action>;
 export declare class SettingsApp implements UiApp {
     #private;
     readonly id = "settings";
-    constructor(session: OwnedSettingsManager);
+    /**
+     * `pinned` presents the screen as a resident Settings tab, which offers no screen-level close;
+     * `configurePlusMenu` opens the tab bar's Plus Menu dialog in place of this screen's own.
+     */
+    constructor(session: OwnedSettingsManager, options: {
+        readonly pinned?: boolean;
+        readonly searchInputFactory: SettingsSearchInputFactory;
+        readonly copyText?: (text: string) => void;
+        readonly configurePlusMenu?: (() => boolean) | null;
+        readonly dialogPanel?: (text: string) => string;
+    });
     onActivate(host: AppHostServices): void;
     onClose(_host: AppHostServices): void;
     render(rect: PaneRect, host: AppHostServices): readonly string[];