cnhis-design-vue 3.1.17-beta.1 → 3.1.17-beta.10

package/es/shared/components/SlotRender/SlotRender.d.ts

@@ -0,0 +1,20 @@
+import { Func } from '../../../../es/shared/types';
+import { Component, PropType } from 'vue';
+declare const _default: import("vue").DefineComponent<{
+    renderer: {
+        type: PropType<string | Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions> | Func<any[], any>>;
+        required: true;
+    };
+    rootSlots: {
+        type: PropType<Record<string, Func<any[], any>>>;
+    };
+}, () => any, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    renderer: {
+        type: PropType<string | Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions> | Func<any[], any>>;
+        required: true;
+    };
+    rootSlots: {
+        type: PropType<Record<string, Func<any[], any>>>;
+    };
+}>>, {}>;
+export default _default;

package/es/shared/components/TextOverTooltip/TextOverTooltip.js

@@ -0,0 +1,77 @@
+import { defineComponent, ref, computed, openBlock, createElementBlock, createVNode, unref, withCtx, createElementVNode, normalizeClass, renderSlot, toDisplayString, createTextVNode } from 'vue';
+import { NTooltip } from 'naive-ui';
+import XEUtils from 'xe-utils';
+import 'moment';
+import _export_sfc from '../../../_virtual/plugin-vue_export-helper.js';
+
+const _hoisted_1 = { class: "text-over-tooltip-components" };
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "TextOverTooltip",
+  props: {
+    content: null,
+    className: null,
+    refName: null,
+    effect: { default: "dark" },
+    placement: { default: "top" },
+    tooltipTitle: { default: "" },
+    isAlias: { type: Boolean }
+  },
+  setup(__props) {
+    const props = __props;
+    let isDisabledTooltip = ref(false);
+    const curContent = computed(() => {
+      let res = props.tooltipTitle || props.content || "";
+      if (XEUtils.isNumber(res)) {
+        return res.toString();
+      }
+      return res;
+    });
+    const $refName = ref(null);
+    const onMouseOver = (str) => {
+      if (props.isAlias) {
+        isDisabledTooltip.value = true;
+        return;
+      }
+      let parentWidth = $refName.value.parentNode.offsetWidth;
+      let contentWidth = $refName.value.offsetWidth;
+      isDisabledTooltip.value = contentWidth > parentWidth;
+    };
+    const onMouseOut = () => {
+      isDisabledTooltip.value = false;
+    };
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", _hoisted_1, [
+        createVNode(unref(NTooltip), {
+          effect: __props.effect,
+          show: unref(isDisabledTooltip),
+          placement: __props.placement
+        }, {
+          trigger: withCtx(() => [
+            createElementVNode("div", {
+              class: normalizeClass(["ellipsis", __props.className]),
+              onMouseover: _cache[0] || (_cache[0] = ($event) => onMouseOver(__props.refName)),
+              onMouseout: onMouseOut
+            }, [
+              createElementVNode("i", {
+                ref: (el) => {
+                  if (el)
+                    $refName.value = el;
+                }
+              }, [
+                renderSlot(_ctx.$slots, "default"),
+                createElementVNode("i", null, toDisplayString(__props.content), 1)
+              ], 512)
+            ], 34)
+          ]),
+          default: withCtx(() => [
+            createTextVNode(" " + toDisplayString(unref(curContent)), 1)
+          ]),
+          _: 3
+        }, 8, ["effect", "show", "placement"])
+      ]);
+    };
+  }
+});
+var script = /* @__PURE__ */ _export_sfc(_sfc_main, [["__file", "TextOverTooltip.vue"]]);
+
+export { script as default };

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

@@ -0,0 +1,126 @@
+import { defineComponent, reactive, computed, createVNode, resolveComponent } from 'vue';
+import XEUtils from 'xe-utils';
+import 'moment';
+import videoModal from './video-modal.js';
+import { NIcon } from 'naive-ui';
+import { SyncOutline } from '@vicons/ionicons5';
+import img from '../../assets/img/video_default_cover.js';
+
+var videoList = defineComponent({
+  name: "video-list",
+  components: {
+    videoModal,
+    NIcon
+  },
+  props: {
+    propsList: {
+      type: [Array, String],
+      default: () => []
+    },
+    columnName: {
+      type: String,
+      default: ""
+    },
+    stlist: {
+      type: String,
+      default: ""
+    }
+  },
+  setup(props, context) {
+    const state = reactive({
+      videoVisible: false,
+      fileList: [],
+      palyerIndex: 0,
+      playerOptions: {}
+    });
+    const handleGetJsonStr = (str) => {
+      let resList = [];
+      if (XEUtils.isJSON(str)) {
+        resList = JSON.parse(str);
+      } else {
+        resList = typeof str === "string" ? [] : str;
+      }
+      if (resList && resList.type === "jsonb") {
+        if (XEUtils.isJSON(resList.value)) {
+          resList = JSON.parse(resList.value);
+          if (resList.type === "jsonb") {
+            resList = handleGetJsonStr(resList);
+          }
+        }
+      }
+      return resList;
+    };
+    const initFileList = (val) => {
+      let fileList = val;
+      let resList = [];
+      if (Array.isArray(fileList)) {
+        resList = JSON.parse(JSON.stringify(fileList));
+      }
+      if (typeof fileList === "string") {
+        resList = handleGetJsonStr(fileList);
+      }
+      resList.forEach((v) => {
+        v.vodCoverUrl = v.vodCoverUrl || void 0;
+        let vodUrl = v.url || v.videoUrl;
+        let strList = vodUrl.split(".");
+        let last = strList[strList.length - 1];
+        let type = `video/${last}`;
+        v.playerOptions = {
+          sources: [{
+            type,
+            src: vodUrl
+          }]
+        };
+      });
+      state.fileList = resList || [];
+      return resList;
+    };
+    const showFileList = computed(() => {
+      let val = props.stlist || props.propsList;
+      return initFileList(val) || [];
+    });
+    const palyerVod = (data, index) => {
+      state.palyerIndex = index;
+      let vodUrl = data.url || data.videoUrl;
+      let strList = vodUrl.split(".");
+      strList[strList.length - 1];
+      state.playerOptions = data.playerOptions;
+      state.videoVisible = true;
+    };
+    const getvideoCover = (item) => {
+      return item.vodCoverUrl || img;
+    };
+    const renderVodList = () => {
+      return createVNode("div", {
+        "class": "c-playervod-wrap vod-list"
+      }, [createVNode("div", {
+        "class": "show-list"
+      }, [showFileList.value.map((v, i) => {
+        createVNode("div", {
+          "class": "vod-wrap"
+        }, [createVNode("div", {
+          "class": "vod-def-bg"
+        }, [createVNode("img", {
+          "src": getvideoCover(v),
+          "class": "vod-cover-img"
+        }, null)]), createVNode("div", {
+          "class": "icon-wrap"
+        }, [createVNode(resolveComponent("n-icon"), {
+          "component": SyncOutline,
+          "class": "icon-play",
+          "onClick": palyerVod(v, i)
+        }, null)])]);
+      })]), state.videoVisible && createVNode(resolveComponent("video-modal"), {
+        "visible:sync": state.videoVisible,
+        "fileList": state.fileList,
+        "palyerIndex": state.palyerIndex,
+        "playerOptions": state.playerOptions
+      }, null)]);
+    };
+    return () => {
+      return renderVodList();
+    };
+  }
+});
+
+export { videoList as default };

package/es/shared/core/create.js

@@ -0,0 +1,8 @@
+import { COMPONENT_NAMESPACE } from '../global/variable.js';
+
+function create(vm) {
+  vm.name = COMPONENT_NAMESPACE + (vm.name || "");
+  return vm;
+}
+
+export { create as default };

package/es/shared/types/index.js

@@ -0,0 +1 @@
+

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

@@ -0,0 +1,31 @@
+export declare enum LogsType {
+    DEFAULT = "default",
+    PRIMARY = "primary",
+    SUCCESS = "success",
+    WARNING = "warning",
+    DANGER = "danger"
+}
+declare class Log {
+    /**
+     * @description 打印一个 [ title | text ] 样式的信息
+     * @param {String} title title text
+     * @param {String} info info text
+     * @param {String} type style
+     * @param {any[]} appendInfo
+     */
+    capsule(title: string, info: any, type?: LogsType, ...appendInfo: any[]): void;
+    /**
+     * @description 打印彩色文字
+     */
+    colorful(textArr: {
+        text: any;
+        type: LogsType;
+    }[]): void;
+    text(text: any): void;
+    primary(text: any): void;
+    success(text: any): void;
+    warning(text: any): void;
+    danger(text: any): void;
+}
+declare const log: Log;
+export default log;

package/es/shared/utils/colorLog.js

@@ -0,0 +1,44 @@
+var LogsType = /* @__PURE__ */ ((LogsType2) => {
+  LogsType2["DEFAULT"] = "default";
+  LogsType2["PRIMARY"] = "primary";
+  LogsType2["SUCCESS"] = "success";
+  LogsType2["WARNING"] = "warning";
+  LogsType2["DANGER"] = "danger";
+  return LogsType2;
+})(LogsType || {});
+function typeColor(type = "primary" /* PRIMARY */) {
+  const colorMap = {
+    ["default" /* DEFAULT */]: "#f5f5f5",
+    ["primary" /* PRIMARY */]: "#409EFF",
+    ["success" /* SUCCESS */]: "#67C23A",
+    ["warning" /* WARNING */]: "#E6A23C",
+    ["danger" /* DANGER */]: "#F56C6C"
+  };
+  return colorMap[type];
+}
+class Log {
+  capsule(title, info, type = "primary" /* PRIMARY */, ...appendInfo) {
+    console.log(`%c ${title} %c ${info} %c`, "background:#35495E; padding: 1px; border-radius: 3px 0 0 3px; color: #fff;", `background:${typeColor(type)}; padding: 1px; border-radius: 0 3px 3px 0;  color: #fff;`, "background:transparent", ...appendInfo);
+  }
+  colorful(textArr) {
+    console.log(`%c${textArr.map((t) => t.text || "").join("%c")}`, ...textArr.map((t) => `color: ${typeColor(t.type)};`));
+  }
+  text(text) {
+    this.colorful([{ text, type: "default" /* DEFAULT */ }]);
+  }
+  primary(text) {
+    this.colorful([{ text, type: "primary" /* PRIMARY */ }]);
+  }
+  success(text) {
+    this.colorful([{ text, type: "success" /* SUCCESS */ }]);
+  }
+  warning(text) {
+    this.colorful([{ text, type: "warning" /* WARNING */ }]);
+  }
+  danger(text) {
+    this.colorful([{ text, type: "danger" /* DANGER */ }]);
+  }
+}
+const log = new Log();
+
+export { LogsType, log as default };

package/es/shared/utils/loadViewer.js

@@ -0,0 +1,11 @@
+import { safeComponentRegister } from './index.js';
+import VueViewer from 'v-viewer';
+
+function loadViewer(app) {
+  safeComponentRegister(app, VueViewer, "viewer", () => {
+    app.use(VueViewer);
+    import('viewerjs/dist/viewer.min.css');
+  });
+}
+
+export { loadViewer };

package/es/shared/utils/loadVxe.js

@@ -0,0 +1,12 @@
+import { safeComponentRegister } from './index.js';
+import VXETable from 'vxe-table';
+
+function loadVxeTable(app) {
+  safeComponentRegister(app, VXETable, "VxeTable", () => {
+    app.use(VXETable);
+    import('vxe-table/lib/style.css');
+    import('xe-utils');
+  });
+}
+
+export { loadVxeTable };