@ohzw/worktree-command-tui 0.1.1 → 0.1.3

package/dist/core/worktree-projection.js

@@ -0,0 +1,132 @@
+const tagPriority = {
+    active: 0,
+    main: 1,
+    external: 2,
+    invalid: 3,
+};
+const ANSI_CSI_PATTERN = /\u001B\[[0-?]*[ -/]*[@-~]/gu;
+const ANSI_OSC_PATTERN = /\u001B\][^\u0007\u001B\u009C]*(?:\u0007|\u001B\\|\u009C)?/gu;
+const ANSI_STRING_PATTERN = /\u001B[P^_X][\s\S]*?(?:\u001B\\|\u009C|$)/gu;
+const C1_STRING_PATTERN = /[\u0090\u0098\u009D\u009E\u009F][^\u0007\u009C]*(?:\u0007|\u009C)?/gu;
+export function sanitizeInlineText(value) {
+    return value
+        .replace(ANSI_OSC_PATTERN, '')
+        .replace(ANSI_STRING_PATTERN, '')
+        .replace(C1_STRING_PATTERN, '')
+        .replace(ANSI_CSI_PATTERN, '')
+        .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: sanitizeInlineText(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,6 +2,7 @@
 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 { sanitizeInlineText } from './core/worktree-projection.js';
 import { ThemeProvider } from '@inkjs/ui';
 import { render } from 'ink';
 import { APP_RENDER_OPTIONS } from './render-options.js';
@@ -37,7 +38,7 @@ async function handleInitCommand() {
         parsed = parseInitArgs(args.slice(1));
     }
     catch (error) {
-        console.error(error.message);
+        console.error(sanitizeInlineText(error.message));
         process.exit(1);
     }
     if (parsed.help) {
@@ -46,10 +47,10 @@ async function handleInitCommand() {
     }
     try {
         const result = await createConfigForRepo({ cwd, force: parsed.force });
-        console.log(`Created ${result.path}`);
+        console.log(`Created ${sanitizeInlineText(result.path)}`);
     }
     catch (error) {
-        console.error(error.message);
+        console.error(sanitizeInlineText(error.message));
         process.exit(1);
     }
 }
@@ -62,7 +63,7 @@ if (args.includes('-h') || args.includes('--help')) {
     process.exit(0);
 }
 if (subcommand !== undefined) {
-    console.error(`Unknown command: ${subcommand}`);
+    console.error(`Unknown command: ${sanitizeInlineText(subcommand)}`);
     process.exit(1);
 }
 try {
@@ -90,6 +91,6 @@ try {
     }
 }
 catch (error) {
-    console.error(describeError(error));
+    console.error(sanitizeInlineText(describeError(error)));
     process.exit(1);
 }

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.3",
   "description": "A TUI for managing git worktrees",
   "private": false,
   "type": "module",