@nocobase/flow-engine 2.0.0-alpha.2

package/src/components/variables/__tests__/utils.test.ts

@@ -0,0 +1,310 @@
+/**
+ * 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 {
+  parseValueToPath,
+  formatPathToValue,
+  loadMetaTreeChildren,
+  searchInLoadedNodes,
+  buildContextSelectorItems,
+  isVariableValue,
+  createDefaultConverters,
+} from '../utils';
+import type { MetaTreeNode } from '../../../flowContext';
+import type { ContextSelectorItem } from '../types';
+
+describe('Variable Utils', () => {
+  describe('parseValueToPath', () => {
+    it('should parse {{ ctx.aaa.bbb }} to path array', () => {
+      expect(parseValueToPath('{{ ctx.aaa.bbb }}')).toEqual(['aaa', 'bbb']);
+      expect(parseValueToPath('{{ctx.user.name}}')).toEqual(['user', 'name']);
+      expect(parseValueToPath('{{ ctx.data.items.0.title }}')).toEqual(['data', 'items', '0', 'title']);
+    });
+
+    it('should handle edge cases', () => {
+      expect(parseValueToPath('{{ ctx }}')).toEqual([]);
+      expect(parseValueToPath('{{ctx}}')).toEqual([]);
+      expect(parseValueToPath('not a variable')).toBeUndefined();
+      expect(parseValueToPath('')).toBeUndefined();
+      expect(parseValueToPath('{{ something.else }}')).toBeUndefined();
+    });
+
+    it('should handle whitespace variations', () => {
+      expect(parseValueToPath('{{  ctx.aaa.bbb  }}')).toEqual(['aaa', 'bbb']);
+      expect(parseValueToPath('{{ ctx.aaa.bbb}}')).toEqual(['aaa', 'bbb']);
+      expect(parseValueToPath('{{ctx.aaa.bbb }}')).toEqual(['aaa', 'bbb']);
+    });
+  });
+
+  describe('loadMetaTreeChildren', () => {
+    it('should load async children from MetaTreeNode', async () => {
+      const asyncChildren = async () => [
+        { name: 'child1', title: 'Child 1', type: 'string', paths: ['parent', 'child1'], parentTitles: ['Parent'] },
+        { name: 'child2', title: 'Child 2', type: 'number', paths: ['parent', 'child2'], parentTitles: ['Parent'] },
+      ];
+
+      const metaNode: MetaTreeNode = {
+        name: 'parent',
+        title: 'Parent',
+        type: 'object',
+        paths: ['parent'],
+        children: asyncChildren,
+      };
+
+      const result = await loadMetaTreeChildren(metaNode);
+      expect(result).toHaveLength(2);
+      expect(result[0].name).toBe('child1');
+      expect(result[1].name).toBe('child2');
+    });
+
+    it('should return empty array for nodes without children', async () => {
+      const metaNode: MetaTreeNode = {
+        name: 'leaf',
+        title: 'Leaf',
+        type: 'string',
+        paths: ['leaf'],
+      };
+
+      const result = await loadMetaTreeChildren(metaNode);
+      expect(result).toEqual([]);
+    });
+
+    it('should handle sync children array', async () => {
+      const metaNode: MetaTreeNode = {
+        name: 'parent',
+        title: 'Parent',
+        type: 'object',
+        paths: ['parent'],
+        children: [
+          { name: 'child1', title: 'Child 1', type: 'string', paths: ['parent', 'child1'], parentTitles: ['Parent'] },
+        ],
+      };
+
+      const result = await loadMetaTreeChildren(metaNode);
+      expect(result).toHaveLength(1);
+      expect(result[0].name).toBe('child1');
+    });
+  });
+
+  describe('searchInLoadedNodes', () => {
+    const mockOptions: ContextSelectorItem[] = [
+      {
+        label: 'User',
+        value: 'user',
+        paths: ['user'],
+        children: [
+          { label: 'Name', value: 'name', isLeaf: true, paths: ['user', 'name'] },
+          { label: 'Email', value: 'email', isLeaf: true, paths: ['user', 'email'] },
+        ],
+      },
+      {
+        label: 'Data',
+        value: 'data',
+        paths: ['data'],
+        children: [{ label: 'Items', value: 'items', isLeaf: true, paths: ['data', 'items'] }],
+      },
+    ];
+
+    it('should search in cascader options by label', () => {
+      const result = searchInLoadedNodes(mockOptions, 'User');
+      expect(result).toHaveLength(1);
+      expect(result[0].label).toBe('User');
+    });
+
+    it('should search nested options', () => {
+      const result = searchInLoadedNodes(mockOptions, 'Name');
+      expect(result).toHaveLength(1);
+      expect(result[0].label).toBe('Name');
+    });
+
+    it('should return empty array for no matches', () => {
+      const result = searchInLoadedNodes(mockOptions, 'NonExistent');
+      expect(result).toEqual([]);
+    });
+
+    it('should handle case insensitive search', () => {
+      const result = searchInLoadedNodes(mockOptions, 'user');
+      expect(result).toHaveLength(1);
+      expect(result[0].label).toBe('User');
+    });
+
+    it('should return the same object instances without creating new ones', () => {
+      const result = searchInLoadedNodes(mockOptions, 'User');
+      expect(result).toHaveLength(1);
+      // Verify that the returned object is the exact same instance as the original
+      expect(result[0]).toBe(mockOptions[0]);
+      expect(result[0].paths).toBe(mockOptions[0].paths);
+
+      const nestedResult = searchInLoadedNodes(mockOptions, 'Name');
+      expect(nestedResult).toHaveLength(1);
+      // Verify that nested search also returns the same instance
+      expect(nestedResult[0]).toBe(mockOptions[0].children![0]);
+      expect(nestedResult[0].paths).toBe(mockOptions[0].children![0].paths);
+    });
+  });
+
+  describe('buildContextSelectorItems', () => {
+    it('should convert MetaTreeNode[] to ContextSelectorItem[]', () => {
+      const metaTree: MetaTreeNode[] = [
+        {
+          name: 'user',
+          title: 'User',
+          type: 'object',
+          paths: ['user'],
+          children: [
+            { name: 'name', title: 'Name', type: 'string', paths: ['user', 'name'], parentTitles: ['User'] },
+            { name: 'email', title: 'Email', type: 'string', paths: ['user', 'email'], parentTitles: ['User'] },
+          ],
+        },
+        {
+          name: 'data',
+          title: 'Data',
+          type: 'string',
+          paths: ['data'],
+        },
+      ];
+
+      const result = buildContextSelectorItems(metaTree);
+      expect(result).toHaveLength(2);
+      expect(result[0]).toEqual({
+        label: 'User',
+        value: 'user',
+        isLeaf: false,
+        meta: metaTree[0],
+        paths: ['user'],
+        disabled: false,
+        children: [
+          {
+            label: 'Name',
+            value: 'name',
+            isLeaf: true,
+            meta: metaTree[0].children?.[0],
+            paths: ['user', 'name'],
+            disabled: false,
+          },
+          {
+            label: 'Email',
+            value: 'email',
+            isLeaf: true,
+            meta: metaTree[0].children?.[1],
+            paths: ['user', 'email'],
+            disabled: false,
+          },
+        ],
+      });
+      expect(result[1]).toEqual({
+        label: 'Data',
+        value: 'data',
+        isLeaf: true,
+        meta: metaTree[1],
+        paths: ['data'],
+        disabled: false,
+      });
+    });
+
+    it('should handle async children by marking as not leaf', () => {
+      const metaTree: MetaTreeNode[] = [
+        {
+          name: 'async',
+          title: 'Async Node',
+          type: 'object',
+          paths: ['async'],
+          children: async () => [],
+        },
+      ];
+
+      const result = buildContextSelectorItems(metaTree);
+      expect(result[0]).toEqual({
+        label: 'Async Node',
+        value: 'async',
+        isLeaf: false,
+        meta: metaTree[0],
+        paths: ['async'],
+        disabled: false,
+      });
+    });
+
+    it('should handle invalid metaTree input', () => {
+      const consoleSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+
+      expect(buildContextSelectorItems(null as any)).toEqual([]);
+      expect(buildContextSelectorItems(undefined as any)).toEqual([]);
+      expect(buildContextSelectorItems({} as any)).toEqual([]);
+
+      expect(consoleSpy).toHaveBeenCalledTimes(3);
+      consoleSpy.mockRestore();
+    });
+
+    it('should use name as fallback when title is missing', () => {
+      const metaTree: MetaTreeNode[] = [
+        {
+          name: 'test',
+          type: 'object',
+          title: '',
+          paths: ['test'],
+        },
+      ];
+
+      const result = buildContextSelectorItems(metaTree);
+
+      expect(result).toEqual([
+        {
+          label: 'test',
+          value: 'test',
+          isLeaf: true,
+          meta: { name: 'test', type: 'object', title: '', paths: ['test'] },
+          paths: ['test'],
+          disabled: false,
+        },
+      ]);
+    });
+  });
+
+  describe('isVariableValue', () => {
+    it('should detect variable values', () => {
+      expect(isVariableValue('{{ ctx.user.name }}')).toBe(true);
+      expect(isVariableValue('{{ctx.data}}')).toBe(true);
+      expect(isVariableValue('{{ ctx.items.0.title }}')).toBe(true);
+    });
+
+    it('should return false for non-variable values', () => {
+      expect(isVariableValue('plain text')).toBe(false);
+      expect(isVariableValue('123')).toBe(false);
+      expect(isVariableValue('')).toBe(false);
+      expect(isVariableValue(null)).toBe(false);
+      expect(isVariableValue(undefined)).toBe(false);
+      expect(isVariableValue({ key: 'value' })).toBe(false);
+    });
+
+    it('should handle edge cases', () => {
+      expect(isVariableValue('{{ something.else }}')).toBe(false);
+      expect(isVariableValue('{{ ctx }}')).toBe(true);
+      expect(isVariableValue('{ctx.user}')).toBe(false);
+      expect(isVariableValue('{{ ctx.user')).toBe(false);
+      expect(isVariableValue('ctx.user }}')).toBe(false);
+    });
+  });
+
+  describe('createDefaultConverters', () => {
+    it('should create default converters', () => {
+      const converters = createDefaultConverters();
+      expect(converters).toHaveProperty('resolvePathFromValue');
+      expect(converters).toHaveProperty('resolveValueFromPath');
+      expect(typeof converters.resolvePathFromValue).toBe('function');
+      expect(typeof converters.resolveValueFromPath).toBe('function');
+    });
+
+    it('should resolve path from variable value', () => {
+      const converters = createDefaultConverters();
+      expect(converters.resolvePathFromValue?.('{{ ctx.user.name }}')).toEqual(['user', 'name']);
+      expect(converters.resolvePathFromValue?.('static value')).toBeUndefined();
+    });
+  });
+});

package/src/components/variables/index.ts

@@ -0,0 +1,16 @@
+/**
+ * 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.
+ */
+
+export { VariableInput } from './VariableInput';
+export { SlateVariableEditor } from './SlateVariableEditor';
+export { VariableTag } from './VariableTag';
+export { InlineVariableTag } from './InlineVariableTag';
+export { useResolvedMetaTree } from './useResolvedMetaTree';
+export * from './types';
+export * from './utils';

package/src/components/variables/types.ts

@@ -0,0 +1,100 @@
+/**
+ * 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 React from 'react';
+import { CascaderProps } from 'antd';
+import type { MetaTreeNode } from '../../flowContext';
+
+export interface FlowContextSelectorProps
+  extends Omit<CascaderProps<ContextSelectorItem>, 'value' | 'onChange' | 'options' | 'children' | 'multiple'> {
+  value?: string;
+  onChange?: (value: string, metaTreeNode?: MetaTreeNode) => void;
+  children?: CascaderProps<ContextSelectorItem>['children'];
+  metaTree?: MetaTreeNode[] | (() => MetaTreeNode[] | Promise<MetaTreeNode[]>);
+  parseValueToPath?: (value: string) => string[] | undefined;
+  formatPathToValue?: (item: MetaTreeNode) => string;
+  open?: boolean;
+  onlyLeafSelectable?: boolean;
+}
+
+export interface ContextSelectorItem {
+  label: React.ReactNode;
+  value: string;
+  isLeaf?: boolean;
+  children?: ContextSelectorItem[];
+  loading?: boolean;
+  meta?: MetaTreeNode;
+  paths: string[];
+  disabled?: boolean;
+}
+
+export interface Converters {
+  /**
+   * 根据选中的上下文选择器项目，返回一个用于渲染该值的 React 组件类型。
+   * 如果返回 null 或 undefined，则会使用默认的渲染组件。
+   * @param metaTreeNode 选中的 MetaTreeNode 对象，或者在未选择任何变量时为 null。
+   * @returns React.ComponentType<{ value: any; onChange: (value: any) => void; }> | null
+   */
+  renderInputComponent?: (metaTreeNode: MetaTreeNode | null) => React.ComponentType<any> | null;
+
+  /**
+   * 将一个外部 value 转换成 FlowContextSelector 需要的路径数组。
+   * @param value 外部传入的值。
+   * @returns string[] | undefined
+   */
+  resolvePathFromValue?: (value: any) => string[] | undefined;
+  /**
+   * 当一个上下文节点被选中后，将其信息转换成最终的外部 value。
+   * @param metaTreeNode 选中的 MetaTreeNode 对象。
+   * @returns any
+   */
+  resolveValueFromPath?: (metaTreeNode: MetaTreeNode) => any;
+}
+
+export interface VariableInputProps {
+  value?: any;
+  onChange?: (value: any, contextMeta?: MetaTreeNode) => void;
+  converters?: Converters;
+  showValueComponent?: boolean;
+  metaTree?: MetaTreeNode[] | (() => MetaTreeNode[] | Promise<MetaTreeNode[]>);
+  onlyLeafSelectable?: boolean;
+  /**
+   * 清空（点击 Tag 的 clear、或 Input 的 allowClear）时要设置的值。
+   * 默认行为为 null；可设置为 '' 等，以便清空后默认切换为“常量-空字符串”。
+   */
+  clearValue?: any;
+  [key: string]: any;
+}
+
+export interface VariableTagProps {
+  value?: string;
+  onClear?: () => void;
+  className?: string;
+  style?: React.CSSProperties;
+  metaTreeNode?: MetaTreeNode | null;
+  metaTree?: MetaTreeNode[] | (() => MetaTreeNode[] | Promise<MetaTreeNode[]>);
+}
+
+export interface VariableTriggerElement {
+  type: 'variable-trigger';
+  triggerId: string;
+  children: [{ text: '' }];
+}
+
+export interface VariableElement {
+  type: 'variable';
+  value: string;
+  meta?: MetaTreeNode;
+  children: [{ text: '' }];
+}
+
+export interface ParagraphElement {
+  type: 'paragraph';
+  children: any[];
+}

package/src/components/variables/useResolvedMetaTree.ts

@@ -0,0 +1,76 @@
+/**
+ * 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 React from 'react';
+import type { MetaTreeNode } from '../../flowContext';
+
+export interface UseResolvedMetaTreeResult {
+  resolvedMetaTree: MetaTreeNode[] | undefined;
+  loading: boolean;
+  error: Error | null;
+}
+
+/**
+ * 通用 hook 用于处理异步/同步 metaTree
+ * 统一处理 metaTree 为函数（同步/异步）或数组的情况
+ */
+export const useResolvedMetaTree = (
+  metaTree?: MetaTreeNode[] | (() => MetaTreeNode[] | Promise<MetaTreeNode[]>),
+): UseResolvedMetaTreeResult => {
+  const [resolvedMetaTree, setResolvedMetaTree] = React.useState<MetaTreeNode[] | undefined>();
+  const [loading, setLoading] = React.useState(false);
+  const [error, setError] = React.useState<Error | null>(null);
+
+  React.useEffect(() => {
+    const resolveMetaTree = async () => {
+      if (!metaTree) {
+        setResolvedMetaTree(undefined);
+        setLoading(false);
+        setError(null);
+        return;
+      }
+
+      // 如果是数组，直接使用
+      if (Array.isArray(metaTree)) {
+        setResolvedMetaTree(metaTree);
+        setLoading(false);
+        setError(null);
+        return;
+      }
+
+      // 如果是函数，需要调用它
+      if (typeof metaTree === 'function') {
+        setLoading(true);
+        setError(null);
+        try {
+          let result = await metaTree();
+          // 兼容返回值仍然是函数（惰性 loader）的情况，继续调用一次获取真正的数组
+          if (typeof result === 'function') {
+            result = await (result as unknown as () => Promise<MetaTreeNode[]>)();
+          }
+          setResolvedMetaTree(result as MetaTreeNode[]);
+        } catch (err) {
+          console.warn('Failed to resolve metaTree function:', err);
+          setError(err instanceof Error ? err : new Error(String(err)));
+          setResolvedMetaTree(undefined);
+        } finally {
+          setLoading(false);
+        }
+      }
+    };
+
+    resolveMetaTree();
+  }, [metaTree]);
+
+  return {
+    resolvedMetaTree,
+    loading,
+    error,
+  };
+};

package/src/components/variables/utils.ts

@@ -0,0 +1,192 @@
+/**
+ * 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 React from 'react';
+import { Input } from 'antd';
+import type { MetaTreeNode } from '../../flowContext';
+import type { ContextSelectorItem, Converters } from './types';
+import { isVariableExpression } from '../../utils';
+
+export const parseValueToPath = (value: string): string[] | undefined => {
+  if (typeof value !== 'string') return undefined;
+
+  const trimmed = value.trim();
+  const variableRegex = /^\{\{\s*ctx(?:\.(.+?))?\s*\}\}$/;
+  const match = trimmed.match(variableRegex);
+
+  if (!match) return undefined;
+
+  const pathString = match[1];
+  if (!pathString) return [];
+
+  return pathString.split('.');
+};
+
+export const formatPathToValue = (item: MetaTreeNode): string => {
+  const path = item?.paths || [];
+  if (path.length === 0) return '{{ ctx }}';
+  return `{{ ctx.${path.join('.')} }}`;
+};
+
+export const loadMetaTreeChildren = async (metaNode: MetaTreeNode): Promise<MetaTreeNode[]> => {
+  if (!metaNode?.children) return [];
+
+  if (typeof metaNode.children === 'function') {
+    try {
+      return await metaNode.children();
+    } catch (error) {
+      console.warn(`Failed to load children for ${metaNode.name}:`, error);
+      return [];
+    }
+  }
+
+  return metaNode.children;
+};
+
+// 在已加载的级联选项中搜索，支持模糊匹配
+export const searchInLoadedNodes = (
+  options: ContextSelectorItem[],
+  searchText: string,
+  parentPaths: string[] = [],
+): ContextSelectorItem[] => {
+  if (!searchText || !searchText.trim()) return [];
+
+  const lowerSearchText = searchText.toLowerCase().trim();
+  const results: ContextSelectorItem[] = [];
+
+  // 递归搜索已加载的节点
+  const searchRecursive = (nodes: ContextSelectorItem[], currentPath: string[] = []) => {
+    for (const node of nodes) {
+      const nodePath = [...currentPath, node.value];
+
+      // 计算可搜索的纯文本标签
+      const labelText =
+        typeof node.label === 'string'
+          ? node.label
+          : typeof node.meta?.title === 'string'
+            ? node.meta!.title
+            : String(node.value);
+
+      // 检查节点标签是否匹配搜索文本
+      if (labelText.toLowerCase().includes(lowerSearchText)) {
+        results.push(node);
+      }
+
+      // 只搜索已加载的子节点（存在children属性表示已加载）
+      if (node.children && Array.isArray(node.children)) {
+        searchRecursive(node.children, nodePath);
+      }
+    }
+  };
+
+  searchRecursive(options, []);
+  return results;
+};
+
+export const buildContextSelectorItems = (metaTree: MetaTreeNode[]): ContextSelectorItem[] => {
+  if (!metaTree || !Array.isArray(metaTree)) {
+    console.warn('buildContextSelectorItems received invalid metaTree:', metaTree);
+    return [];
+  }
+
+  const convertNode = (node: MetaTreeNode): ContextSelectorItem => {
+    const hasChildren = !!(
+      node.children &&
+      (typeof node.children === 'function' || (Array.isArray(node.children) && node.children.length > 0))
+    );
+    // 计算禁用状态：支持 boolean 或函数
+    const disabled = !!(typeof node.disabled === 'function' ? node.disabled() : node.disabled);
+    const option: ContextSelectorItem = {
+      label: node.title || node.name,
+      value: node.name,
+      isLeaf: !hasChildren,
+      meta: node,
+      paths: node.paths,
+      disabled,
+    };
+
+    if (Array.isArray(node.children) && node.children.length > 0) {
+      option.children = node.children.map((child) => convertNode(child));
+    }
+
+    return option;
+  };
+
+  return metaTree.map((node) => convertNode(node));
+};
+
+/**
+ * 预加载：根据路径逐级加载 ContextSelectorItem 的 children，保证打开时已展开对应层级。
+ */
+export const preloadContextSelectorPath = async (
+  options: ContextSelectorItem[] | undefined,
+  pathSegments: (string | number)[],
+  triggerUpdate?: () => void,
+) => {
+  if (!options || !Array.isArray(options) || !pathSegments || pathSegments.length === 0) return;
+  let list: ContextSelectorItem[] | undefined = options;
+  for (let i = 0; i < pathSegments.length && list; i++) {
+    const seg = String(pathSegments[i]);
+    const opt = list.find((o) => String(o.value) === seg);
+    if (!opt) break;
+    const meta = opt.meta as MetaTreeNode | undefined;
+    const hasLoaded = !!opt.children && Array.isArray(opt.children);
+    if (i < pathSegments.length - 1 && !hasLoaded && meta && typeof meta.children === 'function') {
+      opt.loading = true;
+      try {
+        const childNodes = await loadMetaTreeChildren(meta);
+        meta.children = childNodes;
+        const childOptions = buildContextSelectorItems(childNodes);
+        opt.children = childOptions;
+        opt.isLeaf = !childOptions || childOptions.length === 0;
+        Promise.resolve()
+          .then(() => triggerUpdate?.())
+          .catch(() => {});
+      } finally {
+        opt.loading = false;
+      }
+    }
+    list = Array.isArray(opt.children) ? opt.children : undefined;
+  }
+};
+
+export const isVariableValue = (value: any): boolean => {
+  return isVariableExpression(value);
+};
+
+export const createDefaultConverters = (): Converters => {
+  return {
+    resolvePathFromValue: (value: any) => {
+      return parseValueToPath(value);
+    },
+
+    resolveValueFromPath: (item: MetaTreeNode) => {
+      return formatPathToValue(item);
+    },
+  };
+};
+
+export const createFinalConverters = (propConverters?: Converters): Converters => {
+  const defaultConverters = createDefaultConverters();
+  const mergedConverters = propConverters ? { ...defaultConverters, ...propConverters } : defaultConverters;
+
+  // 如果用户自定义了 resolveValueFromPath，需要包装一下以保持后备逻辑
+  if (propConverters?.resolveValueFromPath) {
+    const customResolveValueFromPath = propConverters.resolveValueFromPath;
+    return {
+      ...mergedConverters,
+      resolveValueFromPath: (item: MetaTreeNode) => {
+        const ret = customResolveValueFromPath(item);
+        return ret === undefined ? formatPathToValue(item) : ret;
+      },
+    };
+  }
+
+  return mergedConverters;
+};