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

package/es/shared/components/no-data/NoData.js

@@ -0,0 +1,74 @@
+import { defineComponent, computed, openBlock, createElementBlock, unref, createCommentVNode, createElementVNode, toDisplayString } from 'vue';
+import noData from '../../assets/img/nodata.js';
+import noPermission from '../../assets/img/no-permission.js';
+import failure from '../../assets/img/failure.js';
+import notfound from '../../assets/img/notfound.js';
+import _export_sfc from '../../../_virtual/plugin-vue_export-helper.js';
+
+const _hoisted_1 = { class: "no-data-tip NoData-page" };
+const _hoisted_2 = ["src"];
+const _hoisted_3 = { key: 1 };
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "NoData",
+  props: {
+    noDataTip: {
+      type: String,
+      default: "\u6682\u65E0\u6570\u636E"
+    },
+    noDataImg: {
+      type: String,
+      default: "nodata"
+    },
+    showImg: {
+      type: Boolean,
+      default: true
+    }
+  },
+  setup(__props) {
+    const props = __props;
+    const imgStr = computed(() => {
+      let str = null;
+      switch (props.noDataImg) {
+        case "no-permission":
+          str = noPermission;
+          break;
+        case "failure":
+          str = failure;
+          break;
+        case "nodata":
+          str = noData;
+          break;
+        default:
+          str = notfound;
+          break;
+      }
+      return str;
+    });
+    const handleDesc = computed(() => {
+      let res = "";
+      switch (props.noDataImg) {
+        case "no-permission":
+          res = "\u8BF7\u8054\u7CFB\u7BA1\u7406\u5458";
+          break;
+        case "failure":
+          res = "\u8BF7\u7A0D\u540E\u518D\u8BD5";
+          break;
+      }
+      return res;
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", _hoisted_1, [
+        __props.showImg ? (openBlock(), createElementBlock("img", {
+          key: 0,
+          src: unref(imgStr),
+          alt: ""
+        }, null, 8, _hoisted_2)) : createCommentVNode("v-if", true),
+        createElementVNode("p", null, toDisplayString(__props.noDataTip), 1),
+        unref(handleDesc) ? (openBlock(), createElementBlock("span", _hoisted_3, toDisplayString(unref(handleDesc)), 1)) : createCommentVNode("v-if", true)
+      ]);
+    };
+  }
+});
+var script = /* @__PURE__ */ _export_sfc(_sfc_main, [["__file", "NoData.vue"]]);
+
+export { script as default };

package/es/shared/components/no-data/NoData.vue.d.ts

@@ -0,0 +1,49 @@
+declare const _default: import("vue").DefineComponent<{
+    noDataTip: {
+        type: StringConstructor;
+        default: string;
+    };
+    noDataImg: {
+        type: StringConstructor;
+        default: string;
+    };
+    showImg: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}, {
+    imgStr: import("vue").ComputedRef<null>;
+    props: Readonly<import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
+        noDataTip: {
+            type: StringConstructor;
+            default: string;
+        };
+        noDataImg: {
+            type: StringConstructor;
+            default: string;
+        };
+        showImg: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+    }>> & {}>>;
+    handleDesc: import("vue").ComputedRef<string>;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    noDataTip: {
+        type: StringConstructor;
+        default: string;
+    };
+    noDataImg: {
+        type: StringConstructor;
+        default: string;
+    };
+    showImg: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>>, {
+    noDataTip: string;
+    noDataImg: string;
+    showImg: boolean;
+}>;
+export default _default;

package/es/shared/components/no-data/index.d.ts

@@ -0,0 +1,2 @@
+import script from './NoData.vue';
+export default script;

package/es/shared/components/no-data/index.js

@@ -0,0 +1,2 @@
+import script from './NoData.js';
+export { default } from './NoData.js';

package/es/shared/components/player-vod/index.vue.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{}>>, {}>;
+export default _default;

package/es/shared/components/player-vod/player.d.ts

@@ -0,0 +1,17 @@
+import 'video.js/dist/video-js.css';
+declare const _default: import("vue").DefineComponent<{
+    options: {
+        type: ObjectConstructor;
+        required: true;
+        default: () => void;
+    };
+}, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    options: {
+        type: ObjectConstructor;
+        required: true;
+        default: () => void;
+    };
+}>>, {
+    options: Record<string, any>;
+}>;
+export default _default;

package/es/shared/components/player-vod/player.js

@@ -0,0 +1,121 @@
+import { defineComponent, reactive, ref, computed, onMounted, watch, createVNode } from 'vue';
+import videojs from 'video.js/dist/video.min.js';
+import 'video.js/dist/video-js.css';
+
+var playerVod = defineComponent({
+  name: "player",
+  props: {
+    options: {
+      type: Object,
+      required: true,
+      default: () => {
+      }
+    }
+  },
+  setup(props, context) {
+    let tempW = document.documentElement.clientWidth * 0.6 + "";
+    const state = reactive({
+      player: null,
+      playerOptions: {},
+      defaultOptions: {
+        playbackRates: [0.5, 1, 1.5, 2],
+        autoplay: true,
+        muted: false,
+        loop: false,
+        preload: "auto",
+        src: "",
+        poster: "",
+        height: 600,
+        width: parseInt(tempW),
+        controls: true,
+        notSupportedMessage: "\u6B64\u89C6\u9891\u6682\u65E0\u6CD5\u64AD\u653E",
+        suppressNotSupportedError: true,
+        controlBar: {
+          timeDivider: true,
+          durationDisplay: true,
+          currentTimeDisplay: true,
+          remainingTimeDisplay: false,
+          pictureInPictureToggle: false,
+          volumePanel: {
+            inline: false
+          }
+        },
+        errorDisplay: true,
+        posterImage: false,
+        bigPlayButton: true,
+        textTrackDisplay: false
+      }
+    });
+    const videoDom = ref(null);
+    const error = (e) => {
+      let err = e.error();
+      if (err.code === 2) {
+        let buffTime = e.bufferedEnd() - 6;
+        e.load(window.playerOptions.sources[0].src);
+        e.currentTime(buffTime);
+        e.play();
+      } else {
+        window.alert.err(err.message);
+      }
+    };
+    const initVideo = () => {
+      state.player = videojs(videoDom.value, Object.assign(state.defaultOptions, props.options), function() {
+        state.player.on("error", () => {
+          let err = error();
+          if (err.code === 2) {
+            let buffTime = window.bufferedEnd() - 6;
+            window.load(src.value);
+            window.currentTime(buffTime);
+            window.play();
+          } else {
+            console.log(err.message);
+          }
+        });
+      });
+      state.player.src(src.value);
+      if (state.player)
+        state.player.play();
+    };
+    const src = computed(() => {
+      var _a, _b, _c;
+      return (_c = (_b = (_a = props.options) == null ? void 0 : _a.sources) == null ? void 0 : _b[0]) == null ? void 0 : _c.src;
+    });
+    const autoplay = computed(() => {
+      var _a;
+      return (_a = props.options) == null ? void 0 : _a.autoplay;
+    });
+    onMounted(() => {
+      initVideo();
+    });
+    watch(() => src.value, (val) => {
+      if (!val)
+        return;
+      console.log(val, "---watch--src");
+    });
+    watch(() => autoplay.value, (val) => {
+      if (!val)
+        return;
+      state.player.play();
+    });
+    const renderVideoPlayer = () => {
+      return createVNode("div", {
+        "class": "video-container cp"
+      }, [createVNode("video", {
+        "onContextmenu": (e) => {
+          e.preventDefault();
+          e.stopPropagation();
+        },
+        "ref": videoDom,
+        "controls": true,
+        "class": "video-js vjs-default-skin vjs-big-play-centered",
+        "webkit-playsinline": "true",
+        "playsinline": true
+      }, null)]);
+    };
+    return () => {
+      return renderVideoPlayer();
+    };
+  }
+});
+
+export { playerVod as default };

package/es/shared/components/player-vod/video-list.d.ts

@@ -0,0 +1,32 @@
+declare const _default: import("vue").DefineComponent<{
+    propsList: {
+        type: (ArrayConstructor | StringConstructor)[];
+        default: () => never[];
+    };
+    columnName: {
+        type: StringConstructor;
+        default: string;
+    };
+    stlist: {
+        type: StringConstructor;
+        default: string;
+    };
+}, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    propsList: {
+        type: (ArrayConstructor | StringConstructor)[];
+        default: () => never[];
+    };
+    columnName: {
+        type: StringConstructor;
+        default: string;
+    };
+    stlist: {
+        type: StringConstructor;
+        default: string;
+    };
+}>>, {
+    columnName: string;
+    propsList: string | unknown[];
+    stlist: string;
+}>;
+export default _default;

package/es/shared/components/player-vod/video-modal.d.ts

@@ -0,0 +1,54 @@
+declare const _default: import("vue").DefineComponent<{
+    visible: BooleanConstructor;
+    formData: {
+        type: ObjectConstructor;
+        default: () => {};
+    };
+    playerOptions: {
+        type: ObjectConstructor;
+        default: () => {
+            sources: {
+                type: string;
+                src: string;
+            }[];
+        };
+    };
+    fileList: {
+        type: ArrayConstructor;
+        default: () => never[];
+    };
+    palyerIndex: {
+        type: NumberConstructor;
+        default: number;
+    };
+}, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    visible: BooleanConstructor;
+    formData: {
+        type: ObjectConstructor;
+        default: () => {};
+    };
+    playerOptions: {
+        type: ObjectConstructor;
+        default: () => {
+            sources: {
+                type: string;
+                src: string;
+            }[];
+        };
+    };
+    fileList: {
+        type: ArrayConstructor;
+        default: () => never[];
+    };
+    palyerIndex: {
+        type: NumberConstructor;
+        default: number;
+    };
+}>>, {
+    visible: boolean;
+    formData: Record<string, any>;
+    fileList: unknown[];
+    playerOptions: Record<string, any>;
+    palyerIndex: number;
+}>;
+export default _default;

package/es/shared/components/player-vod/video-modal.js

@@ -0,0 +1,91 @@
+import { defineComponent, reactive, createVNode, resolveComponent, withDirectives, resolveDirective, isVNode } from 'vue';
+import { NModal, NCarousel } from 'naive-ui';
+import playerVod from './player.js';
+
+function _isSlot(s) {
+  return typeof s === "function" || Object.prototype.toString.call(s) === "[object Object]" && !isVNode(s);
+}
+var videoModal = defineComponent({
+  name: "videoModal",
+  components: {
+    NModal,
+    NCarousel,
+    playerVod
+  },
+  props: {
+    visible: Boolean,
+    formData: {
+      type: Object,
+      default: () => ({})
+    },
+    playerOptions: {
+      type: Object,
+      default: () => ({
+        sources: [{
+          type: "video/mp4",
+          src: ""
+        }]
+      })
+    },
+    fileList: {
+      type: Array,
+      default: () => []
+    },
+    palyerIndex: {
+      type: Number,
+      default: 0
+    }
+  },
+  setup(props, context) {
+    const state = reactive({
+      previewVisible: false
+    });
+    state.previewVisible = props.visible;
+    console.log(state.previewVisible);
+    const isSingle = props.fileList && !props.fileList.length;
+    const handleCancel = () => {
+      context.emit("closeVideoModal", false);
+      state.previewVisible = false;
+    };
+    console.log("\u6E32\u67D3video-model---", props.formData.title);
+    const renderVideoModal = () => {
+      let _slot;
+      return createVNode(resolveComponent("n-modal"), {
+        "class": "c-player-video-modal",
+        "show": state.previewVisible,
+        "onUpdate:show": ($event) => state.previewVisible = $event,
+        "preset": "card",
+        "style": {
+          width: "60vw",
+          height: "65vh"
+        },
+        "on-after-leave": handleCancel
+      }, {
+        default: () => [createVNode("div", {
+          "class": "preview-wrap"
+        }, [createVNode("div", {
+          "class": "preview"
+        }, [isSingle && createVNode(playerVod, {
+          "options": props.playerOptions
+        }, null), !isSingle && withDirectives(createVNode(resolveComponent("n-carousel"), {
+          "arrows": true,
+          "current-index": props.palyerIndex,
+          "dot-type": "line",
+          "show-arrow": true
+        }, _isSlot(_slot = props.fileList.map((v, i) => {
+          createVNode(playerVod, {
+            "playerOptions": v.playerOptions,
+            "key": i
+          }, null);
+        })) ? _slot : {
+          default: () => [_slot]
+        }), [[resolveDirective("else")]])])])]
+      });
+    };
+    return () => {
+      return renderVideoModal();
+    };
+  }
+});
+
+export { videoModal as default };

package/es/shared/global/variable.d.ts

@@ -0,0 +1 @@
+export declare const COMPONENT_NAMESPACE = "C";

package/es/shared/global/variable.js

@@ -0,0 +1,3 @@
+const COMPONENT_NAMESPACE = "C";
+
+export { COMPONENT_NAMESPACE };

package/es/shared/index.js

@@ -0,0 +1 @@
+

package/es/shared/types/index.d.ts

@@ -0,0 +1,11 @@
+import { App } from '@vue/runtime-core';
+export declare type SFCWithInstall<T> = T & {
+    install: (app: App, ...options: any[]) => any;
+};
+export declare type AnyObject = Record<string, any>;
+export declare type Func<T extends Array<any> = any[], P = any> = (...args: T) => P;
+export declare type Nullable<T> = T | null | undefined;
+export declare type UndefinedAble<T> = T | undefined;
+export declare type ArrayAble<T> = T | T[];
+export declare type MapValue<T> = T extends Map<any, infer P> ? P : any;
+export declare type NotNull<T> = T extends null | undefined ? never : T;

package/es/shared/types/index.js

@@ -0,0 +1 @@
+

package/es/shared/utils/anime.d.ts

@@ -0,0 +1,35 @@
+declare function bounceOut(x: number): number;
+declare const animeType: {
+    easeInQuad: (x: number) => number;
+    easeOutQuad: (x: number) => number;
+    easeInOutQuad: (x: number) => number;
+    easeInCubic: (x: number) => number;
+    easeOutCubic: (x: number) => number;
+    easeInOutCubic: (x: number) => number;
+    easeInQuart: (x: number) => number;
+    easeOutQuart: (x: number) => number;
+    easeInOutQuart: (x: number) => number;
+    easeInQuint: (x: number) => number;
+    easeOutQuint: (x: number) => number;
+    easeInOutQuint: (x: number) => number;
+    easeInSine: (x: number) => number;
+    easeOutSine: (x: number) => number;
+    easeInOutSine: (x: number) => number;
+    easeInExpo: (x: number) => number;
+    easeOutExpo: (x: number) => number;
+    easeInOutExpo: (x: number) => number;
+    easeInCirc: (x: number) => number;
+    easeOutCirc: (x: number) => number;
+    easeInOutCirc: (x: number) => number;
+    easeInElastic: (x: number) => number;
+    easeOutElastic: (x: number) => number;
+    easeInOutElastic: (x: number) => number;
+    easeInBack: (x: number) => number;
+    easeOutBack: (x: number) => number;
+    easeInOutBack: (x: number) => number;
+    easeInBounce: (x: number) => number;
+    easeOutBounce: typeof bounceOut;
+    easeInOutBounce: (x: number) => number;
+};
+export declare const doAnimation: (startValue: number, endValue: number, during: number | undefined, callback: (v: number) => void, type?: keyof typeof animeType, onAnimationEnd?: ((...args: unknown[]) => void) | undefined) => void;
+export {};

package/es/shared/utils/anime.js

@@ -0,0 +1,129 @@
+const pow = Math.pow, sqrt = Math.sqrt, sin = Math.sin, cos = Math.cos, PI = Math.PI, c1 = 1.70158, c2 = c1 * 1.525, c3 = c1 + 1, c4 = 2 * PI / 3, c5 = 2 * PI / 4.5;
+function bounceOut(x) {
+  const n1 = 7.5625, d1 = 2.75;
+  if (x < 1 / d1) {
+    return n1 * x * x;
+  } else if (x < 2 / d1) {
+    return n1 * (x -= 1.5 / d1) * x + 0.75;
+  } else if (x < 2.5 / d1) {
+    return n1 * (x -= 2.25 / d1) * x + 0.9375;
+  } else {
+    return n1 * (x -= 2.625 / d1) * x + 0.984375;
+  }
+}
+const animeType = {
+  easeInQuad: function(x) {
+    return x * x;
+  },
+  easeOutQuad: function(x) {
+    return 1 - (1 - x) * (1 - x);
+  },
+  easeInOutQuad: function(x) {
+    return x < 0.5 ? 2 * x * x : 1 - pow(-2 * x + 2, 2) / 2;
+  },
+  easeInCubic: function(x) {
+    return x * x * x;
+  },
+  easeOutCubic: function(x) {
+    return 1 - pow(1 - x, 3);
+  },
+  easeInOutCubic: function(x) {
+    return x < 0.5 ? 4 * x * x * x : 1 - pow(-2 * x + 2, 3) / 2;
+  },
+  easeInQuart: function(x) {
+    return x * x * x * x;
+  },
+  easeOutQuart: function(x) {
+    return 1 - pow(1 - x, 4);
+  },
+  easeInOutQuart: function(x) {
+    return x < 0.5 ? 8 * x * x * x * x : 1 - pow(-2 * x + 2, 4) / 2;
+  },
+  easeInQuint: function(x) {
+    return x * x * x * x * x;
+  },
+  easeOutQuint: function(x) {
+    return 1 - pow(1 - x, 5);
+  },
+  easeInOutQuint: function(x) {
+    return x < 0.5 ? 16 * x * x * x * x * x : 1 - pow(-2 * x + 2, 5) / 2;
+  },
+  easeInSine: function(x) {
+    return 1 - cos(x * PI / 2);
+  },
+  easeOutSine: function(x) {
+    return sin(x * PI / 2);
+  },
+  easeInOutSine: function(x) {
+    return -(cos(PI * x) - 1) / 2;
+  },
+  easeInExpo: function(x) {
+    return x === 0 ? 0 : pow(2, 10 * x - 10);
+  },
+  easeOutExpo: function(x) {
+    return x === 1 ? 1 : 1 - pow(2, -10 * x);
+  },
+  easeInOutExpo: function(x) {
+    return x === 0 ? 0 : x === 1 ? 1 : x < 0.5 ? pow(2, 20 * x - 10) / 2 : (2 - pow(2, -20 * x + 10)) / 2;
+  },
+  easeInCirc: function(x) {
+    return 1 - sqrt(1 - pow(x, 2));
+  },
+  easeOutCirc: function(x) {
+    return sqrt(1 - pow(x - 1, 2));
+  },
+  easeInOutCirc: function(x) {
+    return x < 0.5 ? (1 - sqrt(1 - pow(2 * x, 2))) / 2 : (sqrt(1 - pow(-2 * x + 2, 2)) + 1) / 2;
+  },
+  easeInElastic: function(x) {
+    return x === 0 ? 0 : x === 1 ? 1 : -pow(2, 10 * x - 10) * sin((x * 10 - 10.75) * c4);
+  },
+  easeOutElastic: function(x) {
+    return x === 0 ? 0 : x === 1 ? 1 : pow(2, -10 * x) * sin((x * 10 - 0.75) * c4) + 1;
+  },
+  easeInOutElastic: function(x) {
+    return x === 0 ? 0 : x === 1 ? 1 : x < 0.5 ? -(pow(2, 20 * x - 10) * sin((20 * x - 11.125) * c5)) / 2 : pow(2, -20 * x + 10) * sin((20 * x - 11.125) * c5) / 2 + 1;
+  },
+  easeInBack: function(x) {
+    return c3 * x * x * x - c1 * x * x;
+  },
+  easeOutBack: function(x) {
+    return 1 + c3 * pow(x - 1, 3) + c1 * pow(x - 1, 2);
+  },
+  easeInOutBack: function(x) {
+    return x < 0.5 ? pow(2 * x, 2) * ((c2 + 1) * 2 * x - c2) / 2 : (pow(2 * x - 2, 2) * ((c2 + 1) * (x * 2 - 2) + c2) + 2) / 2;
+  },
+  easeInBounce: function(x) {
+    return 1 - bounceOut(1 - x);
+  },
+  easeOutBounce: bounceOut,
+  easeInOutBounce: function(x) {
+    return x < 0.5 ? (1 - bounceOut(1 - 2 * x)) / 2 : (1 + bounceOut(2 * x - 1)) / 2;
+  }
+};
+const doAnimation = (startValue, endValue, during = 1e3, callback, type = "easeInBack", onAnimationEnd) => {
+  const changeValue = endValue - startValue;
+  const updateTime = 1e3 / 60;
+  const updateCount = during / updateTime;
+  const rAF = window.requestAnimationFrame || function(cb) {
+    setTimeout(cb, updateTime);
+  };
+  const startPosition = 0;
+  const endPosition = 1;
+  const perUpdateDistance = endPosition / updateCount;
+  let position = startPosition;
+  function step() {
+    const stepValue = startValue + changeValue * animeType[type](position);
+    callback(stepValue);
+    position += perUpdateDistance;
+    if (position < endPosition) {
+      rAF(step);
+    } else {
+      rAF(() => callback(endValue));
+      onAnimationEnd == null ? void 0 : onAnimationEnd();
+    }
+  }
+  step();
+};
+
+export { doAnimation };

package/es/shared/utils/clickoutside.d.ts

@@ -0,0 +1,18 @@
+interface Binding {
+    expression: any;
+    value?: any;
+}
+/**
+ * v-clickoutside
+ * @desc 点击元素外面才会触发的事件
+ * @example
+ * ```vue
+ * <div v-element-clickoutside="handleClose">
+ * ```
+ */
+declare const _default: {
+    mounted(el: any, binding: Binding, vnode: any): void;
+    update(el: any, binding: Binding, vnode: any): void;
+    unmounted(el: any): void;
+};
+export default _default;