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: 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.tsx
index 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.ts
index 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.ts
index 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;