@opentiny/vue-renderless 3.11.8 → 3.12.0

package/types/{upload-dragger.type.d.mts → upload-dragger.type.d.ts}

@@ -1,6 +1,6 @@
 import { ExtractPropTypes } from 'vue';
-import { ISharedRenderlessParamUtils, ISharedRenderlessFunctionParams } from './shared.type.mjs';
-import { I as IFileUploadVm, a as IFileUploadConstants } from './upload-list.type-b934f279.js';
+import { ISharedRenderlessParamUtils, ISharedRenderlessFunctionParams } from './shared.type.js';
+import { I as IFileUploadVm, a as IFileUploadConstants } from './upload-list.type-343e8c11.js';
 
 declare const UploadDraggerProps: {
     disabled: BooleanConstructor;

package/types/{upload-list.type-b934f279.d.ts → upload-list.type-343e8c11.d.ts}

@@ -1,5 +1,5 @@
 import { ExtractPropTypes } from 'vue';
-import { ISharedRenderlessParamUtils, ISharedRenderlessFunctionParams, ITinyVm } from './shared.type.mjs';
+import { ISharedRenderlessParamUtils, ISharedRenderlessFunctionParams, ITinyVm } from './shared.type.js';
 
 declare const $constants: {
     FILE_UPLOAD_INNER_TEMPLATE: string;
@@ -65,6 +65,9 @@ declare const $constants: {
         KIASTATUS: number;
         NumberExceed: string;
         notSupport: string;
+        NOT_SUPPORT_NO_SUFFIX: string;
+        STATUS_SPECIAL_CHARACTERS: number;
+        NOT_SUPPORT_SPECIAL_CHARACTERS: string;
     };
     IMAGE_TYPE: string;
     FILE_TYPE: {
@@ -155,6 +158,9 @@ declare const fileUploadProps: {
                 KIASTATUS: number;
                 NumberExceed: string;
                 notSupport: string;
+                NOT_SUPPORT_NO_SUFFIX: string;
+                STATUS_SPECIAL_CHARACTERS: number;
+                NOT_SUPPORT_SPECIAL_CHARACTERS: string;
             };
             IMAGE_TYPE: string;
             FILE_TYPE: {
@@ -331,6 +337,15 @@ declare const fileUploadProps: {
         type: BooleanConstructor;
         default: boolean;
     };
+    beforeAddFile: FunctionConstructor;
+    encryptConfig: {
+        type: ObjectConstructor;
+        default: () => {
+            enabled: boolean;
+            encrypt: boolean;
+            watermark: string;
+        };
+    };
     isHidden: {
         type: BooleanConstructor;
         default: boolean;
@@ -339,6 +354,8 @@ declare const fileUploadProps: {
         type: BooleanConstructor;
         default: boolean;
     };
+    reUploadable: BooleanConstructor;
+    reUploadTip: FunctionConstructor;
     tiny_mode: StringConstructor;
     tiny_mode_root: BooleanConstructor;
     tiny_template: (FunctionConstructor | ObjectConstructor)[];
@@ -366,7 +383,7 @@ declare const watchListType: ({ constants, state, api }: Pick<IFileUploadRenderl
 declare const watchFileList: ({ constants, state, props, api }: Pick<IFileUploadRenderlessParams, 'constants' | 'state' | 'props' | 'api'>) => (fileList: IFileUploadFile[]) => void;
 declare const beforeUpload: ({ props, api, Modal, constants, t, state }: Pick<IFileUploadRenderlessParams, 'props' | 'api' | 'constants' | 't' | 'state'> & IFileUploadModalVm) => (file: IFileUploadFile, autoRemove: boolean, doUpload: Function) => any;
 declare const startUpload: ({ state, constants, vm, Modal, api, t }: Pick<IFileUploadRenderlessParams, 'state' | 'constants' | 'vm' | 'api' | 't'> & IFileUploadModalVm) => (file: IFileUploadFile, isList: boolean) => void;
-declare const properFileSize: ({ props, state, constants, Modal, t }: Pick<IFileUploadRenderlessParams, 'props' | 'state' | 'constants' | 't'> & IFileUploadModalVm) => (file: IFileUploadFile) => boolean;
+declare const properFileSize: ({ props, state, api, constants, Modal, t }: Pick<IFileUploadRenderlessParams, 'props' | 'state' | 'constants' | 'api' | 't'> & IFileUploadModalVm) => (file: IFileUploadFile) => boolean;
 declare const addFileToList: ({ api, constants, emit, props, state, mode }: Pick<IFileUploadRenderlessParams, 'api' | 'constants' | 'emit' | 'props' | 'state' | 'mode'>) => (rawFile: IFileUploadFile, updateId: string, reUpload: boolean) => void;
 declare const getFileHash: ({ emit, Modal, constants, t, CryptoJS, state }: Pick<IFileUploadRenderlessParams, "state" | "t" | "constants" | "emit"> & IFileUploadModalVm & {
     CryptoJS: object;
@@ -382,9 +399,11 @@ declare const calcUploadingFilesInfo: ({ state, constants }: Pick<IFileUploadRen
     uploadedCount: number;
 };
 declare const handleProgress: ({ api, constants, emit, state }: Pick<IFileUploadRenderlessParams, 'api' | 'constants' | 'emit' | 'state'>) => (event: any, rawFile: File) => void;
-declare const handleSuccess: ({ api, constants, emit, state, props }: Pick<IFileUploadRenderlessParams, 'api' | 'constants' | 'emit' | 'state' | 'props'>) => (res: any, rawFile: IFileUploadFile) => void;
-declare const handleError: ({ api, constants, emit, state }: Pick<IFileUploadRenderlessParams, 'api' | 'constants' | 'emit' | 'state'>) => (err: any, rawFile: IFileUploadFile) => void;
+declare const handleSuccess: ({ api, constants, emit, state, props, Modal, t }: Pick<IFileUploadRenderlessParams, 'api' | 'constants' | 'emit' | 'state' | 't' | 'props'>) => (res: any, rawFile: IFileUploadFile) => void;
+declare const handleError: ({ api, constants, emit, state, props }: Pick<IFileUploadRenderlessParams, 'api' | 'constants' | 'emit' | 'state' | 'props'>) => (err: any, rawFile: IFileUploadFile) => void;
 declare const handleRemove: ({ api, emit, props, state, constants }: Pick<IFileUploadRenderlessParams, 'api' | 'emit' | 'props' | 'state' | 'constants'>) => (file: IFileUploadFile, raw: File) => void;
+declare const handleReUpload: ({ vm, constants }: Pick<IFileUploadRenderlessParams, 'vm' | 'constants'>) => (file: IFileUploadFile) => void;
+declare const handleReUploadTotal: (api: IFileUploadRenderlessParams['api']) => (files: IFileUploadFile[]) => void;
 declare const clearUploadingFiles: ({ constants, state }: Pick<IFileUploadRenderlessParams, 'constants' | 'state'>) => () => void;
 declare const getFile: (state: IFileUploadRenderlessParams['state']) => (rawFile: IFileUploadFile) => IFileUploadFile;
 declare const abort$1: ({ constants, vm, state }: Pick<IFileUploadRenderlessParams, 'constants' | 'vm' | 'state'>) => (file: IFileUploadFile) => void;
@@ -428,7 +447,15 @@ declare const downloadFileSingleHwh5: ({ state, props, emit, constants }: Pick<I
     file: IFileUploadFile;
 }) => void;
 declare const downloadFile$1: ({ api, state }: Pick<IFileUploadRenderlessParams, 'api' | 'state'>) => (file: IFileUploadFile) => void;
-declare const downloadFileSingleInner: ({ props, state, api, constants }: Pick<IFileUploadRenderlessParams, 'props' | 'state' | 'api' | 'constants'>) => ({ file, isBatch }: IFileUploadDownloadFileSingleInner) => void;
+declare const downloadFileSingleInner: ({ props, state, api, constants }: {
+    props: any;
+    state: any;
+    api: any;
+    constants: any;
+}) => ({ file, isBatch }: {
+    file: any;
+    isBatch: any;
+}) => void;
 declare const getDownloadFileInfo: ({ api, state, props, service }: Pick<IFileUploadRenderlessParams, 'api' | 'state' | 'props' | 'service'>) => ({ docId }: {
     docId: string;
 }) => any;
@@ -858,6 +885,8 @@ interface IFileUploadApi {
     handleChange: ReturnType<typeof handleChange$1>;
     handleClickFileList: ReturnType<typeof handleClickFileList>;
     handleTriggerClick: ReturnType<typeof handleTriggerClick$1>;
+    handleReUpload: ReturnType<typeof handleReUpload>;
+    handleReUploadTotal: ReturnType<typeof handleReUploadTotal>;
 }
 type IFileUploadNoopFnCreator = ReturnType<typeof noopFnCreator>;
 interface IFileUploadService {
@@ -888,9 +917,9 @@ type IFileUploadRenderlessParams = ISharedRenderlessFunctionParams<IFileUploadCo
     api: IFileUploadApi;
 };
 type IFileUploadVm = ITinyVm<IFileUploadConstants> & IFileUploadProps;
-type IFileUploadModalVm = {
+interface IFileUploadModalVm {
     Modal: ITinyVm<unknown>;
-};
+}
 type IFileUploadFile = File & {
     [propName: string]: any;
 };
@@ -1050,6 +1079,8 @@ declare const uploadListProps: {
         type: BooleanConstructor;
         default: boolean;
     };
+    reUploadable: BooleanConstructor;
+    reUploadTip: FunctionConstructor;
     tiny_mode: StringConstructor;
     tiny_mode_root: BooleanConstructor;
     tiny_template: (FunctionConstructor | ObjectConstructor)[];
@@ -1077,6 +1108,13 @@ declare let getApi: () => {
 interface IUploadListState {
     focusing: boolean;
     shows: boolean;
+    progressType: string;
+    progressWidth: number;
+    progressStrokeWidth: number;
+    tooltipDisabled: boolean;
+    closeComponent: string;
+    preViewComponent: string;
+    failUploadFileCount: number;
     startPostion: number;
     screenType: boolean;
     showPanel: boolean;

package/types/{upload-list.type.d.mts → upload-list.type.d.ts}

@@ -1,3 +1,3 @@
 import 'vue';
-export { H as IUploadListApi, J as IUploadListProps, K as IUploadListRenderlessParamUtils, L as IUploadListRenderlessParams, G as IUploadListState, M as IUploadListVideoParam } from './upload-list.type-b934f279.js';
-import './shared.type.mjs';
+export { H as IUploadListApi, J as IUploadListProps, K as IUploadListRenderlessParamUtils, L as IUploadListRenderlessParams, G as IUploadListState, M as IUploadListVideoParam } from './upload-list.type-343e8c11.js';
+import './shared.type.js';

package/types/{upload.type.d.mts → upload.type.d.ts}

@@ -1,3 +1,3 @@
 import 'vue';
-export { d as IUploadApi, i as IUploadFormData, k as IUploadOptionsOfHwh5, j as IUploadOptionsOfPost, e as IUploadProps, h as IUploadRenderlessOtherParams, f as IUploadRenderlessParamUtils, g as IUploadRenderlessParams, c as IUploadState, b as IUploadStateHeader } from './upload-list.type-b934f279.js';
-import './shared.type.mjs';
+export { d as IUploadApi, i as IUploadFormData, k as IUploadOptionsOfHwh5, j as IUploadOptionsOfPost, e as IUploadProps, h as IUploadRenderlessOtherParams, f as IUploadRenderlessParamUtils, g as IUploadRenderlessParams, c as IUploadState, b as IUploadStateHeader } from './upload-list.type-343e8c11.js';
+import './shared.type.js';

package/types/watermark.type.d.ts

@@ -0,0 +1,33 @@
+declare const useWatermarkBg: (props: any, state: any) => Promise<any>;
+declare const reRenderWatermark: ({ state }: {
+    state: any;
+}) => () => void;
+declare const mounted: ({ vm, state, props }: {
+    vm: any;
+    state: any;
+    props: any;
+}) => () => void;
+declare const unmounted: ({ state }: {
+    state: any;
+}) => () => void;
+declare const watchProps: ({ state, vm, props }: {
+    state: any;
+    vm: any;
+    props: any;
+}) => () => Promise<void>;
+
+interface IWatermarkState {
+    div: HTMLDivElement;
+    ob: MutationObserver;
+    bg: ReturnType<typeof useWatermarkBg>;
+    flag: number;
+}
+interface IWatermarkApi {
+    state: IWatermarkState;
+    mounted: ReturnType<typeof mounted>;
+    reRenderWatermark: ReturnType<typeof reRenderWatermark>;
+    unmounted: ReturnType<typeof unmounted>;
+    watchProps: ReturnType<typeof watchProps>;
+}
+
+export { IWatermarkApi };

package/types/{wizard.type.d.mts → wizard.type.d.ts}

@@ -1,5 +1,5 @@
 import { ExtractPropTypes } from 'vue';
-import { ISharedRenderlessFunctionParams, ISharedRenderlessParamUtils } from './shared.type.mjs';
+import { ISharedRenderlessFunctionParams, ISharedRenderlessParamUtils } from './shared.type.js';
 
 declare const $constants: {
     DOING_STATUS: string;

package/upload/index.js

@@ -1,6 +1,6 @@
 import "../chunk-G2ADBYYC.js";
 import { KEY_CODE } from "../common";
-const isImage = (str) => str.indexOf("image") !== -1;
+const isImage = (str) => str.includes("image");
 const handleChange = (api) => (event) => {
   const files = event.target.files;
   if (!files) {

package/upload-list/index.js

@@ -146,11 +146,12 @@ const getFileIcon = ({ constants }) => ({ type }) => {
       typeName.split("/").forEach((type2) => iconTypes[type2] = typeValue);
     }
   }
-  return iconTypes[type] || iconTypes["default"];
+  return iconTypes[type] || iconTypes.default;
 };
 const remove = ({ emit }) => ({ file }) => emit("remove", file);
 const calcUploadListLiWidth = ({ vm, nextTick, props, constants }) => () => {
-  const { listType } = props, { LIST_TYPE } = constants;
+  const { listType } = props;
+  const { LIST_TYPE } = constants;
   nextTick(() => {
     const uploadListEle = vm.$refs["upload-list"];
     const uploadListLiEle = vm.$refs["upload-list-li"];

package/upload-list/vue.js

@@ -45,7 +45,8 @@ const api = [
   "handleTriggerClick",
   "chooseFile"
 ];
-const renderless = (props, { reactive, onMounted, onUnmounted, watch, inject, computed }, { t, parent, mode, emit, service, vm, nextTick }, { Modal }) => {
+const renderless = (props, { reactive, onMounted, onUnmounted, watch, inject, computed }, { t, parent, mode, emit, service, vm, nextTick, designConfig }, { Modal }) => {
+  var _a, _b, _c, _d, _e, _f;
   const api2 = { getApi };
   parent = inject("uploader").$children[0];
   const constants = parent.$constants;
@@ -53,8 +54,17 @@ const renderless = (props, { reactive, onMounted, onUnmounted, watch, inject, co
   const state = reactive({
     focusing: false,
     shows: false,
+    progressType: ((_a = designConfig == null ? void 0 : designConfig.state) == null ? void 0 : _a.progressType) || "circle",
+    progressWidth: (_b = designConfig == null ? void 0 : designConfig.state) == null ? void 0 : _b.progressWidth,
+    progressStrokeWidth: ((_c = designConfig == null ? void 0 : designConfig.state) == null ? void 0 : _c.progressStrokeWidth) || 6,
+    tooltipDisabled: ((_d = designConfig == null ? void 0 : designConfig.state) == null ? void 0 : _d.tooltipDisabled) !== false,
+    closeComponent: ((_e = designConfig == null ? void 0 : designConfig.icons) == null ? void 0 : _e.closeComponent) || "icon-close",
+    preViewComponent: (_f = designConfig == null ? void 0 : designConfig.icons) == null ? void 0 : _f.preViewComponent,
+    failUploadFileCount: computed(
+      () => props.files.reduce((total, item) => total += item.status === "fail" ? 1 : 0, 0)
+    ),
     startPostion: 0,
-    screenType: mode === "mobile" ? true : false,
+    screenType: mode === "mobile",
     showPanel: false,
     showTriggerPanel: false,
     triggerClickType: "",

package/watermark/index.js

@@ -0,0 +1,202 @@
+import {
+  __spreadProps,
+  __spreadValues
+} from "../chunk-G2ADBYYC.js";
+const SelfFontGap = 3;
+const getMarkSize = ({ props, ctx, state }) => {
+  const { content } = props;
+  const { fontSize, fontFamily } = state.font;
+  let defaultWidth = 120;
+  let defaultHeight = 64;
+  if (!props.image && ctx.measureText) {
+    ctx.font = `${Number(fontSize)}px ${fontFamily}`;
+    const contents = Array.isArray(content) ? content : [content];
+    const widths = contents.map((item) => ctx.measureText(item).width);
+    defaultWidth = Math.ceil(Math.max(...widths));
+    defaultHeight = Number(fontSize) * contents.length + (contents.length - 1) * SelfFontGap;
+  }
+  return [Math.max(props.width, defaultWidth), Math.max(props.height, defaultHeight)];
+};
+const selfDrawText = ({ props, state, ctx, canvasWidth, canvasHeight, ratios }) => {
+  const { rotate, content } = props;
+  const { fontSize, color, fontStyle, fontWeight, fontFamily } = state.font;
+  const devicePixelRatio = window.devicePixelRatio || 1;
+  const mergedFontSize = Number(fontSize) * devicePixelRatio;
+  const drawHeight = canvasHeight / devicePixelRatio;
+  ctx.font = `${fontStyle} normal ${fontWeight} ${mergedFontSize}px/${drawHeight}px ${fontFamily}`;
+  ctx.fillStyle = color;
+  ctx.textAlign = "center";
+  ctx.textBaseline = "bottom";
+  ratios.forEach((ratio) => {
+    ctx.save();
+    ctx.translate(canvasWidth / ratio, canvasHeight / ratio);
+    ctx.rotate(Math.PI / 180 * rotate);
+    const contents = Array.isArray(content) ? content : [content];
+    const fontHeight = mergedFontSize + SelfFontGap * devicePixelRatio;
+    const startHeight = (canvasHeight - contents.length * fontHeight) / 2 - canvasHeight / 2;
+    contents == null ? void 0 : contents.forEach((item, index) => {
+      ctx.fillText(item || "", 0, startHeight + (index + 1) * fontHeight);
+    });
+    ctx.restore();
+  });
+};
+const imageLoad = (props, state, ctx, result, canvas) => {
+  const { image, width, height, rotate, interlaced } = props;
+  const img = new Image();
+  return new Promise((resolve) => {
+    img.onload = () => {
+      const ratios = interlaced ? [4, 4 / 3] : [2];
+      ratios.forEach((ratio) => {
+        ctx.save();
+        ctx.translate(result.size.width / ratio, result.size.height / ratio);
+        ctx.rotate(Math.PI / 180 * rotate);
+        ctx.drawImage(img, -width / 2, -height / 2, width, height);
+        ctx.restore();
+      });
+      resolve(__spreadValues({
+        base64: canvas.toDataURL()
+      }, result));
+    };
+    img.onerror = () => {
+      const propsTmp = props.content ? props : __spreadProps(__spreadValues({}, props), {
+        content: "Invalid data"
+      });
+      if (interlaced) {
+        selfDrawText({
+          props,
+          ctx,
+          state,
+          canvasWidth: result.size.width,
+          canvasHeight: result.size.height,
+          ratios: [4, 4 / 3]
+        });
+      } else {
+        selfDrawText({
+          props: propsTmp,
+          ctx,
+          state,
+          canvasWidth: result.size.width,
+          canvasHeight: result.size.height,
+          ratios: [2]
+        });
+      }
+      resolve(__spreadValues({
+        base64: canvas.toDataURL()
+      }, result));
+    };
+    img.crossOrigin = "anonymous";
+    img.referrerPolicy = "no-referrer";
+    img.src = image;
+  });
+};
+const useWatermarkBg = function(props, state) {
+  const { gap, image, interlaced } = props;
+  const [gapX, gapY] = gap;
+  const canvas = document.createElement("canvas");
+  const ctx = canvas.getContext("2d");
+  const devicePixelRatio = window.devicePixelRatio || 1;
+  const [markWidth, markHeight] = getMarkSize({ props, state, ctx });
+  const singleWidth = (gapX + markWidth) * devicePixelRatio;
+  const singleHeight = (gapY + markHeight) * devicePixelRatio;
+  const canvasWidth = interlaced ? singleWidth * 2 : singleWidth;
+  const canvasHeight = interlaced ? singleHeight * 2 : singleHeight;
+  canvas.width = canvasWidth;
+  canvas.height = canvasHeight;
+  const result = {
+    size: {
+      width: canvasWidth,
+      height: canvasHeight
+    },
+    styleSize: {
+      width: canvasWidth / devicePixelRatio,
+      height: canvasHeight / devicePixelRatio
+    }
+  };
+  if (image) {
+    return imageLoad(props, state, ctx, result, canvas);
+  } else {
+    if (interlaced) {
+      selfDrawText({ props, state, ctx, canvasWidth, canvasHeight, ratios: [4, 4 / 3] });
+    } else {
+      selfDrawText({ props, state, ctx, canvasWidth, canvasHeight, ratios: [2] });
+    }
+  }
+  return new Promise(
+    (resolve) => resolve(__spreadValues({
+      base64: canvas.toDataURL()
+    }, result))
+  );
+};
+const updateWatermark = (watermarkBg, props) => {
+  const { base64, styleSize } = watermarkBg;
+  const watermarkDiv = document.createElement("div");
+  watermarkDiv.style.position = "absolute";
+  watermarkDiv.style.inset = "0";
+  watermarkDiv.style.backgroundImage = `url(${base64})`;
+  watermarkDiv.style.backgroundSize = `${styleSize.width}px ${styleSize.height}px`;
+  watermarkDiv.style.backgroundRepeat = "repeat";
+  watermarkDiv.style.backgroundPosition = `${props.offset[0] || 20}px ${(props == null ? void 0 : props.offset[1]) || 20}px`;
+  watermarkDiv.style.width = "100%";
+  watermarkDiv.style.height = "100%";
+  watermarkDiv.style.pointerEvents = "none";
+  watermarkDiv.style.zIndex = `${props.zIndex}`;
+  return watermarkDiv;
+};
+async function createWatermark({ vm, state, props }) {
+  const parentRef = vm.$refs.parentRef;
+  if (!parentRef) {
+    return;
+  }
+  const bgValue = await useWatermarkBg(props, state);
+  if (state.watermarkDiv) {
+    state.watermarkDiv.remove();
+  }
+  state.watermarkDiv = updateWatermark(bgValue, props);
+  parentRef.appendChild(state.watermarkDiv);
+}
+const reRenderWatermark = ({ state }) => () => {
+  state.flag++;
+};
+const mounted = ({ vm, state, props }) => () => {
+  createWatermark({ vm, state, props });
+  state.observerInstance = new MutationObserver((records) => {
+    for (const record of records) {
+      for (const dom of Array.from(record.removedNodes)) {
+        if (dom === state.watermarkDiv) {
+          state.flag++;
+          return;
+        }
+      }
+      if (record.type === "attributes" && record.target === state.watermarkDiv) {
+        state.flag++;
+        return;
+      }
+    }
+  });
+  const parentRef = vm.$refs.parentRef;
+  if (parentRef) {
+    state.observerInstance.observe(parentRef, {
+      childList: true,
+      attributes: true,
+      subtree: true
+    });
+    if (props.customClass) {
+      parentRef.classList.add(props.customClass);
+    }
+  }
+};
+const unmounted = ({ state }) => () => {
+  if (state.observerInstance) {
+    state.observerInstance.disconnect();
+  }
+  state.watermarkDiv = null;
+};
+const watchProps = ({ state, vm, props }) => () => createWatermark({ state, vm, props });
+export {
+  mounted,
+  reRenderWatermark,
+  unmounted,
+  updateWatermark,
+  useWatermarkBg,
+  watchProps
+};

package/watermark/vue.js

@@ -0,0 +1,27 @@
+import "../chunk-G2ADBYYC.js";
+import { mounted, reRenderWatermark, unmounted, watchProps } from "./index";
+const api = ["reRenderWatermark"];
+const renderless = (props, { onMounted, reactive, watch, computed, onUnmounted }, { constants, vm }) => {
+  const api2 = {};
+  const state = reactive({
+    watermarkDiv: null,
+    observerInstance: null,
+    flag: 0,
+    font: computed(() => Object.assign(constants.font, props.font))
+  });
+  Object.assign(api2, {
+    state,
+    reRenderWatermark: reRenderWatermark({ state }),
+    mounted: mounted({ vm, state, props }),
+    unmounted: unmounted({ state }),
+    watchProps: watchProps({ state, vm, props })
+  });
+  onMounted(api2.mounted);
+  onUnmounted(api2.unmounted);
+  watch([props, () => state.flag], api2.watchProps);
+  return api2;
+};
+export {
+  api,
+  renderless
+};

package/wizard/index.js

@@ -3,10 +3,10 @@ import { format } from "../common/date";
 import { copyArray, extend } from "../common/object";
 import { isObject } from "../common/type";
 const lastStepHandle = ({ state, emit }) => () => {
+  if (state.datas[0].status === state.doing) {
+    return;
+  }
   for (let i = 0; i < state.datas.length; i++) {
-    if (state.datas[0].status === state.doing) {
-      return;
-    }
     if (state.datas[i].status === state.doing) {
       state.datas[i].status = state.wait;
       state.datas[i - 1].status = state.doing;
@@ -24,10 +24,10 @@ const nextStepHandle = ({ state, emit }) => () => {
       state.datas[i].status = state.ready;
       state.datas[i + 1].status = state.doing;
       state.submitShow = i + 2 === state.datas.length;
-      return;
+      break;
     }
-    emit("btnNext", state.datas);
   }
+  emit("btnNext", state.datas);
 };
 const btnSaveHandle = ({ state, emit }) => () => {
   emit("btnSave", state.datas);

package/card-group/index.js

@@ -1,16 +0,0 @@
-import "../chunk-G2ADBYYC.js";
-const getStyle = ({ props }) => () => {
-  const size = props.size || "medium";
-  const sizeMap = {
-    large: "31.25rem",
-    medium: "18.75rem",
-    small: "12.5rem",
-    mini: "6.25rem"
-  };
-  return {
-    "grid-template-columns": `repeat(auto-fit, minmax(${sizeMap[size]}, 1fr))`
-  };
-};
-export {
-  getStyle
-};

package/color-picker/alpha-select/index.js

@@ -1,20 +0,0 @@
-import "../../chunk-G2ADBYYC.js";
-const calcLeftByAlpha = (wrapper, thumb, alpha) => {
-  return Math.round(alpha * (wrapper.offsetWidth - thumb.offsetWidth / 2) / 100);
-};
-const updateThumb = (alpha, thumb, wrapper) => {
-  thumb.style.left = `${calcLeftByAlpha(wrapper, thumb, alpha)}px`;
-};
-const onDrag = (event, bar, thumb, alpha) => {
-  const rect = bar.value.getBoundingClientRect();
-  const { clientX } = event;
-  let left = clientX - rect.left;
-  left = Math.max(thumb.value.offsetWidth / 2, left);
-  left = Math.min(left, rect.width - thumb.value.offsetWidth / 2);
-  alpha.value = Math.round((left - thumb.value.offsetWidth / 2) / (rect.width - thumb.value.offsetWidth) * 100);
-};
-export {
-  calcLeftByAlpha,
-  onDrag,
-  updateThumb
-};

package/color-picker/alpha-select/vue.js

@@ -1,60 +0,0 @@
-import "../../chunk-G2ADBYYC.js";
-import Color from "../utils/color";
-import { draggable } from "../utils/use-drag";
-import { onDrag, updateThumb } from ".";
-const api = ["state", "color", "slider", "alphaWrapper", "alphaThumb"];
-const renderless = (props, context, { emit }) => {
-  const hex = props.color;
-  const color = new Color(hex, props.alpha);
-  const [rr, gg, bb] = color.getRGB();
-  const r = context.ref(rr);
-  const g = context.ref(gg);
-  const b = context.ref(bb);
-  const slider = context.ref();
-  const alphaWrapper = context.ref();
-  const alphaThumb = context.ref();
-  const alpha = context.ref(color.get("a"));
-  context.watch(
-    () => props.color,
-    (hex2) => {
-      color.reset(hex2);
-      const [rr2, gg2, bb2] = color.getRGB();
-      r.value = rr2;
-      g.value = gg2;
-      b.value = bb2;
-    }
-  );
-  context.watch(alpha, (newAlpha) => {
-    updateThumb(newAlpha, alphaThumb.value, alphaWrapper.value);
-    emit("alpha-update", alpha.value);
-  });
-  const background = context.computed(() => {
-    return `linear-gradient(to right, rgba(${r.value}, ${g.value}, ${b.value}, 0) 0%, rgba(${r.value}, ${g.value}, ${b.value}, 1) 100%)`;
-  });
-  const state = context.reactive({
-    background,
-    hex
-  });
-  const api2 = {
-    state,
-    slider,
-    alphaWrapper,
-    alphaThumb
-  };
-  context.onMounted(() => {
-    updateThumb(alpha.value, alphaThumb.value, slider.value);
-    draggable(slider.value, {
-      drag(event) {
-        onDrag(event, slider, alphaThumb, alpha);
-      },
-      start(event) {
-        onDrag(event, slider, alphaThumb, alpha);
-      }
-    });
-  });
-  return api2;
-};
-export {
-  api,
-  renderless
-};