@ohzw/worktree-command-tui 0.1.1 → 0.1.2

package/dist/core/tui-interaction.js

@@ -0,0 +1,59 @@
+export function getNextSelectedPath(rows, currentPath) {
+    if (rows.length === 0) {
+        return null;
+    }
+    if (currentPath && rows.some(row => row.path === currentPath)) {
+        return currentPath;
+    }
+    return rows[0].path;
+}
+export function getSelectedIndex(rows, selectedPath) {
+    if (selectedPath === null) {
+        return 0;
+    }
+    const foundIndex = rows.findIndex(row => row.path === selectedPath);
+    return foundIndex >= 0 ? foundIndex : 0;
+}
+export function clampSelectionIndex(nextIndex, rowCount) {
+    if (rowCount <= 0) {
+        return null;
+    }
+    return Math.min(Math.max(nextIndex, 0), rowCount - 1);
+}
+export function decideEnterInteraction(selected, activePath) {
+    if (selected === undefined) {
+        return { kind: 'ignore' };
+    }
+    if (selected.invalidReason) {
+        return {
+            kind: 'set-status',
+            status: { kind: 'error', message: selected.invalidReason },
+            suppressesBackgroundRefreshes: true,
+        };
+    }
+    if (selected.path === activePath) {
+        return {
+            kind: 'set-status',
+            status: { kind: 'idle', message: 'already active' },
+            suppressesBackgroundRefreshes: true,
+        };
+    }
+    return {
+        kind: 'start',
+        path: selected.path,
+        status: { kind: 'starting', message: `Starting ${selected.branch}...` },
+    };
+}
+export function decideSetupInteraction(selected, setupAvailable) {
+    if (selected === undefined || !setupAvailable) {
+        return { kind: 'ignore' };
+    }
+    return {
+        kind: 'setup',
+        path: selected.path,
+        status: { kind: 'setting-up', message: `Running setup for ${selected.branch}...` },
+    };
+}
+export function shouldApplyAsyncResult(state) {
+    return state.blocksInput || (state.generation === state.currentGeneration && !state.userActionInFlight);
+}

package/dist/core/worktree-projection.d.ts

@@ -0,0 +1,76 @@
+import type { AppRow, RowTag } from './runtime.js';
+export type ProjectionSeverity = 'success' | 'error' | 'info';
+export type ProjectionTag = RowTag | string;
+export type WorktreeListRowState = 'active' | 'invalid' | 'external' | 'normal';
+export interface WorktreeListRowProjection {
+    state: WorktreeListRowState;
+    isSelected: boolean;
+    isMain: boolean;
+}
+export interface TagProjection {
+    tag: ProjectionTag;
+}
+export type ActionProjection = {
+    kind: 'blocked';
+    severity: 'error';
+} | {
+    kind: 'active';
+    severity: 'success';
+} | {
+    kind: 'startable';
+    severity: 'error' | 'info';
+};
+export type NoteProjection = {
+    kind: 'invalid';
+    severity: 'error';
+    invalidReason: string;
+} | {
+    kind: 'external';
+    severity: 'info';
+} | {
+    kind: 'ready';
+    severity: 'error' | 'info';
+};
+export type UpstreamProjection = {
+    kind: 'unavailable';
+} | {
+    kind: 'none';
+} | {
+    kind: 'found';
+    branch: string;
+    ahead: number;
+    behind: number;
+};
+export type WorkingTreePartKind = 'staged' | 'unstaged' | 'untracked' | 'conflicts';
+export type WorkingTreeProjection = {
+    kind: 'unavailable';
+} | {
+    kind: 'clean';
+} | {
+    kind: 'dirty';
+    parts: Array<{
+        kind: WorkingTreePartKind;
+        count: number;
+    }>;
+};
+export type PullRequestProjection = {
+    kind: 'none';
+} | {
+    kind: 'unavailable';
+} | {
+    kind: 'found';
+    number: number;
+    title: string;
+    state: 'OPEN' | 'CLOSED' | 'MERGED';
+    isDraft: boolean;
+    baseBranch: string;
+    isHistorical: boolean;
+};
+export declare function sanitizeInlineText(value: string): string;
+export declare function projectWorktreeListRow(row: AppRow, isSelected: boolean): WorktreeListRowProjection;
+export declare function getOrderedNonActiveTags(tags: readonly string[]): TagProjection[];
+export declare function projectAction(row: AppRow, activePath: string | null): ActionProjection;
+export declare function projectNote(row: AppRow): NoteProjection;
+export declare function projectUpstream(row: AppRow): UpstreamProjection;
+export declare function projectWorkingTree(row: AppRow): WorkingTreeProjection;
+export declare function projectPullRequest(row: AppRow): PullRequestProjection;

package/dist/core/worktree-projection.js

@@ -0,0 +1,124 @@
+const tagPriority = {
+    active: 0,
+    main: 1,
+    external: 2,
+    invalid: 3,
+};
+export function sanitizeInlineText(value) {
+    return value
+        .replace(/[\r\n\t\u2028\u2029]+/g, ' ')
+        .replace(/[\u0000-\u001f\u007f-\u009f]/g, '')
+        .replace(/\p{Cf}/gu, '')
+        .replace(/\s+/g, ' ')
+        .trim();
+}
+function hasTag(row, tag) {
+    return row.tags.includes(tag);
+}
+function hasConflicts(row) {
+    return (row.workingTree?.conflicts ?? 0) > 0;
+}
+export function projectWorktreeListRow(row, isSelected) {
+    let state = 'normal';
+    if (hasTag(row, 'active')) {
+        state = 'active';
+    }
+    else if (hasTag(row, 'invalid')) {
+        state = 'invalid';
+    }
+    else if (hasTag(row, 'external')) {
+        state = 'external';
+    }
+    return {
+        state,
+        isSelected,
+        isMain: hasTag(row, 'main'),
+    };
+}
+export function getOrderedNonActiveTags(tags) {
+    return tags
+        .filter(tag => tag !== 'active')
+        .slice()
+        .sort((a, b) => {
+        const aPriority = tagPriority[a] ?? 10;
+        const bPriority = tagPriority[b] ?? 10;
+        if (aPriority === bPriority) {
+            return a.localeCompare(b);
+        }
+        return aPriority - bPriority;
+    })
+        .map(tag => ({ tag }));
+}
+export function projectAction(row, activePath) {
+    if (row.invalidReason) {
+        return { kind: 'blocked', severity: 'error' };
+    }
+    if (row.path === activePath) {
+        return { kind: 'active', severity: 'success' };
+    }
+    return { kind: 'startable', severity: hasConflicts(row) ? 'error' : 'info' };
+}
+export function projectNote(row) {
+    if (row.invalidReason) {
+        return { kind: 'invalid', severity: 'error', invalidReason: row.invalidReason };
+    }
+    if (hasTag(row, 'external')) {
+        return { kind: 'external', severity: 'info' };
+    }
+    return { kind: 'ready', severity: hasConflicts(row) ? 'error' : 'info' };
+}
+export function projectUpstream(row) {
+    if (row.upstreamUnavailable) {
+        return { kind: 'unavailable' };
+    }
+    if (!row.upstream) {
+        return { kind: 'none' };
+    }
+    return {
+        kind: 'found',
+        branch: sanitizeInlineText(row.upstream.branch),
+        ahead: row.upstream.ahead,
+        behind: row.upstream.behind,
+    };
+}
+export function projectWorkingTree(row) {
+    if (!row.workingTree) {
+        return { kind: 'unavailable' };
+    }
+    const { staged, unstaged, untracked, conflicts } = row.workingTree;
+    if (staged === 0 && unstaged === 0 && untracked === 0 && conflicts === 0) {
+        return { kind: 'clean' };
+    }
+    const parts = [];
+    if (staged > 0) {
+        parts.push({ kind: 'staged', count: staged });
+    }
+    if (unstaged > 0) {
+        parts.push({ kind: 'unstaged', count: unstaged });
+    }
+    if (untracked > 0) {
+        parts.push({ kind: 'untracked', count: untracked });
+    }
+    if (conflicts > 0) {
+        parts.push({ kind: 'conflicts', count: conflicts });
+    }
+    return { kind: 'dirty', parts };
+}
+export function projectPullRequest(row) {
+    if (!row.pullRequest || row.pullRequest.kind === 'none') {
+        return { kind: 'none' };
+    }
+    if (row.pullRequest.kind === 'unavailable') {
+        return { kind: 'unavailable' };
+    }
+    const isHistorical = row.pullRequest.state !== 'OPEN';
+    return {
+        kind: 'found',
+        number: row.pullRequest.number,
+        title: sanitizeInlineText(row.pullRequest.title),
+        state: row.pullRequest.state,
+        isDraft: row.pullRequest.isDraft,
+        baseBranch: sanitizeInlineText(row.pullRequest.baseBranch),
+        isHistorical,
+    };
+}

package/dist/terminal/viewport.d.ts

@@ -0,0 +1,15 @@
+export type ViewportSlice<T> = {
+    visibleItems: T[];
+    startIndex: number;
+    viewportHeight: number;
+    scrollOffset: number;
+    maxScrollOffset: number;
+};
+export type TailViewportSlice<T> = ViewportSlice<T> & {
+    topScrollOffset: number;
+};
+export declare function normalizeViewportHeight(viewportHeight: number): number;
+export declare function clampScrollOffset(totalItems: number, viewportHeight: number, scrollOffset: number): number;
+export declare function sliceListViewport<T>(items: readonly T[], viewportHeight: number, scrollOffset: number): ViewportSlice<T>;
+export declare function sliceTailViewport<T>(items: readonly T[], viewportHeight: number, scrollOffset: number): TailViewportSlice<T>;
+export declare function getScrollbarThumbRows(totalLines: number, viewportHeight: number, scrollOffset: number): Set<number>;

package/dist/terminal/viewport.js

@@ -0,0 +1,49 @@
+export function normalizeViewportHeight(viewportHeight) {
+    return Math.max(1, Math.trunc(viewportHeight));
+}
+export function clampScrollOffset(totalItems, viewportHeight, scrollOffset) {
+    const normalizedViewportHeight = normalizeViewportHeight(viewportHeight);
+    const maxScrollOffset = Math.max(0, totalItems - normalizedViewportHeight);
+    return Math.min(Math.max(Math.trunc(scrollOffset), 0), maxScrollOffset);
+}
+export function sliceListViewport(items, viewportHeight, scrollOffset) {
+    const normalizedViewportHeight = normalizeViewportHeight(viewportHeight);
+    const maxScrollOffset = Math.max(0, items.length - normalizedViewportHeight);
+    const effectiveScrollOffset = Math.min(Math.max(Math.trunc(scrollOffset), 0), maxScrollOffset);
+    return {
+        visibleItems: items.slice(effectiveScrollOffset, effectiveScrollOffset + normalizedViewportHeight),
+        startIndex: effectiveScrollOffset,
+        viewportHeight: normalizedViewportHeight,
+        scrollOffset: effectiveScrollOffset,
+        maxScrollOffset,
+    };
+}
+export function sliceTailViewport(items, viewportHeight, scrollOffset) {
+    const normalizedViewportHeight = normalizeViewportHeight(viewportHeight);
+    const maxScrollOffset = Math.max(0, items.length - normalizedViewportHeight);
+    const effectiveScrollOffset = Math.min(Math.max(Math.trunc(scrollOffset), 0), maxScrollOffset);
+    const topScrollOffset = maxScrollOffset - effectiveScrollOffset;
+    return {
+        visibleItems: items.slice(topScrollOffset, topScrollOffset + normalizedViewportHeight),
+        startIndex: topScrollOffset,
+        viewportHeight: normalizedViewportHeight,
+        scrollOffset: effectiveScrollOffset,
+        maxScrollOffset,
+        topScrollOffset,
+    };
+}
+export function getScrollbarThumbRows(totalLines, viewportHeight, scrollOffset) {
+    const normalizedViewportHeight = normalizeViewportHeight(viewportHeight);
+    if (totalLines <= normalizedViewportHeight) {
+        return new Set();
+    }
+    const thumbSize = Math.max(1, Math.floor((normalizedViewportHeight / totalLines) * normalizedViewportHeight));
+    const maxScrollOffset = Math.max(1, totalLines - normalizedViewportHeight);
+    const effectiveScrollOffset = Math.min(Math.max(Math.trunc(scrollOffset), 0), maxScrollOffset);
+    const thumbStart = Math.round((effectiveScrollOffset / maxScrollOffset) * (normalizedViewportHeight - thumbSize));
+    const rows = new Set();
+    for (let index = 0; index < thumbSize; index += 1) {
+        rows.add(thumbStart + index);
+    }
+    return rows;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ohzw/worktree-command-tui",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "A TUI for managing git worktrees",
   "private": false,
   "type": "module",