cnhis-design-vue 3.1.8-beta.4 → 3.1.8-beta.7

package/es/packages/scale-view/src/components/formitem/r-datetime.mjs

@@ -1 +1,200 @@
-export { default } from './r-datetime2.mjs';
+import { defineComponent, reactive, computed, createVNode, resolveComponent, createTextVNode } from 'vue';
+import { NTimePicker, NDatePicker } from 'naive-ui';
+import vexutils from 'cnhis-design-vue/es/src/utils/vexutils';
+import moment from 'moment';
+
+var scriptDatetime = defineComponent({
+  name: "RDatetime",
+  components: {
+    NTimePicker,
+    NDatePicker
+  },
+  props: {
+    form: {
+      type: Object,
+      default: () => ({})
+    },
+    item: {
+      type: Object,
+      default: () => ({})
+    },
+    isLock: {
+      type: Boolean,
+      default: false
+    }
+  },
+  emits: ["scaleChange"],
+  setup(props, context) {
+    var _a, _b, _c, _d, _e;
+    const type = (_a = props.item) == null ? void 0 : _a.type;
+    const startToStop = (_c = (_b = props.item) == null ? void 0 : _b.setting) == null ? void 0 : _c.startToStop;
+    const dateType = type === "DATE" ? "date" : (_e = (_d = props.item) == null ? void 0 : _d.setting) == null ? void 0 : _e.dateType;
+    const timeFormat = "HH:mm:ss";
+    const state = reactive({
+      rangeValue: [null, null]
+    });
+    const useDateRangeType = computed(() => {
+      if (dateType == "datetime")
+        return "datetimerange";
+      return "daterange";
+    });
+    const defaultValue = (val) => {
+      vexutils.isJSON(val) && (val = JSON.parse(val));
+      if (vexutils.isEmpty(val))
+        return;
+      let value = JSON.parse(JSON.stringify(val));
+      if (type === "TIME" || dateType == "time") {
+        if (startToStop != 1)
+          return;
+        if (!Array.isArray(value) || !value.length)
+          return;
+        let val0 = value[0] ? moment(value[0], timeFormat).valueOf() : "";
+        let val1 = value[1] ? moment(value[1], timeFormat).valueOf() : "";
+        let sV = val0 ? vexutils.isValidDate(new Date(val0)) ? val0 : null : null;
+        let eV = val1 ? vexutils.isValidDate(new Date(val1)) ? val1 : null : null;
+        state.rangeValue = [sV, eV];
+        return;
+      }
+    };
+    const disStartHours = (hour) => {
+      let endTime = state.rangeValue[1];
+      if (!endTime)
+        return false;
+      let eH = Number(new Date(endTime).getHours());
+      return hour > eH;
+    };
+    const disStartMinute = (minute, hour) => {
+      if (hour === null)
+        return false;
+      let endTime = state.rangeValue[1];
+      if (!endTime)
+        return false;
+      let eH = Number(new Date(endTime).getHours());
+      let eM = Number(new Date(endTime).getMinutes());
+      if (hour < eH)
+        return false;
+      return minute > eM;
+    };
+    const disStartSeconds = (second, minute, hour) => {
+      if (hour === null || minute === null)
+        return false;
+      let endTime = state.rangeValue[1];
+      if (!endTime)
+        return false;
+      let eH = Number(new Date(endTime).getHours());
+      let eM = Number(new Date(endTime).getMinutes());
+      let eS = Number(new Date(endTime).getSeconds());
+      if (hour < eH)
+        return false;
+      if (minute < eM)
+        return false;
+      return second >= eS;
+    };
+    const disEndHours = (hour) => {
+      let startTime = state.rangeValue[0];
+      if (!startTime)
+        return false;
+      let sH = Number(new Date(startTime).getHours());
+      return hour < sH;
+    };
+    const disEndMinute = (minute, hour) => {
+      if (hour === null)
+        return false;
+      let startTime = state.rangeValue[0];
+      if (!startTime)
+        return false;
+      let sH = Number(new Date(startTime).getHours());
+      let sM = Number(new Date(startTime).getMinutes());
+      if (hour > sH)
+        return false;
+      return minute < sM;
+    };
+    const disEndSeconds = (second, minute, hour) => {
+      if (hour === null || minute === null)
+        return false;
+      let startTime = state.rangeValue[0];
+      if (!startTime)
+        return false;
+      let sH = Number(new Date(startTime).getHours());
+      let sM = Number(new Date(startTime).getMinutes());
+      let sS = Number(new Date(startTime).getSeconds());
+      if (hour > sH)
+        return false;
+      if (minute > sM)
+        return false;
+      return second <= sS;
+    };
+    const changeRangeTime = (val, formattedValue, rangeType) => {
+      let otherIndex = rangeType === "start" ? 1 : 0;
+      let otherVal = state.rangeValue[otherIndex];
+      otherVal && (otherVal = moment(otherVal).format(timeFormat));
+      if (rangeType === "start") {
+        context.emit("scaleChange", [formattedValue, otherVal || ""], props.item);
+        return;
+      }
+      context.emit("scaleChange", [otherVal || "", formattedValue], props.item);
+    };
+    const renderTime = () => {
+      return createVNode(resolveComponent("n-time-picker"), {
+        "formatted-value": props.form[props.item.val_key],
+        "onUpdate:formatted-value": ($event) => props.form[props.item.val_key] = $event,
+        "clearable": true,
+        "disabled": props.isLock
+      }, null);
+    };
+    const renderTimeRange = () => {
+      return createVNode("div", {
+        "class": "c-time-range"
+      }, [createVNode(resolveComponent("n-time-picker"), {
+        "value": state.rangeValue[0],
+        "onUpdate:value": [($event) => state.rangeValue[0] = $event, (val, formattedValue) => changeRangeTime(val, formattedValue, "start")],
+        "clearable": true,
+        "disabled": props.isLock,
+        "isHourDisabled": disStartHours,
+        "isMinuteDisabled": disStartMinute,
+        "isSecondDisabled": disStartSeconds
+      }, null), createTextVNode("\xA0 - \xA0"), createVNode(resolveComponent("n-time-picker"), {
+        "value": state.rangeValue[1],
+        "onUpdate:value": [($event) => state.rangeValue[1] = $event, (val, formattedValue) => changeRangeTime(val, formattedValue, "end")],
+        "clearable": true,
+        "disabled": props.isLock,
+        "isHourDisabled": disEndHours,
+        "isMinuteDisabled": disEndMinute,
+        "isSecondDisabled": disEndSeconds
+      }, null)]);
+    };
+    const renderDate = () => {
+      return createVNode(resolveComponent("n-date-picker"), {
+        "formatted-value": props.form[props.item.val_key],
+        "onUpdate:formatted-value": ($event) => props.form[props.item.val_key] = $event,
+        "type": dateType,
+        "clearable": true,
+        "disabled": props.isLock
+      }, null);
+    };
+    const renderDateRange = () => {
+      return createVNode(resolveComponent("n-date-picker"), {
+        "formatted-value": props.form[props.item.val_key],
+        "onUpdate:formatted-value": ($event) => props.form[props.item.val_key] = $event,
+        "type": useDateRangeType.value,
+        "clearable": true,
+        "disabled": props.isLock
+      }, null);
+    };
+    defaultValue(props.form[props.item.val_key]);
+    return () => {
+      if (type === "TIME" || dateType == "time") {
+        if (startToStop == 1)
+          return renderTimeRange();
+        return renderTime();
+      }
+      if (dateType === "date" || dateType === "datetime") {
+        if (startToStop == 1)
+          return renderDateRange();
+      }
+      return renderDate();
+    };
+  }
+});
+
+export { scriptDatetime as default };

package/es/packages/scale-view/src/components/formitem/r-input.mjs

@@ -1 +1,88 @@
-export { default } from './r-input2.mjs';
+import { defineComponent, computed, ref, watch, createVNode } from 'vue';
+import { NInput } from 'naive-ui';
+
+var RInput = defineComponent({
+  name: "RInput",
+  components: {
+    NInput
+  },
+  props: {
+    form: {
+      type: Object,
+      default: () => ({})
+    },
+    item: {
+      type: Object,
+      default: () => ({})
+    },
+    isLock: {
+      type: Boolean,
+      default: false
+    }
+  },
+  emits: ["scaleChange"],
+  setup(props, {
+    emit
+  }) {
+    var _a, _b, _c, _d, _e, _f;
+    let type = (_a = props.item) == null ? void 0 : _a.valueType;
+    let eleType = ((_b = props.item) == null ? void 0 : _b.type) || "INPUT";
+    let isTextarea = eleType == "INPUT" || eleType == "EVALUATE_INPUT";
+    let row = ((_d = (_c = props.item) == null ? void 0 : _c.setting) == null ? void 0 : _d.inputRow) || 1;
+    let defaultPlaceHolder = ((_f = (_e = props.item) == null ? void 0 : _e.setting) == null ? void 0 : _f.defaultPlaceHolder) || "\u8BF7\u8F93\u5165";
+    const setTextareaRow = computed(() => {
+      if (!row || row == "auto") {
+        return {
+          minRows: 1
+        };
+      }
+      return {
+        minRows: row || 1,
+        maxRows: row || 1
+      };
+    });
+    const keydown = (e) => {
+      if (!isTextarea)
+        return;
+      let key = e.key;
+      if (key === "e" || key === "E" || key === "+" || key === "-") {
+        e.returnValue = false;
+      } else {
+        e.returnValue = true;
+      }
+    };
+    const inputValue = ref(props.form[props.item.val_key]);
+    watch(() => props.form[props.item.val_key], (val) => {
+      if (!val)
+        return;
+      inputValue.value = val;
+    }, {
+      immediate: true
+    });
+    const handleUpdateValue = (val) => {
+      if (isTextarea && val && type === "number") {
+        inputValue.value = val.replace(/[^\d.]/gi, "");
+      } else {
+        inputValue.value = val;
+      }
+      emit("scaleChange", inputValue.value, props.item);
+    };
+    const inputRender = () => {
+      let inputType = isTextarea ? "textarea" : type || "text";
+      return createVNode(NInput, {
+        "value": inputValue.value,
+        "type": inputType,
+        "autosize": setTextareaRow.value,
+        "placeholder": defaultPlaceHolder,
+        "disabled": props.isLock,
+        "onKeydown": keydown,
+        "onUpdate:value": handleUpdateValue
+      }, null);
+    };
+    return () => {
+      return inputRender();
+    };
+  }
+});
+
+export { RInput as default };

package/es/packages/scale-view/src/components/formitem/r-map.mjs

@@ -1 +1,104 @@
-export { default } from './r-map2.mjs';
+import { defineComponent, reactive, createVNode, resolveComponent } from 'vue';
+import { NModal, NInput, NIcon } from 'naive-ui';
+import vexutils from 'cnhis-design-vue/es/src/utils/vexutils';
+import { AlertCircleOutline } from '@vicons/ionicons5';
+import CMap from 'cnhis-design-vue/es/packages/map';
+
+var RMap = defineComponent({
+  name: "RMap",
+  components: {
+    NModal,
+    NInput,
+    NIcon,
+    CMap
+  },
+  props: {
+    form: {
+      type: Object,
+      default: () => ({})
+    },
+    item: {
+      type: Object,
+      default: () => ({})
+    },
+    isLock: {
+      type: Boolean,
+      default: false
+    },
+    locationProp: {
+      type: String,
+      default: ""
+    },
+    ak: {
+      type: String,
+      default: "KP3BZ-OAC3W-PY6RY-OJ6DV-JYKN3-H6F72"
+    }
+  },
+  emits: ["scaleChange"],
+  setup(props, context) {
+    let locationProp = props.form[props.item.val_key];
+    const state = reactive({
+      mapVisible: false,
+      mapLocation: ""
+    });
+    const handleGetAddress = (val) => {
+      if (vexutils.isJSON(val)) {
+        const valObj = JSON.parse(val);
+        return valObj.address || valObj.name;
+      }
+      return "";
+    };
+    state.mapLocation = handleGetAddress(locationProp);
+    const handleSelectLocation = (obj) => {
+      const {
+        locationProp: locationProp2,
+        isInit
+      } = obj;
+      state.mapLocation = handleGetAddress(locationProp2);
+      context.emit("scaleChange", locationProp2, props.item);
+      state.mapVisible = false;
+    };
+    const clickMap = () => {
+      if (props.isLock)
+        return;
+      state.mapVisible = true;
+    };
+    const renderMap = () => {
+      return createVNode("div", {
+        "class": {
+          "c-map-container": !props.isLock
+        }
+      }, [createVNode(resolveComponent("n-input"), {
+        "value": state.mapLocation,
+        "disabled": true,
+        "class": "map-input",
+        "on-click": clickMap
+      }, {
+        prefix: () => createVNode(resolveComponent("n-icon"), {
+          "size": "18",
+          "component": AlertCircleOutline
+        }, null)
+      }), createVNode(resolveComponent("n-modal"), {
+        "class": "c-scale-map-modal",
+        "show": state.mapVisible,
+        "onUpdate:show": ($event) => state.mapVisible = $event,
+        "preset": "card",
+        "style": {
+          width: "800px",
+          height: "80vh"
+        }
+      }, {
+        default: () => [createVNode(CMap, {
+          "locationProp": props.locationProp,
+          "ak": props.ak,
+          "onSelectLocation": handleSelectLocation
+        }, null)]
+      })]);
+    };
+    return () => {
+      return renderMap();
+    };
+  }
+});
+
+export { RMap as default };

package/es/packages/scale-view/src/components/formitem/r-radio.mjs

@@ -1 +1,221 @@
-export { default } from './r-radio2.mjs';
+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-common.mjs';
+
+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 = (url, i) => {
+      let imgs = state.curOptions.map((v) => v.imageUrl);
+      if (!imgs.length)
+        return;
+      api({
+        images: imgs
+      });
+    };
+    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,
+        "on-click": () => handlePreview(o.imageUrl)
+      }, 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), hasPreSuffix(o) && renderPresuffix(o), !hasPreSuffix(o) && renderDefault(o), o.importability && renderOther(o)]
+      }))) ? _slot : {
+        default: () => [_slot]
+      });
+    };
+  }
+});
+
+export { scriptRadio as default };