@nocobase/client-v2 2.4.0-alpha.7 → 2.4.0-alpha.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nocobase/client-v2",
-  "version": "2.4.0-alpha.7",
+  "version": "2.4.0-alpha.9",
   "license": "Apache-2.0",
   "main": "lib/index.js",
   "module": "es/index.mjs",
@@ -27,11 +27,11 @@
     "@formily/antd-v5": "1.2.3",
     "@formily/react": "^2.2.27",
     "@formily/shared": "^2.2.27",
-    "@nocobase/evaluators": "2.4.0-alpha.7",
-    "@nocobase/flow-engine": "2.4.0-alpha.7",
-    "@nocobase/sdk": "2.4.0-alpha.7",
-    "@nocobase/shared": "2.4.0-alpha.7",
-    "@nocobase/utils": "2.4.0-alpha.7",
+    "@nocobase/evaluators": "2.4.0-alpha.9",
+    "@nocobase/flow-engine": "2.4.0-alpha.9",
+    "@nocobase/sdk": "2.4.0-alpha.9",
+    "@nocobase/shared": "2.4.0-alpha.9",
+    "@nocobase/utils": "2.4.0-alpha.9",
     "ahooks": "^3.7.2",
     "antd": "5.24.2",
     "antd-style": "3.7.1",
@@ -49,5 +49,5 @@
     "react-router-dom": "^6.30.1",
     "zxing-wasm": "^3.1.3"
   },
-  "gitHead": "bb018bfc8bdcc0f399244d2f248c55e51ceb2d1e"
+  "gitHead": "d383bdb224c62d1ba21c3dffd682165f3385a11b"
 }

package/src/BaseApplication.tsx

@@ -274,6 +274,8 @@ export abstract class BaseApplication<
     this.eventBus.addEventListener('auth:tokenChanged', (event: Event) => {
       const detail = (event as CustomEvent<AuthTokenPayload>).detail;
       if (!detail?.token) {
+        // 登录态已结束（退出登录或 token 失效），清空路由缓存，避免下一个用户沿用上一个用户的可访问路由。
+        this.context.routeRepository?.clear();
         return;
       }
       this.setTokenInWebSocket(detail);

package/src/RouteRepository.ts

@@ -153,6 +153,20 @@ export class RouteRepository {
     return loadingPromise;
   }
 
+  /**
+   * 清空所有布局的路由缓存，并丢弃清空前发起的请求结果。
+   *
+   * 用于登录态失效（如退出登录）时，避免下一个用户沿用上一个用户的可访问路由。
+   */
+  clear() {
+    this.routeCaches.clear();
+    this.accessibleLoadingPromises.clear();
+    this.refreshRequestIds.forEach((requestId, layoutUid) => {
+      this.refreshRequestIds.set(layoutUid, requestId + 1);
+    });
+    this.syncRoutesProperty();
+  }
+
   /**
    * 订阅路由缓存变化，用于驱动 React 上下文刷新。
    *

package/src/__tests__/RouteRepository.test.ts

@@ -193,6 +193,57 @@ describe('RouteRepository', () => {
     unsubscribeCustom();
   });
 
+  it('should drop cached routes of every layout when cleared', () => {
+    const { repository } = createRouteRepository();
+
+    repository.setRoutes([route('admin-page')], 'admin-layout-model');
+    repository.setRoutes([route('custom-page')], 'custom-desktop-layout-model');
+
+    repository.clear();
+
+    expect(repository.isAccessibleLoaded()).toBe(false);
+    expect(repository.listAccessible()).toEqual([]);
+    expect(repository.routes).toEqual([]);
+    const deactivateLayout = repository.activateLayout({
+      uid: 'custom-desktop-layout-model',
+    });
+    expect(repository.isAccessibleLoaded()).toBe(false);
+    expect(repository.listAccessible()).toEqual([]);
+    deactivateLayout();
+  });
+
+  it('should reload accessible routes after being cleared', async () => {
+    const { repository, request } = createRouteRepository();
+    request.mockResolvedValueOnce({ data: { data: [route('previous-user-page')] } });
+    await repository.ensureAccessibleLoaded();
+
+    repository.clear();
+    request.mockResolvedValueOnce({ data: { data: [route('next-user-page')] } });
+    const routes = await repository.ensureAccessibleLoaded();
+
+    expect(request).toHaveBeenCalledTimes(2);
+    expect(routes.map((item) => item.schemaUid)).toEqual(['next-user-page']);
+  });
+
+  it('should ignore refresh results requested before being cleared', async () => {
+    const { repository, request } = createRouteRepository();
+    let resolveStaleRequest: (value: unknown) => void = () => {};
+    request.mockImplementationOnce(
+      () =>
+        new Promise((resolve) => {
+          resolveStaleRequest = resolve;
+        }),
+    );
+
+    const staleRefresh = repository.refreshAccessible();
+    repository.clear();
+    resolveStaleRequest({ data: { data: [route('previous-user-page')] } });
+    await staleRefresh;
+
+    expect(repository.isAccessibleLoaded()).toBe(false);
+    expect(repository.listAccessible()).toEqual([]);
+  });
+
   it('should pass the default admin layout when creating a route', async () => {
     const { repository, create } = createRouteRepository();
 

package/src/__tests__/app.test.tsx

@@ -171,6 +171,19 @@ describe('app', () => {
       expect(document.documentElement.lang).toBe('ja-JP');
     });
 
+    it('should clear cached accessible routes when the auth token is cleared', () => {
+      const app = new Application({ router });
+      const routeRepository = app.flowEngine.context.routeRepository;
+      routeRepository.setRoutes([{ schemaUid: 'previous-user-page' }]);
+
+      app.apiClient.auth.setToken('renewed-token');
+      expect(routeRepository.listAccessible().map((route) => route.schemaUid)).toEqual(['previous-user-page']);
+
+      app.apiClient.auth.setToken(null);
+      expect(routeRepository.isAccessibleLoaded()).toBe(false);
+      expect(routeRepository.listAccessible()).toEqual([]);
+    });
+
     it('should escape app version html placeholder content', () => {
       expect(getAppVersionHTML('<script>alert(1)</script>&"')).toBe(
         '<span class="nb-app-version">v&lt;script&gt;alert(1)&lt;/script&gt;&amp;&quot;</span>',

package/src/flow/components/filter/VariableFilterItem.tsx

@@ -130,7 +130,9 @@ export interface VariableFilterItemProps {
   rightAsVariable?: boolean;
   /**
    * 右侧 VariableInput 的 metaTree 提供器；
-   * 默认使用整棵 ctx 的 metaTree：model.context.getPropertyMetaTree()
+   * 默认使用视图上下文的 metaTree：useFlowViewContext().getPropertyMetaTree()。
+   * 注意它取自视图上下文而非 `model.context`：当调用方传入的 model 与打开设置弹窗的模型不是同一个时，
+   * 右侧变量不会跟随 model 变化，需要显式传入本属性。
    */
   rightMetaTree?: MetaTreeNode[] | (() => MetaTreeNode[] | Promise<MetaTreeNode[]>);
   /**

package/src/flow/internal/utils/__tests__/quickEditDataScope.test.ts

@@ -0,0 +1,156 @@
+/**
+ * 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 { beforeEach, describe, expect, it } from 'vitest';
+// Prime the model module graph: the association field models sit in an import cycle that only resolves cleanly when the
+// models barrel is loaded first.
+import '../../../models';
+import { FlowEngine, FlowModel } from '@nocobase/flow-engine';
+import { CascadeSelectFieldModel } from '../../../models/fields/AssociationFieldModel/CascadeSelectFieldModel';
+import { RecordSelectFieldModel } from '../../../models/fields/AssociationFieldModel/RecordSelectFieldModel';
+import { SelectFieldModel } from '../../../models/fields/SelectFieldModel';
+import {
+  createQuickEditDataScopeContext,
+  findDataScopeStep,
+  getQuickEditDataScopeFilter,
+  isEmptyDataScopeFilter,
+} from '../quickEditDataScope';
+
+const resolveSubTree = async (subTree: unknown) => {
+  if (typeof subTree === 'function') {
+    return (await (subTree as () => Promise<Array<{ name: string }>>)()) || [];
+  }
+  return (subTree as Array<{ name: string }>) || [];
+};
+
+describe('quickEditDataScope', () => {
+  describe('findDataScopeStep', () => {
+    it('finds the data scope step of the dropdown association editor', () => {
+      expect(findDataScopeStep(RecordSelectFieldModel)).toEqual({ flowKey: 'selectSettings', stepKey: 'dataScope' });
+    });
+
+    it('finds the data scope step of the cascade association editor', () => {
+      expect(findDataScopeStep(CascadeSelectFieldModel)).toEqual({ flowKey: 'selectSettings', stepKey: 'dataScope' });
+    });
+
+    it('returns null for editors without a data scope step', () => {
+      expect(findDataScopeStep(SelectFieldModel)).toBeNull();
+    });
+
+    it('returns null for a missing model class', () => {
+      expect(findDataScopeStep(undefined)).toBeNull();
+    });
+  });
+
+  describe('isEmptyDataScopeFilter', () => {
+    it('treats a filter without conditions as empty', () => {
+      expect(isEmptyDataScopeFilter(undefined)).toBe(true);
+      expect(isEmptyDataScopeFilter({ logic: '$and', items: [] })).toBe(true);
+    });
+
+    it('treats a filter with conditions as non-empty', () => {
+      expect(isEmptyDataScopeFilter({ logic: '$and', items: [{ path: 'name', operator: 'eq', value: 'a' }] })).toBe(
+        false,
+      );
+    });
+  });
+
+  describe('getQuickEditDataScopeFilter', () => {
+    let engine: FlowEngine;
+    let column: FlowModel;
+    let displayField: FlowModel;
+
+    beforeEach(() => {
+      engine = new FlowEngine();
+      column = engine.createModel<FlowModel>({ use: 'FlowModel', uid: 'table-column' });
+      displayField = engine.createModel<FlowModel>({ use: 'FlowModel', uid: 'display-field', parentId: column.uid });
+    });
+
+    it('reads the filter configured on the owning table column', () => {
+      const filter = { logic: '$and', items: [{ path: 'status', operator: 'eq', value: 'active' }] };
+      column.setStepParams('tableColumnSettings', 'quickEditDataScope', { filter });
+
+      expect(getQuickEditDataScopeFilter(displayField)).toEqual(filter);
+    });
+
+    it('ignores an unconfigured filter so no step params are injected', () => {
+      column.setStepParams('tableColumnSettings', 'quickEditDataScope', { filter: { logic: '$and', items: [] } });
+
+      expect(getQuickEditDataScopeFilter(displayField)).toBeUndefined();
+    });
+
+    it('returns undefined when there is no source field model', () => {
+      expect(getQuickEditDataScopeFilter(undefined)).toBeUndefined();
+    });
+  });
+
+  describe('createQuickEditDataScopeContext', () => {
+    let engine: FlowEngine;
+    let column: FlowModel;
+
+    beforeEach(() => {
+      engine = new FlowEngine();
+      const ds = engine.context.dataSourceManager.getDataSource('main');
+      ds.addCollection({
+        name: 'departments',
+        filterTargetKey: 'id',
+        titleField: 'name',
+        fields: [
+          { name: 'id', type: 'integer', interface: 'number' },
+          { name: 'name', type: 'string', interface: 'input', uiSchema: { title: 'Name' } },
+        ],
+      });
+      ds.addCollection({
+        name: 'members',
+        filterTargetKey: 'id',
+        fields: [
+          { name: 'id', type: 'integer', interface: 'number' },
+          { name: 'level', type: 'string', interface: 'input', uiSchema: { title: 'Level' } },
+          {
+            name: 'department',
+            type: 'belongsTo',
+            interface: 'm2o',
+            target: 'departments',
+            targetKey: 'id',
+            uiSchema: { title: 'Department' },
+          },
+        ],
+      });
+      const membersCollection = engine.context.dataSourceManager.getCollection('main', 'members');
+      column = engine.createModel<FlowModel>({ use: 'FlowModel', uid: 'scoped-column' });
+      column.context.defineProperty('collection', { get: () => membersCollection });
+      column.context.defineProperty('collectionField', { get: () => membersCollection.getField('department') });
+    });
+
+    it('points the left-hand field list at the association target', async () => {
+      const scoped = await createQuickEditDataScopeContext(column);
+
+      expect(scoped.collection?.name).toBe('departments');
+    });
+
+    it('offers the edited row as a right-hand variable that the column context alone does not provide', async () => {
+      // Regression guard: the right-hand tree used to come from the settings view context, which delegates to the
+      // column and therefore carries no row record, so "Current record" was missing from the variable picker.
+      const columnTree = column.context.getPropertyMetaTree();
+      expect(columnTree.find((node) => node.name === 'record')).toBeUndefined();
+
+      const scoped = await createQuickEditDataScopeContext(column);
+      const scopedTree = scoped.getPropertyMetaTree();
+
+      expect(scopedTree.find((node) => node.name === 'record')).toBeDefined();
+    });
+
+    it('keeps the row record describing the table collection rather than the association target', async () => {
+      const scoped = await createQuickEditDataScopeContext(column);
+      const recordSubTree = await resolveSubTree(scoped.getPropertyMetaTree('{{ ctx.record }}'));
+
+      expect(recordSubTree.map((node) => node.name)).toContain('level');
+    });
+  });
+});

package/src/flow/internal/utils/__tests__/quickEditViewContainer.test.ts

@@ -0,0 +1,52 @@
+/**
+ * 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 { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { getQuickEditViewContainer, syncQuickEditPreventClose } from '../quickEditViewContainer';
+
+describe('quickEditViewContainer', () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  it('only resolves the view container of a QuickEditFormModel parent', () => {
+    const viewContainer = { update: vi.fn() };
+    expect(getQuickEditViewContainer({ parent: { use: 'QuickEditFormModel', viewContainer } })).toBe(viewContainer);
+    expect(getQuickEditViewContainer({ parent: { use: 'EditFormModel', viewContainer } })).toBeUndefined();
+    expect(getQuickEditViewContainer({ parent: null })).toBeUndefined();
+    expect(getQuickEditViewContainer(undefined)).toBeUndefined();
+  });
+
+  it('locks the popover while the dropdown is open and releases it after the closing click', () => {
+    const update = vi.fn();
+    const model = { parent: { use: 'QuickEditFormModel', viewContainer: { update } } };
+
+    syncQuickEditPreventClose(model, true);
+    expect(update).toHaveBeenCalledWith({ preventClose: true });
+
+    syncQuickEditPreventClose(model, false);
+    expect(update).toHaveBeenCalledTimes(1);
+
+    vi.runAllTimers();
+    expect(update).toHaveBeenCalledTimes(2);
+    expect(update).toHaveBeenLastCalledWith({ preventClose: false });
+  });
+
+  it('is a no-op outside of quick edit', () => {
+    const update = vi.fn();
+    syncQuickEditPreventClose({ parent: { use: 'EditFormModel', viewContainer: { update } } }, true);
+    syncQuickEditPreventClose({ parent: { use: 'QuickEditFormModel' } }, true);
+    vi.runAllTimers();
+    expect(update).not.toHaveBeenCalled();
+  });
+});

package/src/flow/internal/utils/quickEditDataScope.tsx

@@ -0,0 +1,177 @@
+/**
+ * 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 type { FlowEngineContext, ModelConstructor } from '@nocobase/flow-engine';
+import {
+  CollectionField,
+  FlowModel,
+  createCollectionContextMeta,
+  createCurrentRecordMetaFactory,
+  createEphemeralContext,
+  useFlowSettingsContext,
+} from '@nocobase/flow-engine';
+import { Skeleton } from 'antd';
+import React, { useCallback, useEffect, useState } from 'react';
+import { FilterGroup, VariableFilterItem } from '../../components/filter';
+import { FormItemModel } from '../../models/blocks/form/FormItemModel';
+
+const DATA_SCOPE_ACTION_NAME = 'dataScope';
+
+export const QUICK_EDIT_DATA_SCOPE_FLOW_KEY = 'tableColumnSettings';
+export const QUICK_EDIT_DATA_SCOPE_STEP_KEY = 'quickEditDataScope';
+
+export type DataScopeStepLocation = { flowKey: string; stepKey: string };
+
+/**
+ * Minimal shape read off a model class: the static flow registry and the `use` of each step. `ModelConstructor` does not
+ * declare the registry, so the lookup reaches for it through this shape instead of widening to `any`.
+ */
+type FlowRegistryHolder = {
+  globalFlowRegistry?: {
+    getFlows?: () => Map<string, { steps?: Record<string, { use?: string } | undefined> } | undefined>;
+  };
+};
+
+type DataScopeFilter = { logic?: string; items?: unknown[] } | undefined;
+
+/**
+ * Locate the flow and step that carry the shared `dataScope` action on a field model class. Both association editors
+ * currently keep it under `selectSettings`, but the lookup resolves it from the class instead of hard-coding that name,
+ * so an editor registered later is picked up without touching the quick edit path. Returns the first match.
+ */
+export function findDataScopeStep(
+  ModelClass: ModelConstructor | typeof FlowModel | undefined | null,
+): DataScopeStepLocation | null {
+  const flows = (ModelClass as unknown as FlowRegistryHolder | undefined)?.globalFlowRegistry?.getFlows?.();
+  if (!flows) {
+    return null;
+  }
+  for (const [flowKey, flow] of flows) {
+    for (const [stepKey, step] of Object.entries(flow?.steps || {})) {
+      if (step?.use === DATA_SCOPE_ACTION_NAME) {
+        return { flowKey, stepKey };
+      }
+    }
+  }
+  return null;
+}
+
+/**
+ * Resolve the data scope step of the editor model that the quick edit popover builds for `collectionField`. Returns null
+ * when the field is not an association or when its default editor has no data scope step, which is what the column
+ * setting uses to decide whether to offer the item at all.
+ */
+export function resolveQuickEditDataScopeStep(
+  ctx: FlowEngineContext,
+  collectionField: CollectionField,
+): DataScopeStepLocation | null {
+  if (!collectionField?.isAssociationField?.()) {
+    return null;
+  }
+  // Resolve through the same class the quick edit popover builds its editor with, so the setting is offered exactly
+  // when the editor that will actually open has a data scope step.
+  const binding = FormItemModel.getDefaultBindingByField(ctx, collectionField);
+  if (!binding?.modelName) {
+    return null;
+  }
+  return findDataScopeStep(ctx.engine?.getModelClass?.(binding.modelName));
+}
+
+export function isEmptyDataScopeFilter(filter: DataScopeFilter) {
+  return !filter || !Array.isArray(filter.items) || filter.items.length === 0;
+}
+
+/** Read the quick edit data scope filter stored on the table column that owns `sourceFieldModel`. */
+export function getQuickEditDataScopeFilter(sourceFieldModel?: FlowModel): DataScopeFilter {
+  const columnModel = sourceFieldModel?.parent as FlowModel | undefined;
+  const params = columnModel?.getStepParams?.(QUICK_EDIT_DATA_SCOPE_FLOW_KEY, QUICK_EDIT_DATA_SCOPE_STEP_KEY);
+  const filter = params?.filter as DataScopeFilter;
+  return isEmptyDataScopeFilter(filter) ? undefined : filter;
+}
+
+/**
+ * Context the filter builder is configured against. The setting lives on the table column, but the filter describes
+ * records of the association target, so `collection` points at the target collection to drive the left-hand field list.
+ * `record` is declared with meta only so that "Current record" is offered as a right-hand variable and describes the row
+ * being edited rather than whatever record an enclosing popup happens to supply; it has no value while configuring and
+ * resolves per row once the popover opens.
+ */
+export function createQuickEditDataScopeContext(columnModel: FlowModel) {
+  const collectionField = columnModel.context.collectionField as CollectionField;
+  const getTargetCollection = () => collectionField?.targetCollection ?? null;
+  const getSourceCollection = () => columnModel.context.collection ?? null;
+  return createEphemeralContext(columnModel.context, {
+    defineProperties: {
+      collection: {
+        get: getTargetCollection,
+        meta: createCollectionContextMeta(getTargetCollection, 'Current collection'),
+      },
+      record: {
+        get: () => undefined,
+        meta: createCurrentRecordMetaFactory(columnModel.context, getSourceCollection),
+      },
+    },
+  });
+}
+
+/** Wrap the column model so the filter builder reads the scoped context instead of the column's own. */
+function useQuickEditDataScopeModel(columnModel: FlowModel): FlowModel | null {
+  const [scopedModel, setScopedModel] = useState<FlowModel | null>(null);
+
+  useEffect(() => {
+    let cancelled = false;
+
+    const build = async () => {
+      const scopedContext = await createQuickEditDataScopeContext(columnModel);
+      if (cancelled) {
+        return;
+      }
+      setScopedModel(
+        new Proxy(columnModel, {
+          get(target, key, receiver) {
+            if (key === 'context') {
+              return scopedContext;
+            }
+            const value = Reflect.get(target, key, receiver);
+            return typeof value === 'function' ? value.bind(target) : value;
+          },
+        }),
+      );
+    };
+
+    build();
+
+    return () => {
+      cancelled = true;
+    };
+  }, [columnModel]);
+
+  return scopedModel;
+}
+
+export function QuickEditDataScopeInput(props: { value?: Record<string, any> }) {
+  const flowContext = useFlowSettingsContext<FlowModel>();
+  const scopedModel = useQuickEditDataScopeModel(flowContext.model);
+  // The right-hand variable tree defaults to the settings view context, which delegates to the table column and
+  // therefore carries no row record. Feed it the scoped context so "Current record" is offered and describes the row.
+  const rightMetaTree = useCallback(() => scopedModel?.context.getPropertyMetaTree() ?? [], [scopedModel]);
+
+  if (!scopedModel) {
+    return <Skeleton.Input active size="small" />;
+  }
+
+  return (
+    <FilterGroup
+      value={props.value}
+      FilterItem={(p) => (
+        <VariableFilterItem {...p} model={scopedModel} rightAsVariable rightMetaTree={rightMetaTree} />
+      )}
+    />
+  );
+}

package/src/flow/internal/utils/quickEditViewContainer.ts

@@ -0,0 +1,46 @@
+/**
+ * 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.
+ */
+
+type QuickEditViewContainerLike = {
+  update?: (newConfig: { preventClose?: boolean }) => unknown;
+};
+
+type QuickEditFieldModelLike = {
+  parent?: {
+    use?: string;
+    viewContainer?: QuickEditViewContainerLike;
+  } | null;
+};
+
+export function getQuickEditViewContainer(model: QuickEditFieldModelLike | undefined) {
+  const parent = model?.parent;
+  if (parent?.use !== 'QuickEditFormModel') {
+    return undefined;
+  }
+  return parent.viewContainer;
+}
+
+/**
+ * Keeps the quick edit popover open while a nested dropdown (Select / Cascader) is open. The outside click that
+ * closes the dropdown would otherwise also close the popover and drop the unsaved edit. Releasing is deferred so the
+ * closing click itself never reaches the popover as a close request.
+ */
+export function syncQuickEditPreventClose(model: QuickEditFieldModelLike | undefined, dropdownOpen: boolean) {
+  const container = getQuickEditViewContainer(model);
+  if (!container?.update) {
+    return;
+  }
+  if (dropdownOpen) {
+    container.update({ preventClose: true });
+    return;
+  }
+  setTimeout(() => {
+    container.update?.({ preventClose: false });
+  }, 0);
+}