@nocobase/flow-engine 2.1.0-beta.9 → 2.2.0-alpha.1

package/src/views/__tests__/FlowView.usePage.test.tsx

@@ -8,7 +8,7 @@
  */
 
 import React from 'react';
-import { describe, expect, it, beforeEach } from 'vitest';
+import { describe, expect, it, beforeEach, vi } from 'vitest';
 import { render, act, waitFor, screen } from '@testing-library/react';
 import { FlowEngine } from '../../flowEngine';
 import { FlowEngineProvider } from '../../provider';
@@ -167,15 +167,16 @@ describe('FlowViewer zIndex with usePage', () => {
     );
 
     await waitFor(() => expect(api).toBeDefined());
+    const pageApi = api as NonNullable<typeof api>;
 
     await act(async () => {
-      api!.open({ target, content: <div data-testid="page1">Page 1</div> }, engine.context);
+      pageApi.open({ target, content: <div data-testid="page1">Page 1</div> }, engine.context);
     });
     await waitFor(() => expect(screen.getByTestId('page1')).toBeInTheDocument());
 
     // Opening page2 into the global embed container should destroy page1 (replace behavior).
     await act(async () => {
-      api!.open({ target, content: <div data-testid="page2">Page 2</div> }, engine.context);
+      pageApi.open({ target, content: <div data-testid="page2">Page 2</div> }, engine.context);
     });
     await waitFor(() => expect(screen.getByTestId('page2')).toBeInTheDocument());
     expect(screen.queryByTestId('page1')).not.toBeInTheDocument();
@@ -183,4 +184,243 @@ describe('FlowViewer zIndex with usePage', () => {
     unmount();
     document.body.removeChild(target);
   });
+
+  it('keeps active global embed view when replacement beforeClose blocks closing', async () => {
+    let getViewer: () => FlowViewer;
+    const beforeClose = vi.fn().mockResolvedValue(false);
+
+    const target = document.createElement('div');
+    target.id = GLOBAL_EMBED_CONTAINER_ID;
+    document.body.appendChild(target);
+
+    const { unmount } = render(
+      <Wrapper
+        onReady={(fn) => {
+          getViewer = fn;
+        }}
+      />,
+    );
+
+    await waitFor(() => expect(getViewer).toBeDefined());
+    const initialZIndex = getViewer().getNextZIndex();
+
+    let page1: any;
+    await act(async () => {
+      page1 = getViewer().embed({
+        target,
+        content: (currentPage) => {
+          currentPage.beforeClose = beforeClose;
+          return <div data-testid="page1">Page 1</div>;
+        },
+      });
+    });
+
+    await waitFor(() => expect(screen.getByTestId('page1')).toBeInTheDocument());
+    expect(getViewer().getNextZIndex()).toBe(initialZIndex + 1);
+
+    await act(async () => {
+      const page2 = getViewer().embed({ target, content: <div data-testid="page2">Page 2</div> });
+      await page2;
+    });
+
+    expect(beforeClose).toHaveBeenCalledTimes(1);
+    expect(screen.getByTestId('page1')).toBeInTheDocument();
+    expect(screen.queryByTestId('page2')).not.toBeInTheDocument();
+    expect(getViewer().getNextZIndex()).toBe(initialZIndex + 1);
+
+    await act(async () => {
+      page1.destroy();
+    });
+
+    unmount();
+    document.body.removeChild(target);
+  });
+
+  it('opens the replacement view after async beforeClose allows global embed replacement', async () => {
+    let getViewer: () => FlowViewer;
+    const beforeClose = vi.fn().mockResolvedValue(true);
+
+    const target = document.createElement('div');
+    target.id = GLOBAL_EMBED_CONTAINER_ID;
+    document.body.appendChild(target);
+
+    const { unmount } = render(
+      <Wrapper
+        onReady={(fn) => {
+          getViewer = fn;
+        }}
+      />,
+    );
+
+    await waitFor(() => expect(getViewer).toBeDefined());
+
+    await act(async () => {
+      getViewer().embed({
+        target,
+        content: (currentPage) => {
+          currentPage.beforeClose = beforeClose;
+          return <div data-testid="page1">Page 1</div>;
+        },
+      });
+    });
+
+    await waitFor(() => expect(screen.getByTestId('page1')).toBeInTheDocument());
+
+    await act(async () => {
+      getViewer().embed({ target, content: <div data-testid="page2">Page 2</div> });
+    });
+
+    await waitFor(() => expect(screen.getByTestId('page2')).toBeInTheDocument());
+    expect(beforeClose).toHaveBeenCalledTimes(1);
+    expect(screen.queryByTestId('page1')).not.toBeInTheDocument();
+
+    unmount();
+    document.body.removeChild(target);
+  });
+
+  it('runs a pending close only once and allows retry when beforeClose rejects', async () => {
+    let getViewer: () => FlowViewer;
+    let resolveFirstClose: (value: boolean) => void;
+    const beforeClose = vi
+      .fn()
+      .mockImplementationOnce(() => new Promise<boolean>((resolve) => (resolveFirstClose = resolve)))
+      .mockResolvedValueOnce(true);
+
+    const { unmount } = render(
+      <Wrapper
+        onReady={(fn) => {
+          getViewer = fn;
+        }}
+      />,
+    );
+
+    await waitFor(() => expect(getViewer).toBeDefined());
+
+    let page: any;
+    await act(async () => {
+      page = getViewer().embed({
+        content: (currentPage) => {
+          currentPage.beforeClose = beforeClose;
+          return <div data-testid="draft-editor">Draft editor</div>;
+        },
+      });
+    });
+
+    await waitFor(() => expect(screen.getByTestId('draft-editor')).toBeInTheDocument());
+
+    const firstClose = page.close();
+    const secondClose = page.close();
+    expect(firstClose).toBe(secondClose);
+    expect(beforeClose).toHaveBeenCalledTimes(1);
+
+    await act(async () => {
+      resolveFirstClose(false);
+      await firstClose;
+    });
+
+    expect(screen.getByTestId('draft-editor')).toBeInTheDocument();
+
+    await act(async () => {
+      await page.close();
+    });
+
+    expect(beforeClose).toHaveBeenCalledTimes(2);
+    await waitFor(() => expect(screen.queryByTestId('draft-editor')).not.toBeInTheDocument());
+
+    unmount();
+  });
+
+  it('keeps only the latest pending global embed replacement', async () => {
+    let getViewer: () => FlowViewer;
+    let resolveBeforeClose: (value: boolean) => void;
+    const beforeClose = vi.fn(() => new Promise<boolean>((resolve) => (resolveBeforeClose = resolve)));
+
+    const target = document.createElement('div');
+    target.id = GLOBAL_EMBED_CONTAINER_ID;
+    document.body.appendChild(target);
+
+    const { unmount } = render(
+      <Wrapper
+        onReady={(fn) => {
+          getViewer = fn;
+        }}
+      />,
+    );
+
+    await waitFor(() => expect(getViewer).toBeDefined());
+    const initialZIndex = getViewer().getNextZIndex();
+
+    await act(async () => {
+      getViewer().embed({
+        target,
+        content: (currentPage) => {
+          currentPage.beforeClose = beforeClose;
+          return <div data-testid="page1">Page 1</div>;
+        },
+      });
+    });
+
+    await waitFor(() => expect(screen.getByTestId('page1')).toBeInTheDocument());
+
+    const page2 = getViewer().embed({ target, content: <div data-testid="page2">Page 2</div> });
+    const page3 = getViewer().embed({ target, content: <div data-testid="page3">Page 3</div> });
+
+    await act(async () => {
+      resolveBeforeClose(true);
+      await page2;
+    });
+
+    expect(beforeClose).toHaveBeenCalledTimes(1);
+    expect(screen.queryByTestId('page1')).not.toBeInTheDocument();
+    expect(screen.queryByTestId('page2')).not.toBeInTheDocument();
+    await waitFor(() => expect(screen.getByTestId('page3')).toBeInTheDocument());
+    expect(getViewer().getNextZIndex()).toBe(initialZIndex + 1);
+
+    unmount();
+    document.body.removeChild(target);
+  });
+
+  it('keeps the embed close button usable after beforeClose blocks closing', async () => {
+    let getViewer: () => FlowViewer;
+    const beforeClose = vi.fn().mockResolvedValueOnce(false).mockResolvedValueOnce(true);
+
+    const { unmount } = render(
+      <Wrapper
+        onReady={(fn) => {
+          getViewer = fn;
+        }}
+      />,
+    );
+
+    await waitFor(() => expect(getViewer).toBeDefined());
+
+    await act(async () => {
+      getViewer().embed({
+        title: 'Draft editor',
+        content: (currentPage) => {
+          currentPage.beforeClose = beforeClose;
+          return <div data-testid="draft-editor">Draft editor</div>;
+        },
+      });
+    });
+
+    await waitFor(() => expect(screen.getByTestId('draft-editor')).toBeInTheDocument());
+    const closeButton = screen.getByRole('button');
+
+    await act(async () => {
+      closeButton.click();
+    });
+
+    expect(beforeClose).toHaveBeenCalledTimes(1);
+    expect(screen.getByTestId('draft-editor')).toBeInTheDocument();
+
+    await act(async () => {
+      closeButton.click();
+    });
+
+    expect(beforeClose).toHaveBeenCalledTimes(2);
+    await waitFor(() => expect(screen.queryByTestId('draft-editor')).not.toBeInTheDocument());
+
+    unmount();
+  });
 });

package/src/views/__tests__/ViewNavigation.test.ts

@@ -146,6 +146,47 @@ describe('ViewNavigation', () => {
 
       expect(mockCtx.router.navigate).toHaveBeenCalledWith('/admin', { replace: true });
     });
+
+    it('should use explicit basePath when navigating back', () => {
+      viewNavigation = new ViewNavigation(mockCtx, [{ viewUid: 'view1' }], { basePath: '/embed' });
+
+      viewNavigation.back();
+
+      expect(mockCtx.router.navigate).toHaveBeenCalledWith('/embed', { replace: true });
+    });
+
+    it('should use layout route basePathname when explicit basePath is absent', () => {
+      mockCtx.layoutRoute = {
+        basePathname: '/mobile',
+      };
+      viewNavigation = new ViewNavigation(mockCtx, [{ viewUid: 'view1' }]);
+
+      viewNavigation.back();
+
+      expect(mockCtx.router.navigate).toHaveBeenCalledWith('/mobile', { replace: true });
+    });
+
+    it('should fall back to layout routePath when explicit basePath is absent', () => {
+      mockCtx.layout = {
+        routePath: '/mobile',
+      };
+      viewNavigation = new ViewNavigation(mockCtx, [{ viewUid: 'view1' }]);
+
+      viewNavigation.back();
+
+      expect(mockCtx.router.navigate).toHaveBeenCalledWith('/mobile', { replace: true });
+    });
+
+    it('should ignore relative layout routePath when runtime basePathname is absent', () => {
+      mockCtx.layout = {
+        routePath: 'public-forms',
+      };
+      viewNavigation = new ViewNavigation(mockCtx, [{ viewUid: 'view1' }]);
+
+      viewNavigation.back();
+
+      expect(mockCtx.router.navigate).toHaveBeenCalledWith('/admin', { replace: true });
+    });
   });
 });
 
@@ -160,6 +201,17 @@ describe('generatePathnameFromViewParams', () => {
     expect(generatePathnameFromViewParams([{ viewUid: 'xxx' }])).toBe('/admin/xxx');
   });
 
+  it('should generate path with custom prefix', () => {
+    expect(generatePathnameFromViewParams([{ viewUid: 'xxx' }], { basePath: '/embed' })).toBe('/embed/xxx');
+    expect(generatePathnameFromViewParams([], { basePath: '/embed' })).toBe('/embed');
+  });
+
+  it('should generate path with nested basePath', () => {
+    expect(generatePathnameFromViewParams([{ viewUid: 'xxx' }], { basePath: '/admin/settings/public-forms' })).toBe(
+      '/admin/settings/public-forms/xxx',
+    );
+  });
+
   it('should generate view with tab', () => {
     expect(generatePathnameFromViewParams([{ viewUid: 'xxx', tabUid: 'yyy' }])).toBe('/admin/xxx/tab/yyy');
   });

package/src/views/__tests__/inheritLayoutContext.test.ts

@@ -0,0 +1,53 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+import { describe, expect, it } from 'vitest';
+import { FlowContext } from '../../flowContext';
+import { inheritLayoutContextForDetachedView } from '../inheritLayoutContext';
+
+describe('inheritLayoutContextForDetachedView', () => {
+  it('inherits layout context for detached view contexts', () => {
+    const sourceContext = new FlowContext();
+    const engineContext = new FlowContext();
+    const layoutContext = new FlowContext();
+    const viewContext = new FlowContext();
+
+    engineContext.defineProperty('skipAclCheck', { value: false });
+    layoutContext.defineProperty('skipAclCheck', { value: true });
+    sourceContext.defineProperty('engine', {
+      value: {
+        context: engineContext,
+      },
+    });
+    sourceContext.defineProperty('layoutContext', { value: layoutContext });
+
+    viewContext.addDelegate(engineContext);
+    inheritLayoutContextForDetachedView(viewContext, sourceContext);
+
+    expect(viewContext.skipAclCheck).toBe(true);
+  });
+
+  it('does nothing when source context has no layout context', () => {
+    const sourceContext = new FlowContext();
+    const engineContext = new FlowContext();
+    const viewContext = new FlowContext();
+
+    engineContext.defineProperty('skipAclCheck', { value: false });
+    sourceContext.defineProperty('engine', {
+      value: {
+        context: engineContext,
+      },
+    });
+
+    viewContext.addDelegate(engineContext);
+    inheritLayoutContextForDetachedView(viewContext, sourceContext);
+
+    expect(viewContext.skipAclCheck).toBe(false);
+  });
+});

package/src/views/__tests__/runViewBeforeClose.test.ts

@@ -0,0 +1,30 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+import { describe, expect, it, vi } from 'vitest';
+import { runViewBeforeClose } from '../runViewBeforeClose';
+
+describe('runViewBeforeClose', () => {
+  it('returns true when no beforeClose handler is configured', async () => {
+    await expect(runViewBeforeClose({} as any, { force: false })).resolves.toBe(true);
+  });
+
+  it('skips beforeClose handler for force close', async () => {
+    const beforeClose = vi.fn();
+
+    await expect(runViewBeforeClose({ beforeClose } as any, { force: true })).resolves.toBe(true);
+    expect(beforeClose).not.toHaveBeenCalled();
+  });
+
+  it('returns false when beforeClose handler blocks the close', async () => {
+    const beforeClose = vi.fn().mockResolvedValue(false);
+
+    await expect(runViewBeforeClose({ beforeClose } as any, { force: false })).resolves.toBe(false);
+  });
+});

package/src/views/__tests__/useDialog.closeDestroy.test.tsx

@@ -76,40 +76,40 @@ describe('useDialog - close/destroy logic', () => {
     return api;
   };
 
-  it('should call destroy (and thus closeFunc) when close is called without preventClose', () => {
+  it('should call destroy (and thus closeFunc) when close is called without preventClose', async () => {
     const api = renderUseDialog();
     const flowContext = createMockFlowContext();
 
     const dialog = api.open({}, flowContext);
 
-    dialog.close();
+    await dialog.close();
 
     expect(mockCloseFunc).toHaveBeenCalled();
   });
 
-  it('should not call destroy (and thus closeFunc) when close is called with preventClose=true', () => {
+  it('should not call destroy (and thus closeFunc) when close is called with preventClose=true', async () => {
     const api = renderUseDialog();
     const flowContext = createMockFlowContext();
 
     const dialog = api.open({ preventClose: true }, flowContext);
 
-    dialog.close();
+    await dialog.close();
 
     expect(mockCloseFunc).not.toHaveBeenCalled();
   });
 
-  it('should call destroy (and thus closeFunc) when close is called with preventClose=true but force=true', () => {
+  it('should call destroy (and thus closeFunc) when close is called with preventClose=true but force=true', async () => {
     const api = renderUseDialog();
     const flowContext = createMockFlowContext();
 
     const dialog = api.open({ preventClose: true }, flowContext);
 
-    dialog.close(undefined, true);
+    await dialog.close(undefined, true);
 
     expect(mockCloseFunc).toHaveBeenCalled();
   });
 
-  it('should delegate to navigation.back when triggerByRouter is true', () => {
+  it('should delegate to navigation.back when triggerByRouter is true', async () => {
     const api = renderUseDialog();
     const flowContext = createMockFlowContext();
     const backMock = vi.fn();
@@ -126,25 +126,25 @@ describe('useDialog - close/destroy logic', () => {
       flowContext,
     );
 
-    dialog.close();
+    await dialog.close();
 
     expect(backMock).toHaveBeenCalled();
     // Should not call destroy directly, let router handle it
     expect(mockCloseFunc).not.toHaveBeenCalled();
   });
 
-  it('should emit view activated event on opener engine', () => {
+  it('should emit view activated event on opener engine', async () => {
     const api = renderUseDialog();
     const flowContext = createMockFlowContext();
     const emitSpy = flowContext.engine.emitter.emit;
 
     const dialog = api.open({ inputArgs: { viewUid: 'child-view' } }, flowContext);
 
-    dialog.close();
+    await dialog.close();
     expect(emitSpy).toHaveBeenCalledWith('view:activated', expect.anything());
   });
 
-  it('should emit view events on immediate opener engine (previousEngine) when present', () => {
+  it('should emit view events on immediate opener engine (previousEngine) when present', async () => {
     const api = renderUseDialog();
     const flowContext = createMockFlowContext();
     const rootEmitSpy = flowContext.engine.emitter.emit;
@@ -153,7 +153,7 @@ describe('useDialog - close/destroy logic', () => {
 
     const dialog = api.open({ inputArgs: { viewUid: 'child-view' } }, flowContext);
 
-    dialog.close();
+    await dialog.close();
     expect(openerEmitSpy).toHaveBeenCalledWith('view:activated', expect.anything());
     expect(rootEmitSpy).not.toHaveBeenCalledWith('view:activated', expect.anything());
   });