@antdv-next/mobile 0.0.0-stage → 0.1.0

package/dist/action-sheet/style/index.css

@@ -0,0 +1,153 @@
+.am-action-sheet-root {
+  --am-action-sheet-item-height: 52px;
+  --am-action-sheet-item-font-size: var(--am-font-size-lg);
+  --am-action-sheet-item-color: var(--am-color-text);
+  --am-action-sheet-item-active-bg: var(--am-color-fill-tertiary);
+  --am-action-sheet-description-color: var(--am-color-text-description);
+  --am-action-sheet-header-color: var(--am-color-text-description);
+  --am-action-sheet-gap-size: 8px;
+  --am-action-sheet-gap-color: var(--am-color-bg-layout);
+  --am-action-sheet-max-height: 80%;
+}
+
+.am-popup.am-action-sheet {
+  display: flex;
+  flex-direction: column;
+  max-height: var(--am-action-sheet-max-height);
+  overflow: hidden;
+}
+
+.am-action-sheet-header {
+  position: relative;
+  flex: none;
+  padding: var(--am-padding) var(--am-padding-lg);
+  color: var(--am-action-sheet-header-color);
+  font-size: var(--am-font-size);
+  line-height: var(--am-line-height);
+  text-align: center;
+}
+
+.am-action-sheet-header::after,
+.am-action-sheet-item + .am-action-sheet-item::before {
+  position: absolute;
+  right: 0;
+  left: 0;
+  border-top: var(--am-line-width) var(--am-line-type) var(--am-color-split);
+  transform: scaleY(0.5);
+  content: '';
+  pointer-events: none;
+}
+
+.am-action-sheet-header::after {
+  bottom: 0;
+  transform-origin: bottom;
+}
+
+.am-action-sheet-item + .am-action-sheet-item::before {
+  top: 0;
+  transform-origin: top;
+}
+
+.am-action-sheet-title {
+  color: var(--am-color-text-secondary);
+  font-weight: var(--am-font-weight-strong);
+}
+
+.am-action-sheet-title + .am-action-sheet-extra {
+  margin-top: var(--am-margin-xxs);
+}
+
+.am-action-sheet-extra {
+  font-size: var(--am-font-size-sm);
+}
+
+.am-action-sheet-content {
+  flex: none;
+}
+
+.am-action-sheet-list {
+  flex: 1;
+  min-height: 0;
+  overflow-y: auto;
+  -webkit-overflow-scrolling: touch;
+  overscroll-behavior: contain;
+}
+
+.am-action-sheet-item {
+  position: relative;
+  display: flex;
+  flex: none;
+  flex-direction: column;
+  align-items: center;
+  justify-content: center;
+  box-sizing: border-box;
+  width: 100%;
+  min-height: var(--am-action-sheet-item-height);
+  margin: 0;
+  padding: var(--am-padding-xs) var(--am-padding);
+  color: var(--am-action-sheet-item-color);
+  font-size: var(--am-action-sheet-item-font-size);
+  font-family: inherit;
+  line-height: var(--am-line-height-lg);
+  text-align: center;
+  background: transparent;
+  border: 0;
+  outline: none;
+  cursor: pointer;
+  user-select: none;
+  touch-action: manipulation;
+  -webkit-tap-highlight-color: transparent;
+  appearance: none;
+}
+
+.am-action-sheet-item:active {
+  background: var(--am-action-sheet-item-active-bg);
+}
+
+.am-action-sheet-item-main {
+  display: inline-flex;
+  gap: var(--am-padding-xs);
+  align-items: center;
+  max-width: 100%;
+}
+
+.am-action-sheet-item-icon {
+  display: inline-flex;
+  flex: none;
+  font-size: 1.125em;
+}
+
+.am-action-sheet-item-description {
+  margin-top: 2px;
+  color: var(--am-action-sheet-description-color);
+  font-weight: 400;
+  font-size: var(--am-font-size-sm);
+  line-height: var(--am-line-height-sm);
+}
+
+.am-action-sheet-item-danger {
+  color: var(--am-color-error);
+}
+
+.am-action-sheet-item-bold {
+  font-weight: var(--am-font-weight-strong);
+}
+
+.am-action-sheet-item-disabled {
+  color: var(--am-color-text-disabled);
+  cursor: not-allowed;
+}
+
+.am-action-sheet-item-disabled:active {
+  background: transparent;
+}
+
+.am-action-sheet-gap {
+  flex: none;
+  height: var(--am-action-sheet-gap-size);
+  background: var(--am-action-sheet-gap-color);
+}
+
+.am-action-sheet-cancel {
+  color: var(--am-color-text-secondary);
+}

package/dist/affix/Affix.js

@@ -0,0 +1,4 @@
+import Affix_vue_vue_type_script_setup_true_lang_default from "./Affix.vue_vue_type_script_setup_true_lang.js";
+// src/affix/Affix.vue
+var Affix_default = Affix_vue_vue_type_script_setup_true_lang_default;
+export { Affix_default as default };

package/dist/affix/Affix.vue.d.ts

@@ -0,0 +1,21 @@
+import type { AffixProps, AffixSlots } from './interface';
+import '../style';
+import './style/index.css';
+type __VLS_Slots = AffixSlots;
+/** resize / content change: measure the natural size again */
+declare function updatePosition(): void;
+declare const __VLS_base: import("vue").DefineComponent<AffixProps, {
+    updatePosition: typeof updatePosition;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    change: (affixed: boolean) => any;
+}, string, import("vue").PublicProps, Readonly<AffixProps> & Readonly<{
+    onChange?: ((affixed: boolean) => any) | undefined;
+}>, {}, {}, {}, {}, 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/affix/Affix.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,176 @@
+import { cancelRaf, raf } from "../_util/index.js";
+import "../style/index2.js";
+import './style/index.css';/* empty css            */
+import { computed, createCommentVNode, createElementBlock, createElementVNode, defineComponent, mergeProps, nextTick, normalizeClass, normalizeStyle, onActivated, onBeforeUnmount, onMounted, openBlock, ref, renderSlot, shallowRef, watch } from "vue";
+// src/affix/Affix.vue?vue&type=script&setup=true&lang.ts
+var Affix_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComponent({
+	name: "AmAffix",
+	inheritAttrs: false,
+	__name: "Affix",
+	props: {
+		offsetTop: {},
+		offsetBottom: {},
+		target: { type: Function },
+		zIndex: {},
+		rootClass: {},
+		classes: {},
+		styles: {}
+	},
+	emits: ["change"],
+	setup(__props, { expose: __expose, emit: __emit }) {
+		const props = __props;
+		const emit = __emit;
+		const rootRef = ref();
+		const fixedRef = ref();
+		const affixStyle = shallowRef();
+		const placeholderStyle = shallowRef();
+		const affixed = computed(() => !!affixStyle.value);
+		const getTarget = () => props.target ? props.target() : window;
+		function getTargetRect(target) {
+			return target === window ? {
+				top: 0,
+				bottom: window.innerHeight
+			} : target.getBoundingClientRect();
+		}
+		/** the pinned state that was last reported through `change` */
+		let reported = false;
+		function report() {
+			if (reported !== affixed.value) {
+				reported = affixed.value;
+				emit("change", reported);
+			}
+		}
+		function measure() {
+			const root = rootRef.value;
+			const target = getTarget();
+			if (!root || !target) return;
+			const rect = root.getBoundingClientRect();
+			if (!rect.top && !rect.left && !rect.width && !rect.height) return;
+			const targetRect = getTargetRect(target);
+			const offsetTop = props.offsetBottom === void 0 && props.offsetTop === void 0 ? 0 : props.offsetTop;
+			const { offsetBottom } = props;
+			let nextStyle;
+			if (offsetTop !== void 0 && targetRect.top > rect.top - offsetTop) nextStyle = {
+				position: "fixed",
+				top: `${offsetTop + targetRect.top}px`
+			};
+			else if (offsetBottom !== void 0 && targetRect.bottom < rect.bottom + offsetBottom) nextStyle = {
+				position: "fixed",
+				bottom: `${offsetBottom + (window.innerHeight - targetRect.bottom)}px`
+			};
+			if (nextStyle) {
+				nextStyle.width = `${rect.width}px`;
+				nextStyle.height = `${rect.height}px`;
+				if (props.zIndex !== void 0) nextStyle.zIndex = props.zIndex;
+			}
+			const prev = affixStyle.value;
+			if (!(!!prev !== !!nextStyle || !!prev && !!nextStyle && Object.keys(nextStyle).some((key) => prev[key] !== nextStyle[key]))) return;
+			affixStyle.value = nextStyle;
+			placeholderStyle.value = nextStyle ? {
+				width: nextStyle.width,
+				height: nextStyle.height
+			} : void 0;
+			report();
+		}
+		let frame = 0;
+		/** scroll: cheap re-check, at most once per frame */
+		function lazyUpdate() {
+			cancelRaf(frame);
+			frame = raf(measure);
+		}
+		/** resize / content change: measure the natural size again */
+		function updatePosition() {
+			cancelRaf(frame);
+			frame = raf(() => {
+				if (!affixStyle.value) {
+					measure();
+					return;
+				}
+				affixStyle.value = void 0;
+				placeholderStyle.value = void 0;
+				nextTick(() => {
+					measure();
+					report();
+				});
+			});
+		}
+		let boundTarget = null;
+		let resizeObserver;
+		function unbind() {
+			if (boundTarget) {
+				boundTarget.removeEventListener("scroll", lazyUpdate);
+				boundTarget = null;
+			}
+			window.removeEventListener("scroll", lazyUpdate);
+			window.removeEventListener("resize", updatePosition);
+			window.removeEventListener("orientationchange", updatePosition);
+			resizeObserver?.disconnect();
+			resizeObserver = void 0;
+		}
+		function bind() {
+			unbind();
+			const target = getTarget();
+			boundTarget = target;
+			target?.addEventListener("scroll", lazyUpdate, { passive: true });
+			if (target !== window) window.addEventListener("scroll", lazyUpdate, { passive: true });
+			window.addEventListener("resize", updatePosition, { passive: true });
+			window.addEventListener("orientationchange", updatePosition, { passive: true });
+			if (typeof ResizeObserver !== "undefined") {
+				resizeObserver = new ResizeObserver(updatePosition);
+				if (rootRef.value) resizeObserver.observe(rootRef.value);
+				if (fixedRef.value) resizeObserver.observe(fixedRef.value);
+			}
+		}
+		let mounted = false;
+		onMounted(() => {
+			mounted = true;
+			bind();
+			measure();
+			nextTick(() => {
+				if (!mounted) return;
+				if (getTarget() !== boundTarget) bind();
+				measure();
+			});
+		});
+		onActivated(lazyUpdate);
+		onBeforeUnmount(() => {
+			mounted = false;
+			cancelRaf(frame);
+			unbind();
+		});
+		watch(() => props.target, () => {
+			if (mounted) {
+				bind();
+				updatePosition();
+			}
+		});
+		watch(() => [
+			props.offsetTop,
+			props.offsetBottom,
+			props.zIndex
+		], () => {
+			if (mounted) updatePosition();
+		});
+		__expose({ updatePosition });
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock("div", mergeProps({
+				ref_key: "rootRef",
+				ref: rootRef
+			}, _ctx.$attrs, {
+				class: ["am-affix-wrapper", [__props.rootClass, __props.classes?.root]],
+				style: __props.styles?.root
+			}), [affixed.value ? (openBlock(), createElementBlock("div", {
+				key: 0,
+				class: "am-affix-placeholder",
+				style: normalizeStyle(placeholderStyle.value),
+				"aria-hidden": "true"
+			}, null, 4)) : createCommentVNode("", true), createElementVNode("div", {
+				ref_key: "fixedRef",
+				ref: fixedRef,
+				class: normalizeClass([{ "am-affix": affixed.value }, __props.classes?.affix]),
+				style: normalizeStyle([affixStyle.value, __props.styles?.affix])
+			}, [renderSlot(_ctx.$slots, "default")], 6)], 16);
+		};
+	}
+});
+export { Affix_vue_vue_type_script_setup_true_lang_default as default };

package/dist/affix/index.d.ts

@@ -0,0 +1,33 @@
+export type * from './interface';
+declare const Affix: import("../_util/withInstall").WithInstall<{
+    new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("./interface").AffixProps> & Readonly<{
+        onChange?: ((affixed: boolean) => any) | undefined;
+    }>, {
+        updatePosition: () => void;
+    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+        change: (affixed: boolean) => any;
+    }, import("vue").PublicProps, {}, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import("./interface").AffixProps> & Readonly<{
+        onChange?: ((affixed: boolean) => any) | undefined;
+    }>, {
+        updatePosition: () => void;
+    }, {}, {}, {}, {}>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import("vue").ComponentOptionsBase<Readonly<import("./interface").AffixProps> & Readonly<{
+    onChange?: ((affixed: boolean) => any) | undefined;
+}>, {
+    updatePosition: () => void;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    change: (affixed: boolean) => any;
+}, string, {}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+    $slots: import("./interface").AffixSlots;
+}), object>;
+export default Affix;

package/dist/affix/index.js

@@ -0,0 +1,5 @@
+import { withInstall } from "../_util/withInstall.js";
+import Affix_default from "./Affix.js";
+// src/affix/index.ts
+var Affix = withInstall(Affix_default, "AmAffix");
+export { Affix as default };

package/dist/affix/interface.d.ts

@@ -0,0 +1,33 @@
+import type { CSSProperties } from 'vue';
+export interface AffixSemanticClassNames {
+    root?: string;
+    /** the element that gets fixed */
+    affix?: string;
+}
+export interface AffixSemanticStyles {
+    root?: CSSProperties;
+    affix?: CSSProperties;
+}
+export interface AffixProps {
+    /** Pin when the distance to the top of the target is smaller than this value (default `0`) */
+    offsetTop?: number;
+    /** Pin when the distance to the bottom of the target is smaller than this value */
+    offsetBottom?: number;
+    /** The scrollable element to observe, defaults to `window` */
+    target?: () => Window | HTMLElement | null;
+    /** z-index of the pinned element */
+    zIndex?: number;
+    rootClass?: string;
+    classes?: AffixSemanticClassNames;
+    styles?: AffixSemanticStyles;
+}
+export interface AffixEmits {
+    change: [affixed: boolean];
+}
+export interface AffixSlots {
+    default?: () => any;
+}
+export interface AffixRef {
+    /** re-calculate the position (it is done automatically on scroll / resize) */
+    updatePosition: () => void;
+}

package/dist/affix/style/index.css

@@ -0,0 +1,11 @@
+.am-affix-wrapper {
+  --am-affix-z-index: 10;
+
+  box-sizing: border-box;
+}
+
+.am-affix {
+  position: fixed;
+  z-index: var(--am-affix-z-index);
+  box-sizing: border-box;
+}

package/dist/alert/Alert.js

@@ -0,0 +1,4 @@
+import Alert_vue_vue_type_script_setup_true_lang_default from "./Alert.vue_vue_type_script_setup_true_lang.js";
+// src/alert/Alert.vue
+var Alert_default = Alert_vue_vue_type_script_setup_true_lang_default;
+export { Alert_default as default };

package/dist/alert/Alert.vue.d.ts

@@ -0,0 +1,24 @@
+import type { AlertProps, AlertSlots } from './interface';
+import '../style';
+import './style/index.css';
+type __VLS_Slots = AlertSlots;
+declare const __VLS_base: import("vue").DefineComponent<AlertProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    close: (event: MouseEvent) => any;
+    afterClose: () => any;
+}, string, import("vue").PublicProps, Readonly<AlertProps> & Readonly<{
+    onClose?: ((event: MouseEvent) => any) | undefined;
+    onAfterClose?: (() => any) | undefined;
+}>, {
+    variant: import("./interface").AlertVariant;
+    role: string;
+    closable: import("./interface").AlertClosableType;
+    showIcon: 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/alert/Alert.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,193 @@
+import { isRenderable } from "../_util/index.js";
+import RenderNode_default from "../_util/RenderNode.js";
+import { useLocale } from "../locale/index.js";
+import "../style/index2.js";
+import './style/index.css';/* empty css            */
+import { Transition, computed, createBlock, createCommentVNode, createElementBlock, createElementVNode, createVNode, defineComponent, mergeProps, normalizeClass, normalizeStyle, openBlock, ref, renderSlot, resolveDynamicComponent, unref, useSlots, withCtx } from "vue";
+import { CheckCircleFilled, CloseCircleFilled, CloseOutlined, ExclamationCircleFilled, InfoCircleFilled } from "@antdv-next/icons";
+// src/alert/Alert.vue?vue&type=script&setup=true&lang.ts
+var _hoisted_1 = ["role", "data-show"];
+var _hoisted_2 = ["disabled", "aria-label"];
+var Alert_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComponent({
+	name: "AmAlert",
+	inheritAttrs: false,
+	__name: "Alert",
+	props: {
+		type: {},
+		variant: { default: "filled" },
+		title: { type: [
+			Object,
+			String,
+			Number,
+			Boolean,
+			null,
+			Array,
+			Function
+		] },
+		message: { type: [
+			Object,
+			String,
+			Number,
+			Boolean,
+			null,
+			Array,
+			Function
+		] },
+		description: { type: [
+			Object,
+			String,
+			Number,
+			Boolean,
+			null,
+			Array,
+			Function
+		] },
+		showIcon: {
+			type: Boolean,
+			default: void 0
+		},
+		icon: { type: [
+			Object,
+			String,
+			Number,
+			Boolean,
+			null,
+			Array,
+			Function
+		] },
+		closable: {
+			type: [Boolean, Object],
+			default: void 0
+		},
+		closeIcon: { type: [
+			Object,
+			String,
+			Number,
+			Boolean,
+			null,
+			Array,
+			Function
+		] },
+		action: { type: [
+			Object,
+			String,
+			Number,
+			Boolean,
+			null,
+			Array,
+			Function
+		] },
+		banner: { type: Boolean },
+		role: { default: "alert" },
+		rootClass: {},
+		classes: {},
+		styles: {}
+	},
+	emits: ["close", "afterClose"],
+	setup(__props, { emit: __emit }) {
+		const props = __props;
+		const emit = __emit;
+		const slots = useSlots();
+		const iconMap = {
+			success: CheckCircleFilled,
+			info: InfoCircleFilled,
+			warning: ExclamationCircleFilled,
+			error: CloseCircleFilled
+		};
+		const commonLocale = useLocale("common");
+		const closed = ref(false);
+		const mergedType = computed(() => props.type ?? (props.banner ? "warning" : "info"));
+		const mergedShowIcon = computed(() => props.showIcon ?? !!props.banner);
+		const mergedTitle = computed(() => isRenderable(props.title) ? props.title : props.message);
+		const hasTitle = computed(() => !!slots.title || !!slots.message || !!slots.default || isRenderable(mergedTitle.value));
+		const hasDescription = computed(() => !!slots.description || isRenderable(props.description));
+		const hasAction = computed(() => !!slots.action || isRenderable(props.action));
+		const closableConfig = computed(() => typeof props.closable === "object" && props.closable ? props.closable : void 0);
+		const mergedCloseIcon = computed(() => isRenderable(props.closeIcon) ? props.closeIcon : closableConfig.value?.closeIcon);
+		const mergedClosable = computed(() => {
+			if (props.closable === false) return false;
+			return !!props.closable || !!slots.closeIcon || isRenderable(mergedCloseIcon.value);
+		});
+		const classNames = computed(() => [
+			"am-alert",
+			`am-alert-${mergedType.value}`,
+			`am-alert-${props.variant}`,
+			{
+				"am-alert-with-description": hasDescription.value,
+				"am-alert-no-icon": !mergedShowIcon.value,
+				"am-alert-banner": props.banner
+			},
+			props.rootClass,
+			props.classes?.root
+		]);
+		function handleClose(event) {
+			if (closableConfig.value?.disabled) return;
+			closed.value = true;
+			emit("close", event);
+		}
+		function onBeforeLeave(el) {
+			const node = el;
+			node.style.height = `${node.offsetHeight}px`;
+		}
+		function onLeave(el) {
+			const node = el;
+			node.offsetHeight;
+			node.style.height = "0px";
+		}
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(Transition, {
+				name: "am-alert-motion",
+				onBeforeLeave,
+				onLeave,
+				onAfterLeave: _cache[0] || (_cache[0] = ($event) => emit("afterClose"))
+			}, {
+				default: withCtx(() => [!closed.value ? (openBlock(), createElementBlock("div", mergeProps({ key: 0 }, _ctx.$attrs, {
+					class: classNames.value,
+					style: __props.styles?.root,
+					role: __props.role,
+					"data-show": !closed.value
+				}), [
+					mergedShowIcon.value ? (openBlock(), createElementBlock("span", {
+						key: 0,
+						class: normalizeClass(["am-alert-icon", __props.classes?.icon]),
+						style: normalizeStyle(__props.styles?.icon)
+					}, [renderSlot(_ctx.$slots, "icon", {}, () => [unref(isRenderable)(__props.icon) ? (openBlock(), createBlock(unref(RenderNode_default), {
+						key: 0,
+						node: __props.icon
+					}, null, 8, ["node"])) : (openBlock(), createBlock(resolveDynamicComponent(iconMap[mergedType.value]), { key: 1 }))])], 6)) : createCommentVNode("", true),
+					createElementVNode("div", {
+						class: normalizeClass(["am-alert-section", __props.classes?.section]),
+						style: normalizeStyle(__props.styles?.section)
+					}, [hasTitle.value ? (openBlock(), createElementBlock("div", {
+						key: 0,
+						class: normalizeClass(["am-alert-title", __props.classes?.title]),
+						style: normalizeStyle(__props.styles?.title)
+					}, [renderSlot(_ctx.$slots, "title", {}, () => [renderSlot(_ctx.$slots, "message", {}, () => [renderSlot(_ctx.$slots, "default", {}, () => [createVNode(unref(RenderNode_default), { node: mergedTitle.value }, null, 8, ["node"])])])])], 6)) : createCommentVNode("", true), hasDescription.value ? (openBlock(), createElementBlock("div", {
+						key: 1,
+						class: normalizeClass(["am-alert-description", __props.classes?.description]),
+						style: normalizeStyle(__props.styles?.description)
+					}, [renderSlot(_ctx.$slots, "description", {}, () => [createVNode(unref(RenderNode_default), { node: __props.description }, null, 8, ["node"])])], 6)) : createCommentVNode("", true)], 6),
+					hasAction.value ? (openBlock(), createElementBlock("div", {
+						key: 1,
+						class: normalizeClass(["am-alert-actions", __props.classes?.actions]),
+						style: normalizeStyle(__props.styles?.actions)
+					}, [renderSlot(_ctx.$slots, "action", {}, () => [createVNode(unref(RenderNode_default), { node: __props.action }, null, 8, ["node"])])], 6)) : createCommentVNode("", true),
+					mergedClosable.value ? (openBlock(), createElementBlock("button", {
+						key: 2,
+						type: "button",
+						class: normalizeClass(["am-alert-close", __props.classes?.close]),
+						style: normalizeStyle(__props.styles?.close),
+						disabled: closableConfig.value?.disabled || void 0,
+						"aria-label": closableConfig.value?.["aria-label"] ?? unref(commonLocale).close,
+						onClick: handleClose
+					}, [renderSlot(_ctx.$slots, "closeIcon", {}, () => [unref(isRenderable)(mergedCloseIcon.value) ? (openBlock(), createBlock(unref(RenderNode_default), {
+						key: 0,
+						node: mergedCloseIcon.value
+					}, null, 8, ["node"])) : (openBlock(), createBlock(unref(CloseOutlined), { key: 1 }))])], 14, _hoisted_2)) : createCommentVNode("", true)
+				], 16, _hoisted_1)) : createCommentVNode("", true)]),
+				_: 3
+			});
+		};
+	}
+});
+export { Alert_vue_vue_type_script_setup_true_lang_default as default };