cnhis-design-vue 3.1.5-beta.13 → 3.1.5-beta.14

package/es/packages/scale-view/src/components/formitem/r-radio2.js

@@ -0,0 +1,227 @@
+import { defineComponent, reactive, watch, createVNode, resolveComponent, isVNode } from 'vue';
+import { NRadioGroup, NRadio, NInput, NIcon } from 'naive-ui';
+import { api } from 'v-viewer';
+import { SearchOutline } from '@vicons/ionicons5';
+import chooseCommon from '../composables/choose-common2.js';
+
+function _isSlot(s) {
+  return typeof s === "function" || Object.prototype.toString.call(s) === "[object Object]" && !isVNode(s);
+}
+var scriptRadio = defineComponent({
+  name: "RRadio",
+  components: {
+    NRadioGroup,
+    NRadio,
+    NInput,
+    NIcon
+  },
+  props: {
+    form: {
+      type: Object,
+      default: () => {
+      }
+    },
+    item: {
+      type: Object,
+      default: () => {
+      }
+    },
+    isLock: {
+      type: Boolean,
+      default: false
+    }
+  },
+  emits: ["scaleChange"],
+  setup(props, context) {
+    var _a, _b;
+    const state = reactive({
+      curvalue: "",
+      othersText: "",
+      curOptions: [],
+      optionsPreSuffixObj: {}
+    });
+    const {
+      choiceColor,
+      showImgWrap,
+      handleDefPreSuffix,
+      choiceUseKey,
+      isRadioItem,
+      showPreSuffix,
+      handleOptions
+    } = chooseCommon(props, state);
+    const chooseStyleSetting = ((_b = (_a = props.item) == null ? void 0 : _a.setting) == null ? void 0 : _b.chooseStyleSetting) || 1;
+    const handlePreview = (e, url, i) => {
+      e.preventDefault();
+      e.stopPropagation();
+      let imgs = state.curOptions.map((v) => v.imageUrl);
+      if (!imgs.length)
+        return;
+      api({
+        images: imgs,
+        options: {
+          toolbar: true,
+          initialViewIndex: i
+        }
+      });
+    };
+    const handleRadioDef = (item, curValue, options) => {
+      state.curOptions = handleOptions(options);
+      if (!options.length || !curValue)
+        return;
+      if (item.type === "EVALUATE_RADIO_BLOCK") {
+        state.curvalue = curValue;
+        radioChange();
+        return;
+      }
+      let hasOther = options.find((v) => v.value === curValue);
+      if (hasOther) {
+        state.curvalue = hasOther.key;
+        radioChange();
+        return;
+      }
+      let preSuffixItem = options.find((v, i) => {
+        let res = handleDefPreSuffix(v, i, curValue);
+        if (res) {
+          state.curvalue = res;
+        }
+        return !!res || false;
+      });
+      if (!preSuffixItem) {
+        state.othersText = curValue;
+        state.curvalue = "other";
+      }
+      radioChange();
+    };
+    const handleDef = (value) => {
+      var _a2;
+      let options = value.options || [];
+      let valueDef = props.form[props.item.val_key];
+      if (props.item.type === "EVALUATE_RADIO_BLOCK") {
+        options = ((_a2 = value.scoreConfigs) == null ? void 0 : _a2.scoreRules) || [];
+      }
+      const defVal = value.dbValue || value.setting.defaultValue || valueDef;
+      handleRadioDef(value, defVal, options);
+    };
+    const radioChange = () => {
+      let choiceObj = {
+        othersText: state.othersText,
+        optionsPreSuffixObj: state.optionsPreSuffixObj
+      };
+      context.emit("scaleChange", state.curvalue, props.item, {
+        choiceObj,
+        isSetObj: isRadioItem.value
+      });
+    };
+    watch(() => props.item, (value) => {
+      if (!value || !Object.keys(value).length)
+        return;
+      handleDef(value);
+    }, {
+      immediate: true
+    });
+    const inputPreSuffixChange = (o, i) => {
+      state.curvalue = o.key;
+      let choiceObj = {
+        othersText: state.othersText,
+        optionsPreSuffixObj: state.optionsPreSuffixObj
+      };
+      console.log(state.optionsPreSuffixObj);
+      context.emit("scaleChange", state.curvalue, props.item, {
+        choiceObj,
+        isSetObj: isRadioItem.value
+      });
+    };
+    const inputChange = () => {
+      let choiceObj = {
+        othersText: state.othersText,
+        optionsPreSuffixObj: state.optionsPreSuffixObj
+      };
+      state.curvalue = "other";
+      context.emit("scaleChange", "other", props.item, {
+        choiceObj,
+        isSetObj: isRadioItem.value
+      });
+    };
+    const renderImg = (o, i) => {
+      return createVNode("span", {
+        "class": "scale-choice-img-wrap"
+      }, [createVNode("img", {
+        "class": "show-picture",
+        "src": o.imageUrl
+      }, null), createVNode("div", {
+        "class": "scale-preview-wrap"
+      }, [createVNode(NIcon, {
+        "size": "24",
+        "color": "#fff",
+        "component": SearchOutline,
+        "onClick": (e) => handlePreview(e, o.imageUrl, i)
+      }, null)])]);
+    };
+    const renderPresuffix = (o, i) => {
+      return createVNode("div", {
+        "class": "presuffix-wrap"
+      }, [o.prefix && createVNode("span", {
+        "class": "prefix-span",
+        "style": {
+          color: choiceColor.value(o)
+        }
+      }, [o.prefix]), createVNode(resolveComponent("n-input"), {
+        "value": state.optionsPreSuffixObj[o.key],
+        "onUpdate:value": ($event) => state.optionsPreSuffixObj[o.key] = $event,
+        "disabled": props.isLock,
+        "style": {
+          color: choiceColor.value(o)
+        },
+        "placeholder": "\u8BF7\u8F93\u5165",
+        "bordered": false,
+        "onInput": () => inputPreSuffixChange(o)
+      }, null), o.suffix && createVNode("span", {
+        "class": "suffix-span",
+        "style": {
+          color: choiceColor.value(o)
+        }
+      }, [o.suffix])]);
+    };
+    const renderDefault = (o) => {
+      return createVNode("span", {
+        "style": {
+          color: choiceColor.value(o)
+        }
+      }, [o.label]);
+    };
+    const renderOther = (o) => {
+      return createVNode(resolveComponent("n-input"), {
+        "value": state.othersText,
+        "onUpdate:value": [($event) => state.othersText = $event, inputChange],
+        "disabled": props.isLock,
+        "style": {
+          color: choiceColor.value(o)
+        },
+        "placeholder": "\u8BF7\u8F93\u5165",
+        "bordered": false
+      }, null);
+    };
+    const hasPreSuffix = (o) => {
+      return isRadioItem.value && showPreSuffix.value(o);
+    };
+    let opKey = choiceUseKey.value;
+    return () => {
+      let _slot;
+      return createVNode(NRadioGroup, {
+        "value": state.curvalue,
+        "onUpdate:value": [($event) => state.curvalue = $event, radioChange],
+        "class": ["c-choice-wrap", "choice-wrap-" + chooseStyleSetting],
+        "disabled": props.isLock
+      }, _isSlot(_slot = state.curOptions.map((o, i) => createVNode(resolveComponent("n-radio"), {
+        "key": o.value,
+        "value": o[opKey]
+      }, {
+        default: () => [showImgWrap.value(o) && renderImg(o, i), hasPreSuffix(o) && renderPresuffix(o), !hasPreSuffix(o) && renderDefault(o), o.importability && renderOther(o)]
+      }))) ? _slot : {
+        default: () => [_slot]
+      });
+    };
+  }
+});
+
+export { scriptRadio as default };

package/es/packages/scale-view/src/components/formitem/r-select.js

@@ -0,0 +1 @@
+export { default } from './r-select2.js';

package/es/packages/scale-view/src/components/formitem/r-select2.js

@@ -0,0 +1,149 @@
+import { defineComponent, reactive, computed, watch, createVNode, resolveComponent } from 'vue';
+import { NSelect, NEmpty } from 'naive-ui';
+import '../LoadingCom2.js';
+import script from '../LoadingCom.vue_vue_type_script_setup_true_lang.js';
+
+var scriptSelect = defineComponent({
+  name: "RSelect",
+  components: {
+    NSelect,
+    NEmpty,
+    LoadingCom: script
+  },
+  props: {
+    form: {
+      type: Object,
+      default: () => {
+      }
+    },
+    item: {
+      type: Object,
+      default: () => {
+      }
+    },
+    isLock: {
+      type: Boolean,
+      default: false
+    },
+    getSelectOptions: {
+      type: Function,
+      default: () => Promise.resolve([])
+    },
+    getSearchOptions: {
+      type: Function,
+      default: () => Promise.resolve([])
+    },
+    openType: {
+      type: String,
+      default: ""
+    }
+  },
+  emits: ["scaleChange"],
+  setup(props, context) {
+    const state = reactive({
+      choiceValue: [],
+      selectParams: {
+        tableType: "TABLE_LIST",
+        pageSize: 20,
+        page: 1
+      },
+      cloneItem: {},
+      columnName: "",
+      showField: "",
+      curOptions: [],
+      fieldList: [],
+      buttonList: [],
+      fetching: false
+    });
+    props.openType == "formIframe";
+    const isMultiple = computed(() => {
+      var _a, _b;
+      return !!((_b = (_a = props.item) == null ? void 0 : _a.setting) == null ? void 0 : _b.isMultiple);
+    });
+    const initSelectOptions = async () => {
+      const {
+        targetSource,
+        type,
+        options = [],
+        optionType = 1
+      } = state.cloneItem;
+      state.showField = "label";
+      if (!(targetSource == null ? void 0 : targetSource.target_id))
+        return;
+      if (options.length || optionType == 3) {
+        state.curOptions = options;
+        return;
+      }
+      try {
+        state.fetching = true;
+        state.curOptions = await props.getSelectOptions(state.cloneItem);
+        state.fetching = false;
+        state.columnName = targetSource == null ? void 0 : targetSource.values;
+        state.showField = (targetSource == null ? void 0 : targetSource.showField) || (targetSource == null ? void 0 : targetSource.values);
+      } catch (err) {
+        state.fetching = false;
+      }
+    };
+    const handleDef = (value) => {
+      var _a;
+      state.cloneItem = JSON.parse(JSON.stringify(value));
+      let options = state.cloneItem.options || [];
+      if (value.type === "EVALUATE_SELECT") {
+        options = ((_a = state.cloneItem.scoreConfigs) == null ? void 0 : _a.scoreRules) || [];
+      }
+      state.curOptions = options;
+      initSelectOptions();
+    };
+    const handleSelectChange = (value) => {
+      let res = {
+        value: "",
+        list: []
+      };
+      let matchItem;
+      if (!value || !Array.isArray(value)) {
+        res.value = value;
+        matchItem = addItem(value);
+        matchItem && res.list.push(matchItem);
+        context.emit("scaleChange", res, props.item, res);
+        return;
+      }
+      res.value = value;
+      if (!value.length) {
+        res.list = [];
+        context.emit("scaleChange", res, props.item, res);
+        return;
+      }
+      value.forEach((item) => {
+        matchItem = addItem(item);
+        matchItem && res.list.push(matchItem);
+      });
+      context.emit("scaleChange", res, props.item, res);
+    };
+    const addItem = (item) => {
+      return state.curOptions.find((v) => v.value === item);
+    };
+    watch(() => props.item, (value) => {
+      if (!value || !Object.keys(value).length)
+        return;
+      handleDef(value);
+    }, {
+      immediate: true
+    });
+    return () => {
+      return createVNode(resolveComponent("n-select"), {
+        "value": props.form[props.item.val_key],
+        "onUpdate:value": [($event) => props.form[props.item.val_key] = $event, handleSelectChange],
+        "filterable": true,
+        "placeholder": "\u8BF7\u9009\u62E9",
+        "multiple": isMultiple.value,
+        "disabled": props.isLock,
+        "loading": state.fetching,
+        "options": state.curOptions
+      }, {
+        empty: () => state.fetching ? createVNode(script, null, null) : createVNode(NEmpty, null, null)
+      });
+    };
+  }
+});
+
+export { scriptSelect as default };

package/es/packages/scale-view/src/components/formitem/r-upload.js

@@ -0,0 +1 @@
+export { default } from './r-upload2.js';

package/es/packages/scale-view/src/components/formitem/r-upload2.js

@@ -0,0 +1,210 @@
+import { defineComponent, reactive, createVNode, resolveComponent, createTextVNode } from 'vue';
+import { NUpload, NUploadDragger, NModal, NIcon, useMessage } from 'naive-ui';
+import { Add, CameraOutline } from '@vicons/ionicons5';
+import vexutils from '../..\\..\\..\\../src/utils/vexutils';
+
+var RUpload = defineComponent({
+  name: "RUpload",
+  components: {
+    NUpload,
+    NUploadDragger,
+    NModal,
+    NIcon
+  },
+  props: {
+    form: {
+      type: Object,
+      default: () => {
+      }
+    },
+    item: {
+      type: Object,
+      default: () => {
+      }
+    },
+    isLock: {
+      type: Boolean,
+      default: false
+    },
+    uploadPictureUrl: {
+      type: String,
+      default: ""
+    },
+    uploadFileUrl: {
+      type: String,
+      default: ""
+    }
+  },
+  emits: ["scaleChange"],
+  setup(props, context) {
+    var _a, _b;
+    const message = useMessage();
+    const type = props.item.type;
+    const limitPic = ((_b = (_a = props.item) == null ? void 0 : _a.setting) == null ? void 0 : _b.limitPic) || 1;
+    const max = isNaN(limitPic) ? void 0 : +limitPic;
+    let state = reactive({
+      defaultFileList: [],
+      fileList: [],
+      previewVisible: false,
+      previewImage: ""
+    });
+    const handleDef = () => {
+      let value = props.form[props.item.val_key];
+      if (!value)
+        return;
+      value.forEach((v) => {
+        v.status = "finished";
+        v.id = v.uid;
+      });
+      state.defaultFileList = value;
+      state.fileList = value;
+    };
+    handleDef();
+    const handleUploadChange = (info) => {
+      var _a2;
+      const {
+        file,
+        fileList,
+        event
+      } = info;
+      if (file.status == "remove") {
+        let curIndex = state.fileList.findIndex((v) => v.uid === file.id);
+        curIndex > -1 && fileList.splice(curIndex, 1);
+      }
+      if (!fileList.length) {
+        state.fileList = [];
+        context.emit("scaleChange", state.fileList, props.item);
+        return;
+      }
+      let matchItem;
+      if (file.status == "uploading" && file.file) {
+        matchItem = state.fileList.find((v) => v.uid === file.id);
+        if (!matchItem) {
+          state.fileList.push({
+            name: file.name,
+            uid: file.id,
+            size: file.file.size
+          });
+        }
+      }
+      if (!event)
+        return;
+      if (event.type == "error") {
+        message.error(file.response.resultMsg || "\u4E0A\u4F20\u5931\u8D25\uFF01");
+        return;
+      }
+      if (event.type === "load") {
+        let {
+          response = {}
+        } = event.target;
+        if (response && vexutils.isJSON(response)) {
+          response = JSON.parse(response);
+        }
+        if (response.result != "SUCCESS") {
+          message.error(file.response.resultMsg || "\u4E0A\u4F20\u5931\u8D25\uFF01");
+          return;
+        }
+        matchItem = state.fileList.find((v) => v.uid === file.id);
+        if (matchItem) {
+          matchItem.url = (_a2 = response.map) == null ? void 0 : _a2.url;
+        }
+        let useFileList = state.fileList.filter((v) => v.url);
+        context.emit("scaleChange", useFileList, props.item);
+      }
+    };
+    const beforeUpload = (info) => {
+      var _a2;
+      let {
+        file
+      } = info;
+      let size = ((_a2 = file.file) == null ? void 0 : _a2.size) || 0;
+      const isJpgOrPng = file.type === "image/jpeg" || file.type === "image/png";
+      if (!isJpgOrPng) {
+        message.error("\u4EC5\u652F\u6301jpeg/png\u683C\u5F0F");
+      }
+      const isLt2M = size / 1024 / 1024 < 2;
+      if (!isLt2M) {
+        message.error("\u4E0A\u4F20\u56FE\u7247\u9650\u5236\u57282MB\u4EE5\u5185");
+      }
+      return isJpgOrPng && isLt2M;
+    };
+    const handlePreview = (file) => {
+      let fileList = state.fileList;
+      if (!fileList.length)
+        return;
+      let matchItem = fileList.find((v) => v.uid === file.id);
+      if (!matchItem)
+        return;
+      state.previewImage = matchItem.url;
+      state.previewVisible = true;
+    };
+    const renderPicture = () => {
+      return createVNode(resolveComponent("n-upload"), {
+        "action": props.uploadPictureUrl,
+        "default-file-list": state.defaultFileList,
+        "accept": "image/*",
+        "list-type": "image-card",
+        "max": max,
+        "disabled": props.isLock,
+        "on-before-upload": beforeUpload,
+        "on-change": handleUploadChange,
+        "on-preview": handlePreview
+      }, {
+        default: () => [createVNode("div", {
+          "class": "upload-img-wrap"
+        }, [createVNode(NIcon, {
+          "class": "prompt-icon",
+          "size": "28",
+          "component": CameraOutline
+        }, null), createTextVNode("\u70B9\u51FB\u4E0A\u4F20")])]
+      });
+    };
+    const renderFile = () => {
+      return createVNode(resolveComponent("n-upload"), {
+        "multiple": true,
+        "directory-dnd": true,
+        "disabled": props.isLock,
+        "action": props.uploadFileUrl,
+        "default-file-list": state.defaultFileList,
+        "on-change": handleUploadChange
+      }, {
+        default: () => [createVNode(resolveComponent("n-upload-dragger"), null, {
+          default: () => [createVNode("div", {
+            "class": "dragger-upload-text"
+          }, [createVNode(NIcon, {
+            "class": "prompt-icon",
+            "size": "28",
+            "component": Add
+          }, null), createTextVNode("\u8BF7\u70B9\u51FB\u6587\u4EF6\u4E0A\u4F20,\u5355\u4E2A\u6587\u4EF650M\u4EE5\u5185\u3002")])]
+        })]
+      });
+    };
+    const renderModal = () => {
+      return createVNode(resolveComponent("n-modal"), {
+        "show": state.previewVisible,
+        "onUpdate:show": ($event) => state.previewVisible = $event,
+        "preset": "card",
+        "style": {
+          width: "520px"
+        }
+      }, {
+        default: () => [createVNode("img", {
+          "src": state.previewImage,
+          "style": "width: 100%"
+        }, null)]
+      });
+    };
+    const renderDom = () => {
+      return createVNode("div", {
+        "class": ["c-scale-upload", {
+          "scale-upload-file": type === "UPFILE"
+        }]
+      }, [type === "UPFILE" && renderFile(), type === "UPPICTURE" && renderPicture(), renderModal()]);
+    };
+    return () => {
+      return renderDom();
+    };
+  }
+});
+
+export { RUpload as default };

package/es/packages/scale-view/src/components/formitem/text-over-tooltip/TextOverTooltip.js

@@ -0,0 +1,2 @@
+import './TextOverTooltip2.js';
+export { default } from './TextOverTooltip.vue_vue_type_script_setup_true_lang.js';

package/es/packages/scale-view/src/components/formitem/text-over-tooltip/TextOverTooltip.vue.d.ts

@@ -176,7 +176,6 @@ declare const _default: import("vue").DefineComponent<{
         onClickoutside: import("vue").PropType<(e: MouseEvent) => void>;
         'onUpdate:show': import("vue").PropType<import("naive-ui/es/_utils").MaybeArray<(value: boolean) => void>>;
         onUpdateShow: import("vue").PropType<import("naive-ui/es/_utils").MaybeArray<(value: boolean) => void>>;
-        internalDeactivateImmediately: BooleanConstructor;
         internalSyncTargetWithParent: BooleanConstructor;
         internalInheritedEventHandlers: {
             type: import("vue").PropType<import("naive-ui/es/popover/src/Popover").TriggerEventHandlers[]>;
@@ -241,11 +240,10 @@ declare const _default: import("vue").DefineComponent<{
                 opacity5: string;
                 dividerColor: string;
                 borderColor: string;
-                closeIconColor: string;
-                closeIconColorHover: string;
-                closeIconColorPressed: string;
+                closeColor: string;
                 closeColorHover: string;
                 closeColorPressed: string;
+                closeColorDisabled: string;
                 clearColor: string;
                 clearColorHover: string;
                 clearColorPressed: string;
@@ -477,7 +475,6 @@ declare const _default: import("vue").DefineComponent<{
         onClickoutside: import("vue").PropType<(e: MouseEvent) => void>;
         'onUpdate:show': import("vue").PropType<import("naive-ui/es/_utils").MaybeArray<(value: boolean) => void>>;
         onUpdateShow: import("vue").PropType<import("naive-ui/es/_utils").MaybeArray<(value: boolean) => void>>;
-        internalDeactivateImmediately: BooleanConstructor;
         internalSyncTargetWithParent: BooleanConstructor;
         internalInheritedEventHandlers: {
             type: import("vue").PropType<import("naive-ui/es/popover/src/Popover").TriggerEventHandlers[]>;
@@ -513,7 +510,6 @@ declare const _default: import("vue").DefineComponent<{
         arrowPointToCenter: boolean;
         displayDirective: "show" | "if";
         keepAliveOnHover: boolean;
-        internalDeactivateImmediately: boolean;
         animated: boolean;
         internalTrapFocus: boolean;
         defaultShow: boolean;