sard 1.0.0 → 1.0.2

package/components/signature/signature.js

@@ -0,0 +1,247 @@
+import { createBem } from "../../utils/bem.js";
+import { useZIndex } from "../../use/useZIndex.js";
+import { usePointerDown } from "../../use/usePointerDown.js";
+import { useResizeObserver } from "../../use/useResizeObserver.js";
+import motion_default from "../motion/motion.js";
+import { useTranslateWithPrefix } from "../../locale/index.js";
+import button_default from "../button/button.js";
+import { defaultSignatureProps } from "./common.js";
+import { Teleport, computed, createBlock, createCommentVNode, createElementVNode, createTextVNode, createVNode, defineComponent, mergeDefaults, normalizeClass, normalizeStyle, openBlock, renderSlot, toDisplayString, unref, useModel, useTemplateRef, vShow, withCtx, withDirectives } from "vue";
+//#region packages/sard/components/signature/signature.vue
+var signature_default = /*@__PURE__*/ defineComponent({
+	__name: "signature",
+	props: /*@__PURE__*/ mergeDefaults({
+		color: {
+			type: String,
+			required: false
+		},
+		lineWidth: {
+			type: Number,
+			required: false
+		},
+		background: {
+			type: String,
+			required: false
+		},
+		fullScreen: {
+			type: Boolean,
+			required: false
+		},
+		visible: {
+			type: Boolean,
+			required: false
+		},
+		cancelText: {
+			type: String,
+			required: false
+		},
+		clearText: {
+			type: String,
+			required: false
+		},
+		confirmText: {
+			type: String,
+			required: false
+		},
+		type: {
+			type: String,
+			required: false
+		},
+		quality: {
+			type: Number,
+			required: false
+		}
+	}, defaultSignatureProps),
+	emits: [
+		"update:visible",
+		"confirm",
+		"clear",
+		"cancel"
+	],
+	setup(__props, { expose: __expose, emit: __emit }) {
+		const props = __props;
+		const emit = __emit;
+		const bem = createBem("signature");
+		const { t } = useTranslateWithPrefix("signature");
+		const innerVisible = useModel(props, "visible");
+		const [zIndex, increaseZIndex] = useZIndex();
+		const onBeforeEnter = () => {
+			increaseZIndex();
+		};
+		const dpr = window.devicePixelRatio;
+		const canvasRef = useTemplateRef("canvas");
+		const contextRef = computed(() => canvasRef.value?.getContext("2d"));
+		let covertCanvas = null;
+		let covertContext = null;
+		useResizeObserver(canvasRef, ({ width, height }) => {
+			const canvas = canvasRef.value;
+			if (canvas) {
+				canvas.width = width * dpr;
+				canvas.height = height * dpr;
+				initialCanvas();
+			}
+		});
+		let prevPoints = [0, 0];
+		let isEmpty = true;
+		const onTouchStart = (event) => {
+			event.preventDefault();
+			const canvas = canvasRef.value;
+			const context = contextRef.value;
+			const rect = canvas.getBoundingClientRect();
+			const touch = event.touches[0];
+			const x = touch.clientX - rect.x;
+			const y = touch.clientY - rect.y;
+			context.setTransform(dpr, 0, 0, dpr, 0, 0);
+			context.lineCap = "round";
+			context.lineJoin = "round";
+			context.lineWidth = props.lineWidth;
+			context.strokeStyle = props.color;
+			context.beginPath();
+			context.moveTo(x, y);
+			context.lineTo(x, y);
+			prevPoints = [x, y];
+			context.stroke();
+			isEmpty = false;
+		};
+		const onTouchMove = (event) => {
+			const canvas = canvasRef.value;
+			const context = contextRef.value;
+			const rect = canvas.getBoundingClientRect();
+			const touch = event.touches[0];
+			const x = touch.clientX - rect.x;
+			const y = touch.clientY - rect.y;
+			context.moveTo(...prevPoints);
+			context.lineTo(x, y);
+			prevPoints = [x, y];
+			context.stroke();
+		};
+		const onTouchEnd = () => {
+			contextRef.value.closePath();
+		};
+		const onPointerDown = usePointerDown(onTouchStart, onTouchMove, onTouchEnd);
+		const getCanvasDataURL = () => {
+			return canvasRef.value.toDataURL(props.type, props.quality);
+		};
+		const drawCovertCanvas = () => {
+			if (!covertCanvas) covertCanvas = document.createElement("canvas");
+			if (!covertContext) covertContext = covertCanvas.getContext("2d");
+			if (!covertContext) return;
+			const canvas = canvasRef.value;
+			covertCanvas.width = canvas.height;
+			covertCanvas.height = canvas.width;
+			covertContext.clearRect(0, 0, covertCanvas.width, covertCanvas.height);
+			covertContext.save();
+			covertContext.translate(0, covertCanvas.height);
+			covertContext.rotate(-Math.PI / 2);
+			covertContext.drawImage(canvas, 0, 0);
+			covertContext.restore();
+		};
+		const getCovertCanvasDataURL = () => {
+			drawCovertCanvas();
+			return covertCanvas.toDataURL(props.type, props.quality);
+		};
+		const initialCanvas = () => {
+			const context = contextRef.value;
+			const canvas = canvasRef.value;
+			if (context && canvas) {
+				context.clearRect(0, 0, canvas.width, canvas.height);
+				if (props.background) {
+					context.fillStyle = props.background;
+					context.fillRect(0, 0, canvas.width, canvas.height);
+				}
+			}
+			isEmpty = true;
+		};
+		const clear = () => {
+			initialCanvas();
+			emit("clear");
+		};
+		const confirm = () => {
+			const dataURL = isEmpty ? "" : props.fullScreen ? getCovertCanvasDataURL() : getCanvasDataURL();
+			emit("confirm", dataURL);
+			if (props.fullScreen) close();
+		};
+		const close = () => {
+			initialCanvas();
+			innerVisible.value = false;
+		};
+		const cancel = () => {
+			close();
+			emit("cancel");
+		};
+		const footerSize = useResizeObserver(useTemplateRef("footer"), void 0, () => !props.fullScreen);
+		const footerContentStyle = computed(() => {
+			if (props.fullScreen) return {
+				width: footerSize.height + "px",
+				height: footerSize.width + "px"
+			};
+			return null;
+		});
+		const signatureClass = computed(() => {
+			return [bem.b(), bem.m("full", props.fullScreen)];
+		});
+		const signatureStyle = computed(() => {
+			return { zIndex: props.fullScreen && innerVisible.value ? zIndex.value : "" };
+		});
+		__expose({
+			clear,
+			confirm
+		});
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(Teleport, {
+				to: "body",
+				disabled: !__props.fullScreen
+			}, [createVNode(motion_default, {
+				disalbed: !__props.fullScreen,
+				name: "fade",
+				onBeforeEnter
+			}, {
+				default: withCtx(() => [withDirectives(createElementVNode("div", {
+					class: normalizeClass(signatureClass.value),
+					style: normalizeStyle(signatureStyle.value)
+				}, [createElementVNode("div", { class: normalizeClass(unref(bem).e("body")) }, [createElementVNode("canvas", {
+					ref: "canvas",
+					onTouchstart: onTouchStart,
+					onTouchmove: onTouchMove,
+					onTouchend: onTouchEnd,
+					onTouchcancel: onTouchEnd,
+					onPointerdown: _cache[0] || (_cache[0] = (...args) => unref(onPointerDown) && unref(onPointerDown)(...args))
+				}, null, 544)], 2), createElementVNode("div", {
+					ref: "footer",
+					class: normalizeClass(unref(bem).e("footer"))
+				}, [createElementVNode("div", {
+					class: normalizeClass(unref(bem).e("footer-content")),
+					style: normalizeStyle(footerContentStyle.value)
+				}, [renderSlot(_ctx.$slots, "default"), createElementVNode("div", { class: normalizeClass(unref(bem).e("button-group")) }, [
+					__props.fullScreen ? (openBlock(), createBlock(button_default, {
+						key: 0,
+						size: "small",
+						variant: "filled",
+						onClick: cancel
+					}, {
+						default: withCtx(() => [createTextVNode(toDisplayString(__props.cancelText || unref(t)("cancel")), 1)]),
+						_: 1
+					})) : createCommentVNode("v-if", true),
+					createVNode(button_default, {
+						size: "small",
+						variant: "filled",
+						onClick: clear
+					}, {
+						default: withCtx(() => [createTextVNode(toDisplayString(__props.clearText || unref(t)("clear")), 1)]),
+						_: 1
+					}),
+					createVNode(button_default, {
+						size: "small",
+						onClick: confirm
+					}, {
+						default: withCtx(() => [createTextVNode(toDisplayString(__props.confirmText || unref(t)("confirm")), 1)]),
+						_: 1
+					})
+				], 2)], 6)], 2)], 6), [[vShow, !__props.fullScreen || unref(innerVisible)]])]),
+				_: 3
+			}, 8, ["disalbed"])], 8, ["disabled"]);
+		};
+	}
+});
+//#endregion
+export { signature_default as default };

package/components/skeleton/common.d.ts

@@ -0,0 +1,29 @@
+import { type DefaultProps } from '../config';
+export interface SkeletonProps {
+    rows?: number;
+    title?: boolean;
+    avatar?: boolean;
+    avatarSize?: string;
+    avatarRound?: boolean;
+    round?: boolean;
+    loading?: boolean;
+    animated?: boolean;
+}
+export declare const defaultSkeletonProps: DefaultProps<SkeletonProps>;
+export interface SkeletonSlots {
+    default?(props: Record<string, never>): any;
+}
+export interface SkeletonBlockProps {
+    animated?: boolean;
+    round?: boolean;
+    width?: string;
+    height?: string;
+}
+export interface SkeletonAvatarProps extends SkeletonBlockProps {
+    size?: string;
+}
+export interface SkeletonParagraphProps extends SkeletonBlockProps {
+    rows?: number;
+}
+export interface SkeletonTitleProps extends SkeletonBlockProps {
+}

package/components/skeleton/common.js

@@ -0,0 +1,7 @@
+//#region packages/sard/components/skeleton/common.ts
+const defaultSkeletonProps = {
+	rows: 3,
+	loading: true
+};
+//#endregion
+export { defaultSkeletonProps };

package/components/skeleton/index.css

@@ -0,0 +1 @@
+:root{--s-skeleton-bg:var(--s-fill-color-secondary);--s-skeleton-radius:var(--s-border-radius-sm);--s-skeleton-highlight-color:rgba(0,0,0,.08);--s-skeleton-block-height:var(--s-size);--s-skeleton-avatar-size:var(--s-size-2xl);--s-skeleton-avatar-margin-end:var(--s-size);--s-skeleton-title-width:40%;--s-skeleton-title-height:var(--s-size-lg);--s-skeleton-title-margin-bottom:var(--s-size);--s-skeleton-row-last-width:60%;--s-skeleton-row-gap:var(--s-size-sm)}.dark{--s-skeleton-highlight-color:hsla(0,0%,100%,.15)}.s-skeleton{display:flex;flex-wrap:nowrap;column-gap:var(--s-skeleton-avatar-margin-end)}.s-skeleton__block{width:100%;height:var(--s-skeleton-block-height);background:var(--s-skeleton-bg);border-radius:var(--s-skeleton-radius)}.s-skeleton__avatar{flex:none;width:var(--s-skeleton-avatar-size);height:var(--s-skeleton-avatar-size);border-radius:var(--s-skeleton-radius)}.s-skeleton__title{width:var(--s-skeleton-title-width);height:var(--s-skeleton-title-height)}.s-skeleton__row:last-child{width:var(--s-skeleton-row-last-width)}.s-skeleton__content{display:flex;flex-direction:column;flex:1;row-gap:var(--s-skeleton-title-margin-bottom)}.s-skeleton__paragraph{display:flex;flex-direction:column;row-gap:var(--s-skeleton-row-gap)}.s-skeleton--round{border-radius:var(--s-border-radius-full)}.s-skeleton--animated{background-image:linear-gradient(90deg, transparent 25%, var(--s-skeleton-highlight-color) 37%, transparent 50%);background-size:400% 100%;animation:s-skeleton-animated 1.2s ease infinite}@keyframes s-skeleton-animated{0%{background-position:100% 50%}100%{background-position:0 50%}}

package/components/skeleton/index.d.ts

@@ -0,0 +1,13 @@
+import { type EnhancedComponent } from '../../utils';
+import _Skeleton from './skeleton.vue';
+import _SkeletonAvatar from './skeleton-avatar.vue';
+import _SkeletonBlock from './skeleton-block.vue';
+import _SkeletonParagraph from './skeleton-paragraph.vue';
+import _SkeletonTitle from './skeleton-title.vue';
+export declare const Skeleton: EnhancedComponent<typeof _Skeleton>;
+export declare const SkeletonAvatar: EnhancedComponent<typeof _SkeletonAvatar>;
+export declare const SkeletonBlock: EnhancedComponent<typeof _SkeletonBlock>;
+export declare const SkeletonParagraph: EnhancedComponent<typeof _SkeletonParagraph>;
+export declare const SkeletonTitle: EnhancedComponent<typeof _SkeletonTitle>;
+export default Skeleton;
+export type { SkeletonProps, SkeletonSlots, SkeletonBlockProps, SkeletonAvatarProps, SkeletonParagraphProps, SkeletonTitleProps, } from './common';

package/components/skeleton/index.js

@@ -0,0 +1,14 @@
+import { enhanceComponent } from "../../utils/component.js";
+import skeleton_block_default from "./skeleton-block.js";
+import skeleton_avatar_default from "./skeleton-avatar.js";
+import skeleton_title_default from "./skeleton-title.js";
+import skeleton_paragraph_default from "./skeleton-paragraph.js";
+import skeleton_default from "./skeleton.js";
+//#region packages/sard/components/skeleton/index.ts
+const Skeleton = enhanceComponent(skeleton_default);
+const SkeletonAvatar = enhanceComponent(skeleton_avatar_default);
+const SkeletonBlock = enhanceComponent(skeleton_block_default);
+const SkeletonParagraph = enhanceComponent(skeleton_paragraph_default);
+const SkeletonTitle = enhanceComponent(skeleton_title_default);
+//#endregion
+export { Skeleton, Skeleton as default, SkeletonAvatar, SkeletonBlock, SkeletonParagraph, SkeletonTitle };

package/components/skeleton/skeleton-avatar.d.ts

@@ -0,0 +1,4 @@
+import { type SkeletonAvatarProps } from './common';
+declare const __VLS_export: import("vue").DefineComponent<SkeletonAvatarProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<SkeletonAvatarProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/components/skeleton/skeleton-avatar.js

@@ -0,0 +1,58 @@
+import { createBem } from "../../utils/bem.js";
+import skeleton_block_default from "./skeleton-block.js";
+import { computed, createBlock, defineComponent, normalizeClass, normalizeStyle, openBlock, unref } from "vue";
+//#region packages/sard/components/skeleton/skeleton-avatar.vue
+var skeleton_avatar_default = /*@__PURE__*/ defineComponent({
+	__name: "skeleton-avatar",
+	props: {
+		size: {
+			type: String,
+			required: false
+		},
+		animated: {
+			type: Boolean,
+			required: false
+		},
+		round: {
+			type: Boolean,
+			required: false
+		},
+		width: {
+			type: String,
+			required: false
+		},
+		height: {
+			type: String,
+			required: false
+		}
+	},
+	setup(__props) {
+		const props = __props;
+		const bem = createBem("skeleton");
+		const skeletonAvatarStyle = computed(() => {
+			return {
+				width: props.size,
+				height: props.size
+			};
+		});
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(skeleton_block_default, {
+				class: normalizeClass(unref(bem).e("avatar")),
+				style: normalizeStyle(skeletonAvatarStyle.value),
+				animated: __props.animated,
+				round: __props.round,
+				width: __props.width,
+				height: __props.height
+			}, null, 8, [
+				"class",
+				"style",
+				"animated",
+				"round",
+				"width",
+				"height"
+			]);
+		};
+	}
+});
+//#endregion
+export { skeleton_avatar_default as default };

package/components/skeleton/skeleton-block.d.ts

@@ -0,0 +1,4 @@
+import { type SkeletonBlockProps } from '../skeleton/common';
+declare const __VLS_export: import("vue").DefineComponent<SkeletonBlockProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<SkeletonBlockProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/components/skeleton/skeleton-block.js

@@ -0,0 +1,49 @@
+import { createBem } from "../../utils/bem.js";
+import { computed, createElementBlock, defineComponent, normalizeClass, normalizeStyle, openBlock } from "vue";
+//#region packages/sard/components/skeleton/skeleton-block.vue
+var skeleton_block_default = /*@__PURE__*/ defineComponent({
+	__name: "skeleton-block",
+	props: {
+		animated: {
+			type: Boolean,
+			required: false
+		},
+		round: {
+			type: Boolean,
+			required: false
+		},
+		width: {
+			type: String,
+			required: false
+		},
+		height: {
+			type: String,
+			required: false
+		}
+	},
+	setup(__props) {
+		const props = __props;
+		const bem = createBem("skeleton");
+		const skeletonBlockClass = computed(() => {
+			return [
+				bem.e("block"),
+				bem.m("animated", props.animated),
+				bem.m("round", props.round)
+			];
+		});
+		const skeletonBlockStyle = computed(() => {
+			return {
+				width: props.width,
+				height: props.height
+			};
+		});
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock("div", {
+				class: normalizeClass(skeletonBlockClass.value),
+				style: normalizeStyle(skeletonBlockStyle.value)
+			}, null, 6);
+		};
+	}
+});
+//#endregion
+export { skeleton_block_default as default };

package/components/skeleton/skeleton-paragraph.d.ts

@@ -0,0 +1,4 @@
+import { type SkeletonParagraphProps } from './common';
+declare const __VLS_export: import("vue").DefineComponent<SkeletonParagraphProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<SkeletonParagraphProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/components/skeleton/skeleton-paragraph.js

@@ -0,0 +1,52 @@
+import { createBem } from "../../utils/bem.js";
+import skeleton_block_default from "./skeleton-block.js";
+import { Fragment, createBlock, createElementBlock, defineComponent, normalizeClass, openBlock, renderList, unref } from "vue";
+//#region packages/sard/components/skeleton/skeleton-paragraph.vue
+var skeleton_paragraph_default = /*@__PURE__*/ defineComponent({
+	__name: "skeleton-paragraph",
+	props: {
+		rows: {
+			type: Number,
+			required: false
+		},
+		animated: {
+			type: Boolean,
+			required: false
+		},
+		round: {
+			type: Boolean,
+			required: false
+		},
+		width: {
+			type: String,
+			required: false
+		},
+		height: {
+			type: String,
+			required: false
+		}
+	},
+	setup(__props) {
+		const bem = createBem("skeleton");
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock("div", { class: normalizeClass(unref(bem).e("paragraph")) }, [(openBlock(true), createElementBlock(Fragment, null, renderList(__props.rows, (i) => {
+				return openBlock(), createBlock(skeleton_block_default, {
+					key: i,
+					animated: __props.animated,
+					round: __props.round,
+					width: __props.width,
+					height: __props.height,
+					class: normalizeClass(unref(bem).e("row"))
+				}, null, 8, [
+					"animated",
+					"round",
+					"width",
+					"height",
+					"class"
+				]);
+			}), 128))], 2);
+		};
+	}
+});
+//#endregion
+export { skeleton_paragraph_default as default };

package/components/skeleton/skeleton-title.d.ts

@@ -0,0 +1,4 @@
+import { type SkeletonTitleProps } from './common';
+declare const __VLS_export: import("vue").DefineComponent<SkeletonTitleProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<SkeletonTitleProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/components/skeleton/skeleton-title.js

@@ -0,0 +1,45 @@
+import { createBem } from "../../utils/bem.js";
+import skeleton_block_default from "./skeleton-block.js";
+import { createBlock, defineComponent, normalizeClass, openBlock, unref } from "vue";
+//#region packages/sard/components/skeleton/skeleton-title.vue
+var skeleton_title_default = /*@__PURE__*/ defineComponent({
+	__name: "skeleton-title",
+	props: {
+		animated: {
+			type: Boolean,
+			required: false
+		},
+		round: {
+			type: Boolean,
+			required: false
+		},
+		width: {
+			type: String,
+			required: false
+		},
+		height: {
+			type: String,
+			required: false
+		}
+	},
+	setup(__props) {
+		const bem = createBem("skeleton");
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(skeleton_block_default, {
+				class: normalizeClass(unref(bem).e("title")),
+				animated: __props.animated,
+				round: __props.round,
+				width: __props.width,
+				height: __props.height
+			}, null, 8, [
+				"class",
+				"animated",
+				"round",
+				"width",
+				"height"
+			]);
+		};
+	}
+});
+//#endregion
+export { skeleton_title_default as default };

package/components/skeleton/skeleton.d.ts

@@ -0,0 +1,20 @@
+import { type SkeletonProps, type SkeletonSlots } from './common';
+type __VLS_Slots = SkeletonSlots;
+declare const __VLS_base: import("vue").DefineComponent<SkeletonProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<SkeletonProps> & Readonly<{}>, {
+    title: boolean;
+    animated: boolean;
+    loading: boolean;
+    round: boolean;
+    avatar: boolean;
+    rows: number;
+    avatarSize: string;
+    avatarRound: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/components/skeleton/skeleton.js

@@ -0,0 +1,76 @@
+import { createBem } from "../../utils/bem.js";
+import skeleton_avatar_default from "./skeleton-avatar.js";
+import skeleton_title_default from "./skeleton-title.js";
+import skeleton_paragraph_default from "./skeleton-paragraph.js";
+import { defaultSkeletonProps } from "./common.js";
+import { createBlock, createCommentVNode, createElementBlock, createElementVNode, createVNode, defineComponent, mergeDefaults, normalizeClass, openBlock, renderSlot, unref } from "vue";
+//#region packages/sard/components/skeleton/skeleton.vue
+var skeleton_default = /*@__PURE__*/ defineComponent({
+	__name: "skeleton",
+	props: /*@__PURE__*/ mergeDefaults({
+		rows: {
+			type: Number,
+			required: false
+		},
+		title: {
+			type: Boolean,
+			required: false
+		},
+		avatar: {
+			type: Boolean,
+			required: false
+		},
+		avatarSize: {
+			type: String,
+			required: false
+		},
+		avatarRound: {
+			type: Boolean,
+			required: false
+		},
+		round: {
+			type: Boolean,
+			required: false
+		},
+		loading: {
+			type: Boolean,
+			required: false
+		},
+		animated: {
+			type: Boolean,
+			required: false
+		}
+	}, defaultSkeletonProps),
+	setup(__props) {
+		const bem = createBem("skeleton");
+		return (_ctx, _cache) => {
+			return __props.loading ? (openBlock(), createElementBlock("div", {
+				key: 0,
+				class: normalizeClass(unref(bem).b())
+			}, [__props.avatar ? (openBlock(), createBlock(skeleton_avatar_default, {
+				key: 0,
+				animated: __props.animated,
+				size: __props.avatarSize,
+				round: __props.avatarRound
+			}, null, 8, [
+				"animated",
+				"size",
+				"round"
+			])) : createCommentVNode("v-if", true), createElementVNode("div", { class: normalizeClass(unref(bem).e("content")) }, [__props.title ? (openBlock(), createBlock(skeleton_title_default, {
+				key: 0,
+				animated: __props.animated,
+				round: __props.round
+			}, null, 8, ["animated", "round"])) : createCommentVNode("v-if", true), createVNode(skeleton_paragraph_default, {
+				rows: __props.rows,
+				animated: __props.animated,
+				round: __props.round
+			}, null, 8, [
+				"rows",
+				"animated",
+				"round"
+			])], 2)], 2)) : renderSlot(_ctx.$slots, "default", { key: 1 });
+		};
+	}
+});
+//#endregion
+export { skeleton_default as default };

package/components/slide-verify/common.d.ts

@@ -0,0 +1,30 @@
+import { type DefaultProps } from '../config';
+export interface SlideVerifyResult {
+    targetPos: number;
+    actualPos: number;
+    startTime: number;
+    endTime: number;
+    trajectory: [x: number, y: number, t: number][];
+}
+export interface SlideVerifyProps {
+    targetPos?: number;
+    text?: string;
+    successText?: string;
+    errorText?: string;
+    disabled?: boolean;
+    resetWhenError?: boolean;
+    showTarget?: boolean;
+    verify?: (result: SlideVerifyResult) => Promise<boolean> | boolean;
+}
+export declare const defaultSlideVerifyProps: DefaultProps<SlideVerifyProps>;
+export interface SlideVerifySlots {
+}
+export interface SlideVerifyEmits {
+    (e: 'start', event: any): void;
+    (e: 'move', event: any): void;
+    (e: 'end', event: any): void;
+    (e: 'change', percent: number): void;
+}
+export interface SlideVerifyExpose {
+    reset: () => void;
+}

package/components/slide-verify/common.js

@@ -0,0 +1,4 @@
+//#region packages/sard/components/slide-verify/common.ts
+const defaultSlideVerifyProps = { resetWhenError: true };
+//#endregion
+export { defaultSlideVerifyProps };