@termaxjs/web-source-control 0.1.1

package/dist/useSourceControlPanel.js

@@ -0,0 +1,761 @@
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+const COMMIT_DIFF_CHAR_LIMIT = 60_000;
+const COMMIT_MESSAGE_MAX_OUTPUT_TOKENS = 1024;
+const RECONCILE_DEBOUNCE_MS = 180;
+const CONVENTIONAL_PREFIX = /^(feat|fix|docs|style|refactor|perf|test|build|ci|chore|revert)(\([^)]+\))?: .+/;
+const COMMIT_MESSAGE_SYSTEM_PROMPT = "You write concise Conventional Commit subject lines in English. Return exactly one complete line, with no markdown, no quotes, no body, and no explanation.";
+function normalizeError(error) {
+    if (typeof error === "string")
+        return error;
+    if (error && typeof error === "object" && "message" in error) {
+        const message = error.message;
+        if (typeof message === "string")
+            return message;
+    }
+    return "Unknown source control error";
+}
+function normalizeStatusCode(status) {
+    const code = status.trim().toUpperCase();
+    switch (code) {
+        case "?":
+            return "U";
+        case "A":
+            return "A";
+        case "M":
+            return "M";
+        case "D":
+            return "D";
+        case "R":
+        case "C":
+            return "R";
+        case "U":
+            return "U";
+        default:
+            return code || "M";
+    }
+}
+function statusCodeForMode(mode, file) {
+    if (mode === "-" && file.untracked)
+        return "U";
+    const primary = mode === "+" ? file.indexStatus : file.worktreeStatus;
+    const fallback = mode === "+" ? file.worktreeStatus : file.indexStatus;
+    return normalizeStatusCode(primary !== " " ? primary : fallback);
+}
+function makeEntry(path, mode, file) {
+    return {
+        key: `${mode}:${path}`,
+        path,
+        mode,
+        indexStatus: file.indexStatus,
+        worktreeStatus: file.worktreeStatus,
+        statusLabel: file.statusLabel,
+        statusCode: statusCodeForMode(mode, file),
+        originalPath: file.originalPath,
+        untracked: file.untracked,
+    };
+}
+function sameSelection(a, b) {
+    return !!a && !!b && a.path === b.path && a.mode === b.mode;
+}
+function stagedFilesSummary(entries) {
+    return entries
+        .map((entry) => {
+        const status = entry.originalPath
+            ? `R ${entry.originalPath} -> ${entry.path}`
+            : `${entry.statusCode} ${entry.path}`;
+        return `- ${status}`;
+    })
+        .join("\n");
+}
+function truncateDiff(diff) {
+    if (diff.length <= COMMIT_DIFF_CHAR_LIMIT) {
+        return { text: diff, truncated: false };
+    }
+    return { text: diff.slice(0, COMMIT_DIFF_CHAR_LIMIT), truncated: true };
+}
+function cleanCommitMessage(raw) {
+    let text = raw.trim();
+    const fence = text.match(/^```[a-zA-Z0-9_-]*\n([\s\S]*?)\n```\s*$/);
+    if (fence)
+        text = fence[1].trim();
+    const firstLine = text
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .find(Boolean);
+    if (!firstLine)
+        return "";
+    return firstLine.replace(/^["'`]+|["'`]+$/g, "").trim();
+}
+function isValidCommitMessage(message) {
+    return CONVENTIONAL_PREFIX.test(message);
+}
+function buildCommitMessagePrompt(entries, diffText, truncated) {
+    return [
+        "Generate one complete commit message for the staged changes only.",
+        "Format: type(scope): subject",
+        "Allowed types: feat, fix, docs, style, refactor, perf, test, build, ci, chore, revert.",
+        "Examples:",
+        "- feat(source-control): generate commit messages",
+        "- fix(git): handle staged diff errors",
+        "- chore: update project metadata",
+        "Use a short lowercase subject in imperative mood. Omit the scope if it would be vague.",
+        "Do not stop after the type or an opening parenthesis; the line must include a subject after ': '.",
+        truncated
+            ? "The diff below was truncated; infer from the visible staged changes only."
+            : "The full staged diff is included below.",
+        "",
+        "Staged files:",
+        stagedFilesSummary(entries),
+        "",
+        "Staged diff:",
+        diffText || "(No textual diff available.)",
+    ].join("\n");
+}
+function buildRepairCommitMessagePrompt(invalidMessage, entries) {
+    return [
+        "Repair this invalid Conventional Commit subject line.",
+        `Invalid line: ${invalidMessage || "(empty)"}`,
+        "Return exactly one complete valid line in this format: type(scope): subject",
+        "Allowed types: feat, fix, docs, style, refactor, perf, test, build, ci, chore, revert.",
+        "If the scope is unclear, omit it and use: type: subject",
+        "",
+        "Staged files:",
+        stagedFilesSummary(entries),
+    ].join("\n");
+}
+function optimisticStage(status, paths) {
+    let changed = false;
+    const next = status.changedFiles.map((file) => {
+        if (!paths.has(file.path))
+            return file;
+        if (file.staged && !file.unstaged)
+            return file;
+        changed = true;
+        const wt = file.worktreeStatus !== " " ? file.worktreeStatus : file.indexStatus;
+        return {
+            ...file,
+            indexStatus: wt,
+            worktreeStatus: " ",
+            staged: true,
+            unstaged: false,
+            untracked: false,
+        };
+    });
+    if (!changed)
+        return status;
+    return { ...status, changedFiles: next };
+}
+function optimisticUnstage(status, paths) {
+    let changed = false;
+    const next = [];
+    for (const file of status.changedFiles) {
+        if (!paths.has(file.path)) {
+            next.push(file);
+            continue;
+        }
+        if (!file.staged && file.unstaged) {
+            next.push(file);
+            continue;
+        }
+        changed = true;
+        const idx = file.indexStatus !== " " ? file.indexStatus : file.worktreeStatus;
+        if (idx === "R" && file.originalPath) {
+            next.push({
+                path: file.originalPath,
+                originalPath: null,
+                indexStatus: " ",
+                worktreeStatus: "D",
+                staged: false,
+                unstaged: true,
+                untracked: false,
+                statusLabel: "Deleted",
+            });
+            next.push({
+                path: file.path,
+                originalPath: null,
+                indexStatus: " ",
+                worktreeStatus: "?",
+                staged: false,
+                unstaged: true,
+                untracked: true,
+                statusLabel: "Untracked",
+            });
+            continue;
+        }
+        next.push({
+            ...file,
+            originalPath: null,
+            indexStatus: " ",
+            worktreeStatus: idx === "A" ? "?" : idx,
+            staged: false,
+            unstaged: true,
+            untracked: idx === "A",
+        });
+    }
+    if (!changed)
+        return status;
+    return { ...status, changedFiles: next };
+}
+function optimisticDiscard(status, paths) {
+    let changed = false;
+    const next = [];
+    for (const file of status.changedFiles) {
+        if (!paths.has(file.path)) {
+            next.push(file);
+            continue;
+        }
+        if (file.staged) {
+            changed = true;
+            next.push({
+                ...file,
+                worktreeStatus: " ",
+                unstaged: false,
+                untracked: false,
+            });
+        }
+        else {
+            changed = true;
+        }
+    }
+    if (!changed)
+        return status;
+    return { ...status, changedFiles: next };
+}
+export function useSourceControlPanel(adapter, isOpen, summary, onOpenDiff) {
+    // AI commit generation state is calculated below
+    const [panelState, setPanelState] = useState("closed");
+    const [repo, setRepo] = useState(null);
+    const [status, setStatus] = useState(null);
+    const [selected, setSelected] = useState(null);
+    const [commitMessage, setCommitMessage] = useState("");
+    const [localActionBusy, setLocalActionBusy] = useState(null);
+    const [actionError, setActionError] = useState(null);
+    const [actionMessage, setActionMessage] = useState(null);
+    const [selectionTransition, setSelectionTransition] = useState("none");
+    const [pendingDiscard, setPendingDiscard] = useState(null);
+    const selectedRef = useRef(null);
+    const reconcileTimerRef = useRef(0);
+    useEffect(() => {
+        selectedRef.current = selected;
+    }, [selected]);
+    const stagedEntries = useMemo(() => (status?.changedFiles ?? [])
+        .filter((file) => file.staged)
+        .map((file) => makeEntry(file.path, "+", file)), [status]);
+    const unstagedEntries = useMemo(() => (status?.changedFiles ?? [])
+        .filter((file) => file.unstaged)
+        .map((file) => makeEntry(file.path, "-", file)), [status]);
+    const fileEntries = useMemo(() => {
+        const seen = new Set();
+        const out = [];
+        for (const file of status?.changedFiles ?? []) {
+            if (seen.has(file.path))
+                continue;
+            seen.add(file.path);
+            const checkState = file.staged && file.unstaged
+                ? "indeterminate"
+                : file.staged
+                    ? "checked"
+                    : "unchecked";
+            const statusCode = file.unstaged
+                ? statusCodeForMode("-", file)
+                : statusCodeForMode("+", file);
+            out.push({
+                key: file.path,
+                path: file.path,
+                originalPath: file.originalPath,
+                statusCode,
+                statusLabel: file.statusLabel,
+                checkState,
+                staged: file.staged,
+                unstaged: file.unstaged,
+                untracked: file.untracked,
+            });
+        }
+        return out;
+    }, [status]);
+    const headerCheckState = useMemo(() => {
+        if (fileEntries.length === 0)
+            return "unchecked";
+        const allChecked = fileEntries.every((e) => e.checkState === "checked");
+        if (allChecked)
+            return "checked";
+        const anyStaged = fileEntries.some((e) => e.staged);
+        return anyStaged ? "indeterminate" : "unchecked";
+    }, [fileEntries]);
+    const allClean = stagedEntries.length === 0 && unstagedEntries.length === 0;
+    const canPush = !!status?.upstream && status.behind === 0;
+    const anyActionBusy = localActionBusy !== null || summary.busyAction !== null;
+    const aiUnavailableReason = useMemo(() => {
+        if (stagedEntries.length === 0) {
+            return "Stage changes to generate a commit message";
+        }
+        return null;
+    }, [stagedEntries.length]);
+    const canGenerateCommitMessage = (adapter.canGenerateCommitMessage ?? false) && stagedEntries.length > 0 && !anyActionBusy && !!repo;
+    const generateCommitMessageHint = aiUnavailableReason
+        ? aiUnavailableReason
+        : (adapter.generateCommitMessageHint ?? "Generate commit message");
+    const pushHint = useMemo(() => {
+        if (!status)
+            return null;
+        if (!status.upstream) {
+            return "Configure or publish this branch in the terminal to enable push in this iteration.";
+        }
+        if (status.behind > 0) {
+            return "Pull remote changes before pushing local commits.";
+        }
+        if (status.ahead === 0) {
+            return `No local commits to push to ${status.upstream}.`;
+        }
+        return `Pushes to ${status.upstream}.`;
+    }, [status]);
+    const stagedEmptyText = "No staged changes";
+    const unstagedEmptyText = "No unstaged changes";
+    const cancelReconcile = useCallback(() => {
+        if (reconcileTimerRef.current) {
+            window.clearTimeout(reconcileTimerRef.current);
+            reconcileTimerRef.current = 0;
+        }
+    }, []);
+    const scheduleReconcile = useCallback(() => {
+        cancelReconcile();
+        reconcileTimerRef.current = window.setTimeout(() => {
+            reconcileTimerRef.current = 0;
+            void summary.refresh({ remote: "never" });
+        }, RECONCILE_DEBOUNCE_MS);
+    }, [cancelReconcile, summary]);
+    useEffect(() => () => cancelReconcile(), [cancelReconcile]);
+    const openSelection = useCallback((sel, repoRoot, file) => {
+        onOpenDiff?.({
+            path: sel.path,
+            repoRoot,
+            mode: sel.mode,
+            originalPath: file?.originalPath ?? null,
+        });
+    }, [onOpenDiff]);
+    const refresh = useCallback(async () => {
+        if (!isOpen) {
+            setPanelState("closed");
+            setSelectionTransition("none");
+            return;
+        }
+        if (summary.repo)
+            adapter.invalidateRepoDiffs?.(summary.repo.repoRoot);
+        await summary.refresh({ remote: "never" });
+    }, [isOpen, summary, adapter]);
+    useEffect(() => {
+        if (!isOpen) {
+            setPanelState("closed");
+            setSelectionTransition("none");
+            return;
+        }
+        if (summary.isLoading && !summary.hasRepo && !summary.status) {
+            setPanelState("loading");
+            return;
+        }
+        if (!summary.hasRepo) {
+            setRepo(null);
+            setStatus(null);
+            setSelected(null);
+            setPanelState("no-repo");
+            setSelectionTransition("none");
+            return;
+        }
+        if (summary.localError && !summary.status) {
+            setRepo(summary.repo);
+            setStatus(null);
+            setSelected(null);
+            setPanelState("error");
+            setSelectionTransition("none");
+            return;
+        }
+        if (!summary.repo || !summary.status) {
+            if (summary.isLoading) {
+                setPanelState("loading");
+            }
+            return;
+        }
+        setRepo(summary.repo);
+        setStatus(summary.status);
+        setPanelState("ready");
+        const current = selectedRef.current;
+        const exists = !!current &&
+            summary.status.changedFiles.some((file) => {
+                if (file.path !== current.path)
+                    return false;
+                return current.mode === "+" ? file.staged : file.unstaged;
+            });
+        if (!exists && current) {
+            const samePathOtherMode = summary.status.changedFiles.find((file) => file.path === current.path &&
+                (current.mode === "+" ? file.unstaged : file.staged));
+            if (samePathOtherMode) {
+                const moved = {
+                    path: samePathOtherMode.path,
+                    mode: current.mode === "+" ? "-" : "+",
+                };
+                setSelected(moved);
+                setSelectionTransition("moved-group");
+            }
+            else {
+                setSelected(null);
+                setSelectionTransition("reset");
+            }
+        }
+        else {
+            setSelectionTransition("none");
+        }
+    }, [
+        isOpen,
+        summary.hasRepo,
+        summary.isLoading,
+        summary.localError,
+        summary.repo,
+        summary.status,
+    ]);
+    const selectEntry = useCallback(async (entry) => {
+        if (!repo)
+            return;
+        const nextSelection = {
+            path: entry.path,
+            mode: entry.mode,
+        };
+        if (sameSelection(selected, nextSelection)) {
+            setActionError(null);
+            setActionMessage(null);
+            setSelectionTransition("none");
+            return;
+        }
+        setSelected(nextSelection);
+        setActionError(null);
+        setActionMessage(null);
+        setSelectionTransition("none");
+        const file = status?.changedFiles.find((c) => c.path === entry.path);
+        openSelection(nextSelection, repo.repoRoot, file);
+    }, [openSelection, repo, selected, status]);
+    const runMutation = useCallback(async (busyKey, optimistic, ipc, affected) => {
+        if (!repo || summary.busyAction)
+            return;
+        setLocalActionBusy(busyKey);
+        setActionMessage(null);
+        setActionError(null);
+        if (optimistic)
+            summary.applyStatus(optimistic);
+        for (const path of affected) {
+            adapter.invalidateDiff?.(repo.repoRoot, path);
+        }
+        try {
+            await ipc();
+            scheduleReconcile();
+        }
+        catch (error) {
+            setActionError(normalizeError(error));
+            cancelReconcile();
+            await summary.refresh({ remote: "never" }).catch(() => { });
+        }
+        finally {
+            setLocalActionBusy(null);
+        }
+    }, [adapter, cancelReconcile, repo, scheduleReconcile, summary]);
+    const stageEntry = useCallback(async (entry) => {
+        if (!repo)
+            return;
+        await runMutation(`stage:${entry.path}`, (s) => optimisticStage(s, new Set([entry.path])), () => adapter.gitStage(repo.repoRoot, [entry.path]), [entry.path]);
+    }, [repo, runMutation, adapter]);
+    const unstageEntry = useCallback(async (entry) => {
+        if (!repo)
+            return;
+        await runMutation(`unstage:${entry.path}`, (s) => optimisticUnstage(s, new Set([entry.path])), () => adapter.gitUnstage(repo.repoRoot, [entry.path]), [entry.path]);
+    }, [repo, runMutation, adapter]);
+    const requestDiscardEntry = useCallback((entry) => {
+        if (!repo || summary.busyAction)
+            return;
+        setPendingDiscard({ scope: "single", entry });
+    }, [repo, summary.busyAction]);
+    const requestDiscardAll = useCallback(() => {
+        if (!repo || summary.busyAction || unstagedEntries.length === 0)
+            return;
+        setPendingDiscard({ scope: "all", entries: unstagedEntries });
+    }, [repo, summary.busyAction, unstagedEntries]);
+    const requestDiscardFile = useCallback((file) => {
+        if (!repo || summary.busyAction || unstagedEntries.length === 0)
+            return;
+        setPendingDiscard({ scope: "all", entries: unstagedEntries });
+    }, [repo, summary.busyAction, unstagedEntries]);
+    const cancelPendingDiscard = useCallback(() => {
+        setPendingDiscard(null);
+    }, []);
+    const confirmPendingDiscard = useCallback(async () => {
+        if (!repo || !pendingDiscard)
+            return;
+        const list = pendingDiscard.scope === "single"
+            ? [pendingDiscard.entry]
+            : pendingDiscard.entries;
+        setPendingDiscard(null);
+        const entries = list.map((entry) => ({
+            path: entry.path,
+            untracked: entry.untracked,
+        }));
+        const paths = new Set(list.map((entry) => entry.path));
+        await runMutation(pendingDiscard.scope === "single"
+            ? `discard:${list[0].path}`
+            : "discard:all", (s) => optimisticDiscard(s, paths), () => adapter.gitDiscard(repo.repoRoot, entries), [...paths]);
+    }, [pendingDiscard, repo, runMutation, adapter]);
+    const stageAllEntries = useCallback(async () => {
+        if (!repo || unstagedEntries.length === 0)
+            return;
+        const paths = new Set(unstagedEntries.map((entry) => entry.path));
+        await runMutation("stage:all", (s) => optimisticStage(s, paths), () => adapter.gitStage(repo.repoRoot, [...paths]), [...paths]);
+    }, [repo, runMutation, unstagedEntries, adapter]);
+    const unstageAllEntries = useCallback(async () => {
+        if (!repo || stagedEntries.length === 0)
+            return;
+        const paths = new Set(stagedEntries.map((entry) => entry.path));
+        await runMutation("unstage:all", (s) => optimisticUnstage(s, paths), () => adapter.gitUnstage(repo.repoRoot, [...paths]), [...paths]);
+    }, [repo, runMutation, stagedEntries, adapter]);
+    const selectFile = useCallback(async (entry) => {
+        if (!repo)
+            return;
+        const mode = entry.unstaged ? "-" : "+";
+        const nextSelection = { path: entry.path, mode };
+        if (sameSelection(selected, nextSelection)) {
+            setActionError(null);
+            setActionMessage(null);
+            setSelectionTransition("none");
+            return;
+        }
+        setSelected(nextSelection);
+        setActionError(null);
+        setActionMessage(null);
+        setSelectionTransition("none");
+        const file = status?.changedFiles.find((c) => c.path === entry.path);
+        openSelection(nextSelection, repo.repoRoot, file);
+    }, [openSelection, repo, selected, status]);
+    const toggleStageFile = useCallback(async (entry) => {
+        if (!repo)
+            return;
+        const paths = new Set([entry.path]);
+        if (entry.checkState === "checked") {
+            await runMutation(`unstage:${entry.path}`, (s) => optimisticUnstage(s, paths), () => adapter.gitUnstage(repo.repoRoot, [entry.path]), [entry.path]);
+        }
+        else {
+            await runMutation(`stage:${entry.path}`, (s) => optimisticStage(s, paths), () => adapter.gitStage(repo.repoRoot, [entry.path]), [entry.path]);
+        }
+    }, [repo, runMutation, adapter]);
+    const toggleAll = useCallback(async () => {
+        if (headerCheckState === "checked")
+            await unstageAllEntries();
+        else
+            await stageAllEntries();
+    }, [headerCheckState, stageAllEntries, unstageAllEntries]);
+    const stageHunk = useCallback(async (entry, patch, reverse) => {
+        if (!repo)
+            return;
+        await runMutation(reverse ? `unstage:${entry.path}` : `stage:${entry.path}`, (s) => s, () => adapter.gitApplyPatch(repo.repoRoot, patch, reverse, true), [entry.path]);
+    }, [repo, runMutation, adapter]);
+    const discardHunk = useCallback(async (entry, patch) => {
+        if (!repo)
+            return;
+        await runMutation(`discard:${entry.path}`, (s) => s, () => adapter.gitApplyPatch(repo.repoRoot, patch, true, false), [entry.path]);
+    }, [repo, runMutation, adapter]);
+    const generateCommitMessage = useCallback(async () => {
+        if (!repo || stagedEntries.length === 0)
+            return;
+        if (adapter.canGenerateCommitMessage === false) {
+            setActionError(adapter.generateCommitMessageHint ?? "AI commit generation not available");
+            return;
+        }
+        setLocalActionBusy("generate-message");
+        setActionMessage(null);
+        setActionError(null);
+        try {
+            const diffStr = await adapter.gitDiff(repo.repoRoot, null, true);
+            const diffText = diffStr.diffText;
+            if (adapter.generateCommitMessage) {
+                const message = await adapter.generateCommitMessage(diffText);
+                setCommitMessage(message);
+            }
+            else {
+                throw new Error("generateCommitMessage is not implemented in the adapter.");
+            }
+        }
+        catch (error) {
+            setActionError(normalizeError(error));
+        }
+        finally {
+            setLocalActionBusy(null);
+        }
+    }, [repo, stagedEntries, adapter]);
+    const commit = useCallback(async () => {
+        if (!repo || summary.busyAction)
+            return;
+        setLocalActionBusy("commit");
+        setActionMessage(null);
+        setActionError(null);
+        try {
+            const result = await adapter.gitCommit(repo.repoRoot, commitMessage);
+            setCommitMessage("");
+            setActionMessage(`Committed ${result.commitSha.slice(0, 7)} ${result.summary}`);
+            adapter.invalidateRepoDiffs?.(repo.repoRoot);
+            await summary.refresh({ remote: "never" });
+        }
+        catch (error) {
+            setActionError(normalizeError(error));
+        }
+        finally {
+            setLocalActionBusy(null);
+        }
+    }, [commitMessage, repo, summary, adapter.gitCommit, adapter.invalidateRepoDiffs]);
+    const push = useCallback(async () => {
+        if (!repo)
+            return;
+        setActionMessage(null);
+        setActionError(null);
+        const result = await summary.runRemoteAction("push");
+        if (result.ok) {
+            setActionMessage(status?.upstream ? `Pushed to ${status.upstream}` : "Push completed");
+            return;
+        }
+        if (result.error) {
+            setActionError(result.error);
+        }
+    }, [repo, status?.upstream, summary]);
+    const stashPush = useCallback(async (message) => {
+        if (!repo)
+            return;
+        setActionMessage(null);
+        setActionError(null);
+        setLocalActionBusy("stash");
+        try {
+            await adapter.gitStashPush(repo.repoRoot, message);
+            await summary.refresh();
+            setActionMessage("Stashed changes");
+        }
+        catch (error) {
+            setActionError(normalizeError(error));
+        }
+        finally {
+            setLocalActionBusy(null);
+        }
+    }, [repo, summary, adapter.gitStashPush]);
+    const stashPop = useCallback(async (stashId) => {
+        if (!repo)
+            return;
+        setActionMessage(null);
+        setActionError(null);
+        setLocalActionBusy("stash");
+        try {
+            await adapter.gitStashPop(repo.repoRoot, stashId);
+            await summary.refresh();
+            setActionMessage(`Popped stash ${stashId}`);
+        }
+        catch (error) {
+            setActionError(normalizeError(error));
+        }
+        finally {
+            setLocalActionBusy(null);
+        }
+    }, [repo, summary, adapter.gitStashPop]);
+    const stashApply = useCallback(async (stashId) => {
+        if (!repo)
+            return;
+        setActionMessage(null);
+        setActionError(null);
+        setLocalActionBusy("stash");
+        try {
+            await adapter.gitStashApply(repo.repoRoot, stashId);
+            await summary.refresh();
+            setActionMessage(`Applied stash ${stashId}`);
+        }
+        catch (error) {
+            setActionError(normalizeError(error));
+        }
+        finally {
+            setLocalActionBusy(null);
+        }
+    }, [repo, summary, adapter.gitStashApply]);
+    const stashDrop = useCallback(async (stashId) => {
+        if (!repo)
+            return;
+        setActionMessage(null);
+        setActionError(null);
+        setLocalActionBusy("stash");
+        try {
+            await adapter.gitStashDrop(repo.repoRoot, stashId);
+            await summary.refresh();
+            setActionMessage(`Dropped stash ${stashId}`);
+        }
+        catch (error) {
+            setActionError(normalizeError(error));
+        }
+        finally {
+            setLocalActionBusy(null);
+        }
+    }, [repo, summary, adapter.gitStashDrop]);
+    const pendingDiscardView = useMemo(() => {
+        if (!pendingDiscard)
+            return null;
+        if (pendingDiscard.scope === "single") {
+            return {
+                scope: "single",
+                count: 1,
+                label: pendingDiscard.entry.path,
+            };
+        }
+        return {
+            scope: "all",
+            count: pendingDiscard.entries.length,
+            label: `${pendingDiscard.entries.length} unstaged ${pendingDiscard.entries.length === 1 ? "file" : "files"}`,
+        };
+    }, [pendingDiscard]);
+    return {
+        panelState,
+        repo,
+        status,
+        stashes: summary.stashes,
+        selected,
+        commitMessage,
+        actionBusy: localActionBusy ?? summary.busyAction,
+        statusError: summary.localError,
+        actionError,
+        remoteError: summary.lastRemoteError,
+        actionMessage,
+        stagedEntries,
+        unstagedEntries,
+        fileEntries,
+        headerCheckState,
+        allClean,
+        canPush,
+        pushHint,
+        canGenerateCommitMessage,
+        generateCommitMessageHint,
+        selectionTransition,
+        stagedEmptyText,
+        unstagedEmptyText,
+        pendingDiscard: pendingDiscardView,
+        setCommitMessage,
+        refresh,
+        selectEntry,
+        selectFile,
+        stageEntry,
+        unstageEntry,
+        toggleStageFile,
+        toggleAll,
+        requestDiscardEntry,
+        requestDiscardFile,
+        requestDiscardAll,
+        stageHunk,
+        discardHunk,
+        confirmPendingDiscard,
+        cancelPendingDiscard,
+        stageAllEntries,
+        unstageAllEntries,
+        generateCommitMessage,
+        commit,
+        push,
+        stashPush,
+        stashPop,
+        stashApply,
+        stashDrop,
+    };
+}
+//# sourceMappingURL=useSourceControlPanel.js.map