@kp-ui/lowcode-pc 1.0.0-alpha.1

package/assets/CustomerModal.mjs

@@ -0,0 +1,210 @@
+import { ref, defineComponent, getCurrentInstance, useAttrs, computed, onMounted, createBlock, openBlock, unref, withCtx, createVNode, mergeProps, nextTick } from "vue";
+import { c as useI18n, V as VFormRender, A as ActionButtonListRender } from "./install.mjs";
+import { useDataQueryApi, useRouteBackTab, routerReloadStatus, TpfConfigProvider, TpfModal } from "tmgc2-share";
+import { Skeleton } from "ant-design-vue";
+const useLowcode = (params) => {
+  let { formCode, entityCode, type = "add", basicFieldsEnums } = params;
+  const isLoading = ref(false);
+  const useDataQuery = useDataQueryApi();
+  const vfdRef = ref();
+  const formConfig = ref();
+  const { routeBackTab } = useRouteBackTab();
+  const insertBtn = (list = []) => {
+    return list;
+  };
+  const getInitRenderJSON = (list = []) => {
+    if (!basicFieldsEnums) {
+      return [];
+    }
+    const res = list.reduce((t, v) => {
+      const fn = basicFieldsEnums[v.componentType];
+      if (fn) {
+        const json = fn({
+          name: v.entityPropertyCode,
+          label: v.entityPropertyName,
+          ...v.options
+        });
+        t = [...t, json];
+      }
+      return t;
+    }, []);
+    return res.length ? insertBtn(res) : res;
+  };
+  const getComponentJson = async (list = [], _formCode) => {
+    var _a, _b;
+    let json = { widgetList: [], formConfig: {} };
+    formCode = _formCode || formCode;
+    if (formCode && type) {
+      (_a = vfdRef.value) == null ? void 0 : _a.setLoading(true);
+      try {
+        const res = await useDataQuery.dataQueryDetail({ code: formCode }, "FormDefinitionManagement").then((res2) => res2.data.object || {});
+        json = JSON.parse(res.frontendDefinition || "{}");
+      } finally {
+        (_b = vfdRef.value) == null ? void 0 : _b.setLoading(false);
+      }
+    } else {
+      json.widgetList = getInitRenderJSON(list);
+    }
+    isLoading.value = false;
+    console.log("json: ", json);
+    formConfig.value = json.formConfig;
+    vfdRef.value.setFormJson(json);
+    return json;
+  };
+  const getFieldList = async () => {
+    isLoading.value = true;
+    if (!entityCode) {
+      getComponentJson([]);
+      return [];
+    }
+    const p = {
+      pageCode: "EntityPropertyFormItem",
+      conditions: [{ fieldCode: "entityCode", type: "EQ", value: entityCode }],
+      requiredFields: ["entityPropertyCode", "entityPropertyName", "valueType"],
+      page: 1,
+      pageSize: null,
+      sorts: []
+    };
+    const list = await useDataQuery.execute(p).then((res) => res.data.object.list);
+    getComponentJson(list);
+    return list;
+  };
+  const fieldListApi = async () => {
+    const list = await getFieldList();
+    return list.map((item) => ({
+      showName: item.entityPropertyName,
+      fieldCode: item.entityPropertyCode
+    }));
+  };
+  const goBack = (reloadStatus = routerReloadStatus.view, cb) => {
+    routeBackTab(reloadStatus, cb);
+  };
+  return {
+    isLoading,
+    goBack,
+    formConfig,
+    getInitRenderJSON,
+    vfdRef,
+    getComponentJson,
+    getFieldList,
+    fieldListApi
+  };
+};
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "CustomerModal",
+  props: {
+    title: {},
+    type: {},
+    formCode: {}
+  },
+  setup(__props, {
+    expose: __expose
+  }) {
+    const {
+      i18nt
+    } = useI18n();
+    const instance = getCurrentInstance();
+    const attrs = useAttrs() || {};
+    const visible = ref(false);
+    const props = __props;
+    const vfCtx = computed(() => {
+      var _a, _b;
+      return {
+        $router: instance.proxy.$router,
+        _id: ((_b = (_a = attrs == null ? void 0 : attrs.row) == null ? void 0 : _a.record) == null ? void 0 : _b._id) || null,
+        type: props.type,
+        instance,
+        ...attrs
+      };
+    });
+    const isDisabled = ref(false);
+    const {
+      vfdRef,
+      formConfig,
+      getComponentJson,
+      isLoading
+    } = useLowcode({
+      formCode: props.formCode,
+      type: props.type
+    });
+    const leftNum = ref(null);
+    const title = computed(() => {
+      if (props.title) return props.title;
+      if (props.type === "add") return "新增";
+      if (props.type === "edit") return "编辑";
+      if (props.type === "view") return "查看";
+      return "新增";
+    });
+    const show = async () => {
+      visible.value = true;
+      await nextTick();
+      await getComponentJson([]);
+      console.log("attrs", attrs);
+    };
+    const setleftText = (number) => {
+      leftNum.value = number;
+    };
+    const setDisabled = (status) => {
+      isDisabled.value = status;
+    };
+    onMounted(() => {
+      show();
+    });
+    const handleCloseDialog = () => {
+      visible.value = false;
+    };
+    const handleButtonClick = async ({
+      item,
+      result
+    }) => {
+      if (item.name === "cancelButton") {
+        return handleCloseDialog();
+      }
+      if (result !== false) {
+        handleCloseDialog();
+      }
+    };
+    __expose({
+      handleCloseDialog,
+      i18nt,
+      setDisabled,
+      setleftText
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(unref(TpfConfigProvider), null, {
+        default: withCtx(() => [createVNode(unref(TpfModal), mergeProps({
+          visible: visible.value,
+          "onUpdate:visible": _cache[0] || (_cache[0] = ($event) => visible.value = $event)
+        }, _ctx.$attrs, {
+          title: title.value,
+          leftNum: leftNum.value
+        }), {
+          footerRight: withCtx(() => {
+            var _a, _b;
+            return [createVNode(ActionButtonListRender, {
+              buttonList: ((_a = unref(formConfig)) == null ? void 0 : _a.buttonList) || [],
+              ctx: (_b = unref(vfdRef)) == null ? void 0 : _b.context,
+              onOnClick: handleButtonClick
+            }, null, 8, ["buttonList", "ctx"])];
+          }),
+          default: withCtx(() => [createVNode(unref(Skeleton), {
+            active: "",
+            loading: unref(isLoading)
+          }, {
+            default: withCtx(() => [createVNode(VFormRender, {
+              vfCtx: vfCtx.value,
+              ref_key: "vfdRef",
+              ref: vfdRef
+            }, null, 8, ["vfCtx"])]),
+            _: 1
+          }, 8, ["loading"])]),
+          _: 1
+        }, 16, ["visible", "title", "leftNum"])]),
+        _: 1
+      });
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

package/assets/bpmn-editor-widget.mjs

@@ -0,0 +1,71 @@
+import { defineComponent, ref, watchEffect, createBlock, createCommentVNode, unref, openBlock, mergeProps, withCtx, createElementVNode } from "vue";
+import FormItemWrapper from "./form-item-wrapper.mjs";
+import { u as useField } from "./useField.mjs";
+import BpmnViewer from "bpmn-js/lib/Viewer";
+import { C as ComponentNameEnum, W as WidgetTypeEnum, _ as _export_sfc } from "./install.mjs";
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  ...{
+    name: WidgetTypeEnum.bpmnEditor,
+    componentName: ComponentNameEnum.FieldWidget
+  },
+  __name: "bpmn-editor-widget",
+  props: {
+    widget: {},
+    field: {},
+    designer: {},
+    parentWidget: {},
+    parentList: {},
+    indexOfParentList: {},
+    subFormRowIndex: {},
+    subFormRowId: {},
+    subFormColIndex: {}
+  },
+  setup(__props, { expose: __expose }) {
+    const props = __props;
+    const { rules, fieldEditor, fieldModel, handleHidden, defineExposed } = useField(props);
+    const bpmnModeler = ref();
+    const preview = (xml) => {
+      if (bpmnModeler.value && bpmnModeler.value.destroy) {
+        bpmnModeler.value.destroy();
+      }
+      bpmnModeler.value = new BpmnViewer({ container: fieldEditor.value });
+      const viewer = bpmnModeler.value;
+      bpmnModeler.value.importXML(xml, (err) => {
+        if (err) {
+          console.error(err);
+        } else {
+          const canvas = viewer.get("canvas");
+          canvas.zoom("fit-viewport");
+        }
+      });
+    };
+    watchEffect(() => {
+      if (fieldModel.value) {
+        preview(fieldModel.value);
+      } else {
+        if (bpmnModeler.value && bpmnModeler.value.destroy) {
+          bpmnModeler.value.destroy();
+        }
+      }
+    });
+    __expose({
+      ...defineExposed
+    });
+    return (_ctx, _cache) => {
+      return !unref(handleHidden) ? (openBlock(), createBlock(FormItemWrapper, mergeProps({ key: 0 }, props, { rules: unref(rules) }), {
+        default: withCtx(() => [
+          createElementVNode("div", {
+            ref_key: "fieldEditor",
+            ref: fieldEditor,
+            class: "t-w-full t-h-[30vh]"
+          }, null, 512)
+        ]),
+        _: 1
+      }, 16, ["rules"])) : createCommentVNode("", true);
+    };
+  }
+});
+const bpmnEditorWidget = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-038cba28"]]);
+export {
+  bpmnEditorWidget as default
+};

package/assets/button-list-widget.mjs

@@ -0,0 +1,53 @@
+import { defineComponent, computed, createBlock, createCommentVNode, unref, openBlock } from "vue";
+import { C as ComponentNameEnum, W as WidgetTypeEnum, A as ActionButtonListRender, _ as _export_sfc } from "./install.mjs";
+import "ant-design-vue";
+import "@kp-ui/tool";
+import "lodash-es";
+import { useExecFunction } from "tmgc2-share";
+import "vue-router";
+import { u as useField } from "./useField.mjs";
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  ...{
+    name: WidgetTypeEnum.buttonList,
+    componentName: ComponentNameEnum.FieldWidget
+  },
+  __name: "button-list-widget",
+  props: {
+    widget: {},
+    field: {},
+    designer: {},
+    parentWidget: {},
+    parentList: {},
+    indexOfParentList: {},
+    subFormRowIndex: {},
+    subFormRowId: {},
+    subFormColIndex: {}
+  },
+  setup(__props, { expose: __expose }) {
+    const props = __props;
+    const buttonList = computed(() => field.options.buttonList || []);
+    const { fieldEditor, field, designState, handleHidden, defineExposed } = useField(props);
+    const { context } = useExecFunction();
+    __expose({
+      buttonList,
+      ...defineExposed
+    });
+    return (_ctx, _cache) => {
+      return !unref(handleHidden) ? (openBlock(), createBlock(unref(ActionButtonListRender), {
+        key: 0,
+        ref_key: "fieldEditor",
+        ref: fieldEditor,
+        options: unref(field).options,
+        designState: unref(designState),
+        buttonList: unref(field).options.buttonList || [],
+        customClass: unref(field).options.customClass || [],
+        flex: unref(field).options.flex,
+        ctx: unref(context)
+      }, null, 8, ["options", "designState", "buttonList", "customClass", "flex", "ctx"])) : createCommentVNode("", true);
+    };
+  }
+});
+const buttonListWidget = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-b51e000d"]]);
+export {
+  buttonListWidget as default
+};

package/assets/button-widget.mjs

@@ -0,0 +1,80 @@
+import { defineComponent, resolveComponent, createBlock, createCommentVNode, unref, openBlock, normalizeClass, withCtx, createTextVNode, toDisplayString } from "vue";
+import { SvgIcon } from "tmgc2-share";
+import { u as useField } from "./useField.mjs";
+import { C as ComponentNameEnum, W as WidgetTypeEnum, _ as _export_sfc } from "./install.mjs";
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  ...{
+    name: WidgetTypeEnum.button,
+    componentName: ComponentNameEnum.FieldWidget
+  },
+  __name: "button-widget",
+  props: {
+    widget: {},
+    field: {},
+    designer: {},
+    parentWidget: {},
+    parentList: {},
+    indexOfParentList: {},
+    subFormRowIndex: {},
+    subFormRowId: {},
+    subFormColIndex: {}
+  },
+  setup(__props, { expose: __expose }) {
+    const props = __props;
+    const {
+      loading,
+      asyncExecuteFunction,
+      fieldEditor,
+      field,
+      size,
+      designState,
+      handleHidden,
+      handleDisabled,
+      defineExposed
+    } = useField(props);
+    const handleButtonWidgetClick = async () => {
+      if (designState) {
+        return;
+      }
+      if (field.options.onClick) {
+        await asyncExecuteFunction({
+          functionBody: field.options.onClick || ""
+        });
+      }
+    };
+    __expose({
+      ...defineExposed,
+      handleButtonWidgetClick
+    });
+    return (_ctx, _cache) => {
+      const _component_a_button = resolveComponent("a-button");
+      return !unref(handleHidden) ? (openBlock(), createBlock(_component_a_button, {
+        key: 0,
+        ref_key: "fieldEditor",
+        ref: fieldEditor,
+        type: unref(field).options.type,
+        size: unref(size),
+        class: normalizeClass([unref(field).options.label === "" ? "hide-text-span" : "", "tpf-button"]),
+        shape: unref(field).options.shape,
+        danger: unref(field).options.danger,
+        ghost: unref(field).options.ghost,
+        disabled: unref(handleDisabled),
+        loading: unref(loading),
+        onClick: handleButtonWidgetClick
+      }, {
+        default: withCtx(() => [
+          unref(field).options.icon ? (openBlock(), createBlock(unref(SvgIcon), {
+            key: 0,
+            "icon-class": unref(field).options.icon
+          }, null, 8, ["icon-class"])) : createCommentVNode("", true),
+          createTextVNode(" " + toDisplayString(unref(field).options.label), 1)
+        ]),
+        _: 1
+      }, 8, ["type", "size", "class", "shape", "danger", "ghost", "disabled", "loading"])) : createCommentVNode("", true);
+    };
+  }
+});
+const buttonWidget = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-7e3e590f"]]);
+export {
+  buttonWidget as default
+};

package/assets/cascader-widget.mjs

@@ -0,0 +1,95 @@
+import { defineComponent, onMounted, computed, resolveComponent, createBlock, createCommentVNode, unref, openBlock, mergeProps, withCtx, createElementVNode, createElementBlock, isRef, toDisplayString } from "vue";
+import FormItemWrapper from "./form-item-wrapper.mjs";
+import { u as useField } from "./useField.mjs";
+import { u as useSelect } from "./useSelect.mjs";
+import { C as ComponentNameEnum, W as WidgetTypeEnum, f as formateCascaderCode } from "./install.mjs";
+const _hoisted_1 = { class: "full-width-input" };
+const _hoisted_2 = {
+  key: 1,
+  class: "readonly-mode-field"
+};
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  ...{
+    name: WidgetTypeEnum.cascader,
+    componentName: ComponentNameEnum.FieldWidget
+  },
+  __name: "cascader-widget",
+  props: {
+    widget: {},
+    field: {},
+    designer: {},
+    parentWidget: {},
+    parentList: {},
+    indexOfParentList: {},
+    subFormRowIndex: {},
+    subFormRowId: {},
+    subFormColIndex: {}
+  },
+  setup(__props, { expose: __expose }) {
+    const props = __props;
+    const {
+      rules,
+      i18nt,
+      fieldEditor,
+      field,
+      fieldModel,
+      isReadMode,
+      size,
+      designState,
+      handleHidden,
+      handleDisabled,
+      handleFocusCustomEvent,
+      handleBlurCustomEvent,
+      defineExposed
+    } = useField(props);
+    const { labelKey, valueKey, childrenKey, initOptionItems } = useSelect({
+      field,
+      fieldModel,
+      designState
+    });
+    onMounted(() => {
+      initOptionItems();
+    });
+    const contentForReadMode = computed(() => {
+      if (!fieldModel.value) return "";
+      return formateCascaderCode(field.options.optionItems, fieldModel.value, {
+        label: labelKey.value,
+        value: valueKey.value,
+        children: childrenKey.value
+      });
+    });
+    __expose({
+      ...defineExposed
+    });
+    return (_ctx, _cache) => {
+      const _component_a_cascader = resolveComponent("a-cascader");
+      return !unref(handleHidden) ? (openBlock(), createBlock(FormItemWrapper, mergeProps({ key: 0 }, props, { rules: unref(rules) }), {
+        default: withCtx(() => [
+          createElementVNode("div", _hoisted_1, [
+            !unref(isReadMode) ? (openBlock(), createBlock(_component_a_cascader, {
+              key: 0,
+              ref_key: "fieldEditor",
+              ref: fieldEditor,
+              size: unref(size),
+              options: unref(field).options.optionItems,
+              value: unref(fieldModel),
+              "onUpdate:value": _cache[0] || (_cache[0] = ($event) => isRef(fieldModel) ? fieldModel.value = $event : null),
+              disabled: unref(handleDisabled),
+              allowClear: unref(field).options.allowClear,
+              placeholder: unref(field).options.placeholder || unref(i18nt)("render.hint.selectPlaceholder"),
+              fieldNames: { value: unref(valueKey), label: unref(labelKey), children: unref(childrenKey) },
+              expandTrigger: "hover",
+              multiple: unref(field).options.multiple,
+              onFocus: unref(handleFocusCustomEvent),
+              onBlur: unref(handleBlurCustomEvent)
+            }, null, 8, ["size", "options", "value", "disabled", "allowClear", "placeholder", "fieldNames", "multiple", "onFocus", "onBlur"])) : (openBlock(), createElementBlock("span", _hoisted_2, toDisplayString(contentForReadMode.value), 1))
+          ])
+        ]),
+        _: 1
+      }, 16, ["rules"])) : createCommentVNode("", true);
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

package/assets/checkbox-widget.mjs

@@ -0,0 +1,89 @@
+import { defineComponent, resolveComponent, createBlock, createCommentVNode, unref, openBlock, mergeProps, withCtx, createElementBlock, isRef, Fragment, renderList, createTextVNode, toDisplayString } from "vue";
+import FormItemWrapper from "./form-item-wrapper.mjs";
+import { u as useSelect } from "./useSelect.mjs";
+import { u as useField } from "./useField.mjs";
+import { C as ComponentNameEnum, W as WidgetTypeEnum } from "./install.mjs";
+const _hoisted_1 = {
+  key: 1,
+  class: "readonly-mode-field"
+};
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  ...{
+    name: WidgetTypeEnum.checkbox,
+    componentName: ComponentNameEnum.FieldWidget
+  },
+  __name: "checkbox-widget",
+  props: {
+    widget: {},
+    field: {},
+    designer: {},
+    parentWidget: {},
+    parentList: {},
+    indexOfParentList: {},
+    subFormRowIndex: {},
+    subFormRowId: {},
+    subFormColIndex: {}
+  },
+  setup(__props, { expose: __expose }) {
+    const props = __props;
+    const {
+      rules,
+      field,
+      designState,
+      fieldModel,
+      isReadMode,
+      fieldEditor,
+      handleHidden,
+      handleDisabled,
+      defineExposed,
+      handleChangeEvent
+    } = useField(props);
+    const { optionLabel } = useSelect({
+      fieldModel,
+      field: props.field,
+      designState
+    });
+    __expose({
+      ...defineExposed
+    });
+    return (_ctx, _cache) => {
+      const _component_a_checkbox = resolveComponent("a-checkbox");
+      const _component_a_checkbox_group = resolveComponent("a-checkbox-group");
+      return !unref(handleHidden) ? (openBlock(), createBlock(FormItemWrapper, mergeProps({ key: 0 }, props, { rules: unref(rules) }), {
+        default: withCtx(() => [
+          !unref(isReadMode) ? (openBlock(), createBlock(_component_a_checkbox_group, {
+            key: 0,
+            ref_key: "fieldEditor",
+            ref: fieldEditor,
+            value: unref(fieldModel),
+            "onUpdate:value": _cache[0] || (_cache[0] = ($event) => isRef(fieldModel) ? fieldModel.value = $event : null),
+            disabled: unref(handleDisabled),
+            onChange: unref(handleChangeEvent)
+          }, {
+            default: withCtx(() => [
+              (openBlock(true), createElementBlock(Fragment, null, renderList(unref(field).options.optionItems, (item, index) => {
+                return openBlock(), createBlock(_component_a_checkbox, {
+                  key: index,
+                  value: item[unref(field).options.valueKey],
+                  disabled: item.disabled,
+                  border: unref(field).options.border,
+                  style: {}
+                }, {
+                  default: withCtx(() => [
+                    createTextVNode(toDisplayString(item[unref(field).options.labelKey]), 1)
+                  ]),
+                  _: 2
+                }, 1032, ["value", "disabled", "border"]);
+              }), 128))
+            ]),
+            _: 1
+          }, 8, ["value", "disabled", "onChange"])) : (openBlock(), createElementBlock("span", _hoisted_1, toDisplayString(unref(optionLabel)), 1))
+        ]),
+        _: 1
+      }, 16, ["rules"])) : createCommentVNode("", true);
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

package/assets/code-editor-widget.mjs

@@ -0,0 +1,58 @@
+import { defineComponent, createBlock, createCommentVNode, unref, openBlock, mergeProps, withCtx, createVNode, isRef } from "vue";
+import FormItemWrapper from "./form-item-wrapper.mjs";
+import { u as useField } from "./useField.mjs";
+import { CodeEditor } from "tmgc2-share";
+import { C as ComponentNameEnum, W as WidgetTypeEnum } from "./install.mjs";
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  ...{
+    name: WidgetTypeEnum.codeEditor,
+    componentName: ComponentNameEnum.FieldWidget
+  },
+  __name: "code-editor-widget",
+  props: {
+    widget: {},
+    field: {},
+    designer: {},
+    parentWidget: {},
+    parentList: {},
+    indexOfParentList: {},
+    subFormRowIndex: {},
+    subFormRowId: {},
+    subFormColIndex: {}
+  },
+  setup(__props, { expose: __expose }) {
+    const props = __props;
+    const {
+      rules,
+      fieldEditor,
+      field,
+      fieldModel,
+      isReadMode,
+      handleHidden,
+      handleBlurCustomEvent,
+      defineExposed
+    } = useField(props);
+    __expose({
+      ...defineExposed
+    });
+    return (_ctx, _cache) => {
+      return !unref(handleHidden) ? (openBlock(), createBlock(FormItemWrapper, mergeProps({ key: 0 }, props, { rules: unref(rules) }), {
+        default: withCtx(() => [
+          createVNode(unref(CodeEditor), {
+            mode: unref(field).options.mode,
+            readonly: unref(field).options.readonly || unref(isReadMode),
+            value: unref(fieldModel),
+            "onUpdate:value": _cache[0] || (_cache[0] = ($event) => isRef(fieldModel) ? fieldModel.value = $event : null),
+            ref_key: "fieldEditor",
+            ref: fieldEditor,
+            onBlur: unref(handleBlurCustomEvent)
+          }, null, 8, ["mode", "readonly", "value", "onBlur"])
+        ]),
+        _: 1
+      }, 16, ["rules"])) : createCommentVNode("", true);
+    };
+  }
+});
+export {
+  _sfc_main as default
+};