antdv-next 0.0.111 → 1.0.0-alpha.2

package/dist/tooltip/index.js

@@ -0,0 +1,271 @@
+import { useComponentBaseConfig } from "../config-provider/context.js";
+import useToken from "../theme/useToken.js";
+import "../theme/internal.js";
+import { useMergeSemantic, useToArr, useToProps } from "../_util/hooks/useMergeSemantic.js";
+import { ZIndexProvider } from "../_util/zindexContext.js";
+import { useZIndex } from "../_util/hooks/useZIndex.js";
+import "../_util/hooks/index.js";
+import { getSlotPropsFnRun, toPropsRefs } from "../_util/tools.js";
+import useCSSVarCls_default from "../config-provider/hooks/useCSSVarCls.js";
+import { ContextIsolator } from "../_util/ContextIsolator.js";
+import getPlacements from "../_util/placements.js";
+import useMergedArrow_default from "./hooks/useMergedArrow.js";
+import style_default from "./style/index.js";
+import { parseColor } from "./util.js";
+import PurePanel_default from "./PurePanel.js";
+import UniqueProvider_default from "./UniqueProvider/index.js";
+import { computed, createVNode, defineComponent, isVNode, mergeDefaults, mergeProps, shallowRef, watchEffect } from "vue";
+import { clsx } from "@v-c/util";
+import { filterEmpty, removeUndefined } from "@v-c/util/dist/props-util";
+import VcTooltip from "@v-c/tooltip";
+import { getTransitionName } from "@v-c/util/dist/utils/transition";
+
+//#region src/tooltip/index.tsx
+/**
+* @internal
+* Internal props type with hidden properties
+*/
+function _isSlot(s) {
+	return typeof s === "function" || Object.prototype.toString.call(s) === "[object Object]" && !isVNode(s);
+}
+const InternalTooltip = /* @__PURE__ */ defineComponent((props, { slots, attrs, expose, emit }) => {
+	const [, token] = useToken();
+	const { getPrefixCls, prefixCls, direction, arrow: contextArrow, class: contextClassName, style: contextStyle, classes: contextClassNames, styles: contextStyles, getPopupContainer: getContextPopupContainer } = useComponentBaseConfig("tooltip", props, ["arrow"]);
+	const { arrow: tooltipArrow, builtinPlacements, autoAdjustOverflow, classes, styles } = toPropsRefs(props, "arrow", "builtinPlacements", "autoAdjustOverflow", "classes", "styles");
+	const mergedArrow = useMergedArrow_default(tooltipArrow, contextArrow);
+	const mergedShowArrow = computed(() => mergedArrow.value?.show);
+	const tooltipRef = shallowRef();
+	const forceAlign = () => {
+		tooltipRef.value?.forceAlign?.();
+	};
+	expose({
+		forceAlign,
+		nativeElement: computed(() => tooltipRef.value?.nativeElement),
+		popupElement: computed(() => tooltipRef.value?.popupElement)
+	});
+	const open = shallowRef(props?.defaultOpen ?? false);
+	watchEffect(() => {
+		if (props.open !== void 0) open.value = props.open;
+	});
+	let noTitle = false;
+	const onInternalOpenChange = (vis) => {
+		if (props.open === void 0) open.value = noTitle ? false : vis;
+		if (!noTitle) {
+			emit("openChange", vis);
+			emit("update:open", vis);
+		}
+	};
+	const tooltipPlacements = computed(() => {
+		return builtinPlacements.value || getPlacements({
+			arrowPointAtCenter: mergedArrow?.value?.pointAtCenter ?? false,
+			autoAdjustOverflow: autoAdjustOverflow.value,
+			arrowWidth: mergedShowArrow ? token.value.sizePopupArrow : 0,
+			borderRadius: token.value.borderRadius,
+			offset: token.value.marginXXS,
+			visibleFirst: true
+		});
+	});
+	const mergedProps = computed(() => {
+		return props;
+	});
+	const [mergedClassNames, mergedStyles] = useMergeSemantic(useToArr(contextClassNames, classes), useToArr(contextStyles, styles), useToProps(mergedProps));
+	const rootPrefixCls = computed(() => getPrefixCls());
+	const injectFromPopover = props.dataPopoverInject;
+	const rootCls = useCSSVarCls_default(prefixCls);
+	const [hashId, cssVarCls] = style_default(prefixCls, rootCls, !injectFromPopover);
+	const [zIndex, contextZIndex] = useZIndex("Tooltip", computed(() => props.zIndex));
+	return () => {
+		const { color, rootClass, placement, mouseLeaveDelay, mouseEnterDelay, getPopupContainer, getTooltipContainer, afterOpenChange, motion, destroyOnHidden, openClass,...restProps } = props;
+		const title = getSlotPropsFnRun(slots, props, "title");
+		const overlay = getSlotPropsFnRun(slots, props, "overlay");
+		noTitle = !title && !overlay && title !== 0;
+		const memoOverlay = title === 0 ? title : overlay || title || "";
+		const memoOverlayWrapper = createVNode(ContextIsolator, { "space": true }, _isSlot(memoOverlay) ? memoOverlay : { default: () => [memoOverlay] });
+		let child = filterEmpty(slots.default?.())?.[0];
+		child = isVNode(child) ? child : createVNode("span", null, [child]);
+		const childProps = child?.props ?? {};
+		const childCls = !childProps?.class || typeof childProps?.class === "string" ? clsx(childProps.class, openClass || `${prefixCls.value}-open`) : childProps.class;
+		const colorInfo = parseColor(prefixCls.value, color);
+		const arrowContentStyle = colorInfo.arrowStyle;
+		const themeCls = clsx(rootCls.value, hashId.value, cssVarCls.value);
+		const rootClassNames = clsx({ [`${prefixCls.value}-rtl`]: direction.value === "rtl" }, colorInfo.className, rootClass, themeCls, contextClassName.value, mergedClassNames.value.root);
+		const containerStyle = {
+			...mergedStyles.value.container,
+			...colorInfo.overlayStyle
+		};
+		let tempOpen = open.value;
+		if (!(props.open !== void 0) && noTitle) tempOpen = false;
+		const content = createVNode(VcTooltip, mergeProps({ "unique": true }, removeUndefined(restProps), attrs, {
+			"zIndex": zIndex.value,
+			"showArrow": mergedShowArrow.value,
+			"placement": placement,
+			"mouseLeaveDelay": mouseLeaveDelay,
+			"mouseEnterDelay": mouseEnterDelay,
+			"prefixCls": prefixCls.value,
+			"classNames": {
+				root: rootClassNames,
+				container: mergedClassNames.value.container,
+				arrow: mergedClassNames.value.arrow,
+				uniqueContainer: clsx(themeCls, mergedClassNames.value.container)
+			},
+			"styles": {
+				root: {
+					...arrowContentStyle,
+					...mergedStyles.value?.root,
+					...contextStyle.value
+				},
+				container: containerStyle,
+				uniqueContainer: containerStyle,
+				arrow: mergedStyles.value.arrow
+			},
+			"getTooltipContainer": getPopupContainer || getTooltipContainer || getContextPopupContainer,
+			"ref": tooltipRef,
+			"builtinPlacements": tooltipPlacements.value,
+			"overlay": memoOverlayWrapper,
+			"visible": tempOpen,
+			"onVisibleChange": onInternalOpenChange,
+			"afterVisibleChange": afterOpenChange,
+			"arrowContent": createVNode("span", { "class": `${prefixCls.value}-arrow-content` }, null),
+			"motion": {
+				name: getTransitionName(rootPrefixCls.value, "zoom-big-fast", typeof motion?.name === "string" ? motion?.name : void 0),
+				duration: 1e3
+			},
+			"destroyOnHidden": destroyOnHidden
+		}), { default: () => [tempOpen ? createVNode(child, { class: childCls }) : child] });
+		return createVNode(ZIndexProvider, { "value": contextZIndex.value }, _isSlot(content) ? content : { default: () => [content] });
+	};
+}, {
+	emits: ["openChange", "update:open"],
+	props: /* @__PURE__ */ mergeDefaults({
+		dataPopoverInject: {
+			type: Boolean,
+			required: false
+		},
+		afterOpenChange: {
+			type: Function,
+			required: false
+		},
+		builtinPlacements: { required: false },
+		title: {
+			type: [
+				Function,
+				Boolean,
+				String,
+				Number,
+				null,
+				Object
+			],
+			required: false
+		},
+		overlay: {
+			type: [
+				Function,
+				Boolean,
+				String,
+				Number,
+				null,
+				Object
+			],
+			required: false
+		},
+		openClass: {
+			type: String,
+			required: false
+		},
+		unique: {
+			type: Boolean,
+			required: false
+		},
+		align: {
+			type: Object,
+			required: false
+		},
+		arrow: {
+			type: [Boolean, Object],
+			required: false
+		},
+		autoAdjustOverflow: {
+			type: [Boolean, Object],
+			required: false
+		},
+		color: { required: false },
+		open: {
+			type: Boolean,
+			required: false
+		},
+		defaultOpen: {
+			type: Boolean,
+			required: false
+		},
+		getPopupContainer: {
+			type: Function,
+			required: false
+		},
+		destroyOnHidden: {
+			type: Boolean,
+			required: false
+		},
+		zIndex: {
+			type: Number,
+			required: false
+		},
+		placement: {
+			type: String,
+			required: false
+		},
+		trigger: {
+			type: [String, Array],
+			required: false
+		},
+		fresh: {
+			type: Boolean,
+			required: false
+		},
+		mouseEnterDelay: {
+			type: Number,
+			required: false
+		},
+		mouseLeaveDelay: {
+			type: Number,
+			required: false
+		},
+		classes: {
+			type: [Object, Function],
+			required: false
+		},
+		styles: {
+			type: [Object, Function],
+			required: false
+		},
+		getTooltipContainer: {
+			type: Function,
+			required: false
+		},
+		motion: { required: false },
+		rootClass: {
+			type: String,
+			required: false
+		},
+		prefixCls: {
+			type: String,
+			required: false
+		}
+	}, {
+		autoAdjustOverflow: true,
+		placement: "top",
+		mouseEnterDelay: .1,
+		mouseLeaveDelay: .1
+	}),
+	name: "ATooltip",
+	inheritAttrs: false
+});
+InternalTooltip.install = (app) => {
+	app.component(InternalTooltip.name, InternalTooltip);
+	app.component("AUniqueProvider", UniqueProvider_default);
+};
+InternalTooltip.UniqueProvider = UniqueProvider_default;
+InternalTooltip._InternalPanelDoNotUseOrYouWillBeFired = PurePanel_default;
+var tooltip_default = InternalTooltip;
+
+//#endregion
+export { tooltip_default as default };

package/dist/tooltip/style/index.d.ts

@@ -0,0 +1,15 @@
+import { ArrowToken } from "../../style/roundedArrow.js";
+import { ArrowOffsetToken } from "../../style/placementArrow.js";
+import "../../theme/internal.js";
+import { Ref } from "vue";
+
+//#region src/tooltip/style/index.d.ts
+interface ComponentToken extends ArrowOffsetToken, ArrowToken {
+  /**
+   * @desc 文字提示 z-index
+   * @descEN z-index of tooltip
+   */
+  zIndexPopup: number;
+}
+//#endregion
+export { ComponentToken };

package/dist/tooltip/style/index.js

@@ -0,0 +1,112 @@
+import genPresetColor from "../../theme/util/genPresetColor.js";
+import { resetComponent } from "../../style/index.js";
+import { genStyleHooks } from "../../theme/util/genStyleUtils.js";
+import { mergeToken } from "../../theme/internal.js";
+import { getArrowToken } from "../../style/roundedArrow.js";
+import getArrowStyle, { MAX_VERTICAL_CONTENT_RADIUS, getArrowOffsetToken } from "../../style/placementArrow.js";
+import { initFadeMotion } from "../../style/motion/fade.js";
+import { initZoomMotion } from "../../style/motion/zoom.js";
+import "../../style/motion/index.js";
+import { unit } from "@antdv-next/cssinjs";
+
+//#region src/tooltip/style/index.ts
+const genTooltipStyle = (token) => {
+	const { calc, componentCls, tooltipMaxWidth, tooltipColor, tooltipBg, tooltipBorderRadius, zIndexPopup, controlHeight, boxShadowSecondary, paddingSM, paddingXS, arrowOffsetHorizontal, sizePopupArrow } = token;
+	const edgeAlignMinWidth = calc(tooltipBorderRadius).add(sizePopupArrow).add(arrowOffsetHorizontal).equal();
+	const sharedBodyStyle = {
+		minWidth: calc(tooltipBorderRadius).mul(2).add(sizePopupArrow).equal(),
+		minHeight: controlHeight,
+		padding: `${unit(token.calc(paddingSM).div(2).equal())} ${unit(paddingXS)}`,
+		color: `var(--ant-tooltip-color, ${tooltipColor})`,
+		textAlign: "start",
+		textDecoration: "none",
+		wordWrap: "break-word",
+		backgroundColor: tooltipBg,
+		borderRadius: tooltipBorderRadius,
+		boxShadow: boxShadowSecondary,
+		boxSizing: "border-box"
+	};
+	const sharedTransformOrigin = {
+		"--valid-offset-x": "var(--arrow-offset-horizontal, var(--arrow-x))",
+		"transformOrigin": [`var(--valid-offset-x, 50%)`, `var(--arrow-y, 50%)`].join(" ")
+	};
+	return [
+		{ [componentCls]: {
+			...resetComponent(token),
+			"position": "absolute",
+			"zIndex": zIndexPopup,
+			"display": "block",
+			"width": "max-content",
+			"maxWidth": tooltipMaxWidth,
+			"visibility": "visible",
+			...sharedTransformOrigin,
+			"&-hidden": { display: "none" },
+			"--antd-arrow-background-color": tooltipBg,
+			[`${componentCls}-container`]: [sharedBodyStyle, initFadeMotion(token, true)],
+			[`&:has(~ ${componentCls}-unique-container)`]: { [`${componentCls}-container`]: {
+				border: "none",
+				background: "transparent",
+				boxShadow: "none"
+			} },
+			[[
+				`&-placement-topLeft`,
+				`&-placement-topRight`,
+				`&-placement-bottomLeft`,
+				`&-placement-bottomRight`
+			].join(",")]: { minWidth: edgeAlignMinWidth },
+			[[
+				`&-placement-left`,
+				`&-placement-leftTop`,
+				`&-placement-leftBottom`,
+				`&-placement-right`,
+				`&-placement-rightTop`,
+				`&-placement-rightBottom`
+			].join(",")]: { [`${componentCls}-inner`]: { borderRadius: token.min(tooltipBorderRadius, MAX_VERTICAL_CONTENT_RADIUS) } },
+			[`${componentCls}-content`]: { position: "relative" },
+			...genPresetColor(token, (colorKey, { darkColor }) => ({ [`&${componentCls}-${colorKey}`]: {
+				[`${componentCls}-container`]: { backgroundColor: darkColor },
+				[`${componentCls}-arrow`]: { "--antd-arrow-background-color": darkColor }
+			} })),
+			"&-rtl": { direction: "rtl" }
+		} },
+		getArrowStyle(token, "var(--antd-arrow-background-color)"),
+		{ [`${componentCls}-pure`]: {
+			position: "relative",
+			maxWidth: "none",
+			margin: token.sizePopupArrow
+		} },
+		{ [`${componentCls}-unique-container`]: {
+			...sharedBodyStyle,
+			...sharedTransformOrigin,
+			"position": "absolute",
+			"zIndex": calc(zIndexPopup).sub(1).equal(),
+			"&-hidden": { display: "none" },
+			"&-visible": { transition: `all ${token.motionDurationSlow}` }
+		} }
+	];
+};
+const prepareComponentToken = (token) => ({
+	zIndexPopup: token.zIndexPopupBase + 70,
+	...getArrowOffsetToken({
+		contentRadius: token.borderRadius,
+		limitVerticalRadius: true
+	}),
+	...getArrowToken(mergeToken(token, { borderRadiusOuter: Math.min(token.borderRadiusOuter, 4) }))
+});
+var style_default = (prefixCls, rootCls, injectStyle = true) => {
+	return genStyleHooks("Tooltip", (token) => {
+		const { borderRadius, colorTextLightSolid, colorBgSpotlight } = token;
+		return [genTooltipStyle(mergeToken(token, {
+			tooltipMaxWidth: 250,
+			tooltipColor: colorTextLightSolid,
+			tooltipBorderRadius: borderRadius,
+			tooltipBg: colorBgSpotlight
+		})), initZoomMotion(token, "zoom-big-fast")];
+	}, prepareComponentToken, {
+		resetStyle: false,
+		injectStyle
+	})(prefixCls, rootCls);
+};
+
+//#endregion
+export { style_default as default };

package/dist/tooltip/util.js

@@ -0,0 +1,26 @@
+import { isPresetColor } from "../_util/colors.js";
+import { generateColor } from "../color-picker/util.js";
+import { classNames } from "@v-c/util";
+
+//#region src/tooltip/util.ts
+function parseColor(prefixCls, color) {
+	const isInternalColor = isPresetColor(color);
+	const className = classNames({ [`${prefixCls}-${color}`]: color && isInternalColor });
+	const overlayStyle = {};
+	const arrowStyle = {};
+	const rgb = generateColor(color).toRgb();
+	const textColor = (.299 * rgb.r + .587 * rgb.g + .114 * rgb.b) / 255 < .5 ? "#FFF" : "#000";
+	if (color && !isInternalColor) {
+		overlayStyle.background = color;
+		overlayStyle["--ant-tooltip-color"] = textColor;
+		arrowStyle["--antd-arrow-background-color"] = color;
+	}
+	return {
+		className,
+		overlayStyle,
+		arrowStyle
+	};
+}
+
+//#endregion
+export { parseColor };

package/dist/tour/index.d.ts

@@ -0,0 +1,11 @@
+import { TourEmits, TourLocale, TourProps, TourSemanticName, TourSlots, TourStepProps, TourStylesType } from "./interface.js";
+import * as vue23 from "vue";
+import { SlotsType } from "vue";
+
+//#region src/tour/index.d.ts
+declare const Tour: vue23.DefineSetupFnComponent<TourProps, TourEmits, SlotsType<TourSlots>, TourProps & {
+  [x: `on${Capitalize<string>}`]: ((...args: any[]) => any) | undefined;
+}, vue23.PublicProps>;
+type TourStepItem = TourStepProps;
+//#endregion
+export { Tour, TourStepItem };

package/dist/tour/index.js

@@ -0,0 +1,266 @@
+import { useComponentBaseConfig } from "../config-provider/context.js";
+import useToken from "../theme/useToken.js";
+import "../theme/internal.js";
+import { pureAttrs, useMergeSemantic, useToArr, useToProps } from "../_util/hooks/useMergeSemantic.js";
+import { ZIndexProvider } from "../_util/zindexContext.js";
+import { useZIndex } from "../_util/hooks/useZIndex.js";
+import "../_util/hooks/index.js";
+import { toPropsRefs } from "../_util/tools.js";
+import { checkRenderNode } from "../_util/vueNode.js";
+import getPlacements from "../_util/placements.js";
+import panelRender_default from "./panelRender.js";
+import style_default from "./style/index.js";
+import { computed, createVNode, defineComponent, mergeProps } from "vue";
+import { clsx } from "@v-c/util";
+import { filterEmpty } from "@v-c/util/dist/props-util";
+import { omit } from "es-toolkit";
+import VcTour from "@v-c/tour";
+
+//#region src/tour/index.tsx
+const Tour = /* @__PURE__ */ defineComponent((props, { slots, emit, attrs }) => {
+	const { prefixCls, direction, closeIcon: contextCloseIcon, class: contextClassName, style: contextStyle, classes: contextClassNames, styles: contextStyles } = useComponentBaseConfig("tour", props, ["closeIcon"]);
+	const { classes, styles } = toPropsRefs(props, "classes", "styles");
+	const [hashId, cssVarCls] = style_default(prefixCls);
+	const [, token] = useToken();
+	const mergedSteps = computed(() => {
+		return (props?.steps ?? []).map((step, index) => {
+			const _cover = filterEmpty(slots?.coverRender?.({
+				step,
+				index
+			})).filter(Boolean);
+			const _title = filterEmpty(slots?.titleRender?.({
+				step,
+				index
+			})).filter(Boolean);
+			const _description = filterEmpty(slots?.descriptionRender?.({
+				step,
+				index
+			})).filter(Boolean);
+			return {
+				...step,
+				cover: step?.cover ?? checkRenderNode(_cover),
+				title: step?.title ?? checkRenderNode(_title),
+				description: step?.description ?? checkRenderNode(_description),
+				class: clsx(step.class, { [`${prefixCls.value}-primary`]: (step.type ?? props.type) === "primary" })
+			};
+		});
+	});
+	const vcSteps = computed(() => {
+		return mergedSteps.value.map((step) => {
+			const { class: stepClass,...restStep } = step ?? {};
+			return {
+				...restStep,
+				className: stepClass
+			};
+		});
+	});
+	const mergedProps = computed(() => {
+		return {
+			...props,
+			steps: mergedSteps.value
+		};
+	});
+	const [mergedClassNames, mergedStyles] = useMergeSemantic(useToArr(contextClassNames, classes), useToArr(contextStyles, styles), useToProps(mergedProps));
+	const builtinPlacements = (config) => getPlacements({
+		arrowPointAtCenter: config?.arrowPointAtCenter ?? true,
+		autoAdjustOverflow: true,
+		offset: token.value.marginXXS,
+		arrowWidth: token.value.sizePopupArrow,
+		borderRadius: token.value.borderRadius
+	});
+	const [zIndex, contextZIndex] = useZIndex("Tour", computed(() => props.zIndex));
+	return () => {
+		const { rootClass, type, closeIcon } = props;
+		const mergedRootClassName = clsx({ [`${prefixCls.value}-rtl`]: direction.value === "rtl" }, hashId.value, cssVarCls.value, rootClass, contextClassName.value, mergedClassNames.value?.root, attrs.class);
+		const semanticStyles = {
+			...mergedStyles.value,
+			mask: {
+				...mergedStyles.value?.root,
+				...mergedStyles.value?.mask,
+				...contextStyle.value,
+				...attrs.style
+			}
+		};
+		const indicatorsRender = slots?.indicatorsRender ?? props?.indicatorsRender;
+		const actionsRender = slots?.actionsRender ?? props?.actionsRender;
+		const mergedRenderPanel = (stepProps, stepCurrent) => {
+			return createVNode(panelRender_default, {
+				"styles": semanticStyles,
+				"classes": mergedClassNames.value,
+				"type": type,
+				"stepProps": {
+					...stepProps,
+					classes: stepProps?.classNames
+				},
+				"current": stepCurrent,
+				"indicatorsRender": indicatorsRender,
+				"actionsRender": actionsRender,
+				"prevButtonProps": slots?.prevButton,
+				"nextButtonProps": slots?.nextButton
+			}, null);
+		};
+		const restProps = omit(props, [
+			"prefixCls",
+			"type",
+			"indicatorsRender",
+			"actionsRender",
+			"steps",
+			"closeIcon",
+			"styles"
+		]);
+		return createVNode(ZIndexProvider, { "value": contextZIndex.value }, { default: () => [createVNode(VcTour, mergeProps(pureAttrs(attrs), restProps, {
+			"styles": semanticStyles,
+			"classNames": mergedClassNames.value,
+			"closeIcon": closeIcon ?? contextCloseIcon.value,
+			"zIndex": zIndex.value,
+			"rootClassName": mergedRootClassName,
+			"prefixCls": prefixCls.value,
+			"animated": true,
+			"renderPanel": mergedRenderPanel,
+			"builtinPlacements": builtinPlacements,
+			"steps": vcSteps.value,
+			"onClose": (current) => {
+				emit("close", current);
+				emit("update:open", false);
+			},
+			"onChange": (current) => {
+				emit("update:current", current);
+				emit("change", current);
+			},
+			"onFinish": () => {
+				emit("finish");
+				emit("update:open", false);
+			},
+			"onPopupAlign": (el, info) => {
+				emit("popupAlign", el, info);
+			}
+		}), null)] });
+	};
+}, {
+	emits: [
+		"change",
+		"close",
+		"finish",
+		"update:open",
+		"update:current",
+		"popupAlign"
+	],
+	props: {
+		steps: {
+			type: Array,
+			required: false
+		},
+		prefixCls: {
+			type: String,
+			required: false
+		},
+		current: {
+			type: Number,
+			required: false
+		},
+		indicatorsRender: {
+			type: Function,
+			required: false
+		},
+		actionsRender: {
+			type: Function,
+			required: false
+		},
+		type: {
+			type: String,
+			required: false
+		},
+		classes: {
+			type: [Object, Function],
+			required: false
+		},
+		styles: {
+			type: [Object, Function],
+			required: false
+		},
+		rootClass: {
+			type: String,
+			required: false
+		},
+		style: {
+			type: Object,
+			required: false
+		},
+		open: {
+			type: Boolean,
+			required: false
+		},
+		defaultOpen: {
+			type: Boolean,
+			required: false
+		},
+		defaultCurrent: {
+			type: Number,
+			required: false
+		},
+		closeIcon: {
+			type: [
+				Object,
+				Function,
+				String,
+				Number,
+				null,
+				Boolean,
+				Array
+			],
+			required: false
+		},
+		closable: {
+			type: [Boolean, Object],
+			required: false
+		},
+		mask: {
+			type: [Boolean, Object],
+			required: false
+		},
+		arrow: {
+			type: [Boolean, Object],
+			required: false
+		},
+		placement: {
+			type: String,
+			required: false
+		},
+		gap: { required: false },
+		animated: {
+			type: [Boolean, Object],
+			required: false
+		},
+		scrollIntoViewOptions: {
+			type: Boolean,
+			required: false,
+			skipCheck: true
+		},
+		zIndex: {
+			type: Number,
+			required: false
+		},
+		getPopupContainer: {
+			type: [Function, Boolean],
+			required: false
+		},
+		builtinPlacements: {
+			type: Function,
+			required: false,
+			skipCheck: true
+		},
+		disabledInteraction: {
+			type: Boolean,
+			required: false
+		}
+	},
+	name: "ATour",
+	inheritAttrs: false
+});
+Tour.install = (app) => {
+	app.component(Tour.name, Tour);
+};
+var tour_default = Tour;
+
+//#endregion
+export { tour_default as default };