dsh-ide-git 0.19.8 → 0.19.10

package/dsh.plugin.json

@@ -1,6 +1,6 @@
 {
   "id": "dsh-external/dsh-ide-git",
-  "version": "0.19.8",
+  "version": "0.19.10",
   "main": "./src/index.js",
   "description": "IDE 级 Git 操作面板:分支树 + 提交图谱 + 变更/暂存/提交 + 提交详情。装了 dsh-better-sidebar 时挂成它的原生 tab(右侧栏 + 底部工作台);没装时直接挂 DSH 原生右侧栏,单独安装即可用。JetBrains 风格 Git 工具窗口 for DeepSeek Harness.",
   "engines": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-ide-git",
-  "version": "0.19.8",
+  "version": "0.19.10",
   "description": "DSH plugin: an IDE-grade Git tool window as a native dsh-better-sidebar tab — branch tree, commit graph, changes, commit details, JetBrains-style actions, in the right sidebar and the bottom panel. | DSH 插件:IDE 级 Git 工具窗口,以 dsh-better-sidebar 原生 Tab 挂载——分支树 / 提交图谱 / 变更与提交详情 / JetBrains 风格操作,右侧栏与底部面板双布局自适应。",
   "type": "module",
   "repository": {

package/src/client.js

@@ -7068,6 +7068,20 @@ window.__ModuleLoader__.load({
       return kind + ':' + entry.name
     }
 
+    /* v0.19.9: the REMOTE section folds by path exactly like the local one. In
+       the common single-remote repo every row starts with the same "<remote>/"
+       prefix, which would nest every tree under one folder named after the
+       remote — noise, not grouping — so the strip applies only when EVERY name
+       shares that first segment AND carries it (a bare "main" beside
+       "origin/main" means mixed shapes and keeps full names). */
+    function remoteTreeStripOf(names) {
+      if (names.length === 0) return ''
+      const first = names.map((name) => String(name).split('/')[0])
+      if (new Set(first).size !== 1) return ''
+      const prefix = first[0] + '/'
+      return names.every((name) => String(name).startsWith(prefix) === true) ? prefix : ''
+    }
+
     /* Join selected values for the clipboard — one per line, the shape a
        terminal or an editor expects when pasting a list. */
     function clipboardLines(values) {
@@ -10249,6 +10263,22 @@ window.__ModuleLoader__.load({
         return props.vertical === true ? rect.width : rect.height
       }
       const sign = props.side === 'next' ? -1 : 1
+      /* Pointermove arrives faster than frames can paint, and every dragPane
+       * does a forced reflow (measurePanes) plus two setStates — handling each
+       * event is layout thrashing, and the report (#16 follow-up) is exactly
+       * that: a drag starts smooth, then feels glued to the cursor. The latest
+       * px parks in a ref and ONE rAF per frame hands it to the clamp; pointerup
+       * flushes the parked value first so a gesture never ends on a stale size. */
+      const frameRef = useRef(0)
+      const pendingRef = useRef(null)
+      const flushRef = useRef(null)
+      useEffect(() => () => { if (frameRef.current !== 0) cancelAnimationFrame(frameRef.current) }, [])
+      flushRef.current = () => {
+        if (frameRef.current !== 0) { cancelAnimationFrame(frameRef.current); frameRef.current = 0 }
+        const value = pendingRef.current
+        pendingRef.current = null
+        if (value !== null) props.onDrag(value)
+      }
       const onPointerDown = (event) => {
         if (event.button !== undefined && event.button !== 0) return
         dragRef.current = {
@@ -10264,11 +10294,13 @@ window.__ModuleLoader__.load({
         const drag = dragRef.current
         if (drag === null || drag.id !== event.pointerId) return
         const at = props.vertical === true ? event.clientX : event.clientY
-        props.onDrag(drag.size + sign * (at - drag.at))
+        pendingRef.current = drag.size + sign * (at - drag.at)
+        if (frameRef.current === 0) frameRef.current = requestAnimationFrame(() => flushRef.current())
       }
       const onPointerUp = () => {
         if (dragRef.current === null) return
         dragRef.current = null
+        if (frameRef.current !== 0) flushRef.current()
         props.onEnd()
       }
       const onKeyDown = (event) => {
@@ -10478,6 +10510,13 @@ window.__ModuleLoader__.load({
          double-click browses the current branch's history, right-click opens
          the same row menu (quick jump back to HEAD lives there). */
       const headEntry = locals.find((entry) => entry.head === true) || null
+      /* v0.19.9: remote rows group by their path BELOW the "<remote>/" prefix;
+         the full name still drives every selKey/menu/checkout path. */
+      const remoteStrip = remoteTreeStripOf(remotes.map((entry) => entry.name))
+      const remoteNameOf = (entry) => {
+        const name = String(entry.name)
+        return remoteStrip !== '' && name.startsWith(remoteStrip) === true ? name.slice(remoteStrip.length) : name
+      }
       /* A refresh that makes a picked ref disappear must not keep it selected. */
       useEffect(() => {
         reportGestureRef.current = false
@@ -10507,10 +10546,14 @@ window.__ModuleLoader__.load({
        * row only SELECTS it (checking out rewrites the working tree), so the row
        * carries the selection and a double-click does the checkout.
        */
-      const forestOf = (entries) => {
+      /* nameOf (v0.19.9) lets the remote section group by its name WITHOUT the
+         "<remote>/" prefix (see remoteTreeStripOf) while every row keeps its
+         full entry.name for selection, menus and checkout. */
+      const forestOf = (entries, nameOf) => {
+        const labelOf = nameOf === undefined ? (entry) => entry.name : nameOf
         const root = { folders: new Map(), leaves: [] }
         for (const entry of entries) {
-          const parts = String(entry.name).split('/')
+          const parts = String(labelOf(entry)).split('/')
           let node = root
           for (let index = 0; index < parts.length - 1; index += 1) {
             const key = parts[index]
@@ -10591,7 +10634,9 @@ window.__ModuleLoader__.load({
         for (const leaf of node.leaves) out.push(branchRow(leaf.entry, leaf.label, depth))
         return out
       }
-      const section = (key, title, entries, decorate, grouped) => E('div', { className: 'dig-section', key: key },
+      /* ns (v0.19.9) namespaces the fold ids of a grouped section ("remote/…")
+         so its folders remember their state independently of the local ones. */
+      const section = (key, title, entries, decorate, grouped, ns, nameOf) => E('div', { className: 'dig-section', key: key },
         E('button', {
           type: 'button', className: 'dig-section-head',
           onClick: () => setCollapsed((previous) => Object.assign({}, previous, { [key]: !previous[key] })),
@@ -10602,14 +10647,16 @@ window.__ModuleLoader__.load({
           E('span', null, title)),
         collapsed[key] === true ? null : E('div', { className: 'dig-section-body' },
           grouped === true
-            ? rowsOf(forestOf(entries.map((entry) => decorate(entry))), '', 0)
+            ? rowsOf(forestOf(entries.map((entry) => decorate(entry)), nameOf), ns || '', 0)
             : entries.map((entry) => branchRow(decorate(entry), undefined, 0))))
       /* Render-order mirror for Shift-ranges and Ctrl+A, plus the selKey→entry
          lookup the right-click menu and the Delete key resolve through. */
       const visibleLeaves = []
       if (favorites.length > 0) flatLeaves(forestOf(locals.filter((entry) => favorites.indexOf(entry.name) >= 0)), '', 0, visibleLeaves)
       flatLeaves(forestOf(locals), '', 0, visibleLeaves)
-      for (const entry of remotes) visibleLeaves.push({ entry: entry, label: undefined, depth: 0 })
+      /* Same tree, same prefix namespace the section renders with — Shift-ranges
+         and Ctrl+A must walk the EXACT order rows are shown in. */
+      flatLeaves(forestOf(remotes.map((entry) => Object.assign({}, entry, { remote: true })), remoteNameOf), 'remote', 0, visibleLeaves)
       for (const entry of tags) visibleLeaves.push({ entry: entry, label: undefined, depth: 0 })
       visibleRef.current = visibleLeaves
       const entryBySelKey = new Map()
@@ -10726,7 +10773,7 @@ window.__ModuleLoader__.load({
           }, t('branches.head')),
           favorites.length === 0 ? null : section('favorites', t('branches.favorites'), locals.filter((entry) => favorites.indexOf(entry.name) >= 0), (entry) => entry),
           section('local', t('branches.local'), locals, (entry) => entry, true),
-          section('remote', t('branches.remote'), remotes, (entry) => Object.assign({}, entry, { remote: true })),
+          section('remote', t('branches.remote'), remotes, (entry) => Object.assign({}, entry, { remote: true }), true, 'remote', remoteNameOf),
           section('tags', t('branches.tags'), tags, (entry) => Object.assign({}, entry, { tag: true }))),
         E(MarqueeBox, { box: treeMarquee.box }))
     }
@@ -12028,6 +12075,7 @@ window.__ModuleLoader__.load({
       useMeasureLayoutEffect(() => {
         const node = hostRef.current
         const holder = node === null || typeof node.closest !== 'function' ? null : node.closest('.dig-conversation-seat[data-immersive="1"]')
+        if (gateNestedLoop() === false) return
         setImmersiveSeat(holder !== null)
       })
       const compact = size.width > 0 && size.width < COMPACT_MAX_WIDTH
@@ -12089,14 +12137,48 @@ window.__ModuleLoader__.load({
          re-clamps a stored size has to see the same numbers the drag did — a drag
          allowed further than the render allows snaps back under the cursor. The
          bail-out comparison is what keeps this from looping. */
-      useEffect(() => {
+      /* A LAYOUT effect: on mount this runs before the first paint, so the
+         fallback layout (paneGeometry's stylesheet/literal defaults) is
+         replaced by the live one inside the same frame instead of being
+         painted and then jumped a frame later. Painting both is the "height
+         animation" on tab switches from issue #16 — two visible layouts ~80px
+         apart read as a smooth resize in a low-fps screen recording. Later
+         runs still track content arrival; the layout-phase cost is one
+         querySelectorAll over the 3-4 panes the post-paint run already paid. */
+      /* ---------- measurement loop fuse (issue #17) ---------- */
+
+      /* Every effect below runs on EVERY render and feeds a state update.
+         In a steady UI the bail-out comparisons stop the chain, but when the
+         realized layout disagrees with the just-measured one — a float pane
+         being created/resized on the desktop client hit exactly this — each
+         render re-measures a DIFFERENT box, the update nests synchronously
+         and React aborts at depth 50 with #185, leaving the pane white
+         behind the host's slot boundary. The gate detects that nesting
+         directly: runs are counted in a 40 ms window and a nested render
+         loop (50 commits inside one task) trips it long before React's
+         limit, while legitimate per-event work (a pointermove drag renders
+         at most twice in 40 ms) never comes close. Skipping a measurement
+         during a pathological burst only freezes the affected number until
+         the next window — degraded ratios for a frame, never a white pane. */
+      const measureGate = useRef({ n: 0, at: 0 })
+      const gateNestedLoop = () => {
+        const slot = measureGate.current
+        const now = Date.now()
+        if (now - slot.at > 40) { slot.at = now; slot.n = 0 }
+        slot.n += 1
+        return slot.n <= 6
+      }
+
+      useMeasureLayoutEffect(() => {
         const found = measurePanes()
+        if (gateNestedLoop() === false) return
         setPaneSizes((current) => (samePaneSizes(current, found) ? current : found))
       })
       useEffect(() => {
         const node = hostRef.current
         const holder = node === null || typeof node.closest !== 'function' ? null : node.closest('[data-dockkit-float]')
         const next = holder === null ? null : holder.getAttribute('data-dockkit-float')
+        if (gateNestedLoop() === false) return
         setFloatPaneId((current) => (current === next ? current : next))
       })
       const dock = props.dock === undefined ? null : props.dock

package/src/index.js

@@ -755,7 +755,14 @@ async function branches(payload) {
       behind: 0,
     }
     if (parts[0].startsWith('refs/heads/')) local.push(entry)
-    else if (parts[0].startsWith('refs/remotes/')) remote.push(entry)
+    else if (parts[0].startsWith('refs/remotes/')) {
+      /* "<remote>/HEAD" is the symbolic pointer at a remote's default branch —
+         its %(refname:short) collapses to the BARE remote name, so it is not a
+         branch anyone can check out. It never becomes a row (the stray
+         "<remote>" entry used to pollute the remote tree and, grouped, it also
+         defeated the tree's single-remote prefix strip). */
+      if (/^refs\/remotes\/[^/]+\/HEAD$/.test(parts[0]) === false) remote.push(entry)
+    }
     else if (parts[0].startsWith('refs/tags/')) tags.push({ name: entry.name, hash: entry.hash, shortHash: entry.shortHash, date: entry.date, subject: entry.subject })
   }
   for (const entry of local) {