cnhis-design-vue 3.1.5-beta.16 → 3.1.5-beta.17

package/es/packages/chunk-upload/src/chunk-upload-new.vue_vue_type_script_setup_true_lang.js

@@ -1,9 +1,9 @@
-import { defineComponent, ref, reactive, onMounted, nextTick, onUnmounted, resolveComponent, openBlock, createElementBlock, createCommentVNode, createVNode, unref, withCtx, createElementVNode, Fragment, renderList, normalizeClass, toDisplayString, withDirectives, vShow, createTextVNode } from 'vue';
+import { defineComponent, ref, reactive, onMounted, nextTick, onUnmounted, resolveComponent, openBlock, createElementBlock, createCommentVNode, createVNode, unref, withCtx, createElementVNode, Fragment, renderList, withDirectives, normalizeClass, toDisplayString, vShow, createTextVNode } from 'vue';
 import SparkMD5 from 'spark-md5';
 import axios from 'axios';
 import { useMessage, NIcon, NProgress, NButton } from 'naive-ui';
-import { UploadProps, UploadState, statusSet } from './hooks/upload-data2.js';
-import { UploadComputed } from './hooks/upload-computed2.js';
+import { UploadProps, getUploadData, statusSet } from './hooks/upload-data.js';
+import { UploadComputed } from './hooks/upload-computed.js';
 import { FolderOutline, DocumentAttachOutline, Close } from '@vicons/ionicons5';
 
 const _hoisted_1 = { class: "c-chunk-upload-container" };
@@ -22,14 +22,16 @@ const _hoisted_13 = { class: "upload-btn" };
 const _hoisted_14 = /* @__PURE__ */ createElementVNode("span", null, "\u4E0A\u4F20\u65B0\u6587\u4EF6", -1);
 const _hoisted_15 = /* @__PURE__ */ createTextVNode("\u5F00\u59CB\u4E0A\u4F20");
 var script = /* @__PURE__ */ defineComponent({
+  __name: "chunk-upload-new",
   props: { ...UploadProps },
   emits: ["getSumbitList", "closeUpload"],
   setup(__props, { expose, emit }) {
     const props = __props;
+    const { UploadState } = getUploadData();
     var instance = axios.create({});
     const uploaderDom = ref(null);
     const uploadBtnDom = ref(null);
-    const state = reactive({ ...UploadState });
+    const state = reactive(UploadState);
     const message = useMessage();
     const { initState, uploadArguments, autoStart, btnAttrs } = UploadComputed(props, state);
     initState();
@@ -136,7 +138,7 @@ var script = /* @__PURE__ */ defineComponent({
         fileReader.readAsArrayBuffer(blobSlice.call(file.file, start, end));
       }
     };
-    const onFileAdded = async (file) => {
+    const onFileAdded = (file) => {
       let sizeFlag = checkSize(file);
       if (handleCheckExt(props.propsCategoryMap, file) || checkMaxLength() || sizeFlag) {
         file.ignored = true;
@@ -202,7 +204,7 @@ var script = /* @__PURE__ */ defineComponent({
             statusSet(file, "complete");
             if (uploaderDom) {
               let resData = (data2 == null ? void 0 : data2.data) || {};
-              let fileList = uploaderDom.fileList;
+              let fileList = uploaderDom.value.fileList;
               fileList.forEach((v) => {
                 if (v.uniqueIdentifier == file.uniqueIdentifier) {
                   v.crm_chkuns_complete_status = "complete";
@@ -257,7 +259,11 @@ var script = /* @__PURE__ */ defineComponent({
       return ["complete", "failed"].includes(getUploadShowStatus(file, "status"));
     };
     const handleRemove = (file) => {
-      file.cancel();
+      if (file.cancel) {
+        file.cancel();
+      } else if (file.remove) {
+        file.remove();
+      }
       let id = file.id;
       state.configList = state.configList.filter((c) => c.id !== id);
     };
@@ -349,7 +355,7 @@ var script = /* @__PURE__ */ defineComponent({
         createVNode(_component_uploader, {
           ref_key: "uploaderDom",
           ref: uploaderDom,
-          options: unref(state).options,
+          options: state.options,
           autoStart: unref(autoStart),
           onFileAdded,
           onFileSuccess,
@@ -379,7 +385,7 @@ var script = /* @__PURE__ */ defineComponent({
                       return openBlock(), createElementBlock("li", {
                         key: file.id
                       }, [
-                        createVNode(_component_uploader_file, {
+                        withDirectives(createVNode(_component_uploader_file, {
                           class: normalizeClass("file_" + file.id),
                           ref_for: true,
                           ref: "files",
@@ -415,14 +421,16 @@ var script = /* @__PURE__ */ defineComponent({
                                 ])
                               ]),
                               createVNode(unref(NProgress), {
-                                percentage: formatedProgress(unref(state).progress, file),
+                                percentage: formatedProgress(state.progress, file),
                                 type: "line",
                                 "show-indicator": false
                               }, null, 8, ["percentage"])
                             ], 2)
                           ]),
                           _: 2
-                        }, 1032, ["class", "file"])
+                        }, 1032, ["class", "file"]), [
+                          [vShow, !file.ignored]
+                        ])
                       ]);
                     }), 128))
                   ])

package/es/packages/chunk-upload/src/hooks/upload-computed.js

@@ -1 +1,70 @@
-export { UploadComputed } from './upload-computed2.js';
+import { computed } from 'vue';
+
+const UploadComputed = (props, state, config) => {
+  const handleProcessHeaders = () => {
+    return {
+      Authorization: "bearer " + state.uploadConfig.token
+    };
+  };
+  const handleGetTargetUrl = (file) => {
+    var _a;
+    return ((_a = state == null ? void 0 : state.uploadConfig) == null ? void 0 : _a.partFileUpload) || "";
+  };
+  const handleProcessParams = (params, file) => {
+    let res = {
+      channel: channel.value,
+      md5: file.uniqueIdentifier,
+      name: params.filename,
+      chunk: params.chunkNumber - 1,
+      chunks: params.totalChunks,
+      chunkSize: params.currentChunkSize
+    };
+    return res || params;
+  };
+  const processResponse = (response, cb, file, Chunk) => {
+    cb(null, response);
+  };
+  const parseTimeRemaining = (timeRemaining, parsedTimeRemaining) => {
+    return parsedTimeRemaining.replace(/\syears?/, "\u5E74").replace(/\days?/, "\u5929").replace(/\shours?/, "\u5C0F\u65F6").replace(/\sminutes?/, "\u5206\u949F").replace(/\sseconds?/, "\u79D2");
+  };
+  const initState = () => {
+    state.options.target = handleGetTargetUrl;
+    state.options.headers = handleProcessHeaders;
+    state.options.processParams = handleProcessParams;
+    state.options.parseTimeRemaining = parseTimeRemaining;
+    state.options.processResponse = processResponse;
+  };
+  const autoStart = computed(() => {
+    return false;
+  });
+  const btnAttrs = computed(() => {
+    return {
+      accept: props.propsCategoryMap
+    };
+  });
+  const channel = computed(() => {
+    let obj = state.uploadConfig;
+    if (Object.keys(obj || {}).length === 0) {
+      return void 0;
+    }
+    let res = props.uploaderType === "file" ? obj.fileChannel : obj.channel;
+    return res || obj.fileChannel;
+  });
+  const uploadArguments = computed(() => {
+    return {
+      type: props.uploaderType,
+      channel: channel.value
+    };
+  });
+  computed(() => {
+    return { ...uploadArguments.value, share: state.share };
+  });
+  return {
+    initState,
+    uploadArguments,
+    autoStart,
+    btnAttrs
+  };
+};
+
+export { UploadComputed };

package/es/packages/chunk-upload/src/hooks/upload-data.d.ts

@@ -1,31 +1,33 @@
-export declare const UploadState: {
-    spinning: boolean;
-    uploadConfig: {};
-    progress: number;
-    options: {
-        target: {};
-        chunkSize: number;
-        fileParameterName: string;
-        maxChunkRetries: number;
-        simultaneousUploads: number;
-        prioritizeFirstAndLastChunk: boolean;
-        forceChunkSize: boolean;
-        testChunks: boolean;
-        headers: {};
-        query(): void;
-        processParams: {};
-        parseTimeRemaining: {};
-        processResponse: {};
+export declare const getUploadData: () => {
+    UploadState: {
+        spinning: boolean;
+        uploadConfig: {};
+        progress: number;
+        options: {
+            target: {};
+            chunkSize: number;
+            fileParameterName: string;
+            maxChunkRetries: number;
+            simultaneousUploads: number;
+            prioritizeFirstAndLastChunk: boolean;
+            forceChunkSize: boolean;
+            testChunks: boolean;
+            headers: {};
+            query(): void;
+            processParams: {};
+            parseTimeRemaining: {};
+            processResponse: {};
+        };
+        attrs: {};
+        collapse: boolean;
+        configList: never[];
+        share: number;
+        baseUrl: string;
+        headers: {
+            Authorization: string;
+        };
+        withCredentials: boolean;
     };
-    attrs: {};
-    collapse: boolean;
-    configList: never[];
-    share: number;
-    baseUrl: string;
-    headers: {
-        Authorization: string;
-    };
-    withCredentials: boolean;
 };
 export declare const UploadProps: {
     propsCategoryMap: {

package/es/packages/chunk-upload/src/hooks/upload-data.js

@@ -1 +1,96 @@
-export { UploadProps, UploadState, statusSet } from './upload-data2.js';
+const getUploadData = () => {
+  const UploadState = {
+    spinning: false,
+    uploadConfig: {},
+    progress: 0,
+    options: {
+      target: {},
+      chunkSize: 3 * 1024 * 1024,
+      fileParameterName: "file",
+      maxChunkRetries: 3,
+      simultaneousUploads: 3,
+      prioritizeFirstAndLastChunk: true,
+      forceChunkSize: true,
+      testChunks: false,
+      headers: {},
+      query() {
+      },
+      processParams: {},
+      parseTimeRemaining: {},
+      processResponse: {}
+    },
+    attrs: {},
+    collapse: false,
+    configList: [],
+    share: 1,
+    baseUrl: "http://192.168.20.113:12060",
+    headers: {
+      Authorization: "bearer d012a22a9f284801b1bed4c20f3715de"
+    },
+    withCredentials: false
+  };
+  return { UploadState };
+};
+const UploadProps = {
+  propsCategoryMap: { type: String, default: "" },
+  max_size: { type: String, default: "" },
+  maxLength: { type: Number, default: 0 },
+  defaultList: { type: Array, default: () => [] },
+  uploaderType: { type: String, default: "video" },
+  getChunkUploadConfig: { type: Function, default: () => Promise.resolve({}) }
+};
+const statusSet = (file, status) => {
+  let statusMap = {
+    init: {
+      status: "init",
+      text: "\u521D\u59CB\u5316\u4E2D",
+      bgc: "#fff"
+    },
+    md5: {
+      status: "md5",
+      text: "\u6821\u9A8CMD5",
+      bgc: "#fff"
+    },
+    ready: {
+      status: "ready",
+      text: "\u521D\u59CB\u5316\u5B8C\u6210",
+      bgc: "#fff"
+    },
+    merging: {
+      status: "merging",
+      text: "\u5408\u5E76\u4E2D",
+      bgc: "#e2eeff"
+    },
+    uploading: {
+      status: "uploading",
+      text: "\u4E0A\u4F20\u4E2D",
+      bgc: "#e2eeff"
+    },
+    transcoding: {
+      status: "transcoding",
+      text: "\u8F6C\u7801\u4E2D",
+      bgc: "#e2eeff"
+    },
+    paused: {
+      status: "paused",
+      text: "\u6682\u505C",
+      bgc: "#e2eeff"
+    },
+    failed: {
+      status: "failed",
+      text: "\u4E0A\u4F20\u5931\u8D25",
+      bgc: "#e2eeff"
+    },
+    complete: {
+      status: "complete",
+      text: "\u4E0A\u4F20\u5B8C\u6210",
+      bgc: "#e2eeff"
+    }
+  };
+  if (status === "failed") {
+    file.pause && file.pause();
+  }
+  file.file_upload_status = { ...statusMap[status] };
+};
+
+export { UploadProps, getUploadData, statusSet };

package/es/packages/chunk-upload/src/hooks/vod-computed.js

@@ -1 +1,79 @@
-export { VodComputed } from './vod-computed2.js';
+import { computed } from 'vue';
+
+const defaultAccept = ".mp4,.ts,.mov,.mxf,.mpg,.flv,.wmv,.avi,.m4v,.f4v,.mpeg,.3gp,.asf,.mkv,.hls";
+const VodComputed = (props, state, config) => {
+  let { mainForm } = config;
+  const isShowBtn = computed(() => {
+    var _a;
+    let { max_length } = ((_a = props.formData) == null ? void 0 : _a.validate) || {};
+    if (props.source == "guage") {
+      max_length = +props.limitNum;
+    }
+    if (max_length) {
+      return state.fileList.length < max_length;
+    }
+    return true;
+  });
+  const maskHeight = computed(() => (item) => {
+    return `${item.percent}%`;
+  });
+  const showPercent = computed(() => (percent) => {
+    let res = percent > 99 ? 99 : percent;
+    return Math.floor(res);
+  });
+  const allow_format = computed(() => {
+    if (props.source === "guage")
+      return defaultAccept;
+    const { allow_format: allow_format2 } = props.formData;
+    try {
+      if (allow_format2) {
+        let list = allow_format2.split(",");
+        let resList = list.map((v) => {
+          if (v.startsWith(".")) {
+            return v;
+          } else {
+            return "." + v;
+          }
+        });
+        let resStr = resList.join(",");
+        return resStr;
+      } else {
+        return defaultAccept;
+      }
+    } catch (error) {
+      console.log(error);
+      return defaultAccept;
+    }
+  });
+  const defaultValue = computed(() => {
+    const { formData, source, defFileList } = props;
+    if (source === "guage") {
+      return defFileList;
+    }
+    return (mainForm == null ? void 0 : mainForm.defaultValue[formData.name]) || formData.default_val;
+  });
+  const isDisabled = computed(() => {
+    return props.formData.is_edit == 0 || props.isLock;
+  });
+  const max_size = computed(() => {
+    var _a;
+    const { max_size: max_size2 } = ((_a = props.formData) == null ? void 0 : _a.validate) || {};
+    return max_size2 || "";
+  });
+  const maxlength = computed(() => {
+    var _a, _b, _c, _d;
+    return +(((_b = (_a = props == null ? void 0 : props.formData) == null ? void 0 : _a.validate) == null ? void 0 : _b.max_length) || ((_d = (_c = props == null ? void 0 : props.formData) == null ? void 0 : _c.setting) == null ? void 0 : _d.limitPic) || 0);
+  });
+  return {
+    isShowBtn,
+    maskHeight,
+    showPercent,
+    allow_format,
+    defaultValue,
+    isDisabled,
+    max_size,
+    maxlength
+  };
+};
+
+export { VodComputed };

package/es/packages/chunk-upload/src/hooks/vod-data.d.ts

@@ -1,44 +1,23 @@
-export declare const VodProps: {
-    formData: {
-        type: ObjectConstructor;
-        default: () => {};
-    };
-    defList: (ArrayConstructor | StringConstructor)[];
-    source: StringConstructor;
-    limitNum: {
-        default: number;
-    };
-    defFileList: {
-        default: string;
-    };
-    isLock: BooleanConstructor;
-    isDetail: {
-        type: BooleanConstructor;
-        default: boolean;
-    };
-    getChunkUploadConfig: {
-        type: FunctionConstructor;
-        default: () => Promise<{}>;
-    };
-};
-export declare const VodState: {
-    videoVisible: boolean;
-    fileList: never[];
-    cacheFileObj: {};
-    playerOptions: {};
-    vodClient: null;
-    chunkUploadVisible: boolean;
-    uploader: null;
-    autoStart: boolean;
-    timeOuts: number;
-    configList: never[];
-    draggableOptions: {
-        group: string;
-        filter: string;
-        delayOnTouchOnly: boolean;
-        delay: number;
-        touchStartThreshold: number;
-        chosenClass: string;
-        dragClass: string;
+export declare const getVodData: () => {
+    VodState: {
+        videoVisible: boolean;
+        fileList: never[];
+        cacheFileObj: {};
+        playerOptions: {};
+        vodClient: null;
+        chunkUploadVisible: boolean;
+        uploader: null;
+        autoStart: boolean;
+        timeOuts: number;
+        configList: never[];
+        draggableOptions: {
+            group: string;
+            filter: string;
+            delayOnTouchOnly: boolean;
+            delay: number;
+            touchStartThreshold: number;
+            chosenClass: string;
+            dragClass: string;
+        };
     };
 };

package/es/packages/chunk-upload/src/hooks/vod-data.js

@@ -1 +1,28 @@
-export { VodProps, VodState } from './vod-data2.js';
+const getVodData = () => {
+  const VodState = {
+    videoVisible: false,
+    fileList: [],
+    cacheFileObj: {},
+    playerOptions: {},
+    vodClient: null,
+    chunkUploadVisible: false,
+    uploader: null,
+    autoStart: true,
+    timeOuts: 6e4 * 5,
+    configList: [],
+    draggableOptions: {
+      group: "upload-com-item",
+      filter: ".uploading-item",
+      delayOnTouchOnly: true,
+      delay: 100,
+      touchStartThreshold: 3,
+      chosenClass: "upload-chosen-draing",
+      dragClass: "upload-sortable-drag"
+    }
+  };
+  return {
+    VodState
+  };
+};
+
+export { getVodData };

package/es/packages/chunk-upload/src/vod-chunk-upload/index.js

@@ -1,2 +1,3 @@
-import './vod-chunk-upload2.js';
+import './vod-chunk-upload.js';
+import script from './vod-chunk-upload.vue_vue_type_script_setup_true_lang.js';
 export { default } from './vod-chunk-upload.vue_vue_type_script_setup_true_lang.js';

package/es/packages/chunk-upload/src/vod-chunk-upload/vod-chunk-upload.js

@@ -1,2 +1,4 @@
-import './vod-chunk-upload2.js';
+import script from './vod-chunk-upload.vue_vue_type_script_setup_true_lang.js';
 export { default } from './vod-chunk-upload.vue_vue_type_script_setup_true_lang.js';
+
+script.__file = "packages/chunk-upload/src/vod-chunk-upload/vod-chunk-upload.vue";