@fudanda/workflow 0.0.0-stage → 1.20261015.1-beta.1

package/vendor/coze/source/form-extensions/setters/condition/multi-condition/condition-params-item/operator/index.module.less

@@ -0,0 +1,7 @@
+.container {
+  width: 100%;
+
+  :global(.semi-select-selection-text) {
+    display: flex;
+  }
+}

package/vendor/coze/source/form-extensions/setters/condition/multi-condition/condition-params-item/operator/index.tsx

@@ -0,0 +1,144 @@
+/*
+ * Copyright 2025 coze-dev Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import React, { useMemo } from 'react';
+
+import { ViewVariableType } from '@coze-workflow/base/types';
+import { type ConditionType } from '@coze-workflow/base/api';
+import { useNodeTestId } from '@coze-workflow/base';
+import { I18n } from '@coze-arch/i18n';
+import { Tooltip, Select } from '@coze-arch/coze-design';
+import { type SelectProps } from '@coze-arch/bot-semi/Select';
+
+import {
+  arrayConditionValueMap,
+  booleanConditionValueMap,
+  numberConditionValueMap,
+  intConditionValueMap,
+  objectConditionValueMap,
+  stringConditionValueMap,
+  fileConditionValueMap,
+  timeConditionValueMap,
+} from '../constants';
+import { operatorMap } from '../../constants';
+import convertMap2options from './convert-map2options';
+
+import styles from './index.module.less';
+
+interface OperatorProps {
+  value?: ConditionType;
+  onChange: (v: ConditionType) => void;
+  sourceType?: ViewVariableType;
+  onBlur?: () => void;
+  validateStatus?: SelectProps['validateStatus'];
+  testId: string;
+}
+
+export default function Operator(props: OperatorProps) {
+  const { value, onChange, sourceType, onBlur, validateStatus, testId } = props;
+  const { concatTestId } = useNodeTestId();
+
+  // Change the corresponding options according to the reference variable
+  const options = useMemo(() => {
+    if (sourceType && ViewVariableType.isFileType(sourceType)) {
+      return convertMap2options(fileConditionValueMap, {
+        computedValue: val => Number(val),
+        i18n: true,
+      });
+    }
+
+    switch (sourceType) {
+      case ViewVariableType.ArrayBoolean:
+      case ViewVariableType.ArrayInteger:
+      case ViewVariableType.ArrayNumber:
+      case ViewVariableType.ArrayObject:
+      case ViewVariableType.ArrayString:
+      case ViewVariableType.ArrayTime: {
+        return convertMap2options(arrayConditionValueMap, {
+          computedValue: val => Number(val),
+          i18n: true,
+        });
+      }
+      case ViewVariableType.Object: {
+        return convertMap2options(objectConditionValueMap, {
+          computedValue: val => Number(val),
+          i18n: true,
+        });
+      }
+      case ViewVariableType.Boolean: {
+        return convertMap2options(booleanConditionValueMap, {
+          computedValue: val => Number(val),
+          i18n: true,
+        });
+      }
+      case ViewVariableType.Integer: {
+        return convertMap2options(intConditionValueMap, {
+          computedValue: val => Number(val),
+          i18n: true,
+        });
+      }
+      case ViewVariableType.String: {
+        return convertMap2options(stringConditionValueMap, {
+          computedValue: val => Number(val),
+          i18n: true,
+        });
+      }
+      case ViewVariableType.Number: {
+        return convertMap2options(numberConditionValueMap, {
+          computedValue: val => Number(val),
+          i18n: true,
+        });
+      }
+      case ViewVariableType.Time: {
+        return convertMap2options(timeConditionValueMap, {
+          computedValue: val => Number(val),
+          i18n: true,
+        });
+      }
+      default:
+        return [];
+    }
+  }, [sourceType]);
+
+  const renderSelectedItem = option => (
+    <Tooltip content={option.label}>{operatorMap[option.value]}</Tooltip>
+  );
+
+  return (
+    <Select
+      data-testid={testId}
+      size="small"
+      value={value}
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      onChange={onChange as any}
+      onBlur={onBlur}
+      validateStatus={validateStatus}
+      // optionList={options}
+      // showClear
+      placeholder={I18n.t('workflow_detail_condition_pleaseselect')}
+      emptyContent={I18n.t('workflow_detail_node_nodata')}
+      className={styles.container}
+      renderSelectedItem={renderSelectedItem}
+    >
+      {options.map(option => (
+        <Select.Option
+          {...option}
+          data-testid={concatTestId(testId, `${option.value}`)}
+        />
+      ))}
+    </Select>
+  );
+}

package/vendor/coze/source/form-extensions/setters/condition/multi-condition/condition-params-item/value-expression-with-state/index.tsx

@@ -0,0 +1,69 @@
+/*
+ * Copyright 2025 coze-dev Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/* eslint-disable @coze-arch/no-deep-relative-import */
+/**
+ * Interactively, when the operator is selected, when the rvalue is switched between disabled and disabled, it needs to keep the type the same as last time, so here is a state store
+ */
+import React, { type FC, useEffect, useState } from 'react';
+
+import { ConditionType } from '@coze-arch/idl/workflow_api';
+import { Input } from '@coze-arch/coze-design';
+
+import {
+  ValueExpressionInput,
+  type ValueExpressionInputProps,
+} from '../../../../../components/value-expression-input';
+
+export const ValueExpressionWithState: FC<
+  ValueExpressionInputProps & {
+    operator?: ConditionType;
+  }
+> = props => {
+  const { value, operator } = props;
+
+  const [valueType, setValueType] = useState(value?.type);
+
+  useEffect(() => {
+    if (value?.type) {
+      setValueType(value?.type);
+    }
+  }, [value?.type]);
+
+  if (
+    operator &&
+    [ConditionType.Null, ConditionType.NotNull].includes(operator)
+  ) {
+    return <Input disabled value="empty" size="small" />;
+  }
+  if (
+    operator &&
+    [ConditionType.True, ConditionType.False].includes(operator)
+  ) {
+    if (operator === ConditionType.True) {
+      return <Input disabled value="true" size="small" />;
+    } else {
+      return <Input disabled value="false" size="small" />;
+    }
+  }
+
+  return (
+    <ValueExpressionInput
+      {...props}
+      value={value ?? (valueType ? { type: valueType } : undefined)}
+    />
+  );
+};

package/vendor/coze/source/form-extensions/setters/condition/multi-condition/context.ts

@@ -0,0 +1,36 @@
+/*
+ * Copyright 2025 coze-dev Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { createContext, useContext } from 'react';
+
+import { type FlowNodeEntity } from '@flowgram-adapter/free-layout-editor';
+
+interface ConditionContext {
+  flowNodeEntity: FlowNodeEntity | null;
+  readonly: boolean;
+  expanded?: boolean;
+  setterPath: string;
+}
+// eslint-disable-next-line @typescript-eslint/naming-convention -- react context
+const ConditionContext = createContext<ConditionContext>({
+  flowNodeEntity: null,
+  readonly: false,
+  setterPath: '',
+});
+export const useConditionContext = () => useContext(ConditionContext);
+
+// eslint-disable-next-line @typescript-eslint/naming-convention -- react context
+export const ConditionContextProvider = ConditionContext.Provider;

package/vendor/coze/source/form-extensions/setters/condition/multi-condition/draggable/condition-branch-preview.tsx

@@ -0,0 +1,44 @@
+/*
+ * Copyright 2025 coze-dev Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { type FC } from 'react';
+
+import { IconHandle } from '@douyinfe/semi-icons';
+
+import {
+  type ConditionBranchProps,
+  ConditionBranch,
+} from '../condition-branch';
+
+type DraggableConditionBranchPreviewProps = Pick<
+  ConditionBranchProps,
+  'priority' | 'prefixName' | 'portId' | 'branch'
+> & {
+  index: number;
+};
+
+export const DraggableConditionBranchPreview: FC<
+  DraggableConditionBranchPreviewProps
+> = props => (
+  <div className="opacity-100 z-50">
+    <ConditionBranch
+      {...props}
+      titleIcon={
+        <IconHandle className="cursor-move pr-1" style={{ color: '#aaa' }} />
+      }
+    />
+  </div>
+);

package/vendor/coze/source/form-extensions/setters/condition/multi-condition/draggable/condition-branch.tsx

@@ -0,0 +1,152 @@
+/*
+ * Copyright 2025 coze-dev Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { getEmptyImage } from 'react-dnd-html5-backend';
+import { useDrop, useDrag } from 'react-dnd';
+import { type FC, useRef, useEffect } from 'react';
+
+import type { Identifier } from 'dnd-core';
+import classNames from 'classnames';
+import { IconHandle } from '@douyinfe/semi-icons';
+
+import {
+  ConditionBranch,
+  type ConditionBranchProps,
+} from '../condition-branch';
+import { ConditionBranchBlock } from './types';
+
+interface DraggableConditionBranchProps extends ConditionBranchProps {
+  index: number;
+  showDraggable?: boolean;
+  onDragStart: (uid: number) => void;
+  onDragEnd?: (startIndex: number, endIndex: number) => void;
+  onMoveBranch: (dragIndex: number, hoverIndex: number) => void;
+}
+
+interface DragItem {
+  index: number;
+  name: string;
+}
+
+export const DraggableConditionBranch: FC<
+  DraggableConditionBranchProps
+> = props => {
+  const { branch, index, onDragStart, onDragEnd, onMoveBranch, showDraggable } =
+    props;
+  const ref = useRef<HTMLDivElement>(null);
+
+  const [{ isDragging }, drag, preview] = useDrag(
+    () => ({
+      type: ConditionBranchBlock,
+      item: () => {
+        onDragStart?.(branch.uid);
+        return {
+          type: ConditionBranchBlock,
+          index,
+          startIndex: index,
+          uid: branch.uid,
+        };
+      },
+      end: (item, monitor) => {
+        onDragEnd?.(item.startIndex, index);
+      },
+      collect: monitor => ({
+        isDragging: monitor.isDragging(),
+      }),
+    }),
+    [branch, onDragEnd, index],
+  );
+
+  const [, drop] = useDrop<
+    DragItem,
+    // eslint-disable-next-line @typescript-eslint/no-invalid-void-type
+    void,
+    { handlerId: Identifier | null }
+  >(
+    () => ({
+      accept: ConditionBranchBlock,
+      hover(item, monitor) {
+        if (!ref.current || !monitor) {
+          return;
+        }
+        const dragIndex = item.index;
+        const hoverIndex = index;
+
+        // If the drag and hover items are the same, do nothing
+        if (dragIndex === hoverIndex) {
+          return;
+        }
+
+        // Get the bounding rectangle of the hover item
+        const hoverBoundingRect = ref.current?.getBoundingClientRect();
+        // Calculate the vertical midpoint of the hover term
+        const hoverMiddleY =
+          (hoverBoundingRect.bottom - hoverBoundingRect.top) / 2;
+        // Get the current mouse pointer position
+        const clientOffset = monitor.getClientOffset();
+        if (!clientOffset) {
+          return;
+        }
+        // Calculate the distance of the pointer from the top of the hovering item
+        const hoverClientY = clientOffset.y - hoverBoundingRect.top;
+
+        // Drag down
+        if (dragIndex < hoverIndex && hoverClientY < hoverMiddleY) {
+          return;
+        }
+        // Drag up
+        if (dragIndex > hoverIndex && hoverClientY > hoverMiddleY) {
+          return;
+        }
+        // Perform a move operation
+        onMoveBranch(dragIndex, hoverIndex);
+        // Update the index of the drag item
+        item.index = hoverIndex;
+      },
+    }),
+    [branch, onMoveBranch, index],
+  );
+
+  useEffect(() => {
+    preview(getEmptyImage(), { captureDraggingState: true });
+  }, []);
+
+  drag(ref);
+
+  return (
+    <div
+      className={classNames({
+        ['opacity-0']: isDragging,
+        ['opacity-100']: !isDragging,
+      })}
+      ref={drop}
+    >
+      <ConditionBranch
+        {...props}
+        titleIcon={
+          showDraggable ? (
+            <IconHandle
+              ref={ref}
+              data-disable-node-drag="true"
+              className="cursor-move pr-1"
+              style={{ color: '#aaa' }}
+            />
+          ) : null
+        }
+      />
+    </div>
+  );
+};

package/vendor/coze/source/form-extensions/setters/condition/multi-condition/draggable/container.tsx

@@ -0,0 +1,19 @@
+/*
+ * Copyright 2025 coze-dev Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+export const ConditionDraggableContainer = props => (
+  <div className="relative">{props.children}</div>
+);

package/vendor/coze/source/form-extensions/setters/condition/multi-condition/draggable/custom-drag-layer.tsx

@@ -0,0 +1,117 @@
+/*
+ * Copyright 2025 coze-dev Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { useDragLayer } from 'react-dnd';
+import { useRef, useEffect, type FC, type ReactNode } from 'react';
+
+import { usePlayground } from '@flowgram-adapter/free-layout-editor';
+import { type Disposable } from '@flowgram-adapter/common';
+
+import { ConditionBranchBlock } from './types';
+
+interface CustomDragLayerProps {
+  preview: ReactNode;
+}
+
+export const CustomDragLayer: FC<CustomDragLayerProps> = props => {
+  const { preview } = props;
+  const layerRef = useRef<HTMLDivElement>(null);
+  const zoomRef = useRef<number>();
+
+  const playground = usePlayground();
+
+  useEffect(() => {
+    let dispose: Disposable;
+    if (playground) {
+      dispose = playground.onZoom(z => {
+        zoomRef.current = z;
+      });
+    }
+    return () => {
+      if (dispose) {
+        dispose.dispose();
+      }
+    };
+  }, []);
+
+  const { itemType, isDragging, initialOffset, currentOffset } = useDragLayer(
+    monitor => ({
+      item: monitor.getItem(),
+      itemType: monitor.getItemType(),
+      isDragging: monitor.isDragging(),
+      initialOffset: monitor.getInitialSourceClientOffset(),
+      currentOffset: monitor.getSourceClientOffset(),
+    }),
+  );
+  function renderItem() {
+    switch (itemType) {
+      case ConditionBranchBlock:
+        return preview;
+      default:
+        return null;
+    }
+  }
+
+  function getItemStyles() {
+    if (
+      !initialOffset ||
+      !currentOffset ||
+      !layerRef.current
+      // !zoomRef.current
+    ) {
+      return {
+        display: 'none',
+      };
+    }
+    const layerOffset = layerRef.current.getBoundingClientRect();
+
+    let { x, y } = currentOffset;
+
+    // In the new interaction of 2.0, setters are rendered in the right panel and are not affected by canvas scaling, so if it is 2.0, the scaling ratio defaults to 1.
+    const zoomRatio = 1;
+
+    x -= layerOffset.x;
+    y -= layerOffset.y;
+    const transform = `translate(${x / zoomRatio}px, ${y / zoomRatio}px)`;
+
+    return {
+      transform,
+      WebkitTransform: transform,
+    };
+  }
+
+  if (!isDragging) {
+    return null;
+  }
+
+  return (
+    <div
+      style={{
+        position: 'absolute',
+        pointerEvents: 'none',
+        scale: 1,
+        zIndex: 100,
+        left: 0,
+        top: 0,
+        width: '100%',
+        height: '100%',
+      }}
+      ref={layerRef}
+    >
+      <div style={getItemStyles()}>{renderItem()}</div>
+    </div>
+  );
+};

package/vendor/coze/source/form-extensions/setters/condition/multi-condition/draggable/types.ts

@@ -0,0 +1,18 @@
+/*
+ * Copyright 2025 coze-dev Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// eslint-disable-next-line @typescript-eslint/naming-convention
+export const ConditionBranchBlock = 'ConditionBranch';

package/vendor/coze/source/form-extensions/setters/condition/multi-condition/types.ts

@@ -0,0 +1,58 @@
+/*
+ * Copyright 2025 coze-dev Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import {
+  type RefExpression,
+  type ValueExpression,
+} from '@coze-workflow/base/types';
+import { type ConditionType } from '@coze-workflow/base/api';
+
+import { Logic } from './constants';
+
+export interface ConditionItem {
+  /**
+   * Expression left data
+   *  */
+  left?: RefExpression;
+  /**
+   * Expression Operators
+   */
+  operator?: ConditionType;
+  /**
+   * Expression right data
+   */
+
+  right?: ValueExpression;
+}
+
+export { Logic };
+
+export interface ConditionBranchValue {
+  condition: {
+    // And or or operations, corresponding to the logic of the backend data
+    logic: Logic;
+    conditions: ConditionItem[];
+  };
+}
+
+export interface ConditionBranchValueWithUid extends ConditionBranchValue {
+  uid: number;
+}
+
+export type ConditionValue = Array<ConditionBranchValue>;
+export type ConditionValueWithUid = Array<ConditionBranchValueWithUid>;
+
+export type ElementOfRecord<T> = T[keyof T];