refactor(core): fold single overflow entry unconditionally, drop foldSingleOverflow flag

Author: antfubot

packages/core/src/client/webcomponents/components/dock/Dock.vue

@@ -94,10 +94,8 @@ const isRpcTrusted = useIsRpcTrusted(context, (isTrusted) => {
 
 const groupedEntries = computed(() => context.docks.groupedEntries)
 
-// A lone overflowing entry folds back into `visible` (rendered inline) rather
-// than earning its own `DockOverflowButton` — see `foldSingleOverflow`.
 const splitEntries = computed(() => {
-  return docksSplitGroupsWithCapacity(groupedEntries.value, layout.value.maxVisibleItems, { foldSingleOverflow: true })
+  return docksSplitGroupsWithCapacity(groupedEntries.value, layout.value.maxVisibleItems)
 })
 
 const selectedEntry = computed(() => {

packages/core/src/client/webcomponents/state/__tests__/dock-sidebar-capacity.test.ts

@@ -52,46 +52,39 @@ describe('deriveSidebarCapacity', () => {
 
 describe('docksSplitGroupsWithCapacity (sidebar overflow)', () => {
   it('folds members beyond capacity into overflow, preserving order', () => {
-    const groups: DevToolsDockEntriesGrouped = [['default', [iframe('a'), iframe('b'), iframe('c')]]]
+    const groups: DevToolsDockEntriesGrouped = [['default', [iframe('a'), iframe('b'), iframe('c'), iframe('d')]]]
     const { visible, overflow } = docksSplitGroupsWithCapacity(groups, 2)
     expect(visible).toEqual([['default', [iframe('a'), iframe('b')]]])
-    expect(overflow).toEqual([['default', [iframe('c')]]])
+    expect(overflow).toEqual([['default', [iframe('c'), iframe('d')]]])
   })
 
   it('splits across sub-categories once the first fills capacity', () => {
     const groups: DevToolsDockEntriesGrouped = [
       ['app', [iframe('a'), iframe('b')]],
-      ['web', [iframe('c'), iframe('d')]],
+      ['web', [iframe('c'), iframe('d'), iframe('e')]],
     ]
     const { visible, overflow } = docksSplitGroupsWithCapacity(groups, 3)
     expect(visible).toEqual([['app', [iframe('a'), iframe('b')]], ['web', [iframe('c')]]])
-    expect(overflow).toEqual([['web', [iframe('d')]]])
+    expect(overflow).toEqual([['web', [iframe('d'), iframe('e')]]])
   })
 
-  it('leaves a single overflowing entry in overflow by default', () => {
+  it('folds a lone overflowing entry back into visible instead of leaving it in overflow', () => {
     const groups: DevToolsDockEntriesGrouped = [['default', [iframe('a'), iframe('b'), iframe('c')]]]
     const { visible, overflow } = docksSplitGroupsWithCapacity(groups, 2)
-    expect(visible).toEqual([['default', [iframe('a'), iframe('b')]]])
-    expect(overflow).toEqual([['default', [iframe('c')]]])
-  })
-
-  it('foldSingleOverflow folds a lone overflowing entry back into visible', () => {
-    const groups: DevToolsDockEntriesGrouped = [['default', [iframe('a'), iframe('b'), iframe('c')]]]
-    const { visible, overflow } = docksSplitGroupsWithCapacity(groups, 2, { foldSingleOverflow: true })
     expect(visible).toEqual([['default', [iframe('a'), iframe('b')]], ['default', [iframe('c')]]])
     expect(overflow).toEqual([])
   })
 
-  it('foldSingleOverflow leaves two or more overflowing entries alone', () => {
+  it('leaves two or more overflowing entries as overflow', () => {
     const groups: DevToolsDockEntriesGrouped = [['default', [iframe('a'), iframe('b'), iframe('c'), iframe('d')]]]
-    const { visible, overflow } = docksSplitGroupsWithCapacity(groups, 2, { foldSingleOverflow: true })
+    const { visible, overflow } = docksSplitGroupsWithCapacity(groups, 2)
     expect(visible).toEqual([['default', [iframe('a'), iframe('b')]]])
     expect(overflow).toEqual([['default', [iframe('c'), iframe('d')]]])
   })
 
-  it('foldSingleOverflow is a no-op when nothing overflows', () => {
+  it('is a no-op when nothing overflows', () => {
     const groups: DevToolsDockEntriesGrouped = [['default', [iframe('a'), iframe('b')]]]
-    const { visible, overflow } = docksSplitGroupsWithCapacity(groups, 2, { foldSingleOverflow: true })
+    const { visible, overflow } = docksSplitGroupsWithCapacity(groups, 2)
     expect(visible).toEqual(groups)
     expect(overflow).toEqual([])
   })

packages/core/src/client/webcomponents/state/dock-settings.ts

@@ -406,18 +406,16 @@ export function deriveSidebarCapacity(options: SidebarCapacityOptions): number {
 /**
  * Split grouped entries into visible and overflow based on capacity.
  *
- * With `foldSingleOverflow`, a lone overflowing entry is folded back into
- * `visible` instead — a whole overflow affordance (button + badge + popover)
- * just to reveal one icon costs more chrome than it saves, so that one entry
- * renders inline in the slot the affordance would have occupied. Folding only
+ * A lone overflowing entry folds back into `visible` instead of staying in
+ * `overflow` — a whole overflow affordance (button + badge + popover) just to
+ * reveal one icon costs more chrome than it saves, so that one entry renders
+ * inline in the slot the affordance would have occupied. Folding only
  * triggers for exactly one overflowing entry; two or more still overflow
- * normally. Off by default so callers with their own overflow affordance
- * semantics (e.g. the group sidebar's "show more" rail button) are unaffected.
+ * normally.
  */
 export function docksSplitGroupsWithCapacity(
   groups: DevToolsDockEntriesGrouped,
   capacity: number,
-  options?: { foldSingleOverflow?: boolean },
 ): SplitGroupsResult {
   const visible: DevToolsDockEntriesGrouped = []
   const overflow: DevToolsDockEntriesGrouped = []
@@ -438,7 +436,7 @@ export function docksSplitGroupsWithCapacity(
     }
   }
 
-  if (options?.foldSingleOverflow && overflow.reduce((acc, [, items]) => acc + items.length, 0) === 1)
+  if (overflow.reduce((acc, [, items]) => acc + items.length, 0) === 1)
     return { visible: [...visible, ...overflow], overflow: [] }
 
   return { visible, overflow }