@flowgram.ai/form-materials 0.4.8 → 0.4.10

package/dist/esm/components/dynamic-value-input/index.mjs

@@ -0,0 +1,137 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+import "react";
+import { JsonSchemaUtils, useTypeManager } from "@flowgram.ai/json-schema";
+import { IconButton } from "@douyinfe/semi-ui";
+import { IconSetting } from "@douyinfe/semi-icons";
+import { createInjectMaterial } from "../../shared/index.mjs";
+import { InjectVariableSelector } from "../variable-selector/index.mjs";
+import { TypeSelector } from "../type-selector/index.mjs";
+import { ConstantInput } from "../constant-input/index.mjs";
+import { UIContainer, UIMain, UITrigger, UIType } from "./styles.mjs";
+import { useIncludeSchema, useRefVariable, useSelectSchema } from "./hooks.mjs";
+const DEFAULT_VALUE = {
+    type: 'constant',
+    content: '',
+    schema: {
+        type: 'string'
+    }
+};
+function DynamicValueInput({ value, onChange, readonly, style, schema: schemaFromProps, constantProps }) {
+    const refVariable = useRefVariable(value);
+    const [selectSchema, setSelectSchema] = useSelectSchema(schemaFromProps, constantProps, value);
+    const includeSchema = useIncludeSchema(schemaFromProps);
+    const typeManager = useTypeManager();
+    const renderTypeSelector = ()=>{
+        if (schemaFromProps) return /*#__PURE__*/ jsx(TypeSelector, {
+            value: schemaFromProps,
+            readonly: true
+        });
+        if (value?.type === 'ref') {
+            const schema = refVariable?.type ? JsonSchemaUtils.astToSchema(refVariable?.type) : void 0;
+            return /*#__PURE__*/ jsx(TypeSelector, {
+                value: schema,
+                readonly: true
+            });
+        }
+        return /*#__PURE__*/ jsx(TypeSelector, {
+            value: selectSchema,
+            onChange: (_v)=>{
+                setSelectSchema(_v || {
+                    type: 'string'
+                });
+                const schema = _v || {
+                    type: 'string'
+                };
+                let content = typeManager.getDefaultValue(schema);
+                if (_v?.type === 'object') content = '{}';
+                if (_v?.type === 'array') content = '[]';
+                onChange({
+                    type: 'constant',
+                    content,
+                    schema
+                });
+            },
+            readonly: readonly
+        });
+    };
+    const renderMain = ()=>{
+        if (value?.type === 'ref') return /*#__PURE__*/ jsx(InjectVariableSelector, {
+            style: {
+                width: '100%'
+            },
+            value: value?.content,
+            onChange: (_v)=>onChange(_v ? {
+                    type: 'ref',
+                    content: _v
+                } : DEFAULT_VALUE),
+            includeSchema: includeSchema,
+            readonly: readonly
+        });
+        const constantSchema = schemaFromProps || selectSchema || {
+            type: 'string'
+        };
+        return /*#__PURE__*/ jsx(ConstantInput, {
+            value: value?.content,
+            onChange: (_v)=>onChange({
+                    type: 'constant',
+                    content: _v,
+                    schema: constantSchema
+                }),
+            schema: constantSchema || {
+                type: 'string'
+            },
+            readonly: readonly,
+            fallbackRenderer: ()=>/*#__PURE__*/ jsx(InjectVariableSelector, {
+                    style: {
+                        width: '100%'
+                    },
+                    onChange: (_v)=>onChange(_v ? {
+                            type: 'ref',
+                            content: _v
+                        } : DEFAULT_VALUE),
+                    includeSchema: includeSchema,
+                    readonly: readonly
+                }),
+            ...constantProps,
+            strategies: [
+                ...constantProps?.strategies || []
+            ]
+        });
+    };
+    const renderTrigger = ()=>/*#__PURE__*/ jsx(InjectVariableSelector, {
+            style: {
+                width: '100%'
+            },
+            value: value?.type === 'ref' ? value?.content : void 0,
+            onChange: (_v)=>onChange({
+                    type: 'ref',
+                    content: _v
+                }),
+            includeSchema: includeSchema,
+            readonly: readonly,
+            triggerRender: ()=>/*#__PURE__*/ jsx(IconButton, {
+                    disabled: readonly,
+                    size: "small",
+                    icon: /*#__PURE__*/ jsx(IconSetting, {
+                        size: "small"
+                    })
+                })
+        });
+    return /*#__PURE__*/ jsxs(UIContainer, {
+        style: style,
+        children: [
+            /*#__PURE__*/ jsx(UIType, {
+                children: renderTypeSelector()
+            }),
+            /*#__PURE__*/ jsx(UIMain, {
+                children: renderMain()
+            }),
+            /*#__PURE__*/ jsx(UITrigger, {
+                children: renderTrigger()
+            })
+        ]
+    });
+}
+DynamicValueInput.renderKey = 'dynamic-value-input-render-key';
+const InjectDynamicValueInput = createInjectMaterial(DynamicValueInput);
+export { DynamicValueInput, InjectDynamicValueInput };

package/dist/esm/components/dynamic-value-input/styles.mjs

@@ -0,0 +1,54 @@
+import styled_components from "styled-components";
+const UIContainer = styled_components.div`
+  display: flex;
+  align-items: center;
+  border-radius: 4px;
+  border: 1px solid var(--semi-color-border);
+
+  overflow: hidden;
+
+  background-color: var(--semi-color-fill-0);
+`;
+const UIMain = styled_components.div`
+  flex-grow: 1;
+  overflow: hidden;
+  min-width: 0;
+  border-left: 1px solid var(--semi-color-border);
+  border-right: 1px solid var(--semi-color-border);
+
+  & .semi-tree-select,
+  & .semi-input-number,
+  & .semi-select {
+    width: 100%;
+    border: none;
+    border-radius: 0;
+  }
+
+  & .semi-input-wrapper {
+    border: none;
+    border-radius: 0;
+  }
+
+  & .semi-input-textarea-wrapper {
+    border: none;
+    border-radius: 0;
+  }
+
+  & .semi-input-textarea {
+    padding: 2px 6px;
+    border: none;
+    border-radius: 0;
+    word-break: break-all;
+  }
+`;
+const UIType = styled_components.div`
+  & .semi-button {
+    border-radius: 0;
+  }
+`;
+const UITrigger = styled_components.div`
+  & .semi-button {
+    border-radius: 0;
+  }
+`;
+export { UIContainer, UIMain, UITrigger, UIType };

package/dist/esm/components/index.mjs

@@ -0,0 +1,26 @@
+import { AssignRow } from "./assign-row/index.mjs";
+import { AssignRows } from "./assign-rows/index.mjs";
+import { BatchOutputs } from "./batch-outputs/index.mjs";
+import { BatchVariableSelector } from "./batch-variable-selector/index.mjs";
+import { BlurInput } from "./blur-input/index.mjs";
+import { CodeEditor } from "./code-editor/index.mjs";
+import { CodeEditorMini } from "./code-editor-mini/index.mjs";
+import { ConditionRow } from "./condition-row/index.mjs";
+import { ConstantInput } from "./constant-input/index.mjs";
+import { DBConditionRow } from "./db-condition-row/index.mjs";
+import { DisplayFlowValue } from "./display-flow-value/index.mjs";
+import { DisplayInputsValueAllInTag, DisplayInputsValues } from "./display-inputs-values/index.mjs";
+import { DisplayOutputs } from "./display-outputs/index.mjs";
+import { DisplaySchemaTag } from "./display-schema-tag/index.mjs";
+import { DisplaySchemaTree } from "./display-schema-tree/index.mjs";
+import { DynamicValueInput, InjectDynamicValueInput } from "./dynamic-value-input/index.mjs";
+import { InputsValues } from "./inputs-values/index.mjs";
+import { InputsValuesTree } from "./inputs-values-tree/index.mjs";
+import { JsonEditorWithVariables } from "./json-editor-with-variables/index.mjs";
+import { JsonSchemaEditor } from "./json-schema-editor/index.mjs";
+import { PromptEditor } from "./prompt-editor/index.mjs";
+import { PromptEditorWithInputs } from "./prompt-editor-with-inputs/index.mjs";
+import { PromptEditorWithVariables } from "./prompt-editor-with-variables/index.mjs";
+import { InjectTypeSelector, TypeSelector, getTypeSelectValue, parseTypeSelectValue } from "./type-selector/index.mjs";
+import { InjectVariableSelector, VariableSelector, VariableSelectorProvider, useVariableTree } from "./variable-selector/index.mjs";
+export { AssignRow, AssignRows, BatchOutputs, BatchVariableSelector, BlurInput, CodeEditor, CodeEditorMini, ConditionRow, ConstantInput, DBConditionRow, DisplayFlowValue, DisplayInputsValueAllInTag, DisplayInputsValues, DisplayOutputs, DisplaySchemaTag, DisplaySchemaTree, DynamicValueInput, InjectDynamicValueInput, InjectTypeSelector, InjectVariableSelector, InputsValues, InputsValuesTree, JsonEditorWithVariables, JsonSchemaEditor, PromptEditor, PromptEditorWithInputs, PromptEditorWithVariables, TypeSelector, VariableSelector, VariableSelectorProvider, getTypeSelectValue, parseTypeSelectValue, useVariableTree };

package/dist/esm/components/inputs-values/index.mjs

@@ -0,0 +1,78 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+import "react";
+import { I18n } from "@flowgram.ai/editor";
+import { Button, IconButton } from "@douyinfe/semi-ui";
+import { IconDelete, IconPlus } from "@douyinfe/semi-icons";
+import { useObjectList } from "../../hooks/index.mjs";
+import { InjectDynamicValueInput } from "../dynamic-value-input/index.mjs";
+import { BlurInput } from "../blur-input/index.mjs";
+import { UIRow, UIRows } from "./styles.mjs";
+function InputsValues({ value, onChange, style, readonly, constantProps, schema, hasError }) {
+    const { list, updateKey, updateValue, remove, add } = useObjectList({
+        value,
+        onChange,
+        sortIndexKey: 'extra.index'
+    });
+    return /*#__PURE__*/ jsxs("div", {
+        children: [
+            /*#__PURE__*/ jsx(UIRows, {
+                style: style,
+                children: list.map((item)=>/*#__PURE__*/ jsxs(UIRow, {
+                        children: [
+                            /*#__PURE__*/ jsx(BlurInput, {
+                                style: {
+                                    width: 100,
+                                    minWidth: 100,
+                                    maxWidth: 100
+                                },
+                                disabled: readonly,
+                                size: "small",
+                                value: item.key,
+                                onChange: (v)=>updateKey(item.id, v),
+                                placeholder: I18n.t('Input Key')
+                            }),
+                            /*#__PURE__*/ jsx(InjectDynamicValueInput, {
+                                style: {
+                                    flexGrow: 1
+                                },
+                                readonly: readonly,
+                                value: item.value,
+                                onChange: (v)=>updateValue(item.id, v),
+                                schema: schema,
+                                hasError: hasError,
+                                constantProps: {
+                                    ...constantProps,
+                                    strategies: [
+                                        ...constantProps?.strategies || []
+                                    ]
+                                }
+                            }),
+                            /*#__PURE__*/ jsx(IconButton, {
+                                disabled: readonly,
+                                theme: "borderless",
+                                icon: /*#__PURE__*/ jsx(IconDelete, {
+                                    size: "small"
+                                }),
+                                size: "small",
+                                onClick: ()=>remove(item.id)
+                            })
+                        ]
+                    }, item.id))
+            }),
+            /*#__PURE__*/ jsx(Button, {
+                disabled: readonly,
+                icon: /*#__PURE__*/ jsx(IconPlus, {}),
+                size: "small",
+                onClick: ()=>add({
+                        type: 'constant',
+                        content: '',
+                        schema: {
+                            type: 'string'
+                        }
+                    }),
+                children: I18n.t('Add')
+            })
+        ]
+    });
+}
+export { InputsValues };

package/dist/esm/components/inputs-values/styles.mjs

@@ -0,0 +1,13 @@
+import styled_components from "styled-components";
+const UIRows = styled_components.div`
+  display: flex;
+  flex-direction: column;
+  gap: 10px;
+  margin-bottom: 10px;
+`;
+const UIRow = styled_components.div`
+  display: flex;
+  align-items: flex-start;
+  gap: 5px;
+`;
+export { UIRow, UIRows };

package/dist/esm/components/inputs-values-tree/hooks/use-child-list.mjs

@@ -0,0 +1,43 @@
+import { useMemo } from "react";
+import { isPlainObject } from "lodash-es";
+import { FlowValueUtils } from "../../../shared/index.mjs";
+import { useObjectList } from "../../../hooks/index.mjs";
+function useChildList(value, onChange) {
+    const canAddField = useMemo(()=>{
+        if (!isPlainObject(value)) return false;
+        if (FlowValueUtils.isFlowValue(value)) return FlowValueUtils.isConstant(value) && value?.schema?.type === 'object';
+        return true;
+    }, [
+        value
+    ]);
+    const objectListValue = useMemo(()=>{
+        if (isPlainObject(value)) {
+            if (FlowValueUtils.isFlowValue(value)) return;
+            return value;
+        }
+    }, [
+        value
+    ]);
+    const { list, add, updateKey, updateValue, remove } = useObjectList({
+        value: objectListValue,
+        onChange: (value)=>{
+            onChange?.(value);
+        },
+        sortIndexKey: (value)=>FlowValueUtils.isFlowValue(value) ? 'extra.index' : ''
+    });
+    const hasChildren = useMemo(()=>canAddField && (list.length > 0 || Object.keys(objectListValue || {}).length > 0), [
+        canAddField,
+        list.length,
+        Object.keys(objectListValue || {}).length
+    ]);
+    return {
+        canAddField,
+        hasChildren,
+        list,
+        add,
+        updateKey,
+        updateValue,
+        remove
+    };
+}
+export { useChildList };

package/dist/esm/components/inputs-values-tree/index.mjs

@@ -0,0 +1,53 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+import "react";
+import { I18n } from "@flowgram.ai/editor";
+import { Button } from "@douyinfe/semi-ui";
+import { IconPlus } from "@douyinfe/semi-icons";
+import { FlowValueUtils } from "../../shared/index.mjs";
+import { useObjectList } from "../../hooks/index.mjs";
+import { UITreeItems } from "./styles.mjs";
+import { InputValueRow } from "./row.mjs";
+function InputsValuesTree(props) {
+    const { value, onChange, readonly, hasError, constantProps } = props;
+    const { list, updateKey, updateValue, remove, add } = useObjectList({
+        value,
+        onChange,
+        sortIndexKey: (value)=>FlowValueUtils.isFlowValue(value) ? 'extra.index' : ''
+    });
+    return /*#__PURE__*/ jsxs("div", {
+        children: [
+            /*#__PURE__*/ jsx(UITreeItems, {
+                children: list.map((item)=>/*#__PURE__*/ jsx(InputValueRow, {
+                        keyName: item.key,
+                        value: item.value,
+                        onUpdateKey: (key)=>updateKey(item.id, key),
+                        onUpdateValue: (value)=>updateValue(item.id, value),
+                        onRemove: ()=>remove(item.id),
+                        readonly: readonly,
+                        hasError: hasError,
+                        constantProps: constantProps
+                    }, item.id))
+            }),
+            /*#__PURE__*/ jsx(Button, {
+                style: {
+                    marginTop: 10,
+                    marginLeft: 16
+                },
+                disabled: readonly,
+                icon: /*#__PURE__*/ jsx(IconPlus, {}),
+                size: "small",
+                onClick: ()=>{
+                    add({
+                        type: 'constant',
+                        content: '',
+                        schema: {
+                            type: 'string'
+                        }
+                    });
+                },
+                children: I18n.t('Add')
+            })
+        ]
+    });
+}
+export { InputsValuesTree };

package/dist/esm/components/inputs-values-tree/row.mjs

@@ -0,0 +1,149 @@
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { useMemo, useState } from "react";
+import { I18n } from "@flowgram.ai/editor";
+import { IconButton, Input } from "@douyinfe/semi-ui";
+import { IconChevronDown, IconChevronRight, IconDelete } from "@douyinfe/semi-icons";
+import { IconAddChildren, UIActions, UICollapseTrigger, UICollapsible, UIRow, UITreeItemLeft, UITreeItemMain, UITreeItemRight, UITreeItems } from "./styles.mjs";
+import { useChildList } from "./hooks/use-child-list.mjs";
+import { InjectDynamicValueInput } from "../dynamic-value-input/index.mjs";
+import { BlurInput } from "../blur-input/index.mjs";
+const AddObjectChildStrategy = {
+    hit: (schema)=>'object' === schema.type,
+    Renderer: ()=>/*#__PURE__*/ jsx(Input, {
+            size: "small",
+            disabled: true,
+            style: {
+                pointerEvents: 'none'
+            },
+            value: I18n.t('Configure via child fields')
+        })
+};
+function InputValueRow(props) {
+    const { keyName, value, $level = 0, onUpdateKey, onUpdateValue, $isLast, onRemove, constantProps, hasError, readonly } = props;
+    const [collapse, setCollapse] = useState(false);
+    const { canAddField, hasChildren, list, add, updateKey, updateValue, remove } = useChildList(value, onUpdateValue);
+    const strategies = useMemo(()=>[
+            ...hasChildren ? [
+                AddObjectChildStrategy
+            ] : [],
+            ...constantProps?.strategies || []
+        ], [
+        hasChildren,
+        constantProps?.strategies
+    ]);
+    const flowDisplayValue = useMemo(()=>hasChildren ? {
+            type: 'constant',
+            schema: {
+                type: 'object'
+            }
+        } : value, [
+        hasChildren,
+        value
+    ]);
+    return /*#__PURE__*/ jsxs(Fragment, {
+        children: [
+            /*#__PURE__*/ jsx(UITreeItemLeft, {
+                $isLast: $isLast,
+                $showLine: $level > 0,
+                $showCollapse: hasChildren,
+                children: hasChildren && /*#__PURE__*/ jsx(UICollapseTrigger, {
+                    onClick: ()=>setCollapse((_collapse)=>!_collapse),
+                    children: collapse ? /*#__PURE__*/ jsx(IconChevronDown, {
+                        size: "small"
+                    }) : /*#__PURE__*/ jsx(IconChevronRight, {
+                        size: "small"
+                    })
+                })
+            }),
+            /*#__PURE__*/ jsxs(UITreeItemRight, {
+                children: [
+                    /*#__PURE__*/ jsx(UITreeItemMain, {
+                        children: /*#__PURE__*/ jsxs(UIRow, {
+                            children: [
+                                /*#__PURE__*/ jsx(BlurInput, {
+                                    style: {
+                                        width: 100,
+                                        minWidth: 100,
+                                        maxWidth: 100
+                                    },
+                                    disabled: readonly,
+                                    size: "small",
+                                    value: keyName,
+                                    onChange: (v)=>onUpdateKey?.(v),
+                                    placeholder: I18n.t('Input Key')
+                                }),
+                                /*#__PURE__*/ jsx(InjectDynamicValueInput, {
+                                    style: {
+                                        flexGrow: 1
+                                    },
+                                    readonly: readonly,
+                                    value: flowDisplayValue,
+                                    onChange: (v)=>onUpdateValue(v),
+                                    hasError: hasError,
+                                    constantProps: {
+                                        ...constantProps,
+                                        strategies
+                                    }
+                                }),
+                                /*#__PURE__*/ jsxs(UIActions, {
+                                    children: [
+                                        canAddField && /*#__PURE__*/ jsx(IconButton, {
+                                            disabled: readonly,
+                                            size: "small",
+                                            theme: "borderless",
+                                            icon: /*#__PURE__*/ jsx(IconAddChildren, {}),
+                                            onClick: ()=>{
+                                                add({
+                                                    type: 'constant',
+                                                    content: '',
+                                                    schema: {
+                                                        type: 'string'
+                                                    }
+                                                });
+                                                setCollapse(true);
+                                            }
+                                        }),
+                                        /*#__PURE__*/ jsx(IconButton, {
+                                            disabled: readonly,
+                                            theme: "borderless",
+                                            icon: /*#__PURE__*/ jsx(IconDelete, {
+                                                size: "small"
+                                            }),
+                                            size: "small",
+                                            onClick: ()=>onRemove?.()
+                                        })
+                                    ]
+                                })
+                            ]
+                        })
+                    }),
+                    hasChildren && /*#__PURE__*/ jsx(UICollapsible, {
+                        $collapse: collapse,
+                        children: /*#__PURE__*/ jsx(UITreeItems, {
+                            $shrink: true,
+                            children: list.map((_item, index)=>/*#__PURE__*/ jsx(InputValueRow, {
+                                    readonly: readonly,
+                                    hasError: hasError,
+                                    constantProps: constantProps,
+                                    keyName: _item.key,
+                                    value: _item.value,
+                                    $level: $level + 1,
+                                    onUpdateValue: (_v)=>{
+                                        updateValue(_item.id, _v);
+                                    },
+                                    onUpdateKey: (k)=>{
+                                        updateKey(_item.id, k);
+                                    },
+                                    onRemove: ()=>{
+                                        remove(_item.id);
+                                    },
+                                    $isLast: index === list.length - 1
+                                }, _item.id))
+                        })
+                    })
+                ]
+            })
+        ]
+    });
+}
+export { InputValueRow };

package/dist/esm/components/inputs-values-tree/styles.mjs

@@ -0,0 +1,105 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+import "react";
+import styled_components, { css } from "styled-components";
+import semi_icons from "@douyinfe/semi-icons";
+const UIContainer = styled_components.div``;
+const UIRow = styled_components.div`
+  display: flex;
+  align-items: flex-start;
+  gap: 5px;
+`;
+const UICollapseTrigger = styled_components.div`
+  cursor: pointer;
+  margin-right: 5px;
+`;
+const UITreeItems = styled_components.div`
+  display: grid;
+  grid-template-columns: auto 1fr;
+
+  ${({ $shrink })=>$shrink && css`
+      padding-left: 3px;
+      margin-top: 10px;
+    `}
+`;
+const UITreeItemLeft = styled_components.div`
+  grid-column: 1;
+  position: relative;
+  width: 16px;
+
+  ${({ $showLine, $isLast, $showCollapse })=>{
+    let height = $isLast ? '24px' : '100%';
+    let width = $showCollapse ? '12px' : '30px';
+    return $showLine && css`
+        &::before {
+          /* 竖线 */
+          content: '';
+          height: ${height};
+          position: absolute;
+          left: -14px;
+          top: -16px;
+          width: 1px;
+          background: #d9d9d9;
+          display: block;
+        }
+
+        &::after {
+          /* 横线 */
+          content: '';
+          position: absolute;
+          left: -14px; // 横线起点和竖线对齐
+          top: 8px; // 跟随你的行高调整
+          width: ${width}; // 横线长度
+          height: 1px;
+          background: #d9d9d9;
+          display: block;
+        }
+      `;
+}}
+`;
+const UITreeItemRight = styled_components.div`
+  grid-column: 2;
+  margin-bottom: 10px;
+
+  &:last-child {
+    margin-bottom: 0px;
+  }
+`;
+const UITreeItemMain = styled_components.div`
+  display: flex;
+  flex-direction: column;
+  gap: 10px;
+  position: relative;
+`;
+const UICollapsible = styled_components.div`
+  display: none;
+
+  ${({ $collapse })=>$collapse && css`
+      display: block;
+    `}
+`;
+const UIActions = styled_components.div`
+  white-space: nowrap;
+`;
+const iconAddChildrenSvg = /*#__PURE__*/ jsxs("svg", {
+    className: "icon-icon icon-icon-coz_add_node ",
+    width: "1em",
+    height: "1em",
+    viewBox: "0 0 24 24",
+    fill: "currentColor",
+    xmlns: "http://www.w3.org/2000/svg",
+    children: [
+        /*#__PURE__*/ jsx("path", {
+            fillRule: "evenodd",
+            clipRule: "evenodd",
+            d: "M11 6.49988C11 8.64148 9.50397 10.4337 7.49995 10.8884V15.4998C7.49995 16.0521 7.94767 16.4998 8.49995 16.4998H11.208C11.0742 16.8061 11 17.1443 11 17.4998C11 17.8554 11.0742 18.1936 11.208 18.4998H8.49995C6.8431 18.4998 5.49995 17.1567 5.49995 15.4998V10.8884C3.49599 10.4336 2 8.64145 2 6.49988C2 4.0146 4.01472 1.99988 6.5 1.99988C8.98528 1.99988 11 4.0146 11 6.49988ZM6.5 8.99988C7.88071 8.99988 9 7.88059 9 6.49988C9 5.11917 7.88071 3.99988 6.5 3.99988C5.11929 3.99988 4 5.11917 4 6.49988C4 7.88059 5.11929 8.99988 6.5 8.99988Z"
+        }),
+        /*#__PURE__*/ jsx("path", {
+            d: "M17.5 12.4999C18.0523 12.4999 18.5 12.9476 18.5 13.4999V16.4999H21.5C22.0523 16.4999 22.5 16.9476 22.5 17.4999C22.5 18.0522 22.0523 18.4999 21.5 18.4999H18.5V21.4999C18.5 22.0522 18.0523 22.4999 17.5 22.4999C16.9477 22.4999 16.5 22.0522 16.5 21.4999V18.4999H13.5C12.9477 18.4999 12.5 18.0522 12.5 17.4999C12.5 16.9476 12.9477 16.4999 13.5 16.4999H16.5V13.4999C16.5 12.9476 16.9477 12.4999 17.5 12.4999Z"
+        })
+    ]
+});
+const IconAddChildren = ()=>/*#__PURE__*/ jsx(semi_icons, {
+        size: "small",
+        svg: iconAddChildrenSvg
+    });
+export { IconAddChildren, UIActions, UICollapseTrigger, UICollapsible, UIContainer, UIRow, UITreeItemLeft, UITreeItemMain, UITreeItemRight, UITreeItems };