service-flow-designer 1.1.3 → 1.1.5

package/dist/es/designer/service-panel/service-panel.vue2.js

@@ -0,0 +1,80 @@
+import { defineComponent, ref, computed, openBlock, createElementBlock, normalizeStyle, createElementVNode, normalizeClass, createBlock } from "vue";
+import LogicFlow from "@logicflow/core";
+import ServiceList from "./service-list.vue.js";
+import ComponentPanel from "./component-panel.vue.js";
+const _hoisted_1 = { class: "amb-assembly-header" };
+const _hoisted_2 = { class: "amb-assembly-header-type" };
+const _hoisted_3 = { class: "amb-design-assembly-list" };
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "service-panel",
+  props: {
+    logicFlowInstance: {
+      type: LogicFlow,
+      default: () => {
+      }
+    },
+    serviceTreeData: {
+      type: Array,
+      default: () => []
+    }
+  },
+  emits: ["drag-node", "service-click", "clear-flow-canvas", "load-tree-data"],
+  setup(__props, { emit: __emit }) {
+    const emits = __emit;
+    const clickType = ref("serviceFlowList");
+    const winHeight = ref();
+    const containerHeightStyle = computed(() => {
+      return {
+        height: winHeight.value + "px"
+      };
+    });
+    const dragNode = (serviceComponent) => {
+      console.log(`service-component-lib $_dragNode:${serviceComponent.type}`);
+      emits("drag-node", serviceComponent);
+    };
+    const onServiceClick = (service) => {
+      emits("service-click", service);
+    };
+    const clearFlowCanvas = () => {
+      emits("clear-flow-canvas");
+    };
+    const loadTreeData = () => {
+      emits("load-tree-data");
+    };
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", {
+        class: "amb-design-assembly-content",
+        ref: "ambDesignAssemblyContent",
+        style: normalizeStyle(containerHeightStyle.value)
+      }, [
+        createElementVNode("div", _hoisted_1, [
+          createElementVNode("div", _hoisted_2, [
+            createElementVNode("label", {
+              class: normalizeClass({ selected: clickType.value === "serviceFlowList" }),
+              onClick: _cache[0] || (_cache[0] = ($event) => clickType.value = "serviceFlowList")
+            }, " 服务列表 ", 2),
+            createElementVNode("label", {
+              class: normalizeClass({ selected: clickType.value === "component" }),
+              onClick: _cache[1] || (_cache[1] = ($event) => clickType.value = "component")
+            }, " 组件库 ", 2)
+          ])
+        ]),
+        createElementVNode("div", _hoisted_3, [
+          clickType.value === "serviceFlowList" ? (openBlock(), createBlock(ServiceList, {
+            key: 0,
+            serviceTreeData: __props.serviceTreeData,
+            onLoadTreeData: loadTreeData,
+            onServiceClick,
+            onClearFlowCanvas: clearFlowCanvas
+          }, null, 8, ["serviceTreeData"])) : (openBlock(), createBlock(ComponentPanel, {
+            key: 1,
+            onDragNode: dragNode
+          }))
+        ])
+      ], 4);
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

package/dist/es/stores/page-store.d.ts

@@ -0,0 +1,23 @@
+interface PageContextVarOptions {
+    [otherProp: string]: any;
+}
+export declare const useServiceFlowStore: import('pinia').StoreDefinition<"serviceFlowStoreUtil", import('pinia')._UnwrapAll<Pick<{
+    pageContext: import('vue').Ref<any>;
+    pageContextVarOptions: import('vue').Ref<PageContextVarOptions>;
+    currentService: import('vue').Ref<any>;
+    setPageContext: (newPageContext: any) => void;
+    getServiceVarOptions: () => any[];
+}, "pageContext" | "pageContextVarOptions" | "currentService">>, Pick<{
+    pageContext: import('vue').Ref<any>;
+    pageContextVarOptions: import('vue').Ref<PageContextVarOptions>;
+    currentService: import('vue').Ref<any>;
+    setPageContext: (newPageContext: any) => void;
+    getServiceVarOptions: () => any[];
+}, never>, Pick<{
+    pageContext: import('vue').Ref<any>;
+    pageContextVarOptions: import('vue').Ref<PageContextVarOptions>;
+    currentService: import('vue').Ref<any>;
+    setPageContext: (newPageContext: any) => void;
+    getServiceVarOptions: () => any[];
+}, "setPageContext" | "getServiceVarOptions">>;
+export {};

package/dist/es/stores/page-store.js

@@ -0,0 +1,79 @@
+import { ref, watch } from "vue";
+import { defineStore } from "pinia";
+const useServiceFlowStore = defineStore("serviceFlowStoreUtil", () => {
+  const pageContext = ref({ modelFields: [] });
+  const currentService = ref({ variables: [] });
+  watch(
+    () => pageContext.value.modelFields,
+    (newValue, oldValue) => {
+      console.log("pageContext.value.modelFields 改变", newValue, oldValue);
+      setPageContextVarOptions(pageContext.value);
+    }
+  );
+  const pageContextVarOptions = ref({
+    dataOptions: [],
+    systemVarOptions: [],
+    pageVarOptions: []
+  });
+  function setPageContext(newPageContext) {
+    pageContext.value = newPageContext;
+    setPageContextVarOptions(newPageContext);
+  }
+  function setPageContextVarOptions(pageObject) {
+    if (pageObject) {
+      pageObject.modelFields.forEach((element) => {
+        pageContextVarOptions.value.dataOptions.push({
+          value: element.name,
+          label: element.alias,
+          type: element.type
+        });
+      });
+    }
+  }
+  function setVarOptions(variables, parentName, filterArray) {
+    const tempVarOptions = [];
+    if (variables) {
+      variables.forEach((element) => {
+        const item = {
+          code: element.code,
+          value: element.name,
+          label: element.alias,
+          type: element.type
+        };
+        if (parentName) {
+          item.value = `${parentName}.${element.name}`;
+        }
+        if (element.items && element.items.length > 0 && element.type !== "array") {
+          item.items = setVarOptions(element.items, element.name);
+        }
+        tempVarOptions.push(item);
+      });
+    }
+    return tempVarOptions;
+  }
+  function getServiceVarOptions() {
+    let temp = [];
+    if (currentService.value.variables) {
+      currentService.value.variables.forEach((element) => {
+        temp.push({
+          code: element.code,
+          value: element.name,
+          label: element.alias,
+          type: element.type
+        });
+      });
+    }
+    temp = setVarOptions(currentService.value.variables);
+    return temp;
+  }
+  return {
+    pageContext,
+    pageContextVarOptions,
+    currentService,
+    setPageContext,
+    getServiceVarOptions
+  };
+});
+export {
+  useServiceFlowStore
+};

package/dist/lib/designer/common/components/file-upload.css

@@ -0,0 +1,7 @@
+
+[data-v-2d06523b] .el-upload {
+  width: 100%;
+}
+[data-v-2d06523b] .el-button {
+  width: 100%;
+}

package/dist/lib/designer/common/components/file-upload.vue.d.ts

@@ -0,0 +1,20 @@
+declare const _default: import('vue').DefineComponent<{
+    modelValue: {
+        type: ObjectConstructor;
+        default: () => {};
+    };
+}, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (...args: any[]) => void;
+    "on-success": (...args: any[]) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    modelValue: {
+        type: ObjectConstructor;
+        default: () => {};
+    };
+}>> & {
+    "onUpdate:modelValue"?: (...args: any[]) => any;
+    "onOn-success"?: (...args: any[]) => any;
+}, {
+    modelValue: Record<string, any>;
+}, {}>;
+export default _default;

package/dist/lib/designer/common/components/file-upload.vue.js

@@ -0,0 +1,6 @@
+"use strict";
+const fileUpload_vue_vue_type_script_setup_true_lang = require("./file-upload.vue2.js");
+;/* empty css                  */
+const _pluginVue_exportHelper = require("../../../_virtual/_plugin-vue_export-helper.js");
+const fileUpload = /* @__PURE__ */ _pluginVue_exportHelper(fileUpload_vue_vue_type_script_setup_true_lang, [["__scopeId", "data-v-2d06523b"]]);
+module.exports = fileUpload;

package/dist/lib/designer/common/components/file-upload.vue2.js

@@ -0,0 +1,98 @@
+"use strict";
+const vue = require("vue");
+const iconsVue = require("@element-plus/icons-vue");
+const elementPlus = require("element-plus");
+const auth = require("agilebuilder-ui/src/utils/auth");
+const pageStore = require("../../../stores/page-store.js");
+const _sfc_main = /* @__PURE__ */ vue.defineComponent({
+  __name: "file-upload",
+  props: {
+    modelValue: {
+      type: Object,
+      default: () => {
+        return {};
+      }
+    }
+  },
+  emits: ["update:modelValue", "on-success"],
+  setup(__props, { expose: __expose, emit: __emit }) {
+    const serviceFlowStoreUtil = pageStore.useServiceFlowStore();
+    const emits = __emit;
+    const props = __props;
+    const systemCode = vue.ref("");
+    systemCode.value = serviceFlowStoreUtil.pageContext.systemCode;
+    if (!props.modelValue || typeof props.modelValue !== "object") {
+      emits("update:modelValue", {});
+    }
+    const upload = vue.ref();
+    const headers = { Authorization: auth.getToken() };
+    const uploadUrl = window["$vueApp"].config.globalProperties.baseAPI + "/component/super-form/uploads";
+    const fileList = vue.ref([]);
+    if (props.modelValue && props.modelValue.fileUuid) {
+      fileList.value.push({
+        name: props.modelValue.name,
+        url: props.modelValue.fileUuid
+      });
+    }
+    const fileChange = (file, fileList2) => {
+      console.log(file, fileList2, "fileChange");
+    };
+    const handleRemove = (file, uploadFiles) => {
+      console.log(file, uploadFiles);
+      props.modelValue.name = "";
+      props.modelValue.fileUuid = "";
+    };
+    const handleExceed = (files) => {
+      console.log("handleExceed", files);
+      upload.value.clearFiles();
+      const file = files[0];
+      file.uid = elementPlus.genFileId();
+      upload.value.handleStart(file);
+      upload.value.submit();
+    };
+    const handleSuccess = (response, file, fileList2) => {
+      console.log(response, file, fileList2);
+      props.modelValue.name = response.name;
+      props.modelValue.fileUuid = response.serverPath;
+      emits("on-success");
+    };
+    __expose({});
+    return (_ctx, _cache) => {
+      const _component_el_icon = vue.resolveComponent("el-icon");
+      const _component_el_button = vue.resolveComponent("el-button");
+      const _component_el_upload = vue.resolveComponent("el-upload");
+      return vue.openBlock(), vue.createBlock(_component_el_upload, {
+        ref_key: "upload",
+        ref: upload,
+        name: "file",
+        data: { systemCode: systemCode.value, isExport: true },
+        "auto-upload": true,
+        action: uploadUrl,
+        headers,
+        limit: 1,
+        "on-change": fileChange,
+        "on-exceed": handleExceed,
+        "on-remove": handleRemove,
+        "on-success": handleSuccess,
+        "file-list": fileList.value
+      }, {
+        default: vue.withCtx(() => [
+          vue.createVNode(_component_el_button, null, {
+            default: vue.withCtx(() => [
+              vue.createTextVNode(" 上传附件"),
+              vue.createVNode(_component_el_icon, { class: "el-icon--right" }, {
+                default: vue.withCtx(() => [
+                  vue.createVNode(vue.unref(iconsVue.Upload))
+                ]),
+                _: 1
+              })
+            ]),
+            _: 1
+          })
+        ]),
+        _: 1
+      }, 8, ["data", "file-list"]);
+    };
+  }
+});
+module.exports = _sfc_main;

package/dist/lib/designer/common/components/json-view/index.d.ts

@@ -0,0 +1,4 @@
+import { default as JsonView } from './json-view.vue';
+import { default as JsonViewDialog } from './json-view-dialog.vue';
+
+export { JsonView, JsonViewDialog };

package/dist/lib/designer/common/components/json-view/json-view-dialog.vue.d.ts

@@ -0,0 +1,36 @@
+declare const _default: import('vue').DefineComponent<{
+    jsonObject: {
+        type: ObjectConstructor;
+        default: () => void;
+    };
+    appendToBody: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    modelValue: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (...args: any[]) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    jsonObject: {
+        type: ObjectConstructor;
+        default: () => void;
+    };
+    appendToBody: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    modelValue: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & {
+    "onUpdate:modelValue"?: (...args: any[]) => any;
+}, {
+    modelValue: boolean;
+    appendToBody: boolean;
+    jsonObject: Record<string, any>;
+}, {}>;
+export default _default;

package/dist/lib/designer/common/components/json-view/json-view-dialog.vue.js

@@ -0,0 +1,60 @@
+"use strict";
+const vue = require("vue");
+const jsonView_vue_vue_type_script_setup_true_lang = require("./json-view.vue.js");
+const _sfc_main = /* @__PURE__ */ vue.defineComponent({
+  ...{
+    name: "JsonViewDialog",
+    inheritAttrs: false
+  },
+  __name: "json-view-dialog",
+  props: {
+    jsonObject: {
+      type: Object,
+      default: () => {
+      }
+    },
+    appendToBody: {
+      type: Boolean,
+      default: false
+    },
+    modelValue: {
+      type: Boolean,
+      default: false
+    }
+  },
+  emits: ["update:modelValue"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emits = __emit;
+    const showJsonVisible = vue.ref(false);
+    vue.watch(
+      () => props.modelValue,
+      (newVal) => {
+        if (newVal) {
+          showJsonVisible.value = true;
+        }
+      }
+    );
+    const close = () => {
+      showJsonVisible.value = false;
+      emits("update:modelValue", false);
+    };
+    return (_ctx, _cache) => {
+      const _component_el_dialog = vue.resolveComponent("el-dialog");
+      return vue.openBlock(), vue.createBlock(_component_el_dialog, {
+        modelValue: showJsonVisible.value,
+        "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => showJsonVisible.value = $event),
+        "append-to-body": __props.appendToBody,
+        title: "格式化",
+        width: "600",
+        onClose: close
+      }, {
+        default: vue.withCtx(() => [
+          vue.createVNode(jsonView_vue_vue_type_script_setup_true_lang, { jsonObject: __props.jsonObject }, null, 8, ["jsonObject"])
+        ]),
+        _: 1
+      }, 8, ["modelValue", "append-to-body"]);
+    };
+  }
+});
+module.exports = _sfc_main;

package/dist/lib/designer/common/components/json-view/json-view-dialog.vue2.js

@@ -0,0 +1,3 @@
+"use strict";
+const jsonViewDialog_vue_vue_type_script_setup_true_lang = require("./json-view-dialog.vue.js");
+module.exports = jsonViewDialog_vue_vue_type_script_setup_true_lang;

package/dist/lib/designer/common/components/json-view/json-view.vue.d.ts

@@ -0,0 +1,32 @@
+declare const _default: import('vue').DefineComponent<{
+    jsonObject: {
+        type: ObjectConstructor;
+        default: () => void;
+    };
+    height: {
+        type: NumberConstructor;
+        default: number;
+    };
+    theme: {
+        type: StringConstructor;
+        default: any;
+    };
+}, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    jsonObject: {
+        type: ObjectConstructor;
+        default: () => void;
+    };
+    height: {
+        type: NumberConstructor;
+        default: number;
+    };
+    theme: {
+        type: StringConstructor;
+        default: any;
+    };
+}>>, {
+    height: number;
+    jsonObject: Record<string, any>;
+    theme: string;
+}, {}>;
+export default _default;

package/dist/lib/designer/common/components/json-view/json-view.vue.js

@@ -0,0 +1,141 @@
+"use strict";
+const vue = require("vue");
+const codemirror = require("codemirror");
+const langJson = require("@codemirror/lang-json");
+const state = require("@codemirror/state");
+const codemirrorThemesAll = require("@uiw/codemirror-themes-all");
+const _sfc_main = /* @__PURE__ */ vue.defineComponent({
+  ...{
+    name: "JsonView",
+    inheritAttrs: false
+  },
+  __name: "json-view",
+  props: {
+    jsonObject: {
+      type: Object,
+      default: () => {
+      }
+    },
+    height: {
+      type: Number,
+      default: 0
+    },
+    theme: {
+      type: String,
+      default: null
+    }
+  },
+  setup(__props) {
+    const props = __props;
+    const editor = vue.ref(null);
+    const cfCodemirrorJsonViewRef = vue.ref();
+    const codemirrorHeight = vue.ref("400px");
+    vue.watch(
+      () => props.jsonObject,
+      (newVal) => {
+        if (editor.value) {
+          loadEditor();
+        }
+      },
+      { deep: true }
+    );
+    vue.onMounted(() => {
+      vue.nextTick(() => {
+        loadEditor();
+      });
+    });
+    function loadEditor() {
+      if (editor.value) {
+        editor.value.destroy();
+      }
+      const jsonStr = props.jsonObject ? JSON.stringify(props.jsonObject, null, 2) : "";
+      if (props.height) {
+        codemirrorHeight.value = props.height + "px";
+      } else {
+        if (cfCodemirrorJsonViewRef.value) {
+          const rect = cfCodemirrorJsonViewRef.value.getBoundingClientRect();
+          if (rect.y || rect.y === 0) {
+            console.log("window.innerHeight - rect.y", window.innerHeight, rect.y);
+            codemirrorHeight.value = window.innerHeight - rect.y - 100 + "px";
+          }
+        }
+      }
+      const state2 = getEditorState(jsonStr);
+      let element = document.getElementById("cf-codemirror-view-json");
+      if (element) {
+        editor.value = new codemirror.EditorView({
+          state: state2,
+          parent: element
+        });
+      }
+    }
+    function getEditorState(jsonStr) {
+      const mytheme = getTheme();
+      const baseTheme = codemirror.EditorView.theme({
+        ".cm-content, .cm-gutter": { minHeight: codemirrorHeight.value },
+        "&": {
+          height: codemirrorHeight.value,
+          maxHeight: codemirrorHeight.value,
+          fontSize: "12px"
+        }
+      });
+      return state.EditorState.create({
+        doc: jsonStr,
+        extensions: [
+          state.EditorState.tabSize.of(16),
+          codemirror.basicSetup,
+          langJson.jsonLanguage,
+          mytheme,
+          baseTheme,
+          readOnlyFacet.of(true),
+          preventChanges
+        ]
+      });
+    }
+    const readOnlyFacet = state.Facet.define({ combine: (values) => values.some((a) => a) });
+    const preventChanges = state.EditorState.transactionFilter.of((tr) => {
+      if (tr.isUserEvent && tr.docChanged && tr.state.facet(readOnlyFacet)) {
+        return {
+          changes: {
+            from: tr.changes.from,
+            to: tr.changes.to,
+            insert: tr.startState.doc.sliceString(tr.changes.from, tr.changes.to)
+          }
+        };
+      }
+      return tr;
+    });
+    function getTheme() {
+      if (props.theme) {
+        switch (props.theme) {
+          case "xcodeLight":
+            return codemirrorThemesAll.xcodeLight;
+          case "xcodeDark":
+            return codemirrorThemesAll.xcodeDark;
+          case "vscodeDark":
+            return codemirrorThemesAll.vscodeDark;
+          case "dracula":
+            return codemirrorThemesAll.dracula;
+          case "githubLight":
+            return codemirrorThemesAll.githubLight;
+          case "githubDark":
+            return codemirrorThemesAll.githubDark;
+          case "eclipse":
+            return codemirrorThemesAll.eclipse;
+        }
+      }
+      return codemirror.EditorView.theme({});
+    }
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createElementBlock("div", {
+        style: {
+          width: "100%"
+        },
+        ref_key: "cfCodemirrorJsonViewRef",
+        ref: cfCodemirrorJsonViewRef,
+        id: "cf-codemirror-view-json"
+      }, null, 512);
+    };
+  }
+});
+module.exports = _sfc_main;

package/dist/lib/designer/common/components/json-view/json-view.vue2.js

@@ -0,0 +1,3 @@
+"use strict";
+const jsonView_vue_vue_type_script_setup_true_lang = require("./json-view.vue.js");
+module.exports = jsonView_vue_vue_type_script_setup_true_lang;

package/dist/lib/designer/common/components/value-set-input/index.d.ts

@@ -0,0 +1,3 @@
+import { default as ValueSetInput } from './value-set-input.vue';
+
+export default ValueSetInput;

package/dist/lib/designer/common/components/value-set-input/index.js

@@ -0,0 +1,3 @@
+"use strict";
+const valueSetInput = require("./value-set-input.vue.js");
+module.exports = valueSetInput;

package/dist/lib/designer/common/components/value-set-input/option.d.ts

@@ -0,0 +1,12 @@
+interface Option {
+    value: string | number | boolean;
+    label: string;
+    [otherProp: string]: any;
+}
+declare const contextVarOptions: Option[];
+declare const taskVarOptions: Option[];
+declare function getTypeOptions(types: Array<string>): {
+    value: string;
+    label: string;
+}[];
+export { contextVarOptions, taskVarOptions, getTypeOptions };