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

package/vendor/coze/source/external/features/log/components/data-viewer/hooks/use-data-viewer-store.ts

@@ -0,0 +1,29 @@
+/*
+ * 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 { useContext } from 'react';
+
+import { DataViewerContext, type DataViewerState } from '../context';
+
+export const useDataViewerStore = <T>(selector: (s: DataViewerState) => T) => {
+  const store = useContext(DataViewerContext);
+
+  if (!store) {
+    throw new Error('cant not found DataViewerContext');
+  }
+
+  return store(selector);
+};

package/vendor/coze/source/external/features/log/components/data-viewer/hooks/use-expand.ts

@@ -0,0 +1,35 @@
+/*
+ * 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 { useMemoizedFn } from 'ahooks';
+
+import { useDataViewerStore } from './use-data-viewer-store';
+
+export const useExpand = (path: string) => {
+  const { expand, setExpand } = useDataViewerStore(store => ({
+    expand: !!store.expand?.[path],
+    setExpand: store.setExpand,
+  }));
+
+  const toggle = useMemoizedFn(() => {
+    setExpand(path, !expand);
+  });
+
+  return {
+    expand,
+    toggle,
+  };
+};

package/vendor/coze/source/external/features/log/components/data-viewer/hooks/use-value.tsx

@@ -0,0 +1,66 @@
+/*
+ * 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 { useMemo } from 'react';
+
+import { isBoolean, isNil, isNumber, isObject, isString } from 'lodash-es';
+
+import { isBigNumber, bigNumberToString } from '../utils/big-number';
+import { type Field } from '../types';
+import { LogValueStyleType } from '../constants';
+
+export const useValue = (value: Field['value']) => {
+  const v = useMemo(() => {
+    if (isNil(value)) {
+      return {
+        value: 'null',
+        type: LogValueStyleType.Default,
+      };
+    } else if (isObject(value)) {
+      // Large number Returns the numeric type, and the value is a string.
+      if (isBigNumber(value)) {
+        return {
+          value: bigNumberToString(value),
+          type: LogValueStyleType.Number,
+        };
+      }
+      return {
+        value: '',
+        type: LogValueStyleType.Default,
+      };
+    } else if (isBoolean(value)) {
+      return {
+        value: value.toString(),
+        type: LogValueStyleType.Boolean,
+      };
+    } else if (isString(value)) {
+      return {
+        value: JSON.stringify(value),
+        type: LogValueStyleType.Default,
+      };
+    } else if (isNumber(value)) {
+      return {
+        value,
+        type: LogValueStyleType.Number,
+      };
+    }
+    return {
+      value,
+      type: LogValueStyleType.Default,
+    };
+  }, [value]);
+  return v;
+};

package/vendor/coze/source/external/features/log/components/data-viewer/index.tsx

@@ -0,0 +1,21 @@
+/*
+ * 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 type { JsonValueType } from './types';
+
+export { DataViewer, DataViewerProps } from './data-viewer';
+
+export { LogObjSpecialKey, LogValueStyleType } from './constants';

package/vendor/coze/source/external/features/log/components/data-viewer/json-field/index.tsx

@@ -0,0 +1,186 @@
+/*
+ * 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, { useEffect, useMemo } from 'react';
+
+import { isString, last } from 'lodash-es';
+import cls from 'classnames';
+import { I18n } from '@coze-arch/i18n';
+import { IconCozArrowRight, IconCozEye } from '@coze-arch/coze-design/icons';
+import { Button } from '@coze-arch/coze-design';
+
+import { type Field } from '../types';
+import { useExpand, useValue } from '../hooks';
+import { LogObjSpecialKey, LogValueStyleType } from '../constants';
+import { isPreviewMarkdown } from '../../../utils/markdown';
+import { useTestRunReporterService } from '../../../../../hooks';
+
+import styles from './json-field.module.less';
+
+const SPACE_WIDTH = 14;
+
+/* JSON type data rendering */
+const FieldValue: React.FC<{
+  value: Field['value'];
+  /** Is it in markdown format? */
+  isMarkdown?: boolean;
+  onMarkdownPreview?: () => void;
+}> = ({ value, isMarkdown, onMarkdownPreview }) => {
+  const { value: current, type } = useValue(value);
+
+  return (
+    <span className={styles['field-value']}>
+      <span
+        data-testid="json-viewer-field-value"
+        className={cls({
+          [styles['field-value-number']]: type === LogValueStyleType.Number,
+          [styles['field-value-boolean']]: type === LogValueStyleType.Boolean,
+        })}
+      >
+        {current}
+      </span>
+      {/* preview */}
+      {isMarkdown ? (
+        <Button
+          className={styles['value-button']}
+          size="mini"
+          color="primary"
+          icon={<IconCozEye />}
+          onClick={onMarkdownPreview}
+        >
+          {I18n.t('creat_project_use_template_preview')}
+        </Button>
+      ) : null}
+    </span>
+  );
+};
+
+const JsonField: React.FC<{
+  field: Field;
+  mdPreview: boolean;
+  onPreview: (value: string, path: string[]) => void;
+}> = ({ field, mdPreview, onPreview }) => {
+  const reporter = useTestRunReporterService();
+  const { lines, children, path, isObj } = field;
+  const echoLines = useMemo(() => lines.slice(1), [lines]);
+
+  const pathStr = useMemo(() => path.join('.'), [path]);
+
+  const isError = useMemo(() => pathStr === LogObjSpecialKey.Error, [pathStr]);
+  const isWarning = useMemo(
+    () => pathStr === LogObjSpecialKey.Warning,
+    [pathStr],
+  );
+
+  const key = useMemo(() => last(path), [path]);
+  const keyWithColon = useMemo(() => {
+    if (isError) {
+      return I18n.t('workflow_detail_testrun_error_front');
+    }
+    if (isWarning) {
+      return I18n.t('workflow_detail_testrun_warning_front');
+    }
+    return key ? `${key} : ` : '';
+  }, [key, isError, isWarning]);
+
+  const isCanRenderMarkdown = useMemo(
+    () => !isObj && !isError && !isWarning && isPreviewMarkdown(field.value),
+    [isObj, isError, isWarning, field.value],
+  );
+
+  const isRenderMarkdown = useMemo(
+    () => mdPreview && isCanRenderMarkdown,
+    [isCanRenderMarkdown, mdPreview],
+  );
+
+  const { expand, toggle } = useExpand(path.join('.'));
+
+  const handleMarkdownPreview = () => {
+    if (isString(field.value)) {
+      onPreview(field.value, path);
+      reporter.logOutputMarkdown({ action_type: 'preview' });
+    }
+  };
+
+  useEffect(() => {
+    if (isRenderMarkdown) {
+      reporter.logOutputMarkdown({ action_type: 'render' });
+    }
+  }, [isRenderMarkdown]);
+
+  return (
+    <>
+      <div className={styles['json-viewer-field']}>
+        <div
+          className={styles['field-space']}
+          style={{ width: `${echoLines.length * SPACE_WIDTH}px` }}
+        />
+        <div
+          data-testid="json-viewer-field-content"
+          className={cls('field-content', styles['field-content'], {
+            [styles['is-error']]: isError,
+            [styles['is-warning']]: isWarning,
+          })}
+          onClick={isObj ? toggle : undefined}
+        >
+          {isObj ? (
+            <>
+              <span
+                data-testid="json-viewer-json-field-expander"
+                className={cls('field-icon', styles['field-icon'], {
+                  [styles.expand]: expand,
+                })}
+              >
+                <IconCozArrowRight />
+              </span>
+              <span className={cls('field-key', styles['field-key'])}>
+                {key}
+              </span>
+              <span className={cls('field-len', styles['field-len'])}>
+                {` {${children.length}}`}
+              </span>
+            </>
+          ) : (
+            <>
+              {keyWithColon ? (
+                <span className={cls('field-key', styles['field-key'])}>
+                  {keyWithColon}
+                </span>
+              ) : null}
+              <FieldValue
+                value={field.value}
+                isMarkdown={isRenderMarkdown}
+                onMarkdownPreview={handleMarkdownPreview}
+              />
+            </>
+          )}
+        </div>
+      </div>
+      {expand
+        ? children.map(i => (
+            <JsonField
+              mdPreview={mdPreview}
+              onPreview={onPreview}
+              field={i}
+              key={i.path.join('.')}
+            />
+          ))
+        : null}
+    </>
+  );
+};
+
+export { JsonField };

package/vendor/coze/source/external/features/log/components/data-viewer/json-field/json-field.module.less

@@ -0,0 +1,79 @@
+.json-viewer-field {
+  font-size: 12px;
+  font-weight: 400;
+  line-height: 16px;
+  display: flex;
+
+  .field-content {
+    flex: 1 1 0;
+    width: 0;
+    padding: 2px 0;
+    user-select: auto;
+
+    position: relative;
+
+    &.is-error .field-key,
+    &.is-error .field-value {
+      color: #FF441E;
+    }
+
+    &.is-warning .field-key,
+    &.is-warning .field-value {
+      color: #FF9600;
+    }
+
+    .field-value-number {
+      color: #03B6D0;
+    }
+
+    .field-value-boolean {
+      color: #BB2BC9;
+    }
+  }
+
+  .field-icon {
+    font-size: 12px;
+    color: var(--coz-fg-secondary);
+    margin-right: 2px;
+    cursor: pointer;
+    display: inline-flex;
+    align-items: center;
+
+    position: absolute;
+    top: 4px;
+    left: -12px;
+
+    &.expand>svg {
+      transform: rotate(90deg);
+    }
+  }
+
+  .field-block {
+    padding-left: 14px;
+  }
+
+  .field-key {
+    color: var(--coz-fg-hglt);
+    word-break: break-word;
+  }
+
+  .field-value {
+    overflow-wrap: anywhere;
+    white-space: pre-wrap;
+    line-height: 16px;
+  }
+
+  .field-len {
+    color: var(--coz-fg-dim);
+  }
+}
+
+.field-space {
+  display: inline-block;
+  flex-grow: 0;
+  flex-shrink: 0;
+}
+
+.value-button {
+  margin-left: 4px;
+}

package/vendor/coze/source/external/features/log/components/data-viewer/types.ts

@@ -0,0 +1,50 @@
+/*
+ * 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.
+ */
+
+/*******************************************************************************
+ * Log related types
+ */
+/** The possible states of a line */
+export enum LineStatus {
+  /** Completely hidden, the last parent attribute nested child attribute will not be wired in the same column */
+  Hidden,
+  /** Full display, appearing only on adjacent lines of properties */
+  Visible,
+  /** Semi-display, non-adjacent lines */
+  Half,
+  /** Adjacent line of last property */
+  Last,
+}
+
+/** Possible values in JsonViewer */
+export type JsonValueType =
+  | string
+  | null
+  | number
+  | object
+  | boolean
+  | undefined;
+
+export interface Field {
+  /** The use of arrays instead of'a.b.c 'is due to the possibility that key =' a.b 'will generate false nesting */
+  path: string[];
+  lines: LineStatus[];
+  /** Here value can be any value, here is an incomplete enumeration */
+  value: JsonValueType;
+  children: Field[];
+  /** Whether it is a drillable object (containing an array) */
+  isObj: boolean;
+}

package/vendor/coze/source/external/features/log/components/data-viewer/utils/big-number.ts

@@ -0,0 +1,35 @@
+/*
+ * 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 BigNumber from 'bignumber.js';
+
+/**
+ * Is it a big number?
+ * @param value
+ * @returns
+ */
+export function isBigNumber(value: unknown): value is BigNumber {
+  return !!(value && value instanceof BigNumber);
+}
+
+/**
+ * Large number to string
+ * @param value
+ * @returns
+ */
+export function bigNumberToString(value: BigNumber): string {
+  return value.toFixed();
+}

package/vendor/coze/source/external/features/log/components/data-viewer/utils/generate-field.ts

@@ -0,0 +1,104 @@
+/*
+ * 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 { isObject } from 'lodash-es';
+
+import { LineStatus, type JsonValueType, type Field } from '../types';
+import { isBigNumber } from './big-number';
+
+/**
+ * Push through the line state of the parent element to the line state of the child element
+ */
+const getLineByParent2Child = (pLine: LineStatus): LineStatus => {
+  switch (pLine) {
+    /** It means that the parent node is also drilled from the parent node, and the sub-node here only needs to continue the line. */
+    case LineStatus.Visible:
+      return LineStatus.Half;
+    /** Indicates that the parent node is the last node of the parent node, and the sub-node does not need to continue, just render blank. */
+    case LineStatus.Last:
+      return LineStatus.Hidden;
+    /** Other cases fully inherit the line of the parent node */
+    default:
+      return pLine;
+  }
+};
+
+/**
+ * Parse objects into fields that can be cycled
+ * 1. If object is not a complex type, fields of length 1 are returned to render only one item
+ * 2. If object = {}, fields of length 0 are returned, and the rendering layer needs to be well covered
+ */
+const generateFields = (object: JsonValueType): Field[] => {
+  /** If the object is not a complex type */
+  if (!isObject(object) || isBigNumber(object)) {
+    return [
+      {
+        path: [],
+        lines: [],
+        value: object,
+        isObj: false,
+        children: [],
+      },
+    ];
+  }
+
+  /** Cache the calculated line during recursive calculation, which is meaningless and reduces some time complexity */
+  const lineMap = new Map<string[], LineStatus[]>();
+
+  /** Recursive parsing of object as fields */
+  const dfs = ($object: object, $parentPath: string[] = []): Field[] => {
+    // If it is not an object, return an empty array directly to cover the exception
+    if (!isObject($object)) {
+      return [];
+    }
+
+    // If it is a large number, return an empty array directly
+    if (isBigNumber($object)) {
+      return [];
+    }
+
+    const parentLines = lineMap.get($parentPath) || [];
+
+    const keys = Object.keys($object);
+
+    return keys.map((key, idx) => {
+      const value = $object[key];
+      const path = $parentPath.concat(key);
+      const last = idx === keys.length - 1;
+      /**
+       * Derive the sub-node's line from the parent's line
+       */
+      const lines = parentLines
+        .map<LineStatus>(getLineByParent2Child)
+        /**
+         * Finally, splice the sub-node's own line, and the last node is distinguished from the ordinary node by style.
+         */
+        .concat(last ? LineStatus.Last : LineStatus.Visible);
+      lineMap.set(path, lines);
+      return {
+        path,
+        lines,
+        value,
+        children: dfs(value, path),
+        isObj: isObject(value) && !isBigNumber(value),
+      };
+    });
+  };
+
+  return dfs(object);
+};
+
+export { generateFields };

package/vendor/coze/source/external/features/log/components/log-parser/log-wrap.module.less

@@ -0,0 +1,27 @@
+.flow-log-detail-label {
+  display: flex;
+  align-items: center;
+  font-size: 14px;
+  margin-bottom: 4px;
+  column-gap: 4px;
+  height: 20px;
+  margin-left: 2px;
+
+  .label-text {
+    color: var(--coz-fg-plus);
+    font-weight: 500;
+    word-break: keep-all;
+    height: 20px;
+    line-height: 20px;
+  }
+
+  :global {
+    .coz-icon-button-mini {
+      line-height: 0px;
+    }
+  }
+}
+
+.wrapper {
+  padding: 8px 6px;
+}