@nocobase/flow-engine 2.2.0-beta.5 → 2.2.0-beta.7

package/src/components/settings/wrappers/contextual/__tests__/FlowsFloatContextMenu.test.tsx

@@ -8,7 +8,7 @@
  */
 
 import React from 'react';
-import { cleanup, fireEvent, render, waitFor, within } from '@testing-library/react';
+import { act, cleanup, fireEvent, render, waitFor, within } from '@testing-library/react';
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import { App, ConfigProvider } from 'antd';
 import { FlowEngine } from '../../../../../flowEngine';
@@ -17,7 +17,7 @@ import { FlowEngineProvider } from '../../../../../provider';
 import { FieldModelRenderer } from '../../../../FieldModelRenderer';
 import { FlowModelRenderer } from '../../../../FlowModelRenderer';
 import { FlowsFloatContextMenu } from '../FlowsFloatContextMenu';
-import { TOOLBAR_DRAG_ACTIVITY_EVENT } from '../../../../dnd';
+import { DndProvider, DragHandler, TOOLBAR_DRAG_ACTIVITY_EVENT } from '../../../../dnd';
 
 const mockColorTextTertiary = '#8c8c8c';
 
@@ -182,12 +182,24 @@ const ToolbarDragItem = ({ model }: { model: FlowModel }) => {
   );
 };
 
+const ForkedToolbarDragItem = ({ model }: { model: FlowModel }) => {
+  return (
+    <DragHandler model={model}>
+      <button type="button" aria-label="forked-toolbar-drag">
+        drag
+      </button>
+    </DragHandler>
+  );
+};
+
 describe('FlowsFloatContextMenu', () => {
   const originalResizeObserver = globalThis.ResizeObserver;
   const originalRequestAnimationFrame = globalThis.requestAnimationFrame;
   const originalCancelAnimationFrame = globalThis.cancelAnimationFrame;
+  const originalPointerEvent = globalThis.PointerEvent;
 
   beforeEach(() => {
+    globalThis.PointerEvent = MouseEvent as typeof PointerEvent;
     globalThis.ResizeObserver = class {
       observe = vi.fn();
       disconnect = vi.fn();
@@ -207,6 +219,7 @@ describe('FlowsFloatContextMenu', () => {
     globalThis.ResizeObserver = originalResizeObserver;
     globalThis.requestAnimationFrame = originalRequestAnimationFrame;
     globalThis.cancelAnimationFrame = originalCancelAnimationFrame;
+    globalThis.PointerEvent = originalPointerEvent;
     document.body.innerHTML = '';
   });
 
@@ -545,28 +558,163 @@ describe('FlowsFloatContextMenu', () => {
     fireEvent.mouseEnter(icons, { relatedTarget: host });
 
     const dragButton = within(overlay).getByLabelText('toolbar-drag');
-    dragButton.ownerDocument.dispatchEvent(
-      new CustomEvent(TOOLBAR_DRAG_ACTIVITY_EVENT, {
-        detail: { active: true, modelUid: model.uid },
-      }),
-    );
+    act(() => {
+      dragButton.ownerDocument.dispatchEvent(
+        new CustomEvent(TOOLBAR_DRAG_ACTIVITY_EVENT, {
+          detail: { active: true, modelUid: model.uid },
+        }),
+      );
+    });
     fireEvent.mouseLeave(icons, { relatedTarget: document.createElement('div') });
 
     await waitFor(() => {
       expect(queryOverlay(appContainer, 'drag-toolbar-model')?.className).toContain('nb-toolbar-visible');
     });
 
-    dragButton.ownerDocument.dispatchEvent(
-      new CustomEvent(TOOLBAR_DRAG_ACTIVITY_EVENT, {
-        detail: { active: false, modelUid: model.uid },
-      }),
-    );
+    act(() => {
+      dragButton.ownerDocument.dispatchEvent(
+        new CustomEvent(TOOLBAR_DRAG_ACTIVITY_EVENT, {
+          detail: { active: false, modelUid: model.uid },
+        }),
+      );
+    });
 
     await waitFor(() => {
       expect(queryOverlay(appContainer, 'drag-toolbar-model')).toBeNull();
     });
   });
 
+  it('does not let resize handle drag release close the surrounding modal wrap', async () => {
+    const engine = new FlowEngine();
+    await engine.flowSettings.forceEnable();
+    const parentModel = createModel(engine, 'resize-parent-model');
+    const model = createModel(engine, 'resize-child-model');
+    model.setParent(parentModel);
+    const appContainer = createAppContainer();
+    const modalWrap = createPopupRoot('ant-modal-wrap');
+    const onModalWrapClick = vi.fn();
+    modalWrap.addEventListener('click', onModalWrapClick);
+    appContainer.appendChild(modalWrap);
+    mockRect(appContainer, { top: 0, left: 0, width: 1280, height: 900 });
+    mockRect(modalWrap, { top: 100, left: 200, width: 640, height: 520 });
+
+    const { getByTestId } = renderWithProviders(
+      engine,
+      <FlowsFloatContextMenu model={model} showDragHandle>
+        <div data-testid="resize-content">content</div>
+      </FlowsFloatContextMenu>,
+      { container: modalWrap },
+    );
+
+    const host = getHost(getByTestId('resize-content'));
+    mockRect(host, { top: 140, left: 280, width: 220, height: 48 });
+
+    fireEvent.mouseEnter(host);
+
+    const overlay = await waitFor(() => {
+      const nextOverlay = modalWrap.querySelector('[data-model-uid="resize-child-model"]') as HTMLDivElement | null;
+      expect(nextOverlay).toBeTruthy();
+      return nextOverlay as HTMLDivElement;
+    });
+
+    const resizeHandle = overlay.querySelector('.resize-handle-right') as HTMLDivElement;
+    expect(resizeHandle).toBeTruthy();
+
+    fireEvent.mouseDown(resizeHandle, { clientX: 500, clientY: 164 });
+    fireEvent.mouseMove(document, { clientX: 460, clientY: 164 });
+    fireEvent.mouseUp(modalWrap, { clientX: 460, clientY: 164 });
+    fireEvent.click(modalWrap, { clientX: 460, clientY: 164 });
+
+    expect(onModalWrapClick).not.toHaveBeenCalled();
+  });
+
+  it('emits resize end when resize handles unmount during a drag', async () => {
+    const engine = new FlowEngine();
+    await engine.flowSettings.forceEnable();
+    const parentModel = createModel(engine, 'resize-unmount-parent-model');
+    const model = createModel(engine, 'resize-unmount-child-model');
+    model.setParent(parentModel);
+    const appContainer = createAppContainer();
+    const onResizeEnd = vi.fn();
+    parentModel.emitter.on('onResizeEnd', onResizeEnd);
+    mockRect(appContainer, { top: 0, left: 0, width: 1280, height: 900 });
+
+    const { getByTestId, unmount } = renderWithProviders(
+      engine,
+      <FlowsFloatContextMenu model={model} showDragHandle>
+        <div data-testid="resize-unmount-content">content</div>
+      </FlowsFloatContextMenu>,
+      { container: appContainer },
+    );
+
+    const host = getHost(getByTestId('resize-unmount-content'));
+    mockRect(host, { top: 140, left: 280, width: 220, height: 48 });
+
+    fireEvent.mouseEnter(host);
+
+    const overlay = await waitFor(() => {
+      const nextOverlay = appContainer.querySelector(
+        '[data-model-uid="resize-unmount-child-model"]',
+      ) as HTMLDivElement | null;
+      expect(nextOverlay).toBeTruthy();
+      return nextOverlay as HTMLDivElement;
+    });
+
+    const resizeHandle = overlay.querySelector('.resize-handle-right') as HTMLDivElement;
+    expect(resizeHandle).toBeTruthy();
+
+    fireEvent.mouseDown(resizeHandle, { clientX: 500, clientY: 164 });
+    unmount();
+
+    expect(onResizeEnd).toHaveBeenCalledTimes(1);
+  });
+
+  it('keeps the resize release click suppressed after handles unmount', async () => {
+    const engine = new FlowEngine();
+    await engine.flowSettings.forceEnable();
+    const parentModel = createModel(engine, 'resize-release-unmount-parent-model');
+    const model = createModel(engine, 'resize-release-unmount-child-model');
+    model.setParent(parentModel);
+    const appContainer = createAppContainer();
+    const modalWrap = createPopupRoot('ant-modal-wrap');
+    const onModalWrapClick = vi.fn();
+    modalWrap.addEventListener('click', onModalWrapClick);
+    appContainer.appendChild(modalWrap);
+    mockRect(appContainer, { top: 0, left: 0, width: 1280, height: 900 });
+    mockRect(modalWrap, { top: 100, left: 200, width: 640, height: 520 });
+
+    const { getByTestId, unmount } = renderWithProviders(
+      engine,
+      <FlowsFloatContextMenu model={model} showDragHandle>
+        <div data-testid="resize-release-unmount-content">content</div>
+      </FlowsFloatContextMenu>,
+      { container: modalWrap },
+    );
+
+    const host = getHost(getByTestId('resize-release-unmount-content'));
+    mockRect(host, { top: 140, left: 280, width: 220, height: 48 });
+
+    fireEvent.mouseEnter(host);
+
+    const overlay = await waitFor(() => {
+      const nextOverlay = modalWrap.querySelector(
+        '[data-model-uid="resize-release-unmount-child-model"]',
+      ) as HTMLDivElement | null;
+      expect(nextOverlay).toBeTruthy();
+      return nextOverlay as HTMLDivElement;
+    });
+
+    const resizeHandle = overlay.querySelector('.resize-handle-right') as HTMLDivElement;
+    expect(resizeHandle).toBeTruthy();
+
+    fireEvent.mouseDown(resizeHandle, { clientX: 500, clientY: 164 });
+    fireEvent.mouseUp(modalWrap, { clientX: 460, clientY: 164 });
+    unmount();
+    fireEvent.click(modalWrap, { clientX: 460, clientY: 164 });
+
+    expect(onModalWrapClick).not.toHaveBeenCalled();
+  });
+
   it('hides parent toolbar when hovering a nested child host', async () => {
     const engine = new FlowEngine();
     await engine.flowSettings.forceEnable();
@@ -714,6 +862,122 @@ describe('FlowsFloatContextMenu', () => {
     });
   });
 
+  it('restores parent toolbar when stale child activity remains but pointer is on the parent block', async () => {
+    const engine = new FlowEngine();
+    await engine.flowSettings.forceEnable();
+    const parentModel = createModel(engine, 'parent-stale-child-model');
+    const childModel = createModel(engine, 'child-stale-model');
+    const appContainer = createAppContainer();
+    mockRect(appContainer, { top: 0, left: 0, width: 1280, height: 900 });
+
+    const { getByTestId } = renderWithProviders(
+      engine,
+      <FlowsFloatContextMenu model={parentModel}>
+        <div data-testid="parent-content">
+          <div data-testid="parent-gap">gap</div>
+          <FlowsFloatContextMenu model={childModel}>
+            <div data-testid="child-content">child</div>
+          </FlowsFloatContextMenu>
+        </div>
+      </FlowsFloatContextMenu>,
+      { container: appContainer },
+    );
+
+    const parentHost = getHost(getByTestId('parent-content'));
+    const childHost = getHost(getByTestId('child-content'));
+    const parentGap = getByTestId('parent-gap');
+    mockRect(parentHost, { top: 10, left: 10, width: 320, height: 160 });
+    mockRect(childHost, { top: 28, left: 36, width: 120, height: 48 });
+
+    fireEvent.mouseEnter(parentHost);
+
+    const parentOverlay = await waitFor(() => {
+      const nextOverlay = queryOverlay(appContainer, 'parent-stale-child-model');
+      expect(nextOverlay).toBeTruthy();
+      return nextOverlay as HTMLDivElement;
+    });
+
+    await waitFor(() => {
+      expect(within(parentOverlay).getByLabelText('flows-settings')).toBeTruthy();
+    });
+
+    act(() => {
+      childHost.dispatchEvent(
+        new CustomEvent('nb-float-menu-child-activity', {
+          bubbles: true,
+          detail: { active: true, modelUid: childModel.uid },
+        }),
+      );
+    });
+
+    await waitFor(() => {
+      expect(queryOverlay(appContainer, 'parent-stale-child-model')).toBeNull();
+    });
+
+    fireEvent.mouseMove(parentGap);
+
+    await waitFor(() => {
+      const parentOverlayAfterRestore = queryOverlay(appContainer, 'parent-stale-child-model');
+      expect(parentOverlayAfterRestore).toBeTruthy();
+      expect(parentOverlayAfterRestore?.className).toContain('nb-toolbar-visible');
+    });
+  });
+
+  it('keeps parent toolbar hidden when moving over the parent block while child toolbar is active', async () => {
+    const engine = new FlowEngine();
+    await engine.flowSettings.forceEnable();
+    const parentModel = createModel(engine, 'parent-active-child-model');
+    const childModel = createModel(engine, 'child-active-model');
+    const appContainer = createAppContainer();
+    mockRect(appContainer, { top: 0, left: 0, width: 1280, height: 900 });
+
+    const { getByTestId } = renderWithProviders(
+      engine,
+      <FlowsFloatContextMenu model={parentModel}>
+        <div data-testid="parent-content">
+          <div data-testid="parent-gap">gap</div>
+          <FlowsFloatContextMenu model={childModel}>
+            <div data-testid="child-content">child</div>
+          </FlowsFloatContextMenu>
+        </div>
+      </FlowsFloatContextMenu>,
+      { container: appContainer },
+    );
+
+    const parentHost = getHost(getByTestId('parent-content'));
+    const childHost = getHost(getByTestId('child-content'));
+    const parentGap = getByTestId('parent-gap');
+    mockRect(parentHost, { top: 10, left: 10, width: 320, height: 160 });
+    mockRect(childHost, { top: 28, left: 36, width: 120, height: 48 });
+
+    fireEvent.mouseEnter(parentHost);
+
+    await waitFor(() => {
+      expect(queryOverlay(appContainer, 'parent-active-child-model')).toBeTruthy();
+    });
+
+    fireEvent.mouseEnter(childHost);
+    fireEvent.mouseMove(childHost);
+
+    const childOverlay = await waitFor(() => {
+      const nextOverlay = queryOverlay(appContainer, 'child-active-model');
+      expect(nextOverlay).toBeTruthy();
+      return nextOverlay as HTMLDivElement;
+    });
+
+    await waitFor(() => {
+      expect(childOverlay.className).toContain('nb-toolbar-visible');
+      expect(queryOverlay(appContainer, 'parent-active-child-model')).toBeNull();
+    });
+
+    fireEvent.mouseMove(parentGap);
+
+    await waitFor(() => {
+      expect(queryOverlay(appContainer, 'child-active-model')?.className).toContain('nb-toolbar-visible');
+      expect(queryOverlay(appContainer, 'parent-active-child-model')).toBeNull();
+    });
+  });
+
   it('treats forked models as distinct float menu instances even when they share the same uid', async () => {
     const engine = new FlowEngine();
     await engine.flowSettings.forceEnable();
@@ -775,4 +1039,109 @@ describe('FlowsFloatContextMenu', () => {
     expect(firstOverlay.getAttribute('data-model-uid')).toBe(firstInstanceId);
     expect(secondOverlay.getAttribute('data-model-uid')).toBe(secondInstanceId);
   });
+
+  it('keeps a forked child toolbar active while dragging one of its toolbar items', async () => {
+    const engine = new FlowEngine();
+    await engine.flowSettings.forceEnable();
+    const parentModel = createModel(engine, 'parent-forked-drag-model');
+    const childMasterModel = new FlowModel({ uid: 'forked-drag-child-model', flowEngine: engine });
+    childMasterModel.context.defineProperty('themeToken', { value: { borderRadiusLG: 8 } });
+    const childFork = childMasterModel.createFork({}, 'drag-card') as FlowModel & { forkId?: string };
+    const childInstanceId = `forked-drag-child-model::${String(childFork.forkId)}`;
+    const appContainer = createAppContainer();
+    mockRect(appContainer, { top: 0, left: 0, width: 1280, height: 900 });
+
+    const { getByTestId } = renderWithProviders(
+      engine,
+      <DndProvider>
+        <FlowsFloatContextMenu model={parentModel}>
+          <div data-testid="parent-content">
+            <div data-testid="parent-gap">gap</div>
+            <FlowsFloatContextMenu
+              model={childFork}
+              extraToolbarItems={[
+                {
+                  key: 'forked-toolbar-drag',
+                  component: ForkedToolbarDragItem,
+                  sort: 100,
+                },
+              ]}
+            >
+              <div data-testid="forked-child-content">child</div>
+            </FlowsFloatContextMenu>
+          </div>
+        </FlowsFloatContextMenu>
+      </DndProvider>,
+      { container: appContainer },
+    );
+
+    const parentHost = getHost(getByTestId('parent-content'));
+    const childHost = getHost(getByTestId('forked-child-content'));
+    const parentGap = getByTestId('parent-gap');
+    mockRect(parentHost, { top: 10, left: 10, width: 320, height: 160 });
+    mockRect(childHost, { top: 28, left: 36, width: 120, height: 48 });
+
+    fireEvent.mouseEnter(parentHost);
+
+    await waitFor(() => {
+      expect(queryOverlay(appContainer, 'parent-forked-drag-model')).toBeTruthy();
+    });
+
+    fireEvent.mouseEnter(childHost);
+    fireEvent.mouseMove(childHost);
+
+    const childOverlay = await waitFor(() => {
+      const nextOverlay = queryOverlay(appContainer, childInstanceId);
+      expect(nextOverlay).toBeTruthy();
+      return nextOverlay as HTMLDivElement;
+    });
+
+    await waitFor(() => {
+      expect(queryOverlay(appContainer, 'parent-forked-drag-model')).toBeNull();
+      expect(within(childOverlay).getByLabelText('forked-toolbar-drag')).toBeTruthy();
+    });
+
+    const childIcons = childOverlay.querySelector('.nb-toolbar-container-icons') as HTMLDivElement;
+    fireEvent.mouseLeave(parentHost, { relatedTarget: childIcons });
+    fireEvent.mouseLeave(childHost, { relatedTarget: childIcons });
+    fireEvent.mouseEnter(childIcons, { relatedTarget: childHost });
+
+    const dragButton = within(childOverlay).getByLabelText('forked-toolbar-drag');
+    const dragActivityListener = vi.fn();
+    dragButton.ownerDocument.addEventListener(TOOLBAR_DRAG_ACTIVITY_EVENT, dragActivityListener);
+    fireEvent.pointerDown(dragButton.parentElement as HTMLElement, { button: 0, clientX: 48, clientY: 36 });
+
+    expect(dragActivityListener).toHaveBeenCalledWith(
+      expect.objectContaining({
+        detail: expect.objectContaining({ active: true, modelUid: childInstanceId }),
+      }),
+    );
+    dragButton.ownerDocument.removeEventListener(TOOLBAR_DRAG_ACTIVITY_EVENT, dragActivityListener);
+
+    vi.useFakeTimers();
+    const querySelectorAllSpy = vi.spyOn(parentGap.ownerDocument, 'querySelectorAll');
+
+    try {
+      fireEvent.mouseLeave(childIcons, { relatedTarget: parentGap });
+      fireEvent.mouseEnter(parentHost, { relatedTarget: childIcons });
+      fireEvent.mouseEnter(parentGap, { relatedTarget: childIcons });
+      fireEvent.mouseMove(parentGap);
+
+      expect(querySelectorAllSpy).not.toHaveBeenCalled();
+
+      await act(async () => {
+        await vi.advanceTimersByTimeAsync(250);
+      });
+    } finally {
+      querySelectorAllSpy.mockRestore();
+      vi.useRealTimers();
+    }
+
+    await waitFor(() => {
+      const childOverlayAfterDrag = queryOverlay(appContainer, childInstanceId);
+      expect(childOverlayAfterDrag).toBeTruthy();
+      expect(childOverlayAfterDrag?.className).toContain('nb-toolbar-visible');
+      expect(queryOverlay(appContainer, 'parent-forked-drag-model')).toBeNull();
+    });
+  });
 });

package/src/components/settings/wrappers/contextual/useFloatToolbarVisibility.ts

@@ -47,6 +47,25 @@ const getToolbarModelUidFromTarget = (target: EventTarget | null): string | null
   return target.closest('.nb-toolbar-container[data-model-uid]')?.getAttribute('data-model-uid') || null;
 };
 
+const escapeCssAttributeValue = (value: string): string => {
+  return value
+    .replace(/\\/g, '\\\\')
+    .replace(/"/g, '\\"')
+    .replace(/\n/g, '\\a ')
+    .replace(/\r/g, '\\d ')
+    .replace(/\f/g, '\\c ');
+};
+
+const isToolbarModelUidRendered = (ownerDocument: Document | null, modelUid: string): boolean => {
+  if (!ownerDocument) {
+    return false;
+  }
+
+  return !!ownerDocument.querySelector<HTMLElement>(
+    `.nb-toolbar-container[data-model-uid="${escapeCssAttributeValue(modelUid)}"]`,
+  );
+};
+
 const isNodeWithinDescendantFloatToolbar = (
   target: EventTarget | null,
   container: HTMLElement | null,
@@ -264,6 +283,15 @@ export const useFloatToolbarVisibility = ({
 
       if (isCurrentHostTarget) {
         clearHideToolbarTimer();
+        setActiveChildToolbarIds((prevIds) => {
+          if (!prevIds.length) {
+            return prevIds;
+          }
+
+          const ownerDocument = containerRef.current?.ownerDocument ?? null;
+          const nextIds = prevIds.filter((id) => isToolbarModelUidRendered(ownerDocument, id));
+          return nextIds.length === prevIds.length ? prevIds : nextIds;
+        });
         setHostHovered(true);
       }
 

package/src/flowContext.ts

@@ -3139,6 +3139,37 @@ class BaseFlowModelContext extends BaseFlowEngineContext {
   declare makeResource: <T extends FlowResource = FlowResource>(resourceType: ResourceType<T>) => T;
 }
 
+const OPEN_VIEW_INHERITED_INPUT_ARG_KEYS = [
+  'dataSourceKey',
+  'collectionName',
+  'associationName',
+  'filterByTk',
+  'sourceId',
+  'tabUid',
+];
+
+function pickDefinedKeys(source: Record<string, unknown> | null | undefined, keys: string[]) {
+  const res: Record<string, unknown> = {};
+  for (const key of keys) {
+    if (typeof source?.[key] !== 'undefined') {
+      res[key] = source[key];
+    }
+  }
+  return res;
+}
+
+function pickDefinedOpenViewInputArgs(source?: Record<string, unknown> | null) {
+  return pickDefinedKeys(source, OPEN_VIEW_INHERITED_INPUT_ARG_KEYS);
+}
+
+function applyDefinedDefaults(target: Record<string, unknown>, defaults: Record<string, unknown>) {
+  for (const [key, value] of Object.entries(defaults)) {
+    if (typeof target[key] === 'undefined') {
+      target[key] = value;
+    }
+  }
+}
+
 export class FlowEngineContext extends BaseFlowEngineContext {
   // public dataSourceManager: DataSourceManager;
   constructor(public engine: FlowEngine) {
@@ -3398,7 +3429,19 @@ export class FlowEngineContext extends BaseFlowEngineContext {
       }),
     });
     this.defineProperty('role', {
-      get: () => this.api?.auth?.role,
+      get: () => {
+        const currentRole = this.api?.auth?.role;
+        if (currentRole !== '__union__') {
+          return currentRole;
+        }
+        const roles = this.user?.roles;
+        if (!Array.isArray(roles)) {
+          return [];
+        }
+        return roles
+          .map((role: { name?: string }) => role?.name)
+          .filter((name: string | undefined): name is string => !!name);
+      },
       cache: false,
       // 注意：使用惰性 meta 工厂，避免在 i18n 尚未注入时提前求值导致无法翻译
       meta: Object.assign(() => ({ type: 'string', title: this.t('Current role'), sort: 990 }), {
@@ -3561,7 +3604,17 @@ export class FlowEngineContext extends BaseFlowEngineContext {
         doc = {};
       }
       const deprecatedCtx = createRunJSDeprecationProxy(runCtx, { doc });
-      const globals: Record<string, any> = { ctx: deprecatedCtx, ...(options?.globals || {}) };
+      const browserGlobals: Record<string, any> = {};
+      if (typeof window !== 'undefined') {
+        browserGlobals.window = window;
+        if (typeof navigator !== 'undefined') {
+          browserGlobals.navigator = navigator;
+        }
+      }
+      if (typeof document !== 'undefined') {
+        browserGlobals.document = document;
+      }
+      const globals: Record<string, any> = { ctx: deprecatedCtx, ...browserGlobals, ...(options?.globals || {}) };
       const { timeoutMs } = options || {};
       return new JSRunner({ globals, timeoutMs });
     });
@@ -3687,7 +3740,14 @@ export class FlowModelContext extends BaseFlowModelContext {
       },
     });
     this.defineMethod('openView', async function (uid: string, options) {
-      const opts = { ...options };
+      const inheritedInputArgs = {
+        ...(typeof this.model?.['getInputArgs'] === 'function'
+          ? pickDefinedOpenViewInputArgs(this.model['getInputArgs']())
+          : {}),
+        ...pickDefinedOpenViewInputArgs(this.inputArgs),
+      };
+      const opts = { ...(options || {}) };
+      applyDefinedDefaults(opts, inheritedInputArgs);
       // NOTE: when custom context is passed, route navigation must be disabled to avoid losing it after refresh.
       if (opts.defineProperties || opts.defineMethods) {
         opts.navigation = false; // 强制不使用路由导航, 避免刷新页面时丢失上下文
@@ -3695,15 +3755,6 @@ export class FlowModelContext extends BaseFlowModelContext {
       let model: FlowModel | null = null;
       model = await this.engine.loadModel({ uid });
       if (!model) {
-        const pickDefined = (src: Record<string, any>, keys: string[]) => {
-          const res: Record<string, any> = {};
-          for (const k of keys) {
-            if (typeof src?.[k] !== 'undefined') {
-              res[k] = src[k];
-            }
-          }
-          return res;
-        };
         model = this.engine.createModel({
           uid, // 注意： 新建的 model 应该使用 ${parentModel.uid}-xxx 形式的 uid
           use: 'PopupActionModel',
@@ -3714,7 +3765,7 @@ export class FlowModelContext extends BaseFlowModelContext {
             popupSettings: {
               openView: {
                 // 仅在创建时持久化一份默认配置；运行时以本次 opts 为准，避免多个 opener 互相覆盖。
-                ...pickDefined(opts, ['dataSourceKey', 'collectionName', 'associationName', 'mode', 'size']),
+                ...pickDefinedKeys(opts, ['dataSourceKey', 'collectionName', 'associationName', 'mode', 'size']),
               },
             },
           },
@@ -3734,8 +3785,6 @@ export class FlowModelContext extends BaseFlowModelContext {
       // 统一语义：为即将打开的外部视图定义一个 PendingView（占位视图）
       const pendingType = (opts?.isMobileLayout ? 'embed' : opts?.mode || 'drawer') as any;
       const pendingInputArgs = { ...opts, viewUid, navigation: opts.navigation };
-      pendingInputArgs.filterByTk = pendingInputArgs.filterByTk || this.inputArgs?.filterByTk;
-      pendingInputArgs.sourceId = pendingInputArgs.sourceId || this.inputArgs?.sourceId;
 
       const pendingView = {
         type: pendingType,
@@ -3754,17 +3803,10 @@ export class FlowModelContext extends BaseFlowModelContext {
       } else if (on && typeof on === 'object' && typeof (on as any).eventName === 'string' && (on as any).eventName) {
         openEventName = (on as any).eventName;
       }
-      await model.dispatchEvent(
-        openEventName,
-        {
-          // navigation: false, // TODO: 路由模式有bug，不支持多层同样viewId的弹窗，因此这里默认先用false
-          // ...this.model?.['getInputArgs']?.(), // 避免部分关系字段信息丢失, 仿照 ClickableCollectionField 做法
-          ...opts,
-        },
-        {
-          debounce: true,
-        },
-      );
+      await model.dispatchEvent(openEventName, {
+        // navigation: false, // TODO: 路由模式有bug，不支持多层同样viewId的弹窗，因此这里默认先用false
+        ...opts,
+      });
     });
     this.defineMethod('getEvents', function (this: BaseFlowModelContext) {
       return this.model.getEvents();

package/src/runjs-context/helpers.ts

@@ -46,12 +46,17 @@ export function createJSRunnerWithVersion(this: FlowContext, options?: JSRunnerO
     doc = {};
   }
   const deprecatedCtx = createRunJSDeprecationProxy(runCtx, { doc });
-  const globals: Record<string, any> = { ctx: deprecatedCtx, ...(options?.globals || {}) };
-  // 对字段/区块类上下文，默认注入 window/document 以支持在沙箱中访问 DOM API
-  if (modelClass === 'JSFieldModel' || modelClass === 'JSBlockModel') {
-    if (typeof window !== 'undefined') globals.window = window as any;
-    if (typeof document !== 'undefined') globals.document = document as any;
+  const browserGlobals: Record<string, any> = {};
+  if (typeof window !== 'undefined') {
+    browserGlobals.window = window;
+    if (typeof navigator !== 'undefined') {
+      browserGlobals.navigator = navigator;
+    }
   }
+  if (typeof document !== 'undefined') {
+    browserGlobals.document = document;
+  }
+  const globals: Record<string, any> = { ctx: deprecatedCtx, ...browserGlobals, ...(options?.globals || {}) };
   // 透传 JSRunnerOptions 其余配置（如 timeoutMs）
   const { timeoutMs } = options || {};
   return new JSRunner({ globals, timeoutMs });
@@ -59,7 +64,8 @@ export function createJSRunnerWithVersion(this: FlowContext, options?: JSRunnerO
 
 export function getRunJSScenesForModel(modelClass: string, version: RunJSVersion = 'v1'): string[] {
   const meta = RunJSContextRegistry.getMeta(version, modelClass);
-  return Array.isArray(meta?.scenes) ? [...meta!.scenes!] : [];
+  const scenes = meta?.scenes;
+  return Array.isArray(scenes) ? [...scenes] : [];
 }
 
 export function getRunJSScenesForContext(ctx: FlowContext, { version = 'v1' as RunJSVersion } = {}): string[] {