sard 1.0.0 → 1.0.1

package/components/crop-image/crop-image.js

@@ -0,0 +1,537 @@
+import { createBem } from "../../utils/bem.js";
+import { loadImage } from "../../utils/file.js";
+import { getAspectFillSize, getAspectFitSize } from "../../utils/geometry.js";
+import { createInertialAnimate } from "../../utils/inertialAnimate.js";
+import { logError } from "../../utils/log.js";
+import { useTimeout } from "../../use/useTimeout.js";
+import { usePointerDown } from "../../use/usePointerDown.js";
+import { useDragPinch } from "../../use/useDragPinch.js";
+import "../../use/index.js";
+import "../../utils/index.js";
+import popup_default from "../popup/popup.js";
+import loading_default from "../loading/loading.js";
+import { useTranslateWithPrefix } from "../../locale/index.js";
+import button_default from "../button/button.js";
+import { defaultCropImageProps } from "./common.js";
+import { computed, createBlock, createCommentVNode, createElementBlock, createElementVNode, createTextVNode, createVNode, defineComponent, mergeDefaults, normalizeClass, normalizeStyle, onBeforeUnmount, openBlock, ref, toDisplayString, unref, watch, withCtx, withModifiers } from "vue";
+import { RotateLeft, Undo } from "@sard/icons";
+//#region packages/sard/components/crop-image/crop-image.vue
+const _hoisted_1 = ["src"];
+const minGapX = 20;
+const bounceCoeff = 4;
+const maxScale = 5;
+var crop_image_default = /*@__PURE__*/ defineComponent({
+	__name: "crop-image",
+	props: /*@__PURE__*/ mergeDefaults({
+		visible: {
+			type: Boolean,
+			required: false
+		},
+		url: {
+			type: String,
+			required: false
+		},
+		cropScale: {
+			type: String,
+			required: false
+		},
+		type: {
+			type: String,
+			required: false
+		},
+		quality: {
+			type: Number,
+			required: false
+		},
+		success: {
+			type: Function,
+			required: false
+		},
+		fail: {
+			type: Function,
+			required: false
+		},
+		complete: {
+			type: Function,
+			required: false
+		},
+		cancel: {
+			type: Function,
+			required: false
+		},
+		beforeCrop: {
+			type: Function,
+			required: false
+		},
+		cancelText: {
+			type: String,
+			required: false
+		},
+		confirmText: {
+			type: String,
+			required: false
+		}
+	}, defaultCropImageProps),
+	emits: [
+		"update:visible",
+		"before-enter",
+		"enter",
+		"after-enter",
+		"enter-cancelled",
+		"before-leave",
+		"leave",
+		"after-leave",
+		"leave-cancelled",
+		"visible-hook"
+	],
+	setup(__props, { expose: __expose, emit: __emit }) {
+		const props = __props;
+		const emit = __emit;
+		const bem = createBem("crop-image");
+		const { t } = useTranslateWithPrefix("signature");
+		const innerVisible = ref(props.visible);
+		watch(() => props.visible, () => {
+			innerVisible.value = props.visible;
+		});
+		const close = () => {
+			innerVisible.value = false;
+			emit("update:visible", false);
+		};
+		const onVisibleHook = (name, el) => {
+			emit("visible-hook", name, el);
+			emit(name, el);
+		};
+		const windowWidth = window.innerWidth;
+		const windowHeight = window.innerHeight;
+		const aspectRatio = computed(() => {
+			const [w, h] = props.cropScale.split(":").map(Number);
+			return [w, h];
+		});
+		const minGapY = windowWidth / 750 * 128;
+		const focusRect = computed(() => {
+			const maxWidth = windowWidth - minGapX * 2;
+			const maxHeight = windowHeight - minGapY * 2;
+			const [width, height] = getAspectFitSize(...aspectRatio.value, maxWidth, maxHeight);
+			return [
+				(windowWidth - width) / 2,
+				(windowHeight - height) / 2,
+				width,
+				height
+			];
+		});
+		const rotate = ref(0);
+		const actualRotate = ref(0);
+		const rotateTimer = useTimeout();
+		watch(rotate, () => {
+			rotateTimer.set(() => {
+				actualRotate.value = rotate.value;
+			}, 250);
+		});
+		const isRotating = computed(() => rotate.value !== actualRotate.value);
+		const isStillRotating = ref(false);
+		const rotatingTimer = useTimeout();
+		watch(isRotating, () => {
+			rotatingTimer.clear();
+			if (isRotating.value) isStillRotating.value = true;
+			else rotatingTimer.set(() => {
+				isStillRotating.value = false;
+			}, 150);
+		});
+		const maskStyle = computed(() => {
+			const [left, top, width, height] = focusRect.value;
+			return {
+				left: left + "px",
+				top: top + "px",
+				width: width + "px",
+				height: height + "px"
+			};
+		});
+		const focusStyle = computed(() => {
+			return {
+				...maskStyle.value,
+				transition: isRotating.value ? "" : "none",
+				transform: `rotate(${rotate.value - actualRotate.value}deg)`
+			};
+		});
+		const imageOrigSize = ref([0, 0]);
+		watch(() => props.url, (url) => {
+			imageOrigSize.value = [0, 0];
+			rotate.value = 0;
+			actualRotate.value = 0;
+			isStillRotating.value = false;
+			if (url) loadImage(url).then((image) => {
+				imageOrigSize.value = [image.naturalWidth, image.naturalHeight];
+			});
+		}, { immediate: true });
+		const imageCoverSize = ref([0, 0]);
+		watch(imageOrigSize, () => {
+			const [, , width, height] = focusRect.value;
+			imageCoverSize.value = getAspectFillSize(...imageOrigSize.value, width, height);
+		}, { immediate: true });
+		const reversedCoverSize = computed(() => {
+			const size = [...imageCoverSize.value];
+			return actualRotate.value % 180 !== 0 ? size.reverse() : size;
+		});
+		const imgLeft = ref(0);
+		const imgTop = ref(0);
+		const imgWidth = ref(0);
+		const imgHeight = ref(0);
+		watch(imageCoverSize, ([width, height]) => {
+			imgWidth.value = width;
+			imgHeight.value = height;
+			imgLeft.value = 0;
+			imgTop.value = 0;
+		}, { immediate: true });
+		watch(actualRotate, (rotate, oldRotate) => {
+			const oldWidth = imgWidth.value;
+			const oldHeight = imgHeight.value;
+			const oldTop = imgTop.value;
+			const oldLeft = imgLeft.value;
+			const [, , focusWidth, focusHeight] = focusRect.value;
+			const top = focusHeight / 2 - oldTop;
+			const left = focusWidth / 2 - oldLeft;
+			const right = oldWidth - left;
+			const bottom = oldHeight - top;
+			const r = (rotate - oldRotate) % 360;
+			let topOpposite = 0;
+			let leftOpposite = 0;
+			if (r === 0) return;
+			switch (r) {
+				case -90:
+				case 270:
+					topOpposite = right;
+					leftOpposite = top;
+					break;
+				case -180:
+				case 180:
+					topOpposite = bottom;
+					leftOpposite = right;
+					break;
+				case -270:
+				case 90:
+					topOpposite = left;
+					leftOpposite = bottom;
+					break;
+			}
+			imgTop.value = focusHeight / 2 - topOpposite;
+			imgLeft.value = focusWidth / 2 - leftOpposite;
+			if (rotate % 180 - oldRotate % 180 !== 0) {
+				const [width, height] = [oldWidth, oldHeight].reverse();
+				imgWidth.value = width;
+				imgHeight.value = height;
+			}
+		});
+		const isCaptured = ref(false);
+		const inInertia = ref(false);
+		const puppetStyle = computed(() => {
+			const [width, height] = reversedCoverSize.value;
+			const scale = imgWidth.value / width || 1;
+			const x = imgLeft.value;
+			const y = imgTop.value;
+			return {
+				width: width + "px",
+				height: height + "px",
+				transform: `translate3d(${x}px, ${y}px, 0) scale(${scale})`,
+				transition: isStillRotating.value || isCaptured.value || inInertia.value ? "none" : ""
+			};
+		});
+		const imageStyle = computed(() => {
+			const [reversedCoverWidth, reversedCoverHeight] = reversedCoverSize.value;
+			const [width, height] = Math.abs(actualRotate.value) % 360 % 180 !== 0 ? [reversedCoverHeight, reversedCoverWidth] : [reversedCoverWidth, reversedCoverHeight];
+			return {
+				width: width + "px",
+				height: height + "px",
+				transform: `translate(-50%, -50%) rotate(${actualRotate.value}deg)`
+			};
+		});
+		let stopInertialAnimate = null;
+		onBeforeUnmount(() => {
+			stopInertialAnimate?.();
+		});
+		const [onTouchStart, onTouchMove, onTouchEnd] = useDragPinch({
+			onOffset(offsetX, offsetY) {
+				const [, , focusWidth, focusHeight] = focusRect.value;
+				if (imgWidth.value !== focusWidth) {
+					if (imgLeft.value > 0 || imgLeft.value < focusWidth - imgWidth.value) offsetX /= bounceCoeff;
+					imgLeft.value += offsetX;
+				}
+				if (imgHeight.value !== focusHeight) {
+					if (imgTop.value > 0 || imgTop.value < focusHeight - imgHeight.value) offsetY /= bounceCoeff;
+					imgTop.value += offsetY;
+				}
+			},
+			onScale(originX, originY, scale) {
+				const [focusLeft, focusTop, focusWidth, focusHeight] = focusRect.value;
+				let offsetScaleX = imgWidth.value * scale;
+				let offsetScaleY = imgHeight.value * scale;
+				if (imgWidth.value < focusWidth || imgHeight.value < focusHeight) {
+					offsetScaleX /= bounceCoeff;
+					offsetScaleY /= bounceCoeff;
+				} else if (imgWidth.value > reversedCoverSize.value[0] * maxScale && offsetScaleX > 0) {
+					offsetScaleX = 0;
+					offsetScaleY = 0;
+				}
+				const nextWidth = imgWidth.value + offsetScaleX;
+				const nextHeight = imgHeight.value + offsetScaleY;
+				const originScaleX = (originX - focusLeft - imgLeft.value) / imgWidth.value;
+				const originScaleY = (originY - focusTop - imgTop.value) / imgHeight.value;
+				imgLeft.value += (imgWidth.value - nextWidth) * originScaleX;
+				imgTop.value += (imgHeight.value - nextHeight) * originScaleY;
+				imgWidth.value = nextWidth;
+				imgHeight.value = nextHeight;
+			},
+			onCapture() {
+				isCaptured.value = true;
+				stopInertialAnimate?.();
+			},
+			onRelease(v) {
+				const [, , focusWidth, focusHeight] = focusRect.value;
+				const currWidth = imgWidth.value;
+				const currHeight = imgHeight.value;
+				const tooSmall = currWidth < focusWidth || currHeight < focusHeight;
+				const tooBig = currWidth > reversedCoverSize.value[0] * maxScale;
+				if (tooSmall || tooBig) {
+					const [width, height] = tooSmall ? getAspectFillSize(currWidth, currHeight, focusWidth, focusHeight) : reversedCoverSize.value.map((item) => item * maxScale);
+					imgWidth.value = width;
+					imgHeight.value = height;
+					imgLeft.value += (currWidth - width) / 2;
+					imgTop.value += (currHeight - height) / 2;
+				}
+				const overLeft = imgLeft.value > 0;
+				const overRight = imgLeft.value < focusWidth - imgWidth.value;
+				if (overLeft) imgLeft.value = 0;
+				else if (overRight) imgLeft.value = focusWidth - imgWidth.value;
+				const overTop = imgTop.value > 0;
+				const overBottom = imgTop.value < focusHeight - imgHeight.value;
+				if (overTop) imgTop.value = 0;
+				else if (overBottom) imgTop.value = focusHeight - imgHeight.value;
+				isCaptured.value = false;
+				if (tooSmall || overLeft || overRight || overTop || overBottom) return;
+				if (v.x === 0 && v.y === 0) return;
+				inInertia.value = true;
+				const animateList = [[
+					v.x,
+					imgLeft,
+					focusWidth,
+					imgWidth.value
+				], [
+					v.y,
+					imgTop,
+					focusHeight,
+					imgHeight.value
+				]].filter(([v]) => v !== 0).map(([v, translate, boxSize, elSize]) => {
+					const animate = createInertialAnimate(v, {
+						update(value) {
+							let next = translate.value + value;
+							const overStart = next > 0;
+							const overEnd = next < boxSize - elSize;
+							if (overStart) next = 0;
+							else if (overEnd) next = boxSize - elSize;
+							translate.value = next;
+							if (overStart || overEnd) {
+								animate.stop();
+								tryFinish();
+							}
+						},
+						complete() {
+							tryFinish();
+						}
+					});
+					animate.play();
+					return animate;
+				});
+				const tryFinish = () => {
+					if (animateList.every((animate) => !animate.isAnimating())) inInertia.value = false;
+				};
+				stopInertialAnimate = () => {
+					animateList.forEach((animate) => {
+						animate.stop();
+					});
+					inInertia.value = false;
+					stopInertialAnimate = null;
+				};
+			}
+		});
+		const onPointerDown = usePointerDown(onTouchStart, onTouchMove, onTouchEnd);
+		let canvas = null;
+		let context = null;
+		const cropImage = async () => {
+			return new Promise((resolve, reject) => {
+				const [imgOrigW, imgOrigH] = imageOrigSize.value;
+				const [, , focusWidth, focusHeight] = focusRect.value;
+				const rotate = actualRotate.value % 360;
+				let scale = (rotate % 180 !== 0 ? imgOrigH : imgOrigW) / imgWidth.value;
+				let canvasW = focusWidth * scale;
+				let canvasH = focusHeight * scale;
+				let customScale = 1;
+				if (props.beforeCrop) customScale = props.beforeCrop(canvasW, canvasH);
+				canvasW *= customScale;
+				canvasH *= customScale;
+				scale *= customScale;
+				const imgL = imgLeft.value * scale;
+				const imgT = imgTop.value * scale;
+				const imgW = imgOrigW * customScale;
+				const imgH = imgOrigH * customScale;
+				let tx = 0;
+				let ty = 0;
+				switch (rotate) {
+					case 0:
+						tx = imgL;
+						ty = imgT;
+						break;
+					case -90:
+						tx = (imgW + imgT) * -1;
+						ty = imgL;
+						break;
+					case -180:
+						tx = (imgW + imgL) * -1;
+						ty = (imgH + imgT) * -1;
+						break;
+					case -270:
+						tx = imgT;
+						ty = (imgH + imgL) * -1;
+						break;
+				}
+				const drawCanvas = (image) => {
+					if (!canvas) canvas = document.createElement("canvas");
+					if (!context) context = canvas.getContext("2d");
+					if (!context) {
+						reject();
+						return;
+					}
+					canvas.width = canvasW;
+					canvas.height = canvasH;
+					context.clearRect(0, 0, canvasW, canvasH);
+					context.save();
+					context.rotate(rotate * (Math.PI / 180));
+					context.translate(tx, ty);
+					context.scale(customScale, customScale);
+					context.drawImage(image, 0, 0, imgOrigW, imgOrigH, 0, 0, imgOrigW, imgOrigH);
+					context.restore();
+					resolve({
+						dataURL: canvas.toDataURL(props.type, props.quality),
+						width: canvasW,
+						height: canvasH
+					});
+				};
+				loadImage(props.url).then(drawCanvas).catch(reject);
+			});
+		};
+		const onCancel = () => {
+			props.cancel?.();
+			close();
+		};
+		const onReset = () => {
+			const current = Math.abs(rotate.value);
+			const integer = Math.floor(current / 360) * 360;
+			rotate.value = (integer + (current % 360 > 180 ? 360 : 0)) * -1;
+		};
+		const onRotate = () => {
+			rotate.value -= 90;
+		};
+		const isCropping = ref(false);
+		const onConfirm = () => {
+			if (isCropping.value) return;
+			isCropping.value = true;
+			cropImage().then(({ dataURL, width, height }) => {
+				close();
+				props.success?.(dataURL, {
+					width,
+					height
+				});
+			}).catch((err) => {
+				logError(err);
+				props.fail?.(err);
+			}).finally(() => {
+				isCropping.value = false;
+				props.complete?.();
+			});
+		};
+		const cropImageClass = computed(() => {
+			return [bem.b()];
+		});
+		__expose({});
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(popup_default, {
+				effect: "full-fade",
+				visible: __props.visible,
+				overlay: false,
+				onVisibleHook
+			}, {
+				default: withCtx(() => [createElementVNode("div", { class: normalizeClass(cropImageClass.value) }, [
+					createElementVNode("div", {
+						class: normalizeClass(unref(bem).e("sensor")),
+						onPointerdown: _cache[0] || (_cache[0] = (...args) => unref(onPointerDown) && unref(onPointerDown)(...args)),
+						onTouchstart: _cache[1] || (_cache[1] = (...args) => unref(onTouchStart) && unref(onTouchStart)(...args)),
+						onTouchmove: _cache[2] || (_cache[2] = withModifiers((...args) => unref(onTouchMove) && unref(onTouchMove)(...args), ["stop", "prevent"])),
+						onTouchend: _cache[3] || (_cache[3] = (...args) => unref(onTouchEnd) && unref(onTouchEnd)(...args)),
+						onTouchcancel: _cache[4] || (_cache[4] = (...args) => unref(onTouchEnd) && unref(onTouchEnd)(...args))
+					}, [createElementVNode("div", {
+						class: normalizeClass(unref(bem).e("focus")),
+						style: normalizeStyle(focusStyle.value)
+					}, [createElementVNode("div", {
+						class: normalizeClass(unref(bem).e("puppet")),
+						style: normalizeStyle(puppetStyle.value)
+					}, [imageOrigSize.value[0] > 0 ? (openBlock(), createElementBlock("img", {
+						key: 0,
+						src: __props.url,
+						class: normalizeClass(unref(bem).e("image")),
+						style: normalizeStyle(imageStyle.value)
+					}, null, 14, _hoisted_1)) : createCommentVNode("v-if", true)], 6)], 6)], 34),
+					createElementVNode("div", {
+						class: normalizeClass(unref(bem).e("mask")),
+						style: normalizeStyle(maskStyle.value)
+					}, null, 6),
+					createElementVNode("div", { class: normalizeClass(unref(bem).e("toolbar")) }, [
+						createVNode(button_default, {
+							class: normalizeClass(unref(bem).e("cancel")),
+							size: "small",
+							variant: "link",
+							color: "white",
+							block: "",
+							onClick: onCancel
+						}, {
+							default: withCtx(() => [createTextVNode(toDisplayString(__props.cancelText || unref(t)("cancel")), 1)]),
+							_: 1
+						}, 8, ["class"]),
+						createVNode(button_default, {
+							size: "small",
+							variant: "link",
+							color: "white",
+							block: "",
+							onClick: onReset
+						}, {
+							default: withCtx(() => [createVNode(unref(Undo), { class: normalizeClass(unref(bem).e("action-icon")) }, null, 8, ["class"])]),
+							_: 1
+						}),
+						createVNode(button_default, {
+							size: "small",
+							variant: "link",
+							color: "white",
+							block: "",
+							onClick: onRotate
+						}, {
+							default: withCtx(() => [createVNode(unref(RotateLeft), { class: normalizeClass(unref(bem).e("action-icon")) }, null, 8, ["class"])]),
+							_: 1
+						}),
+						createVNode(button_default, {
+							class: normalizeClass(unref(bem).e("confirm")),
+							size: "small",
+							block: "",
+							onClick: onConfirm
+						}, {
+							default: withCtx(() => [createTextVNode(toDisplayString(__props.confirmText || unref(t)("confirm")), 1)]),
+							_: 1
+						}, 8, ["class"])
+					], 2)
+				], 2), isCropping.value ? (openBlock(), createElementBlock("div", {
+					key: 0,
+					class: normalizeClass(unref(bem).e("loading"))
+				}, [createVNode(loading_default)], 2)) : createCommentVNode("v-if", true)]),
+				_: 1
+			}, 8, ["visible"]);
+		};
+	}
+});
+//#endregion
+export { crop_image_default as default };

package/components/crop-image/imperative.d.ts

@@ -0,0 +1,10 @@
+import { type CropImageProps } from './common';
+export type CropImageOptions = Omit<CropImageProps, 'url'> & Required<Pick<CropImageProps, 'url'>>;
+export interface CropImageShowFunction {
+    (options?: CropImageOptions): void;
+}
+export type CropImageFunction = CropImageShowFunction & {
+    hide: () => void;
+};
+export declare function createCropImage(defaultOptions?: CropImageOptions): CropImageFunction;
+export declare const cropImage: CropImageFunction;

package/components/crop-image/imperative.js

@@ -0,0 +1,20 @@
+import { createImperativeComponent } from "../../utils/createImperativeComponent.js";
+import crop_image_default from "./crop-image.js";
+//#region packages/sard/components/crop-image/imperative.ts
+function createCropImage(defaultOptions) {
+	const imperative = createImperativeComponent(crop_image_default, defaultOptions);
+	const show = (options) => {
+		imperative.show(options);
+	};
+	const hide = () => {
+		imperative.hide();
+	};
+	const cropImage = (options) => {
+		show(options);
+	};
+	cropImage.hide = hide;
+	return cropImage;
+}
+const cropImage = createCropImage();
+//#endregion
+export { createCropImage, cropImage };

package/components/crop-image/index.css

@@ -0,0 +1 @@
+.s-crop-image{position:fixed;top:0;left:0;width:100%;height:100%;background-color:var(--s-black);touch-action:none;-webkit-user-select:none;user-select:none}.s-crop-image__sensor{position:absolute;width:100%;height:100%;direction:ltr}.s-crop-image__focus{position:absolute;transition:transform var(--s-duration-fast);pointer-events:none}.s-crop-image__puppet{position:relative;transform-origin:top left;transition:transform var(--s-duration-fast)}.s-crop-image__image{position:absolute;width:100%;height:100%;left:50%;top:50%;max-width:none}.s-crop-image__mask{position:absolute;z-index:10;box-shadow:0 0 0 9999vh rgba(45,45,45,.8);pointer-events:none}.s-crop-image__toolbar{position:absolute;left:16px;right:16px;bottom:calc(var(--s-safe-bottom) + 16px);z-index:20;display:flex;justify-content:center;align-items:center}.s-crop-image__toolbar .s-crop-image__cancel{font-size:var(--s-font-size);font-weight:var(--s-font-weight-bold)}.s-crop-image__toolbar .s-crop-image__confirm{font-weight:var(--s-font-weight-bold)}.s-crop-image__toolbar .s-crop-image__action-icon{font-size:var(--s-font-size-xl)}.s-crop-image__loading{position:absolute;top:0;left:0;z-index:30;display:flex;width:100%;height:100%;justify-content:center;align-items:center;font-size:30px;color:var(--s-white);background:var(--s-overlay-illegible);touch-action:none}

package/components/crop-image/index.d.ts

@@ -0,0 +1,6 @@
+import { type EnhancedComponent } from '../../utils';
+import _CropImage from './crop-image.vue';
+export declare const CropImage: EnhancedComponent<typeof _CropImage>;
+export default CropImage;
+export type { CropImageProps, CropImageSlots, CropImageEmits, CropImageExpose } from './common';
+export * from './imperative';

package/components/crop-image/index.js

@@ -0,0 +1,8 @@
+import { enhanceComponent } from "../../utils/component.js";
+import "../../utils/index.js";
+import crop_image_default from "./crop-image.js";
+import { createCropImage, cropImage } from "./imperative.js";
+//#region packages/sard/components/crop-image/index.ts
+const CropImage = enhanceComponent(crop_image_default);
+//#endregion
+export { CropImage, CropImage as default, createCropImage, cropImage };

package/components/date-strip/common.d.ts

@@ -0,0 +1,28 @@
+import { type DefaultProps } from '../config';
+import { type CalendarDay, type CalendarType } from '../calendar';
+export interface DateStripProps {
+    type?: CalendarType;
+    modelValue?: Date | Date[] | string | string[];
+    min?: Date;
+    max?: Date;
+    currentDate?: Date;
+    disabledDate?: (date: Date) => boolean;
+    maxDays?: number;
+    overMaxDays?: () => void;
+    formatter?: (day: CalendarDay) => void;
+    filter?: (date: Date) => boolean;
+    allowSameDay?: boolean;
+    valueFormat?: string;
+    startDateText?: string;
+    endDateText?: string;
+    sameDateText?: string;
+    showLunar?: boolean;
+}
+export declare const defaultDateStripProps: DefaultProps<DateStripProps>;
+export interface DateStripEmits {
+    (e: 'update:modelValue', value: Date | Date[] | string | string[]): void;
+    (e: 'change', value: Date | Date[] | string | string[]): void;
+}
+export declare const getMinDate: (date?: Date) => Date;
+export declare const getMaxDate: (date?: Date) => Date;
+export declare const sortDates: (dates: Date[]) => Date[];

package/components/date-strip/common.js

@@ -0,0 +1,21 @@
+//#region packages/sard/components/date-strip/common.ts
+const defaultDateStripProps = {
+	type: "single",
+	maxDays: Number.MAX_SAFE_INTEGER,
+	showLunar: false
+};
+const getMinDate = (date = /* @__PURE__ */ new Date()) => {
+	const start = new Date(date);
+	start.setDate(start.getDate() - 7);
+	return start;
+};
+const getMaxDate = (date = /* @__PURE__ */ new Date()) => {
+	const end = new Date(date);
+	end.setDate(end.getDate() + 7);
+	return end;
+};
+const sortDates = (dates) => {
+	return dates.sort((a, b) => a.getTime() - b.getTime());
+};
+//#endregion
+export { defaultDateStripProps, getMaxDate, getMinDate, sortDates };

package/components/date-strip/date-strip.d.ts

@@ -0,0 +1,28 @@
+import { type DateStripProps } from './common';
+import { type CalendarDay } from '../calendar';
+declare const __VLS_export: import("vue").DefineComponent<DateStripProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    change: (value: string | string[] | Date | Date[]) => any;
+    "update:modelValue": (value: string | string[] | Date | Date[]) => any;
+}, string, import("vue").PublicProps, Readonly<DateStripProps> & Readonly<{
+    onChange?: ((value: string | string[] | Date | Date[]) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: string | string[] | Date | Date[]) => any) | undefined;
+}>, {
+    filter: (date: Date) => boolean;
+    min: Date;
+    max: Date;
+    type: import(".").CalendarType;
+    modelValue: Date | Date[] | string | string[];
+    currentDate: Date;
+    disabledDate: (date: Date) => boolean;
+    maxDays: number;
+    overMaxDays: () => void;
+    formatter: (day: CalendarDay) => void;
+    allowSameDay: boolean;
+    valueFormat: string;
+    startDateText: string;
+    endDateText: string;
+    sameDateText: string;
+    showLunar: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;