deck-plugin-sdk 1.2.0 → 1.5.0

package/types/modules/editor/DiffPeek.d.ts

@@ -0,0 +1,19 @@
+// GENERATED by sdk/gen-types.mjs from Deck's source — do not edit.
+import { type RefObject } from "react";
+import { monaco } from "../../core/monaco";
+import { type DirtyRange } from "./hunks";
+/**
+ * The peek, for the editor in `edRef` showing `path` with the gutter's `ranges`. Returns what to
+ * render (a portal into the overlay), or null while closed.
+ *
+ * `clean` is whether the editor holds what is on disk: the changes are git's, read from disk, so
+ * their line numbers only fit the buffer when it has no unsaved edits. Staging and reverting wait
+ * for a save otherwise. `readBase` gives the text a change is against: the index's copy of the
+ * file for a change in the working tree, HEAD's for a staged one.
+ */
+export declare function useDiffPeek(edRef: RefObject<monaco.editor.IStandaloneCodeEditor | null>, path: string, ranges: DirtyRange[] | undefined, opts: {
+    clean: boolean;
+    onStage: (r: DirtyRange) => Promise<void>;
+    onUnstage: (r: DirtyRange) => Promise<void>;
+    readBase: (staged: boolean) => Promise<string>;
+}): import("react").ReactPortal | null;

package/types/modules/editor/MonacoHosts.d.ts

@@ -1,8 +1,8 @@
 // GENERATED by sdk/gen-types.mjs from Deck's source — do not edit.
 import { monaco } from "../../core/monaco";
 import { type EditorSettings } from "../../core/editorsettings";
-import type { DirtyRange } from "./tree";
-declare function MonacoEditorInner({ path, rel, value, onChange, onSave, gotoLine, gotoCol, gotoNonce, highlight, dirty, settings, onEditor }: {
+import type { DirtyRange } from "./hunks";
+declare function MonacoEditorInner({ path, rel, value, onChange, onSave, gotoLine, gotoCol, gotoNonce, highlight, dirty, settings, onEditor, clean, onStageChange, onUnstageChange, onReadBase }: {
     path: string;
     rel?: string | null;
     value: string;
@@ -22,6 +22,13 @@ declare function MonacoEditorInner({ path, rel, value, onChange, onSave, gotoLin
     /** Hands the live editor out, and null on unmount. For a formatting toolbar, which has to
      *  dispatch into this instance rather than rewrite the string around it. */
     onEditor?: (e: monaco.editor.IStandaloneCodeEditor | null) => void;
+    /** The buffer matches the file on disk, which the gutter's changes were read from. */
+    clean?: boolean;
+    /** Stage or unstage one change from the gutter's peek (DiffPeek.tsx). */
+    onStageChange?: (r: DirtyRange) => Promise<void>;
+    onUnstageChange?: (r: DirtyRange) => Promise<void>;
+    /** The text the file's changes are against: the index's copy, or HEAD's for a staged change. */
+    onReadBase?: (staged: boolean) => Promise<string>;
 }): import("react").JSX.Element;
 /**
  * Monaco owns its buffer, so this component re-rendering achieves nothing on its own — yet it was
@@ -35,13 +42,19 @@ declare function MonacoEditorInner({ path, rel, value, onChange, onSave, gotoLin
  */
 export declare const MonacoEditor: import("react").MemoExoticComponent<typeof MonacoEditorInner>;
 export declare function applyLineChanges(original: monaco.editor.ITextModel, modified: monaco.editor.ITextModel, diffs: monaco.editor.ILineChange[]): string;
+type HunkRun = (change: monaco.editor.ILineChange, models: {
+    original: monaco.editor.ITextModel;
+    modified: monaco.editor.ITextModel;
+}) => void;
+/**
+ * Per-change buttons in a diff's gutter: stage (or unstage) one change, and, given `revert`, put
+ * one change back to the left side's text. Each change gets them at its first line.
+ */
 export interface HunkAction {
     label: string;
     unstage: boolean;
-    run: (change: monaco.editor.ILineChange, models: {
-        original: monaco.editor.ITextModel;
-        modified: monaco.editor.ITextModel;
-    }) => void;
+    run: HunkRun;
+    revert?: HunkRun;
 }
 /** A side of a diff: LEFT the old version, RIGHT the new — GitHub's names, which line comments use. */
 export type DiffSide = "LEFT" | "RIGHT";

package/types/modules/editor/hunks.d.ts

@@ -0,0 +1,54 @@
+// GENERATED by sdk/gen-types.mjs from Deck's source — do not edit.
+/** One change: lines `oldStart..` of the base replaced by lines `newStart..` of the file. */
+export interface Hunk {
+    oldStart: number;
+    oldCount: number;
+    /** For a deletion (newCount 0), the line the removed lines were after; 0 at the very top. */
+    newStart: number;
+    newCount: number;
+    /** The base's lines and the file's, without git's prefix or a trailing \r. */
+    removed: string[];
+    added: string[];
+    /** The hunk exactly as git printed it, from its @@ line on, for a patch. */
+    raw: string[];
+}
+/** One file's diff: the lines before the first hunk (its header), and the hunks. */
+export interface FileDiff {
+    header: string[];
+    hunks: Hunk[];
+}
+/** A changed line range in the file, for the gutter. */
+export interface DirtyRange {
+    start: number;
+    end: number;
+    type: "added" | "modified" | "deleted";
+    /** Staged: in the index already, so shown dimmed. */
+    staged?: boolean;
+    hunk: Hunk;
+}
+/** Parse `git diff --unified=0` for one file. Empty text is an empty diff. */
+export declare function parseDiff(diff: string): FileDiff;
+/** Where a hunk sits in the file. A deletion is drawn on the line it follows (the first, at the top). */
+export declare function rangeOf(h: Hunk): Omit<DirtyRange, "hunk">;
+/**
+ * The gutter's ranges: every unstaged change, and every staged one that has not been changed again
+ * since it was staged.
+ *
+ * `unstaged` is the file against the index; `sinceHead`, when given, the file against HEAD. Both
+ * are in the file's own line numbers, which a diff of the index against HEAD (`--cached`) would
+ * not be once there are unstaged edits too. A change against HEAD that touches no unstaged line is
+ * entirely in the index: that is a staged one.
+ */
+export declare function dirtyRanges(unstaged: FileDiff, sinceHead?: FileDiff): DirtyRange[];
+/** A patch holding just this hunk, for `git apply --cached --unidiff-zero`. */
+export declare function hunkPatch(file: FileDiff, h: Hunk): string;
+/** The hunk in `file` with the same removed and added lines as `h`: a staged change, found in `--cached`. */
+export declare function sameHunk(file: FileDiff, h: Hunk): Hunk | undefined;
+/**
+ * The edit that puts a hunk's base lines back in the file, as a range in 1-based lines and
+ * columns and its replacement text. `lineCount` and `maxColumn` describe the file as it is.
+ */
+export declare function revertEdit(h: Hunk, lineCount: number, maxColumn: (line: number) => number, eol?: string): {
+    range: [number, number, number, number];
+    text: string;
+};

package/types/modules/editor/tree.d.ts

@@ -48,12 +48,6 @@ export declare function sameRows(a: readonly {
 export declare function buildChangeTree<T extends {
     rel: string;
 }>(rows: T[]): TreeNodeOf<T>[];
-export interface DirtyRange {
-    start: number;
-    end: number;
-    type: "added" | "modified" | "deleted";
-}
 export declare function statusColor(letter: string): string;
 /** Flatten a tree node to the file rows underneath it (a file node is just itself). */
 export declare function collectFiles(node: ChangeTreeNode): GitStatusRow[];
-export declare function parseDirty(diff: string): DirtyRange[];