@opentiny/vue-renderless 3.6.0 → 3.6.1-alpha.2

package/file-upload/vue.js

@@ -1,26 +1,83 @@
-import { downloadFile as ordinaryDownload } from '@opentiny/vue-renderless/upload-list';
-import { initService, getNewTabPreviewUrl, previewFile, getToken, downloadFile, batchSegmentUpload, segmentUpload, sliceChunk, segmentUploadInit, largeDocumentUpload, getFormData, abort, clearFiles, computedUploadDisabled, getFile, handleStart, handleProgress, handleSuccess, handleError, handleRemove, onBeforeDestroy, submit, watchListType, watchFileList, handleClick, getFileUploadUrl, updateUrl, previewImage, startUpload, getDialogConfigObj, computeDocChunkSize, updateFile, getPreviewUrlSync, beforeUpload, computedUploadingSize, clearUploadingFiles, calcUploadingFilesInfo, properFileSize, addFileToList, getDownloadFileInfo, largeDocumentDownload, sliceDownloadChunk, batchSegmentDownload, downloadFileInner, setWriterFile, afterDownload } from './index';
-import { isEmptyObject } from '@opentiny/vue-renderless/common/type';
-export var api = ['state', 'getNewTabPreviewUrl', 'previewFile', 'downloadFile', 'abort', 'clearFiles', 'getFile', 'handleStart', 'handleProgress', 'handleSuccess', 'handleError', 'handleRemove', 'submit', 'handleClick', 'getFileUploadUrl', 'updateUrl', 'previewImage', 'updateFile'];
-var initState = function initState(_ref) {
-  var api = _ref.api,
-    reactive = _ref.reactive,
-    computed = _ref.computed,
-    inject = _ref.inject,
-    ref = _ref.ref,
-    vm = _ref.vm,
-    props = _ref.props,
-    httpRequest = _ref.httpRequest;
-  var state = reactive({
-    url: '',
+import "../chunk-PKUHTIDK.js";
+import { downloadFile as ordinaryDownload } from "@opentiny/vue-renderless/upload-list";
+import {
+  initService,
+  getNewTabPreviewUrl,
+  previewFile,
+  getToken,
+  downloadFile,
+  batchSegmentUpload,
+  segmentUpload,
+  sliceChunk,
+  segmentUploadInit,
+  largeDocumentUpload,
+  getFormData,
+  abort,
+  clearFiles,
+  computedUploadDisabled,
+  getFile,
+  handleStart,
+  handleProgress,
+  handleSuccess,
+  handleError,
+  handleRemove,
+  onBeforeDestroy,
+  submit,
+  watchListType,
+  watchFileList,
+  handleClick,
+  getFileUploadUrl,
+  updateUrl,
+  previewImage,
+  startUpload,
+  getDialogConfigObj,
+  computeDocChunkSize,
+  updateFile,
+  getPreviewUrlSync,
+  beforeUpload,
+  computedUploadingSize,
+  clearUploadingFiles,
+  calcUploadingFilesInfo,
+  properFileSize,
+  addFileToList,
+  getDownloadFileInfo,
+  largeDocumentDownload,
+  sliceDownloadChunk,
+  batchSegmentDownload,
+  downloadFileInner,
+  setWriterFile,
+  afterDownload
+} from "./index";
+import { isEmptyObject } from "@opentiny/vue-renderless/common/type";
+const api = [
+  "state",
+  "getNewTabPreviewUrl",
+  "previewFile",
+  "downloadFile",
+  "abort",
+  "clearFiles",
+  "getFile",
+  "handleStart",
+  "handleProgress",
+  "handleSuccess",
+  "handleError",
+  "handleRemove",
+  "submit",
+  "handleClick",
+  "getFileUploadUrl",
+  "updateUrl",
+  "previewImage",
+  "updateFile"
+];
+const initState = ({ api: api2, reactive, computed, inject, ref, vm, props, httpRequest }) => {
+  const state = reactive({
+    url: "",
     tempIndex: 1,
     draging: false,
     uploadFiles: [],
     dragOver: false,
-    httpRequest: httpRequest,
-    form: inject('form', ref({
-      "default": ''
-    })),
+    httpRequest,
+    form: inject("form", ref({ default: "" })),
     listeners: vm.$listeners,
     docSize: 0,
     chunkSize: 0,
@@ -30,429 +87,130 @@ var initState = function initState(_ref) {
     batchQueueListen: {},
     batchCancelToken: {},
     replayAtoms: {},
-    chunkUploadUrl: '',
+    chunkUploadUrl: "",
     largeFileInfo: {},
     headers: {},
-    accept: '',
+    accept: "",
     edmToken: {},
     isSuccess: false,
     singleMaxSize: 200,
     formData: {},
     showPreview: false,
-    iframeUrl: '',
+    iframeUrl: "",
     fileWater: false,
-    tabUrl: '',
+    tabUrl: "",
     cacheDocuments: {},
-    isEdm: computed(function () {
-      return !isEmptyObject(props.edm);
-    }),
-    uploadDisabled: computed(function () {
-      return api.computedUploadDisabled();
-    }),
-    dialogConfigObj: computed(function () {
-      return api.getDialogConfigObj();
-    }),
+    isEdm: computed(() => !isEmptyObject(props.edm)),
+    uploadDisabled: computed(() => api2.computedUploadDisabled()),
+    dialogConfigObj: computed(() => api2.getDialogConfigObj()),
     uploadingFiles: [],
     currentUploadingFileUids: [],
-    uploadingSize: computed(function () {
-      return api.computedUploadingSize();
-    }),
-    isEntireCheckCode: computed(function () {
-      return !('isEntireCheckCode' in props.edm && props.edm.isEntireCheckCode !== true);
-    }),
+    uploadingSize: computed(() => api2.computedUploadingSize()),
+    isEntireCheckCode: computed(() => !("isEntireCheckCode" in props.edm && props.edm.isEntireCheckCode !== true)),
     downloadBatchQueue: {},
     downloadBatchQueueListen: {},
-    dowuloadChunkFile: new Map(),
+    dowuloadChunkFile: /* @__PURE__ */ new Map(),
     downloadReplayAtoms: {}
   });
   return state;
 };
-var initApi = function initApi(_ref2) {
-  var api = _ref2.api,
-    state = _ref2.state,
-    props = _ref2.props,
-    constants = _ref2.constants,
-    refs = _ref2.refs,
-    $service = _ref2.$service,
-    t = _ref2.t,
-    Modal = _ref2.Modal;
-  var _constants$EDM = constants.EDM,
-    SIZE_2G = _constants$EDM.SIZE_2G,
-    SIZE_20M = _constants$EDM.SIZE_20M,
-    SIZE_8M = _constants$EDM.SIZE_8M;
-  Object.assign(api, {
-    state: state,
-    sliceChunk: sliceChunk({
-      state: state,
-      props: props
-    }),
-    getFormData: getFormData({
-      constants: constants,
-      props: props,
-      state: state
-    }),
-    abort: abort({
-      constants: constants,
-      refs: refs
-    }),
-    handleClick: handleClick({
-      constants: constants,
-      refs: refs
-    }),
+const initApi = ({ api: api2, state, props, constants, refs, $service, t, Modal }) => {
+  const { SIZE_2G, SIZE_20M, SIZE_8M } = constants.EDM;
+  Object.assign(api2, {
+    state,
+    sliceChunk: sliceChunk({ state, props }),
+    getFormData: getFormData({ constants, props, state }),
+    abort: abort({ constants, refs }),
+    handleClick: handleClick({ constants, refs }),
     getFile: getFile(state),
     clearFiles: clearFiles(state),
-    watchFileList: watchFileList({
-      constants: constants,
-      state: state
-    }),
-    watchListType: watchListType({
-      constants: constants,
-      state: state
-    }),
+    watchFileList: watchFileList({ constants, state }),
+    watchListType: watchListType({ constants, state }),
     onBeforeDestroy: onBeforeDestroy(state),
-    computedUploadDisabled: computedUploadDisabled({
-      props: props,
-      state: state
-    }),
+    computedUploadDisabled: computedUploadDisabled({ props, state }),
     computedUploadingSize: computedUploadingSize(state),
     getFileUploadUrl: getFileUploadUrl($service),
-    getToken: getToken({
-      constants: constants,
-      props: props,
-      state: state,
-      t: t,
-      Modal: Modal
-    }),
-    getDialogConfigObj: getDialogConfigObj({
-      props: props,
-      state: state
-    }),
-    computeDocChunkSize: computeDocChunkSize({
-      props: props,
-      state: state,
-      SIZE_2G: SIZE_2G,
-      SIZE_20M: SIZE_20M,
-      SIZE_8M: SIZE_8M
-    }),
-    updateFile: updateFile({
-      constants: constants,
-      refs: refs
-    }),
-    getPreviewUrlSync: getPreviewUrlSync({
-      constants: constants,
-      props: props,
-      state: state
-    }),
+    getToken: getToken({ constants, props, state, t, Modal }),
+    getDialogConfigObj: getDialogConfigObj({ props, state }),
+    computeDocChunkSize: computeDocChunkSize({ props, state, SIZE_2G, SIZE_20M, SIZE_8M }),
+    updateFile: updateFile({ constants, refs }),
+    getPreviewUrlSync: getPreviewUrlSync({ constants, props, state }),
     ordinaryDownload: ordinaryDownload($service),
-    clearUploadingFiles: clearUploadingFiles({
-      constants: constants,
-      state: state
-    }),
-    calcUploadingFilesInfo: calcUploadingFilesInfo({
-      state: state
-    }),
-    properFileSize: properFileSize({
-      props: props,
-      state: state,
-      constants: constants,
-      Modal: Modal,
-      t: t
-    })
+    clearUploadingFiles: clearUploadingFiles({ constants, state }),
+    calcUploadingFilesInfo: calcUploadingFilesInfo({ state }),
+    properFileSize: properFileSize({ props, state, constants, Modal, t })
   });
 };
-var mergeApi = function mergeApi(_ref3) {
-  var api = _ref3.api,
-    props = _ref3.props,
-    $service = _ref3.$service,
-    state = _ref3.state,
-    constants = _ref3.constants,
-    emit = _ref3.emit,
-    mode = _ref3.mode,
-    Modal = _ref3.Modal,
-    t = _ref3.t,
-    refs = _ref3.refs;
-  Object.assign(api, {
-    segmentUploadInit: segmentUploadInit({
-      api: api,
-      props: props,
-      service: $service,
-      state: state,
-      constants: constants
-    }),
-    segmentUpload: segmentUpload({
-      api: api,
-      props: props,
-      service: $service,
-      state: state,
-      emit: emit,
-      constants: constants
-    }),
-    addFileToList: addFileToList({
-      api: api,
-      constants: constants,
-      emit: emit,
-      props: props,
-      state: state,
-      mode: mode
-    }),
-    downloadFile: downloadFile({
-      api: api,
-      state: state,
-      props: props
-    }),
-    previewImage: previewImage({
-      api: api,
-      props: props,
-      service: $service,
-      state: state
-    }),
-    previewFile: previewFile({
-      api: api,
-      constants: constants,
-      Modal: Modal,
-      props: props,
-      service: $service,
-      state: state,
-      t: t
-    }),
-    getNewTabPreviewUrl: getNewTabPreviewUrl({
-      api: api,
-      props: props
-    }),
-    submit: submit({
-      api: api,
-      constants: constants,
-      Modal: Modal,
-      refs: refs,
-      props: props,
-      state: state,
-      t: t
-    }),
-    handleStart: handleStart({
-      api: api,
-      constants: constants,
-      props: props,
-      state: state,
-      refs: refs
-    }),
-    batchSegmentUpload: batchSegmentUpload({
-      api: api,
-      constants: constants,
-      props: props,
-      refs: refs,
-      state: state
-    }),
-    largeDocumentUpload: largeDocumentUpload({
-      api: api,
-      Modal: Modal,
-      state: state,
-      emit: emit,
-      constants: constants,
-      t: t
-    }),
-    handleProgress: handleProgress({
-      api: api,
-      constants: constants,
-      emit: emit,
-      state: state
-    }),
-    handleSuccess: handleSuccess({
-      api: api,
-      constants: constants,
-      emit: emit,
-      Modal: Modal,
-      props: props,
-      state: state
-    }),
-    handleError: handleError({
-      api: api,
-      constants: constants,
-      emit: emit,
-      state: state
-    }),
-    handleRemove: handleRemove({
-      api: api,
-      emit: emit,
-      props: props,
-      state: state
-    }),
-    updateUrl: updateUrl({
-      api: api,
-      props: props,
-      service: $service,
-      state: state
-    }),
-    startUpload: startUpload({
-      api: api,
-      state: state,
-      constants: constants,
-      refs: refs,
-      Modal: Modal,
-      t: t
-    }),
-    beforeUpload: beforeUpload({
-      api: api,
-      props: props,
-      Modal: Modal,
-      constants: constants,
-      t: t,
-      state: state
-    }),
-    getDownloadFileInfo: getDownloadFileInfo({
-      api: api,
-      props: props,
-      state: state,
-      service: $service
-    }),
-    largeDocumentDownload: largeDocumentDownload({
-      api: api,
-      state: state
-    }),
-    sliceDownloadChunk: sliceDownloadChunk({
-      api: api,
-      state: state
-    }),
-    batchSegmentDownload: batchSegmentDownload({
-      state: state,
-      api: api
-    }),
-    downloadFileInner: downloadFileInner({
-      api: api,
-      props: props,
-      service: $service,
-      state: state,
-      emit: emit,
-      constants: constants,
-      t: t,
-      Modal: Modal
-    }),
-    setWriterFile: setWriterFile({
-      state: state,
-      emit: emit,
-      props: props
-    }),
-    afterDownload: afterDownload({
-      api: api,
-      state: state
-    })
+const mergeApi = ({ api: api2, props, $service, state, constants, emit, mode, Modal, t, refs }) => {
+  Object.assign(api2, {
+    segmentUploadInit: segmentUploadInit({ api: api2, props, service: $service, state, constants }),
+    segmentUpload: segmentUpload({ api: api2, props, service: $service, state, emit, constants }),
+    addFileToList: addFileToList({ api: api2, constants, emit, props, state, mode }),
+    downloadFile: downloadFile({ api: api2, state, props }),
+    previewImage: previewImage({ api: api2, props, service: $service, state }),
+    previewFile: previewFile({ api: api2, constants, Modal, props, service: $service, state, t }),
+    getNewTabPreviewUrl: getNewTabPreviewUrl({ api: api2, props }),
+    submit: submit({ api: api2, constants, Modal, refs, props, state, t }),
+    handleStart: handleStart({ api: api2, constants, props, state, refs }),
+    batchSegmentUpload: batchSegmentUpload({ api: api2, constants, props, refs, state }),
+    largeDocumentUpload: largeDocumentUpload({ api: api2, Modal, state, emit, constants, t }),
+    handleProgress: handleProgress({ api: api2, constants, emit, state }),
+    handleSuccess: handleSuccess({ api: api2, constants, emit, Modal, props, state }),
+    handleError: handleError({ api: api2, constants, emit, state }),
+    handleRemove: handleRemove({ api: api2, emit, props, state }),
+    updateUrl: updateUrl({ api: api2, props, service: $service, state }),
+    startUpload: startUpload({ api: api2, state, constants, refs, Modal, t }),
+    beforeUpload: beforeUpload({ api: api2, props, Modal, constants, t, state }),
+    getDownloadFileInfo: getDownloadFileInfo({ api: api2, props, state, service: $service }),
+    largeDocumentDownload: largeDocumentDownload({ api: api2, state }),
+    sliceDownloadChunk: sliceDownloadChunk({ api: api2, state }),
+    batchSegmentDownload: batchSegmentDownload({ state, api: api2 }),
+    downloadFileInner: downloadFileInner({ api: api2, props, service: $service, state, emit, constants, t, Modal }),
+    setWriterFile: setWriterFile({ state, emit, props }),
+    afterDownload: afterDownload({ api: api2, state })
   });
 };
-var initWatch = function initWatch(_ref4) {
-  var watch = _ref4.watch,
-    state = _ref4.state,
-    api = _ref4.api,
-    props = _ref4.props,
-    $service = _ref4.$service;
-  watch(function () {
-    return props.edm.upload;
-  }, function (value) {
-    return value && api.getToken({
-      token: value.token,
-      isinit: true
-    });
-  }, {
-    immediate: true,
-    deep: true
-  });
-  watch(function () {
-    return props.listType;
-  }, api.watchListType);
-  watch(function () {
-    return props.fileList;
-  }, function (value) {
-    return api.watchFileList(value);
-  }, {
-    immediate: true,
-    deep: true
-  });
-  watch(function () {
-    return props.action;
-  }, function () {
-    if (!props.httpRequest && !state.isEdm) {
-      api.updateUrl();
-    }
-  }, {
-    immediate: true
-  });
-  watch(function () {
-    return state.isSuccess;
-  }, function (value) {
-    return value && $service.getSingleUploadUrl().then(function (url) {
-      return state.url = url;
-    });
-  }, {
-    immediate: true
-  });
-  watch(function () {
-    return props.edm;
-  }, api.computeDocChunkSize, {
-    deep: true,
-    immediate: true
-  });
+const initWatch = ({ watch, state, api: api2, props, $service }) => {
+  watch(
+    () => props.edm.upload,
+    (value) => value && api2.getToken({ token: value.token, isinit: true }),
+    { immediate: true, deep: true }
+  );
+  watch(() => props.listType, api2.watchListType);
+  watch(
+    () => props.fileList,
+    (value) => api2.watchFileList(value),
+    { immediate: true, deep: true }
+  );
+  watch(
+    () => props.action,
+    () => {
+      if (!props.httpRequest && !state.isEdm) {
+        api2.updateUrl();
+      }
+    },
+    { immediate: true }
+  );
+  watch(
+    () => state.isSuccess,
+    (value) => value && $service.getSingleUploadUrl().then((url) => state.url = url),
+    { immediate: true }
+  );
+  watch(() => props.edm, api2.computeDocChunkSize, { deep: true, immediate: true });
+};
+const renderless = (props, { computed, inject, onBeforeUnmount, provide, reactive, ref, watch }, { t, vm, refs, parent, emit, service, mode, constants }, { Modal }) => {
+  const api2 = {};
+  const $service = initService({ props, service });
+  const httpRequest = $service.httpRequest;
+  const state = initState({ reactive, computed, api: api2, inject, ref, vm, props, httpRequest });
+  initApi({ api: api2, state, props, constants, refs, $service, t, Modal });
+  mergeApi({ api: api2, props, $service, state, constants, emit, mode, Modal, t, refs });
+  provide("uploader", parent);
+  onBeforeUnmount(api2.onBeforeDestroy);
+  initWatch({ watch, state, api: api2, props, $service });
+  return api2;
+};
+export {
+  api,
+  renderless
 };
-export var renderless = function renderless(props, _ref5, _ref6, _ref7) {
-  var computed = _ref5.computed,
-    inject = _ref5.inject,
-    onBeforeUnmount = _ref5.onBeforeUnmount,
-    provide = _ref5.provide,
-    reactive = _ref5.reactive,
-    ref = _ref5.ref,
-    watch = _ref5.watch;
-  var t = _ref6.t,
-    vm = _ref6.vm,
-    refs = _ref6.refs,
-    parent = _ref6.parent,
-    emit = _ref6.emit,
-    service = _ref6.service,
-    mode = _ref6.mode,
-    constants = _ref6.constants;
-  var Modal = _ref7.Modal;
-  var api = {};
-  var $service = initService({
-    props: props,
-    service: service
-  });
-  var httpRequest = $service.httpRequest;
-  var state = initState({
-    reactive: reactive,
-    computed: computed,
-    api: api,
-    inject: inject,
-    ref: ref,
-    vm: vm,
-    props: props,
-    httpRequest: httpRequest
-  });
-  initApi({
-    api: api,
-    state: state,
-    props: props,
-    constants: constants,
-    refs: refs,
-    $service: $service,
-    t: t,
-    Modal: Modal
-  });
-  mergeApi({
-    api: api,
-    props: props,
-    $service: $service,
-    state: state,
-    constants: constants,
-    emit: emit,
-    mode: mode,
-    Modal: Modal,
-    t: t,
-    refs: refs
-  });
-  provide('uploader', parent);
-  onBeforeUnmount(api.onBeforeDestroy);
-  initWatch({
-    watch: watch,
-    state: state,
-    api: api,
-    props: props,
-    $service: $service
-  });
-  return api;
-};

package/floatbar/index.js

@@ -1,10 +1,13 @@
-import { xss } from '@opentiny/vue-renderless/common/xss.js';
-export var computeData = function computeData(_ref) {
-  var props = _ref.props;
+import "../chunk-PKUHTIDK.js";
+import { xss } from "@opentiny/vue-renderless/common/xss.js";
+const computeData = ({ props }) => {
   if (Array.isArray(props.data) && props.data.length) {
-    props.data.forEach(function (item) {
+    props.data.forEach((item) => {
       item.url = xss.filterUrl(item.url);
     });
   }
   return props.data;
-};
+};
+export {
+  computeData
+};

package/floatbar/vue.js

@@ -1,17 +1,14 @@
-import { computeData } from './index';
-export var api = ['state'];
-export var renderless = function renderless(props, _ref) {
-  var computed = _ref.computed,
-    reactive = _ref.reactive;
-  var state = reactive({
-    data: computed(function () {
-      return computeData({
-        props: props
-      });
-    })
+import "../chunk-PKUHTIDK.js";
+import { computeData } from "./index";
+const api = ["state"];
+const renderless = (props, { computed, reactive }) => {
+  const state = reactive({
+    data: computed(() => computeData({ props }))
   });
-  var api = {
-    state: state
-  };
-  return api;
-};
+  const api2 = { state };
+  return api2;
+};
+export {
+  api,
+  renderless
+};