Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.
TypeScript agentaiai-agentsall-in-onecrmcrm-systememaillinearmcpmessagingnotesnotionofficerustslackslack-alternativestartupstartup-toolstypescriptworkspace
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.tsxindex 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.tsxindex 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. */}<PriorityCollapseOverflowSensorcontroller={props.collapseController}+ truncateAsLastResortclass="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.tsindex 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);