@ohzw/worktree-command-tui 0.1.0 → 0.1.2

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/main.js

@@ -2,10 +2,12 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { createConfigForRepo, parseInitArgs } from './core/init.js';
 import { CONFIG_FILE_NAME, CONFIG_FILE_NAMES } from './core/config.js';
+import { ThemeProvider } from '@inkjs/ui';
 import { render } from 'ink';
+import { APP_RENDER_OPTIONS } from './render-options.js';
 import { App } from './app.js';
 import { buildActions, buildInitialModel } from './core/runtime.js';
-import { APP_RENDER_OPTIONS } from './render-options.js';
+import { appTheme } from './ui-theme.js';
 const cwd = process.cwd();
 const args = process.argv.slice(2);
 const [, , subcommand] = process.argv;
@@ -65,7 +67,27 @@ if (subcommand !== undefined) {
 }
 try {
     const [initialModel, actions] = await Promise.all([buildInitialModel(cwd), buildActions(cwd)]);
-    render(_jsx(App, { initialModel: initialModel, actions: actions }), APP_RENDER_OPTIONS);
+    const createApp = () => (_jsx(ThemeProvider, { theme: appTheme, children: _jsx(App, { initialModel: initialModel, actions: actions }) }));
+    const instance = render(createApp(), APP_RENDER_OPTIONS);
+    let repaintTimer;
+    const repaintAfterResize = () => {
+        // Give Ink/useWindowSize one tick to observe the new size, then force a fresh root render.
+        if (repaintTimer) {
+            clearTimeout(repaintTimer);
+        }
+        repaintTimer = setTimeout(() => {
+            instance.rerender(createApp());
+        }, 25);
+    };
+    if (process.stdout.isTTY) {
+        process.stdout.on('resize', repaintAfterResize);
+        void instance.waitUntilExit().finally(() => {
+            if (repaintTimer) {
+                clearTimeout(repaintTimer);
+            }
+            process.stdout.off('resize', repaintAfterResize);
+        });
+    }
 }
 catch (error) {
     console.error(describeError(error));

package/dist/render-options.d.ts

@@ -1,4 +1,5 @@
 export declare const APP_RENDER_OPTIONS: {
     readonly alternateScreen: true;
     readonly exitOnCtrlC: true;
+    readonly incrementalRendering: true;
 };

package/dist/render-options.js

@@ -1,4 +1,5 @@
 export const APP_RENDER_OPTIONS = {
     alternateScreen: true,
     exitOnCtrlC: true,
+    incrementalRendering: true,
 };

package/dist/repro.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/repro.js

@@ -0,0 +1,13 @@
+const model = {
+    repoName: "reclaim-the-forest",
+    namespace: "rojo-serve",
+    rows: Array.from({ length: 10 }, (_, index) => ({
+        path: `/repo/.worktree/feat-${index}`,
+        shortPath: `.worktree/feat-${index}`,
+        branch: `feat/${index}`,
+        tags: (index === 0 ? [active] : []),
+        pullRequest: index === 0 ? { kind: found, number: 2125, title: Selection }
+            :
+    }))
+};
+export {};

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/dist/ui-theme.d.ts

@@ -0,0 +1,3 @@
+export declare const appTheme: {
+    components: Record<string, import("@inkjs/ui").ComponentTheme>;
+};

package/dist/ui-theme.js

@@ -0,0 +1,38 @@
+import { defaultTheme, extendTheme } from '@inkjs/ui';
+const variantColor = {
+    info: 'blue',
+    success: 'green',
+    error: 'red',
+    warning: 'yellow',
+};
+export const appTheme = extendTheme(defaultTheme, {
+    components: {
+        StatusMessage: {
+            styles: {
+                icon: ({ variant }) => ({
+                    color: variantColor[variant],
+                    bold: true,
+                }),
+            },
+        },
+        Alert: {
+            styles: {
+                container: ({ variant }) => ({
+                    flexGrow: 0,
+                    flexShrink: 0,
+                    borderStyle: 'round',
+                    borderColor: variantColor[variant],
+                    gap: 1,
+                    paddingX: 1,
+                }),
+                icon: ({ variant }) => ({
+                    color: variantColor[variant],
+                    bold: true,
+                }),
+                title: () => ({
+                    bold: true,
+                }),
+            },
+        },
+    },
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ohzw/worktree-command-tui",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "A TUI for managing git worktrees",
   "private": false,
   "type": "module",
@@ -54,6 +54,7 @@
     "access": "public"
   },
   "dependencies": {
+    "@inkjs/ui": "^2.0.0",
     "ink": "^7.0.4",
     "react": "^19.2.0"
   },