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: persist preview mode across empty states in inbox (#5172)
Peter Chinman0a328feb42f5
diff --git a/apps/web/src/features/next-soup/soup-view/soup-view.tsx b/apps/web/src/features/next-soup/soup-view/soup-view.tsxindex 14b4e8ca3a..a0a7f0598b 100644--- a/apps/web/src/features/next-soup/soup-view/soup-view.tsx+++ b/apps/web/src/features/next-soup/soup-view/soup-view.tsx@@ -251,13 +251,6 @@ export const SoupView = (props: SoupViewProps) => {const panel = useSplitPanelOrThrow();const soupView = useSoupView();const isNewInboxEnabled = useIsNewInboxEnabled();- const hasPreviewItems = useSoupPreviewAvailability({- rows: soupView.rows,- isLoading: soupView.source.isLoading,- isFetching: soupView.source.isFetching,- isPlaceholderData: soupView.source.isPlaceholderData,- splitHandle: panel.handle,- });const openFocusedEntityInPreview = () => {const focusedRow = soup.focus.row();if (@@ -271,6 +264,14 @@ export const SoupView = (props: SoupViewProps) => {splitHandle: panel.handle,});};+ const hasPreviewItems = useSoupPreviewAvailability({+ rows: soupView.rows,+ isLoading: soupView.source.isLoading,+ isFetching: soupView.source.isFetching,+ isPlaceholderData: soupView.source.isPlaceholderData,+ splitHandle: panel.handle,+ onPreviewRestored: openFocusedEntityInPreview,+ });const entryState = panel.handle.currentEntryState();const contentId = panel.handle.content().id;@@ -398,9 +399,12 @@ export const SoupView = (props: SoupViewProps) => {});});- // Fresh preview-default views engage as soon as the layout can form a pair.- // useSoupPreviewAvailability owns disengagement and only closes the pair once- // the active query has settled with no previewable rows.+ // Fresh preview-default views engage as soon as the layout can form a pair,+ // without waiting for rows. useSoupPreviewAvailability owns disengagement: a+ // settled result with no previewable rows only suspends the pair and+ // re-engages once an entity arrives, so an initially empty view still lands+ // in preview mode. Resolving here keeps a manual exit from being undone by+ // later Soup updates.let initialPreviewResolved = false;createEffect(() => {if (initialPreviewResolved) return;diff --git a/apps/web/src/features/next-soup/soup-view/use-soup-preview-availability.test.ts b/apps/web/src/features/next-soup/soup-view/use-soup-preview-availability.test.tsindex f5346a3f1e..d449b48ed2 100644--- a/apps/web/src/features/next-soup/soup-view/use-soup-preview-availability.test.ts+++ b/apps/web/src/features/next-soup/soup-view/use-soup-preview-availability.test.ts@@ -17,15 +17,49 @@ const row = (const flushEffects = () => Promise.resolve();+/**+ * A SplitHandle stub whose controller role follows engage/disengage calls,+ * mirroring how the layout manager reports a Preview Pair.+ */+const splitHandleStub = (options: { controller: boolean; room?: boolean }) => {+ let controller = options.controller;+ const engagePreview = vi.fn(() => {+ controller = true;+ });+ const disengagePreview = vi.fn(() => {+ controller = false;+ });+ return {+ engagePreview,+ disengagePreview,+ exitPreviewAsUser: () => {+ controller = false;+ },+ handle: {+ isControllerSplit: () => controller,+ isViewerSplit: () => false,+ canEngagePreview: () => options.room ?? true,+ engagePreview,+ disengagePreview,+ } as unknown as SplitHandle,+ };+};+type HarnessOptions = {rows?: SoupRow[];isLoading?: boolean;isFetching?: boolean;isPlaceholderData?: boolean;+ controller?: boolean;+ room?: boolean;+ onPreviewRestored?: () => void;};const createHarness = (initial: HarnessOptions = {}) => {- const disengagePreview = vi.fn();+ const stub = splitHandleStub({+ controller: initial.controller ?? true,+ room: initial.room,+ });let dispose!: () => void;let setRows!: (rows: SoupRow[]) => void;let setLoading!: (loading: boolean) => void;@@ -51,15 +85,15 @@ const createHarness = (initial: HarnessOptions = {}) => {isLoading,isFetching,isPlaceholderData,- splitHandle: {- isControllerSplit: () => true,- disengagePreview,- } as unknown as SplitHandle,+ splitHandle: stub.handle,+ onPreviewRestored: initial.onPreviewRestored,});});return {- disengagePreview,+ engagePreview: stub.engagePreview,+ disengagePreview: stub.disengagePreview,+ exitPreviewAsUser: stub.exitPreviewAsUser,dispose,setRows,setLoading,@@ -121,6 +155,7 @@ describe('Soup preview availability', () => {});await flushEffects();expect(harness.disengagePreview).not.toHaveBeenCalled();+ expect(harness.engagePreview).not.toHaveBeenCalled();harness.dispose();});@@ -162,4 +197,95 @@ describe('Soup preview availability', () => {expect(harness.disengagePreview).toHaveBeenCalledOnce();harness.dispose();});++ it('re-engages preview when entities return after an empty state', async () => {+ const onPreviewRestored = vi.fn();+ const harness = createHarness({ onPreviewRestored });++ await flushEffects();+ harness.setRows([]);+ await flushEffects();+ expect(harness.disengagePreview).toHaveBeenCalledOnce();+ expect(harness.engagePreview).not.toHaveBeenCalled();++ harness.setRows([row()]);+ await flushEffects();+ expect(harness.engagePreview).toHaveBeenCalledOnce();+ expect(onPreviewRestored).toHaveBeenCalledOnce();+ harness.dispose();+ });++ it('waits for the returning result to settle before restoring preview', async () => {+ const onPreviewRestored = vi.fn();+ const harness = createHarness({ onPreviewRestored });++ await flushEffects();+ harness.setRows([]);+ await flushEffects();+ expect(harness.disengagePreview).toHaveBeenCalledOnce();++ // Entities reappear while their fetch is still in flight (e.g. an+ // optimistic insert): the suspension must not restore mid-flight.+ batch(() => {+ harness.setRows([row()]);+ harness.setFetching(true);+ });+ await flushEffects();+ expect(harness.engagePreview).not.toHaveBeenCalled();++ harness.setFetching(false);+ await flushEffects();+ expect(harness.engagePreview).toHaveBeenCalledOnce();+ expect(onPreviewRestored).toHaveBeenCalledOnce();+ harness.dispose();+ });++ it('does not re-engage after the user exits preview mode', async () => {+ const harness = createHarness();++ await flushEffects();+ harness.exitPreviewAsUser();++ harness.setRows([]);+ await flushEffects();+ expect(harness.disengagePreview).not.toHaveBeenCalled();++ harness.setRows([row()]);+ await flushEffects();+ expect(harness.engagePreview).not.toHaveBeenCalled();+ harness.dispose();+ });++ it('does not engage when preview was never on', async () => {+ const harness = createHarness({ rows: [], controller: false });++ await flushEffects();+ harness.setRows([row()]);+ await flushEffects();+ expect(harness.engagePreview).not.toHaveBeenCalled();+ harness.dispose();+ });++ it('consumes the suspension when there is no room to restore', async () => {+ const onPreviewRestored = vi.fn();+ const harness = createHarness({ room: false, onPreviewRestored });++ await flushEffects();+ harness.setRows([]);+ await flushEffects();+ expect(harness.disengagePreview).toHaveBeenCalledOnce();++ harness.setRows([row()]);+ await flushEffects();+ expect(harness.engagePreview).not.toHaveBeenCalled();+ expect(onPreviewRestored).not.toHaveBeenCalled();++ // The consumed suspension cannot re-engage on a later cycle either.+ harness.setRows([]);+ await flushEffects();+ harness.setRows([row()]);+ await flushEffects();+ expect(harness.engagePreview).not.toHaveBeenCalled();+ harness.dispose();+ });});diff --git a/apps/web/src/features/next-soup/soup-view/use-soup-preview-availability.ts b/apps/web/src/features/next-soup/soup-view/use-soup-preview-availability.tsindex 0bb4013045..ae66ce7d43 100644--- a/apps/web/src/features/next-soup/soup-view/use-soup-preview-availability.ts+++ b/apps/web/src/features/next-soup/soup-view/use-soup-preview-availability.ts@@ -1,14 +1,18 @@import type { SoupRow } from '@app/features/next-soup/create-soup-state';import type { SplitHandle } from '@components/app/split-layout/layoutManager';-import { type Accessor, createEffect, createMemo } from 'solid-js';+import { type Accessor, createEffect, createMemo, untrack } from 'solid-js';export function hasPreviewableSoupRows(rows: readonly SoupRow[]): boolean {return rows.some((row) => !row.getIsGrouped() && !row.getIsLoadMore());}/**- * Tracks whether a Soup view has an entity that can be previewed and closes- * its Preview Pair once a settled result contains no such entities.+ * Tracks whether a Soup view has an entity that can be previewed. A settled+ * result with no such entities suspends the view's Preview Pair rather than+ * ending it: preview mode disengages while the view is empty and re-engages+ * as soon as an entity returns. Only exits that happen outside this hook —+ * the user toggling preview off, closing the Viewer, layout constraints —+ * are permanent.** A result is only settled once nothing is in flight. `isLoading` alone* doesn't cover a tab switch: both soup sources keep the previous tab's rows@@ -26,6 +30,8 @@ export function useSoupPreviewAvailability(options: {/** True while rows still belong to the previous query key (tab switch). */isPlaceholderData: Accessor<boolean>;splitHandle: SplitHandle;+ /** Called after an empty-state suspension ends with preview re-engaged. */+ onPreviewRestored?: () => void;}): Accessor<boolean> {const hasPreviewItems = createMemo(() =>hasPreviewableSoupRows(options.rows())@@ -36,11 +42,38 @@ export function useSoupPreviewAvailability(options: {!options.isFetching() &&!options.isPlaceholderData();+ // Set only when this hook disengages preview itself, so an empty state is+ // a suspension while every other exit stays permanent.+ let suspended = false;+createEffect(() => {- if (!isSettled() || hasPreviewItems()) return;- if (options.splitHandle.isControllerSplit()) {- options.splitHandle.disengagePreview();+ if (!isSettled()) return;++ if (!hasPreviewItems()) {+ if (options.splitHandle.isControllerSplit()) {+ suspended = true;+ options.splitHandle.disengagePreview();+ }+ return;}++ if (!suspended) return;+ // A failed restore (e.g. no room for the Viewer) consumes the+ // suspension instead of re-engaging on an unrelated later layout change.+ suspended = false;+ untrack(() => {+ if (+ options.splitHandle.isViewerSplit() ||+ options.splitHandle.isControllerSplit() ||+ !options.splitHandle.canEngagePreview()+ ) {+ return;+ }+ options.splitHandle.engagePreview();+ if (options.splitHandle.isControllerSplit()) {+ options.onPreviewRestored?.();+ }+ });});return hasPreviewItems;