@antdv-next/mobile 0.0.0-stage → 0.1.0

package/dist/float-button/interface.d.ts

@@ -0,0 +1,138 @@
+import type { CSSProperties } from 'vue';
+import type { VueNode } from '../_util/type';
+export type FloatButtonType = 'default' | 'primary';
+export type FloatButtonShape = 'circle' | 'square';
+export type FloatButtonHTMLType = 'submit' | 'button' | 'reset';
+export type FloatButtonAxis = 'x' | 'y' | 'xy';
+export type FloatButtonMagnetic = 'x' | 'y';
+export type FloatButtonGroupTrigger = 'click';
+export type FloatButtonGroupPlacement = 'top' | 'left' | 'right' | 'bottom';
+export interface FloatButtonOffset {
+    x: number;
+    y: number;
+}
+export interface FloatButtonBadgeProps {
+    count?: number | string;
+    /** Show a red dot instead of the count */
+    dot?: boolean;
+    /** Show `${overflowCount}+` when the count is larger */
+    overflowCount?: number;
+    showZero?: boolean;
+    color?: string;
+}
+export interface FloatButtonSemanticClassNames {
+    root?: string;
+    icon?: string;
+    content?: string;
+    badge?: string;
+}
+export interface FloatButtonSemanticStyles {
+    root?: CSSProperties;
+    icon?: CSSProperties;
+    content?: CSSProperties;
+    badge?: CSSProperties;
+}
+export interface FloatButtonProps {
+    icon?: VueNode;
+    /** Text below the icon */
+    content?: VueNode;
+    /** @deprecated use `content` */
+    description?: VueNode;
+    type?: FloatButtonType;
+    shape?: FloatButtonShape;
+    href?: string;
+    target?: string;
+    htmlType?: FloatButtonHTMLType;
+    badge?: FloatButtonBadgeProps;
+    ariaLabel?: string;
+    /** Let the user drag the button around */
+    draggable?: boolean;
+    /** Axis the button can be dragged along */
+    axis?: FloatButtonAxis;
+    /** Snap to the nearest edge of that axis when released */
+    magnetic?: FloatButtonMagnetic;
+    /** Top-left position in px (relative to the viewport, or the offset parent when positioned absolutely). Supports `v-model:offset`. */
+    offset?: FloatButtonOffset;
+    /** Minimal distance to the edges while dragging */
+    gap?: number;
+    rootClass?: string;
+    classes?: FloatButtonSemanticClassNames;
+    styles?: FloatButtonSemanticStyles;
+}
+export interface FloatButtonEmits {
+    'click': [event: MouseEvent];
+    'update:offset': [offset: FloatButtonOffset];
+    /** The button was dropped at a new position */
+    'offsetChange': [offset: FloatButtonOffset];
+}
+export interface FloatButtonSlots {
+    /** Content below the icon */
+    default?: () => any;
+    icon?: () => any;
+}
+export interface FloatButtonGroupSemanticClassNames {
+    root?: string;
+    list?: string;
+    trigger?: string;
+}
+export interface FloatButtonGroupSemanticStyles {
+    root?: CSSProperties;
+    list?: CSSProperties;
+    trigger?: CSSProperties;
+}
+export interface FloatButtonGroupProps {
+    /** Shape of every button inside */
+    shape?: FloatButtonShape;
+    /** Menu mode: the buttons are revealed by a trigger button */
+    trigger?: FloatButtonGroupTrigger;
+    /** Whether the menu is expanded. Supports `v-model:open`. */
+    open?: boolean;
+    defaultOpen?: boolean;
+    /** Where the menu pops out */
+    placement?: FloatButtonGroupPlacement;
+    /** Icon of the trigger while expanded */
+    closeIcon?: VueNode;
+    /** Icon of the trigger */
+    icon?: VueNode;
+    content?: VueNode;
+    type?: FloatButtonType;
+    badge?: FloatButtonBadgeProps;
+    rootClass?: string;
+    classes?: FloatButtonGroupSemanticClassNames;
+    styles?: FloatButtonGroupSemanticStyles;
+}
+export interface FloatButtonGroupEmits {
+    'update:open': [open: boolean];
+    'openChange': [open: boolean];
+    /** The trigger button was clicked (menu mode) */
+    'click': [event: MouseEvent];
+}
+export interface FloatButtonGroupSlots {
+    default?: () => any;
+    icon?: () => any;
+    closeIcon?: () => any;
+}
+export interface BackTopProps {
+    /** The button shows up once the scroll offset reaches this value */
+    visibilityHeight?: number;
+    /** The scrolling element to listen on, default `window` */
+    target?: () => HTMLElement | Window;
+    /** Duration of the scroll animation in ms */
+    duration?: number;
+    icon?: VueNode;
+    content?: VueNode;
+    type?: FloatButtonType;
+    shape?: FloatButtonShape;
+    badge?: FloatButtonBadgeProps;
+    ariaLabel?: string;
+    rootClass?: string;
+    classes?: FloatButtonSemanticClassNames;
+    styles?: FloatButtonSemanticStyles;
+}
+export interface BackTopEmits {
+    click: [event: MouseEvent];
+}
+export interface BackTopSlots {
+    default?: () => any;
+    icon?: () => any;
+}

package/dist/float-button/style/index.css

@@ -0,0 +1,234 @@
+.am-float-button:not(.am-float-button-in-group),
+.am-float-button-group {
+  --am-float-button-size: 48px;
+  --am-float-button-inset-inline-end: 24px;
+  --am-float-button-inset-block-end: 48px;
+  --am-float-button-z-index: 99;
+  --am-float-button-bg: var(--am-color-bg-elevated);
+  --am-float-button-color: var(--am-color-text);
+  --am-float-button-primary-bg: var(--am-color-primary);
+  --am-float-button-primary-color: var(--am-color-text-light-solid);
+  --am-float-button-icon-size: 20px;
+  --am-float-button-content-font-size: 10px;
+  --am-float-button-border-radius: var(--am-border-radius);
+  --am-float-button-shadow: var(--am-box-shadow);
+  --am-float-button-group-gap: var(--am-margin-sm);
+
+  position: fixed;
+  inset-block-end: var(--am-float-button-inset-block-end);
+  inset-block-end: calc(var(--am-float-button-inset-block-end) + constant(safe-area-inset-bottom));
+  inset-block-end: calc(var(--am-float-button-inset-block-end) + env(safe-area-inset-bottom));
+  inset-inline-end: var(--am-float-button-inset-inline-end);
+  inset-inline-end: calc(var(--am-float-button-inset-inline-end) + constant(safe-area-inset-right));
+  inset-inline-end: calc(var(--am-float-button-inset-inline-end) + env(safe-area-inset-right));
+  z-index: var(--am-float-button-z-index);
+}
+
+.am-float-button {
+  display: inline-flex;
+  box-sizing: border-box;
+  font-family: var(--am-font-family);
+  align-items: center;
+  justify-content: center;
+  width: var(--am-float-button-size);
+  height: var(--am-float-button-size);
+  margin: 0;
+  padding: 0;
+  color: var(--am-float-button-color);
+  font-size: var(--am-font-size);
+  line-height: 1;
+  text-decoration: none;
+  background: var(--am-float-button-bg);
+  border: 0;
+  border-radius: var(--am-float-button-border-radius);
+  outline: none;
+  box-shadow: var(--am-float-button-shadow);
+  cursor: pointer;
+  transition:
+    opacity var(--am-motion-duration-mid),
+    transform var(--am-motion-duration-slow) var(--am-motion-ease-out);
+  user-select: none;
+  touch-action: manipulation;
+  -webkit-tap-highlight-color: transparent;
+  appearance: none;
+}
+
+.am-float-button:active {
+  opacity: var(--am-opacity-active);
+}
+
+.am-float-button-circle {
+  border-radius: 50%;
+}
+
+.am-float-button-primary {
+  color: var(--am-float-button-primary-color);
+  background: var(--am-float-button-primary-bg);
+}
+
+.am-float-button-draggable {
+  touch-action: none;
+}
+
+.am-float-button-dragging {
+  cursor: grabbing;
+  transition: none;
+}
+
+.am-float-button-body {
+  display: flex;
+  flex-direction: column;
+  gap: 2px;
+  align-items: center;
+  justify-content: center;
+  width: 100%;
+  height: 100%;
+  overflow: hidden;
+  border-radius: inherit;
+}
+
+.am-float-button-icon {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  font-size: var(--am-float-button-icon-size);
+}
+
+.am-float-button-with-content .am-float-button-icon {
+  font-size: calc(var(--am-float-button-icon-size) - 4px);
+}
+
+.am-float-button-content {
+  max-width: 100%;
+  overflow: hidden;
+  font-size: var(--am-float-button-content-font-size);
+  line-height: 1.2;
+  white-space: nowrap;
+  text-overflow: ellipsis;
+}
+
+/* the bubble is BaseBadge; only its size tokens, outline and position are set here */
+.am-float-button-badge {
+  --am-base-badge-size: 16px;
+  --am-base-badge-font-size: 10px;
+
+  position: absolute;
+  top: 0;
+  inset-inline-end: 0;
+  z-index: 1;
+  padding: 0 4px;
+  box-shadow: 0 0 0 1px var(--am-color-bg-container);
+  transform: translate(25%, -25%);
+}
+
+[dir='rtl'] .am-float-button-badge {
+  transform: translate(-25%, -25%);
+}
+
+.am-float-button-badge-dot {
+  padding: 0;
+}
+
+.am-float-button-circle .am-float-button-badge-dot {
+  top: 4px;
+  inset-inline-end: 4px;
+  transform: none;
+}
+
+/* ---------- group ---------- */
+.am-float-button-group {
+  display: flex;
+  box-sizing: border-box;
+  width: var(--am-float-button-size);
+  min-height: var(--am-float-button-size);
+}
+
+.am-float-button-in-group {
+  position: relative;
+  flex: none;
+}
+
+.am-float-button-group-list {
+  display: flex;
+  flex-direction: column;
+  gap: var(--am-float-button-group-gap);
+  align-items: center;
+}
+
+/* a square group without trigger is rendered as one card */
+.am-float-button-group-square:not(.am-float-button-group-menu) .am-float-button-group-list {
+  gap: 0;
+  overflow: hidden;
+  background: var(--am-float-button-bg);
+  border-radius: var(--am-float-button-border-radius);
+  box-shadow: var(--am-float-button-shadow);
+}
+
+.am-float-button-group-square:not(.am-float-button-group-menu) .am-float-button {
+  border-radius: 0;
+  box-shadow: none;
+}
+
+.am-float-button-group-square:not(.am-float-button-group-menu) .am-float-button + .am-float-button::before {
+  position: absolute;
+  top: 0;
+  right: 4px;
+  left: 4px;
+  border-top: var(--am-line-width) var(--am-line-type) var(--am-color-split);
+  transform: scaleY(0.5);
+  transform-origin: top;
+  content: '';
+  pointer-events: none;
+}
+
+/* menu mode: the list pops out of the trigger */
+.am-float-button-group-menu .am-float-button-group-list {
+  position: absolute;
+}
+
+.am-float-button-group-top .am-float-button-group-list {
+  bottom: calc(100% + var(--am-float-button-group-gap));
+  left: 0;
+  transform-origin: center bottom;
+}
+
+.am-float-button-group-bottom .am-float-button-group-list {
+  top: calc(100% + var(--am-float-button-group-gap));
+  left: 0;
+  transform-origin: center top;
+}
+
+.am-float-button-group-left .am-float-button-group-list {
+  top: 0;
+  right: calc(100% + var(--am-float-button-group-gap));
+  flex-direction: row;
+  transform-origin: right center;
+}
+
+.am-float-button-group-right .am-float-button-group-list {
+  top: 0;
+  left: calc(100% + var(--am-float-button-group-gap));
+  flex-direction: row;
+  transform-origin: left center;
+}
+
+.am-float-button-group-motion-enter-active,
+.am-float-button-group-motion-leave-active {
+  transition:
+    opacity var(--am-motion-duration-mid) var(--am-motion-ease-out),
+    transform var(--am-motion-duration-mid) var(--am-motion-ease-out);
+}
+
+.am-float-button-group-motion-enter-from,
+.am-float-button-group-motion-leave-to {
+  transform: scale(0.6);
+  opacity: 0;
+}
+
+@media (prefers-reduced-motion: reduce) {
+  .am-float-button,
+  .am-float-button-group-motion-enter-active,
+  .am-float-button-group-motion-leave-active {
+    transition-duration: 0.01s;
+  }
+}

package/dist/floating-panel/FloatingPanel.js

@@ -0,0 +1,4 @@
+import FloatingPanel_vue_vue_type_script_setup_true_lang_default from "./FloatingPanel.vue_vue_type_script_setup_true_lang.js";
+// src/floating-panel/FloatingPanel.vue
+var FloatingPanel_default = FloatingPanel_vue_vue_type_script_setup_true_lang_default;
+export { FloatingPanel_default as default };

package/dist/floating-panel/FloatingPanel.vue.d.ts

@@ -0,0 +1,34 @@
+import type { FloatingPanelProps, FloatingPanelSlots } from './interface';
+import '../style';
+import './style/index.css';
+type __VLS_Slots = FloatingPanelSlots;
+declare function setHeight(value: number, options?: {
+    immediate?: boolean;
+}): void;
+declare const __VLS_base: import("vue").DefineComponent<FloatingPanelProps, {
+    setHeight: typeof setHeight;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:height": (height: number) => any;
+    heightChange: (height: number, info: {
+        animating: boolean;
+    }) => any;
+}, string, import("vue").PublicProps, Readonly<FloatingPanelProps> & Readonly<{
+    "onUpdate:height"?: ((height: number) => any) | undefined;
+    onHeightChange?: ((height: number, info: {
+        animating: boolean;
+    }) => any) | undefined;
+}>, {
+    fixed: boolean;
+    safeArea: boolean;
+    lockScroll: boolean;
+    duration: number;
+    contentDraggable: 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/floating-panel/FloatingPanel.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,197 @@
+import { clamp, doubleRaf, preventDefault } from "../_util/index.js";
+import { useControlled } from "../_util/hooks/useControlled.js";
+import { useEventListener } from "../_util/hooks/useEventListener.js";
+import { useLockScroll } from "../_util/hooks/useLockScroll.js";
+import { useTouch } from "../_util/hooks/useTouch.js";
+import "../style/index2.js";
+import './style/index.css';/* empty css            */
+import { computed, createElementBlock, createElementVNode, defineComponent, mergeProps, normalizeClass, normalizeStyle, onMounted, openBlock, ref, renderSlot, watch } from "vue";
+// src/floating-panel/FloatingPanel.vue?vue&type=script&setup=true&lang.ts
+var DAMP = .2;
+/** px / ms, a faster flick moves to the next anchor in that direction */
+var VELOCITY = .5;
+var DEFAULT_MIN = 100;
+var FloatingPanel_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComponent({
+	name: "AmFloatingPanel",
+	inheritAttrs: false,
+	__name: "FloatingPanel",
+	props: {
+		height: {},
+		anchors: {},
+		contentDraggable: {
+			type: Boolean,
+			default: true
+		},
+		duration: { default: 300 },
+		safeArea: {
+			type: Boolean,
+			default: true
+		},
+		lockScroll: {
+			type: Boolean,
+			default: false
+		},
+		fixed: {
+			type: Boolean,
+			default: true
+		},
+		zIndex: {},
+		rootClass: {},
+		classes: {},
+		styles: {}
+	},
+	emits: ["update:height", "heightChange"],
+	setup(__props, { expose: __expose, emit: __emit }) {
+		const props = __props;
+		const emit = __emit;
+		/** how much the panel follows the finger beyond the first / last anchor */
+		const touch = useTouch();
+		const rootRef = ref();
+		const contentRef = ref();
+		/** height available to the panel, measured on mount (viewport or positioned parent) */
+		const availableHeight = ref(0);
+		const dragging = ref(false);
+		const immediate = ref(false);
+		const anchors = computed(() => {
+			if (props.anchors?.length) return [...props.anchors].sort((a, b) => a - b);
+			return [DEFAULT_MIN, Math.max(Math.round(availableHeight.value * .6), DEFAULT_MIN)];
+		});
+		const boundary = computed(() => ({
+			min: anchors.value[0],
+			max: anchors.value[anchors.value.length - 1]
+		}));
+		const [height, setHeightState] = useControlled(props, "height", {
+			defaultValue: () => boundary.value.min,
+			onChange: (value) => emit("update:height", value)
+		});
+		function closest(list, target) {
+			return list.reduce((prev, cur) => Math.abs(prev - target) <= Math.abs(cur - target) ? prev : cur);
+		}
+		function ease(moveY) {
+			const abs = Math.abs(moveY);
+			const { min, max } = boundary.value;
+			if (abs > max) return -(max + (abs - max) * DAMP);
+			if (abs < min) return -(min - (min - abs) * DAMP);
+			return moveY;
+		}
+		function setHeight(value, options = {}) {
+			const next = Math.max(value, 0);
+			if (options.immediate) {
+				immediate.value = true;
+				doubleRaf(() => {
+					immediate.value = false;
+				});
+			}
+			if (next !== height.value) {
+				setHeightState(next);
+				emit("heightChange", next, { animating: !options.immediate });
+			}
+		}
+		function measure() {
+			const root = rootRef.value;
+			if (!root) return;
+			const parent = props.fixed ? null : root.offsetParent;
+			availableHeight.value = parent?.clientHeight || window.innerHeight;
+		}
+		onMounted(() => {
+			measure();
+			if (props.height === void 0 && height.value !== boundary.value.min) setHeightState(boundary.value.min);
+		});
+		useEventListener("resize", measure);
+		watch(() => props.fixed, measure, { flush: "post" });
+		watch(boundary, () => {
+			if (dragging.value) return;
+			const next = closest(anchors.value, height.value);
+			if (next !== height.value) setHeight(next);
+		});
+		let startY = 0;
+		let startTime = 0;
+		let maxScroll = -1;
+		function onTouchStart(event) {
+			touch.start(event);
+			dragging.value = true;
+			startY = -height.value;
+			startTime = Date.now();
+			maxScroll = -1;
+		}
+		function onTouchMove(event) {
+			if (!dragging.value) return;
+			touch.move(event);
+			const target = event.target;
+			const content = contentRef.value;
+			if (content && (content === target || content.contains(target))) {
+				const { scrollTop } = content;
+				maxScroll = Math.max(maxScroll, scrollTop);
+				if (!props.contentDraggable) return;
+				if (-startY < boundary.value.max) preventDefault(event, true);
+				else if (!(scrollTop <= 0 && touch.deltaY.value > 0) || maxScroll > 0) return;
+			} else preventDefault(event, true);
+			const next = -ease(touch.deltaY.value + startY);
+			if (next !== height.value) {
+				setHeightState(next);
+				emit("heightChange", next, { animating: false });
+			}
+		}
+		function onTouchEnd() {
+			if (!dragging.value) return;
+			maxScroll = -1;
+			dragging.value = false;
+			const startHeight = -startY;
+			const moved = height.value !== startHeight;
+			const distance = touch.deltaY.value;
+			const velocity = distance / Math.max(Date.now() - startTime, 1);
+			let target = closest(anchors.value, height.value);
+			if (moved && Math.abs(velocity) > VELOCITY && Math.abs(distance) > 10) {
+				if (velocity < 0) target = anchors.value.find((anchor) => anchor > startHeight) ?? boundary.value.max;
+				else target = [...anchors.value].reverse().find((anchor) => anchor < startHeight) ?? boundary.value.min;
+			}
+			if (target !== height.value) {
+				setHeightState(target);
+				emit("heightChange", target, { animating: true });
+			} else if (moved) emit("heightChange", target, { animating: true });
+		}
+		useLockScroll(rootRef, () => props.lockScroll || dragging.value);
+		useEventListener("touchmove", onTouchMove, {
+			target: rootRef,
+			passive: false
+		});
+		const rootStyle = computed(() => ({
+			height: `${boundary.value.max}px`,
+			transform: `translateY(calc(100% - ${clamp(height.value, 0, Number.MAX_SAFE_INTEGER)}px))`,
+			transitionDuration: dragging.value || immediate.value ? "0ms" : `${props.duration}ms`,
+			zIndex: props.zIndex
+		}));
+		const classNames = computed(() => [
+			"am-floating-panel",
+			{
+				"am-floating-panel-absolute": !props.fixed,
+				"am-floating-panel-safe-area": props.safeArea,
+				"am-floating-panel-dragging": dragging.value
+			},
+			props.rootClass,
+			props.classes?.root
+		]);
+		__expose({ setHeight });
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock("div", mergeProps({
+				ref_key: "rootRef",
+				ref: rootRef
+			}, _ctx.$attrs, {
+				class: classNames.value,
+				style: [rootStyle.value, __props.styles?.root],
+				onTouchstartPassive: onTouchStart,
+				onTouchend: onTouchEnd,
+				onTouchcancel: onTouchEnd
+			}), [createElementVNode("div", {
+				class: normalizeClass(["am-floating-panel-header", __props.classes?.header]),
+				style: normalizeStyle(__props.styles?.header)
+			}, [renderSlot(_ctx.$slots, "header", {}, () => [_cache[0] || (_cache[0] = createElementVNode("div", { class: "am-floating-panel-bar" }, null, -1))])], 6), createElementVNode("div", {
+				ref_key: "contentRef",
+				ref: contentRef,
+				class: normalizeClass(["am-floating-panel-content", __props.classes?.content]),
+				style: normalizeStyle(__props.styles?.content)
+			}, [renderSlot(_ctx.$slots, "default")], 6)], 16);
+		};
+	}
+});
+export { FloatingPanel_vue_vue_type_script_setup_true_lang_default as default };

package/dist/floating-panel/index.d.ts

@@ -0,0 +1,72 @@
+export type * from './interface';
+declare const FloatingPanel: import("../_util/withInstall").WithInstall<{
+    new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("./interface").FloatingPanelProps> & Readonly<{
+        "onUpdate:height"?: ((height: number) => any) | undefined;
+        onHeightChange?: ((height: number, info: {
+            animating: boolean;
+        }) => any) | undefined;
+    }>, {
+        setHeight: (value: number, options?: {
+            immediate?: boolean;
+        }) => void;
+    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+        "update:height": (height: number) => any;
+        heightChange: (height: number, info: {
+            animating: boolean;
+        }) => any;
+    }, import("vue").PublicProps, {
+        fixed: boolean;
+        safeArea: boolean;
+        lockScroll: boolean;
+        duration: number;
+        contentDraggable: boolean;
+    }, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import("./interface").FloatingPanelProps> & Readonly<{
+        "onUpdate:height"?: ((height: number) => any) | undefined;
+        onHeightChange?: ((height: number, info: {
+            animating: boolean;
+        }) => any) | undefined;
+    }>, {
+        setHeight: (value: number, options?: {
+            immediate?: boolean;
+        }) => void;
+    }, {}, {}, {}, {
+        fixed: boolean;
+        safeArea: boolean;
+        lockScroll: boolean;
+        duration: number;
+        contentDraggable: boolean;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import("vue").ComponentOptionsBase<Readonly<import("./interface").FloatingPanelProps> & Readonly<{
+    "onUpdate:height"?: ((height: number) => any) | undefined;
+    onHeightChange?: ((height: number, info: {
+        animating: boolean;
+    }) => any) | undefined;
+}>, {
+    setHeight: (value: number, options?: {
+        immediate?: boolean;
+    }) => void;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:height": (height: number) => any;
+    heightChange: (height: number, info: {
+        animating: boolean;
+    }) => any;
+}, string, {
+    fixed: boolean;
+    safeArea: boolean;
+    lockScroll: boolean;
+    duration: number;
+    contentDraggable: 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").FloatingPanelSlots;
+}), object>;
+export default FloatingPanel;

package/dist/floating-panel/index.js

@@ -0,0 +1,5 @@
+import { withInstall } from "../_util/withInstall.js";
+import FloatingPanel_default from "./FloatingPanel.js";
+// src/floating-panel/index.ts
+var FloatingPanel = withInstall(FloatingPanel_default, "AmFloatingPanel");
+export { FloatingPanel as default };