@antdv-next/mobile 0.0.0-stage → 0.1.1

package/dist/drawer/index.d.ts

@@ -0,0 +1,127 @@
+export type * from './interface';
+declare const Drawer: import("../_util/withInstall").WithInstall<{
+    new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("./interface").DrawerProps> & Readonly<{
+        onClose?: ((event?: Event | undefined) => any) | undefined;
+        "onUpdate:open"?: ((open: boolean) => any) | undefined;
+        onAfterOpenChange?: ((open: boolean) => any) | undefined;
+    }>, {
+        nativeElement: import("vue").ComputedRef<HTMLElement | undefined>;
+    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+        close: (event?: Event | undefined) => any;
+        "update:open": (open: boolean) => any;
+        afterOpenChange: (open: boolean) => any;
+    }, import("vue").PublicProps, {
+        round: boolean;
+        footer: string | number | boolean | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }> | import("vue").VNodeArrayChildren | (() => import("vue").VNodeChild) | null;
+        title: string | number | boolean | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }> | import("vue").VNodeArrayChildren | (() => import("vue").VNodeChild) | null;
+        mask: boolean;
+        safeArea: boolean;
+        size: import("./interface").DrawerSize;
+        open: boolean;
+        getContainer: import("../index.ts").GetContainer;
+        loading: boolean;
+        lockScroll: boolean;
+        closable: boolean | import("./interface").DrawerClosableConfig;
+        destroyOnHidden: boolean;
+        placement: import("./interface").DrawerPlacement;
+        maskClosable: boolean;
+        closeIcon: string | number | boolean | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }> | import("vue").VNodeArrayChildren | (() => import("vue").VNodeChild) | null;
+        forceRender: boolean;
+        keyboard: boolean;
+        extra: string | number | boolean | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }> | import("vue").VNodeArrayChildren | (() => import("vue").VNodeChild) | null;
+        swipeToClose: boolean;
+    }, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import("./interface").DrawerProps> & Readonly<{
+        onClose?: ((event?: Event | undefined) => any) | undefined;
+        "onUpdate:open"?: ((open: boolean) => any) | undefined;
+        onAfterOpenChange?: ((open: boolean) => any) | undefined;
+    }>, {
+        nativeElement: import("vue").ComputedRef<HTMLElement | undefined>;
+    }, {}, {}, {}, {
+        round: boolean;
+        footer: string | number | boolean | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }> | import("vue").VNodeArrayChildren | (() => import("vue").VNodeChild) | null;
+        title: string | number | boolean | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }> | import("vue").VNodeArrayChildren | (() => import("vue").VNodeChild) | null;
+        mask: boolean;
+        safeArea: boolean;
+        size: import("./interface").DrawerSize;
+        open: boolean;
+        getContainer: import("../index.ts").GetContainer;
+        loading: boolean;
+        lockScroll: boolean;
+        closable: boolean | import("./interface").DrawerClosableConfig;
+        destroyOnHidden: boolean;
+        placement: import("./interface").DrawerPlacement;
+        maskClosable: boolean;
+        closeIcon: string | number | boolean | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }> | import("vue").VNodeArrayChildren | (() => import("vue").VNodeChild) | null;
+        forceRender: boolean;
+        keyboard: boolean;
+        extra: string | number | boolean | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }> | import("vue").VNodeArrayChildren | (() => import("vue").VNodeChild) | null;
+        swipeToClose: boolean;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import("vue").ComponentOptionsBase<Readonly<import("./interface").DrawerProps> & Readonly<{
+    onClose?: ((event?: Event | undefined) => any) | undefined;
+    "onUpdate:open"?: ((open: boolean) => any) | undefined;
+    onAfterOpenChange?: ((open: boolean) => any) | undefined;
+}>, {
+    nativeElement: import("vue").ComputedRef<HTMLElement | undefined>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    close: (event?: Event | undefined) => any;
+    "update:open": (open: boolean) => any;
+    afterOpenChange: (open: boolean) => any;
+}, string, {
+    round: boolean;
+    footer: string | number | boolean | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }> | import("vue").VNodeArrayChildren | (() => import("vue").VNodeChild) | null;
+    title: string | number | boolean | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }> | import("vue").VNodeArrayChildren | (() => import("vue").VNodeChild) | null;
+    mask: boolean;
+    safeArea: boolean;
+    size: import("./interface").DrawerSize;
+    open: boolean;
+    getContainer: import("../index.ts").GetContainer;
+    loading: boolean;
+    lockScroll: boolean;
+    closable: boolean | import("./interface").DrawerClosableConfig;
+    destroyOnHidden: boolean;
+    placement: import("./interface").DrawerPlacement;
+    maskClosable: boolean;
+    closeIcon: string | number | boolean | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }> | import("vue").VNodeArrayChildren | (() => import("vue").VNodeChild) | null;
+    forceRender: boolean;
+    keyboard: boolean;
+    extra: string | number | boolean | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }> | import("vue").VNodeArrayChildren | (() => import("vue").VNodeChild) | null;
+    swipeToClose: 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").DrawerSlots;
+}), object>;
+export default Drawer;

package/dist/drawer/index.js

@@ -0,0 +1,5 @@
+import { withInstall } from "../_util/withInstall.js";
+import Drawer_default from "./Drawer.js";
+// src/drawer/index.ts
+var Drawer = withInstall(Drawer_default, "AmDrawer");
+export { Drawer as default };

package/dist/drawer/interface.d.ts

@@ -0,0 +1,87 @@
+import type { CSSProperties } from 'vue';
+import type { GetContainer, Numeric, VueNode } from '../_util/type';
+export type DrawerPlacement = 'top' | 'right' | 'bottom' | 'left';
+export type DrawerSize = 'default' | 'large' | number | string;
+export interface DrawerClosableConfig {
+    closeIcon?: VueNode;
+    disabled?: boolean;
+    /** Side of the header the close button sits on */
+    placement?: 'start' | 'end';
+}
+export interface DrawerSemanticClassNames {
+    root?: string;
+    mask?: string;
+    section?: string;
+    header?: string;
+    title?: string;
+    extra?: string;
+    body?: string;
+    footer?: string;
+    close?: string;
+    handle?: string;
+}
+export interface DrawerSemanticStyles {
+    root?: CSSProperties;
+    mask?: CSSProperties;
+    section?: CSSProperties;
+    header?: CSSProperties;
+    title?: CSSProperties;
+    extra?: CSSProperties;
+    body?: CSSProperties;
+    footer?: CSSProperties;
+    close?: CSSProperties;
+    handle?: CSSProperties;
+}
+export interface DrawerProps {
+    /** Whether the drawer is visible. Supports `v-model:open`. */
+    open?: boolean;
+    title?: VueNode;
+    /** Extra actions at the end of the header */
+    extra?: VueNode;
+    footer?: VueNode;
+    /** Mobile default is `'bottom'` (PC: `'right'`) */
+    placement?: DrawerPlacement;
+    closable?: boolean | DrawerClosableConfig;
+    closeIcon?: VueNode;
+    mask?: boolean;
+    maskClosable?: boolean;
+    /** Close on ESC */
+    keyboard?: boolean;
+    /** `'default'` fits the content (top / bottom) or 80% (left / right); `'large'` is 90% / 100%; or a custom size */
+    size?: DrawerSize;
+    /** Width of a left / right drawer, wins over `size` */
+    width?: Numeric;
+    /** Height of a top / bottom drawer, wins over `size` */
+    height?: Numeric;
+    destroyOnHidden?: boolean;
+    forceRender?: boolean;
+    getContainer?: GetContainer;
+    zIndex?: number;
+    /** Show a loading indicator instead of the content */
+    loading?: boolean;
+    /** Rounded corners on the side facing the page */
+    round?: boolean;
+    /** Reserve the bottom safe area */
+    safeArea?: boolean;
+    /** Lock page scroll while open */
+    lockScroll?: boolean;
+    /** Show a drag handle and close by swiping down (bottom placement only) */
+    swipeToClose?: boolean;
+    rootClass?: string;
+    rootStyle?: CSSProperties;
+    classes?: DrawerSemanticClassNames;
+    styles?: DrawerSemanticStyles;
+}
+export interface DrawerEmits {
+    'update:open': [open: boolean];
+    /** The user asks to close: close icon, mask, ESC or swipe */
+    'close': [event?: Event];
+    'afterOpenChange': [open: boolean];
+}
+export interface DrawerSlots {
+    default?: () => any;
+    title?: () => any;
+    extra?: () => any;
+    footer?: () => any;
+    closeIcon?: () => any;
+}

package/dist/drawer/style/index.css

@@ -0,0 +1,183 @@
+.am-drawer-root {
+  --am-drawer-size: 80%;
+  --am-drawer-size-large: 100%;
+  --am-drawer-max-height: 90%;
+  --am-drawer-header-padding: var(--am-padding-sm) var(--am-padding);
+  --am-drawer-body-padding: var(--am-padding);
+  --am-drawer-footer-padding: var(--am-padding-sm) var(--am-padding);
+  --am-drawer-title-font-size: var(--am-font-size-lg);
+  --am-drawer-close-size: 18px;
+  --am-drawer-handle-width: 36px;
+  --am-drawer-handle-height: 4px;
+  --am-drawer-handle-color: var(--am-color-fill);
+}
+
+.am-drawer.am-popup {
+  display: flex;
+  flex-direction: column;
+  overflow: hidden;
+}
+
+.am-popup.am-drawer-left,
+.am-popup.am-drawer-right {
+  width: var(--am-drawer-size);
+  max-width: 100%;
+}
+
+.am-popup.am-drawer-top,
+.am-popup.am-drawer-bottom {
+  max-height: var(--am-drawer-max-height);
+}
+
+.am-drawer-large.am-drawer-left,
+.am-drawer-large.am-drawer-right {
+  width: var(--am-drawer-size-large);
+}
+
+.am-drawer-large.am-drawer-top,
+.am-drawer-large.am-drawer-bottom {
+  height: var(--am-drawer-max-height);
+}
+
+.am-popup.am-drawer.am-drawer-sized {
+  max-width: 100%;
+  max-height: 100%;
+}
+
+.am-drawer-handle {
+  display: flex;
+  flex: none;
+  align-items: center;
+  justify-content: center;
+  padding: var(--am-padding-xs) 0 var(--am-padding-xxs);
+  cursor: grab;
+  touch-action: none;
+}
+
+.am-drawer-handle-bar {
+  width: var(--am-drawer-handle-width);
+  height: var(--am-drawer-handle-height);
+  background: var(--am-drawer-handle-color);
+  border-radius: var(--am-drawer-handle-height);
+}
+
+.am-drawer-header {
+  position: relative;
+  display: flex;
+  flex: none;
+  gap: var(--am-padding-xs);
+  align-items: center;
+  box-sizing: border-box;
+  min-height: 48px;
+  padding: var(--am-drawer-header-padding);
+}
+
+.am-drawer-header::after {
+  position: absolute;
+  right: 0;
+  bottom: 0;
+  left: 0;
+  border-bottom: var(--am-line-width) var(--am-line-type) var(--am-color-split);
+  transform: scaleY(0.5);
+  transform-origin: bottom;
+  content: '';
+  pointer-events: none;
+}
+
+.am-drawer-with-handle .am-drawer-header {
+  touch-action: none;
+}
+
+.am-drawer-title {
+  flex: 1;
+  min-width: 0;
+  overflow: hidden;
+  color: var(--am-color-text-heading);
+  font-weight: var(--am-font-weight-strong);
+  font-size: var(--am-drawer-title-font-size);
+  line-height: var(--am-line-height-lg);
+  white-space: nowrap;
+  text-overflow: ellipsis;
+}
+
+.am-drawer-extra {
+  flex: none;
+  margin-inline-start: auto;
+  color: var(--am-color-text-secondary);
+}
+
+.am-drawer-close {
+  display: inline-flex;
+  flex: none;
+  align-items: center;
+  justify-content: center;
+  margin: 0;
+  margin-inline-start: auto;
+  padding: var(--am-padding-xxs);
+  color: var(--am-color-icon);
+  font-size: var(--am-drawer-close-size);
+  line-height: 1;
+  background: transparent;
+  border: 0;
+  border-radius: var(--am-border-radius-sm);
+  outline: none;
+  cursor: pointer;
+  -webkit-tap-highlight-color: transparent;
+}
+
+.am-drawer-extra + .am-drawer-close {
+  margin-inline-start: 0;
+}
+
+.am-drawer-close:active {
+  color: var(--am-color-icon-hover);
+  background: var(--am-color-fill-tertiary);
+}
+
+.am-drawer-close-disabled {
+  opacity: var(--am-opacity-disabled);
+  pointer-events: none;
+}
+
+.am-drawer-header-close-start .am-drawer-close {
+  order: -1;
+  margin-inline-start: 0;
+}
+
+.am-drawer-body {
+  flex: 1;
+  box-sizing: border-box;
+  min-height: 0;
+  padding: var(--am-drawer-body-padding);
+  overflow: auto;
+  -webkit-overflow-scrolling: touch;
+  overscroll-behavior: contain;
+}
+
+.am-drawer-loading {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  min-height: 120px;
+  color: var(--am-color-primary);
+  font-size: 28px;
+}
+
+.am-drawer-footer {
+  position: relative;
+  flex: none;
+  box-sizing: border-box;
+  padding: var(--am-drawer-footer-padding);
+}
+
+.am-drawer-footer::before {
+  position: absolute;
+  top: 0;
+  right: 0;
+  left: 0;
+  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;
+}

package/dist/dropdown/Dropdown.js

@@ -0,0 +1,4 @@
+import Dropdown_vue_vue_type_script_setup_true_lang_default from "./Dropdown.vue_vue_type_script_setup_true_lang.js";
+// src/dropdown/Dropdown.vue
+var Dropdown_default = Dropdown_vue_vue_type_script_setup_true_lang_default;
+export { Dropdown_default as default };

package/dist/dropdown/Dropdown.vue.d.ts

@@ -0,0 +1,29 @@
+import type { Key } from '../_util/type';
+import type { DropdownExpose, DropdownProps, DropdownSlots } from './interface';
+import '../style';
+import './style/index.css';
+type __VLS_Slots = DropdownSlots;
+declare const __VLS_base: import("vue").DefineComponent<DropdownProps, DropdownExpose, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    change: (key: Key | null) => any;
+    "update:activeKey": (key: Key | null) => any;
+}, string, import("vue").PublicProps, Readonly<DropdownProps> & Readonly<{
+    onChange?: ((key: Key | null) => any) | undefined;
+    "onUpdate:activeKey"?: ((key: Key | null) => any) | undefined;
+}>, {
+    getContainer: import("..").GetContainer;
+    activeKey: Key | null;
+    defaultActiveKey: Key | null;
+    closeOnMaskClick: boolean;
+    closeOnClickAway: boolean;
+    arrowIcon: string | number | boolean | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }> | import("vue").VNodeArrayChildren | (() => import("vue").VNodeChild) | null;
+}, {}, {}, {}, 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/dropdown/Dropdown.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,205 @@
+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 { dropdownContextKey } from "./context.js";
+import "../style/index2.js";
+import './style/index.css';/* empty css            */
+import { Fragment, computed, createBlock, createElementBlock, createElementVNode, createVNode, defineComponent, mergeProps, normalizeClass, normalizeStyle, onMounted, openBlock, provide, ref, renderList, renderSlot, shallowRef, unref, watch } from "vue";
+import { CaretDownOutlined } from "@antdv-next/icons";
+// src/dropdown/Dropdown.vue?vue&type=script&setup=true&lang.ts
+var _hoisted_1 = [
+	"tabindex",
+	"aria-expanded",
+	"aria-disabled",
+	"onClick"
+];
+var Dropdown_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComponent({
+	name: "AmDropdown",
+	inheritAttrs: false,
+	__name: "Dropdown",
+	props: {
+		activeKey: { default: void 0 },
+		defaultActiveKey: { default: null },
+		closeOnMaskClick: {
+			type: Boolean,
+			default: true
+		},
+		closeOnClickAway: {
+			type: Boolean,
+			default: true
+		},
+		arrowIcon: {
+			type: [
+				Object,
+				String,
+				Number,
+				Boolean,
+				null,
+				Array,
+				Function
+			],
+			default: void 0
+		},
+		getContainer: {
+			type: [
+				String,
+				Function,
+				Boolean
+			],
+			default: void 0
+		},
+		zIndex: {},
+		rootClass: {},
+		classes: {},
+		styles: {}
+	},
+	emits: ["update:activeKey", "change"],
+	setup(__props, { expose: __expose, emit: __emit }) {
+		const props = __props;
+		const emit = __emit;
+		const rootRef = ref();
+		const navRef = ref();
+		const items = shallowRef([]);
+		const rect = ref({
+			top: 0,
+			left: 0,
+			width: 0
+		});
+		const zIndex = ref(props.zIndex);
+		const [activeKey, setActiveKey] = useControlled(props, "activeKey", {
+			defaultValue: () => props.defaultActiveKey ?? null,
+			onChange: (key, prev) => {
+				if (key === prev) return;
+				emit("update:activeKey", key);
+				emit("change", key);
+			}
+		});
+		function updateRect() {
+			const nav = navRef.value;
+			if (!nav) return;
+			const { bottom, left, width } = nav.getBoundingClientRect();
+			rect.value = {
+				top: bottom,
+				left,
+				width
+			};
+		}
+		function sort() {
+			const list = items.value;
+			if (list.length < 2 || list.some((item) => !item.el)) return;
+			const sorted = [...list].sort((a, b) => a.el.compareDocumentPosition(b.el) & 2 ? 1 : -1);
+			if (sorted.some((item, index) => item !== list[index])) items.value = sorted;
+		}
+		function register(item) {
+			items.value = [...items.value, item];
+			return () => {
+				items.value = items.value.filter((i) => i !== item);
+			};
+		}
+		function close() {
+			if (activeKey.value !== null) setActiveKey(null);
+		}
+		function toggle(item) {
+			if (item.disabled()) return;
+			if (activeKey.value === item.key) setActiveKey(null);
+			else {
+				prepare();
+				setActiveKey(item.key);
+			}
+		}
+		function prepare() {
+			updateRect();
+			zIndex.value = props.zIndex ?? nextZIndex();
+		}
+		watch(activeKey, (key, prev) => {
+			if (key !== null && prev === null) prepare();
+		});
+		watch(() => props.zIndex, (value) => {
+			if (value !== void 0) zIndex.value = value;
+		});
+		onMounted(() => {
+			sort();
+			if (activeKey.value !== null) prepare();
+		});
+		function onClickAway(event) {
+			const target = event.target;
+			if (!target || items.value.some((item) => item.layerEl?.()?.contains(target))) return;
+			close();
+		}
+		const clickAwayEnabled = () => activeKey.value !== null && props.closeOnClickAway;
+		useClickAway(rootRef, onClickAway, {
+			eventName: "touchstart",
+			enabled: clickAwayEnabled
+		});
+		useClickAway(rootRef, onClickAway, {
+			eventName: "mousedown",
+			enabled: clickAwayEnabled
+		});
+		useEventListener("resize", () => activeKey.value !== null && updateRect(), { passive: true });
+		useEventListener("scroll", () => activeKey.value !== null && updateRect(), {
+			passive: true,
+			capture: true
+		});
+		const context = {
+			activeKey,
+			rect,
+			zIndex,
+			getContainer: computed(() => props.getContainer),
+			closeOnMaskClick: computed(() => props.closeOnMaskClick),
+			register,
+			sort,
+			close
+		};
+		provide(dropdownContextKey, context);
+		__expose({ close });
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock("div", mergeProps({
+				ref_key: "rootRef",
+				ref: rootRef
+			}, _ctx.$attrs, {
+				class: ["am-dropdown", [
+					{ "am-dropdown-open": unref(activeKey) !== null },
+					__props.rootClass,
+					__props.classes?.root
+				]],
+				style: __props.styles?.root
+			}), [createElementVNode("div", {
+				ref_key: "navRef",
+				ref: navRef,
+				class: normalizeClass(["am-dropdown-nav", __props.classes?.nav]),
+				style: normalizeStyle(__props.styles?.nav)
+			}, [(openBlock(true), createElementBlock(Fragment, null, renderList(items.value, (item) => {
+				return openBlock(), createElementBlock("div", {
+					key: item.key,
+					class: normalizeClass(["am-dropdown-nav-item", [__props.classes?.item, {
+						"am-dropdown-nav-item-active": unref(activeKey) === item.key,
+						"am-dropdown-nav-item-highlight": item.highlight(),
+						"am-dropdown-nav-item-disabled": item.disabled()
+					}]]),
+					style: normalizeStyle(__props.styles?.item),
+					role: "button",
+					tabindex: item.disabled() ? -1 : 0,
+					"aria-expanded": unref(activeKey) === item.key,
+					"aria-disabled": item.disabled() || void 0,
+					onClick: ($event) => toggle(item)
+				}, [createElementVNode("span", {
+					class: normalizeClass(["am-dropdown-nav-title", __props.classes?.title]),
+					style: normalizeStyle(__props.styles?.title)
+				}, [createVNode(unref(RenderNode_default), { node: item.renderTitle }, null, 8, ["node"])], 6), createElementVNode("span", {
+					class: normalizeClass(["am-dropdown-nav-arrow", __props.classes?.arrow]),
+					style: normalizeStyle(__props.styles?.arrow)
+				}, [item.renderArrow ? (openBlock(), createBlock(unref(RenderNode_default), {
+					key: 0,
+					node: item.renderArrow
+				}, null, 8, ["node"])) : renderSlot(_ctx.$slots, "arrowIcon", {}, () => [unref(isRenderable)(__props.arrowIcon) ? (openBlock(), createBlock(unref(RenderNode_default), {
+					key: 0,
+					node: __props.arrowIcon
+				}, null, 8, ["node"])) : (openBlock(), createBlock(unref(CaretDownOutlined), { key: 1 }))], void 0, 1)], 6)], 14, _hoisted_1);
+			}), 128))], 6), renderSlot(_ctx.$slots, "default")], 16);
+		};
+	}
+});
+export { Dropdown_vue_vue_type_script_setup_true_lang_default as default };

package/dist/dropdown/DropdownItem.js

@@ -0,0 +1,4 @@
+import DropdownItem_vue_vue_type_script_setup_true_lang_default from "./DropdownItem.vue_vue_type_script_setup_true_lang.js";
+// src/dropdown/DropdownItem.vue
+var DropdownItem_default = DropdownItem_vue_vue_type_script_setup_true_lang_default;
+export { DropdownItem_default as default };