@nocobase/client-v2 2.1.0-beta.24 → 2.1.0-beta.26

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nocobase/client-v2",
-  "version": "2.1.0-beta.24",
+  "version": "2.1.0-beta.26",
   "license": "Apache-2.0",
   "main": "lib/index.js",
   "module": "es/index.mjs",
@@ -24,9 +24,10 @@
     "@formily/antd-v5": "1.2.3",
     "@formily/react": "^2.2.27",
     "@formily/shared": "^2.2.27",
-    "@nocobase/flow-engine": "2.1.0-beta.24",
-    "@nocobase/sdk": "2.1.0-beta.24",
-    "@nocobase/shared": "2.1.0-beta.24",
+    "@nocobase/flow-engine": "2.1.0-beta.26",
+    "@nocobase/sdk": "2.1.0-beta.26",
+    "@nocobase/shared": "2.1.0-beta.26",
+    "ahooks": "^3.7.2",
     "antd": "5.24.2",
     "classnames": "^2.3.1",
     "dayjs": "^1.11.10",
@@ -35,5 +36,5 @@
     "react-i18next": "^11.15.1",
     "react-router-dom": "^6.30.1"
   },
-  "gitHead": "f77b85530a2d127d9bfe4dca3a26fbb02c1139ba"
+  "gitHead": "b17e1a72057813fa27d8435bf0f2af67ea4b059f"
 }

package/src/BaseApplication.tsx

@@ -189,6 +189,7 @@ export abstract class BaseApplication<
     this.configureContext();
     this.addBaseProviders();
     this.addCustomProviders();
+    this.addFinalProviders();
     this.addReactRouterComponents();
     this.addProviders(options.providers || []);
     this.ws = this.createWebSocketClient(options);
@@ -338,6 +339,9 @@ export abstract class BaseApplication<
     this.use(FlowEngineProvider, { engine: this.flowEngine });
     this.use(GlobalThemeProvider);
     this.use(AntdAppProvider);
+  }
+
+  protected addFinalProviders() {
     this.use(FlowEngineGlobalsContextProvider);
   }
 

package/src/__tests__/globalDeps.test.ts

@@ -9,6 +9,8 @@
 
 import { defineGlobalDeps } from '../utils/globalDeps';
 
+vi.mock('../index', () => ({}));
+
 describe('client-v2 defineGlobalDeps', () => {
   it('should register shared AMD dependencies for remote plugins', () => {
     const define = vi.fn();
@@ -23,5 +25,9 @@ describe('client-v2 defineGlobalDeps', () => {
     expect(define).toHaveBeenCalledWith('@nocobase/utils/client', expect.any(Function));
     expect(define).toHaveBeenCalledWith('@nocobase/client-v2', expect.any(Function));
     expect(define).toHaveBeenCalledWith('@nocobase/flow-engine', expect.any(Function));
+    expect(define).toHaveBeenCalledWith('ahooks', expect.any(Function));
+    expect(define).toHaveBeenCalledWith('dayjs', expect.any(Function));
+    expect(define).toHaveBeenCalledWith('lodash', expect.any(Function));
+    expect(define).toHaveBeenCalledWith('@emotion/css', expect.any(Function));
   });
 });

package/src/__tests__/remotePlugins.test.ts

@@ -8,6 +8,7 @@
  */
 
 import { Plugin } from '../Plugin';
+import { getRequireJs } from '../utils/requirejs';
 import { defineDevPlugins, definePluginClient, getPlugins } from '../utils/remotePlugins';
 
 describe('client-v2 remotePlugins', () => {
@@ -69,4 +70,30 @@ describe('client-v2 remotePlugins', () => {
     expect(mockDefine).toHaveBeenCalledWith('@nocobase/demo/client-v2', expect.any(Function));
     expect(mockDefine).not.toHaveBeenCalledWith('@nocobase/demo/client', expect.any(Function));
   });
+
+  it('should not append duplicate .js for plugin URLs without query strings', () => {
+    const requirejs = getRequireJs();
+
+    requirejs.requirejs.config({
+      paths: {
+        '@nocobase/demo': '/static/plugins/@nocobase/demo/dist/client-v2/index.js',
+      },
+    });
+
+    expect(requirejs.requirejs.toUrl('@nocobase/demo')).toBe('/static/plugins/@nocobase/demo/dist/client-v2/index.js');
+  });
+
+  it('should keep hashed plugin URLs unchanged', () => {
+    const requirejs = getRequireJs();
+
+    requirejs.requirejs.config({
+      paths: {
+        '@nocobase/demo': '/static/plugins/@nocobase/demo/dist/client-v2/index.js?hash=12345678',
+      },
+    });
+
+    expect(requirejs.requirejs.toUrl('@nocobase/demo')).toBe(
+      '/static/plugins/@nocobase/demo/dist/client-v2/index.js?hash=12345678',
+    );
+  });
 });

package/src/flow/actions/__tests__/dataScopeFilter.test.ts

@@ -0,0 +1,158 @@
+/**
+ * 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 { dataScope } from '../dataScope';
+import { normalizeDataScopeFilter } from '../dataScopeFilter';
+import { setTargetDataScope } from '../setTargetDataScope';
+
+describe('normalizeDataScopeFilter', () => {
+  it('keeps null when a right-side variable resolves to empty', () => {
+    const rawFilter = {
+      logic: '$and',
+      items: [{ path: 'departmentId', operator: '$eq', value: '{{ ctx.formValues.department.id }}' }],
+    };
+    const resolvedFilter = {
+      logic: '$and',
+      items: [{ path: 'departmentId', operator: '$eq', value: undefined }],
+    };
+
+    expect(normalizeDataScopeFilter(rawFilter, resolvedFilter)).toEqual({
+      $and: [{ departmentId: { $eq: null } }],
+    });
+  });
+
+  it('keeps null when a right-side variable resolves to an empty string', () => {
+    const rawFilter = {
+      logic: '$and',
+      items: [{ path: 'departmentId', operator: '$eq', value: '{{ ctx.formValues.department.id }}' }],
+    };
+    const resolvedFilter = {
+      logic: '$and',
+      items: [{ path: 'departmentId', operator: '$eq', value: '' }],
+    };
+
+    expect(normalizeDataScopeFilter(rawFilter, resolvedFilter)).toEqual({
+      $and: [{ departmentId: { $eq: null } }],
+    });
+  });
+
+  it('still prunes empty constant values', () => {
+    const filter = {
+      logic: '$and',
+      items: [{ path: 'departmentId', operator: '$eq', value: undefined }],
+    };
+
+    expect(normalizeDataScopeFilter(filter, filter)).toBeUndefined();
+  });
+
+  it('handles nested groups and keeps non-empty values unchanged', () => {
+    const rawFilter = {
+      logic: '$and',
+      items: [
+        { path: 'status', operator: '$eq', value: 'active' },
+        {
+          logic: '$or',
+          items: [{ path: 'departmentId', operator: '$eq', value: '{{ ctx.formValues.department.id }}' }],
+        },
+      ],
+    };
+    const resolvedFilter = {
+      logic: '$and',
+      items: [
+        { path: 'status', operator: '$eq', value: 'active' },
+        {
+          logic: '$or',
+          items: [{ path: 'departmentId', operator: '$eq', value: null }],
+        },
+      ],
+    };
+
+    expect(normalizeDataScopeFilter(rawFilter, resolvedFilter)).toEqual({
+      $and: [{ status: { $eq: 'active' } }, { $or: [{ departmentId: { $eq: null } }] }],
+    });
+  });
+
+  it('does not preserve explicit null constants', () => {
+    const filter = {
+      logic: '$and',
+      items: [{ path: 'departmentId', operator: '$eq', value: null }],
+    };
+
+    expect(normalizeDataScopeFilter(filter, filter)).toBeUndefined();
+  });
+
+  it('dataScope handler sends null for empty variable dependencies', async () => {
+    const resource = {
+      addFilterGroup: vi.fn(),
+      removeFilterGroup: vi.fn(),
+    };
+    const ctx = {
+      model: {
+        uid: 'field-1',
+        resource,
+      },
+      resolveJsonTemplate: vi.fn(async (template) => ({
+        ...template,
+        items: [{ ...template.items[0], value: undefined }],
+      })),
+    };
+    const params = {
+      filter: {
+        logic: '$and',
+        items: [{ path: 'departmentId', operator: '$eq', value: '{{ ctx.formValues.department.id }}' }],
+      },
+    };
+
+    await (dataScope as any).handler(ctx, params);
+
+    expect(resource.addFilterGroup).toHaveBeenCalledWith('field-1', {
+      $and: [{ departmentId: { $eq: null } }],
+    });
+    expect(resource.removeFilterGroup).not.toHaveBeenCalled();
+  });
+
+  it('setTargetDataScope handler sends null for empty variable dependencies', async () => {
+    const resource = {
+      addFilterGroup: vi.fn(),
+      removeFilterGroup: vi.fn(),
+      hasData: vi.fn(() => false),
+      refresh: vi.fn(),
+    };
+    const targetModel = { resource };
+    const ctx = {
+      model: {
+        uid: 'action-1',
+        scheduleModelOperation: vi.fn((_uid, callback) => callback(targetModel)),
+      },
+      resolveJsonTemplate: vi.fn(async (template) => ({
+        ...template,
+        filter: {
+          ...template.filter,
+          items: [{ ...template.filter.items[0], value: undefined }],
+        },
+      })),
+    };
+    const params = {
+      targetBlockUid: 'target-1',
+      filter: {
+        logic: '$and',
+        items: [{ path: 'departmentId', operator: '$eq', value: '{{ ctx.formValues.department.id }}' }],
+      },
+    };
+
+    await (setTargetDataScope as any).handler(ctx, params);
+
+    expect(ctx.model.scheduleModelOperation).toHaveBeenCalledWith('target-1', expect.any(Function));
+    expect(resource.addFilterGroup).toHaveBeenCalledWith('setTargetDataScope_action-1', {
+      $and: [{ departmentId: { $eq: null } }],
+    });
+    expect(resource.removeFilterGroup).not.toHaveBeenCalled();
+  });
+});

package/src/flow/actions/__tests__/linkageRules.formValueDrivenRefresh.test.ts

@@ -0,0 +1,438 @@
+/**
+ * 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 { FlowContext, FlowRuntimeContext } from '@nocobase/flow-engine';
+import { waitFor } from '@testing-library/react';
+import { EventEmitter } from 'events';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { actionLinkageRules, blockLinkageRules } from '../linkageRules';
+
+function createRule(overrides: any = {}) {
+  return {
+    key: 'r1',
+    title: 'r1',
+    enable: true,
+    condition: { logic: '$and', items: [] },
+    actions: [],
+    ...overrides,
+  };
+}
+
+function createRuntime(
+  params: any,
+  options: { fieldIndex?: string[]; fieldIndexRef?: { current: string[] }; actionHandler?: any; engineEmitter?: any } = {},
+) {
+  const formEmitter = new EventEmitter();
+  const formBlock: any = {
+    uid: 'form-block',
+    emitter: formEmitter,
+    formValueRuntime: {},
+  };
+  const actionHandler = options.actionHandler || vi.fn(async () => {});
+  const linkageRunjsHandler = vi.fn(async () => {});
+  const modelContext: any = new FlowContext();
+  modelContext.defineProperty('blockModel', { value: formBlock });
+  modelContext.defineProperty('app', {
+    value: {
+      jsonLogic: {
+        apply: () => true,
+      },
+    },
+  });
+  modelContext.defineProperty('fieldIndex', {
+    get: () => options.fieldIndexRef?.current || options.fieldIndex || [],
+    cache: false,
+  });
+  modelContext.defineMethod('resolveJsonTemplate', async (_template: any) => _template);
+  modelContext.defineMethod('getAction', (name: string) => {
+    if (name === 'actionLinkageRules') {
+      return { useRawParams: true, handler: actionHandler };
+    }
+    if (name === 'blockLinkageRules') {
+      return { useRawParams: true, handler: actionHandler };
+    }
+    if (name === 'linkageRunjs') {
+      return { handler: linkageRunjsHandler };
+    }
+    return undefined;
+  });
+  modelContext.defineMethod('getActions', () => new Map());
+  modelContext.defineMethod('t', (s: string) => s);
+
+  const model: any = {
+    uid: 'action-model',
+    context: modelContext,
+    flowEngine: options.engineEmitter ? { emitter: options.engineEmitter } : undefined,
+    isFork: false,
+    forks: new Set(),
+    getFlow: vi.fn(() => ({})),
+    getStepParams: vi.fn(() => params),
+    getAction: (name: string) => modelContext.getAction(name),
+    getActions: () => new Map(),
+    translate: (s: string) => s,
+  };
+  const ctx: any = new FlowRuntimeContext(model, 'buttonSettings');
+  ctx.defineMethod('resolveJsonTemplate', async (_template: any) => _template);
+
+  return {
+    ctx,
+    model,
+    formEmitter,
+    actionHandler,
+    linkageRunjsHandler,
+  };
+}
+
+describe('linkageRules: form value driven refresh', () => {
+  beforeEach(() => {
+    vi.useRealTimers();
+  });
+
+  it('refreshes action linkage rules when a ctx.formValues dependency changes', async () => {
+    const params = {
+      value: [
+        createRule({
+          condition: {
+            logic: '$and',
+            items: [{ path: '{{ ctx.formValues.status }}', operator: '$eq', value: 'active' }],
+          },
+        }),
+      ],
+    };
+    const { ctx, formEmitter, actionHandler } = createRuntime(params);
+
+    await actionLinkageRules.handler(ctx, params);
+    formEmitter.emit('formValuesChange', {
+      source: 'user',
+      txId: 'tx-1',
+      changedPaths: [['other']],
+    });
+    await new Promise((resolve) => setTimeout(resolve, 0));
+    expect(actionHandler).not.toHaveBeenCalled();
+
+    formEmitter.emit('formValuesChange', {
+      source: 'user',
+      txId: 'tx-2',
+      changedPaths: [['status']],
+    });
+
+    await waitFor(() => expect(actionHandler).toHaveBeenCalledTimes(1));
+    expect(actionHandler.mock.calls[0][0].inputArgs).toMatchObject({
+      source: 'user',
+      txId: 'tx-2',
+      linkageTxId: 'tx-2',
+      changedPaths: [['status']],
+    });
+  });
+
+  it('refreshes block linkage rules when a ctx.formValues dependency changes', async () => {
+    const params = {
+      value: [
+        createRule({
+          condition: {
+            logic: '$and',
+            items: [{ path: '{{ ctx.formValues.status }}', operator: '$eq', value: 'active' }],
+          },
+        }),
+      ],
+    };
+    const { ctx, formEmitter, actionHandler } = createRuntime(params);
+
+    await blockLinkageRules.handler(ctx, params);
+    formEmitter.emit('formValuesChange', {
+      source: 'user',
+      txId: 'tx-1',
+      changedPaths: [['status']],
+    });
+
+    await waitFor(() => expect(actionHandler).toHaveBeenCalledTimes(1));
+  });
+
+  it('dedupes subscriptions for repeated handler runs', async () => {
+    const params = {
+      value: [
+        createRule({
+          condition: {
+            logic: '$and',
+            items: [{ path: '{{ ctx.formValues.status }}', operator: '$eq', value: 'active' }],
+          },
+        }),
+      ],
+    };
+    const { ctx, formEmitter, actionHandler } = createRuntime(params);
+
+    await actionLinkageRules.handler(ctx, params);
+    await actionLinkageRules.handler(ctx, params);
+
+    expect(formEmitter.listenerCount('formValuesChange')).toBe(1);
+
+    formEmitter.emit('formValuesChange', {
+      source: 'user',
+      txId: 'tx-1',
+      changedPaths: [['status']],
+    });
+
+    await waitFor(() => expect(actionHandler).toHaveBeenCalledTimes(1));
+  });
+
+  it('keeps action refresh subscription after the action is hidden and unmounted', async () => {
+    const engineEmitter = new EventEmitter();
+    const params = {
+      value: [
+        createRule({
+          condition: {
+            logic: '$and',
+            items: [{ path: '{{ ctx.formValues.status }}', operator: '$eq', value: 'active' }],
+          },
+        }),
+      ],
+    };
+    const { ctx, model, formEmitter, actionHandler } = createRuntime(params, { engineEmitter });
+
+    await actionLinkageRules.handler(ctx, params);
+    expect(formEmitter.listenerCount('formValuesChange')).toBe(1);
+
+    engineEmitter.emit('model:unmounted', { model });
+    expect(formEmitter.listenerCount('formValuesChange')).toBe(1);
+
+    formEmitter.emit('formValuesChange', {
+      source: 'user',
+      txId: 'tx-1',
+      changedPaths: [['status']],
+    });
+
+    await waitFor(() => expect(actionHandler).toHaveBeenCalledTimes(1));
+  });
+
+  it('maps ctx.item.value dependencies to the current row path', async () => {
+    const params = {
+      value: [
+        createRule({
+          condition: {
+            logic: '$and',
+            items: [{ path: '{{ ctx.item.value.nickname }}', operator: '$eq', value: 'A' }],
+          },
+        }),
+      ],
+    };
+    const { ctx, formEmitter, actionHandler } = createRuntime(params, { fieldIndex: ['users:1'] });
+
+    await actionLinkageRules.handler(ctx, params);
+    formEmitter.emit('formValuesChange', {
+      source: 'user',
+      txId: 'tx-1',
+      changedPaths: [['users', 0, 'nickname']],
+    });
+    await new Promise((resolve) => setTimeout(resolve, 0));
+    expect(actionHandler).not.toHaveBeenCalled();
+
+    formEmitter.emit('formValuesChange', {
+      source: 'user',
+      txId: 'tx-2',
+      changedPaths: [['users', 1, 'nickname']],
+    });
+
+    await waitFor(() => expect(actionHandler).toHaveBeenCalledTimes(1));
+  });
+
+  it('parses object-patch changedPaths before matching ctx.item.value dependencies', async () => {
+    const params = {
+      value: [
+        createRule({
+          condition: {
+            logic: '$and',
+            items: [{ path: '{{ ctx.item.value.nickname }}', operator: '$eq', value: 'A' }],
+          },
+        }),
+      ],
+    };
+    const { ctx, formEmitter, actionHandler } = createRuntime(params, { fieldIndex: ['users:1'] });
+
+    await actionLinkageRules.handler(ctx, params);
+    formEmitter.emit('formValuesChange', {
+      source: 'user',
+      txId: 'tx-1',
+      changedPaths: [['users[1].nickname']],
+    });
+
+    await waitFor(() => expect(actionHandler).toHaveBeenCalledTimes(1));
+  });
+
+  it('recomputes ctx.item.value dependencies from the latest fieldIndex', async () => {
+    const fieldIndexRef = { current: ['users:1'] };
+    const params = {
+      value: [
+        createRule({
+          condition: {
+            logic: '$and',
+            items: [{ path: '{{ ctx.item.value.nickname }}', operator: '$eq', value: 'A' }],
+          },
+        }),
+      ],
+    };
+    const { ctx, formEmitter, actionHandler } = createRuntime(params, { fieldIndexRef });
+
+    await actionLinkageRules.handler(ctx, params);
+    fieldIndexRef.current = ['users:0'];
+    formEmitter.emit('formValuesChange', {
+      source: 'user',
+      txId: 'tx-1',
+      changedPaths: [['users', 0, 'nickname']],
+    });
+
+    await waitFor(() => expect(actionHandler).toHaveBeenCalledTimes(1));
+  });
+
+  it('maps ctx.item.index dependencies to the current list path', async () => {
+    const params = {
+      value: [
+        createRule({
+          condition: {
+            logic: '$and',
+            items: [{ path: '{{ ctx.item.index }}', operator: '$eq', value: 1 }],
+          },
+        }),
+      ],
+    };
+    const { ctx, formEmitter, actionHandler } = createRuntime(params, { fieldIndex: ['users:1'] });
+
+    await actionLinkageRules.handler(ctx, params);
+    formEmitter.emit('formValuesChange', {
+      source: 'user',
+      txId: 'tx-1',
+      changedPaths: [['users', 1, 'nickname']],
+    });
+    await new Promise((resolve) => setTimeout(resolve, 0));
+    expect(actionHandler).not.toHaveBeenCalled();
+
+    formEmitter.emit('formValuesChange', {
+      source: 'user',
+      txId: 'tx-2',
+      changedPaths: [['users']],
+    });
+
+    await waitFor(() => expect(actionHandler).toHaveBeenCalledTimes(1));
+  });
+
+  it('collects ctx.formValues dependencies from linkageRunjs scripts without resolving the script early', async () => {
+    const params = {
+      value: [
+        createRule({
+          actions: [
+            {
+              key: 'a1',
+              name: 'linkageRunjs',
+              params: {
+                value: {
+                  script: 'return ctx.formValues.amount',
+                },
+              },
+            },
+          ],
+        }),
+      ],
+    };
+    const { ctx, formEmitter, actionHandler, linkageRunjsHandler } = createRuntime(params);
+
+    await actionLinkageRules.handler(ctx, params);
+    expect(linkageRunjsHandler).toHaveBeenCalledTimes(1);
+
+    formEmitter.emit('formValuesChange', {
+      source: 'user',
+      txId: 'tx-1',
+      changedPaths: [['amount']],
+    });
+
+    await waitFor(() => expect(actionHandler).toHaveBeenCalledTimes(1));
+  });
+
+  it('reruns once with the latest relevant change after a refresh is already running', async () => {
+    let resolveFirstRefresh: () => void = () => undefined;
+    const firstRefresh = new Promise<void>((resolve) => {
+      resolveFirstRefresh = resolve;
+    });
+    const actionHandler = vi
+      .fn()
+      .mockImplementationOnce(() => firstRefresh)
+      .mockImplementation(async () => undefined);
+    const params = {
+      value: [
+        createRule({
+          condition: {
+            logic: '$and',
+            items: [{ path: '{{ ctx.formValues.status }}', operator: '$eq', value: 'active' }],
+          },
+        }),
+      ],
+    };
+    const { ctx, formEmitter } = createRuntime(params, { actionHandler });
+
+    await actionLinkageRules.handler(ctx, params);
+    formEmitter.emit('formValuesChange', {
+      source: 'user',
+      txId: 'tx-1',
+      changedPaths: [['status']],
+    });
+    await waitFor(() => expect(actionHandler).toHaveBeenCalledTimes(1));
+
+    formEmitter.emit('formValuesChange', {
+      source: 'user',
+      txId: 'tx-2',
+      changedPaths: [['status']],
+    });
+    await new Promise((resolve) => setTimeout(resolve, 0));
+    expect(actionHandler).toHaveBeenCalledTimes(1);
+
+    resolveFirstRefresh();
+    await waitFor(() => expect(actionHandler).toHaveBeenCalledTimes(2));
+  });
+
+  it('does not recursively refresh while handling its own linkage write event', async () => {
+    const params = {
+      value: [
+        createRule({
+          condition: {
+            logic: '$and',
+            items: [{ path: '{{ ctx.formValues.status }}', operator: '$eq', value: 'active' }],
+          },
+        }),
+      ],
+    };
+    const formEmitter = new EventEmitter();
+    const actionHandler = vi.fn(async () => {
+      formEmitter.emit('formValuesChange', {
+        source: 'linkage',
+        txId: 'tx-linkage',
+        linkageTxId: 'tx-1',
+        changedPaths: [['status']],
+      });
+    });
+    const runtime = createRuntime(params, { actionHandler });
+    runtime.formEmitter.removeAllListeners();
+    formEmitter.on('formValuesChange', (...args) => runtime.formEmitter.emit('formValuesChange', ...args));
+
+    await actionLinkageRules.handler(runtime.ctx, params);
+    formEmitter.emit('formValuesChange', {
+      source: 'user',
+      txId: 'tx-1',
+      changedPaths: [['status']],
+    });
+
+    await waitFor(() => expect(actionHandler).toHaveBeenCalledTimes(1));
+
+    runtime.formEmitter.emit('formValuesChange', {
+      source: 'linkage',
+      txId: 'tx-linkage-late',
+      linkageTxId: 'tx-1',
+      changedPaths: [['status']],
+    });
+    await new Promise((resolve) => setTimeout(resolve, 0));
+    expect(actionHandler).toHaveBeenCalledTimes(1);
+  });
+});