@nocobase/flow-engine 2.2.0-alpha.7 → 2.2.0-beta.10

package/src/components/variables/__tests__/VariableInput.test.tsx

@@ -8,7 +8,6 @@
  */
 
 import { act, fireEvent, render, screen, waitFor } from '@testing-library/react';
-import { Input } from 'antd';
 import React from 'react';
 import { describe, expect, it, vi } from 'vitest';
 import type { ContextSelectorItem } from '../types';
@@ -113,62 +112,6 @@ describe('VariableInput', () => {
     expect(selectorButton).toBeInTheDocument();
   });
 
-  it('disables the FlowContextSelector button when disabled', async () => {
-    const flowContext = createTestFlowContext();
-    render(
-      <TestFlowContextWrapper context={flowContext}>
-        <VariableInput value="test" metaTree={() => flowContext.getPropertyMetaTree()} disabled />
-      </TestFlowContextWrapper>,
-    );
-
-    const selectorButton = await screen.findByRole('button');
-    expect(selectorButton).toBeDisabled();
-  });
-
-  it('should not highlight the selector button for synthetic constant/null paths', async () => {
-    const flowContext = createTestFlowContext();
-
-    render(
-      <TestFlowContextWrapper context={flowContext}>
-        <VariableInput
-          value=""
-          metaTree={[
-            { name: 'constant', title: 'Constant', type: 'string', paths: ['constant'] },
-            { name: 'null', title: 'Null', type: 'object', paths: ['null'] },
-            ...flowContext.getPropertyMetaTree(),
-          ]}
-          converters={{
-            renderInputComponent: (meta) => {
-              const first = meta?.paths?.[0];
-              if (first === 'constant') {
-                return (props: any) => <input aria-label="constant-value" {...props} />;
-              }
-              if (first === 'null') {
-                return () => <Input placeholder="<Null>" readOnly />;
-              }
-              return null;
-            },
-            resolveValueFromPath: (meta) => {
-              const first = meta?.paths?.[0];
-              if (first === 'constant') return '';
-              if (first === 'null') return null;
-              return undefined;
-            },
-            resolvePathFromValue: (currentValue) => {
-              if (currentValue === null) return ['null'];
-              const trimmed = typeof currentValue === 'string' ? currentValue.trim() : currentValue;
-              if (trimmed === '') return ['constant'];
-              return undefined;
-            },
-          }}
-        />
-      </TestFlowContextWrapper>,
-    );
-
-    const selectorButton = await screen.findByRole('button');
-    expect(selectorButton.className).not.toContain('ant-btn-primary');
-  });
-
   it('should handle onChange from Input', async () => {
     const onChange = vi.fn();
     const flowContext = createTestFlowContext();
@@ -252,21 +195,20 @@ describe('VariableInput', () => {
 
     const selectElement = container.querySelector('.ant-select');
     expect(selectElement).toBeInTheDocument();
-    if (!selectElement) {
-      throw new Error('Expected variable tag select wrapper to be present');
-    }
 
     // 触发鼠标悬停以显示清除按钮
-    fireEvent.mouseEnter(selectElement);
+    fireEvent.mouseEnter(selectElement!);
 
     // 尝试触发清除功能
     // 方法1: 直接触发 Select 组件的 onClear 事件
+    const selectInstance = selectElement as any;
+
     // 尝试通过键盘事件触发清除
-    fireEvent.keyDown(selectElement, { key: 'Backspace', code: 'Backspace' });
+    fireEvent.keyDown(selectElement!, { key: 'Backspace', code: 'Backspace' });
 
     // 或者尝试触发自定义的清除逻辑
     const clearEvents = new CustomEvent('clear');
-    selectElement.dispatchEvent(clearEvents);
+    selectElement!.dispatchEvent(clearEvents);
 
     // 检查是否调用了清除功能（可能需要调整期望）
     // 如果清除按钮不能直接测试，我们验证组件支持清除功能

package/src/components/variables/types.ts

@@ -16,30 +16,12 @@ export interface FlowContextSelectorProps
   value?: string;
   onChange?: (value: string, metaTreeNode?: MetaTreeNode) => void;
   children?: CascaderProps<ContextSelectorItem>['children'];
-  /**
-   * Controls whether the default `x` trigger button is rendered as active
-   * (`type="primary"`). When omitted, the selector falls back to its parsed
-   * `value` path (`true` iff a valid variable path is currently selected).
-   *
-   * Use this when callers intentionally feed synthetic paths such as
-   * `['constant']` / `['null']` into the cascader to keep menu state aligned,
-   * but only want real variable references to show the blue active button.
-   */
-  active?: boolean;
   metaTree?: MetaTreeNode[] | (() => MetaTreeNode[] | Promise<MetaTreeNode[]>);
   parseValueToPath?: (value: string) => string[] | undefined;
   formatPathToValue?: (item: MetaTreeNode) => string;
   open?: boolean;
   onlyLeafSelectable?: boolean;
   ignoreFieldNames?: string[];
-  /**
-   * Footer rendered at the bottom of the dropdown. Defaults to a muted
-   * "Double click to choose entire object" hint when non-leaf selection is
-   * allowed (`onlyLeafSelectable` is false) — since double-clicking a non-leaf
-   * node selects the whole object. Pass an explicit node to override, or `null`
-   * to hide it.
-   */
-  dropdownFooter?: React.ReactNode;
 }
 
 export interface ContextSelectorItem {

package/src/flowI18n.ts

@@ -64,9 +64,7 @@ export class FlowI18n {
    * @private
    */
   private isTemplate(str: string): boolean {
-    // The closing quote is a backreference to the opening one (group 1) so an embedded quote of a different type — e.g.
-    // {{t('… "Post-action event" …')}} — does not terminate the key early.
-    return /\{\{\s*t\s*\(\s*(["'`])(?:\\.|(?!\1).)*?\1\s*(?:,\s*.*?)?\s*\)\s*\}\}/.test(str);
+    return /\{\{\s*t\s*\(\s*["'`].*?["'`]\s*(?:,\s*.*?)?\s*\)\s*\}\}/g.test(str);
   }
 
   /**
@@ -74,12 +72,9 @@ export class FlowI18n {
    * @private
    */
   private compileTemplate(template: string): string {
-    // `(["'`])` captures the opening quote; the key allows escaped chars (`\\.`) and any char that is not that same
-    // quote (`(?!\1).`), and `\1` closes on the matching quote. This keeps embedded quotes of a different type inside
-    // the key instead of truncating it at the first quote of any kind.
     return template.replace(
-      /\{\{\s*t\s*\(\s*(["'`])((?:\\.|(?!\1).)*?)\1\s*(?:,\s*((?:[^{}]|\{[^}]*\})*?))?\s*\)\s*\}\}/g,
-      (match, _quote, key, optionsStr) => {
+      /\{\{\s*t\s*\(\s*["'`](.*?)["'`]\s*(?:,\s*((?:[^{}]|\{[^}]*\})*?))?\s*\)\s*\}\}/g,
+      (match, key, optionsStr) => {
         try {
           let templateOptions = {};
           if (optionsStr) {

package/src/components/variables/__tests__/VariableHybridInput.test.tsx

@@ -1,212 +0,0 @@
-/**
- * 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.
- */
-
-/**
- * Pins how a `{{ … }}` reference renders as its label when the label lives below a lazily-loaded meta-tree level (e.g. a workflow node's output fields under `$jobsMapByNodeKey.<nodeKey>`). `buildLabelMap` only pre-walks already-loaded (array) children into a memoized map, so the two real user flows each need their own resolution path, both pinned here:
- *   - after reload  — the value is already a deep reference at mount, its level still an unresolved thunk → the preload effect resolves it.
- *   - after picking — the user drills into a lazy level (cascader resolves it IN PLACE, no tree-ref change) then picks a leaf → the live walk of the tree's current contents resolves it on the same render.
- * Plus the top-level (already-loaded) and not-in-tree (raw-token fallback) cases.
- */
-
-import { fireEvent, render, screen, waitFor } from '@testing-library/react';
-import React from 'react';
-import { describe, expect, it, vi } from 'vitest';
-import { VariableHybridInput, type VariableHybridInputConverters } from '../VariableHybridInput';
-import type { MetaTreeNode } from '../../../flowContext';
-import { createTestFlowContext, TestFlowContextWrapper } from './test-utils';
-
-// Workflow-style converters: `{{$root.a.b}}` (dotted path, no inner spaces).
-const VARIABLE_REGEXP = /\{\{\s*([^{}]+?)\s*\}\}/g;
-const workflowConverters: VariableHybridInputConverters = {
-  formatPathToValue: (item?: MetaTreeNode) => {
-    const path = item?.paths ?? [];
-    return path.length ? `{{${path.join('.')}}}` : '';
-  },
-  parseValueToPath: (value?: string) => {
-    if (typeof value !== 'string') return undefined;
-    const match = value.trim().match(/^\{\{\s*(.+?)\s*\}\}$/);
-    return match ? match[1].split('.') : undefined;
-  },
-  variableRegExp: VARIABLE_REGEXP,
-};
-
-const TAG_SELECTOR = '.nb-variable-tag';
-
-describe('VariableHybridInput — saved reference labels', () => {
-  it('renders a top-level (already-loaded) reference as its label, not the raw token', async () => {
-    const flowContext = createTestFlowContext();
-    const metaTree: MetaTreeNode[] = [
-      {
-        name: '$user',
-        title: 'User',
-        type: '',
-        paths: ['$user'],
-        children: [{ name: 'name', title: 'Name', type: 'string', paths: ['$user', 'name'] }],
-      },
-    ];
-
-    render(
-      <TestFlowContextWrapper context={flowContext}>
-        <VariableHybridInput value="{{$user.name}}" metaTree={metaTree} converters={workflowConverters} />
-      </TestFlowContextWrapper>,
-    );
-
-    await waitFor(() => {
-      const tag = document.querySelector(TAG_SELECTOR);
-      expect(tag).toBeTruthy();
-      expect(tag?.textContent).toBe('User/Name');
-    });
-  });
-
-  it('shows the label after reload: a deep reference present at mount preloads its lazy level', async () => {
-    const flowContext = createTestFlowContext();
-    // The node's output fields are behind a lazy `children` thunk — exactly the `$jobsMapByNodeKey.<nodeKey>` shape produced by the workflow adapter.
-    const loadChildren = vi.fn(
-      async (): Promise<MetaTreeNode[]> => [
-        { name: 'name', title: 'Name', type: 'string', paths: ['$jobsMapByNodeKey', 'node1', 'name'] },
-      ],
-    );
-    const metaTree: MetaTreeNode[] = [
-      {
-        name: '$jobsMapByNodeKey',
-        title: 'Node result',
-        type: '',
-        paths: ['$jobsMapByNodeKey'],
-        children: [
-          {
-            name: 'node1',
-            title: 'Query',
-            type: '',
-            paths: ['$jobsMapByNodeKey', 'node1'],
-            children: loadChildren,
-          },
-        ],
-      },
-    ];
-
-    render(
-      <TestFlowContextWrapper context={flowContext}>
-        <VariableHybridInput
-          value="{{$jobsMapByNodeKey.node1.name}}"
-          metaTree={metaTree}
-          converters={workflowConverters}
-        />
-      </TestFlowContextWrapper>,
-    );
-
-    // The lazy thunk is invoked by the preload, and the deep label appears.
-    await waitFor(() => {
-      expect(loadChildren).toHaveBeenCalled();
-      const tag = document.querySelector(TAG_SELECTOR);
-      expect(tag?.textContent).toBe('Node result/Query/Name');
-    });
-    // It must NOT leave the raw token visible.
-    expect(document.body.textContent).not.toContain('{{$jobsMapByNodeKey.node1.name}}');
-  });
-
-  it('shows the label after picking: a level expanded in place then selected resolves live', async () => {
-    // Reproduces drilling into a lazy level in the cascader: that resolves the node's `children` onto the SAME meta-tree object in place — WITHOUT changing the tree reference — then the user picks a leaf, so `value` updates. The memoized `labelMap` (keyed on the tree reference) still misses the freshly loaded leaf; only a live walk of the tree's current contents resolves it.
-    const flowContext = createTestFlowContext();
-    const node1: MetaTreeNode = {
-      name: 'node1',
-      title: 'Query',
-      type: '',
-      paths: ['$jobsMapByNodeKey', 'node1'],
-      // Starts WITHOUT children (an unexpanded branch). No thunk — so the preload effect/`loadedFlag` path does not fire; the fix must come from the live walk.
-    };
-    const metaTree: MetaTreeNode[] = [
-      {
-        name: '$jobsMapByNodeKey',
-        title: 'Node result',
-        type: '',
-        paths: ['$jobsMapByNodeKey'],
-        children: [node1],
-      },
-    ];
-
-    // Mount with no reference yet — the deep level is not loaded.
-    const { rerender } = render(
-      <TestFlowContextWrapper context={flowContext}>
-        <VariableHybridInput value="" metaTree={metaTree} converters={workflowConverters} />
-      </TestFlowContextWrapper>,
-    );
-
-    // Simulate the cascader's loadData: resolve node1's children in place on the SAME tree object (no new reference, no thunk).
-    node1.children = [
-      { name: 'name', title: 'Role name', type: 'string', paths: ['$jobsMapByNodeKey', 'node1', 'name'] },
-    ];
-
-    // The user picks the leaf → value updates to the deep reference.
-    rerender(
-      <TestFlowContextWrapper context={flowContext}>
-        <VariableHybridInput
-          value="{{$jobsMapByNodeKey.node1.name}}"
-          metaTree={metaTree}
-          converters={workflowConverters}
-        />
-      </TestFlowContextWrapper>,
-    );
-
-    await waitFor(() => {
-      const tag = document.querySelector(TAG_SELECTOR);
-      expect(tag?.textContent).toBe('Node result/Query/Role name');
-    });
-    expect(document.body.textContent).not.toContain('{{$jobsMapByNodeKey.node1.name}}');
-  });
-
-  it('falls back to the raw token when the reference is not in the tree', async () => {
-    const flowContext = createTestFlowContext();
-    const metaTree: MetaTreeNode[] = [{ name: '$user', title: 'User', type: '', paths: ['$user'], children: [] }];
-
-    render(
-      <TestFlowContextWrapper context={flowContext}>
-        <VariableHybridInput value="{{$missing.field}}" metaTree={metaTree} converters={workflowConverters} />
-      </TestFlowContextWrapper>,
-    );
-
-    await waitFor(() => {
-      const tag = document.querySelector(TAG_SELECTOR);
-      expect(tag?.textContent).toBe('{{$missing.field}}');
-    });
-  });
-
-  it('keeps the selector enabled when only the editor is read-only', async () => {
-    const flowContext = createTestFlowContext();
-    const onChange = vi.fn();
-    const metaTree: MetaTreeNode[] = [
-      {
-        name: '$user',
-        title: 'User',
-        type: '',
-        paths: ['$user'],
-        children: [{ name: 'name', title: 'Name', type: 'string', paths: ['$user', 'name'] }],
-      },
-    ];
-
-    render(
-      <TestFlowContextWrapper context={flowContext}>
-        <VariableHybridInput
-          readOnly
-          value=""
-          onChange={onChange}
-          metaTree={metaTree}
-          converters={workflowConverters}
-        />
-      </TestFlowContextWrapper>,
-    );
-
-    const editor = screen.getByRole('textbox');
-    expect(editor).toHaveAttribute('contenteditable', 'false');
-    expect(editor).toHaveAttribute('aria-readonly', 'true');
-
-    fireEvent.input(editor, { currentTarget: { textContent: 'manual' } });
-    expect(onChange).not.toHaveBeenCalled();
-    expect(screen.getByRole('button')).not.toBeDisabled();
-  });
-});