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

package/es/components/scale-view/src/components/formitem/sign-com.d.ts

@@ -0,0 +1,63 @@
+declare const _default: import("vue").DefineComponent<{
+    width: {
+        type: NumberConstructor;
+        default: number;
+    };
+    height: {
+        type: NumberConstructor;
+        default: number;
+    };
+    lineWidth: {
+        type: NumberConstructor;
+        default: number;
+    };
+    lineColor: {
+        type: StringConstructor;
+        default: string;
+    };
+    bgColor: {
+        type: StringConstructor;
+        default: string;
+    };
+    isCrop: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}, {
+    renderContent: () => JSX.Element;
+    generate: () => Promise<unknown>;
+    reset: () => void;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, never[], never, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    width: {
+        type: NumberConstructor;
+        default: number;
+    };
+    height: {
+        type: NumberConstructor;
+        default: number;
+    };
+    lineWidth: {
+        type: NumberConstructor;
+        default: number;
+    };
+    lineColor: {
+        type: StringConstructor;
+        default: string;
+    };
+    bgColor: {
+        type: StringConstructor;
+        default: string;
+    };
+    isCrop: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & {}, {
+    height: number;
+    width: number;
+    lineWidth: number;
+    lineColor: string;
+    bgColor: string;
+    isCrop: boolean;
+}>;
+export default _default;

package/es/components/scale-view/src/components/formitem/sign-com.js

@@ -0,0 +1,307 @@
+import { defineComponent, ref, reactive, computed, onBeforeMount, onUnmounted, onMounted, createVNode, createTextVNode } from 'vue';
+
+var SignCom = defineComponent({
+  name: "SignCom",
+  props: {
+    width: {
+      type: Number,
+      default: 620
+    },
+    height: {
+      type: Number,
+      default: 300
+    },
+    lineWidth: {
+      type: Number,
+      default: 4
+    },
+    lineColor: {
+      type: String,
+      default: "#000000"
+    },
+    bgColor: {
+      type: String,
+      default: ""
+    },
+    isCrop: {
+      type: Boolean,
+      default: false
+    }
+  },
+  emits: [],
+  setup(props) {
+    const canvasRef = ref(null);
+    const canvasTxt = ref();
+    const resultImg = ref();
+    const hasDrew = ref(false);
+    const drawObj = reactive({
+      points: [],
+      startX: 0,
+      startY: 0,
+      isDrawing: false,
+      sratio: 1
+    });
+    const ratio = computed(() => {
+      return props.height / props.width;
+    });
+    const myBg = computed(() => {
+      return props.bgColor ? props.bgColor : "rgba(255, 255, 255, 0)";
+    });
+    const drawGrid = (context, color, stepx, stepy) => {
+      context.save();
+      context.fillStyle = "white";
+      console.log(context);
+      context.fillRect(0, 0, context.canvas.width, context.canvas.height);
+      context.lineWidth = 0.5;
+      context.strokeStyle = color;
+      for (let i = stepx; i < context.canvas.width; i += stepx) {
+        context.beginPath();
+        context.moveTo(i, 0);
+        context.lineTo(i, context.canvas.height);
+        context.closePath();
+        context.stroke();
+      }
+      for (let j = stepy; j < context.canvas.height; j += stepy) {
+        context.beginPath();
+        context.moveTo(0, j);
+        context.lineTo(context.canvas.width, j);
+        context.closePath();
+        context.stroke();
+      }
+      context.restore();
+    };
+    const drawStart = (obj) => {
+      drawObj.startX = obj.x;
+      drawObj.startY = obj.y;
+      canvasTxt.value.beginPath();
+      canvasTxt.value.moveTo(drawObj.startX, drawObj.startY);
+      canvasTxt.value.lineTo(obj.x, obj.y);
+      canvasTxt.value.lineCap = "round";
+      canvasTxt.value.lineJoin = "round";
+      canvasTxt.value.lineWidth = props.lineWidth * drawObj.sratio;
+      canvasTxt.value.stroke();
+      canvasTxt.value.closePath();
+      drawObj.points.push(obj);
+    };
+    const drawMove = (obj) => {
+      canvasTxt.value.beginPath();
+      canvasTxt.value.moveTo(drawObj.startX, drawObj.startY);
+      canvasTxt.value.lineTo(obj.x, obj.y);
+      canvasTxt.value.strokeStyle = props.lineColor;
+      canvasTxt.value.lineWidth = props.lineWidth * drawObj.sratio;
+      canvasTxt.value.lineCap = "round";
+      canvasTxt.value.lineJoin = "round";
+      canvasTxt.value.stroke();
+      canvasTxt.value.closePath();
+      drawObj.startY = obj.y;
+      drawObj.startX = obj.x;
+      drawObj.points.push(obj);
+    };
+    const drawEnd = (obj) => {
+      canvasTxt.value.beginPath();
+      canvasTxt.value.moveTo(drawObj.startX, drawObj.startY);
+      canvasTxt.value.lineCap = "round";
+      canvasTxt.value.lineJoin = "round";
+      canvasTxt.value.stroke();
+      canvasTxt.value.closePath();
+      drawObj.points.push(obj);
+      drawObj.points.push({
+        x: -1,
+        y: -1
+      });
+    };
+    const mouseDown = (e) => {
+      e.preventDefault();
+      drawObj.isDrawing = true;
+      hasDrew.value = true;
+      const obj = {
+        x: e.offsetX,
+        y: e.offsetY
+      };
+      drawStart(obj);
+    };
+    const mouseMove = (e) => {
+      e.preventDefault();
+      if (!drawObj.isDrawing)
+        return;
+      const obj = {
+        x: e.offsetX,
+        y: e.offsetY
+      };
+      drawMove(obj);
+    };
+    const mouseUp = (e) => {
+      e.preventDefault();
+      const obj = {
+        x: e.offsetX,
+        y: e.offsetY
+      };
+      drawEnd(obj);
+      drawObj.isDrawing = false;
+    };
+    const touchStart = (e) => {
+      e.preventDefault();
+      hasDrew.value = true;
+      if (e.touches.length === 1) {
+        const obj = {
+          x: e.targetTouches[0].clientX - canvasRef.value.getBoundingClientRect().left,
+          y: e.targetTouches[0].clientY - canvasRef.value.getBoundingClientRect().top
+        };
+        drawStart(obj);
+      }
+    };
+    const touchMove = (e) => {
+      e.preventDefault();
+      if (e.touches.length !== 1)
+        return;
+      const obj = {
+        x: e.targetTouches[0].clientX - canvasRef.value.getBoundingClientRect().left,
+        y: e.targetTouches[0].clientY - canvasRef.value.getBoundingClientRect().top
+      };
+      drawMove(obj);
+    };
+    const touchEnd = (e) => {
+      e.preventDefault();
+      if (e.touches.length !== 1)
+        return;
+      const obj = {
+        x: e.targetTouches[0].clientX - canvasRef.value.getBoundingClientRect().left,
+        y: e.targetTouches[0].clientY - canvasRef.value.getBoundingClientRect().top
+      };
+      drawEnd(obj);
+    };
+    const getCropArea = (imgData) => {
+      let topX = canvasRef.value.width;
+      let btmX = 0;
+      let topY = canvasRef.value.height;
+      let btnY = 0;
+      for (let i = 0; i < canvasRef.value.width; i++) {
+        for (let j = 0; j < canvasRef.value.height; j++) {
+          const pos = (i + canvasRef.value.width * j) * 4;
+          if (imgData[pos] > 0 || imgData[pos + 1] > 0 || imgData[pos + 2] || imgData[pos + 3] > 0) {
+            btnY = Math.max(j, btnY);
+            btmX = Math.max(i, btmX);
+            topY = Math.min(j, topY);
+            topX = Math.min(i, topX);
+          }
+        }
+      }
+      topX++;
+      btmX++;
+      topY++;
+      btnY++;
+      const data = [topX, topY, btmX, btnY];
+      return data;
+    };
+    const getImgSize = (url) => {
+      const strLength = url.length;
+      const strNum = strLength - strLength / 8 * 2;
+      return Math.floor(strNum);
+    };
+    const randomId = () => {
+      const str = Math.random() * 1e10 + "";
+      return parseInt(str).toString(36);
+    };
+    const generate = () => {
+      const pm = new Promise((resolve, reject) => {
+        if (!hasDrew.value) {
+          reject("Warning: Not Signned!");
+          return;
+        }
+        const resImgData = canvasTxt.value.getImageData(0, 0, canvasRef.value.width, canvasRef.value.height);
+        canvasTxt.value.globalCompositeOperation = "destination-over";
+        canvasTxt.value.fillStyle = myBg.value;
+        canvasTxt.value.fillRect(0, 0, canvasRef.value.width, canvasRef.value.height);
+        let resultImg2 = canvasRef.value.toDataURL();
+        canvasTxt.value.clearRect(0, 0, canvasRef.value.width, canvasRef.value.height);
+        canvasTxt.value.putImageData(resImgData, 0, 0);
+        canvasTxt.value.globalCompositeOperation = "source-over";
+        if (props.isCrop) {
+          const crop_area = getCropArea(resImgData.data);
+          let crop_canvas = document.createElement("canvas");
+          const crop_ctx = crop_canvas.getContext("2d");
+          crop_canvas.width = crop_area[2] - crop_area[0];
+          crop_canvas.height = crop_area[3] - crop_area[1];
+          const crop_imgData = canvasTxt.value.getImageData(...crop_area);
+          for (let i = 0; i < crop_imgData.data.length; i += 4) {
+            if (crop_imgData.data[i] > 200) {
+              crop_imgData.data[i] = 255;
+              crop_imgData.data[i + 1] = 255;
+              crop_imgData.data[i + 2] = 255;
+              crop_imgData.data[i + 3] = 255;
+            }
+          }
+          crop_ctx.globalCompositeOperation = "destination-over";
+          crop_ctx.putImageData(crop_imgData, 0, 0);
+          crop_ctx.fillStyle = myBg.value;
+          crop_ctx.fillRect(0, 0, crop_canvas.width, crop_canvas.height);
+          resultImg2 = crop_canvas.toDataURL();
+          crop_canvas = null;
+        }
+        const obj = {
+          name: randomId(),
+          url: resultImg2,
+          size: getImgSize(resultImg2)
+        };
+        resolve(obj);
+      });
+      return pm;
+    };
+    const reset = () => {
+      canvasTxt.value.clearRect(0, 0, canvasRef.value.width, canvasRef.value.height);
+      drawGrid(canvasTxt.value, "rgb(240, 240, 240)", 16, 16);
+      drawObj.points = [];
+      hasDrew.value = false;
+      resultImg.value = "";
+    };
+    const resizeHandler = () => {
+      canvasRef.value.style.width = props.width + "px";
+      const realw = parseFloat(window.getComputedStyle(canvasRef.value).width);
+      canvasRef.value.style.height = ratio.value * realw + "px";
+      canvasTxt.value = canvasRef.value.getContext("2d");
+      canvasTxt.value.globalAlpha = 1;
+    };
+    onBeforeMount(() => {
+      window.addEventListener("resize", resizeHandler);
+    });
+    onUnmounted(() => {
+      window.removeEventListener("resize", resizeHandler);
+    });
+    onMounted(() => {
+      canvasRef.value.height = props.height;
+      canvasRef.value.width = props.width;
+      resizeHandler();
+      drawGrid(canvasTxt.value, "rgb(240, 240, 240)", 16, 16);
+      document.onmouseup = () => {
+        drawObj.isDrawing = false;
+      };
+    });
+    const renderCanvas = () => {
+      return createVNode("canvas", {
+        "class": "sign-canvas",
+        "ref": canvasRef,
+        "onMousedown": mouseDown,
+        "onMousemove": mouseMove,
+        "onMouseup": mouseUp,
+        "onTouchstart": touchStart,
+        "onTouchmove": touchMove,
+        "onTouchend": touchEnd
+      }, null);
+    };
+    const renderContent = () => {
+      return createVNode("div", {
+        "class": "sign-com-wrap"
+      }, [createVNode("span", null, [createTextVNode("\u63D0\u793A\uFF1A\u8BF7\u5728\u4EE5\u4E0B\u533A\u57DF\u5185\u7B7E\u540D\uFF0CPC\u7535\u8111\u8BBE\u5907\u4F7F\u7528\u9F20\u6807\u7B7E\u5B57\u3002")]), renderCanvas()]);
+    };
+    return {
+      renderContent,
+      generate,
+      reset
+    };
+  },
+  render() {
+    return this.renderContent();
+  }
+});
+
+export { SignCom as default };

package/es/components/scale-view/src/components/formitem/standard-modal.d.ts

@@ -0,0 +1,80 @@
+declare const _default: import("vue").DefineComponent<{
+    title: {
+        type: (StringConstructor | FunctionConstructor)[];
+        default: string;
+    };
+    changeSize: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    closable: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    modalWidth: {
+        type: StringConstructor;
+        default: string;
+    };
+    modalHeight: {
+        type: StringConstructor;
+        default: string;
+    };
+    handleOk: {
+        type: FunctionConstructor;
+        default: () => void;
+    };
+    cancel: {
+        type: FunctionConstructor;
+        default: () => void;
+    };
+    visible: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("onClose" | "update:visible")[], "onClose" | "update:visible", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    title: {
+        type: (StringConstructor | FunctionConstructor)[];
+        default: string;
+    };
+    changeSize: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    closable: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    modalWidth: {
+        type: StringConstructor;
+        default: string;
+    };
+    modalHeight: {
+        type: StringConstructor;
+        default: string;
+    };
+    handleOk: {
+        type: FunctionConstructor;
+        default: () => void;
+    };
+    cancel: {
+        type: FunctionConstructor;
+        default: () => void;
+    };
+    visible: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & {
+    onOnClose?: ((...args: any[]) => any) | undefined;
+    "onUpdate:visible"?: ((...args: any[]) => any) | undefined;
+}, {
+    closable: boolean;
+    visible: boolean;
+    handleOk: Function;
+    title: string | Function;
+    modalWidth: string;
+    modalHeight: string;
+    changeSize: boolean;
+    cancel: Function;
+}>;
+export default _default;

package/es/components/scale-view/src/components/formitem/standard-modal.js

@@ -0,0 +1,129 @@
+import { defineComponent, computed, reactive, ref, createVNode, resolveComponent } from 'vue';
+import { NModal, NButton, NTooltip } from 'naive-ui';
+
+const DEFAULT_WIDTH = "50vw";
+const DEFAULT_HEIGHT = "50vh";
+var StandardModal = defineComponent({
+  name: "StandardModal",
+  components: {
+    NModal,
+    NButton,
+    NTooltip
+  },
+  props: {
+    title: {
+      type: [Function, String],
+      default: ""
+    },
+    changeSize: {
+      type: Boolean,
+      default: false
+    },
+    closable: {
+      type: Boolean,
+      default: true
+    },
+    modalWidth: {
+      type: String,
+      default: ""
+    },
+    modalHeight: {
+      type: String,
+      default: ""
+    },
+    handleOk: {
+      type: Function,
+      default: () => {
+      }
+    },
+    cancel: {
+      type: Function,
+      default: () => {
+      }
+    },
+    visible: {
+      type: Boolean,
+      default: false
+    }
+  },
+  emits: ["update:visible", "onClose"],
+  setup(props, context) {
+    const showWidth = computed(() => {
+      return props.modalWidth || DEFAULT_WIDTH;
+    });
+    const showHeight = computed(() => {
+      return props.modalHeight || DEFAULT_HEIGHT;
+    });
+    const modalConfig = reactive({
+      modalWidth: showWidth.value,
+      modalHeight: showHeight.value,
+      maxHeight: "620px",
+      isChangeWindow: false
+    });
+    const isChangeWindow = ref(false);
+    const changeModalWindow = () => {
+      document.body.clientHeight;
+      Object.assign(modalConfig, {
+        isChangeWindow: !modalConfig.isChangeWindow,
+        modalWidth: modalConfig.modalWidth === showWidth.value ? "100vw" : showWidth.value,
+        modalHeight: modalConfig.modalHeight === showHeight.value ? "100vh" : showHeight.value
+      });
+    };
+    const handleOk = () => {
+      props.handleOk();
+    };
+    const cancel = () => {
+      props.cancel();
+      context.emit("update:visible", false);
+    };
+    const renderHeader = () => {
+      const title = props == null ? void 0 : props.title;
+      const type = typeof title;
+      return createVNode("div", {
+        "class": "n-dialog__title-content"
+      }, [type === "string" ? createVNode("div", null, [title]) : null, type === "function" ? createVNode("div", null, [title()]) : null, createVNode("div", {
+        "class": "svg-wrap"
+      }, [props.changeSize ? createVNode(resolveComponent("svg-icon"), {
+        "onClick": () => changeModalWindow(),
+        "icon-class": isChangeWindow.value ? "xitongtubiaodaohangtubiaozuixiaohua" : "xitongtubiaodaohangtubiaozuidahua"
+      }, null) : null, props.closable ? createVNode(resolveComponent("svg-icon"), {
+        "icon-class": "xitongtubiaodaohangtubiaoguanbi",
+        "onClick": () => cancel()
+      }, null) : null])]);
+    };
+    const rednerModal = () => {
+      const curSlot = {
+        ...context.slots
+      };
+      if (!curSlot.header) {
+        curSlot.header = renderHeader;
+      }
+      return createVNode(resolveComponent("n-modal"), {
+        "class": "c-scale-modal-container",
+        "show": props.visible,
+        "mask-closable": false,
+        "show-icon": false,
+        "closable": false,
+        "style": {
+          width: modalConfig.modalWidth,
+          height: modalConfig.modalHeight
+        },
+        "preset": "dialog",
+        "positive-text": "\u786E\u8BA4",
+        "negative-text": "\u53D6\u6D88",
+        "on-positive-click": handleOk,
+        "on-negative-click": cancel,
+        "positiveButtonProps": {
+          type: "primary"
+        }
+      }, {
+        ...curSlot
+      });
+    };
+    return () => {
+      return rednerModal();
+    };
+  }
+});
+
+export { StandardModal as default };

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

@@ -0,0 +1,87 @@
+declare const _default: import("vue").DefineComponent<{
+    content: {
+        type: (NumberConstructor | StringConstructor)[];
+        required: false;
+    };
+    className: {
+        type: StringConstructor;
+        required: false;
+    };
+    refName: {
+        type: StringConstructor;
+        required: false;
+    };
+    effect: {
+        type: StringConstructor;
+        required: false;
+        default: string;
+    };
+    placement: {
+        type: StringConstructor;
+        required: false;
+        default: string;
+    };
+    tooltipTitle: {
+        type: (NumberConstructor | StringConstructor)[];
+        required: false;
+        default: string;
+    };
+    isAlias: {
+        type: BooleanConstructor;
+        required: false;
+    };
+}, {
+    props: {
+        content?: string | number | undefined;
+        className?: string | undefined;
+        refName?: string | undefined;
+        effect: string;
+        placement: 'top-start' | 'top' | 'top-end' | 'right-start' | 'right' | 'right-end' | 'bottom-start' | 'bottom' | 'bottom-end' | 'left-start' | 'left' | 'left-end';
+        tooltipTitle: string | number;
+        isAlias?: boolean | undefined;
+    };
+    isDisabledTooltip: import("vue").Ref<boolean>;
+    curContent: import("vue").ComputedRef<string>;
+    $refName: any;
+    onMouseOver: (str: any) => void;
+    onMouseOut: () => void;
+    NTooltip: any;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    content: {
+        type: (NumberConstructor | StringConstructor)[];
+        required: false;
+    };
+    className: {
+        type: StringConstructor;
+        required: false;
+    };
+    refName: {
+        type: StringConstructor;
+        required: false;
+    };
+    effect: {
+        type: StringConstructor;
+        required: false;
+        default: string;
+    };
+    placement: {
+        type: StringConstructor;
+        required: false;
+        default: string;
+    };
+    tooltipTitle: {
+        type: (NumberConstructor | StringConstructor)[];
+        required: false;
+        default: string;
+    };
+    isAlias: {
+        type: BooleanConstructor;
+        required: false;
+    };
+}>>, {
+    placement: string;
+    effect: string;
+    tooltipTitle: string | number;
+    isAlias: boolean;
+}>;
+export default _default;

package/es/components/scale-view/src/hooks/scaleview-computed.d.ts

@@ -0,0 +1,43 @@
+export declare const ScaleViewComputed: (props: any, state: any, config: any) => {
+    showEvatip: import("vue").ComputedRef<(item: any) => boolean>;
+    isFormBoldOpen: import("vue").ComputedRef<(item: any) => any>;
+    scaleStyle: import("vue").ComputedRef<{
+        width: string;
+        height: string;
+        transform: string;
+    } | null>;
+    handlePageClass: import("vue").ComputedRef<boolean>;
+    isShowItem: import("vue").ComputedRef<(item: any) => any>;
+    handleShowQuestionNumber: import("vue").ComputedRef<(item: any) => any>;
+    hasScore: import("vue").ComputedRef<boolean>;
+    isPreviewScale: import("vue").ComputedRef<any>;
+    showEvaluateEntry: import("vue").ComputedRef<any>;
+    showEvaluateCoundownPage: import("vue").ComputedRef<any>;
+    hasEvaluateResultSetting: import("vue").ComputedRef<number>;
+    hasparamsEvaluate: import("vue").ComputedRef<any>;
+    hasDefault: import("vue").ComputedRef<any>;
+    showSaveBtn: import("vue").ComputedRef<boolean>;
+    componentDisable: import("vue").ComputedRef<any>;
+    showEvaluateLabel: import("vue").ComputedRef<(item: any) => any>;
+    showAnswerParse: import("vue").ComputedRef<(item: any) => any>;
+    tipMsg: import("vue").ComputedRef<"保存" | "提交">;
+    propsConfig: import("vue").ComputedRef<(item: any, index: number) => any>;
+    showEvent: (formItem: any, isSubmitCallback?: any) => any;
+    formKey: (item: any) => any;
+    evaluatePageProps: import("vue").ComputedRef<{
+        formArray: any;
+        evaluateResultConfig: any;
+        evaluateResultSetting: any;
+        isFinished: any;
+        maxScore: any;
+    }>;
+    evaluateCountdownProps: import("vue").ComputedRef<{
+        formArray: any;
+        evaluateResultConfig: any;
+        evaluateResultSetting: any;
+        form: any;
+        isFinished: any;
+        currentTime: any;
+        showEvaluateCountdown: any;
+    }>;
+};