@vunk/form 1.1.84 → 1.1.85

package/components/date-picker-range/index.cjs

@@ -0,0 +1,170 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var datePicker = require('@vunk/form/components/date-picker');
+var utilsObject = require('@vunk/core/shared/utils-object');
+var vue = require('vue');
+var _pluginVue_exportHelper = require('../_plugin-vue_export-helper.cjs');
+
+const props = {
+  ...utilsObject.pickObject(
+    datePicker._VkfDatePickerCtx.props,
+    {
+      excludes: [
+        "modelValue",
+        "prop"
+      ]
+    }
+  ),
+  type: {
+    type: String,
+    default: "daterange"
+  },
+  endPlaceholder: {
+    type: String,
+    default: "\u7ED3\u675F\u65F6\u95F4"
+  },
+  startPlaceholder: {
+    type: String,
+    default: "\u5F00\u59CB\u65F6\u95F4"
+  },
+  startValue: {
+    type: String,
+    default: ""
+  },
+  endValue: {
+    type: String,
+    default: ""
+  },
+  startProp: {
+    type: String
+  },
+  endProp: {
+    type: String
+  },
+  valueFormat: {
+    type: String,
+    default: "YYYY-MM-DD"
+  },
+  selectOptions: {
+    type: Array,
+    default: () => []
+  }
+};
+const emits = {
+  ...utilsObject.pickObject(
+    datePicker._VkfDatePickerCtx.emits,
+    {
+      excludes: ["update:modelValue"]
+    }
+  ),
+  "update:startValue": null,
+  "update:endValue": null
+};
+
+var _sfc_main = vue.defineComponent({
+  name: "VkfDatePickerRange",
+  components: {
+    VkfDatePicker: datePicker.VkfDatePicker
+  },
+  props,
+  emits,
+  setup(props2, { emit }) {
+    const coreProps = datePicker._VkfDatePickerCtx.createBindProps(props2);
+    const coreEmits = datePicker._VkfDatePickerCtx.createOnEmits(emit, ["update:modelValue"]);
+    const modelValue = vue.computed({
+      get: () => [props2.startValue, props2.endValue],
+      set: (val) => {
+        emit("update:startValue", val?.[0]);
+        emit("update:endValue", val?.[1]);
+      }
+    });
+    const prop = vue.computed(() => {
+      const pArr = [];
+      props2.startProp && pArr.push(props2.startProp);
+      props2.endProp && pArr.push(props2.endProp);
+      return pArr.join(",");
+    });
+    const rulesProp = vue.computed(() => {
+      const rules = props2.rules ? Array.isArray(props2.rules) ? props2.rules : [props2.rules] : [];
+      if (!rules.length && props2.required) {
+        rules.push({ required: true });
+      }
+      rules.forEach((rule) => {
+        if (rule.required) {
+          rule.validator = () => {
+            if (props2.startValue && props2.endValue) {
+              return true;
+            } else {
+              return false;
+            }
+          };
+        }
+      });
+      return rules;
+    });
+    return {
+      coreProps,
+      coreEmits,
+      modelValue,
+      rulesProp,
+      prop
+    };
+  }
+});
+
+const _hoisted_1 = { class: "vkf-date-picker-range-select" };
+const _hoisted_2 = ["onClick"];
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+  const _component_VkfDatePicker = vue.resolveComponent("VkfDatePicker");
+  return vue.openBlock(), vue.createElementBlock(
+    vue.Fragment,
+    null,
+    [
+      vue.withDirectives(vue.createElementVNode(
+        "div",
+        _hoisted_1,
+        [
+          (vue.openBlock(true), vue.createElementBlock(
+            vue.Fragment,
+            null,
+            vue.renderList(_ctx.selectOptions, (item) => {
+              return vue.openBlock(), vue.createElementBlock("div", {
+                key: item.label,
+                class: "vkf-date-picker-range-select-item",
+                onClick: ($event) => _ctx.modelValue = item.value
+              }, vue.toDisplayString(item.label), 9, _hoisted_2);
+            }),
+            128
+            /* KEYED_FRAGMENT */
+          ))
+        ],
+        512
+        /* NEED_PATCH */
+      ), [
+        [vue.vShow, _ctx.selectOptions.length]
+      ]),
+      vue.createVNode(_component_VkfDatePicker, vue.mergeProps({
+        modelValue: _ctx.modelValue,
+        "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => _ctx.modelValue = $event),
+        prop: _ctx.prop
+      }, _ctx.coreProps, { rules: _ctx.rulesProp }, vue.toHandlers(_ctx.coreEmits)), null, 16, ["modelValue", "prop", "rules"])
+    ],
+    64
+    /* STABLE_FRAGMENT */
+  );
+}
+var VkfDatePickerRange = /* @__PURE__ */ _pluginVue_exportHelper._export_sfc(_sfc_main, [["render", _sfc_render], ["__file", "/home/runner/work/private-vunk-form/private-vunk-form/packages/components/date-picker-range/src/index.vue"]]);
+
+var types = /*#__PURE__*/Object.freeze({
+  __proto__: null
+});
+
+VkfDatePickerRange.install = (app) => {
+  app.component(VkfDatePickerRange.name || "VkfDatePickerRange", VkfDatePickerRange);
+};
+
+exports.VkfDatePickerRange = VkfDatePickerRange;
+exports.__VkfDatePickerRange = types;
+exports.default = VkfDatePickerRange;

package/components/download-plus/index.cjs

@@ -0,0 +1,445 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var formItem = require('@vunk/form/components/form-item');
+var vue = require('vue');
+var basic = require('@skzz/platform/api/basic');
+var platform = require('@skzz/platform/shared/fetch/platform');
+var elementPlus = require('element-plus');
+var utilsFetch = require('@vunk/core/shared/utils-fetch');
+var index = require('../index.cjs');
+var composables = require('@vunk/core/composables');
+var index$1 = require('../index2.cjs');
+var utilsClass = require('@vunk/core/shared/utils-class');
+var _pluginVue_exportHelper = require('../_plugin-vue_export-helper.cjs');
+
+const props = {
+  ...formItem._VkfFormItemCtx.props,
+  fileId: {
+    type: String,
+    default: ""
+  },
+  url: {
+    type: String,
+    default: void 0
+  },
+  /**
+   * @description 分片大小
+   */
+  chunkSize: {
+    type: Number,
+    default: 1024 * 1024 * 10
+  },
+  fileServiceType: {
+    type: String,
+    default: void 0
+  },
+  /**
+     * @description 
+     * v-model:fileStatus 当前文件状态: wait, doPause, pause, doDownload, downloading, error, done
+     */
+  fileStatus: {
+    type: String,
+    default: void 0
+  }
+};
+const emits = {
+  "update:fileStatus": null
+};
+
+var Status = /* @__PURE__ */ ((Status2) => {
+  Status2["wait"] = "wait";
+  Status2["doPause"] = "doPause";
+  Status2["pause"] = "pause";
+  Status2["doDownload"] = "doDownload";
+  Status2["downloading"] = "downloading";
+  Status2["error"] = "error";
+  Status2["done"] = "done";
+  return Status2;
+})(Status || {});
+
+const restFetch = new utilsFetch.RestFetch({
+  baseURL: platform.restFetch.baseURL,
+  presetRequestInit: (config) => {
+    const header = config.headers;
+    const token = index.getToken();
+    if (token) {
+      header.set("Token", token);
+    }
+    return config;
+  }
+});
+const downChunk = (params, init) => {
+  return new Promise((resolve, reject) => {
+    const xhr = new XMLHttpRequest();
+    let url = `${restFetch.baseURL}/file/downloadByRange?fileId=${params.fileId}`;
+    if (params.fileServiceType) {
+      url += `&fileServiceType=${params.fileServiceType}`;
+      xhr.setRequestHeader("fileServiceType", params.fileServiceType);
+    }
+    if (init?.onprogress) {
+      xhr.onprogress = init?.onprogress;
+    }
+    xhr.open("GET", url, true);
+    xhr.responseType = "blob";
+    xhr.setRequestHeader("Token", index.getToken());
+    xhr.setRequestHeader("tenant", "default");
+    xhr.setRequestHeader("application", "platform");
+    xhr.setRequestHeader("Content-Range", `bytes=${params.start}-${params.end}`);
+    xhr.setRequestHeader("Accept-Ranges", "bytes");
+    xhr.onreadystatechange = (e) => {
+      const target = e.target;
+      if (xhr.readyState === 4) {
+        if (xhr.status === 200 || xhr.status === 206) {
+          if (init?.xhrs) {
+            const i = init.xhrs.findIndex((req) => req === xhr);
+            init.xhrs.splice(i, 1);
+          }
+          resolve({
+            data: target.response
+          });
+        } else if (xhr.status === 500) {
+          reject(target.response);
+        }
+      }
+    };
+    xhr.onerror = () => {
+      reject(xhr.response);
+    };
+    try {
+      xhr.send();
+    } catch (err) {
+      reject(err);
+    }
+    init?.xhrs?.push(xhr);
+  });
+};
+
+var _sfc_main = vue.defineComponent({
+  name: "VkfDownloadPlus",
+  components: {
+    VkfFormItem: formItem.VkfFormItem,
+    ElButtonGroup: elementPlus.ElButtonGroup,
+    ElButton: elementPlus.ElButton,
+    ElInput: elementPlus.ElInput
+  },
+  props,
+  emits,
+  setup(props2, { emit }) {
+    const formItemBindProps = formItem._VkfFormItemCtx.createBindProps(props2);
+    vue.watchEffect(() => {
+      restFetch.baseURL = props2.url || platform.restFetch.baseURL;
+    });
+    const fileInfo = vue.ref();
+    rFileInfo();
+    vue.watch(() => props2.fileId, rFileInfo);
+    function rFileInfo() {
+      if (!props2.fileId) {
+        return;
+      }
+      basic.rFile({
+        fileId: props2.fileId
+      }).then((res) => {
+        fileInfo.value = res;
+      });
+    }
+    const filePrefixIcon = vue.computed(() => {
+      if (fileStatus.value === Status.error) {
+        return index$1.circle_close_filled_default;
+      }
+      return index$1.download_default;
+    });
+    const chunks = vue.ref([]);
+    const downloadingXhrs = vue.ref([]);
+    const fileStatus = composables.useModelComputed({
+      default: Status.wait,
+      key: "fileStatus"
+    }, props2, emit);
+    const handleDownload = () => {
+      if (!fileInfo.value) {
+        return;
+      }
+      const fileSize = fileInfo.value.size;
+      const fileId = fileInfo.value.id;
+      const chunksLength = Math.ceil(fileSize / props2.chunkSize);
+      chunks.value = Array.from({ length: chunksLength }, (_, i) => {
+        const start = i * props2.chunkSize;
+        const end = Math.min(
+          start + props2.chunkSize,
+          fileSize
+        ) - 1;
+        let downloadedChunk = {};
+        if (chunks.value[i] && chunks.value[i].start === start && chunks.value[i].end === end && chunks.value[i].status === Status.done) {
+          downloadedChunk = chunks.value[i];
+        }
+        return {
+          start,
+          end,
+          index: i,
+          status: Status.wait,
+          fileId,
+          fileServiceType: props2.fileServiceType,
+          progress: 0,
+          ...downloadedChunk
+        };
+      });
+      fileStatus.value = Status.downloading;
+      const needDownloadChunks = chunks.value.filter(
+        (v) => v.status === Status.wait || v.status === Status.error
+      );
+      rChunkFiles(needDownloadChunks).then(() => {
+        const blobs = chunks.value.map((item) => {
+          return item.data;
+        });
+        return new Blob(
+          blobs,
+          { type: "application/octet-stream" }
+        );
+      }).then((blob) => {
+        const url = URL.createObjectURL(blob);
+        const a = document.createElement("a");
+        a.href = url;
+        a.download = fileInfo.value?.realName || "\u672A\u77E5\u6587\u4EF6";
+        a.click();
+        URL.revokeObjectURL(url);
+      }).then(() => {
+        fileStatus.value = Status.done;
+      }).catch(() => {
+        fileStatus.value = Status.error;
+        elementPlus.ElMessage.error("\u4E0B\u8F7D\u5931\u8D25");
+      });
+    };
+    vue.watch(() => fileStatus.value, (newVal) => {
+      if (newVal === Status.doDownload) {
+        handleDownload();
+      }
+    });
+    function rChunkFiles(chunks2, max = 4, retrys = 10) {
+      return new Promise((resolve, reject) => {
+        const len = chunks2.length;
+        let counter = 0;
+        if (len === 0) {
+          return resolve(void 0);
+        }
+        const retryArr = [];
+        const start = async () => {
+          while (counter < len && max > 0) {
+            max--;
+            const i = chunks2.findIndex(
+              (v) => v.status === Status.wait || v.status === Status.error
+            );
+            const currentChunk = chunks2[i];
+            if (currentChunk) {
+              currentChunk.status = Status.downloading;
+              downChunk(currentChunk, {
+                onprogress(ev) {
+                  currentChunk.progress = parseInt(ev.loaded / ev.total * 100 + "");
+                },
+                xhrs: downloadingXhrs.value
+              }).then((res) => {
+                currentChunk.status = Status.done;
+                currentChunk.data = res.data;
+                max++;
+                counter++;
+              }).then(() => {
+                if (counter === len) {
+                  resolve(void 0);
+                } else {
+                  start();
+                }
+              }).catch(() => {
+                currentChunk.status = Status.error;
+                const index = currentChunk.index;
+                if (typeof retryArr[index] !== "number") {
+                  retryArr[index] = 0;
+                }
+                retryArr[index]++;
+                console.warn(
+                  index,
+                  currentChunk,
+                  retryArr[index],
+                  "\u6B21\u62A5\u9519"
+                );
+                currentChunk.progress = -1;
+                if (retryArr[index] >= retrys) {
+                  return reject();
+                }
+                max++;
+                start();
+              });
+            }
+          }
+        };
+        start();
+      });
+    }
+    const handlePause = () => {
+      downloadingXhrs.value.forEach((xhr) => {
+        xhr.abort();
+      });
+      downloadingXhrs.value = [];
+      fileStatus.value = Status.pause;
+    };
+    vue.watch(() => fileStatus.value, (newVal) => {
+      if (newVal === Status.doPause) {
+        handlePause();
+      }
+    });
+    vue.onBeforeUnmount(() => {
+      handlePause();
+    });
+    class OnlineToggle extends utilsClass.ToggleHandler {
+      constructor(listener) {
+        super();
+        this.listener = listener;
+      }
+      add() {
+        window.addEventListener("online", this.listener);
+        this.removeHandler = () => {
+          window.removeEventListener("online", this.listener);
+        };
+      }
+    }
+    const onlineToggle = new OnlineToggle(() => {
+      if (fileStatus.value === Status.error) {
+        fileStatus.value = Status.doDownload;
+      }
+    });
+    onlineToggle.add();
+    vue.onBeforeUnmount(() => {
+      onlineToggle.remove();
+    });
+    return {
+      formItemBindProps,
+      fileInfo,
+      handleDownload,
+      handlePause,
+      Status,
+      chunks,
+      fileStatus,
+      filePrefixIcon
+    };
+  }
+});
+
+const _hoisted_1 = { class: "vkf-download-plus-main" };
+const _hoisted_2 = { class: "vkf-download-plus-label" };
+const _hoisted_3 = {
+  key: 0,
+  class: "vkf-download-plus-cube-x"
+};
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+  const _component_ElInput = vue.resolveComponent("ElInput");
+  const _component_el_button = vue.resolveComponent("el-button");
+  const _component_el_button_group = vue.resolveComponent("el-button-group");
+  const _component_VkfFormItem = vue.resolveComponent("VkfFormItem");
+  return vue.openBlock(), vue.createBlock(
+    _component_VkfFormItem,
+    vue.mergeProps(_ctx.formItemBindProps, { class: "vkf-download-plus" }),
+    {
+      default: vue.withCtx(() => [
+        vue.createElementVNode("div", _hoisted_1, [
+          vue.createElementVNode("label", _hoisted_2, [
+            vue.createVNode(_component_ElInput, {
+              class: vue.normalizeClass({
+                "is-error": _ctx.fileStatus === _ctx.Status.error
+              }),
+              "prefix-icon": _ctx.filePrefixIcon,
+              "model-value": _ctx.fileInfo?.realName,
+              readonly: ""
+            }, null, 8, ["class", "prefix-icon", "model-value"]),
+            _ctx.fileStatus === _ctx.Status.downloading || _ctx.fileStatus === _ctx.Status.pause ? (vue.openBlock(), vue.createElementBlock("div", _hoisted_3, [
+              (vue.openBlock(true), vue.createElementBlock(
+                vue.Fragment,
+                null,
+                vue.renderList(_ctx.chunks, (chunk) => {
+                  return vue.openBlock(), vue.createElementBlock(
+                    "div",
+                    {
+                      key: chunk.fileId + "-" + chunk.index,
+                      class: vue.normalizeClass(["vkf-download-plus-cube", {
+                        "error": chunk.status == _ctx.Status.error
+                      }]),
+                      style: vue.normalizeStyle({
+                        width: 100 / _ctx.chunks.length + "%"
+                      })
+                    },
+                    [
+                      vue.createElementVNode(
+                        "div",
+                        {
+                          class: vue.normalizeClass({
+                            "uploading": chunk.progress > 0 && chunk.progress < 100,
+                            "success": chunk.progress == 100
+                          }),
+                          style: vue.normalizeStyle({
+                            height: chunk.progress + "%"
+                          })
+                        },
+                        null,
+                        6
+                        /* CLASS, STYLE */
+                      )
+                    ],
+                    6
+                    /* CLASS, STYLE */
+                  );
+                }),
+                128
+                /* KEYED_FRAGMENT */
+              ))
+            ])) : vue.createCommentVNode("v-if", true)
+          ]),
+          vue.createVNode(_component_el_button_group, { class: "vkf-download-plus-btng" }, {
+            default: vue.withCtx(() => [
+              _ctx.fileStatus === _ctx.Status.downloading ? (vue.openBlock(), vue.createBlock(_component_el_button, {
+                key: 0,
+                type: "danger",
+                onClick: _ctx.handlePause
+              }, {
+                default: vue.withCtx(() => [
+                  vue.createTextVNode(" \u6682\u505C ")
+                ]),
+                _: 1
+                /* STABLE */
+              }, 8, ["onClick"])) : (vue.openBlock(), vue.createBlock(_component_el_button, {
+                key: 1,
+                type: "primary",
+                onClick: _ctx.handleDownload
+              }, {
+                default: vue.withCtx(() => [
+                  vue.createTextVNode(" \u4E0B\u8F7D ")
+                ]),
+                _: 1
+                /* STABLE */
+              }, 8, ["onClick"]))
+            ]),
+            _: 1
+            /* STABLE */
+          })
+        ])
+      ]),
+      _: 1
+      /* STABLE */
+    },
+    16
+    /* FULL_PROPS */
+  );
+}
+var VkfDownloadPlus = /* @__PURE__ */ _pluginVue_exportHelper._export_sfc(_sfc_main, [["render", _sfc_render], ["__file", "/home/runner/work/private-vunk-form/private-vunk-form/packages/components/download-plus/src/index.vue"]]);
+
+var types = /*#__PURE__*/Object.freeze({
+  __proto__: null
+});
+
+VkfDownloadPlus.install = (app) => {
+  app.component(
+    VkfDownloadPlus.name || "VkfDownloadPlus",
+    VkfDownloadPlus
+  );
+};
+
+exports.VkfDownloadPlus = VkfDownloadPlus;
+exports.__VkfDownloadPlus = types;
+exports.default = VkfDownloadPlus;