@antdv-next/mobile 0.0.0-stage → 0.1.1

package/dist/carousel/Carousel.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,410 @@
+import { clamp, doubleRaf, inBrowser, preventDefault } from "../_util/index.js";
+import { useEventListener } from "../_util/hooks/useEventListener.js";
+import { useTouch } from "../_util/hooks/useTouch.js";
+import RenderNode_default from "../_util/RenderNode.js";
+import { useConfig } from "../config-provider/context.js";
+import "../style/index2.js";
+import './style/index.css';/* empty css            */
+import { Comment, Fragment, Text, computed, createBlock, createCommentVNode, createElementBlock, createElementVNode, createTextVNode, defineComponent, guardReactiveProps, mergeProps, normalizeClass, normalizeProps, normalizeStyle, onActivated, onBeforeUnmount, onDeactivated, onMounted, onUpdated, openBlock, reactive, ref, renderList, renderSlot, resolveDynamicComponent, unref, useSlots, watch } from "vue";
+// src/carousel/Carousel.vue?vue&type=script&setup=true&lang.ts
+var _hoisted_1 = ["aria-hidden"];
+var _hoisted_2 = ["onClick"];
+var Carousel_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComponent({
+	name: "AmCarousel",
+	inheritAttrs: false,
+	__name: "Carousel",
+	props: {
+		autoplay: {
+			type: [Boolean, Object],
+			default: false
+		},
+		autoplaySpeed: { default: 3e3 },
+		dots: {
+			type: [Boolean, Object],
+			default: true
+		},
+		dotPlacement: {},
+		dotPosition: {},
+		infinite: {
+			type: Boolean,
+			default: true
+		},
+		speed: { default: 300 },
+		initialSlide: { default: 0 },
+		vertical: {
+			type: Boolean,
+			default: void 0
+		},
+		draggable: {
+			type: Boolean,
+			default: true
+		},
+		allowTouchMove: {
+			type: Boolean,
+			default: true
+		},
+		effect: { default: "scrollx" },
+		slideSize: { default: 100 },
+		trackOffset: { default: 0 },
+		stuckAtBoundary: {
+			type: Boolean,
+			default: true
+		},
+		indicator: {
+			type: [
+				Object,
+				String,
+				Number,
+				Boolean,
+				null,
+				Array,
+				Function
+			],
+			default: void 0
+		},
+		stopPropagation: {
+			type: Boolean,
+			default: false
+		},
+		rootClass: {},
+		classes: {},
+		styles: {}
+	},
+	emits: ["beforeChange", "afterChange"],
+	setup(__props, { expose: __expose, emit: __emit }) {
+		const props = __props;
+		const emit = __emit;
+		const slots = useSlots();
+		const config = useConfig();
+		const touch = useTouch();
+		const rootRef = ref();
+		const count = ref(0);
+		/** number of slides produced by the last render (synced into `count` after each patch) */
+		let renderedCount = 0;
+		const state = reactive({
+			/** size of the carousel along the sliding axis in px (only used to convert finger distance) */
+			rootSize: 0,
+			/** index of the active slide, `-1` and `count` are the transient positions of the infinite loop */
+			active: props.initialSlide,
+			/** track offset in percent of the carousel size */
+			offset: 0,
+			/** offsets (in percent of a slide) that move the first / last slide to the other end of the track */
+			firstOffset: 0,
+			lastOffset: 0,
+			/** transitions are disabled while following the finger or correcting the position */
+			swiping: false
+		});
+		const placement = computed(() => {
+			const value = props.dotPlacement ?? props.dotPosition ?? "bottom";
+			if (value === "left") return "start";
+			if (value === "right") return "end";
+			return value;
+		});
+		const isVertical = computed(() => props.vertical ?? (placement.value === "start" || placement.value === "end"));
+		const isFade = computed(() => props.effect === "fade");
+		const isRtl = computed(() => config.direction.value === "rtl" && !isVertical.value);
+		const loop = computed(() => props.infinite && count.value > 1);
+		const touchable = computed(() => props.draggable && props.allowTouchMove && count.value > 1);
+		/** offset of the track when the last slide touches the end of the carousel */
+		const minOffset = computed(() => 100 - count.value * props.slideSize);
+		const maxIndex = computed(() => {
+			if (loop.value || isFade.value || !props.stuckAtBoundary || props.slideSize >= 100) return Math.max(count.value - 1, 0);
+			return clamp(Math.ceil(Math.abs(Math.min(minOffset.value, 0)) / props.slideSize), 0, Math.max(count.value - 1, 0));
+		});
+		const current = computed(() => {
+			if (!count.value) return 0;
+			return clamp((state.active + count.value) % count.value, 0, count.value - 1);
+		});
+		const showDotProgress = computed(() => typeof props.autoplay === "object" && !!props.autoplay?.dotDuration);
+		function flatten(children, out = []) {
+			if (Array.isArray(children)) children.forEach((child) => flatten(child, out));
+			else if (typeof children === "string" || typeof children === "number") {
+				if (String(children).trim()) out.push(createTextVNode(String(children)));
+			} else if (children && typeof children === "object") {
+				const vnode = children;
+				if (vnode.type === Fragment) flatten(vnode.children, out);
+				else if (vnode.type === Text ? String(vnode.children).trim() : vnode.type !== Comment) out.push(vnode);
+			}
+			return out;
+		}
+		function renderSlides() {
+			const nodes = flatten(slots.default?.());
+			renderedCount = nodes.length;
+			return nodes;
+		}
+		function getTargetActive(pace) {
+			if (!pace) return state.active;
+			if (isFade.value) return loop.value ? (current.value + pace % count.value + count.value) % count.value : clamp(current.value + pace, 0, maxIndex.value);
+			if (loop.value) return clamp(state.active + pace, -1, count.value);
+			return clamp(state.active + pace, 0, maxIndex.value);
+		}
+		function getTargetOffset(active, drag = 0) {
+			let offset = props.trackOffset - active * props.slideSize + drag;
+			if (!loop.value) {
+				const lower = props.stuckAtBoundary ? Math.min(minOffset.value, 0) : props.trackOffset - (count.value - 1) * props.slideSize;
+				const upper = props.stuckAtBoundary ? 0 : props.trackOffset;
+				offset = clamp(offset, lower, upper);
+			}
+			return offset;
+		}
+		function move(pace = 0, drag = 0) {
+			const active = getTargetActive(pace);
+			state.active = active;
+			if (isFade.value || count.value <= 1) {
+				state.offset = 0;
+				state.firstOffset = 0;
+				state.lastOffset = 0;
+				return;
+			}
+			const offset = getTargetOffset(active, drag);
+			if (loop.value) {
+				state.firstOffset = offset < minOffset.value ? count.value * 100 : 0;
+				state.lastOffset = offset > 0 ? -count.value * 100 : 0;
+			} else {
+				state.firstOffset = 0;
+				state.lastOffset = 0;
+			}
+			state.offset = offset;
+		}
+		/** Brings a transient loop position (`-1` / `count`) back into range without animation. */
+		function correctPosition() {
+			if (isFade.value || !loop.value) return false;
+			if (state.active <= -1 || state.active >= count.value) {
+				state.swiping = true;
+				move(state.active <= -1 ? count.value : -count.value);
+				return true;
+			}
+			return false;
+		}
+		let afterChangeTimer;
+		function run(pace, animate) {
+			const prev = current.value;
+			const target = getTargetActive(pace);
+			const next = count.value ? (target + count.value) % count.value : 0;
+			const changed = next !== prev;
+			if (changed) emit("beforeChange", prev, next);
+			state.swiping = !animate;
+			move(pace);
+			if (!changed) return;
+			clearTimeout(afterChangeTimer);
+			if (animate && props.speed > 0) afterChangeTimer = setTimeout(() => emit("afterChange", current.value), props.speed);
+			else emit("afterChange", next);
+		}
+		function change(pace, animate = true) {
+			if (count.value <= 1) return;
+			if (correctPosition() && animate) doubleRaf(() => run(pace, true));
+			else run(pace, animate);
+		}
+		function goTo(slide, dontAnimate = false) {
+			if (count.value <= 1) return;
+			const corrected = correctPosition();
+			const pace = clamp(Math.round(slide), 0, count.value - 1) - current.value;
+			const start = () => run(pace, !dontAnimate);
+			if (corrected && !dontAnimate && pace) doubleRaf(start);
+			else start();
+			startAutoplay();
+		}
+		function next() {
+			if (loop.value || current.value < maxIndex.value) change(1);
+			startAutoplay();
+		}
+		function prev() {
+			if (loop.value || current.value > 0) change(-1);
+			startAutoplay();
+		}
+		let autoplayTimer;
+		let touching = false;
+		function stopAutoplay() {
+			clearTimeout(autoplayTimer);
+			autoplayTimer = void 0;
+		}
+		function startAutoplay() {
+			stopAutoplay();
+			if (!inBrowser || !props.autoplay || count.value <= 1 || touching || document.hidden) return;
+			autoplayTimer = setTimeout(() => {
+				if (!loop.value && current.value >= maxIndex.value) change(-current.value);
+				else change(1);
+				startAutoplay();
+			}, Math.max(props.autoplaySpeed, 0));
+		}
+		function resize() {
+			const root = rootRef.value;
+			if (!root) return;
+			state.rootSize = isVertical.value ? root.offsetHeight : root.offsetWidth;
+		}
+		function reset(active = current.value) {
+			count.value = renderedCount;
+			state.active = clamp(active, 0, Math.max(isFade.value ? count.value - 1 : maxIndex.value, 0));
+			state.swiping = true;
+			resize();
+			move();
+			startAutoplay();
+		}
+		let resizeObserver;
+		onMounted(() => {
+			reset(props.initialSlide);
+			if (typeof ResizeObserver !== "undefined" && rootRef.value) {
+				resizeObserver = new ResizeObserver(resize);
+				resizeObserver.observe(rootRef.value);
+			}
+		});
+		onUpdated(() => {
+			if (renderedCount !== count.value) reset();
+		});
+		onActivated(() => {
+			resize();
+			startAutoplay();
+		});
+		onDeactivated(stopAutoplay);
+		onBeforeUnmount(() => {
+			stopAutoplay();
+			clearTimeout(afterChangeTimer);
+			resizeObserver?.disconnect();
+		});
+		useEventListener("resize", resize);
+		useEventListener("orientationchange", resize);
+		useEventListener("visibilitychange", () => document.hidden ? stopAutoplay() : startAutoplay(), { target: inBrowser ? document : void 0 });
+		watch(() => [props.autoplay, props.autoplaySpeed], startAutoplay, { deep: true });
+		watch(() => [
+			props.slideSize,
+			props.trackOffset,
+			props.infinite,
+			props.stuckAtBoundary,
+			props.effect,
+			isVertical.value
+		], () => reset());
+		let touchStartTime = 0;
+		let dragging = false;
+		const delta = computed(() => isVertical.value ? touch.deltaY.value : touch.deltaX.value * (isRtl.value ? -1 : 1));
+		const isCorrectDirection = () => isVertical.value ? touch.isVertical() : touch.isHorizontal();
+		function onTouchStart(event) {
+			if (!touchable.value) return;
+			touch.start(event);
+			touchStartTime = Date.now();
+			touching = true;
+			dragging = true;
+			stopAutoplay();
+			resize();
+			if (!isFade.value) {
+				correctPosition();
+				state.swiping = true;
+			}
+		}
+		function onTouchMove(event) {
+			if (!touchable.value || !dragging) return;
+			touch.move(event);
+			if (!isCorrectDirection()) return;
+			if (!(!loop.value && (current.value === 0 && delta.value > 0 || current.value >= maxIndex.value && delta.value < 0))) preventDefault(event, props.stopPropagation);
+			if (!isFade.value && state.rootSize) {
+				const max = loop.value ? props.slideSize : Number.POSITIVE_INFINITY;
+				move(0, clamp(delta.value / state.rootSize * 100, -max, max));
+			}
+		}
+		function onTouchEnd() {
+			if (!dragging) return;
+			dragging = false;
+			touching = false;
+			const distance = delta.value;
+			const size = state.rootSize * props.slideSize / 100;
+			const velocity = distance / Math.max(Date.now() - touchStartTime, 1);
+			if ((Math.abs(velocity) > .25 || size > 0 && Math.abs(distance) > size / 2) && isCorrectDirection() && distance) {
+				let pace = distance > 0 ? -1 : 1;
+				if (!loop.value && !isFade.value && size > 0) pace = -Math[distance > 0 ? "ceil" : "floor"](distance / size);
+				run(pace, true);
+			} else {
+				state.swiping = false;
+				move();
+			}
+			startAutoplay();
+		}
+		const sign = computed(() => isRtl.value ? -1 : 1);
+		const translate = (value) => isVertical.value ? `translate3d(0, ${value}%, 0)` : `translate3d(${value * sign.value}%, 0, 0)`;
+		const duration = computed(() => `${state.swiping ? 0 : props.speed}ms`);
+		const trackStyle = computed(() => [isFade.value ? void 0 : {
+			transform: translate(state.offset),
+			transitionDuration: duration.value
+		}, props.styles?.track]);
+		function slideStyle(index) {
+			const size = `${props.slideSize}%`;
+			if (isFade.value) return [{
+				opacity: index === current.value ? 1 : 0,
+				transitionDuration: duration.value,
+				zIndex: index === current.value ? 1 : 0
+			}, props.styles?.slide];
+			let offset = 0;
+			if (index === 0) offset = state.firstOffset;
+			else if (index === count.value - 1) offset = state.lastOffset;
+			return [
+				isVertical.value ? { height: size } : { width: size },
+				offset ? { transform: translate(offset) } : void 0,
+				props.styles?.slide
+			];
+		}
+		const classNames = computed(() => [
+			"am-carousel",
+			{
+				"am-carousel-vertical": isVertical.value,
+				"am-carousel-fade": isFade.value,
+				"am-carousel-rtl": isRtl.value
+			},
+			props.rootClass,
+			props.classes?.root
+		]);
+		const indicatorInfo = computed(() => ({
+			current: current.value,
+			total: count.value
+		}));
+		__expose({
+			goTo,
+			next,
+			prev,
+			resize
+		});
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock("div", mergeProps({
+				ref_key: "rootRef",
+				ref: rootRef
+			}, _ctx.$attrs, {
+				class: classNames.value,
+				style: __props.styles?.root,
+				onTouchstart: onTouchStart,
+				onTouchmove: onTouchMove,
+				onTouchend: onTouchEnd,
+				onTouchcancel: onTouchEnd
+			}), [createElementVNode("div", {
+				class: normalizeClass(["am-carousel-track", __props.classes?.track]),
+				style: normalizeStyle(trackStyle.value)
+			}, [(openBlock(true), createElementBlock(Fragment, null, renderList(renderSlides(), (node, index) => {
+				return openBlock(), createElementBlock("div", {
+					key: node.key ?? index,
+					class: normalizeClass(["am-carousel-slide", [{ "am-carousel-slide-active": index === current.value }, __props.classes?.slide]]),
+					style: normalizeStyle(slideStyle(index)),
+					"aria-hidden": index !== current.value || void 0
+				}, [(openBlock(), createBlock(resolveDynamicComponent(node)))], 14, _hoisted_1);
+			}), 128))], 6), renderSlot(_ctx.$slots, "indicator", normalizeProps(guardReactiveProps(indicatorInfo.value)), () => [__props.indicator !== void 0 ? (openBlock(), createBlock(unref(RenderNode_default), {
+				key: 0,
+				node: __props.indicator,
+				params: indicatorInfo.value
+			}, null, 8, ["node", "params"])) : __props.dots && count.value > 1 ? (openBlock(), createElementBlock("ul", {
+				key: 1,
+				class: normalizeClass(["am-carousel-dots", [
+					`am-carousel-dots-${placement.value}`,
+					typeof __props.dots === "object" ? __props.dots.class : void 0,
+					__props.classes?.dots
+				]]),
+				style: normalizeStyle(__props.styles?.dots)
+			}, [(openBlock(true), createElementBlock(Fragment, null, renderList(count.value, (index) => {
+				return openBlock(), createElementBlock("li", {
+					key: index,
+					class: normalizeClass(["am-carousel-dot", [{
+						"am-carousel-dot-active": index - 1 === current.value,
+						"am-carousel-dot-progress": showDotProgress.value && index - 1 === current.value
+					}, __props.classes?.dot]]),
+					style: normalizeStyle([showDotProgress.value ? { "--am-carousel-dot-duration": `${__props.autoplaySpeed}ms` } : void 0, __props.styles?.dot]),
+					onClick: ($event) => goTo(index - 1)
+				}, null, 14, _hoisted_2);
+			}), 128))], 6)) : createCommentVNode("", true)])], 16);
+		};
+	}
+});
+export { Carousel_vue_vue_type_script_setup_true_lang_default as default };

package/dist/carousel/index.d.ts

@@ -0,0 +1,113 @@
+export type * from './interface';
+declare const Carousel: import("../_util/withInstall").WithInstall<{
+    new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("./interface").CarouselProps> & Readonly<{
+        onBeforeChange?: ((current: number, next: number) => any) | undefined;
+        onAfterChange?: ((current: number) => any) | undefined;
+    }>, {
+        goTo: (slide: number, dontAnimate?: boolean) => void;
+        next: () => void;
+        prev: () => void;
+        resize: () => void;
+    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+        beforeChange: (current: number, next: number) => any;
+        afterChange: (current: number) => any;
+    }, import("vue").PublicProps, {
+        infinite: boolean;
+        vertical: boolean;
+        draggable: boolean;
+        indicator: string | number | boolean | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }> | import("vue").VNodeArrayChildren | ((ctx: import("./interface").CarouselIndicatorInfo) => import("vue").VNodeChild) | null;
+        autoplay: boolean | {
+            dotDuration?: boolean;
+        };
+        autoplaySpeed: number;
+        dots: boolean | {
+            class?: string;
+        };
+        speed: number;
+        initialSlide: number;
+        allowTouchMove: boolean;
+        effect: import("./interface").CarouselEffect;
+        slideSize: number;
+        trackOffset: number;
+        stuckAtBoundary: boolean;
+        stopPropagation: boolean;
+    }, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import("./interface").CarouselProps> & Readonly<{
+        onBeforeChange?: ((current: number, next: number) => any) | undefined;
+        onAfterChange?: ((current: number) => any) | undefined;
+    }>, {
+        goTo: (slide: number, dontAnimate?: boolean) => void;
+        next: () => void;
+        prev: () => void;
+        resize: () => void;
+    }, {}, {}, {}, {
+        infinite: boolean;
+        vertical: boolean;
+        draggable: boolean;
+        indicator: string | number | boolean | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }> | import("vue").VNodeArrayChildren | ((ctx: import("./interface").CarouselIndicatorInfo) => import("vue").VNodeChild) | null;
+        autoplay: boolean | {
+            dotDuration?: boolean;
+        };
+        autoplaySpeed: number;
+        dots: boolean | {
+            class?: string;
+        };
+        speed: number;
+        initialSlide: number;
+        allowTouchMove: boolean;
+        effect: import("./interface").CarouselEffect;
+        slideSize: number;
+        trackOffset: number;
+        stuckAtBoundary: boolean;
+        stopPropagation: boolean;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import("vue").ComponentOptionsBase<Readonly<import("./interface").CarouselProps> & Readonly<{
+    onBeforeChange?: ((current: number, next: number) => any) | undefined;
+    onAfterChange?: ((current: number) => any) | undefined;
+}>, {
+    goTo: (slide: number, dontAnimate?: boolean) => void;
+    next: () => void;
+    prev: () => void;
+    resize: () => void;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    beforeChange: (current: number, next: number) => any;
+    afterChange: (current: number) => any;
+}, string, {
+    infinite: boolean;
+    vertical: boolean;
+    draggable: boolean;
+    indicator: string | number | boolean | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }> | import("vue").VNodeArrayChildren | ((ctx: import("./interface").CarouselIndicatorInfo) => import("vue").VNodeChild) | null;
+    autoplay: boolean | {
+        dotDuration?: boolean;
+    };
+    autoplaySpeed: number;
+    dots: boolean | {
+        class?: string;
+    };
+    speed: number;
+    initialSlide: number;
+    allowTouchMove: boolean;
+    effect: import("./interface").CarouselEffect;
+    slideSize: number;
+    trackOffset: number;
+    stuckAtBoundary: boolean;
+    stopPropagation: boolean;
+}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+    $slots: import("./interface").CarouselSlots;
+}), object>;
+export default Carousel;

package/dist/carousel/index.js

@@ -0,0 +1,5 @@
+import { withInstall } from "../_util/withInstall.js";
+import Carousel_default from "./Carousel.js";
+// src/carousel/index.ts
+var Carousel = withInstall(Carousel_default, "AmCarousel");
+export { Carousel as default };

package/dist/carousel/interface.d.ts

@@ -0,0 +1,80 @@
+import type { CSSProperties } from 'vue';
+import type { RenderNodeFn } from '../_util/type';
+export type CarouselEffect = 'scrollx' | 'fade';
+export type CarouselDotPlacement = 'top' | 'bottom' | 'start' | 'end';
+export interface CarouselIndicatorInfo {
+    /** index of the current slide */
+    current: number;
+    /** number of slides */
+    total: number;
+}
+export interface CarouselSemanticClassNames {
+    root?: string;
+    track?: string;
+    slide?: string;
+    dots?: string;
+    dot?: string;
+}
+export interface CarouselSemanticStyles {
+    root?: CSSProperties;
+    track?: CSSProperties;
+    slide?: CSSProperties;
+    dots?: CSSProperties;
+    dot?: CSSProperties;
+}
+export interface CarouselProps {
+    /** Auto switch. `{ dotDuration: true }` also shows the progress on the active dot. */
+    autoplay?: boolean | {
+        dotDuration?: boolean;
+    };
+    /** Interval of autoplay in ms */
+    autoplaySpeed?: number;
+    /** Show the indicator dots. `{ class }` adds a class to the dots container. */
+    dots?: boolean | {
+        class?: string;
+    };
+    dotPlacement?: CarouselDotPlacement;
+    /** @deprecated use `dotPlacement` */
+    dotPosition?: CarouselDotPlacement | 'left' | 'right';
+    /** Seamless loop */
+    infinite?: boolean;
+    /** Duration of the switch animation in ms */
+    speed?: number;
+    initialSlide?: number;
+    /** Slide vertically. Defaults to `true` when `dotPlacement` is `start` / `end` (same as PC). */
+    vertical?: boolean;
+    /** Follow the finger and switch by swiping */
+    draggable?: boolean;
+    /** Temporarily enable / disable the touch gesture (e.g. while an inner element handles it) */
+    allowTouchMove?: boolean;
+    effect?: CarouselEffect;
+    /** Size of one slide in percent of the carousel (use < 100 for peeking cards) */
+    slideSize?: number;
+    /** Offset of the track in percent of the carousel */
+    trackOffset?: number;
+    /** Without `infinite`: keep the first / last slide attached to the edge instead of applying `trackOffset` */
+    stuckAtBoundary?: boolean;
+    /** Custom indicator, replaces the dots. The same-named slot wins. */
+    indicator?: RenderNodeFn<CarouselIndicatorInfo>;
+    /** Stop the propagation of touch events handled by the carousel (nested carousels) */
+    stopPropagation?: boolean;
+    rootClass?: string;
+    classes?: CarouselSemanticClassNames;
+    styles?: CarouselSemanticStyles;
+}
+export interface CarouselEmits {
+    beforeChange: [current: number, next: number];
+    afterChange: [current: number];
+}
+export interface CarouselSlots {
+    /** every direct child is a slide */
+    default?: () => any;
+    indicator?: (info: CarouselIndicatorInfo) => any;
+}
+export interface CarouselRef {
+    goTo: (slide: number, dontAnimate?: boolean) => void;
+    next: () => void;
+    prev: () => void;
+    /** re-measure the carousel (it is done automatically on resize) */
+    resize: () => void;
+}