cnhis-design-vue 3.1.24-beta.7 → 3.1.24-beta.8

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

@@ -0,0 +1,281 @@
+import { defineComponent, reactive, watch, createVNode, resolveComponent, isVNode } from 'vue';
+import { NCheckboxGroup, NCheckbox, NInput, NIcon } from 'naive-ui';
+import { api } from 'v-viewer';
+import { SearchOutline } from '@vicons/ionicons5';
+import XEUtils from 'xe-utils';
+import 'moment';
+import chooseCommon from '../composables/choose-common.js';
+
+function _isSlot(s) {
+  return typeof s === "function" || Object.prototype.toString.call(s) === "[object Object]" && !isVNode(s);
+}
+var scriptCheckbox = defineComponent({
+  name: "RCheckbox",
+  components: {
+    NCheckboxGroup,
+    NCheckbox,
+    NInput,
+    NIcon
+  },
+  props: {
+    form: {
+      type: Object,
+      default: () => {
+      }
+    },
+    item: {
+      type: Object,
+      default: () => {
+      }
+    },
+    isLock: {
+      type: Boolean,
+      default: false
+    },
+    inputLock: {
+      type: Boolean,
+      default: false
+    }
+  },
+  emits: ["scaleChange"],
+  setup(props, context) {
+    var _a, _b;
+    const state = reactive({
+      curCheckboxValue: [],
+      othersText: "",
+      curOptions: [],
+      optionsPreSuffixObj: {}
+    });
+    const {
+      choiceColor,
+      showImgWrap,
+      handleDefPreSuffix,
+      choiceUseKey,
+      isCheckboxItem,
+      showPreSuffix,
+      handleOptions,
+      stopClick
+    } = chooseCommon(props, state);
+    const chooseStyleSetting = ((_b = (_a = props.item) == null ? void 0 : _a.setting) == null ? void 0 : _b.chooseStyleSetting) || 1;
+    const handlePreview = (e, url) => {
+      e.preventDefault();
+      e.stopPropagation();
+      let imgs = state.curOptions.map((v) => v.imageUrl).filter(Boolean);
+      if (!imgs.length)
+        return;
+      let index = imgs.findIndex((v) => v === url);
+      let i = index < 0 ? 0 : index;
+      api({
+        images: imgs,
+        options: {
+          toolbar: true,
+          initialViewIndex: i
+        }
+      });
+    };
+    const handleCheckboxOther = (isOtherInput) => {
+      let choiceObj = {
+        othersText: state.othersText,
+        optionsPreSuffixObj: state.optionsPreSuffixObj
+      };
+      if (isOtherInput && !state.curCheckboxValue.includes("other")) {
+        state.curCheckboxValue.push("other");
+      }
+      let curCheckboxValue = JSON.parse(JSON.stringify(state.curCheckboxValue));
+      context.emit("scaleChange", curCheckboxValue, props.item, {
+        choiceObj,
+        isSetObj: isCheckboxItem.value
+      });
+    };
+    const handleCheckboxDefModal = (item, curValue, options) => {
+      var _a2;
+      state.curOptions = handleOptions(options);
+      if (!options.length || !curValue || !curValue.length)
+        return;
+      let resArr = [];
+      let i = 0, x, len = curValue.length;
+      for (; i < len; i++) {
+        x = curValue[i];
+        if (x === "\u5176\u4ED6") {
+          state.othersText = x;
+          state.curCheckboxValue = ["other"];
+          !resArr.includes("other") && resArr.push("other");
+          continue;
+        }
+        let matchIndex = options.findIndex((v) => v.value === x);
+        if (matchIndex < 0) {
+          state.othersText = x;
+          !resArr.includes("other") && resArr.push("other");
+          continue;
+        }
+        let res = (_a2 = options[matchIndex]) == null ? void 0 : _a2.key;
+        if (resArr.indexOf(res) < 0) {
+          resArr.push(res);
+        }
+      }
+      state.curCheckboxValue = resArr;
+      handleCheckboxOther();
+    };
+    const handleCheckboxDef = (item, curValue, options) => {
+      var _a2;
+      state.curOptions = handleOptions(options);
+      if (!options.length || !curValue || !curValue.length)
+        return;
+      if (item.type === "EVALUATE_CHECKBOX_BLOCK") {
+        state.curCheckboxValue = curValue;
+        handleCheckboxOther();
+        return;
+      }
+      let resArr = [], i = 0, x, len = curValue.length;
+      let hasOther = options.some((v) => v.importability || v.key === "other");
+      for (; i < len; i++) {
+        x = curValue[i];
+        if (x === "\u5176\u4ED6") {
+          state.othersText = x;
+          state.curCheckboxValue = ["other"];
+          !resArr.includes("other") && resArr.push("other");
+          continue;
+        }
+        let matchIndex = options.findIndex((v) => v.value === x);
+        if (matchIndex > 0) {
+          let res = (_a2 = options[matchIndex]) == null ? void 0 : _a2.key;
+          !resArr.includes(res) && resArr.push(res);
+          continue;
+        }
+        options.map((v) => {
+          let res = handleDefPreSuffix(v, i, x, true, hasOther);
+          res && !resArr.includes(res) && resArr.push(res);
+        });
+      }
+      state.curCheckboxValue = resArr;
+      handleCheckboxOther();
+    };
+    const handleDef = (value) => {
+      var _a2, _b2;
+      let options = value.options || [];
+      let valueDef = props.form[props.item.val_key];
+      let defaultValue = (_a2 = value == null ? void 0 : value.setting) == null ? void 0 : _a2.defaultValue;
+      if (props.item.type === "EVALUATE_CHECKBOX_BLOCK") {
+        options = ((_b2 = value.scoreConfigs) == null ? void 0 : _b2.scoreRules) || [];
+      }
+      let defVal = [];
+      if (defaultValue && XEUtils.isJSON(defaultValue)) {
+        defVal = JSON.parse(defaultValue);
+      } else {
+        defVal = valueDef;
+      }
+      if (props.inputLock) {
+        handleCheckboxDefModal(value, value.dbValue || defVal, options);
+      } else {
+        handleCheckboxDef(value, value.dbValue || defVal, options);
+      }
+    };
+    watch(() => props.item, (value) => {
+      if (!value || !Object.keys(value).length)
+        return;
+      handleDef(value);
+    }, {
+      immediate: true
+    });
+    const inputPreSuffixCheckboxChange = (o, i) => {
+      let choiceObj = {
+        othersText: state.othersText,
+        optionsPreSuffixObj: state.optionsPreSuffixObj
+      };
+      if (!state.curCheckboxValue.includes(o.key)) {
+        state.curCheckboxValue.push(o.key);
+      }
+      let curCheckboxValue = JSON.parse(JSON.stringify(state.curCheckboxValue));
+      context.emit("scaleChange", curCheckboxValue, props.item, {
+        choiceObj,
+        isSetObj: isCheckboxItem.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)
+      }, null)])]);
+    };
+    const renderPresuffix = (o, i) => {
+      return createVNode("div", {
+        "class": "presuffix-wrap",
+        "onClick": stopClick
+      }, [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 || props.inputLock,
+        "style": {
+          color: choiceColor.value(o)
+        },
+        "placeholder": "\u8BF7\u8F93\u5165",
+        "bordered": false,
+        "onInput": () => inputPreSuffixCheckboxChange(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)
+        },
+        "class": "other-span"
+      }, [o.label]);
+    };
+    const renderOther = (o) => {
+      return createVNode("div", {
+        "class": "choose-other",
+        "onClick": stopClick
+      }, [createVNode(resolveComponent("n-input"), {
+        "value": state.othersText,
+        "onUpdate:value": [($event) => state.othersText = $event, () => handleCheckboxOther(true)],
+        "disabled": props.isLock || props.inputLock,
+        "style": {
+          color: choiceColor.value(o)
+        },
+        "placeholder": "\u8BF7\u8F93\u5165",
+        "bordered": false
+      }, null)]);
+    };
+    const hasPreSuffix = (o) => {
+      return isCheckboxItem.value && showPreSuffix.value(o);
+    };
+    let opKey = choiceUseKey.value;
+    return () => {
+      let _slot;
+      return createVNode(NCheckboxGroup, {
+        "value": state.curCheckboxValue,
+        "onUpdate:value": [($event) => state.curCheckboxValue = $event, () => handleCheckboxOther(false)],
+        "class": ["c-choice-wrap", "choice-wrap-" + chooseStyleSetting],
+        "disabled": props.isLock
+      }, _isSlot(_slot = state.curOptions.map((o, i) => createVNode(resolveComponent("n-checkbox"), {
+        "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 { scriptCheckbox as default };

package/es/components/scale-view/src/components/formitem/r-collection.d.ts

@@ -0,0 +1,32 @@
+declare const _default: import("vue").DefineComponent<{
+    form: {
+        type: ObjectConstructor;
+        default: () => {};
+    };
+    item: {
+        type: ObjectConstructor;
+        default: () => {};
+    };
+    isLock: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, never[], never, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    form: {
+        type: ObjectConstructor;
+        default: () => {};
+    };
+    item: {
+        type: ObjectConstructor;
+        default: () => {};
+    };
+    isLock: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & {}, {
+    item: Record<string, any>;
+    isLock: boolean;
+    form: Record<string, any>;
+}>;
+export default _default;

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

@@ -0,0 +1,111 @@
+import { defineComponent, computed, createVNode, withDirectives, vShow, resolveComponent, createTextVNode } from 'vue';
+import { NDivider, NIcon } from 'naive-ui';
+import { AlertCircleOutline } from '@vicons/ionicons5';
+
+var RCollection = defineComponent({
+  name: "RCollection",
+  components: {
+    NDivider,
+    NIcon
+  },
+  props: {
+    form: {
+      type: Object,
+      default: () => ({})
+    },
+    item: {
+      type: Object,
+      default: () => ({})
+    },
+    isLock: {
+      type: Boolean,
+      default: false
+    }
+  },
+  emits: [],
+  setup(props, {
+    emit
+  }) {
+    var _a, _b;
+    const type = (_a = props.item) == null ? void 0 : _a.type;
+    const {
+      title,
+      describe
+    } = props.item || {};
+    const options = ((_b = props.item) == null ? void 0 : _b.setting) || {};
+    const className = computed(() => {
+      const type2 = options.promptType;
+      return type2 ? `is-${type2}` : "";
+    });
+    const showIcon = computed(() => {
+      return options.promptType === "strong";
+    });
+    const imgLink = computed(() => {
+      return options.imgLink;
+    });
+    const imgUrl = computed(() => {
+      return options.imgUrl;
+    });
+    const defaultValue = computed(() => {
+      return options.defaultValue;
+    });
+    const renderTitle = () => {
+      return createVNode("div", {
+        "class": "c-scale-collection scale-collection-title"
+      }, [title && createVNode("h1", {
+        "class": "lb-title"
+      }, [title]), describe && createVNode("div", {
+        "class": "lb-title"
+      }, [describe])]);
+    };
+    const renderLinebar = () => {
+      return createVNode("div", {
+        "class": "linebar-div"
+      }, [withDirectives(createVNode("span", null, [props.item.title]), [[vShow, props.item.title]]), createVNode(resolveComponent("n-divider"), null, null)]);
+    };
+    const renderPrompt = () => {
+      return createVNode("div", {
+        "class": ["prompt-message", "c-scale-collection", className.value]
+      }, [showIcon.value && createVNode(NIcon, {
+        "class": "prompt-icon",
+        "size": "20",
+        "component": AlertCircleOutline
+      }, null), createVNode("div", {
+        "class": "prompt-message-content "
+      }, [createTextVNode(" "), options.promptMsg || ""])]);
+    };
+    const renderImgCard = () => {
+      return createVNode("div", {
+        "class": "c-scale-collection"
+      }, [imgLink.value && createVNode("a", {
+        "href": imgLink.value,
+        "target": "_blank"
+      }, [createVNode("img", {
+        "class": "img-card",
+        "src": imgUrl.value
+      }, null), " "]), !imgLink.value && createVNode("img", {
+        "class": "img-card",
+        "src": imgUrl.value
+      }, null)]);
+    };
+    const renderRichText = () => {
+      return createVNode("div", {
+        "class": "c-scale-collection",
+        "innerHTML": defaultValue.value
+      }, null);
+    };
+    return () => {
+      if (type === "TITLE")
+        return renderTitle();
+      if (type === "LINEBAR")
+        return renderLinebar();
+      if (type === "PROMPT")
+        return renderPrompt();
+      if (type === "IMGCARD")
+        return renderImgCard();
+      return renderRichText();
+    };
+  }
+});
+
+export { RCollection as default };

package/es/components/scale-view/src/components/formitem/r-datetime.d.ts

@@ -0,0 +1,34 @@
+declare const _default: import("vue").DefineComponent<{
+    form: {
+        type: ObjectConstructor;
+        default: () => {};
+    };
+    item: {
+        type: ObjectConstructor;
+        default: () => {};
+    };
+    isLock: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "scaleChange"[], "scaleChange", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    form: {
+        type: ObjectConstructor;
+        default: () => {};
+    };
+    item: {
+        type: ObjectConstructor;
+        default: () => {};
+    };
+    isLock: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & {
+    onScaleChange?: ((...args: any[]) => any) | undefined;
+}, {
+    item: Record<string, any>;
+    isLock: boolean;
+    form: Record<string, any>;
+}>;
+export default _default;

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

@@ -0,0 +1,212 @@
+import { defineComponent, reactive, computed, createVNode, resolveComponent, createTextVNode } from 'vue';
+import { NTimePicker, NDatePicker } from 'naive-ui';
+import XEUtils from 'xe-utils';
+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],
+      dateValue: null
+    });
+    const useDateRangeType = computed(() => {
+      if (dateType == "datetime")
+        return "datetimerange";
+      return "daterange";
+    });
+    const defaultValue = (val) => {
+      console.log(val, "time---val---");
+      XEUtils.isJSON(val) && (val = JSON.parse(val));
+      if (!val || XEUtils.isEmpty(val))
+        return;
+      let value = JSON.parse(JSON.stringify(val));
+      if (type === "TIME" || dateType == "time") {
+        if (startToStop != 1) {
+          state.dateValue = val;
+          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 ? XEUtils.isValidDate(new Date(val0)) ? val0 : null : null;
+        let eV = val1 ? XEUtils.isValidDate(new Date(val1)) ? val1 : null : null;
+        state.rangeValue = [sV, eV];
+        return;
+      } else {
+        state.dateValue = val;
+      }
+    };
+    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 changeDate = (val, formattedValue) => {
+      context.emit("scaleChange", formattedValue, props.item);
+    };
+    const renderTime = () => {
+      return createVNode(resolveComponent("n-time-picker"), {
+        "formatted-value": state.dateValue,
+        "onUpdate:formatted-value": ($event) => state.dateValue = $event,
+        "clearable": true,
+        "disabled": props.isLock,
+        "onUpdate:value": changeDate
+      }, 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": state.dateValue,
+        "onUpdate:formatted-value": ($event) => state.dateValue = $event,
+        "type": dateType,
+        "clearable": true,
+        "disabled": props.isLock,
+        "onUpdate:value": changeDate
+      }, null);
+    };
+    const renderDateRange = () => {
+      return createVNode(resolveComponent("n-date-picker"), {
+        "formatted-value": state.dateValue,
+        "onUpdate:formatted-value": ($event) => state.dateValue = $event,
+        "type": useDateRangeType.value,
+        "clearable": true,
+        "disabled": props.isLock,
+        "onUpdate:value": changeDate
+      }, 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 };