@antdv-next/mobile 0.0.0-stage → 0.1.1

package/dist/tour/Tour.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,596 @@
+import Portal_default from "../_base/Portal.js";
+import { genId, isRenderable } from "../_util/index.js";
+import { nextZIndex } from "../_util/hooks/useZIndex.js";
+import { useControlled } from "../_util/hooks/useControlled.js";
+import { useEventListener } from "../_util/hooks/useEventListener.js";
+import { useLockScroll } from "../_util/hooks/useLockScroll.js";
+import RenderNode_default from "../_util/RenderNode.js";
+import { flattenChildren } from "../_util/vnode.js";
+import { useLocale } from "../locale/index.js";
+import { computeTourPosition, isInViewport } from "./position.js";
+import TourActions_default from "./TourActions.js";
+import "../style/index2.js";
+import './style/index.css';/* empty css            */
+import { Fragment, Transition, computed, createBlock, createCommentVNode, createElementBlock, createElementVNode, createVNode, defineComponent, guardReactiveProps, h, mergeProps, nextTick, normalizeClass, normalizeProps, normalizeStyle, onBeforeUnmount, onMounted, openBlock, ref, renderList, renderSlot, shallowRef, unref, useSlots, vShow, watch, withCtx, withDirectives } from "vue";
+import { CloseOutlined } from "@antdv-next/icons";
+// src/tour/Tour.vue?vue&type=script&setup=true&lang.ts
+var _hoisted_1 = ["dir"];
+var _hoisted_2 = ["id"];
+var _hoisted_3 = [
+	"x",
+	"y",
+	"rx",
+	"width",
+	"height"
+];
+var _hoisted_4 = ["mask"];
+var _hoisted_5 = [
+	"x",
+	"y",
+	"width",
+	"height"
+];
+var _hoisted_6 = ["aria-modal"];
+var _hoisted_7 = {
+	key: 0,
+	class: "am-tour-arrow"
+};
+var _hoisted_8 = ["aria-label"];
+var ARROW_GAP = 12;
+var PLAIN_GAP = 8;
+/** minimal distance of the panel to the screen edges */
+var SCREEN_PADDING = 16;
+var Tour_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComponent({
+	name: "AmTour",
+	inheritAttrs: false,
+	__name: "Tour",
+	props: {
+		open: {
+			type: Boolean,
+			default: void 0
+		},
+		defaultOpen: {
+			type: Boolean,
+			default: false
+		},
+		current: { default: void 0 },
+		defaultCurrent: { default: 0 },
+		steps: { default: () => [] },
+		type: { default: "default" },
+		mask: {
+			type: [Boolean, Object],
+			default: true
+		},
+		arrow: {
+			type: [Boolean, Object],
+			default: true
+		},
+		placement: {},
+		gap: {},
+		disabledInteraction: {
+			type: Boolean,
+			default: false
+		},
+		scrollIntoViewOptions: {
+			type: [Boolean, Object],
+			default: true
+		},
+		indicatorsRender: {},
+		actionsRender: {},
+		closable: {
+			type: [Boolean, Object],
+			default: void 0
+		},
+		closeIcon: {
+			type: [
+				Object,
+				String,
+				Number,
+				Boolean,
+				null,
+				Array,
+				Function
+			],
+			default: void 0
+		},
+		keyboard: {
+			type: Boolean,
+			default: true
+		},
+		lockScroll: {
+			type: Boolean,
+			default: true
+		},
+		zIndex: {},
+		getPopupContainer: {
+			type: [Function, Boolean],
+			default: void 0
+		},
+		rootClass: {},
+		classes: {},
+		styles: {}
+	},
+	emits: [
+		"update:open",
+		"update:current",
+		"change",
+		"close",
+		"finish"
+	],
+	setup(__props, { expose: __expose, emit: __emit }) {
+		const props = __props;
+		const emit = __emit;
+		const slots = useSlots();
+		/** distance between the highlighted area and the panel, with / without arrow */
+		const DEFAULT_SCROLL_OPTIONS = {
+			block: "center",
+			inline: "center"
+		};
+		const commonLocale = useLocale("common");
+		const rootRef = ref();
+		const panelRef = ref();
+		const maskId = genId("am-tour-mask");
+		const [innerOpen, setOpen] = useControlled(props, "open", {
+			defaultValue: () => props.defaultOpen,
+			onChange: (value, prev) => {
+				if (value !== prev) emit("update:open", value);
+			}
+		});
+		/** set while `current` is reset by the component itself (re-open), which is not a user change */
+		let silent = false;
+		const [current, setCurrent] = useControlled(props, "current", {
+			defaultValue: () => props.defaultCurrent,
+			onChange: (value) => {
+				if (silent) return;
+				emit("update:current", value);
+				emit("change", value);
+			}
+		});
+		const total = computed(() => props.steps.length);
+		/** like PC: nothing is shown while `current` is out of range */
+		const open = computed(() => !!innerOpen.value && current.value >= 0 && current.value < total.value);
+		const step = computed(() => props.steps[current.value] ?? {});
+		const stepInfo = computed(() => ({
+			step: step.value,
+			index: current.value
+		}));
+		const isLast = computed(() => current.value === total.value - 1);
+		const mergedType = computed(() => step.value.type ?? props.type);
+		const mergedMask = computed(() => step.value.mask ?? props.mask);
+		const showMask = computed(() => !!mergedMask.value);
+		const maskConfig = computed(() => typeof mergedMask.value === "object" ? mergedMask.value : void 0);
+		function getClosableConfig(closable, closeIcon, preset) {
+			const config = closable !== null && typeof closable === "object" ? closable : void 0;
+			if (closable === false || closeIcon === false && !config?.closeIcon) return null;
+			const icon = typeof closeIcon !== "boolean" ? closeIcon : void 0;
+			if (config) return {
+				...config,
+				closeIcon: config.closeIcon ?? icon
+			};
+			return preset || closable || closeIcon ? { closeIcon: icon } : "empty";
+		}
+		const mergedClosable = computed(() => {
+			const stepConfig = getClosableConfig(step.value.closable, step.value.closeIcon, false);
+			if (stepConfig !== "empty") return stepConfig;
+			const rootConfig = getClosableConfig(props.closable, props.closeIcon, true);
+			return rootConfig === "empty" ? {} : rootConfig;
+		});
+		const mergedClasses = computed(() => ({
+			...props.classes,
+			...step.value.classes
+		}));
+		const mergedStyles = computed(() => ({
+			...props.styles,
+			...step.value.styles
+		}));
+		function pickNode(slot, node) {
+			const children = slot ? flattenChildren(slot(stepInfo.value)) : [];
+			return children.length ? children : node;
+		}
+		const content = computed(() => ({
+			cover: pickNode(slots.coverRender, step.value.cover),
+			title: pickNode(slots.titleRender, step.value.title),
+			description: pickNode(slots.descriptionRender, step.value.description)
+		}));
+		function resolveTarget(target) {
+			let value = typeof target === "function" ? target() : unref(target);
+			value = unref(value);
+			if (value && value.$el) value = value.$el;
+			return value && value.nodeType === 1 ? value : null;
+		}
+		/** the layer is only teleported on the client, once the tour has been opened */
+		const mounted = ref(false);
+		const rendered = ref(false);
+		const container = shallowRef();
+		const zIndex = ref(props.zIndex);
+		const targetEl = shallowRef(null);
+		/** highlighted area (target + gap), relative to the layer; `null` without a target */
+		const hole = ref(null);
+		const position = ref({
+			left: 0,
+			top: 0,
+			placement: "center",
+			arrowOffset: 0,
+			arrow: false
+		});
+		/** moves of the highlighted area / panel are animated right after a step change only (not while scrolling) */
+		const animating = ref(false);
+		let animateTimer;
+		const wantArrow = computed(() => !!(step.value.arrow ?? props.arrow));
+		const showArrow = computed(() => wantArrow.value && !!hole.value && position.value.arrow);
+		const side = computed(() => /^(top|bottom|left|right|center)/.exec(position.value.placement)[1]);
+		function measure() {
+			const root = rootRef.value;
+			const panel = panelRef.value;
+			if (!root || !panel || !open.value) return;
+			const el = resolveTarget(step.value.target);
+			targetEl.value = el;
+			const rootRect = root.getBoundingClientRect();
+			const rootStyle = window.getComputedStyle(root);
+			const viewport = {
+				width: rootRect.width || document.documentElement.clientWidth || window.innerWidth,
+				height: rootRect.height || document.documentElement.clientHeight || window.innerHeight
+			};
+			let rect = null;
+			if (el) {
+				const offset = props.gap?.offset ?? 6;
+				const [offsetX, offsetY] = Array.isArray(offset) ? offset : [offset, offset];
+				const targetRect = el.getBoundingClientRect();
+				rect = {
+					left: targetRect.left - rootRect.left - offsetX,
+					top: targetRect.top - rootRect.top - offsetY,
+					width: targetRect.width + offsetX * 2,
+					height: targetRect.height + offsetY * 2
+				};
+			}
+			const radius = props.gap?.radius;
+			hole.value = rect && {
+				...rect,
+				radius: typeof radius === "number" && !Number.isNaN(radius) ? radius : 2
+			};
+			position.value = computeTourPosition(rect, {
+				width: panel.offsetWidth,
+				height: panel.offsetHeight
+			}, {
+				placement: step.value.placement ?? props.placement,
+				gap: wantArrow.value ? ARROW_GAP : PLAIN_GAP,
+				padding: SCREEN_PADDING,
+				viewport,
+				safeTop: Number.parseFloat(rootStyle.paddingTop) || 0,
+				safeBottom: Number.parseFloat(rootStyle.paddingBottom) || 0
+			});
+		}
+		/** scroll the target into view (when needed), then measure */
+		async function sync() {
+			await nextTick();
+			if (!open.value) return;
+			const el = resolveTarget(step.value.target);
+			const options = step.value.scrollIntoViewOptions ?? props.scrollIntoViewOptions;
+			if (el && options !== false && typeof el.scrollIntoView === "function" && !isInViewport(el)) el.scrollIntoView(options === true ? DEFAULT_SCROLL_OPTIONS : options);
+			measure();
+		}
+		async function prepare() {
+			const { getPopupContainer } = props;
+			container.value = getPopupContainer === false ? false : getPopupContainer?.(resolveTarget(step.value.target) ?? document.body);
+			zIndex.value = props.zIndex ?? nextZIndex();
+			rendered.value = true;
+			await sync();
+		}
+		onMounted(() => {
+			mounted.value = true;
+			if (open.value) prepare();
+		});
+		watch(open, (value) => {
+			if (!value) return;
+			if (props.current === void 0 && current.value !== 0) {
+				silent = true;
+				setCurrent(0);
+				silent = false;
+			}
+			if (mounted.value) prepare();
+		});
+		watch([current, () => props.steps], () => {
+			if (!open.value || !rendered.value) return;
+			animating.value = true;
+			clearTimeout(animateTimer);
+			animateTimer = setTimeout(() => {
+				animating.value = false;
+			}, 350);
+			sync();
+		});
+		watch(() => [
+			props.placement,
+			props.arrow,
+			props.gap,
+			props.mask,
+			props.type
+		], () => {
+			if (open.value) nextTick(measure);
+		});
+		watch(() => props.zIndex, (value) => {
+			if (value !== void 0) zIndex.value = value;
+		});
+		useEventListener("resize", measure, { passive: true });
+		useEventListener("orientationchange", measure, { passive: true });
+		useEventListener("scroll", measure, {
+			passive: true,
+			capture: true
+		});
+		let resizeObserver;
+		watch([panelRef, targetEl], ([panel, target]) => {
+			resizeObserver?.disconnect();
+			if (typeof ResizeObserver === "undefined" || !panel) return;
+			resizeObserver = new ResizeObserver(() => measure());
+			resizeObserver.observe(panel);
+			if (target) resizeObserver.observe(target);
+		}, { flush: "post" });
+		onBeforeUnmount(() => {
+			resizeObserver?.disconnect();
+			clearTimeout(animateTimer);
+		});
+		useLockScroll(rootRef, () => open.value && props.lockScroll && showMask.value);
+		function close() {
+			emit("close", current.value);
+			setOpen(false);
+		}
+		function onPrev(event) {
+			const { prevButtonProps } = step.value;
+			if (current.value > 0) setCurrent(current.value - 1);
+			prevButtonProps?.onClick?.(event);
+		}
+		function onNext(event) {
+			const { nextButtonProps } = step.value;
+			if (isLast.value) {
+				close();
+				emit("finish");
+			} else setCurrent(current.value + 1);
+			nextButtonProps?.onClick?.(event);
+		}
+		useEventListener("keydown", (event) => {
+			if (!open.value || !props.keyboard) return;
+			const target = event.target;
+			if (target && (/^(?:input|textarea)$/i.test(target.tagName) || target.isContentEditable)) return;
+			if (event.key === "Escape" && mergedClosable.value) {
+				event.preventDefault();
+				close();
+			} else if (event.key === "ArrowLeft" && current.value > 0) {
+				event.preventDefault();
+				setCurrent(current.value - 1);
+			} else if (event.key === "ArrowRight" && current.value < total.value - 1) {
+				event.preventDefault();
+				setCurrent(current.value + 1);
+			}
+		});
+		function onAfterLeave() {
+			rendered.value = false;
+			hole.value = null;
+			targetEl.value = null;
+		}
+		/** default prev / next buttons, handed to `actionsRender` as `originNode` */
+		const originNode = computed(() => h(TourActions_default, {
+			current: current.value,
+			total: total.value,
+			type: mergedType.value,
+			prevButtonProps: step.value.prevButtonProps,
+			nextButtonProps: step.value.nextButtonProps,
+			onPrev,
+			onNext
+		}, {
+			prevButton: slots.prevButton,
+			nextButton: slots.nextButton
+		}));
+		const actionsInfo = computed(() => ({
+			current: current.value,
+			total: total.value
+		}));
+		const actionsSlotProps = computed(() => ({
+			originNode: originNode.value,
+			...actionsInfo.value
+		}));
+		function renderActions() {
+			return props.actionsRender ? props.actionsRender(originNode.value, actionsInfo.value) : originNode.value;
+		}
+		function renderIndicators() {
+			return props.indicatorsRender?.(current.value, total.value);
+		}
+		const holeStyle = computed(() => hole.value && {
+			left: `${hole.value.left}px`,
+			top: `${hole.value.top}px`,
+			width: `${hole.value.width}px`,
+			height: `${hole.value.height}px`,
+			borderRadius: `${hole.value.radius}px`
+		});
+		/** the four areas around the hole that swallow taps */
+		const covers = computed(() => {
+			const area = hole.value;
+			if (!area) return [{
+				x: 0,
+				y: 0,
+				width: "100%",
+				height: "100%"
+			}];
+			const right = area.left + area.width;
+			const bottom = area.top + area.height;
+			return [
+				{
+					x: 0,
+					y: 0,
+					width: "100%",
+					height: Math.max(area.top, 0)
+				},
+				{
+					x: 0,
+					y: 0,
+					width: Math.max(area.left, 0),
+					height: "100%"
+				},
+				{
+					x: 0,
+					y: Math.max(bottom, 0),
+					width: "100%",
+					height: `calc(100% - ${Math.max(bottom, 0)}px)`
+				},
+				{
+					x: Math.max(right, 0),
+					y: 0,
+					width: `calc(100% - ${Math.max(right, 0)}px)`,
+					height: "100%"
+				}
+			];
+		});
+		const panelStyle = computed(() => [{
+			left: `${position.value.left}px`,
+			top: `${position.value.top}px`,
+			"--am-tour-arrow-offset": `${position.value.arrowOffset}px`
+		}, step.value.style]);
+		__expose({ updatePosition: measure });
+		return (_ctx, _cache) => {
+			return mounted.value && rendered.value ? (openBlock(), createBlock(unref(Portal_default), {
+				key: 0,
+				"get-container": container.value
+			}, {
+				default: withCtx(({ theme }) => [createVNode(Transition, {
+					name: "am-fade",
+					appear: "",
+					onAfterLeave,
+					persisted: ""
+				}, {
+					default: withCtx(() => [withDirectives(createElementVNode("div", mergeProps({
+						ref_key: "rootRef",
+						ref: rootRef
+					}, _ctx.$attrs, {
+						class: ["am-tour", [
+							theme.class,
+							{ "am-tour-animated": animating.value },
+							__props.rootClass,
+							mergedClasses.value.root
+						]],
+						style: [
+							theme.style,
+							{ zIndex: zIndex.value },
+							mergedStyles.value.root
+						],
+						dir: theme.dir
+					}), [
+						showMask.value ? (openBlock(), createElementBlock("svg", {
+							key: 0,
+							class: normalizeClass(["am-tour-mask", mergedClasses.value.mask]),
+							style: normalizeStyle([maskConfig.value?.style, mergedStyles.value.mask]),
+							"aria-hidden": "true"
+						}, [
+							createElementVNode("defs", null, [createElementVNode("mask", { id: unref(maskId) }, [_cache[0] || (_cache[0] = createElementVNode("rect", {
+								x: "0",
+								y: "0",
+								width: "100%",
+								height: "100%",
+								fill: "white"
+							}, null, -1)), hole.value ? (openBlock(), createElementBlock("rect", {
+								key: 0,
+								class: "am-tour-mask-hole",
+								x: hole.value.left,
+								y: hole.value.top,
+								rx: hole.value.radius,
+								width: Math.max(hole.value.width, 0),
+								height: Math.max(hole.value.height, 0),
+								fill: "black"
+							}, null, 8, _hoisted_3)) : createCommentVNode("", true)], 8, _hoisted_2)]),
+							createElementVNode("rect", {
+								class: "am-tour-mask-fill",
+								x: "0",
+								y: "0",
+								width: "100%",
+								height: "100%",
+								mask: `url(#${unref(maskId)})`,
+								style: normalizeStyle(maskConfig.value?.color ? { fill: maskConfig.value.color } : void 0)
+							}, null, 12, _hoisted_4),
+							(openBlock(true), createElementBlock(Fragment, null, renderList(covers.value, (cover, index) => {
+								return openBlock(), createElementBlock("rect", {
+									key: index,
+									class: "am-tour-mask-cover",
+									x: cover.x,
+									y: cover.y,
+									width: cover.width,
+									height: cover.height
+								}, null, 8, _hoisted_5);
+							}), 128))
+						], 6)) : createCommentVNode("", true),
+						holeStyle.value ? (openBlock(), createElementBlock("div", {
+							key: 1,
+							class: normalizeClass(["am-tour-target-placeholder", { "am-tour-target-disabled": __props.disabledInteraction }]),
+							style: normalizeStyle(holeStyle.value)
+						}, null, 6)) : createCommentVNode("", true),
+						createElementVNode("div", {
+							ref_key: "panelRef",
+							ref: panelRef,
+							class: normalizeClass(["am-tour-panel", [
+								`am-tour-placement-${position.value.placement}`,
+								`am-tour-side-${side.value}`,
+								{ "am-tour-primary": mergedType.value === "primary" },
+								step.value.class
+							]]),
+							style: normalizeStyle(panelStyle.value),
+							role: "dialog",
+							"aria-modal": showMask.value
+						}, [showArrow.value ? (openBlock(), createElementBlock("span", _hoisted_7)) : createCommentVNode("", true), createElementVNode("div", {
+							class: normalizeClass(["am-tour-section", mergedClasses.value.section]),
+							style: normalizeStyle(mergedStyles.value.section)
+						}, [
+							mergedClosable.value ? (openBlock(), createElementBlock("button", {
+								key: 0,
+								type: "button",
+								class: normalizeClass(["am-tour-close", mergedClasses.value.close]),
+								style: normalizeStyle(mergedStyles.value.close),
+								"aria-label": unref(commonLocale).close,
+								onClick: close
+							}, [renderSlot(_ctx.$slots, "closeIcon", normalizeProps(guardReactiveProps(stepInfo.value)), () => [unref(isRenderable)(mergedClosable.value.closeIcon) ? (openBlock(), createBlock(unref(RenderNode_default), {
+								key: 0,
+								node: mergedClosable.value.closeIcon
+							}, null, 8, ["node"])) : (openBlock(), createBlock(unref(CloseOutlined), { key: 1 }))])], 14, _hoisted_8)) : createCommentVNode("", true),
+							unref(isRenderable)(content.value.cover) ? (openBlock(), createElementBlock("div", {
+								key: 1,
+								class: normalizeClass(["am-tour-cover", mergedClasses.value.cover]),
+								style: normalizeStyle(mergedStyles.value.cover)
+							}, [createVNode(unref(RenderNode_default), { node: content.value.cover }, null, 8, ["node"])], 6)) : createCommentVNode("", true),
+							unref(isRenderable)(content.value.title) ? (openBlock(), createElementBlock("div", {
+								key: 2,
+								class: normalizeClass(["am-tour-header", mergedClasses.value.header]),
+								style: normalizeStyle(mergedStyles.value.header)
+							}, [createElementVNode("div", {
+								class: normalizeClass(["am-tour-title", mergedClasses.value.title]),
+								style: normalizeStyle(mergedStyles.value.title)
+							}, [createVNode(unref(RenderNode_default), { node: content.value.title }, null, 8, ["node"])], 6)], 6)) : createCommentVNode("", true),
+							unref(isRenderable)(content.value.description) ? (openBlock(), createElementBlock("div", {
+								key: 3,
+								class: normalizeClass(["am-tour-description", mergedClasses.value.description]),
+								style: normalizeStyle(mergedStyles.value.description)
+							}, [createVNode(unref(RenderNode_default), { node: content.value.description }, null, 8, ["node"])], 6)) : createCommentVNode("", true),
+							createElementVNode("div", {
+								class: normalizeClass(["am-tour-footer", mergedClasses.value.footer]),
+								style: normalizeStyle(mergedStyles.value.footer)
+							}, [total.value > 1 ? (openBlock(), createElementBlock("div", {
+								key: 0,
+								class: normalizeClass(["am-tour-indicators", mergedClasses.value.indicators]),
+								style: normalizeStyle(mergedStyles.value.indicators)
+							}, [renderSlot(_ctx.$slots, "indicatorsRender", normalizeProps(guardReactiveProps(actionsInfo.value)), () => [__props.indicatorsRender ? (openBlock(), createBlock(unref(RenderNode_default), {
+								key: 0,
+								node: renderIndicators
+							})) : (openBlock(true), createElementBlock(Fragment, { key: 1 }, renderList(total.value, (index) => {
+								return openBlock(), createElementBlock("span", {
+									key: index,
+									class: normalizeClass(["am-tour-indicator", [{ "am-tour-indicator-active": index - 1 === unref(current) }, mergedClasses.value.indicator]]),
+									style: normalizeStyle(mergedStyles.value.indicator)
+								}, null, 6);
+							}), 128))])], 6)) : createCommentVNode("", true), createElementVNode("div", {
+								class: normalizeClass(["am-tour-actions", mergedClasses.value.actions]),
+								style: normalizeStyle(mergedStyles.value.actions)
+							}, [renderSlot(_ctx.$slots, "actionsRender", normalizeProps(guardReactiveProps(actionsSlotProps.value)), () => [createVNode(unref(RenderNode_default), { node: renderActions })])], 6)], 6)
+						], 6)], 14, _hoisted_6)
+					], 16, _hoisted_1), [[vShow, open.value]])]),
+					_: 2
+				}, 1024)]),
+				_: 3
+			}, 8, ["get-container"])) : createCommentVNode("", true);
+		};
+	}
+});
+export { Tour_vue_vue_type_script_setup_true_lang_default as default };

package/dist/tour/TourActions.js

@@ -0,0 +1,4 @@
+import TourActions_vue_vue_type_script_setup_true_lang_default from "./TourActions.vue_vue_type_script_setup_true_lang.js";
+// src/tour/TourActions.vue
+var TourActions_default = TourActions_vue_vue_type_script_setup_true_lang_default;
+export { TourActions_default as default };

package/dist/tour/TourActions.vue.d.ts

@@ -0,0 +1,27 @@
+import type { TourButtonInfo, TourButtonProps, TourType } from './interface';
+type __VLS_Props = {
+    current: number;
+    total: number;
+    type?: TourType;
+    prevButtonProps?: TourButtonProps;
+    nextButtonProps?: TourButtonProps;
+};
+type __VLS_Slots = {
+    prevButton?: (props: TourButtonInfo) => any;
+    nextButton?: (props: TourButtonInfo) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    next: (event: MouseEvent) => any;
+    prev: (event: MouseEvent) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onNext?: ((event: MouseEvent) => any) | undefined;
+    onPrev?: ((event: MouseEvent) => any) | undefined;
+}>, {}, {}, {}, {}, 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/dist/tour/TourActions.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,62 @@
+import { isRenderable } from "../_util/index.js";
+import RenderNode_default from "../_util/RenderNode.js";
+import Button_default from "../button/Button.js";
+import { useLocale } from "../locale/index.js";
+import { Fragment, computed, createBlock, createCommentVNode, createElementBlock, createVNode, defineComponent, guardReactiveProps, normalizeClass, normalizeProps, normalizeStyle, openBlock, renderSlot, unref, withCtx } from "vue";
+// src/tour/TourActions.vue?vue&type=script&setup=true&lang.ts
+var TourActions_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComponent({
+	name: "AmTourActions",
+	inheritAttrs: false,
+	__name: "TourActions",
+	props: {
+		current: {},
+		total: {},
+		type: {},
+		prevButtonProps: {},
+		nextButtonProps: {}
+	},
+	emits: ["prev", "next"],
+	setup(__props, { emit: __emit }) {
+		const props = __props;
+		const emit = __emit;
+		const locale = useLocale("Tour");
+		const info = computed(() => ({
+			current: props.current,
+			isFirst: props.current === 0,
+			isLast: props.current === props.total - 1
+		}));
+		const prevText = computed(() => isRenderable(props.prevButtonProps?.children) ? props.prevButtonProps.children : locale.value.prev);
+		const nextText = computed(() => {
+			if (isRenderable(props.nextButtonProps?.children)) return props.nextButtonProps.children;
+			return info.value.isLast ? locale.value.finish : locale.value.next;
+		});
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock(Fragment, null, [!info.value.isFirst ? (openBlock(), createBlock(Button_default, {
+				key: 0,
+				size: "small",
+				type: "default",
+				ghost: __props.type === "primary",
+				class: normalizeClass(["am-tour-prev-btn", __props.prevButtonProps?.class]),
+				style: normalizeStyle(__props.prevButtonProps?.style),
+				onClick: _cache[0] || (_cache[0] = ($event) => emit("prev", $event))
+			}, {
+				default: withCtx(() => [renderSlot(_ctx.$slots, "prevButton", normalizeProps(guardReactiveProps(info.value)), () => [createVNode(unref(RenderNode_default), { node: prevText.value }, null, 8, ["node"])])]),
+				_: 3
+			}, 8, [
+				"ghost",
+				"class",
+				"style"
+			])) : createCommentVNode("", true), createVNode(Button_default, {
+				size: "small",
+				type: "primary",
+				class: normalizeClass(["am-tour-next-btn", __props.nextButtonProps?.class]),
+				style: normalizeStyle(__props.nextButtonProps?.style),
+				onClick: _cache[1] || (_cache[1] = ($event) => emit("next", $event))
+			}, {
+				default: withCtx(() => [renderSlot(_ctx.$slots, "nextButton", normalizeProps(guardReactiveProps(info.value)), () => [createVNode(unref(RenderNode_default), { node: nextText.value }, null, 8, ["node"])])]),
+				_: 3
+			}, 8, ["class", "style"])], 64);
+		};
+	}
+});
+export { TourActions_vue_vue_type_script_setup_true_lang_default as default };