Skip to content

armgit / macro

Public Imported from GitHub
0

Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.

fix: truncate block names correctly (#5531)

Peter Chinmanf74a46e6c76a
diff --git a/apps/web/src/components/app/split-layout/components/PriorityCollapseOverflowSensor.tsx b/apps/web/src/components/app/split-layout/components/PriorityCollapseOverflowSensor.tsx
index 31ed31ec45..9187c2fea0 100644
--- a/apps/web/src/components/app/split-layout/components/PriorityCollapseOverflowSensor.tsx
+++ b/apps/web/src/components/app/split-layout/components/PriorityCollapseOverflowSensor.tsx
@@ -3,6 +3,8 @@ import {
type Accessor,
createEffect,
createSignal,
+ createUniqueId,
+ onCleanup,
type ParentProps,
} from 'solid-js';
import {
@@ -11,6 +13,10 @@ import {
type PriorityCollapser,
} from '../utils/createPriorityCollapser';
+/** Collapses only after every real collapse item has already given up its
+ * space. */
+const TRUNCATE_LAST_RESORT_PRIORITY = Number.MAX_SAFE_INTEGER;
+
export type PriorityCollapseController = {
collapser: PriorityCollapser;
setRow: (element: HTMLElement) => void;
@@ -101,8 +107,33 @@ export function PriorityCollapseOverflowSensor(
class?: string;
contentClass?: string;
contentRef?: (element: HTMLDivElement) => void;
+ /**
+ * Cap the max-content element at the sensor's width as the collapser's
+ * last resort. The cap registers as a final collapse item, so it engages
+ * only once every other registered item has collapsed and the content
+ * still overflows, and it lifts again before any of them re-expands.
+ * While capped, shrinkable content (e.g. a title's `truncate` span)
+ * ellipsizes instead of painting past the sensor's clipped edge; without
+ * it, content that outgrows the fully-collapsed row is clipped mid-glyph.
+ */
+ truncateAsLastResort?: boolean;
}>
) {
+ const [capped, setCapped] = createSignal(false);
+
+ // Read once by design: the flag decides whether this sensor owns a collapse
+ // registration, which can't be torn down and re-created reactively.
+ if (props.truncateAsLastResort) {
+ onCleanup(
+ props.controller.collapser.register({
+ id: `truncate-last-resort-${createUniqueId()}`,
+ priority: TRUNCATE_LAST_RESORT_PRIORITY,
+ collapsed: capped,
+ setCollapsed: (value) => setCapped(value),
+ })
+ );
+ }
+
const setContentRef = (element: HTMLDivElement) => {
props.controller.setContent(element);
props.contentRef?.(element);
@@ -110,7 +141,10 @@ export function PriorityCollapseOverflowSensor(
return (
<div ref={props.controller.setViewport} class={props.class}>
- <div ref={setContentRef} class={cn('w-max', props.contentClass)}>
+ <div
+ ref={setContentRef}
+ class={cn('w-max', capped() && 'max-w-full', props.contentClass)}
+ >
{props.children}
</div>
</div>
diff --git a/apps/web/src/components/app/split-layout/components/SplitHeader.tsx b/apps/web/src/components/app/split-layout/components/SplitHeader.tsx
index 89b62e5ac2..7b6059e641 100644
--- a/apps/web/src/components/app/split-layout/components/SplitHeader.tsx
+++ b/apps/web/src/components/app/split-layout/components/SplitHeader.tsx
@@ -544,10 +544,15 @@ export function SplitHeader(props: {
</HeaderIsland>
</Show>
+ {/* On mobile nothing clips this region (islands float over the
+ panel), so the max-content element is capped at the sensor's
+ width to let shrinkable islands truncate long titles instead of
+ painting off-screen. */}
<PriorityCollapseOverflowSensor
controller={props.collapseController}
+ truncateAsLastResort
class="relative min-w-0 h-full shrink overflow-hidden mobile:overflow-visible"
- contentClass="h-full flex items-center gap-0.5 pl-2 mobile:pl-0 mobile:gap-2"
+ contentClass="h-full flex items-center gap-0.5 pl-2 mobile:pl-0 mobile:gap-2 mobile:max-w-full"
contentRef={(element) => {
panel.layoutRefs.headerLeft = element;
}}
diff --git a/apps/web/src/components/app/split-layout/tests/createPriorityCollapser.test.ts b/apps/web/src/components/app/split-layout/tests/createPriorityCollapser.test.ts
index 7920520a1b..a6b4ee3512 100644
--- a/apps/web/src/components/app/split-layout/tests/createPriorityCollapser.test.ts
+++ b/apps/web/src/components/app/split-layout/tests/createPriorityCollapser.test.ts
@@ -123,6 +123,141 @@ describe('createPriorityCollapser', () => {
};
}
+ // Mirrors PriorityCollapseOverflowSensor's `truncateAsLastResort` item: a
+ // max-priority registration whose collapsed state caps required width at the
+ // available width, because the sensor's shrinkable content then fits the
+ // capped element exactly.
+ function createLastResortCapHarness() {
+ const transitions: Array<{
+ id: string;
+ collapsed: boolean;
+ silent: boolean;
+ }> = [];
+ let availableWidth = 100;
+ let retryWidth = 100;
+ let invalidate = () => {};
+ let disposeRoot = () => {};
+
+ const titleWidth = 40;
+ const [tabsCollapsed, setTabsCollapsed] = createSignal(false);
+ const [capped, setCapped] = createSignal(false);
+
+ const probe: OverflowProbe = {
+ measure: () => {
+ const requiredWidth = titleWidth + (tabsCollapsed() ? 20 : 50);
+ return {
+ requiredWidth: capped()
+ ? Math.min(requiredWidth, availableWidth)
+ : requiredWidth,
+ availableWidth,
+ retryWidth,
+ };
+ },
+ observe: (onChange) => {
+ invalidate = onChange;
+ return () => {};
+ },
+ };
+
+ const collapser = createRoot((dispose) => {
+ disposeRoot = dispose;
+ return createPriorityCollapser(probe);
+ });
+
+ const track =
+ (id: string, set: (value: boolean) => void) =>
+ (value: boolean, options?: { silent?: boolean }) => {
+ transitions.push({
+ id,
+ collapsed: value,
+ silent: options?.silent ?? false,
+ });
+ set(value);
+ };
+
+ collapser.register({
+ id: 'tabs',
+ priority: 1,
+ collapsed: tabsCollapsed,
+ setCollapsed: track('tabs', setTabsCollapsed),
+ });
+ collapser.register({
+ id: 'cap',
+ priority: Number.MAX_SAFE_INTEGER,
+ collapsed: capped,
+ setCollapsed: track('cap', setCapped),
+ });
+
+ return {
+ dispose: disposeRoot,
+ invalidate: () => {
+ invalidate();
+ flushAnimationFrames();
+ },
+ setAvailableWidth: (width: number) => {
+ availableWidth = width;
+ },
+ setRetryWidth: (width: number) => {
+ retryWidth = width;
+ },
+ tabsCollapsed,
+ capped,
+ transitions,
+ };
+ }
+
+ it('collapses a last-resort width cap only after real items give up their space', () => {
+ const harness = createLastResortCapHarness();
+
+ harness.setAvailableWidth(70);
+ harness.invalidate();
+ expect(harness.tabsCollapsed()).toBe(true);
+ expect(harness.capped()).toBe(false);
+
+ harness.setAvailableWidth(50);
+ harness.invalidate();
+ expect(harness.capped()).toBe(true);
+
+ harness.transitions.length = 0;
+ harness.setAvailableWidth(120);
+ harness.setRetryWidth(130);
+ harness.invalidate();
+
+ expect(harness.capped()).toBe(false);
+ expect(harness.tabsCollapsed()).toBe(false);
+ expect(
+ harness.transitions
+ .filter(({ collapsed, silent }) => !collapsed && !silent)
+ .map(({ id }) => id)
+ ).toEqual(['cap', 'tabs']);
+
+ harness.dispose();
+ });
+
+ it('holds a capped row steady instead of thrashing the cap', () => {
+ const harness = createLastResortCapHarness();
+
+ harness.setAvailableWidth(50);
+ harness.invalidate();
+ expect(harness.tabsCollapsed()).toBe(true);
+ expect(harness.capped()).toBe(true);
+
+ // Same widths again: the failed-expand guard skips the trial entirely.
+ harness.transitions.length = 0;
+ harness.invalidate();
+ expect(harness.transitions).toEqual([]);
+
+ // Growth too small to fit the full content: the trial expansion runs but
+ // reverts pre-paint, so the cap never visibly flickers.
+ harness.setAvailableWidth(55);
+ harness.invalidate();
+ expect(harness.capped()).toBe(true);
+ expect(harness.transitions.length).toBeGreaterThan(0);
+ expect(harness.transitions.every(({ silent }) => silent)).toBe(true);
+
+ harness.dispose();
+ });
+
it('collapses the lowest-priority-number item first and stops once content fits', () => {
const harness = createHarness();
const first = harness.register('first', 1, 50, 20);