@antdv-next/mobile 0.0.0-stage → 0.1.0

package/dist/picker-view/style/index.css

@@ -0,0 +1,111 @@
+.am-picker-view {
+  --am-picker-view-item-height: 40px;
+  --am-picker-view-visible-count: 5;
+  --am-picker-view-font-size: var(--am-font-size-lg);
+  --am-picker-view-color: var(--am-color-text);
+  --am-picker-view-disabled-color: var(--am-color-text-disabled);
+  --am-picker-view-indicator-bg: var(--am-color-fill-tertiary);
+  --am-picker-view-indicator-radius: var(--am-border-radius);
+  --am-picker-view-indicator-inset: var(--am-padding-xs);
+  --am-picker-view-mask-opacity: 0.15;
+
+  position: relative;
+  box-sizing: border-box;
+  width: 100%;
+  height: calc(var(--am-picker-view-item-height) * var(--am-picker-view-visible-count));
+  overflow: hidden;
+  color: var(--am-picker-view-color);
+  font-size: var(--am-picker-view-font-size);
+  font-family: var(--am-font-family);
+  line-height: var(--am-line-height);
+  user-select: none;
+  -webkit-tap-highlight-color: transparent;
+}
+
+.am-picker-view-columns {
+  position: relative;
+  display: flex;
+  height: 100%;
+  /* fades the options away from the centre; works on any background, so it is dark-mode safe */
+  -webkit-mask-image: linear-gradient(
+    to bottom,
+    rgb(0 0 0 / var(--am-picker-view-mask-opacity)),
+    #000 calc(50% - var(--am-picker-view-item-height) / 2),
+    #000 calc(50% + var(--am-picker-view-item-height) / 2),
+    rgb(0 0 0 / var(--am-picker-view-mask-opacity))
+  );
+  mask-image: linear-gradient(
+    to bottom,
+    rgb(0 0 0 / var(--am-picker-view-mask-opacity)),
+    #000 calc(50% - var(--am-picker-view-item-height) / 2),
+    #000 calc(50% + var(--am-picker-view-item-height) / 2),
+    rgb(0 0 0 / var(--am-picker-view-mask-opacity))
+  );
+}
+
+.am-picker-view-column {
+  flex: 1;
+  min-width: 0;
+  height: 100%;
+  overflow: hidden;
+  outline: none;
+  cursor: grab;
+  touch-action: none;
+}
+
+.am-picker-view-column-wrapper {
+  margin: 0;
+  padding: 0;
+  list-style: none;
+  transition-timing-function: cubic-bezier(0.23, 1, 0.68, 1);
+  will-change: transform;
+}
+
+.am-picker-view-item {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  box-sizing: border-box;
+  height: var(--am-picker-view-item-height);
+  padding: 0 var(--am-padding-xxs);
+  cursor: pointer;
+}
+
+.am-picker-view-item-text {
+  overflow: hidden;
+  white-space: nowrap;
+  text-overflow: ellipsis;
+}
+
+.am-picker-view-item-disabled {
+  color: var(--am-picker-view-disabled-color);
+  cursor: not-allowed;
+}
+
+.am-picker-view-indicator {
+  position: absolute;
+  top: 50%;
+  right: var(--am-picker-view-indicator-inset);
+  left: var(--am-picker-view-indicator-inset);
+  box-sizing: border-box;
+  height: var(--am-picker-view-item-height);
+  background: var(--am-picker-view-indicator-bg);
+  border-radius: var(--am-picker-view-indicator-radius);
+  transform: translateY(-50%);
+  pointer-events: none;
+}
+
+.am-picker-view-spin {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  height: 100%;
+  color: var(--am-color-primary);
+  font-size: 24px;
+}
+
+@media (prefers-reduced-motion: reduce) {
+  .am-picker-view-column-wrapper {
+    transition-duration: 0.01s !important;
+  }
+}

package/dist/picker-view/util.d.ts

@@ -0,0 +1,23 @@
+import type { PickerColumns, PickerFieldNames, PickerOption, PickerValue } from './interface';
+export interface NormalizedPickerOption {
+    label: string;
+    value: PickerValue;
+    disabled: boolean;
+    raw: PickerOption;
+}
+export interface ResolvedPicker {
+    columns: NormalizedPickerOption[][];
+    /** value of every column, snapped to an existing enabled option */
+    value: PickerValue[];
+    items: (PickerOption | undefined)[];
+}
+export declare function normalizeColumn(column: PickerOption[] | undefined, fieldNames?: PickerFieldNames): NormalizedPickerOption[];
+/** Index of the enabled option nearest to `index`, `-1` when every option is disabled. */
+export declare function findEnabledIndex(options: {
+    disabled?: boolean;
+}[], index: number): number;
+/**
+ * Resolves the columns for `value` and snaps every column value to an existing enabled option.
+ * Function columns are re-evaluated until the value is stable, so cascading columns stay valid.
+ */
+export declare function resolvePicker(columns: PickerColumns | undefined, value: PickerValue[] | undefined, fieldNames?: PickerFieldNames): ResolvedPicker;

package/dist/picker-view/util.js

@@ -0,0 +1,55 @@
+// src/picker-view/util.ts
+function normalizeColumn(column, fieldNames) {
+	const { label = "label", value = "value", disabled = "disabled" } = fieldNames ?? {};
+	return (column ?? []).map((raw) => {
+		const val = raw[value];
+		return {
+			label: String(raw[label] ?? val ?? ""),
+			value: val,
+			disabled: !!raw[disabled],
+			raw
+		};
+	});
+}
+/** Index of the enabled option nearest to `index`, `-1` when every option is disabled. */
+function findEnabledIndex(options, index) {
+	const count = options.length;
+	if (!count) return -1;
+	const start = Math.min(Math.max(index, 0), count - 1);
+	for (let step = 0; step < count; step++) {
+		const after = start + step;
+		if (after < count && !options[after].disabled) return after;
+		const before = start - step;
+		if (before >= 0 && !options[before].disabled) return before;
+	}
+	return -1;
+}
+function pickOption(column, value) {
+	const index = column.findIndex((option) => option.value === value);
+	return column[findEnabledIndex(column, index < 0 ? 0 : index)];
+}
+function getColumns(columns, value, fieldNames) {
+	return ((typeof columns === "function" ? columns(value) : columns) ?? []).map((column) => normalizeColumn(column, fieldNames));
+}
+/**
+* Resolves the columns for `value` and snaps every column value to an existing enabled option.
+* Function columns are re-evaluated until the value is stable, so cascading columns stay valid.
+*/
+function resolvePicker(columns, value, fieldNames) {
+	let current = (value ?? []).slice();
+	let resolved = getColumns(columns, current, fieldNames);
+	let selected = resolved.map((column, index) => pickOption(column, current[index]));
+	if (typeof columns === "function") for (let i = 0; i < 10; i++) {
+		const next = selected.map((option) => option?.value);
+		if (next.length === current.length && next.every((val, index) => val === current[index])) break;
+		current = next;
+		resolved = getColumns(columns, current, fieldNames);
+		selected = resolved.map((column, index) => pickOption(column, current[index]));
+	}
+	return {
+		columns: resolved,
+		value: selected.map((option) => option?.value),
+		items: selected.map((option) => option?.raw)
+	};
+}
+export { findEnabledIndex, normalizeColumn, resolvePicker };

package/dist/popover/Popover.js

@@ -0,0 +1,4 @@
+import Popover_vue_vue_type_script_setup_true_lang_default from "./Popover.vue_vue_type_script_setup_true_lang.js";
+// src/popover/Popover.vue
+var Popover_default = Popover_vue_vue_type_script_setup_true_lang_default;
+export { Popover_default as default };

package/dist/popover/Popover.vue.d.ts

@@ -0,0 +1,38 @@
+import type { PopoverAction, PopoverExpose, PopoverPlacement, PopoverProps, PopoverSlots } from './interface';
+import '../style';
+import './style/index.css';
+type __VLS_Slots = PopoverSlots;
+declare const __VLS_base: import("vue").DefineComponent<PopoverProps, PopoverExpose, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:open": (open: boolean) => any;
+    action: (action: PopoverAction, index: number) => any;
+    openChange: (open: boolean) => any;
+}, string, import("vue").PublicProps, Readonly<PopoverProps> & Readonly<{
+    "onUpdate:open"?: ((open: boolean) => any) | undefined;
+    onAction?: ((action: PopoverAction, index: number) => any) | undefined;
+    onOpenChange?: ((open: boolean) => any) | undefined;
+}>, {
+    title: string | number | boolean | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }> | import("vue").VNodeArrayChildren | (() => import("vue").VNodeChild) | null;
+    content: string | number | boolean | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }> | import("vue").VNodeArrayChildren | (() => import("vue").VNodeChild) | null;
+    open: boolean;
+    mode: import("./interface").PopoverMode;
+    destroyOnHidden: boolean;
+    placement: PopoverPlacement;
+    closeOnAction: boolean;
+    defaultOpen: boolean;
+    trigger: import("./interface").PopoverTrigger;
+    closeOnClickAway: boolean;
+    arrow: boolean;
+    autoAdjustOverflow: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/popover/Popover.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,311 @@
+import Portal_default from "../_base/Portal.js";
+import { isRenderable } from "../_util/index.js";
+import { nextZIndex } from "../_util/hooks/useZIndex.js";
+import { useClickAway } from "../_util/hooks/useClickAway.js";
+import { useControlled } from "../_util/hooks/useControlled.js";
+import { useEventListener } from "../_util/hooks/useEventListener.js";
+import RenderNode_default from "../_util/RenderNode.js";
+import { computePosition, parsePlacement } from "./position.js";
+import "../style/index2.js";
+import './style/index.css';/* empty css            */
+import { Fragment, Transition, computed, createBlock, createCommentVNode, createElementBlock, createElementVNode, createVNode, defineComponent, mergeProps, nextTick, normalizeClass, normalizeStyle, onMounted, openBlock, ref, renderList, renderSlot, shallowRef, unref, useSlots, vShow, watch, withCtx, withDirectives } from "vue";
+// src/popover/Popover.vue?vue&type=script&setup=true&lang.ts
+var _hoisted_1 = ["dir"];
+var _hoisted_2 = {
+	key: 1,
+	class: "am-popover-menu",
+	role: "menu"
+};
+var _hoisted_3 = ["disabled", "onClick"];
+var _hoisted_4 = {
+	key: 0,
+	class: "am-popover-menu-item-icon"
+};
+var _hoisted_5 = { class: "am-popover-menu-item-text" };
+var Popover_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComponent({
+	name: "AmPopover",
+	inheritAttrs: false,
+	__name: "Popover",
+	props: {
+		open: {
+			type: Boolean,
+			default: void 0
+		},
+		defaultOpen: {
+			type: Boolean,
+			default: false
+		},
+		title: {
+			type: [
+				Object,
+				String,
+				Number,
+				Boolean,
+				null,
+				Array,
+				Function
+			],
+			default: void 0
+		},
+		content: {
+			type: [
+				Object,
+				String,
+				Number,
+				Boolean,
+				null,
+				Array,
+				Function
+			],
+			default: void 0
+		},
+		placement: { default: "top" },
+		trigger: { default: "click" },
+		arrow: {
+			type: Boolean,
+			default: true
+		},
+		color: {},
+		mode: { default: "light" },
+		autoAdjustOverflow: {
+			type: Boolean,
+			default: true
+		},
+		closeOnClickAway: {
+			type: Boolean,
+			default: true
+		},
+		destroyOnHidden: {
+			type: Boolean,
+			default: false
+		},
+		getPopupContainer: {},
+		zIndex: {},
+		actions: {},
+		closeOnAction: {
+			type: Boolean,
+			default: true
+		},
+		rootClass: {},
+		classes: {},
+		styles: {}
+	},
+	emits: [
+		"update:open",
+		"openChange",
+		"action"
+	],
+	setup(__props, { expose: __expose, emit: __emit }) {
+		const props = __props;
+		const emit = __emit;
+		const slots = useSlots();
+		const triggerRef = ref();
+		const popupRef = ref();
+		const innerRef = ref();
+		const [open, setOpen] = useControlled(props, "open", {
+			defaultValue: () => props.defaultOpen,
+			onChange: (value, prev) => {
+				if (value === prev) return;
+				emit("update:open", value);
+				emit("openChange", value);
+			}
+		});
+		const hasTitle = computed(() => !!slots.title || isRenderable(props.title));
+		const hasContent = computed(() => !!slots.content || isRenderable(props.content));
+		const hasActions = computed(() => Array.isArray(props.actions) && props.actions.length > 0);
+		/** the popup is only teleported on the client, once it has been opened */
+		const mounted = ref(false);
+		const rendered = ref(false);
+		/** node returned by `getPopupContainer(trigger)`; `undefined` lets Portal use the ConfigProvider default */
+		const container = shallowRef();
+		const zIndex = ref(props.zIndex);
+		const position = ref({
+			left: 0,
+			top: 0,
+			placement: props.placement,
+			arrowOffset: 0
+		});
+		const side = computed(() => parsePlacement(position.value.placement).side);
+		/** viewport position of the origin that `left / top` of the popup are measured from */
+		function getOrigin(el) {
+			const parent = el.offsetParent;
+			const isStaticBody = parent === document.body && window.getComputedStyle(parent).position === "static";
+			if (!parent || isStaticBody) return {
+				left: -window.scrollX,
+				top: -window.scrollY
+			};
+			const rect = parent.getBoundingClientRect();
+			return {
+				left: rect.left + parent.clientLeft - parent.scrollLeft,
+				top: rect.top + parent.clientTop - parent.scrollTop
+			};
+		}
+		function updatePosition() {
+			const trigger = triggerRef.value;
+			const popup = popupRef.value;
+			const inner = innerRef.value;
+			if (!trigger || !popup || !inner || !open.value) return;
+			const rect = trigger.getBoundingClientRect();
+			const next = computePosition(rect, {
+				width: inner.offsetWidth,
+				height: inner.offsetHeight
+			}, {
+				placement: props.placement,
+				gap: props.arrow ? 10 : 6,
+				autoAdjust: props.autoAdjustOverflow,
+				viewport: {
+					width: document.documentElement.clientWidth || window.innerWidth,
+					height: document.documentElement.clientHeight || window.innerHeight
+				}
+			});
+			const origin = getOrigin(popup);
+			position.value = {
+				...next,
+				left: next.left - origin.left,
+				top: next.top - origin.top
+			};
+		}
+		async function prepare() {
+			const trigger = triggerRef.value;
+			container.value = trigger && props.getPopupContainer?.(trigger) || void 0;
+			zIndex.value = props.zIndex ?? nextZIndex();
+			rendered.value = true;
+			await nextTick();
+			updatePosition();
+		}
+		onMounted(() => {
+			mounted.value = true;
+			if (open.value) prepare();
+		});
+		watch(open, (value) => {
+			if (value && mounted.value) prepare();
+		});
+		watch(() => [
+			props.placement,
+			props.arrow,
+			props.actions,
+			props.title,
+			props.content
+		], () => {
+			if (open.value) nextTick(updatePosition);
+		});
+		watch(() => props.zIndex, (value) => {
+			if (value !== void 0) zIndex.value = value;
+		});
+		function show() {
+			setOpen(true);
+		}
+		function hide() {
+			setOpen(false);
+		}
+		function onTriggerClick() {
+			if (props.trigger === "click") setOpen(!open.value);
+		}
+		const clickAwayEnabled = () => !!open.value && props.closeOnClickAway;
+		useClickAway([triggerRef, popupRef], hide, {
+			eventName: "touchstart",
+			enabled: clickAwayEnabled
+		});
+		useClickAway([triggerRef, popupRef], hide, {
+			eventName: "mousedown",
+			enabled: clickAwayEnabled
+		});
+		useEventListener("resize", updatePosition, { passive: true });
+		useEventListener("scroll", updatePosition, {
+			passive: true,
+			capture: true
+		});
+		function onAction(action, index) {
+			if (action.disabled) return;
+			action.onClick?.(action, index);
+			emit("action", action, index);
+			if (props.closeOnAction) hide();
+		}
+		function onAfterLeave() {
+			if (props.destroyOnHidden) rendered.value = false;
+		}
+		const popupStyle = computed(() => [
+			{
+				left: `${position.value.left}px`,
+				top: `${position.value.top}px`,
+				zIndex: zIndex.value,
+				"--am-popover-arrow-offset": `${position.value.arrowOffset}px`
+			},
+			props.color ? { "--am-popover-bg": props.color } : void 0,
+			props.styles?.root
+		]);
+		__expose({
+			show,
+			hide,
+			updatePosition
+		});
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock(Fragment, null, [createElementVNode("span", mergeProps({
+				ref_key: "triggerRef",
+				ref: triggerRef
+			}, _ctx.$attrs, {
+				class: ["am-popover-trigger", { "am-popover-trigger-open": unref(open) }],
+				onClick: onTriggerClick
+			}), [renderSlot(_ctx.$slots, "default")], 16), mounted.value && rendered.value ? (openBlock(), createBlock(unref(Portal_default), {
+				key: 0,
+				"get-container": container.value
+			}, {
+				default: withCtx(({ theme }) => [createElementVNode("div", {
+					ref_key: "popupRef",
+					ref: popupRef,
+					class: normalizeClass(["am-popover", [
+						theme.class,
+						`am-popover-${__props.mode}`,
+						`am-popover-placement-${position.value.placement}`,
+						`am-popover-side-${side.value}`,
+						{ "am-popover-menu-mode": hasActions.value },
+						__props.rootClass,
+						__props.classes?.root
+					]]),
+					style: normalizeStyle([theme.style, popupStyle.value]),
+					dir: theme.dir
+				}, [createVNode(Transition, {
+					name: "am-popover-zoom",
+					appear: "",
+					onAfterLeave,
+					persisted: ""
+				}, {
+					default: withCtx(() => [withDirectives(createElementVNode("div", {
+						ref_key: "innerRef",
+						ref: innerRef,
+						class: normalizeClass(["am-popover-inner", __props.classes?.container]),
+						style: normalizeStyle(__props.styles?.container),
+						role: "tooltip"
+					}, [__props.arrow ? (openBlock(), createElementBlock("span", {
+						key: 0,
+						class: normalizeClass(["am-popover-arrow", __props.classes?.arrow]),
+						style: normalizeStyle(__props.styles?.arrow)
+					}, null, 6)) : createCommentVNode("", true), hasActions.value ? (openBlock(), createElementBlock("div", _hoisted_2, [(openBlock(true), createElementBlock(Fragment, null, renderList(__props.actions, (action, index) => {
+						return openBlock(), createElementBlock("button", {
+							key: action.key,
+							type: "button",
+							role: "menuitem",
+							class: normalizeClass(["am-popover-menu-item", {
+								"am-popover-menu-item-disabled": action.disabled,
+								"am-popover-menu-item-danger": action.danger
+							}]),
+							disabled: action.disabled || void 0,
+							onClick: ($event) => onAction(action, index)
+						}, [unref(isRenderable)(action.icon) ? (openBlock(), createElementBlock("span", _hoisted_4, [createVNode(unref(RenderNode_default), { node: action.icon }, null, 8, ["node"])])) : createCommentVNode("", true), createElementVNode("span", _hoisted_5, [createVNode(unref(RenderNode_default), { node: action.text }, null, 8, ["node"])])], 10, _hoisted_3);
+					}), 128))])) : (openBlock(), createElementBlock(Fragment, { key: 2 }, [hasTitle.value ? (openBlock(), createElementBlock("div", {
+						key: 0,
+						class: normalizeClass(["am-popover-title", __props.classes?.title]),
+						style: normalizeStyle(__props.styles?.title)
+					}, [renderSlot(_ctx.$slots, "title", {}, () => [createVNode(unref(RenderNode_default), { node: __props.title }, null, 8, ["node"])])], 6)) : createCommentVNode("", true), hasContent.value ? (openBlock(), createElementBlock("div", {
+						key: 1,
+						class: normalizeClass(["am-popover-content", __props.classes?.content]),
+						style: normalizeStyle(__props.styles?.content)
+					}, [renderSlot(_ctx.$slots, "content", {}, () => [createVNode(unref(RenderNode_default), { node: __props.content }, null, 8, ["node"])])], 6)) : createCommentVNode("", true)], 64))], 6), [[vShow, unref(open)]])]),
+					_: 3
+				})], 14, _hoisted_1)]),
+				_: 3
+			}, 8, ["get-container"])) : createCommentVNode("", true)], 64);
+		};
+	}
+});
+export { Popover_vue_vue_type_script_setup_true_lang_default as default };

package/dist/popover/index.d.ts

@@ -0,0 +1,88 @@
+export type * from './interface';
+declare const Popover: import("../_util/withInstall").WithInstall<{
+    new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("./interface").PopoverProps> & Readonly<{
+        "onUpdate:open"?: ((open: boolean) => any) | undefined;
+        onAction?: ((action: import("./interface").PopoverAction, index: number) => any) | undefined;
+        onOpenChange?: ((open: boolean) => any) | undefined;
+    }>, import("./interface").PopoverExpose, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+        "update:open": (open: boolean) => any;
+        action: (action: import("./interface").PopoverAction, index: number) => any;
+        openChange: (open: boolean) => any;
+    }, import("vue").PublicProps, {
+        title: string | number | boolean | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }> | import("vue").VNodeArrayChildren | (() => import("vue").VNodeChild) | null;
+        content: string | number | boolean | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }> | import("vue").VNodeArrayChildren | (() => import("vue").VNodeChild) | null;
+        open: boolean;
+        mode: import("./interface").PopoverMode;
+        destroyOnHidden: boolean;
+        placement: import("./interface").PopoverPlacement;
+        closeOnAction: boolean;
+        defaultOpen: boolean;
+        trigger: import("./interface").PopoverTrigger;
+        closeOnClickAway: boolean;
+        arrow: boolean;
+        autoAdjustOverflow: boolean;
+    }, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import("./interface").PopoverProps> & Readonly<{
+        "onUpdate:open"?: ((open: boolean) => any) | undefined;
+        onAction?: ((action: import("./interface").PopoverAction, index: number) => any) | undefined;
+        onOpenChange?: ((open: boolean) => any) | undefined;
+    }>, import("./interface").PopoverExpose, {}, {}, {}, {
+        title: string | number | boolean | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }> | import("vue").VNodeArrayChildren | (() => import("vue").VNodeChild) | null;
+        content: string | number | boolean | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }> | import("vue").VNodeArrayChildren | (() => import("vue").VNodeChild) | null;
+        open: boolean;
+        mode: import("./interface").PopoverMode;
+        destroyOnHidden: boolean;
+        placement: import("./interface").PopoverPlacement;
+        closeOnAction: boolean;
+        defaultOpen: boolean;
+        trigger: import("./interface").PopoverTrigger;
+        closeOnClickAway: boolean;
+        arrow: boolean;
+        autoAdjustOverflow: boolean;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import("vue").ComponentOptionsBase<Readonly<import("./interface").PopoverProps> & Readonly<{
+    "onUpdate:open"?: ((open: boolean) => any) | undefined;
+    onAction?: ((action: import("./interface").PopoverAction, index: number) => any) | undefined;
+    onOpenChange?: ((open: boolean) => any) | undefined;
+}>, import("./interface").PopoverExpose, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:open": (open: boolean) => any;
+    action: (action: import("./interface").PopoverAction, index: number) => any;
+    openChange: (open: boolean) => any;
+}, string, {
+    title: string | number | boolean | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }> | import("vue").VNodeArrayChildren | (() => import("vue").VNodeChild) | null;
+    content: string | number | boolean | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }> | import("vue").VNodeArrayChildren | (() => import("vue").VNodeChild) | null;
+    open: boolean;
+    mode: import("./interface").PopoverMode;
+    destroyOnHidden: boolean;
+    placement: import("./interface").PopoverPlacement;
+    closeOnAction: boolean;
+    defaultOpen: boolean;
+    trigger: import("./interface").PopoverTrigger;
+    closeOnClickAway: boolean;
+    arrow: boolean;
+    autoAdjustOverflow: 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").PopoverSlots;
+}), object>;
+export default Popover;

package/dist/popover/index.js

@@ -0,0 +1,5 @@
+import { withInstall } from "../_util/withInstall.js";
+import Popover_default from "./Popover.js";
+// src/popover/index.ts
+var Popover = withInstall(Popover_default, "AmPopover");
+export { Popover as default };