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

package/vendor/coze/source/form-extensions/components/value-expression-input/context.ts

@@ -0,0 +1,27 @@
+/*
+ * 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';
+
+// eslint-disable-next-line @typescript-eslint/naming-convention
+const ValueExpressionInputContext = createContext<{
+  testId?: string;
+}>({});
+
+export const useValueExpressionInputContext = () =>
+  useContext(ValueExpressionInputContext);
+
+export { ValueExpressionInputContext };

package/vendor/coze/source/form-extensions/components/value-expression-input/index.module.less

@@ -0,0 +1,144 @@
+/* stylelint-disable declaration-no-important */
+.value-expression-input {
+  overflow: hidden;
+  //flex: 1;
+
+  :global(.semi-input-group) {
+    flex-wrap: nowrap;
+    width: 100%;
+
+    :global(.semi-select) {
+      flex: 0 0 auto;
+      width: 80px;
+    }
+  }
+
+  .type {
+    width: 115px
+  }
+
+  .input {
+    width: 100px;
+  }
+
+
+}
+
+.pointer-events-none {
+  pointer-events: none;
+}
+
+.value-expression-input-wrap {
+  overflow: hidden;
+
+  :global(.semi-input-wrapper) {
+    border: none !important;
+  }
+
+  :global(.semi-input-wrapper:hover) {
+    background: transparent !important;
+  }
+}
+
+.value-expression-input-wrap-new {
+  overflow: hidden;
+  border-radius: 0 var(--coze-6) var(--coze-6) 0;
+
+  :global(.semi-input-wrapper) {
+    border: none !important;
+  }
+
+  :global(.semi-input-wrapper:hover) {
+    background: transparent !important;
+  }
+}
+
+.input-wrapper {
+  @apply flex-1 flex items-center overflow-hidden;
+
+  .literal-value-input {
+    width: 100%;
+    border: none;
+
+    :global {
+      .semi-select:is(.coz-select,.coz-select-tag-popover.semi-popover-wrapper) {
+        border: none;
+      }
+
+      .semi-select-prefix {
+        display: none;
+      }
+    }
+  }
+
+  :global {
+    .semi-select:is(.coz-select,.coz-select-tag-popover.semi-popover-wrapper):hover,
+    .semi-select:is(.coz-select,.coz-select-tag-popover.semi-popover-wrapper):active {
+      background-color: transparent;
+    }
+
+    .semi-input-small {
+      @apply truncate;
+    }
+
+    .cm-placeholder {
+      @apply truncate;
+
+      width: calc(100% - 18px);
+      height: auto !important;
+    }
+  }
+}
+
+.setting-button-wrap {
+  flex: 0;
+  align-self: center;
+  margin-right: 1px;
+
+  &.pos-absolute {
+    position: absolute;
+    right: 0;
+    bottom: 1px;
+  }
+
+  &.self-end {
+    align-self: flex-end;
+  }
+
+  :global(.coz-button.coz-btn-small) {
+    width: 20px;
+    min-width: 20px;
+    height: 20px;
+    padding: 2px;
+  }
+
+}
+
+.variable-type-selector-wrapper {
+  display: flex;
+  align-items: center;
+  align-self: stretch;
+
+  border: 1px solid var(--coz-stroke-plus);
+  border-right: none;
+  border-radius: var(--coze-6) 0 0 var(--coze-6);
+}
+
+.undefined-ref-tag {
+  :global {
+    .semi-tag-close {
+      visibility: hidden;
+
+      .semi-icon.semi-icon-close {
+        color: var(--coz-fg-hglt-yellow);
+      }
+    }
+  }
+
+  &:hover {
+    :global(.semi-tag-close){
+      visibility: visible;
+    }
+  }
+}
+

package/vendor/coze/source/form-extensions/components/value-expression-input/value-expression-input.tsx

@@ -0,0 +1,418 @@
+/*
+ * 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 complexity -- no need to check */
+import React, {
+  useCallback,
+  type CSSProperties,
+  useState,
+  useMemo,
+  useRef,
+} from 'react';
+
+import classnames from 'classnames';
+import { type SchemaObject } from 'ajv';
+import {
+  ValueExpression,
+  ValueExpressionType,
+  ViewVariableType,
+  useNodeTestId,
+  type LiteralExpression,
+} from '@coze-workflow/base';
+import { I18n } from '@coze-arch/i18n';
+import { type SelectProps } from '@coze-arch/bot-semi/Select';
+import { IconCozApply } from '@coze-arch/coze-design/icons';
+import { IconButton } from '@coze-arch/coze-design';
+
+import { useRefInputNode } from '@/hooks/use-ref-input';
+import {
+  LiteralValueInput,
+  type LiteralValueType,
+  type InputType as LiteralInputType,
+} from '@/form-extensions/components/literal-value-input';
+
+import {
+  type RenderDisplayVarName,
+  type CustomFilterVar,
+} from '../tree-variable-selector/types';
+import { FileInput } from '../file-input';
+import { type VariableSelectorProps } from '../../components/tree-variable-selector';
+import { VoiceTag } from './voice/voice-option';
+import useVoice from './voice/use-voice';
+import {
+  type RefTagColor,
+  type RefValueDisplayProps,
+} from './ref-value-display';
+import { ObjectRefValueDisplay } from './object-ref-display';
+import { ValueExpressionInputContext } from './context';
+import { SELECT_POPOVER_MIN_WIDTH, VARIABLE_SELECTOR_STYLE } from './const';
+
+import styles from './index.module.less';
+
+export interface ValueExpressionInputProps {
+  className?: string;
+  testId?: string;
+  value: ValueExpression | undefined;
+  onChange: (value: ValueExpression | undefined) => void;
+  onBlur?: () => void;
+  disabled?: boolean;
+  /**
+   * After specifying inputType, the parameter type is fixed and cannot be switched, but variables that are not of this data type can still be selected, and the running state will perform type conversion
+   */
+  inputType?: LiteralInputType;
+  /**
+   * You can switch between several specified types. When length = 1, the usage is the same as inputType.
+   * Effective only in TypedValueExpressionInput
+   * When inputType is specified at the same time, the union of two props is taken
+   */
+  inputTypes?: LiteralInputType[];
+  /**
+   * Default selected data type
+   */
+  defaultInputType?: LiteralInputType;
+  availableFileTypes?: Array<ViewVariableType>;
+  validateStatus?: SelectProps['validateStatus'];
+  optionFilter?: VariableSelectorProps['optionFilter'];
+  handleDataSource?: VariableSelectorProps['handleDataSource'];
+  invalidContent?: string;
+  style?: CSSProperties;
+  selectStyle?: CSSProperties;
+  literalStyle?: CSSProperties;
+  variableTagStyle?: CSSProperties;
+  readonly?: boolean;
+  /** Prohibited data types */
+  disabledTypes?: Array<ViewVariableType>;
+  literalDisabled?: boolean;
+
+  /** Whether to disable variable reference mode */
+  refDisabled?: boolean;
+  literalConfig?: {
+    min?: number;
+    max?: number;
+    optionsList?: { label: string; value: string }[];
+    /**
+     * Schema configuration of object types for json editor code hints and validation
+     */
+    jsonSchema?: SchemaObject;
+  };
+  showClear?: boolean;
+  customFilterVar?: CustomFilterVar;
+  refTagColor?: RefTagColor;
+  placeholder?: string;
+  inputPlaceholder?: string;
+  renderDisplayVarName?: RenderDisplayVarName;
+  hideSettingIcon?: boolean;
+  hideDeleteIcon?: boolean;
+  enableSelectNode?: boolean;
+  variablesDatasource?: VariableSelectorProps['dataSource'];
+  /**
+   * Forbid type conversion. Switching variable types is not supported when a reference variable (ValueExpression) is selected
+   */
+  forbidTypeCast?: boolean;
+  /* Type restrictions, when the reference type does not meet the restrictions, a warning message is displayed */
+  variableTypeConstraints?: RefValueDisplayProps['variableTypeConstraints'];
+}
+
+export const ValueExpressionInput = ({
+  className,
+  value,
+  onChange,
+  onBlur,
+  disabled,
+  variablesDatasource: variablesDataSource,
+  inputType = ViewVariableType.String,
+  availableFileTypes = [],
+  validateStatus,
+  invalidContent,
+  style,
+  literalStyle,
+  readonly,
+  testId,
+  disabledTypes,
+  optionFilter,
+  literalDisabled = false,
+  refDisabled = false,
+  showClear = false,
+  hideDeleteIcon = false,
+  hideSettingIcon = false,
+  enableSelectNode = false,
+  renderDisplayVarName,
+  customFilterVar,
+  literalConfig = {},
+  refTagColor,
+  placeholder,
+  inputPlaceholder,
+  variableTagStyle,
+  handleDataSource,
+  variableTypeConstraints,
+}: ValueExpressionInputProps) => {
+  const { concatTestId } = useNodeTestId();
+  const containerRef = useRef<HTMLDivElement>(null);
+
+  const onLiteralChange = useCallback(
+    (v?: LiteralValueType): void => {
+      onChange({ type: ValueExpressionType.LITERAL, content: v ?? undefined });
+    },
+    [onChange],
+  );
+
+  const onImageChange = useCallback(
+    v => {
+      onChange({
+        type: ValueExpressionType.LITERAL,
+        content: v?.url || '',
+        rawMeta: { fileName: v?.name, type: inputType },
+      });
+    },
+    [onChange],
+  );
+
+  const [focused, setFocused] = useState(false);
+
+  const handleFocus = () => setFocused(true);
+  const handleBlur = () => {
+    setFocused(false);
+    onBlur?.();
+  };
+
+  const isRefValue =
+    !!value && ValueExpression.isRef(value) && !!value.content?.keyPath;
+
+  const isLiteralJsonValue = useMemo(
+    () =>
+      !!value &&
+      ValueExpression.isLiteral(value) &&
+      ViewVariableType.isJSONInputType(inputType),
+    [value, inputType],
+  );
+
+  const [isUploadingFile, setIsUploadingFile] = useState(false);
+
+  const isLiteralMultiFileValue =
+    ((value &&
+      !ValueExpression.isEmpty(value) &&
+      ValueExpression.isLiteral(value)) ||
+      isUploadingFile) &&
+    ViewVariableType.isArrayType(inputType) &&
+    ViewVariableType.isFileType(inputType) &&
+    inputType !== ViewVariableType.ArrayVoice;
+
+  const isLiteralMultiLineValue =
+    isLiteralJsonValue &&
+    String((value as LiteralExpression)?.content)?.includes('\n');
+
+  const [expandLiteralInput, setExpandLiteralInput] = useState(false);
+
+  const isVoiceValue =
+    ViewVariableType.isVoiceType(inputType) &&
+    !!value &&
+    ValueExpression.isLiteral(value) &&
+    value.content;
+
+  const { renderVariableSelectorExtraOption, selectVoiceModal, voiceSelector } =
+    useVoice({
+      inputType,
+      onChange,
+      onBlur,
+      disabled,
+      validateStatus,
+      value,
+    });
+
+  const renderInputRight = () => {
+    if (ViewVariableType.isVoiceType(inputType)) {
+      return voiceSelector;
+    }
+
+    if (ViewVariableType.isFileType(inputType)) {
+      return (
+        <FileInput
+          value={value as LiteralExpression}
+          inputType={inputType}
+          availableFileTypes={availableFileTypes}
+          onChange={onImageChange}
+          onUploadChange={uploading => setIsUploadingFile(uploading)}
+          onBlur={onBlur}
+        />
+      );
+    }
+
+    return (
+      <LiteralValueInput
+        className={classnames(styles['literal-value-input'], {
+          'pb-[24px]':
+            isLiteralMultiLineValue ||
+            (ViewVariableType.isJSONInputType(inputType) && expandLiteralInput),
+        })}
+        testId={concatTestId(testId ?? '', 'literal-input')}
+        readonly={readonly}
+        disabled={disabled}
+        value={(value as LiteralExpression)?.content}
+        inputType={inputType}
+        onBlur={handleBlur}
+        onFocus={handleFocus}
+        onChange={onLiteralChange}
+        config={{
+          ...literalConfig,
+          onRequestInputExpand: isLiteralJsonValue
+            ? setExpandLiteralInput
+            : undefined,
+        }}
+        style={literalStyle}
+        placeholder={inputPlaceholder ?? I18n.t('workflow_241015_01')}
+      />
+    );
+  };
+
+  const { renderVariableSelect, renderVariableDisplay } = useRefInputNode({
+    value,
+    onChange,
+    onBlur,
+    disabled,
+    variablesDataSource,
+    validateStatus,
+    readonly,
+    testId,
+    disabledTypes,
+    showClear,
+    invalidContent,
+    renderDisplayVarName,
+    customFilterVar,
+    setFocused,
+    style: VARIABLE_SELECTOR_STYLE,
+    refTagColor,
+    hideDeleteIcon,
+    variableTagStyle,
+    optionFilter,
+    renderExtraOption: renderVariableSelectorExtraOption,
+    enableSelectNode,
+    handleDataSource,
+    popoverStyle: containerRef.current
+      ? {
+          minWidth: Math.max(
+            containerRef.current.clientWidth,
+            SELECT_POPOVER_MIN_WIDTH,
+          ),
+        }
+      : undefined,
+    variableTypeConstraints,
+  });
+
+  const renderInput = () => {
+    if (isVoiceValue) {
+      return renderVariableSelect(
+        <div
+          className={classnames(
+            'cursor-pointer w-full overflow-hidden flex items-center pl-0.5',
+          )}
+        >
+          <VoiceTag
+            name={
+              (value as LiteralExpression)?.rawMeta?.fileName || value?.content
+            }
+            onClose={() => onChange?.(undefined)}
+          />
+        </div>,
+      );
+    }
+
+    return isRefValue ? renderVariableDisplay() : renderInputRight();
+  };
+  const finalClassName = useMemo(
+    () =>
+      classnames(
+        className,
+        'flex items-start border border-solid bg-transparent max-w-[100%] py-[1px]',
+        {
+          'semi-input-wrapper-error': validateStatus === 'error',
+          'coz-stroke-plus': validateStatus !== 'error',
+          '!bg-transparent': focused,
+          '!coz-stroke-hglt': focused && validateStatus !== 'error',
+          'pointer-events-none': readonly,
+        },
+        'hover:coz-mg-primary-hovered',
+        isLiteralMultiLineValue || isLiteralMultiFileValue || expandLiteralInput
+          ? 'h-full'
+          : 'h-[24px]',
+        styles['value-expression-input-wrap-new'],
+        'semi-input-wrapper semi-input-wrapper-small',
+      ),
+    [
+      className,
+      validateStatus,
+      focused,
+      readonly,
+      styles,
+      isLiteralMultiLineValue,
+      isLiteralMultiFileValue,
+      expandLiteralInput,
+    ],
+  );
+
+  if (value && ValueExpression.isObjectRef(value)) {
+    return (
+      <div className={finalClassName} style={style} ref={containerRef}>
+        <ObjectRefValueDisplay />
+      </div>
+    );
+  }
+
+  return (
+    <ValueExpressionInputContext.Provider value={{ testId }}>
+      <div className={finalClassName} style={style} ref={containerRef}>
+        <div className="ref-wrapper flex-1 flex w-full h-full items-center overflow-hidden">
+          {/* Determine whether the variable selects the scene */}
+          {!refDisabled && // When reference mode is enabled, check for:
+          literalDisabled && // Scenario 1: Literals are disabled
+          !isRefValue ? ( // Scenario 2: The current value is not a reference type
+            renderVariableSelect(
+              <div className="cursor-pointer w-full h-full overflow-hidden flex items-center px-1">
+                <p className="text-[12px] text-[var(--coz-fg-secondary)] pointer-events-none whitespace-nowrap">
+                  {placeholder || I18n.t('workflow_variable_ref_placeholder')}
+                </p>
+              </div>,
+            )
+          ) : (
+            <div className={styles['input-wrapper']}>{renderInput()}</div>
+          )}
+        </div>
+        {refDisabled || hideSettingIcon ? null : (
+          <div
+            className={classnames(
+              styles['setting-button-wrap'],
+              'flex-none leading-none',
+              {
+                [styles['pos-absolute']]: isLiteralJsonValue,
+                [styles['self-end']]: isLiteralMultiFileValue,
+              },
+            )}
+          >
+            {renderVariableSelect(
+              <IconButton
+                color="secondary"
+                size="small"
+                icon={<IconCozApply className="coz-fg-primary text-sm" />}
+                data-testid={concatTestId(testId ?? '', 'variable-trigger')}
+              ></IconButton>,
+            )}
+          </div>
+        )}
+
+        {selectVoiceModal}
+      </div>
+    </ValueExpressionInputContext.Provider>
+  );
+};

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

@@ -0,0 +1,77 @@
+/*
+ * 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 { ViewVariableType } from '@coze-workflow/base/types';
+import {
+  IconCozNumberBracket,
+  IconCozString,
+  IconCozStringBracket,
+  IconCozBoolean,
+  IconCozBooleanBracket,
+  IconCozBrace,
+  IconCozBraceBracket,
+  IconCozFolder,
+  IconCozFolderBracket,
+  IconCozImage,
+  IconCozImageBracket,
+  IconCozSound,
+  IconCozNumber,
+  IconCozNumberInt,
+  IconCozNumberIntBracket,
+  IconCozClock,
+  IconCozClockBracket,
+} from '@coze-arch/coze-design/icons';
+
+export const VARIABLE_TYPE_ICONS_MAP: Record<ViewVariableType, ReactNode> = {
+  [ViewVariableType.String]: <IconCozString />,
+  [ViewVariableType.Integer]: <IconCozNumberInt />,
+  [ViewVariableType.Boolean]: <IconCozBoolean />,
+  [ViewVariableType.Number]: <IconCozNumber />,
+  [ViewVariableType.Object]: <IconCozBrace />,
+  [ViewVariableType.Image]: <IconCozImage />,
+  [ViewVariableType.File]: <IconCozFolder />,
+  [ViewVariableType.Doc]: <IconCozFolder />,
+  [ViewVariableType.Code]: <IconCozFolder />,
+  [ViewVariableType.Ppt]: <IconCozFolder />,
+  [ViewVariableType.Txt]: <IconCozFolder />,
+  [ViewVariableType.Excel]: <IconCozFolder />,
+  [ViewVariableType.Audio]: <IconCozFolder />,
+  [ViewVariableType.Zip]: <IconCozFolder />,
+  [ViewVariableType.Video]: <IconCozFolder />,
+  [ViewVariableType.Svg]: <IconCozImage />,
+  [ViewVariableType.Voice]: <IconCozSound />,
+  [ViewVariableType.Time]: <IconCozClock />,
+  [ViewVariableType.ArrayString]: <IconCozStringBracket />,
+  [ViewVariableType.ArrayInteger]: <IconCozNumberIntBracket />,
+  [ViewVariableType.ArrayBoolean]: <IconCozBooleanBracket />,
+  [ViewVariableType.ArrayNumber]: <IconCozNumberBracket />,
+  [ViewVariableType.ArrayObject]: <IconCozBraceBracket />,
+  [ViewVariableType.ArrayImage]: <IconCozImageBracket />,
+  [ViewVariableType.ArrayFile]: <IconCozFolderBracket />,
+  [ViewVariableType.ArrayDoc]: <IconCozFolderBracket />,
+  [ViewVariableType.ArrayCode]: <IconCozFolderBracket />,
+  [ViewVariableType.ArrayPpt]: <IconCozFolderBracket />,
+  [ViewVariableType.ArrayTxt]: <IconCozFolderBracket />,
+  [ViewVariableType.ArrayExcel]: <IconCozFolderBracket />,
+  [ViewVariableType.ArrayAudio]: <IconCozFolderBracket />,
+  [ViewVariableType.ArrayZip]: <IconCozFolderBracket />,
+  [ViewVariableType.ArrayVideo]: <IconCozFolderBracket />,
+  [ViewVariableType.ArraySvg]: <IconCozImageBracket />,
+  [ViewVariableType.ArrayVoice]: <IconCozFolderBracket />,
+  [ViewVariableType.ArrayTime]: <IconCozClockBracket />,
+};

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

@@ -0,0 +1,31 @@
+/* stylelint-disable max-nesting-depth */
+.container {
+  // align-items: center;
+  position: relative;
+
+  flex: 0 0 116px;
+  flex-direction: column;
+  align-self: stretch;
+
+  margin-left: 4px;
+
+  .pop-container {
+    align-self: self-start;
+  }
+
+  .param-type {
+    height: 32px;
+    padding: 0 1px;
+  }
+
+  :global(.semi-cascader-selection) {
+    padding-right: 0;
+    padding-left: 4px;
+  }
+}
+
+.dropdwon {
+  :global(.coz-menu.semi-dropdown-menu .semi-dropdown-item-disabled .coz-item-text) {
+    @apply coz-fg-dim;
+  }
+}