@opentiny/vue-renderless 3.6.8 → 3.8.0

package/file-upload/vue.js

@@ -1,11 +1,12 @@
 import "../chunk-PKUHTIDK.js";
-import { downloadFile as ordinaryDownload } from "@opentiny/vue-renderless/upload-list";
+import { downloadFile as ordinaryDownload } from "../upload-list";
 import {
   initService,
   getNewTabPreviewUrl,
   previewFile,
   getToken,
   downloadFile,
+  downloadFileSingleInner,
   batchSegmentUpload,
   segmentUpload,
   sliceChunk,
@@ -46,9 +47,25 @@ import {
   batchSegmentDownload,
   downloadFileInner,
   setWriterFile,
-  afterDownload
+  afterDownload,
+  getFileHash,
+  modifyServiceUrlSingle,
+  getKiaScanTip,
+  downloadFileSingle,
+  downloadFileBatch,
+  downloadFileSingleHwh5,
+  validateDownloadStatus,
+  mounted,
+  handleChange,
+  previewFileSingle,
+  previewFileBatch,
+  previewImageSingle,
+  previewImageBatch,
+  abortDownload,
+  createDownloadCancelToken,
+  handleClickFileList
 } from "./index";
-import { isEmptyObject } from "@opentiny/vue-renderless/common/type";
+import { isEmptyObject } from "../common/type";
 const api = [
   "state",
   "getNewTabPreviewUrl",
@@ -67,9 +84,12 @@ const api = [
   "getFileUploadUrl",
   "updateUrl",
   "previewImage",
-  "updateFile"
+  "updateFile",
+  "handleChange",
+  "abortDownload",
+  "handleClickFileList"
 ];
-const initState = ({ api: api2, reactive, computed, inject, ref, vm, props, httpRequest }) => {
+const initState = ({ api: api2, reactive, computed, inject, ref, vm, props, httpRequest, service }) => {
   const state = reactive({
     url: "",
     tempIndex: 1,
@@ -82,7 +102,7 @@ const initState = ({ api: api2, reactive, computed, inject, ref, vm, props, http
     docSize: 0,
     // unit(B)
     chunkSize: 0,
-    chunkBatchLimit: 20,
+    chunkBatchLimit: 5,
     downloadChunkLimit: 5,
     batchQueue: {},
     batchQueueListen: {},
@@ -110,65 +130,92 @@ const initState = ({ api: api2, reactive, computed, inject, ref, vm, props, http
     isEntireCheckCode: computed(() => !("isEntireCheckCode" in props.edm && props.edm.isEntireCheckCode !== true)),
     downloadBatchQueue: {},
     downloadBatchQueueListen: {},
-    dowuloadChunkFile: /* @__PURE__ */ new Map(),
-    downloadReplayAtoms: {}
+    downloadChunkFile: {},
+    downloadReplayAtoms: {},
+    errorStatusCodes: [0, 401, 429],
+    // 0：上传异常 401：没权限（token过期）429：超限
+    hasFileInfoInterface: computed(() => service.setting.services.EDM && service.setting.services.EDM.DocumentInfoUrl),
+    currentDownloadFile: "",
+    isDragover: false,
+    downloadCancelToken: {},
+    // 取消下载token
+    downloadCancelData: {},
+    // 取消下载时需要清空的缓存数据
+    isHwh5: computed(() => !isEmptyObject(props.hwh5)),
+    selected: null
   });
   return state;
 };
-const initApi = ({ api: api2, state, props, constants, refs, $service, t, Modal }) => {
-  const { SIZE_2G, SIZE_20M, SIZE_8M } = constants.EDM;
+const initApi = ({ api: api2, state, props, constants, vm, $service, t, Modal }) => {
   Object.assign(api2, {
     state,
     sliceChunk: sliceChunk({ state, props }),
     getFormData: getFormData({ constants, props, state }),
-    abort: abort({ constants, refs }),
-    handleClick: handleClick({ constants, refs }),
+    abort: abort({ constants, vm, state }),
+    handleClick: handleClick({ constants, vm }),
     getFile: getFile(state),
     clearFiles: clearFiles(state),
-    watchFileList: watchFileList({ constants, state }),
+    watchFileList: watchFileList({ constants, state, props }),
     watchListType: watchListType({ constants, state }),
     onBeforeDestroy: onBeforeDestroy(state),
     computedUploadDisabled: computedUploadDisabled({ props, state }),
-    computedUploadingSize: computedUploadingSize(state),
+    computedUploadingSize: computedUploadingSize({ state, constants }),
     getFileUploadUrl: getFileUploadUrl($service),
     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 }),
+    computeDocChunkSize: computeDocChunkSize({ props, state, constants }),
+    updateFile: updateFile({ constants, vm }),
     getPreviewUrlSync: getPreviewUrlSync({ constants, props, state }),
     ordinaryDownload: ordinaryDownload($service),
     clearUploadingFiles: clearUploadingFiles({ constants, state }),
-    calcUploadingFilesInfo: calcUploadingFilesInfo({ state }),
-    properFileSize: properFileSize({ props, state, constants, Modal, t })
+    calcUploadingFilesInfo: calcUploadingFilesInfo({ state, constants }),
+    properFileSize: properFileSize({ props, state, constants, Modal, t }),
+    mounted: mounted({ vm, state }),
+    previewFileSingle: previewFileSingle({ api: api2, state, props, constants, service: $service }),
+    previewFileBatch: previewFileBatch({ service: $service, props, state, api: api2 }),
+    previewImageSingle: previewImageSingle({ state, props, service: $service }),
+    previewImageBatch: previewImageBatch({ service: $service, api: api2 }),
+    abortDownload: abortDownload({ state }),
+    createDownloadCancelToken: createDownloadCancelToken({ state, service: $service })
   });
 };
-const mergeApi = ({ api: api2, props, $service, state, constants, emit, mode, Modal, t, refs }) => {
+const mergeApi = ({ api: api2, props, $service, state, constants, emit, mode, Modal, t, vm, CryptoJS, Streamsaver }) => {
   Object.assign(api2, {
     segmentUploadInit: segmentUploadInit({ api: api2, props, service: $service, state, constants }),
-    segmentUpload: segmentUpload({ api: api2, props, service: $service, state, emit, constants }),
+    segmentUpload: segmentUpload({ api: api2, props, service: $service, state, emit, constants, CryptoJS }),
     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 }),
+    downloadFile: downloadFile({ api: api2, state }),
+    downloadFileSingleInner: downloadFileSingleInner({ props, state, api: api2, constants }),
+    previewImage: previewImage({ api: api2, props, service: $service }),
+    previewFile: previewFile({ api: api2, props }),
+    getNewTabPreviewUrl: getNewTabPreviewUrl({ api: api2 }),
+    submit: submit({ api: api2, constants, Modal, vm, props, state, t }),
+    handleStart: handleStart({ api: api2, constants, props, state, vm }),
+    batchSegmentUpload: batchSegmentUpload({ api: api2, constants, props, vm, 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 }),
+    handleRemove: handleRemove({ api: api2, emit, props, state, constants }),
     updateUrl: updateUrl({ api: api2, props, service: $service, state }),
-    startUpload: startUpload({ api: api2, state, constants, refs, Modal, t }),
+    startUpload: startUpload({ api: api2, state, constants, vm, 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 })
+    downloadFileInner: downloadFileInner({ api: api2, props, state }),
+    setWriterFile: setWriterFile({ state, emit, Streamsaver }),
+    afterDownload: afterDownload({ api: api2, state }),
+    getFileHash: getFileHash({ emit, Modal, constants, t, CryptoJS, state }),
+    modifyServiceUrlSingle: modifyServiceUrlSingle({ constants }),
+    getKiaScanTip: getKiaScanTip({ Modal, constants, t }),
+    downloadFileSingle: downloadFileSingle({ service: $service, constants, props, state, api: api2, emit }),
+    downloadFileBatch: downloadFileBatch({ api: api2, service: $service, props, state, emit }),
+    downloadFileSingleHwh5: downloadFileSingleHwh5({ state, props, emit, constants }),
+    validateDownloadStatus: validateDownloadStatus({ state, Modal }),
+    handleChange: handleChange({ vm, constants }),
+    handleClickFileList: handleClickFileList({ state, emit })
   });
 };
 const initWatch = ({ watch, state, api: api2, props, $service }) => {
@@ -199,19 +246,23 @@ const initWatch = ({ watch, state, api: api2, props, $service }) => {
   );
   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 }) => {
+let getApi = () => ({});
+const renderless = (props, { computed, inject, onBeforeUnmount, provide, reactive, ref, watch, onMounted }, { t, vm, parent, emit, service, mode, constants }, { Modal, CryptoJS, Streamsaver }) => {
   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 });
+  const state = initState({ reactive, computed, api: api2, inject, ref, vm, props, httpRequest, service });
+  initApi({ api: api2, state, props, constants, vm, $service, t, Modal });
+  mergeApi({ api: api2, props, $service, state, constants, emit, mode, Modal, t, vm, CryptoJS, Streamsaver });
+  getApi = () => api2;
   provide("uploader", parent);
+  onMounted(api2.mounted);
   onBeforeUnmount(api2.onBeforeDestroy);
   initWatch({ watch, state, api: api2, props, $service });
   return api2;
 };
 export {
   api,
+  getApi,
   renderless
 };

package/filter/index.js

@@ -0,0 +1,131 @@
+import "../chunk-PKUHTIDK.js";
+import { cloneDeep } from "../chart-core/deps/utils";
+const isEmpty = (value) => [void 0, null, ""].indexOf(value) !== -1;
+const resize = ({ state, vm, props }) => () => {
+  const refs = vm.$refs;
+  if (state.showPanel) {
+    const pos = refs.maskPoint.getBoundingClientRect();
+    const height = window.innerHeight - pos.top;
+    refs.panelMask.style.top = pos.top + "px";
+    refs.panelMask.style.height = height + "px";
+    if (!props.panelClass) {
+      refs.panel.style.maxHeight = (height * 0.7 || 0).toFixed() + "px";
+    }
+  }
+};
+const panelToggle = ({ state, props, api }) => (index) => {
+  const { modelValue } = props;
+  if (index === "filter") {
+    state.showPanelIndex = -1;
+    state.filterPanel.show = !state.filterPanel.show;
+    if (state.filterPanel.show) {
+      state.filterPanel.selected = props.filterValue.slice();
+      api.resize();
+    }
+    return;
+  }
+  state.filterPanel.show = false;
+  if (state.showPanelIndex === index) {
+    state.showPanelIndex = -1;
+  } else {
+    let value = modelValue[index];
+    value = isEmpty(value) ? [] : Array.isArray(value) ? value : [value];
+    state.showPanelIndex = index;
+    state.selectPanel.selected = value.slice();
+    api.resize();
+  }
+};
+const selectOption = ({ state, api }) => (value) => {
+  const {
+    selectPanel: { config }
+  } = state;
+  if (config.type === "tag" && config.multiple) {
+    state.selectPanel.selected = value;
+  } else if (!config.multiple) {
+    state.selectPanel.selected = [value];
+    api.confirm();
+  }
+};
+const filterSelectOption = ({ state, props }) => (value, index) => {
+  const { filterGroup } = props;
+  if (filterGroup[index].type === "tag" && !filterGroup[index].multiple) {
+    state.filterPanel.selected[index] = value;
+  }
+};
+const reset = ({ state, props }) => (isFilterGroup) => {
+  const { modelValue, filterValue } = props;
+  if (isFilterGroup) {
+    state.filterPanel.selected = cloneDeep(filterValue);
+  } else {
+    let value = modelValue[state.showPanelIndex];
+    value = isEmpty(value) ? [] : Array.isArray(value) ? value : [value];
+    state.selectPanel.selected = value.slice();
+  }
+};
+const filterConfirm = ({ state, emit }) => () => {
+  const filterValue = state.filterPanel.selected.slice();
+  state.filterPanel.show = false;
+  emit("update:filter-value", cloneDeep(filterValue));
+};
+const confirm = ({ state, props, emit, api }) => (isFilterGroup) => {
+  if (isFilterGroup) {
+    api.filterConfirm();
+    return;
+  }
+  const {
+    showPanelIndex,
+    selectPanel: { config }
+  } = state;
+  let modelValue = props.modelValue;
+  if (config.multiple) {
+    modelValue[showPanelIndex] = state.selectPanel.selected;
+  } else {
+    modelValue[showPanelIndex] = state.selectPanel.selected[0];
+  }
+  state.showPanelIndex = -1;
+  emit("update:modelValue", modelValue.slice());
+};
+const cancel = ({ state, emit }) => () => {
+  state.showPanelIndex = -1;
+  state.filterPanel.show = false;
+  emit("cancel", state);
+};
+const labelListComputed = ({ props }) => () => {
+  const { data, modelValue } = props;
+  return data.map((item, index) => {
+    const data2 = modelValue[index];
+    const values = item.options.map((option) => option.value);
+    if (item.type === "tag" && item.multiple) {
+      if (data2 && data2.length) {
+        return data2.map((value) => {
+          const i = values.indexOf(value);
+          return i !== -1 ? item.options[i].label : item.options[i].value;
+        }).join("; ");
+      } else {
+        return item.placeholder;
+      }
+    } else if (!item.multiple) {
+      if (isEmpty(data2)) {
+        return item.placeholder;
+      }
+      const i = values.indexOf(data2);
+      return i !== -1 ? item.options[i].label : data2;
+    }
+  });
+};
+const selectOptionAll = ({ state }) => () => {
+  state.selectPanel.selected = [];
+};
+export {
+  cancel,
+  confirm,
+  filterConfirm,
+  filterSelectOption,
+  isEmpty,
+  labelListComputed,
+  panelToggle,
+  reset,
+  resize,
+  selectOption,
+  selectOptionAll
+};

package/filter/tag-group.js

@@ -0,0 +1,43 @@
+import "../chunk-PKUHTIDK.js";
+import { isEmpty } from "./index";
+const selectOptionAll = ({ state, emit }) => () => {
+  state.selected = [];
+  emit("click", state.selected);
+  emit("update:modelValue", state.selected);
+};
+const selectOption = ({ state, props, emit }) => (value) => {
+  if (props.type === "tag" && props.multiple) {
+    const index = state.selected.indexOf(value);
+    index === -1 ? state.selected.push(value) : state.selected.splice(index, 1);
+    const values = state.selected;
+    emit("click", values);
+    emit("update:modelValue", values.slice());
+  } else if (props.type === "tag" && !props.multiple) {
+    state.selected = [value];
+    emit("click", value);
+    emit("update:modelValue", value);
+  }
+};
+const setSelectedOption = ({ state }) => (value) => {
+  state.selected = isEmpty(value) ? [] : Array.isArray(value) ? value.slice() : [value];
+};
+const api = ["state", "selectOptionAll", "selectOption"];
+const renderless = (props, { reactive, watch, computed }, { emit }) => {
+  const api2 = {};
+  const state = reactive({
+    tagWidth: computed(() => (100 / props.columnNum).toFixed(1) + "%"),
+    selected: []
+  });
+  Object.assign(api2, {
+    state,
+    selectOptionAll: selectOptionAll({ state, emit }),
+    selectOption: selectOption({ state, props, emit }),
+    setSelectedOption: setSelectedOption({ state, props })
+  });
+  watch(() => props.modelValue, api2.setSelectedOption);
+  return api2;
+};
+export {
+  api,
+  renderless
+};

package/filter/vue.js

@@ -0,0 +1,73 @@
+import "../chunk-PKUHTIDK.js";
+import { on, off } from "../common/deps/dom";
+import {
+  panelToggle,
+  filterSelectOption,
+  filterConfirm,
+  labelListComputed,
+  selectOption,
+  confirm,
+  cancel,
+  resize,
+  reset,
+  selectOptionAll
+} from "./index";
+const api = [
+  "state",
+  "panelToggle",
+  "filterSelectOption",
+  "filterConfirm",
+  "selectOption",
+  "confirm",
+  "cancel",
+  "reset",
+  "selectOptionAll"
+];
+const renderless = (props, { reactive, computed, onMounted, onBeforeUnmount }, { emit, vm }) => {
+  const api2 = {};
+  const state = reactive({
+    showPanelIndex: -1,
+    filterPanel: {
+      show: false,
+      selected: []
+    },
+    selectPanel: {
+      selected: [],
+      config: computed(() => state.showPanelIndex !== -1 ? props.data[state.showPanelIndex] : { options: [] })
+    },
+    tagWidth: computed(() => (100 / props.columnNum).toFixed(1) + "%"),
+    labelList: computed(() => api2.labelListComputed()),
+    showPanel: computed(() => state.showPanelIndex !== -1 || state.filterPanel.show),
+    hasFilterValue: computed(
+      () => props.filterValue.find(
+        (item) => Array.isArray(item) ? item.length > 0 : [void 0, null, ""].indexOf(item) === -1
+      )
+    )
+  });
+  Object.assign(api2, {
+    state,
+    panelToggle: panelToggle({ state, props, api: api2 }),
+    filterSelectOption: filterSelectOption({ state, props, emit, api: api2 }),
+    filterConfirm: filterConfirm({ state, props, emit }),
+    selectOption: selectOption({ state, props, emit, api: api2 }),
+    confirm: confirm({ state, props, emit, api: api2 }),
+    cancel: cancel({ state, emit }),
+    resize: resize({ state, vm, props }),
+    reset: reset({ state, props }),
+    selectOptionAll: selectOptionAll({ state }),
+    labelListComputed: labelListComputed({ state, props })
+  });
+  onMounted(() => {
+    on(window, "scroll", api2.resize);
+    on(window, "resize", api2.resize);
+  });
+  onBeforeUnmount(() => {
+    off(window, "scroll", api2.resize);
+    off(window, "resize", api2.resize);
+  });
+  return api2;
+};
+export {
+  api,
+  renderless
+};

package/filter-bar/index.js

@@ -0,0 +1,9 @@
+import "../chunk-PKUHTIDK.js";
+const click = ({ props, emit }) => (index) => {
+  const i = props.modelValue === index ? void 0 : index;
+  emit("update:modelValue", i);
+  emit("click", index);
+};
+export {
+  click
+};

package/filter-bar/vue.js

@@ -0,0 +1,16 @@
+import "../chunk-PKUHTIDK.js";
+import { click } from "./index";
+const api = ["state", "click"];
+const renderless = (props, { reactive }, { emit }) => {
+  const api2 = {};
+  const state = reactive({});
+  Object.assign(api2, {
+    state,
+    click: click({ props, emit })
+  });
+  return api2;
+};
+export {
+  api,
+  renderless
+};

package/filter-box/index.js

@@ -0,0 +1,17 @@
+import "../chunk-PKUHTIDK.js";
+const handleClear = ({ dispatch, emit }) => ($event) => {
+  dispatch("Picker", "handle-clear", $event);
+  dispatch("Select", "handle-clear", $event);
+  dispatch("Cascader", "handle-clear", $event);
+  emit("handle-clear");
+};
+const handeClick = ({ props, emit }) => ($event) => {
+  if (props.disabled)
+    return;
+  $event.stopPropagation();
+  emit("click", $event);
+};
+export {
+  handeClick,
+  handleClear
+};

package/filter-box/vue.js

@@ -0,0 +1,19 @@
+import "../chunk-PKUHTIDK.js";
+import { handleClear, handeClick } from "./index";
+const api = ["state", "handleClear", "focus", "blur", "handeClick"];
+const renderless = (props, { reactive }, { dispatch, emit }) => {
+  const state = reactive({});
+  const api2 = {};
+  Object.assign(api2, {
+    state,
+    focus: () => state,
+    blur: () => state,
+    handleClear: handleClear({ dispatch, emit }),
+    handeClick: handeClick({ props, emit })
+  });
+  return api2;
+};
+export {
+  api,
+  renderless
+};

package/filter-panel/index.js

@@ -0,0 +1,42 @@
+import "../chunk-PKUHTIDK.js";
+const doDestroy = ({ vm }) => () => {
+  vm.$refs.popper && vm.$refs.popper.doDestroy();
+};
+const show = ({ state }) => () => {
+  state.visible = true;
+};
+const hide = ({ state }) => () => {
+  state.visible = false;
+};
+const togglePanel = ({ props, state }) => () => {
+  if (props.disabled)
+    return;
+  state.visible = !state.visible;
+};
+const popoverShow = ({ state, emit }) => () => {
+  emit("visible-change", state.visible);
+};
+const popoverHide = ({ state, emit }) => () => {
+  emit("visible-change", state.visible);
+};
+const handleClear = ({ emit }) => () => {
+  emit("handle-clear");
+};
+const handleDocumentClick = ({ state, vm }) => (event) => {
+  const filterBox = vm.$refs.filterBox.$el;
+  const popper = document.querySelector(".tiny-filter-panel__popover");
+  if (!filterBox || !popper || filterBox.contains(event.target) || popper.contains(event.target)) {
+    return;
+  }
+  state.visible = false;
+};
+export {
+  doDestroy,
+  handleClear,
+  handleDocumentClick,
+  hide,
+  popoverHide,
+  popoverShow,
+  show,
+  togglePanel
+};

package/filter-panel/vue.js

@@ -0,0 +1,33 @@
+import "../chunk-PKUHTIDK.js";
+import { doDestroy, show, hide, popoverShow, popoverHide, handleClear, handleDocumentClick, togglePanel } from "./index";
+import { on, off } from "../common/deps/dom";
+const api = ["state", "doDestroy", "show", "hide", "popoverShow", "popoverHide", "handleClear", "togglePanel"];
+const renderless = (props, { reactive, onMounted, onBeforeUnmount }, { vm, emit }) => {
+  const state = reactive({
+    visible: false
+  });
+  const api2 = {};
+  Object.assign(api2, {
+    state,
+    show: show({ state }),
+    hide: hide({ state }),
+    togglePanel: togglePanel({ props, state }),
+    popoverShow: popoverShow({ state, emit }),
+    popoverHide: popoverHide({ state, emit }),
+    handleClear: handleClear({ emit }),
+    doDestroy: doDestroy({ vm }),
+    handleDocumentClick: handleDocumentClick({ vm, state })
+  });
+  handleDocumentClick;
+  onMounted(() => {
+    on(document, "click", api2.handleDocumentClick);
+  });
+  onBeforeUnmount(() => {
+    off(document, "click", api2.handleDocumentClick);
+  });
+  return api2;
+};
+export {
+  api,
+  renderless
+};

package/floatbar/index.js

@@ -1,5 +1,5 @@
 import "../chunk-PKUHTIDK.js";
-import { xss } from "@opentiny/vue-renderless/common/xss.js";
+import { xss } from "../common/xss.js";
 const computeData = ({ props }) => {
   if (Array.isArray(props.data) && props.data.length) {
     props.data.forEach((item) => {