@flowgram.ai/form-materials 0.1.0-alpha.15 → 0.1.0-alpha.16

package/src/form-plugins/batch-outputs-plugin/index.ts

@@ -3,12 +3,13 @@
  * SPDX-License-Identifier: MIT
  */
 
+import { set } from 'lodash-es';
+import { JsonSchemaUtils } from '@flowgram.ai/json-schema';
 import {
   ASTFactory,
   createEffectFromVariableProvider,
   defineFormPluginCreator,
   FlowNodeRegistry,
-  getNodeForm,
   getNodePrivateScope,
   getNodeScope,
   ScopeChainTransformService,
@@ -24,7 +25,7 @@ export const provideBatchOutputsEffect: EffectOptions[] = createEffectFromVariab
     ASTFactory.createVariableDeclaration({
       key: `${ctx.node.id}`,
       meta: {
-        title: getNodeForm(ctx.node)?.getValueIn('title'),
+        title: ctx.node.form?.getValueIn('title'),
         icon: ctx.node.getNodeRegistry<FlowNodeRegistry>().info?.icon,
       },
       type: ASTFactory.createObject({
@@ -46,59 +47,76 @@ export const provideBatchOutputsEffect: EffectOptions[] = createEffectFromVariab
 /**
  * Free Layout only right now
  */
-export const createBatchOutputsFormPlugin: FormPluginCreator<{ outputKey: string }> =
-  defineFormPluginCreator({
-    name: 'batch-outputs-plugin',
-    onSetupFormMeta({ mergeEffect }, { outputKey }) {
-      mergeEffect({
-        [outputKey]: provideBatchOutputsEffect,
+export const createBatchOutputsFormPlugin: FormPluginCreator<{
+  outputKey: string;
+  /**
+   * if set, infer json schema to inferTargetKey when submit
+   */
+  inferTargetKey?: string;
+}> = defineFormPluginCreator({
+  name: 'batch-outputs-plugin',
+  onSetupFormMeta({ mergeEffect, addFormatOnSubmit }, { outputKey, inferTargetKey }) {
+    mergeEffect({
+      [outputKey]: provideBatchOutputsEffect,
+    });
+
+    if (inferTargetKey) {
+      addFormatOnSubmit((formData, ctx) => {
+        const outputVariable = getNodeScope(ctx.node).output.variables?.[0];
+
+        if (outputVariable?.type) {
+          set(formData, inferTargetKey, JsonSchemaUtils.astToSchema(outputVariable?.type));
+        }
+
+        return formData;
       });
-    },
-    onInit(ctx, { outputKey }) {
-      const chainTransformService = ctx.node.getService(ScopeChainTransformService);
+    }
+  },
+  onInit(ctx, { outputKey }) {
+    const chainTransformService = ctx.node.getService(ScopeChainTransformService);
 
-      const batchNodeType = ctx.node.flowNodeType;
+    const batchNodeType = ctx.node.flowNodeType;
 
-      const transformerId = `${batchNodeType}-outputs`;
+    const transformerId = `${batchNodeType}-outputs`;
 
-      if (chainTransformService.hasTransformer(transformerId)) {
-        return;
-      }
+    if (chainTransformService.hasTransformer(transformerId)) {
+      return;
+    }
 
-      chainTransformService.registerTransformer(transformerId, {
-        transformCovers: (covers, ctx) => {
-          const node = ctx.scope.meta?.node;
+    chainTransformService.registerTransformer(transformerId, {
+      transformCovers: (covers, ctx) => {
+        const node = ctx.scope.meta?.node;
 
-          // Child Node's variable can cover parent
-          if (node?.parent?.flowNodeType === batchNodeType) {
-            return [...covers, getNodeScope(node.parent)];
-          }
+        // Child Node's variable can cover parent
+        if (node?.parent?.flowNodeType === batchNodeType) {
+          return [...covers, getNodeScope(node.parent)];
+        }
 
-          return covers;
-        },
-        transformDeps(scopes, ctx) {
-          const scopeMeta = ctx.scope.meta;
+        return covers;
+      },
+      transformDeps(scopes, ctx) {
+        const scopeMeta = ctx.scope.meta;
 
-          if (scopeMeta?.type === FlowNodeScopeType.private) {
-            return scopes;
-          }
+        if (scopeMeta?.type === FlowNodeScopeType.private) {
+          return scopes;
+        }
 
-          const node = scopeMeta?.node;
+        const node = scopeMeta?.node;
 
-          // Public of Loop Node depends on child Node
-          if (node?.flowNodeType === batchNodeType) {
-            // Get all child blocks
-            const childBlocks = node.blocks;
+        // Public of Loop Node depends on child Node
+        if (node?.flowNodeType === batchNodeType) {
+          // Get all child blocks
+          const childBlocks = node.blocks;
 
-            // public scope of all child blocks
-            return [
-              getNodePrivateScope(node),
-              ...childBlocks.map((_childBlock) => getNodeScope(_childBlock)),
-            ];
-          }
+          // public scope of all child blocks
+          return [
+            getNodePrivateScope(node),
+            ...childBlocks.map((_childBlock) => getNodeScope(_childBlock)),
+          ];
+        }
 
-          return scopes;
-        },
-      });
-    },
-  });
+        return scopes;
+      },
+    });
+  },
+});

package/src/form-plugins/infer-assign-plugin/index.ts

@@ -10,7 +10,6 @@ import {
   createEffectFromVariableProvider,
   defineFormPluginCreator,
   FlowNodeRegistry,
-  getNodeForm,
   getNodeScope,
 } from '@flowgram.ai/editor';
 
@@ -51,7 +50,7 @@ export const createInferAssignPlugin = defineFormPluginCreator<InputConfig>({
             ASTFactory.createVariableDeclaration({
               key: `${ctx.node.id}`,
               meta: {
-                title: getNodeForm(ctx.node)?.getValueIn('title'),
+                title: ctx.node.form?.getValueIn('title'),
                 icon: ctx.node.getNodeRegistry<FlowNodeRegistry>().info?.icon,
               },
               type: ASTFactory.createObject({

package/src/form-plugins/infer-inputs-plugin/index.ts

@@ -3,34 +3,82 @@
  * SPDX-License-Identifier: MIT
  */
 
-import { get, set } from 'lodash-es';
+import { get, omit, set } from 'lodash-es';
+import { Immer } from 'immer';
 import { defineFormPluginCreator, getNodePrivateScope, getNodeScope } from '@flowgram.ai/editor';
 
 import { FlowValueUtils } from '@/shared';
 
+const { produce } = new Immer({ autoFreeze: false });
+
 interface InputConfig {
   sourceKey: string;
   targetKey: string;
   scope?: 'private' | 'public';
+  /**
+   * For backend runtime, constant schema is redundant, so we can choose to ignore it
+   */
+  ignoreConstantSchema?: boolean;
 }
 
 export const createInferInputsPlugin = defineFormPluginCreator<InputConfig>({
-  onSetupFormMeta({ addFormatOnSubmit }, { sourceKey, targetKey, scope }) {
+  onSetupFormMeta(
+    { addFormatOnSubmit, addFormatOnInit },
+    { sourceKey, targetKey, scope, ignoreConstantSchema }
+  ) {
     if (!sourceKey || !targetKey) {
       return;
     }
 
-    addFormatOnSubmit((formData, ctx) => {
-      set(
-        formData,
-        targetKey,
-        FlowValueUtils.inferJsonSchema(
-          get(formData, sourceKey),
-          scope === 'private' ? getNodePrivateScope(ctx.node) : getNodeScope(ctx.node)
-        )
-      );
-
-      return formData;
-    });
+    addFormatOnSubmit((formData, ctx) =>
+      produce(formData, (draft: any) => {
+        const sourceData = get(formData, sourceKey);
+
+        set(
+          draft,
+          targetKey,
+          FlowValueUtils.inferJsonSchema(
+            sourceData,
+            scope === 'private' ? getNodePrivateScope(ctx.node) : getNodeScope(ctx.node)
+          )
+        );
+
+        if (ignoreConstantSchema) {
+          for (const { value, path } of FlowValueUtils.traverse(sourceData, {
+            includeTypes: ['constant'],
+          })) {
+            if (FlowValueUtils.isConstant(value) && value?.schema) {
+              set(formData, `${sourceKey}.${path}`, omit(value, ['schema']));
+            }
+          }
+        }
+      })
+    );
+
+    if (ignoreConstantSchema) {
+      // Revert Schema in frontend
+      addFormatOnInit((formData, ctx) => {
+        const targetSchema = get(formData, targetKey);
+
+        if (!targetSchema) {
+          return formData;
+        }
+
+        // For backend data, it's not necessary to use immer
+        for (const { value, pathArr } of FlowValueUtils.traverse(get(formData, sourceKey), {
+          includeTypes: ['constant'],
+        })) {
+          if (FlowValueUtils.isConstant(value) && !value?.schema) {
+            const schemaPath = pathArr.map((_item) => `properties.${_item}`).join('.');
+            const schema = get(targetSchema, schemaPath);
+            if (schema) {
+              set(value, 'schema', schema);
+            }
+          }
+        }
+
+        return formData;
+      });
+    }
   },
 });

package/src/index.ts

@@ -6,11 +6,14 @@
 export {
   AssignRow,
   AssignRows,
+  BaseCodeEditor,
   BatchOutputs,
   BatchVariableSelector,
   BlurInput,
   CodeEditor,
   CodeEditorMini,
+  ConditionPresetOp,
+  ConditionProvider,
   ConditionRow,
   ConstantInput,
   DBConditionRow,
@@ -21,16 +24,25 @@ export {
   DisplaySchemaTag,
   DisplaySchemaTree,
   DynamicValueInput,
+  EditorInputsTree,
+  EditorVariableTagInject,
+  EditorVariableTree,
   InjectDynamicValueInput,
   InjectTypeSelector,
   InjectVariableSelector,
   InputsValues,
   InputsValuesTree,
+  JsonCodeEditor,
   JsonEditorWithVariables,
   JsonSchemaEditor,
   PromptEditor,
   PromptEditorWithInputs,
   PromptEditorWithVariables,
+  PythonCodeEditor,
+  SQLCodeEditor,
+  SQLEditorWithVariables,
+  ShellCodeEditor,
+  TypeScriptCodeEditor,
   TypeSelector,
   VariableSelector,
   VariableSelectorProvider,
@@ -38,16 +50,23 @@ export {
   parseTypeSelectValue,
   type AssignValueType,
   type CodeEditorPropsType,
+  type ConditionOpConfig,
+  type ConditionOpConfigs,
   type ConditionRowValueType,
   type ConstantInputStrategy,
   type DBConditionOptionType,
   type DBConditionRowValueType,
+  type IConditionRule,
+  type IConditionRuleFactory,
   type JsonEditorWithVariablesProps,
   type PromptEditorPropsType,
   type PromptEditorWithInputsProps,
   type PromptEditorWithVariablesProps,
+  type SQLEditorWithVariablesProps,
   type TypeSelectorProps,
   type VariableSelectorProps,
+  useCondition,
+  useConditionContext,
   useVariableTree,
 } from './components';
 export {

package/src/plugins/json-schema-preset/create-type-preset-plugin.tsx

@@ -10,8 +10,10 @@ import {
 } from '@flowgram.ai/json-schema';
 import { definePluginCreator } from '@flowgram.ai/editor';
 
-import { jsonSchemaTypePreset } from './type-definition';
-import { JsonSchemaTypeRegistry } from './manager';
+import { JsonSchemaTypeRegistry } from './types';
+import { initRegistries, jsonSchemaTypePreset } from './type-definition';
+
+initRegistries();
 
 export const createTypePresetPlugin = definePluginCreator<{
   types?: Partial<JsonSchemaTypeRegistry> & Pick<JsonSchemaTypeRegistry, 'type'>[];

package/src/plugins/json-schema-preset/index.tsx

@@ -2,33 +2,17 @@
  * Copyright (c) 2025 Bytedance Ltd. and/or its affiliates
  * SPDX-License-Identifier: MIT
  */
-import React from 'react';
 
 import {
-  type IJsonSchema,
-  JsonSchemaUtils,
-  useTypeManager as useOriginTypeManager,
-  TypePresetProvider as OriginTypePresetProvider,
-  JsonSchemaTypeManager,
   type JsonSchemaBasicType,
+  JsonSchemaUtils,
+  type IJsonSchema,
 } from '@flowgram.ai/json-schema';
 
-import { jsonSchemaTypePreset } from './type-definition';
-import { type JsonSchemaTypeRegistry, type ConstantRendererProps } from './manager';
+import { type ConstantRendererProps, type JsonSchemaTypeRegistry } from './types';
+import { useTypeManager, JsonSchemaTypePresetProvider } from './react';
 import { createTypePresetPlugin } from './create-type-preset-plugin';
 
-const useTypeManager = () =>
-  useOriginTypeManager() as JsonSchemaTypeManager<IJsonSchema, JsonSchemaTypeRegistry>;
-
-const JsonSchemaTypePresetProvider = ({
-  types = [],
-  children,
-}: React.PropsWithChildren<{ types: JsonSchemaTypeRegistry[] }>) => (
-  <OriginTypePresetProvider types={[...jsonSchemaTypePreset, ...types]}>
-    {children}
-  </OriginTypePresetProvider>
-);
-
 export {
   createTypePresetPlugin,
   useTypeManager,

package/src/plugins/json-schema-preset/react.tsx

@@ -0,0 +1,31 @@
+/**
+ * Copyright (c) 2025 Bytedance Ltd. and/or its affiliates
+ * SPDX-License-Identifier: MIT
+ */
+
+import React from 'react';
+
+import {
+  type IJsonSchema,
+  useTypeManager as useOriginTypeManager,
+  TypePresetProvider as OriginTypePresetProvider,
+  JsonSchemaTypeManager,
+} from '@flowgram.ai/json-schema';
+
+import { type JsonSchemaTypeRegistry } from './types';
+import { initRegistries, jsonSchemaTypePreset } from './type-definition';
+
+// If you want to use new type Manager, init registries
+initRegistries();
+
+export const useTypeManager = () =>
+  useOriginTypeManager() as JsonSchemaTypeManager<IJsonSchema, JsonSchemaTypeRegistry>;
+
+export const JsonSchemaTypePresetProvider = ({
+  types = [],
+  children,
+}: React.PropsWithChildren<{ types: JsonSchemaTypeRegistry[] }>) => (
+  <OriginTypePresetProvider types={[...jsonSchemaTypePreset, ...types]}>
+    {children}
+  </OriginTypePresetProvider>
+);

package/src/plugins/json-schema-preset/type-definition/array.tsx

@@ -8,19 +8,28 @@ import React from 'react';
 
 import { I18n } from '@flowgram.ai/editor';
 
-import { CodeEditorMini } from '@/components/code-editor-mini';
+import { ConditionPresetOp } from '@/components/condition-context/op';
+import { JsonCodeEditor } from '@/components/code-editor';
 
-import { type JsonSchemaTypeRegistry } from '../manager';
+import { type JsonSchemaTypeRegistry } from '../types';
 
 export const arrayRegistry: Partial<JsonSchemaTypeRegistry> = {
   type: 'array',
   ConstantRenderer: (props) => (
-    <CodeEditorMini
+    <JsonCodeEditor
+      mini
       value={props.value}
-      languageId="json"
       onChange={(v) => props.onChange?.(v)}
       placeholder={I18n.t('Please Input Array')}
       readonly={props.readonly}
     />
   ),
+  conditionRule: {
+    [ConditionPresetOp.IS_EMPTY]: null,
+    [ConditionPresetOp.IS_NOT_EMPTY]: null,
+    [ConditionPresetOp.CONTAINS]: { type: 'array', extra: { weak: true } },
+    [ConditionPresetOp.NOT_CONTAINS]: { type: 'array', extra: { weak: true } },
+    [ConditionPresetOp.EQ]: { type: 'array', extra: { weak: true } },
+    [ConditionPresetOp.NEQ]: { type: 'array', extra: { weak: true } },
+  },
 };

package/src/plugins/json-schema-preset/type-definition/boolean.tsx

@@ -9,7 +9,9 @@ import React from 'react';
 import { I18n } from '@flowgram.ai/editor';
 import { Select } from '@douyinfe/semi-ui';
 
-import { type JsonSchemaTypeRegistry } from '../manager';
+import { ConditionPresetOp } from '@/components/condition-context/op';
+
+import { type JsonSchemaTypeRegistry } from '../types';
 
 export const booleanRegistry: Partial<JsonSchemaTypeRegistry> = {
   type: 'boolean',
@@ -30,4 +32,18 @@ export const booleanRegistry: Partial<JsonSchemaTypeRegistry> = {
       />
     );
   },
+  conditionRule: {
+    [ConditionPresetOp.EQ]: { type: 'boolean' },
+    [ConditionPresetOp.NEQ]: { type: 'boolean' },
+    [ConditionPresetOp.IS_TRUE]: null,
+    [ConditionPresetOp.IS_FALSE]: null,
+    [ConditionPresetOp.IN]: {
+      type: 'array',
+      items: { type: 'boolean' },
+    },
+    [ConditionPresetOp.NIN]: {
+      type: 'array',
+      items: { type: 'boolean' },
+    },
+  },
 };

package/src/plugins/json-schema-preset/type-definition/date-time.tsx

@@ -6,20 +6,39 @@
 /* eslint-disable react/prop-types */
 import React from 'react';
 
+import { format } from 'date-fns';
+import { type DatePickerProps } from '@douyinfe/semi-ui/lib/es/datePicker';
 import { DatePicker } from '@douyinfe/semi-ui';
 
-import { type JsonSchemaTypeRegistry } from '../manager';
+import { ConditionPresetOp } from '@/components/condition-context/op';
+
+import { type JsonSchemaTypeRegistry } from '../types';
 
 export const dateTimeRegistry: Partial<JsonSchemaTypeRegistry> = {
   type: 'date-time',
-  ConstantRenderer: (props) => (
+  ConstantRenderer: (props: DatePickerProps & { readonly?: boolean }) => (
     <DatePicker
       size="small"
       type="dateTime"
       density="compact"
+      defaultValue={Date.now()}
       style={{ width: '100%', ...(props.style || {}) }}
       disabled={props.readonly}
       {...props}
+      onChange={(date) => {
+        props.onChange?.(format(date as Date, "yyyy-MM-dd'T'HH:mm:ss.SSS'Z'"));
+      }}
+      value={props.value}
     />
   ),
+  conditionRule: {
+    [ConditionPresetOp.EQ]: { type: 'date-time' },
+    [ConditionPresetOp.NEQ]: { type: 'date-time' },
+    [ConditionPresetOp.GT]: { type: 'date-time' },
+    [ConditionPresetOp.GTE]: { type: 'date-time' },
+    [ConditionPresetOp.LT]: { type: 'date-time' },
+    [ConditionPresetOp.LTE]: { type: 'date-time' },
+    [ConditionPresetOp.IS_EMPTY]: null,
+    [ConditionPresetOp.IS_NOT_EMPTY]: null,
+  },
 };

package/src/plugins/json-schema-preset/type-definition/index.tsx

@@ -8,10 +8,12 @@ import { jsonSchemaTypeManager } from '@flowgram.ai/json-schema';
 import { stringRegistry } from './string';
 import { objectRegistry } from './object';
 import { numberRegistry } from './number';
+import { mapRegistry } from './map';
 import { integerRegistry } from './integer';
 import { dateTimeRegistry } from './date-time';
 import { booleanRegistry } from './boolean';
 import { arrayRegistry } from './array';
+import { type JsonSchemaTypeRegistry } from '../types';
 
 export const jsonSchemaTypePreset = [
   stringRegistry,
@@ -20,7 +22,14 @@ export const jsonSchemaTypePreset = [
   integerRegistry,
   booleanRegistry,
   arrayRegistry,
+  mapRegistry,
   dateTimeRegistry,
 ];
 
-jsonSchemaTypePreset.forEach((_type) => jsonSchemaTypeManager.register(_type));
+export const initRegistries = () => {
+  if ((jsonSchemaTypeManager.getTypeByName('string') as JsonSchemaTypeRegistry)?.ConstantRenderer) {
+    return;
+  }
+
+  jsonSchemaTypePreset.forEach((_type) => jsonSchemaTypeManager.register(_type));
+};

package/src/plugins/json-schema-preset/type-definition/integer.tsx

@@ -9,7 +9,9 @@ import React from 'react';
 import { I18n } from '@flowgram.ai/editor';
 import { InputNumber } from '@douyinfe/semi-ui';
 
-import { type JsonSchemaTypeRegistry } from '../manager';
+import { ConditionPresetOp } from '@/components/condition-context/op';
+
+import { type JsonSchemaTypeRegistry } from '../types';
 
 export const integerRegistry: Partial<JsonSchemaTypeRegistry> = {
   type: 'integer',
@@ -22,4 +24,20 @@ export const integerRegistry: Partial<JsonSchemaTypeRegistry> = {
       {...props}
     />
   ),
+  conditionRule: {
+    [ConditionPresetOp.EQ]: { type: 'number' },
+    [ConditionPresetOp.NEQ]: { type: 'number' },
+    [ConditionPresetOp.GT]: { type: 'number' },
+    [ConditionPresetOp.GTE]: { type: 'number' },
+    [ConditionPresetOp.LT]: { type: 'number' },
+    [ConditionPresetOp.LTE]: { type: 'number' },
+    [ConditionPresetOp.IN]: {
+      type: 'array',
+      extra: { weak: true },
+    },
+    [ConditionPresetOp.NIN]: {
+      type: 'array',
+      extra: { weak: true },
+    },
+  },
 };

package/src/plugins/json-schema-preset/type-definition/map.tsx

@@ -0,0 +1,31 @@
+/**
+ * Copyright (c) 2025 Bytedance Ltd. and/or its affiliates
+ * SPDX-License-Identifier: MIT
+ */
+
+/* eslint-disable react/prop-types */
+import React from 'react';
+
+import { I18n } from '@flowgram.ai/editor';
+
+import { ConditionPresetOp } from '@/components/condition-context/op';
+import { JsonCodeEditor } from '@/components/code-editor';
+
+import { type JsonSchemaTypeRegistry } from '../types';
+
+export const mapRegistry: Partial<JsonSchemaTypeRegistry> = {
+  type: 'map',
+  ConstantRenderer: (props) => (
+    <JsonCodeEditor
+      mini
+      value={props.value}
+      onChange={(v) => props.onChange?.(v)}
+      placeholder={I18n.t('Please Input Map')}
+      readonly={props.readonly}
+    />
+  ),
+  conditionRule: {
+    [ConditionPresetOp.IS_EMPTY]: null,
+    [ConditionPresetOp.IS_NOT_EMPTY]: null,
+  },
+};

package/src/plugins/json-schema-preset/type-definition/number.tsx

@@ -9,7 +9,9 @@ import React from 'react';
 import { I18n } from '@flowgram.ai/editor';
 import { InputNumber } from '@douyinfe/semi-ui';
 
-import { type JsonSchemaTypeRegistry } from '../manager';
+import { ConditionPresetOp } from '@/components/condition-context/op';
+
+import { type JsonSchemaTypeRegistry } from '../types';
 
 export const numberRegistry: Partial<JsonSchemaTypeRegistry> = {
   type: 'number',
@@ -22,4 +24,20 @@ export const numberRegistry: Partial<JsonSchemaTypeRegistry> = {
       {...props}
     />
   ),
+  conditionRule: {
+    [ConditionPresetOp.EQ]: { type: 'number' },
+    [ConditionPresetOp.NEQ]: { type: 'number' },
+    [ConditionPresetOp.GT]: { type: 'number' },
+    [ConditionPresetOp.GTE]: { type: 'number' },
+    [ConditionPresetOp.LT]: { type: 'number' },
+    [ConditionPresetOp.LTE]: { type: 'number' },
+    [ConditionPresetOp.IN]: {
+      type: 'array',
+      extra: { weak: true },
+    },
+    [ConditionPresetOp.NIN]: {
+      type: 'array',
+      extra: { weak: true },
+    },
+  },
 };

package/src/plugins/json-schema-preset/type-definition/object.tsx

@@ -8,19 +8,24 @@ import React from 'react';
 
 import { I18n } from '@flowgram.ai/editor';
 
-import { CodeEditorMini } from '@/components/code-editor-mini';
+import { ConditionPresetOp } from '@/components/condition-context/op';
+import { JsonCodeEditor } from '@/components/code-editor';
 
-import { type JsonSchemaTypeRegistry } from '../manager';
+import { type JsonSchemaTypeRegistry } from '../types';
 
 export const objectRegistry: Partial<JsonSchemaTypeRegistry> = {
   type: 'object',
   ConstantRenderer: (props) => (
-    <CodeEditorMini
+    <JsonCodeEditor
+      mini
       value={props.value}
       onChange={(v) => props.onChange?.(v)}
-      languageId="json"
       placeholder={I18n.t('Please Input Object')}
       readonly={props.readonly}
     />
   ),
+  conditionRule: {
+    [ConditionPresetOp.IS_EMPTY]: null,
+    [ConditionPresetOp.IS_NOT_EMPTY]: null,
+  },
 };