@vunk/form 1.1.12 → 1.1.13

package/components/upload-plus/index.js

@@ -0,0 +1,485 @@
+import { _VkfFormItemCtx, VkfFormItem } from '@vunk/form/components/form-item';
+import { openBlock, createElementBlock, createElementVNode, defineComponent, reactive, ref, computed, resolveComponent, createBlock, mergeProps, withCtx, createVNode, normalizeClass, createCommentVNode, Fragment, renderList, normalizeStyle, createTextVNode } from 'vue';
+import { ElInput, ElButtonGroup, ElButton, ElIcon } from 'element-plus';
+import { createFileChunk, calculateFileHashSample } from '@vunk/form/shared/upload';
+import { RestFetch } from '@vunk/core/shared/utils-fetch';
+
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+const props = __spreadProps(__spreadValues({}, _VkfFormItemCtx.props), {
+  size: {
+    type: Number,
+    default: 1024 / (16 * 16) * 1024 * 1024
+  },
+  dictId: {
+    type: String,
+    default: ""
+  }
+});
+const emits = {};
+
+var Status = /* @__PURE__ */ ((Status2) => {
+  Status2["wait"] = "wait";
+  Status2["pause"] = "pause";
+  Status2["uploading"] = "uploading";
+  Status2["error"] = "error";
+  Status2["done"] = "done";
+  return Status2;
+})(Status || {});
+
+var _const = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  Status: Status
+});
+
+const restFetch = new RestFetch({
+  baseURL: "http://192.168.110.209:36800"
+});
+const verify = async (params) => {
+  return restFetch.request({
+    method: "GET",
+    url: "/dict/hdfs/getChunkList",
+    params
+  }).then((res) => {
+    return res.data.map((item) => item.identifier);
+  });
+};
+const upload = async (data, init) => {
+  return new Promise((resolve, reject) => {
+    var _a;
+    const xhr = new XMLHttpRequest();
+    xhr.upload.onprogress = (init == null ? void 0 : init.onprogress) || null;
+    xhr.open("post", restFetch.baseURL + "/dict/hdfs/chunk/upload");
+    const form = new FormData();
+    form.append("file", data.chunk);
+    form.append("identifier", data.fileHash);
+    form.append("filename", data.fileName);
+    form.append("chunkNumber", data.index + 1 + "");
+    form.append("chunkIdentifier", data.hash + "");
+    form.append("totalChunk", data.chunksLength + "");
+    form.append("chunkSize", data.sliceSize + "");
+    form.append("currentChunkSize", data.chunk.size + "");
+    form.append("totalSize", data.fileSize + "");
+    xhr.send(form);
+    xhr.onreadystatechange = (e) => {
+      const target = e.target;
+      if (xhr.readyState === 4) {
+        if (xhr.status === 200) {
+          if (init == null ? void 0 : 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.timeout = 5 * 1e3;
+    xhr.ontimeout = (e) => {
+      reject(e);
+    };
+    (_a = init == null ? void 0 : init.xhrs) == null ? void 0 : _a.push(xhr);
+  });
+};
+const merge = async (data) => {
+  return restFetch.request({
+    method: "POST",
+    url: "/dict/hdfs/chunk/merge",
+    data
+  }).then((res) => {
+    return res.datas;
+  });
+};
+
+var api = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  restFetch: restFetch,
+  verify: verify,
+  upload: upload,
+  merge: merge
+});
+
+/*! Element Plus Icons Vue v2.1.0 */
+
+// unplugin-vue:/plugin-vue/export-helper
+var export_helper_default = (sfc, props) => {
+  let target = sfc.__vccOpts || sfc;
+  for (let [key, val] of props)
+    target[key] = val;
+  return target;
+};
+
+// unplugin-vue:/home/runner/work/element-plus-icons/element-plus-icons/packages/vue/src/components/circle-close-filled.vue?vue&type=script&lang.ts
+var circle_close_filled_vue_vue_type_script_lang_default = {
+  name: "CircleCloseFilled"
+};
+var _hoisted_150 = {
+  xmlns: "http://www.w3.org/2000/svg",
+  viewBox: "0 0 1024 1024"
+}, _hoisted_250 = /* @__PURE__ */ createElementVNode(
+  "path",
+  {
+    fill: "currentColor",
+    d: "M512 64a448 448 0 1 1 0 896 448 448 0 0 1 0-896zm0 393.664L407.936 353.6a38.4 38.4 0 1 0-54.336 54.336L457.664 512 353.6 616.064a38.4 38.4 0 1 0 54.336 54.336L512 566.336 616.064 670.4a38.4 38.4 0 1 0 54.336-54.336L566.336 512 670.4 407.936a38.4 38.4 0 1 0-54.336-54.336L512 457.664z"
+  },
+  null,
+  -1
+  /* HOISTED */
+), _hoisted_349 = [
+  _hoisted_250
+];
+function _sfc_render50(_ctx, _cache, $props, $setup, $data, $options) {
+  return openBlock(), createElementBlock("svg", _hoisted_150, _hoisted_349);
+}
+var circle_close_filled_default = /* @__PURE__ */ export_helper_default(circle_close_filled_vue_vue_type_script_lang_default, [["render", _sfc_render50], ["__file", "circle-close-filled.vue"]]);
+
+// unplugin-vue:/home/runner/work/element-plus-icons/element-plus-icons/packages/vue/src/components/success-filled.vue?vue&type=script&lang.ts
+var success_filled_vue_vue_type_script_lang_default = {
+  name: "SuccessFilled"
+};
+var _hoisted_1249 = {
+  xmlns: "http://www.w3.org/2000/svg",
+  viewBox: "0 0 1024 1024"
+}, _hoisted_2249 = /* @__PURE__ */ createElementVNode(
+  "path",
+  {
+    fill: "currentColor",
+    d: "M512 64a448 448 0 1 1 0 896 448 448 0 0 1 0-896zm-55.808 536.384-99.52-99.584a38.4 38.4 0 1 0-54.336 54.336l126.72 126.72a38.272 38.272 0 0 0 54.336 0l262.4-262.464a38.4 38.4 0 1 0-54.272-54.336L456.192 600.384z"
+  },
+  null,
+  -1
+  /* HOISTED */
+), _hoisted_3248 = [
+  _hoisted_2249
+];
+function _sfc_render249(_ctx, _cache, $props, $setup, $data, $options) {
+  return openBlock(), createElementBlock("svg", _hoisted_1249, _hoisted_3248);
+}
+var success_filled_default = /* @__PURE__ */ export_helper_default(success_filled_vue_vue_type_script_lang_default, [["render", _sfc_render249], ["__file", "success-filled.vue"]]);
+
+// unplugin-vue:/home/runner/work/element-plus-icons/element-plus-icons/packages/vue/src/components/upload-filled.vue?vue&type=script&lang.ts
+var upload_filled_vue_vue_type_script_lang_default = {
+  name: "UploadFilled"
+};
+var _hoisted_1274 = {
+  xmlns: "http://www.w3.org/2000/svg",
+  viewBox: "0 0 1024 1024"
+}, _hoisted_2274 = /* @__PURE__ */ createElementVNode(
+  "path",
+  {
+    fill: "currentColor",
+    d: "M544 864V672h128L512 480 352 672h128v192H320v-1.6c-5.376.32-10.496 1.6-16 1.6A240 240 0 0 1 64 624c0-123.136 93.12-223.488 212.608-237.248A239.808 239.808 0 0 1 512 192a239.872 239.872 0 0 1 235.456 194.752c119.488 13.76 212.48 114.112 212.48 237.248a240 240 0 0 1-240 240c-5.376 0-10.56-1.28-16-1.6v1.6H544z"
+  },
+  null,
+  -1
+  /* HOISTED */
+), _hoisted_3273 = [
+  _hoisted_2274
+];
+function _sfc_render274(_ctx, _cache, $props, $setup, $data, $options) {
+  return openBlock(), createElementBlock("svg", _hoisted_1274, _hoisted_3273);
+}
+var upload_filled_default = /* @__PURE__ */ export_helper_default(upload_filled_vue_vue_type_script_lang_default, [["render", _sfc_render274], ["__file", "upload-filled.vue"]]);
+
+var _export_sfc = (sfc, props) => {
+  const target = sfc.__vccOpts || sfc;
+  for (const [key, val] of props) {
+    target[key] = val;
+  }
+  return target;
+};
+
+const _sfc_main = defineComponent({
+  name: "VkfUploadPlus",
+  components: {
+    VkfFormItem,
+    ElInput,
+    ElButtonGroup,
+    ElButton,
+    ElIcon,
+    SuccessFilled: success_filled_default
+  },
+  emits,
+  props,
+  setup(props2, { emit }) {
+    const formItemBindProps = _VkfFormItemCtx.createBindProps(props2);
+    const uuid = Math.random().toString(36).slice(-8);
+    const container = reactive({});
+    const fileStatus = ref(Status.wait);
+    const chunks = ref([]);
+    const uploadingXhrs = ref([]);
+    const filePrefixIcon = computed(() => {
+      if (fileStatus.value === Status.done) {
+        return success_filled_default;
+      }
+      if (fileStatus.value === Status.error) {
+        return circle_close_filled_default;
+      }
+      return upload_filled_default;
+    });
+    const handleFileChange = (e) => {
+      const target = e.target;
+      const file = target.files?.[0];
+      if (file) {
+        container.file = file;
+        fileStatus.value = Status.wait;
+      }
+    };
+    const handleUpload = async () => {
+      if (!container.file)
+        return;
+      fileStatus.value = Status.uploading;
+      const chunkFiles = createFileChunk(container.file, props2.size);
+      const hash = await calculateFileHashSample(container.file);
+      container.hash = hash;
+      const uploadedList = await verify({
+        identifier: hash
+      });
+      const sliceSize = chunkFiles[0].size;
+      chunks.value = chunkFiles.map((chunk, index) => {
+        const _container = container;
+        const chunkHash = _container.hash + "-" + index;
+        return {
+          fileName: _container.file.name,
+          fileHash: _container.hash,
+          fileSize: _container.file.size,
+          chunk,
+          hash: chunkHash,
+          index,
+          progress: uploadedList.indexOf(chunkHash) > -1 ? 100 : 0,
+          chunksLength: chunkFiles.length,
+          sliceSize,
+          status: Status.wait
+        };
+      });
+      const needUpload = chunks.value.filter((v) => uploadedList.indexOf(v.hash) === -1);
+      cUploadedChunks(
+        needUpload
+      ).then(() => {
+        return cFile();
+      }).then(() => {
+        fileStatus.value = Status.done;
+      }).catch(() => {
+        fileStatus.value = Status.error;
+      });
+    };
+    const handlePause = () => {
+      uploadingXhrs.value.forEach((xhr) => {
+        xhr.abort();
+      });
+      uploadingXhrs.value = [];
+      fileStatus.value = Status.pause;
+    };
+    async function cUploadedChunks(urls, max = 4, retrys = 3) {
+      return new Promise((resolve, reject) => {
+        const len = urls.length;
+        let counter = 0;
+        const retryArr = [];
+        const start = async () => {
+          while (counter < len && max > 0) {
+            max--;
+            const i = urls.findIndex((v) => v.status === Status.wait || v.status === Status.error);
+            const currentChunk = urls[i];
+            if (currentChunk) {
+              currentChunk.status = Status.uploading;
+              upload(currentChunk, {
+                onprogress(ev) {
+                  chunks.value[currentChunk.index].progress = parseInt(ev.loaded / ev.total * 100 + "");
+                },
+                xhrs: uploadingXhrs.value
+              }).then(() => {
+                urls[i].status = Status.done;
+                max++;
+                counter++;
+              }).then(() => {
+                if (counter === len) {
+                  resolve(void 0);
+                } else {
+                  start();
+                }
+              }).catch(() => {
+                const index = urls[i].index;
+                urls[i].status = Status.error;
+                if (typeof retryArr[index] !== "number") {
+                  retryArr[index] = 0;
+                }
+                retryArr[index]++;
+                console.warn(
+                  index,
+                  urls[i],
+                  retryArr[index],
+                  "\u6B21\u62A5\u9519"
+                );
+                chunks.value[index].progress = -1;
+                if (retryArr[index] >= retrys) {
+                  return reject();
+                }
+                max++;
+                start();
+              });
+            }
+          }
+        };
+        start();
+      });
+    }
+    function cFile() {
+      if (!container.file)
+        return;
+      if (!container.hash)
+        return;
+      return merge({
+        filename: container.file.name,
+        identifier: container.hash,
+        dictId: props2.dictId
+      });
+    }
+    return {
+      formItemBindProps,
+      handleFileChange,
+      uuid,
+      container,
+      handleUpload,
+      fileStatus,
+      chunks,
+      Status,
+      filePrefixIcon,
+      handlePause
+    };
+  }
+});
+const _hoisted_1 = { class: "vkf-upload-plus-main" };
+const _hoisted_2 = ["for"];
+const _hoisted_3 = {
+  key: 0,
+  class: "vkf-upload-plus-msg-x"
+};
+const _hoisted_4 = /* @__PURE__ */ createElementVNode("span", { class: "vkf-upload-plus-msg" }, " \u4E0A\u4F20\u6210\u529F ", -1);
+const _hoisted_5 = {
+  key: 1,
+  class: "vkf-upload-plus-cube-x"
+};
+const _hoisted_6 = ["id"];
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+  const _component_ElInput = resolveComponent("ElInput");
+  const _component_SuccessFilled = resolveComponent("SuccessFilled");
+  const _component_ElIcon = resolveComponent("ElIcon");
+  const _component_ElButton = resolveComponent("ElButton");
+  const _component_el_button = resolveComponent("el-button");
+  const _component_el_button_group = resolveComponent("el-button-group");
+  const _component_VkfFormItem = resolveComponent("VkfFormItem");
+  return openBlock(), createBlock(_component_VkfFormItem, mergeProps(_ctx.formItemBindProps, { class: "vkf-upload-plus" }), {
+    default: withCtx(() => [
+      createElementVNode("div", _hoisted_1, [
+        createElementVNode("label", {
+          for: _ctx.uuid,
+          class: "vkf-upload-plus-label"
+        }, [
+          createVNode(_component_ElInput, {
+            class: normalizeClass({
+              "is-success": _ctx.fileStatus === _ctx.Status.done,
+              "is-error": _ctx.fileStatus === _ctx.Status.error
+            }),
+            modelValue: _ctx.container.file?.name,
+            prefixIcon: _ctx.filePrefixIcon,
+            placeholder: "\u8BF7\u9009\u62E9\u6587\u4EF6"
+          }, null, 8, ["class", "modelValue", "prefixIcon"]),
+          _ctx.fileStatus === _ctx.Status.done ? (openBlock(), createElementBlock("div", _hoisted_3, [
+            createVNode(_component_ElIcon, null, {
+              default: withCtx(() => [
+                createVNode(_component_SuccessFilled)
+              ]),
+              _: 1
+            }),
+            _hoisted_4
+          ])) : createCommentVNode("v-if", true),
+          _ctx.fileStatus === _ctx.Status.uploading || _ctx.fileStatus === _ctx.Status.pause ? (openBlock(), createElementBlock("div", _hoisted_5, [
+            (openBlock(true), createElementBlock(Fragment, null, renderList(_ctx.chunks, (chunk) => {
+              return openBlock(), createElementBlock("div", {
+                class: normalizeClass(["vkf-upload-plus-cube", {
+                  "error": chunk.status == _ctx.Status.error
+                }]),
+                key: chunk.hash,
+                style: normalizeStyle({
+                  width: 100 / chunk.chunksLength + "%"
+                })
+              }, [
+                createElementVNode("div", {
+                  class: normalizeClass({
+                    "uploading": chunk.progress > 0 && chunk.progress < 100,
+                    "success": chunk.progress == 100
+                  }),
+                  style: normalizeStyle({
+                    height: chunk.progress + "%"
+                  })
+                }, null, 6)
+              ], 6);
+            }), 128))
+          ])) : createCommentVNode("v-if", true)
+        ], 8, _hoisted_2),
+        createElementVNode("input", {
+          type: "file",
+          id: _ctx.uuid,
+          class: "vkf-upload-plus-input",
+          onChange: _cache[0] || (_cache[0] = (...args) => _ctx.handleFileChange && _ctx.handleFileChange(...args))
+        }, null, 40, _hoisted_6),
+        createVNode(_component_el_button_group, { class: "vkf-upload-plus-btng" }, {
+          default: withCtx(() => [
+            _ctx.fileStatus === _ctx.Status.uploading ? (openBlock(), createBlock(_component_ElButton, {
+              key: 0,
+              type: "danger",
+              onClick: _ctx.handlePause
+            }, {
+              default: withCtx(() => [
+                createTextVNode(" \u6682\u505C ")
+              ]),
+              _: 1
+            }, 8, ["onClick"])) : (openBlock(), createBlock(_component_el_button, {
+              key: 1,
+              type: "primary",
+              onClick: _ctx.handleUpload
+            }, {
+              default: withCtx(() => [
+                createTextVNode("\u4E0A\u4F20")
+              ]),
+              _: 1
+            }, 8, ["onClick"]))
+          ]),
+          _: 1
+        })
+      ])
+    ]),
+    _: 1
+  }, 16);
+}
+var VkfUploadPlus = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render], ["__file", "index.vue"]]);
+
+var types = /*#__PURE__*/Object.freeze({
+  __proto__: null
+});
+
+VkfUploadPlus.install = (app) => {
+  app.component(VkfUploadPlus.name, VkfUploadPlus);
+};
+
+export { VkfUploadPlus, api as _VkfUploadPlusApi, _const as _VkfUploadPlusConst, types as __VkfUploadPlus, VkfUploadPlus as default };

package/components/upload-plus/src/api.d.ts

@@ -0,0 +1,31 @@
+import { RestFetch } from '@vunk/core/shared/utils-fetch';
+import { Chunk } from './types';
+export declare const restFetch: RestFetch;
+/**
+ * https://app.apifox.com/link/project/2335162/apis/api-92811427
+ * @param data
+ * @returns
+ */
+export declare const verify: (params: {
+    identifier: string;
+}) => Promise<string[]>;
+/**
+ * https://app.apifox.com/link/project/2335162/apis/api-92025462
+ * @param data
+ * @param init
+ * @returns
+ */
+export declare const upload: (data: Chunk, init?: {
+    onprogress?: XMLHttpRequestEventTarget['onprogress'];
+    xhrs?: XMLHttpRequest[];
+}) => Promise<unknown>;
+/**
+ * https://app.apifox.com/link/project/2335162/apis/api-92729706
+ * @param data
+ * @returns
+ */
+export declare const merge: (data: {
+    identifier: string;
+    filename: string;
+    dictId?: string;
+}) => Promise<any>;

package/components/upload-plus/src/api.js

@@ -0,0 +1,65 @@
+import { RestFetch } from '@vunk/core/shared/utils-fetch';
+
+const restFetch = new RestFetch({
+  baseURL: "http://192.168.110.209:36800"
+});
+const verify = async (params) => {
+  return restFetch.request({
+    method: "GET",
+    url: "/dict/hdfs/getChunkList",
+    params
+  }).then((res) => {
+    return res.data.map((item) => item.identifier);
+  });
+};
+const upload = async (data, init) => {
+  return new Promise((resolve, reject) => {
+    var _a;
+    const xhr = new XMLHttpRequest();
+    xhr.upload.onprogress = (init == null ? void 0 : init.onprogress) || null;
+    xhr.open("post", restFetch.baseURL + "/dict/hdfs/chunk/upload");
+    const form = new FormData();
+    form.append("file", data.chunk);
+    form.append("identifier", data.fileHash);
+    form.append("filename", data.fileName);
+    form.append("chunkNumber", data.index + 1 + "");
+    form.append("chunkIdentifier", data.hash + "");
+    form.append("totalChunk", data.chunksLength + "");
+    form.append("chunkSize", data.sliceSize + "");
+    form.append("currentChunkSize", data.chunk.size + "");
+    form.append("totalSize", data.fileSize + "");
+    xhr.send(form);
+    xhr.onreadystatechange = (e) => {
+      const target = e.target;
+      if (xhr.readyState === 4) {
+        if (xhr.status === 200) {
+          if (init == null ? void 0 : 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.timeout = 5 * 1e3;
+    xhr.ontimeout = (e) => {
+      reject(e);
+    };
+    (_a = init == null ? void 0 : init.xhrs) == null ? void 0 : _a.push(xhr);
+  });
+};
+const merge = async (data) => {
+  return restFetch.request({
+    method: "POST",
+    url: "/dict/hdfs/chunk/merge",
+    data
+  }).then((res) => {
+    return res.datas;
+  });
+};
+
+export { merge, restFetch, upload, verify };

package/components/upload-plus/src/const.d.ts

@@ -0,0 +1,7 @@
+export declare enum Status {
+    wait = "wait",
+    pause = "pause",
+    uploading = "uploading",
+    error = "error",
+    done = "done"
+}

package/components/upload-plus/src/const.js

@@ -0,0 +1,10 @@
+var Status = /* @__PURE__ */ ((Status2) => {
+  Status2["wait"] = "wait";
+  Status2["pause"] = "pause";
+  Status2["uploading"] = "uploading";
+  Status2["error"] = "error";
+  Status2["done"] = "done";
+  return Status2;
+})(Status || {});
+
+export { Status };

package/components/upload-plus/src/ctx.d.ts

@@ -0,0 +1,59 @@
+export declare const props: {
+    size: {
+        type: NumberConstructor;
+        default: number;
+    };
+    /**
+     * 上传目录
+     */
+    dictId: {
+        type: StringConstructor;
+        default: string;
+    };
+    required: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, undefined, boolean>;
+    label: StringConstructor;
+    labelWidth: import("element-plus/es/utils").EpPropFinalized<readonly [StringConstructor, NumberConstructor], unknown, unknown, "", boolean>;
+    prop: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => import("element-plus").FormItemProp & {}) | (() => import("element-plus").FormItemProp) | ((new (...args: any[]) => import("element-plus").FormItemProp & {}) | (() => import("element-plus").FormItemProp))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    rules: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => import("element-plus").FormItemRule | import("element-plus").FormItemRule[]) | (() => import("element-plus/es/utils").Arrayable<import("element-plus").FormItemRule>) | ((new (...args: any[]) => import("element-plus").FormItemRule | import("element-plus").FormItemRule[]) | (() => import("element-plus/es/utils").Arrayable<import("element-plus").FormItemRule>))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    error: StringConstructor;
+    validateStatus: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "error" | "success" | "validating", unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    for: StringConstructor;
+    inlineMessage: import("element-plus/es/utils").EpPropFinalized<readonly [StringConstructor, BooleanConstructor], unknown, unknown, "", boolean>;
+    showMessage: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    formItemSize: {
+        type: import("vue").PropType<"default" | "small" | "large">;
+        default: string;
+    };
+    formItemSlots: {
+        type: import("vue").PropType<import("../../form-item/src/types").FormItemSlots>;
+        default: undefined;
+    };
+    elRef: {
+        type: import("vue").PropType<any>;
+        required: boolean;
+    };
+    inline: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    readonly: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+};
+export declare const emits: {};

package/components/upload-plus/src/ctx.js

@@ -0,0 +1,34 @@
+import { _VkfFormItemCtx } from '@vunk/form/components/form-item';
+
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+const props = __spreadProps(__spreadValues({}, _VkfFormItemCtx.props), {
+  size: {
+    type: Number,
+    default: 1024 / (16 * 16) * 1024 * 1024
+  },
+  dictId: {
+    type: String,
+    default: ""
+  }
+});
+const emits = {};
+
+export { emits, props };