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

package/vendor/coze/source/form-extensions/components/variable-type-selector/index.tsx

@@ -0,0 +1,17 @@
+/*
+ * 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 { VariableTypeSelector } from './variable-type-selector';

package/vendor/coze/source/form-extensions/components/variable-type-selector/utils.tsx

@@ -0,0 +1,298 @@
+/*
+ * 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 ReactNode } from 'react';
+
+import { VARIABLE_TYPE_ALIAS_MAP, ViewVariableType } from '@coze-workflow/base';
+import { getFlags } from '@coze-arch/bot-flags';
+
+import { ObjectLikeTypes } from '@/form-extensions/components/output-tree/components/custom-tree-node/constants';
+
+const LEVEL_LIMIT = 3;
+
+export const generateVariableOption = ({
+  type,
+  label,
+  display,
+  parentPath,
+}: {
+  type: ViewVariableType;
+  label?: string;
+  display?: string;
+  parentPath?: Array<number | string>;
+}) => {
+  let targetLabel: string;
+  if (label) {
+    targetLabel = label;
+  } else if (ViewVariableType.isArrayType(type)) {
+    const subType = ViewVariableType.getArraySubType(type);
+    targetLabel = VARIABLE_TYPE_ALIAS_MAP[subType];
+  } else {
+    targetLabel = VARIABLE_TYPE_ALIAS_MAP[type];
+  }
+  return {
+    value: Number(type),
+    label: targetLabel,
+    display: display || label || VARIABLE_TYPE_ALIAS_MAP[type],
+    path: [...(parentPath ?? []), type],
+  };
+};
+
+export const VARIABLE_TYPE_DIVIDER = 'divider';
+
+export type VariableTypeOption =
+  | {
+      // Value of type, possibly empty when not a leaf node
+      value: number | string;
+      // The display name of the option
+      label: ReactNode;
+      // Echoed display name
+      display?: string;
+      // Is the type disabled?
+      disabled?: boolean;
+      // subtype
+      children?: VariableTypeOption[];
+      path?: Array<number | string>;
+    }
+  | typeof VARIABLE_TYPE_DIVIDER;
+
+const getFileChildren = (
+  parentPath: Array<number | string>,
+): VariableTypeOption[] => {
+  const FLAGS = getFlags();
+
+  const result: Array<VariableTypeOption | null> = [
+    generateVariableOption({
+      type: ViewVariableType.File,
+      label: 'Default',
+      display: 'File',
+      parentPath,
+    }),
+    VARIABLE_TYPE_DIVIDER,
+    generateVariableOption({ type: ViewVariableType.Image, parentPath }),
+    generateVariableOption({ type: ViewVariableType.Svg, parentPath }),
+    VARIABLE_TYPE_DIVIDER,
+    generateVariableOption({ type: ViewVariableType.Audio, parentPath }),
+    generateVariableOption({ type: ViewVariableType.Video, parentPath }),
+    // 1. Whether the auto start node is enabled to support the timbre field ability
+    // 2. Whether the voice resource function is turned on
+    FLAGS['bot.automation.start_support_voice'] &&
+    FLAGS['bot.studio.library_voice_resource']
+      ? generateVariableOption({ type: ViewVariableType.Voice })
+      : null,
+    VARIABLE_TYPE_DIVIDER,
+    generateVariableOption({ type: ViewVariableType.Doc, parentPath }),
+    generateVariableOption({ type: ViewVariableType.Ppt, parentPath }),
+    generateVariableOption({ type: ViewVariableType.Excel, parentPath }),
+    generateVariableOption({ type: ViewVariableType.Txt, parentPath }),
+    generateVariableOption({ type: ViewVariableType.Code, parentPath }),
+    VARIABLE_TYPE_DIVIDER,
+    generateVariableOption({ type: ViewVariableType.Zip, parentPath }),
+  ];
+
+  return result.filter((v): v is VariableTypeOption => Boolean(v));
+};
+
+const getArrayChildren = (
+  parentPath: Array<number | string>,
+): Array<VariableTypeOption> => {
+  const fileArrayValue = '$file-array-category';
+  const fileArrayParentPath = parentPath.concat(fileArrayValue);
+  return [
+    generateVariableOption({ type: ViewVariableType.ArrayString, parentPath }),
+    generateVariableOption({ type: ViewVariableType.ArrayInteger, parentPath }),
+    generateVariableOption({ type: ViewVariableType.ArrayNumber, parentPath }),
+    generateVariableOption({ type: ViewVariableType.ArrayBoolean, parentPath }),
+    generateVariableOption({ type: ViewVariableType.ArrayTime, parentPath }),
+    generateVariableOption({ type: ViewVariableType.ArrayObject, parentPath }),
+    {
+      value: fileArrayValue,
+      label: 'File',
+      children: [
+        generateVariableOption({
+          type: ViewVariableType.ArrayFile,
+          label: 'Default',
+          display: 'Array<File>',
+          parentPath: fileArrayParentPath,
+        }),
+        VARIABLE_TYPE_DIVIDER,
+        generateVariableOption({
+          type: ViewVariableType.ArrayImage,
+          parentPath: fileArrayParentPath,
+        }),
+        generateVariableOption({
+          type: ViewVariableType.ArraySvg,
+          parentPath: fileArrayParentPath,
+        }),
+        VARIABLE_TYPE_DIVIDER,
+        generateVariableOption({
+          type: ViewVariableType.ArrayAudio,
+          parentPath: fileArrayParentPath,
+        }),
+        generateVariableOption({
+          type: ViewVariableType.ArrayVideo,
+          parentPath: fileArrayParentPath,
+        }),
+        VARIABLE_TYPE_DIVIDER,
+        generateVariableOption({
+          type: ViewVariableType.ArrayDoc,
+          parentPath: fileArrayParentPath,
+        }),
+        generateVariableOption({
+          type: ViewVariableType.ArrayPpt,
+          parentPath: fileArrayParentPath,
+        }),
+        generateVariableOption({
+          type: ViewVariableType.ArrayExcel,
+          parentPath: fileArrayParentPath,
+        }),
+        generateVariableOption({
+          type: ViewVariableType.ArrayTxt,
+          parentPath: fileArrayParentPath,
+        }),
+        generateVariableOption({
+          type: ViewVariableType.ArrayCode,
+          parentPath: fileArrayParentPath,
+        }),
+        VARIABLE_TYPE_DIVIDER,
+        generateVariableOption({
+          type: ViewVariableType.ArrayZip,
+          parentPath: fileArrayParentPath,
+        }),
+      ],
+    },
+  ];
+};
+
+export const allVariableTypeList: Array<VariableTypeOption> = [
+  generateVariableOption({ type: ViewVariableType.String }),
+  generateVariableOption({ type: ViewVariableType.Integer }),
+  generateVariableOption({ type: ViewVariableType.Number }),
+  generateVariableOption({ type: ViewVariableType.Boolean }),
+  generateVariableOption({ type: ViewVariableType.Time }),
+  generateVariableOption({ type: ViewVariableType.Object }),
+  {
+    value: '$array-category',
+    label: 'Array',
+    children: getArrayChildren(['$array-category']),
+  },
+  {
+    value: '$file-category',
+    label: 'File',
+    children: getFileChildren(['$file-category']),
+  },
+];
+
+const filterTypes = (
+  list: Array<VariableTypeOption>,
+  options?: VariableListOptions,
+): VariableTypeOption[] => {
+  const { disabledTypes = [], hiddenTypes = [], level } = options || {};
+
+  const result: VariableTypeOption[] = list.reduce((pre, cur) => {
+    if (cur === VARIABLE_TYPE_DIVIDER) {
+      return [...pre, VARIABLE_TYPE_DIVIDER];
+    }
+    const newOption = { ...cur };
+
+    if (newOption.children) {
+      newOption.children = filterTypes(newOption.children, options);
+    }
+
+    /**
+     * 1. Hide when hitting hideType
+     * 2. There are children, but when the children are all hidden, the parent is also hidden
+     * 3. File types do not allow nesting
+     */
+    const hidden =
+      hiddenTypes.some(type => type === newOption.value) ||
+      newOption.children?.length === 0 ||
+      (level &&
+        level >= 1 &&
+        ViewVariableType.isFileType(newOption.value as ViewVariableType));
+
+    /**
+     * 1. Disable when hitting disabledTypes
+     * 2. Disable the ObjectLike type when the level limit is reached to avoid too deep nesting
+     */
+    const disabled = Boolean(
+      disabledTypes?.includes(Number(newOption.value)) ||
+        (level &&
+          level >= LEVEL_LIMIT &&
+          ObjectLikeTypes.includes(Number(newOption.value))),
+    );
+
+    if (hidden) {
+      return pre;
+    }
+
+    return [
+      ...pre,
+      {
+        ...newOption,
+        disabled,
+      },
+    ];
+  }, [] as Array<VariableTypeOption>);
+  // If the separator is at the beginning and end, remove it
+  while (result[0] === VARIABLE_TYPE_DIVIDER) {
+    result.shift();
+  }
+  while (result[result.length - 1] === VARIABLE_TYPE_DIVIDER) {
+    result.pop();
+  }
+  return result;
+};
+
+interface VariableListOptions {
+  disabledTypes?: Array<ViewVariableType>;
+  hiddenTypes?: Array<ViewVariableType>;
+  level?: number;
+}
+
+export const getVariableTypeList = options =>
+  filterTypes(allVariableTypeList, options);
+
+/**
+ * Get the path of the type in the options list
+ */
+export const getSelectedValuePath = (
+  originalVal: ViewVariableType,
+  list: Array<VariableTypeOption>,
+  path: Array<string | number> = [],
+) => {
+  let valuePath = [...path];
+  list.forEach(item => {
+    if (item === VARIABLE_TYPE_DIVIDER) {
+      return;
+    }
+    if (item.children) {
+      const childPath = getSelectedValuePath(originalVal, item.children, [
+        ...valuePath,
+        item.value,
+      ]);
+      if (childPath[childPath.length - 1] === originalVal) {
+        valuePath = childPath;
+        return;
+      }
+    } else if (item.value === originalVal) {
+      valuePath.push(originalVal);
+      return;
+    }
+  });
+
+  return valuePath;
+};

package/vendor/coze/source/form-extensions/components/variable-type-selector/variable-type-selector.tsx

@@ -0,0 +1,235 @@
+/*
+ * 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,
+  type CSSProperties,
+  type PropsWithChildren,
+} from 'react';
+
+import classNames from 'classnames';
+import {
+  VARIABLE_TYPE_ALIAS_MAP,
+  type ViewVariableType,
+} from '@coze-workflow/base';
+import { I18n } from '@coze-arch/i18n';
+import {
+  IconCozArrowDown,
+  IconCozArrowRight,
+  IconCozCheckMarkFill,
+} from '@coze-arch/coze-design/icons';
+import {
+  Dropdown,
+  Tooltip,
+  type DropdownProps,
+  type SelectProps,
+  Typography,
+} from '@coze-arch/coze-design';
+
+import {
+  allVariableTypeList,
+  getSelectedValuePath,
+  getVariableTypeList,
+  VARIABLE_TYPE_DIVIDER,
+  type VariableTypeOption,
+} from './utils';
+import { VARIABLE_TYPE_ICONS_MAP } from './constants';
+
+import styles from './index.module.less';
+
+export interface VariableTypeSelectorProps {
+  value: ViewVariableType;
+  level?: number;
+  onChange?: SelectProps['onChange'];
+  readonly?: boolean;
+  disabled?: boolean;
+  /** Types not supported */
+  disabledTypes?: ViewVariableType[];
+  /** hidden type */
+  hiddenTypes?: ViewVariableType[];
+  validateStatus?: SelectProps['validateStatus'];
+  onBlur?: () => void;
+  onFocus?: () => void;
+  testId?: string;
+  disableDropdown?: boolean;
+  contentClassName?: string;
+  contentStyle?: CSSProperties;
+  refVariableType?: ViewVariableType;
+}
+
+export function VariableTypeSelector({
+  value,
+  onChange,
+  onFocus,
+  onBlur,
+  level,
+  readonly,
+  disabled,
+  disabledTypes = [],
+  hiddenTypes = [],
+  validateStatus,
+  testId,
+  contentClassName,
+  contentStyle,
+  disableDropdown,
+  children,
+  refVariableType,
+}: PropsWithChildren<VariableTypeSelectorProps>) {
+  const optionList = useMemo(
+    () => getVariableTypeList({ disabledTypes, hiddenTypes, level }),
+    [disabledTypes, hiddenTypes, level],
+  );
+
+  const selectedValuePath = useMemo(
+    () => getSelectedValuePath(value, allVariableTypeList),
+    [value],
+  );
+
+  const handleSelect = (val: ViewVariableType) => {
+    onChange?.(val);
+  };
+
+  const warningMessage = useMemo(() => {
+    if (disableDropdown || !refVariableType || refVariableType === value) {
+      return '';
+    }
+    return I18n.t('workflow_refer_var_type_same', {
+      type: VARIABLE_TYPE_ALIAS_MAP[refVariableType],
+    });
+  }, [refVariableType, value, disableDropdown]);
+
+  const renderContent = (selected: Array<string | number>) =>
+    children ? (
+      children
+    ) : (
+      <div className={contentClassName} style={contentStyle}>
+        <Tooltip
+          style={{
+            pointerEvents: 'none',
+            transform: warningMessage ? 'translateX(-8px)' : 'none',
+          }}
+          content={
+            <div className="flex flex-col items-start gap-[6px]">
+              <Typography.Text size="small" weight={500}>
+                {VARIABLE_TYPE_ALIAS_MAP[selected[selected.length - 1]]}
+              </Typography.Text>
+              {warningMessage ? (
+                <Typography.Text size="small" className="coz-fg-hglt-yellow">
+                  {warningMessage}
+                </Typography.Text>
+              ) : null}
+            </div>
+          }
+        >
+          <div
+            data-testid={testId}
+            className={classNames(
+              `flex items-center gap-0.5 p-[1px] h-full ${
+                readonly || disabled || disableDropdown
+                  ? 'cursor-auto'
+                  : 'cursor-pointer'
+              }`,
+              {
+                'hover:coz-mg-secondary-hovered active:coz-mg-secondary-pressed':
+                  !disableDropdown && !disabled && !readonly,
+              },
+            )}
+          >
+            <span
+              className={classNames('coz-fg-secondary p-[2px] flex', {
+                'coz-mg-hglt-secondary-yellow rounded-[4px]':
+                  Boolean(warningMessage),
+              })}
+            >
+              {VARIABLE_TYPE_ICONS_MAP[selected[selected.length - 1]]}
+            </span>
+            {disableDropdown ? null : (
+              <IconCozArrowDown className="coz-fg-secondary" />
+            )}
+          </div>
+        </Tooltip>
+      </div>
+    );
+
+  const renderDropdown = (
+    menus: VariableTypeOption[],
+    content: React.ReactNode,
+    props: Pick<DropdownProps, 'trigger' | 'position'>,
+  ) => (
+    <Dropdown
+      {...props}
+      className={styles.dropdwon}
+      clickToHide={true}
+      onVisibleChange={visible => {
+        visible ? onFocus?.() : onBlur?.();
+      }}
+      motion={false}
+      render={
+        <Dropdown.Menu
+          className="min-w-[160px]"
+          selectedKeys={[selectedValuePath.join('/')]}
+        >
+          {menus.map(menu => {
+            if (menu === VARIABLE_TYPE_DIVIDER) {
+              return <Dropdown.Divider />;
+            }
+            const itemContent = (
+              <Dropdown.Item
+                showTick={true}
+                icon={<IconCozCheckMarkFill className="coz-fg-hglt" />}
+                itemKey={menu.path?.join('/')}
+                disabled={menu.disabled}
+                onClick={() => {
+                  if (menu.children?.length) {
+                    return;
+                  }
+                  handleSelect(menu.value as ViewVariableType);
+                }}
+              >
+                {menu.children?.length ? (
+                  <div className="flex items-center justify-between w-[112px]">
+                    {menu.label}
+                    <IconCozArrowRight />
+                  </div>
+                ) : (
+                  menu.label
+                )}
+              </Dropdown.Item>
+            );
+            if (menu.children?.length) {
+              return renderDropdown(menu.children, itemContent, {
+                trigger: 'hover',
+                position: 'leftTop',
+              });
+            }
+            return itemContent;
+          })}
+        </Dropdown.Menu>
+      }
+    >
+      {content}
+    </Dropdown>
+  );
+
+  if (disableDropdown || disabled || readonly) {
+    return renderContent(selectedValuePath);
+  }
+
+  return renderDropdown(optionList, renderContent(selectedValuePath), {
+    trigger: 'click',
+    position: 'bottomLeft',
+  });
+}

package/vendor/coze/source/form-extensions/components/variable-type-tag/index.tsx

@@ -0,0 +1,54 @@
+/*
+ * 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, type PropsWithChildren } from 'react';
+
+import classNames from 'classnames';
+import { type WithCustomStyle } from '@coze-workflow/base/types';
+
+export const VariableTypeTag: FC<
+  PropsWithChildren<
+    WithCustomStyle<{
+      size?: 'xs' | 'default';
+    }>
+  >
+> = props => {
+  const { children, className, size = 'default' } = props;
+  return (
+    <div
+      className={classNames(
+        {
+          'py-[1px] px-[3px] ml-1 rounded-[4px] h-4': size === 'xs',
+          'py-0.5 px-2 rounded-[6px] ml-2': size === 'default',
+        },
+        'shrink-0 flex items-center coz-mg-primary',
+        className,
+      )}
+    >
+      <span
+        className={classNames(
+          {
+            'text-mini': size === 'xs',
+            'text-xs': size === 'default',
+          },
+          'coz-fg-primary block',
+        )}
+      >
+        {children}
+      </span>
+    </div>
+  );
+};

package/vendor/coze/source/form-extensions/setters/condition/multi-condition/condition-branch.module.less

@@ -0,0 +1,9 @@
+.font-normal {
+  font-size: 14px;
+  font-weight: 600;
+  font-style: normal;
+  line-height: 22px;
+  color: var(--light-usage-text-color-text-0, #1c1d23);
+
+  /* 157.143% */
+}