@young1lin/dsh-ui-gitworkbench 0.1.11 → 0.1.13

package/src/client/row-window.ts

@@ -72,6 +72,29 @@ export interface RowWindow {
   readonly padBottom: number
 }
 
+/** Whether two windows paint the same rows AND reserve the same total height.
+ * Comparing only start/end leaves a previous file's bottom spacer behind when
+ * two long files happen to expose the same viewport-sized row range. */
+export function sameRowWindow(a: RowWindow, b: RowWindow): boolean {
+  return a.start === b.start && a.end === b.end
+    && a.padTop === b.padTop && a.padBottom === b.padBottom
+}
+
+/** A rendered window is reusable only for the exact mounted diff. Equal-length
+ * files can be at different scroll positions, so row count alone is not an identity. */
+export interface HeldRowWindow {
+  readonly mountKey: string
+  readonly rowCount: number
+  readonly win: RowWindow
+}
+
+/** Return the held window when it belongs to this diff, otherwise a fresh top window. */
+export function rowWindowForMount(held: HeldRowWindow, rowCount: number, mountKey: string): RowWindow {
+  return held.rowCount === rowCount && held.mountKey === mountKey
+    ? held.win
+    : rowWindow(0, 0, rowCount)
+}
+
 /**
  * @param value - a number from the DOM, which can be NaN or negative.
  * @param fallback - used when it is neither finite nor usable.

package/src/client/search-count.ts

@@ -0,0 +1,125 @@
+/**
+ * How many matches the find panel found, and which one you are on.
+ *
+ * The panel ships without a count, which leaves the one question a reader
+ * actually has unanswered: a query that highlights nothing on screen might
+ * have no matches at all, or two hundred of them below the fold, and the panel
+ * looks identical either way.
+ *
+ * Counting is proportional to the DOCUMENT, and this drawer does not put work
+ * proportional to the document on the keystroke path. Two things keep that
+ * true, and both live here rather than in the wiring:
+ *
+ * - the walk stops at {@link MATCH_CAP}. A cap that turns a feature off would
+ *   be no fix, so this one bounds the WORK and keeps the feature: past the cap
+ *   the total reads `5000+`, which answers "is my query too broad" as well as
+ *   an exact number would. It bounds memory the same way — a single-letter
+ *   search over 20,000 lines of real TypeScript finds 71,515 matches, and an
+ *   array of those is half a megabyte kept alive for a number nobody reads.
+ * - the offsets are KEPT, so moving between matches is a binary search rather
+ *   than a second walk. Measured on this repo's own client sources: a full
+ *   count costs 3-5ms at 300 lines, 9-11ms at 2,000, 12ms at 4,000, and 60ms
+ *   at 20,000 (`SIDE_LINE_CAP`, the ceiling the pane will load). Recounting on
+ *   every Enter would put that 60ms on the navigation path; recounting when
+ *   the typing stops puts it nowhere the reader can feel it.
+ *
+ * The index belongs to one query over one document, and the caller throws it
+ * away when either changes — see `SearchCount` in `CodeEditor.tsx`.
+ *
+ * @module @young1lin/dsh-ui-gitworkbench/client/search-count
+ */
+
+/**
+ * How many match positions are kept.
+ *
+ * 5,000 is past any count a reader distinguishes from "lots" and well inside
+ * what the pane can hold: at 8 bytes an offset it is 40KB, against the half a
+ * megabyte an uncapped single-letter search over the ceiling would take.
+ */
+export const MATCH_CAP = 5000
+
+/** Where every match starts, and whether the walk stopped early. */
+export interface MatchIndex {
+  /** Ascending start offsets, at most {@link MATCH_CAP} of them. */
+  readonly offsets: readonly number[]
+  /** There were more matches than were kept; the total reads `N+`. */
+  readonly capped: boolean
+}
+
+/** No query, or a query with nothing to find. */
+export const EMPTY_INDEX: MatchIndex = { offsets: [], capped: false }
+
+/** One match start, however it is handed over. */
+interface Match { readonly from: number }
+
+/**
+ * Anything that yields matches in order.
+ *
+ * Both halves of the union are here for a reason: `SearchQuery.getCursor` is
+ * DECLARED as an iterator and is also iterable at runtime, while a test wants
+ * to hand over a plain array. Accepting either keeps the rule readable without
+ * a document, a view or a DOM behind it.
+ */
+export type MatchWalk = Iterable<Match> | Iterator<Match>
+
+/**
+ * Walk matches into an index, stopping at `cap`.
+ *
+ * The walk is driven by hand rather than with `for…of`, because the union
+ * above may arrive already unwrapped. A cursor reuses ONE object across
+ * iterations, which is safe here only because nothing but the number is kept.
+ */
+export function indexMatches(matches: MatchWalk, cap: number = MATCH_CAP): MatchIndex {
+  const step: Iterator<Match> = Symbol.iterator in matches
+    ? matches[Symbol.iterator]()
+    : matches
+  const offsets: number[] = []
+  for (;;) {
+    if (offsets.length >= cap) {
+      // Ask once more: `capped` has to mean "there are more", not "there might
+      // have been", or a total that lands exactly on the cap reads as `5000+`.
+      return { offsets, capped: step.next().done !== true }
+    }
+    const next = step.next()
+    if (next.done === true) return { offsets, capped: false }
+    offsets.push(next.value.from)
+  }
+}
+
+/**
+ * Which match the position `from` is on or before, 1-based; 0 when there are
+ * none.
+ *
+ * The first match at or after the caret, because that is the one the panel
+ * will land on — which makes the answer right in both of the states the reader
+ * sees it in. Straight after typing the caret has not moved and the count
+ * should already read `1/128`, not `0/128`; after Enter the selection sits
+ * exactly on a match and the lower bound IS that match. Past the last one the
+ * panel wraps, so the answer wraps with it.
+ */
+export function ordinalAt(index: MatchIndex, from: number): number {
+  const { offsets } = index
+  if (offsets.length === 0) return 0
+  let low = 0
+  let high = offsets.length
+  while (low < high) {
+    const mid = (low + high) >> 1
+    if (offsets[mid]! < from) low = mid + 1
+    else high = mid
+  }
+  return low === offsets.length ? 1 : low + 1
+}
+
+/**
+ * The label: `3/128`, `3/5000+` when the walk stopped early, `0/0` for a query
+ * that finds nothing.
+ *
+ * No words, in a panel whose own labels are the library's English and are not
+ * translated either — a pair of numbers says it in every language the drawer
+ * ships (see `locales.ts` for the strings that do need both).
+ */
+export function formatCount(index: MatchIndex, ordinal: number): string {
+  const total = index.offsets.length
+  if (total === 0) return '0/0'
+  return `${ordinal}/${total}${index.capped ? '+' : ''}`
+}

package/src/client/side-rows.ts

@@ -174,6 +174,17 @@ export function blockLines(rows: readonly SideRow[], block: number): readonly nu
   return [...indices].sort((a, b) => a - b)
 }
 
+/** Every changed hunk-line index, for a whole-layer Stage/Unstage action. */
+export function allBlockLines(rows: readonly SideRow[]): readonly number[] {
+  const indices = new Set<number>()
+  for (const row of rows) {
+    if (row.block < 0) continue
+    if (row.leftIndex !== -1) indices.add(row.leftIndex)
+    if (row.rightIndex !== -1) indices.add(row.rightIndex)
+  }
+  return [...indices].sort((a, b) => a - b)
+}
+
 /**
  * How many change blocks the rows hold.
  *
@@ -186,6 +197,49 @@ export function blockCount(rows: readonly SideRow[]): number {
   return max + 1
 }
 
+export type BlockEdge = 'single' | 'first' | 'middle' | 'last'
+
+/** Where one present side-cell sits on its block's visible perimeter. Absent
+ * cells return null: an addition-only block must not draw a blue cage through
+ * the empty left pane, and a deletion-only block does the symmetric thing. */
+export function blockEdge(rows: readonly SideRow[], index: number, side: 'left' | 'right'): BlockEdge | null {
+  const row = rows[index]
+  if (row === undefined || row.block < 0 || row[side] === null) return null
+  const before = index > 0 && rows[index - 1]!.block === row.block && rows[index - 1]![side] !== null
+  const after = index + 1 < rows.length && rows[index + 1]!.block === row.block && rows[index + 1]![side] !== null
+  if (!before && !after) return 'single'
+  if (!before) return 'first'
+  return after ? 'middle' : 'last'
+}
+
+/** The selected Git block exposed by the fixed pane toolbar. Visibility is
+ * independent of buffer dirtiness: the component keeps actions mounted and
+ * disables unsafe ones. A refreshed diff may carry fewer blocks, so an invalid
+ * selection safely falls back to the first one. */
+export function currentActionBlock(totalBlocks: number, actionsVisible: boolean, selectedBlock: number): number | null {
+  if (!actionsVisible || totalBlocks <= 0) return null
+  return Number.isInteger(selectedBlock) && selectedBlock >= 0 && selectedBlock < totalBlocks ? selectedBlock : 0
+}
+
+/** Git hunk operations wait for a clean editor buffer and for the prior Git
+ * operation to settle. This rule disables controls; it never hides them. */
+export function blockActionsDisabled(dirty: boolean, pendingBlock: number | null): boolean {
+  return dirty || pendingBlock !== null
+}
+
+/**
+ * Whether the first rendered row is already inside a change block.
+ *
+ * The block action bar normally floats one row above its first cell. When the
+ * file itself starts with a change there is no preceding row, so the columns
+ * must reserve that bar's clearance inside their own clipping boxes. This is
+ * derived from the full row model rather than hover state, avoiding a layout
+ * jump when the pointer enters line 1.
+ */
+export function needsFirstBlockClearance(rows: readonly SideRow[]): boolean {
+  return rows.length > 0 && rows[0]!.block >= 0
+}
+
 /**
  * Whether a block is the file's ENTIRE content: the one block of a diff with
  * no context row at all.
@@ -256,3 +310,15 @@ export function blockTally(rows: readonly SideRow[], block: number): { readonly
   }
   return { added, deleted }
 }
+
+/** Whole-layer tallies, paired with {@link allBlockLines}. */
+export function allBlockTally(rows: readonly SideRow[]): { readonly added: number; readonly deleted: number } {
+  let added = 0
+  let deleted = 0
+  for (const row of rows) {
+    if (row.block < 0) continue
+    if (row.left !== null) deleted += 1
+    if (row.right !== null) added += 1
+  }
+  return { added, deleted }
+}