@antdv-next/mobile 0.0.0-stage → 0.1.1

package/dist/_util/hooks/useZIndex.js

@@ -0,0 +1,11 @@
+// src/_util/hooks/useZIndex.ts
+var globalZIndex = 1e3;
+/** Returns an ever-increasing z-index so the latest opened popup is always on top. */
+function nextZIndex() {
+	globalZIndex += 2;
+	return globalZIndex;
+}
+function setGlobalZIndex(val) {
+	globalZIndex = val;
+}
+export { nextZIndex, setGlobalZIndex };

package/dist/_util/index.d.ts

@@ -0,0 +1,36 @@
+import type { CSSProperties } from 'vue';
+import type { GetContainer, Numeric } from './type';
+export declare const inBrowser: boolean;
+export declare const isDef: <T>(val: T) => val is NonNullable<T>;
+export declare const isFunction: (val: unknown) => val is (...args: any[]) => any;
+export declare const isObject: (val: unknown) => val is Record<any, any>;
+export declare const isPromise: <T = any>(val: unknown) => val is Promise<T>;
+export declare const isNumeric: (val: unknown) => val is Numeric;
+/**
+ * Whether a render-type prop (`VueNode`) holds something to render.
+ * `false` is what Vue passes for an absent prop whose type includes `boolean`.
+ */
+export declare function isRenderable(node: unknown): boolean;
+export declare function noop(): void;
+export declare function clamp(num: number, min: number, max: number): number;
+/** `12` -> `12px`, `'1rem'` -> `'1rem'`, `undefined` -> `undefined` */
+export declare function addUnit(value?: Numeric | null): string | undefined;
+export declare function getSizeStyle(size?: Numeric | [Numeric, Numeric]): CSSProperties | undefined;
+export declare function toArray<T>(value: T | T[] | undefined | null): T[];
+export declare function padZero(num: Numeric, length?: number): string;
+export declare function pick<T extends object, K extends keyof T>(obj: T, keys: readonly K[]): Pick<T, K>;
+export declare function omit<T extends object, K extends keyof T>(obj: T, keys: readonly K[]): Omit<T, K>;
+export declare function raf(fn: FrameRequestCallback): number;
+export declare function cancelRaf(id: number): void;
+export declare function doubleRaf(fn: FrameRequestCallback): void;
+export declare function resolveContainer(getContainer?: GetContainer): HTMLElement | null;
+type ScrollElement = HTMLElement | Window;
+export declare function getScrollParent(el?: Element | null, root?: ScrollElement | undefined): ScrollElement;
+export declare function isWindow(el: unknown): el is Window;
+export declare function getScrollTop(el: ScrollElement): number;
+export declare function setScrollTop(el: ScrollElement, value: number): void;
+export declare function preventDefault(event: Event, isStopPropagation?: boolean): void;
+export declare function genId(prefix?: string): string;
+/** Merge class values for semantic `classes` (ignores falsy values). */
+export declare function cls(...args: any[]): string;
+export {};

package/dist/_util/index.js

@@ -0,0 +1,103 @@
+// src/_util/index.ts
+var inBrowser = typeof window !== "undefined" && typeof document !== "undefined";
+var isDef = (val) => val !== void 0 && val !== null;
+var isFunction = (val) => typeof val === "function";
+var isObject = (val) => val !== null && typeof val === "object";
+var isPromise = (val) => isObject(val) && isFunction(val.then) && isFunction(val.catch);
+var isNumeric = (val) => typeof val === "number" || typeof val === "string" && /^-?\d+(?:\.\d+)?$/.test(val);
+/**
+* Whether a render-type prop (`VueNode`) holds something to render.
+* `false` is what Vue passes for an absent prop whose type includes `boolean`.
+*/
+function isRenderable(node) {
+	return node !== void 0 && node !== null && node !== false && node !== "";
+}
+function noop() {}
+function clamp(num, min, max) {
+	return Math.min(Math.max(num, min), max);
+}
+/** `12` -> `12px`, `'1rem'` -> `'1rem'`, `undefined` -> `undefined` */
+function addUnit(value) {
+	if (!isDef(value) || value === "") return void 0;
+	return isNumeric(value) ? `${value}px` : String(value);
+}
+function getSizeStyle(size) {
+	if (!isDef(size)) return void 0;
+	if (Array.isArray(size)) return {
+		width: addUnit(size[0]),
+		height: addUnit(size[1])
+	};
+	const v = addUnit(size);
+	return {
+		width: v,
+		height: v
+	};
+}
+function toArray(value) {
+	if (value === void 0 || value === null) return [];
+	return Array.isArray(value) ? value : [value];
+}
+function padZero(num, length = 2) {
+	return String(num).padStart(length, "0");
+}
+function raf(fn) {
+	return inBrowser ? requestAnimationFrame(fn) : -1;
+}
+function cancelRaf(id) {
+	if (inBrowser) cancelAnimationFrame(id);
+}
+function doubleRaf(fn) {
+	raf(() => raf(fn));
+}
+function resolveContainer(getContainer) {
+	if (!inBrowser || getContainer === false) return null;
+	if (typeof getContainer === "string") return document.querySelector(getContainer) ?? document.body;
+	if (typeof getContainer === "function") return getContainer();
+	return getContainer ?? document.body;
+}
+var overflowScrollReg = /scroll|auto|overlay/i;
+function getScrollParent(el, root = inBrowser ? window : void 0) {
+	let node = el;
+	while (node && node !== root && node.nodeType === 1 && node.tagName !== "HTML" && node.tagName !== "BODY") {
+		const { overflowY } = window.getComputedStyle(node);
+		if (overflowScrollReg.test(overflowY)) return node;
+		node = node.parentNode;
+	}
+	return root;
+}
+function isWindow(el) {
+	return el === window;
+}
+function getScrollTop(el) {
+	const top = isWindow(el) ? el.scrollY : el.scrollTop;
+	return Math.max(top, 0);
+}
+function setScrollTop(el, value) {
+	if (isWindow(el)) el.scrollTo(el.scrollX, value);
+	else el.scrollTop = value;
+}
+function preventDefault(event, isStopPropagation) {
+	if (typeof event.cancelable !== "boolean" || event.cancelable) event.preventDefault();
+	if (isStopPropagation) event.stopPropagation();
+}
+var uid = 0;
+function genId(prefix = "am") {
+	uid += 1;
+	return `${prefix}-${uid}`;
+}
+/** Merge class values for semantic `classes` (ignores falsy values). */
+function cls(...args) {
+	const out = [];
+	args.forEach((arg) => {
+		if (!arg) return;
+		if (typeof arg === "string") out.push(arg);
+		else if (Array.isArray(arg)) {
+			const inner = cls(...arg);
+			if (inner) out.push(inner);
+		} else if (typeof arg === "object") Object.keys(arg).forEach((k) => {
+			if (arg[k]) out.push(k);
+		});
+	});
+	return out.join(" ");
+}
+export { addUnit, cancelRaf, clamp, cls, doubleRaf, genId, getScrollParent, getScrollTop, getSizeStyle, inBrowser, isDef, isFunction, isNumeric, isObject, isPromise, isRenderable, isWindow, noop, padZero, preventDefault, raf, resolveContainer, setScrollTop, toArray };

package/dist/_util/mount.d.ts

@@ -0,0 +1,13 @@
+import type { App } from 'vue';
+export interface MountResult {
+    app: App;
+    /** Unmounts the app and removes its holder element. */
+    unmount: () => void;
+}
+/**
+ * Mounts a root component into a detached holder under `document.body`.
+ * Used by static APIs (`Modal.confirm`, `message`, `toast`, `ImagePreview` ...).
+ * The tree is wrapped by a ConfigProvider fed with `ConfigProvider.config()` values,
+ * so static calls follow the global theme and locale.
+ */
+export declare function mountComponent(render: () => any, appContext?: App['_context'] | null): MountResult;

package/dist/_util/mount.js

@@ -0,0 +1,46 @@
+import ConfigProvider_default from "../config-provider/ConfigProvider.js";
+import { globalConfig } from "../config-provider/context.js";
+import { inBrowser } from "./index.js";
+import { createApp, h } from "vue";
+// src/_util/mount.ts
+/**
+* Mounts a root component into a detached holder under `document.body`.
+* Used by static APIs (`Modal.confirm`, `message`, `toast`, `ImagePreview` ...).
+* The tree is wrapped by a ConfigProvider fed with `ConfigProvider.config()` values,
+* so static calls follow the global theme and locale.
+*/
+function mountComponent(render, appContext) {
+	if (!inBrowser) return {
+		app: null,
+		unmount() {}
+	};
+	const holder = document.createElement("div");
+	holder.className = "am-static-holder";
+	document.body.appendChild(holder);
+	const app = createApp({
+		name: "AmStaticRoot",
+		render() {
+			return h(ConfigProvider_default, {
+				theme: globalConfig.theme,
+				locale: globalConfig.locale,
+				direction: globalConfig.direction
+			}, { default: render });
+		}
+	});
+	if (appContext) Object.assign(app._context, {
+		...appContext,
+		app: app._context.app
+	});
+	app.mount(holder);
+	let unmounted = false;
+	return {
+		app,
+		unmount() {
+			if (unmounted) return;
+			unmounted = true;
+			app.unmount();
+			holder.parentNode?.removeChild(holder);
+		}
+	};
+}
+export { mountComponent };

package/dist/_util/type.d.ts

@@ -0,0 +1,17 @@
+import type { Component, CSSProperties, VNodeChild } from 'vue';
+/**
+ * Render-type prop contract (same as antdv-next): a plain node (string / number / VNode)
+ * or a render function. Every `VueNode` prop also has a same-named slot; the slot wins.
+ */
+export type VueNode = VNodeChild | (() => VNodeChild);
+export type RenderNodeFn<T = any> = VNodeChild | ((ctx: T) => VNodeChild);
+export type SizeType = 'small' | 'middle' | 'large' | undefined;
+export type DirectionType = 'ltr' | 'rtl' | undefined;
+export type ValidateStatus = 'success' | 'warning' | 'error' | 'validating' | '';
+export type Key = string | number;
+export type Numeric = string | number;
+export type MaybeArray<T> = T | T[];
+export type GetContainer = string | HTMLElement | (() => HTMLElement) | false;
+export type SemanticClasses<K extends string> = Partial<Record<K, string>>;
+export type SemanticStyles<K extends string> = Partial<Record<K, CSSProperties>>;
+export type { Component, CSSProperties, VNodeChild };

package/dist/_util/vnode.d.ts

@@ -0,0 +1,11 @@
+import type { CSSProperties, VNode, VNodeChild } from 'vue';
+/**
+ * Flattens slot content into a list of renderable children:
+ * fragments (`v-for`, `<template>`) are unwrapped, comments (`v-if` placeholders) and blank text dropped.
+ */
+export declare function flattenChildren(children?: VNodeChild | VNodeChild[]): (VNode | string | number)[];
+/**
+ * Merges a computed inline style with `$attrs.style` so that the user's value always wins,
+ * whatever notation was used (`max-width` in a string vs `maxWidth` in an object).
+ */
+export declare function mergeAttrsStyle(base: CSSProperties | undefined, attrsStyle: unknown): CSSProperties;

package/dist/_util/vnode.js

@@ -0,0 +1,35 @@
+import { Comment, Fragment, Text, camelize, isVNode, normalizeStyle } from "vue";
+// src/_util/vnode.ts
+/**
+* Flattens slot content into a list of renderable children:
+* fragments (`v-for`, `<template>`) are unwrapped, comments (`v-if` placeholders) and blank text dropped.
+*/
+function flattenChildren(children) {
+	const result = [];
+	(Array.isArray(children) ? children : [children]).forEach((child) => {
+		if (child === null || child === void 0 || typeof child === "boolean") return;
+		if (Array.isArray(child)) result.push(...flattenChildren(child));
+		else if (isVNode(child)) {
+			if (child.type === Fragment) result.push(...flattenChildren(child.children));
+			else if (child.type === Comment) {} else if (child.type === Text) {
+				if (typeof child.children === "string" && child.children.trim() !== "") result.push(child);
+			} else result.push(child);
+		} else if (typeof child === "string") {
+			if (child.trim() !== "") result.push(child);
+		} else if (typeof child === "number") result.push(child);
+	});
+	return result;
+}
+/**
+* Merges a computed inline style with `$attrs.style` so that the user's value always wins,
+* whatever notation was used (`max-width` in a string vs `maxWidth` in an object).
+*/
+function mergeAttrsStyle(base, attrsStyle) {
+	const user = normalizeStyle([attrsStyle]);
+	const merged = { ...base };
+	if (user) Object.keys(user).forEach((key) => {
+		merged[key.startsWith("--") ? key : camelize(key)] = user[key];
+	});
+	return merged;
+}
+export { flattenChildren, mergeAttrsStyle };

package/dist/_util/withInstall.d.ts

@@ -0,0 +1,7 @@
+import type { Plugin } from 'vue';
+export type WithInstall<T, E = object> = T & E & Plugin;
+/** Adds `install` to a component (and optional sub components / static methods). */
+export declare function withInstall<T extends {
+    name?: string;
+    __name?: string;
+}, E extends Record<string, any> = object>(component: T, name: string, extra?: E): WithInstall<T, E>;

package/dist/_util/withInstall.js

@@ -0,0 +1,15 @@
+// src/_util/withInstall.ts
+/** Adds `install` to a component (and optional sub components / static methods). */
+function withInstall(component, name, extra) {
+	const comp = component;
+	comp.name = name;
+	if (extra) Object.assign(comp, extra);
+	comp.install = (app) => {
+		app.component(name, comp);
+		if (extra) Object.values(extra).forEach((sub) => {
+			if (sub && typeof sub === "object" && typeof sub.name === "string" && sub.name.startsWith("Am") && (sub.setup || sub.render || sub.__name)) app.component(sub.name, sub);
+		});
+	};
+	return comp;
+}
+export { withInstall };

package/dist/_virtual/_@oxc-project_runtime@0.156.0/helpers/esm/defineProperty.js

@@ -0,0 +1,11 @@
+import toPropertyKey from "./toPropertyKey.js";
+// \0@oxc-project+runtime@0.156.0/helpers/esm/defineProperty.js
+function _defineProperty(e, r, t) {
+	return (r = toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
+		value: t,
+		enumerable: !0,
+		configurable: !0,
+		writable: !0
+	}) : e[r] = t, e;
+}
+export { _defineProperty as default };

package/dist/_virtual/_@oxc-project_runtime@0.156.0/helpers/esm/toPrimitive.js

@@ -0,0 +1,13 @@
+import _typeof from "./typeof.js";
+// \0@oxc-project+runtime@0.156.0/helpers/esm/toPrimitive.js
+function toPrimitive(t, r) {
+	if ("object" != _typeof(t) || !t) return t;
+	var e = t[Symbol.toPrimitive];
+	if (void 0 !== e) {
+		var i = e.call(t, r || "default");
+		if ("object" != _typeof(i)) return i;
+		throw new TypeError("@@toPrimitive must return a primitive value.");
+	}
+	return ("string" === r ? String : Number)(t);
+}
+export { toPrimitive as default };

package/dist/_virtual/_@oxc-project_runtime@0.156.0/helpers/esm/toPropertyKey.js

@@ -0,0 +1,8 @@
+import _typeof from "./typeof.js";
+import toPrimitive from "./toPrimitive.js";
+// \0@oxc-project+runtime@0.156.0/helpers/esm/toPropertyKey.js
+function toPropertyKey(t) {
+	var i = toPrimitive(t, "string");
+	return "symbol" == _typeof(i) ? i : i + "";
+}
+export { toPropertyKey as default };

package/dist/_virtual/_@oxc-project_runtime@0.156.0/helpers/esm/typeof.js

@@ -0,0 +1,10 @@
+// \0@oxc-project+runtime@0.156.0/helpers/esm/typeof.js
+function _typeof(o) {
+	"@babel/helpers - typeof";
+	return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o) {
+		return typeof o;
+	} : function(o) {
+		return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
+	}, _typeof(o);
+}
+export { _typeof as default };

package/dist/_virtual/_rolldown/runtime.js

@@ -0,0 +1,12 @@
+// \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+export { __exportAll };

package/dist/action-bar/ActionBar.js

@@ -0,0 +1,4 @@
+import ActionBar_vue_vue_type_script_setup_true_lang_default from "./ActionBar.vue_vue_type_script_setup_true_lang.js";
+// src/action-bar/ActionBar.vue
+var ActionBar_default = ActionBar_vue_vue_type_script_setup_true_lang_default;
+export { ActionBar_default as default };

package/dist/action-bar/ActionBar.vue.d.ts

@@ -0,0 +1,21 @@
+import type { ActionBarProps, ActionBarSlots } from './interface';
+import '../style';
+import './style/index.css';
+type __VLS_Slots = ActionBarSlots;
+declare const __VLS_base: import("vue").DefineComponent<ActionBarProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ActionBarProps> & Readonly<{}>, {
+    fixed: boolean;
+    placeholder: boolean;
+    safeArea: boolean;
+    bordered: boolean;
+    prefix: 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/action-bar/ActionBar.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,75 @@
+import { isRenderable } from "../_util/index.js";
+import RenderNode_default from "../_util/RenderNode.js";
+import "../style/index2.js";
+import './style/index.css';/* empty css            */
+import { computed, createCommentVNode, createElementBlock, createElementVNode, createVNode, defineComponent, mergeProps, normalizeClass, normalizeStyle, openBlock, renderSlot, unref, useSlots } from "vue";
+// src/action-bar/ActionBar.vue?vue&type=script&setup=true&lang.ts
+var ActionBar_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComponent({
+	name: "AmActionBar",
+	inheritAttrs: false,
+	__name: "ActionBar",
+	props: {
+		fixed: {
+			type: Boolean,
+			default: true
+		},
+		placeholder: {
+			type: Boolean,
+			default: false
+		},
+		safeArea: {
+			type: Boolean,
+			default: true
+		},
+		bordered: {
+			type: Boolean,
+			default: true
+		},
+		zIndex: {},
+		prefix: {
+			type: [
+				Object,
+				String,
+				Number,
+				Boolean,
+				null,
+				Array,
+				Function
+			],
+			default: void 0
+		},
+		rootClass: {},
+		classes: {},
+		styles: {}
+	},
+	setup(__props) {
+		const props = __props;
+		const slots = useSlots();
+		const hasPrefix = computed(() => !!slots.prefix || isRenderable(props.prefix));
+		const classNames = computed(() => [
+			"am-action-bar",
+			{
+				"am-action-bar-fixed": props.fixed,
+				"am-action-bar-placeholder": props.fixed && props.placeholder,
+				"am-action-bar-safe-area": props.safeArea,
+				"am-action-bar-bordered": props.bordered
+			},
+			props.rootClass,
+			props.classes?.root
+		]);
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock("div", mergeProps(_ctx.$attrs, {
+				class: classNames.value,
+				style: __props.styles?.root
+			}), [createElementVNode("div", {
+				class: normalizeClass(["am-action-bar-content", __props.classes?.content]),
+				style: normalizeStyle([__props.zIndex !== void 0 ? { zIndex: __props.zIndex } : void 0, __props.styles?.content])
+			}, [hasPrefix.value ? (openBlock(), createElementBlock("div", {
+				key: 0,
+				class: normalizeClass(["am-action-bar-prefix", __props.classes?.prefix]),
+				style: normalizeStyle(__props.styles?.prefix)
+			}, [renderSlot(_ctx.$slots, "prefix", {}, () => [createVNode(unref(RenderNode_default), { node: __props.prefix }, null, 8, ["node"])])], 6)) : createCommentVNode("", true), renderSlot(_ctx.$slots, "default")], 6)], 16);
+		};
+	}
+});
+export { ActionBar_vue_vue_type_script_setup_true_lang_default as default };

package/dist/action-bar/ActionBarButton.js

@@ -0,0 +1,4 @@
+import ActionBarButton_vue_vue_type_script_setup_true_lang_default from "./ActionBarButton.vue_vue_type_script_setup_true_lang.js";
+// src/action-bar/ActionBarButton.vue
+var ActionBarButton_default = ActionBarButton_vue_vue_type_script_setup_true_lang_default;
+export { ActionBarButton_default as default };

package/dist/action-bar/ActionBarButton.vue.d.ts

@@ -0,0 +1,27 @@
+import type { ActionBarButtonProps, ActionBarButtonSlots } from './interface';
+import '../style';
+import './style/index.css';
+type __VLS_Slots = ActionBarButtonSlots;
+declare const __VLS_base: import("vue").DefineComponent<ActionBarButtonProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    click: (event: MouseEvent) => any;
+}, string, import("vue").PublicProps, Readonly<ActionBarButtonProps> & Readonly<{
+    onClick?: ((event: MouseEvent) => any) | undefined;
+}>, {
+    type: import("../components.ts").ButtonType;
+    icon: string | number | boolean | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }> | import("vue").VNodeArrayChildren | (() => import("vue").VNodeChild) | null;
+    disabled: boolean;
+    loading: boolean | {
+        delay?: number;
+        icon?: import("../index.ts").RenderNodeFn;
+    };
+}, {}, {}, {}, 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/action-bar/ActionBarButton.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,94 @@
+import Button_default from "../button/Button.js";
+import "../style/index2.js";
+import './style/index.css';/* empty css            */
+import { createBlock, createSlots, defineComponent, mergeProps, openBlock, renderSlot, withCtx } from "vue";
+// src/action-bar/ActionBarButton.vue?vue&type=script&setup=true&lang.ts
+var ActionBarButton_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComponent({
+	name: "AmActionBarButton",
+	inheritAttrs: false,
+	__name: "ActionBarButton",
+	props: {
+		type: { default: "primary" },
+		color: {},
+		variant: {},
+		danger: { type: Boolean },
+		ghost: { type: Boolean },
+		icon: {
+			type: [
+				Object,
+				String,
+				Number,
+				Boolean,
+				null,
+				Array,
+				Function
+			],
+			default: void 0
+		},
+		iconPlacement: {},
+		disabled: {
+			type: Boolean,
+			default: void 0
+		},
+		loading: {
+			type: [Boolean, Object],
+			default: false
+		},
+		href: {},
+		target: {},
+		htmlType: {},
+		rootClass: {},
+		classes: {},
+		styles: {}
+	},
+	emits: ["click"],
+	setup(__props, { emit: __emit }) {
+		const emit = __emit;
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(Button_default, mergeProps(_ctx.$attrs, {
+				type: __props.type,
+				color: __props.color,
+				variant: __props.variant,
+				danger: __props.danger,
+				ghost: __props.ghost,
+				icon: __props.icon,
+				"icon-placement": __props.iconPlacement,
+				disabled: __props.disabled,
+				loading: __props.loading,
+				href: __props.href,
+				target: __props.target,
+				"html-type": __props.htmlType,
+				"root-class": __props.rootClass,
+				classes: __props.classes,
+				styles: __props.styles,
+				class: "am-action-bar-button",
+				onClick: _cache[0] || (_cache[0] = ($event) => emit("click", $event))
+			}), createSlots({ _: 2 }, [_ctx.$slots.icon ? {
+				name: "icon",
+				fn: withCtx(() => [renderSlot(_ctx.$slots, "icon")]),
+				key: "0"
+			} : void 0, _ctx.$slots.default ? {
+				name: "default",
+				fn: withCtx(() => [renderSlot(_ctx.$slots, "default")]),
+				key: "1"
+			} : void 0]), 1040, [
+				"type",
+				"color",
+				"variant",
+				"danger",
+				"ghost",
+				"icon",
+				"icon-placement",
+				"disabled",
+				"loading",
+				"href",
+				"target",
+				"html-type",
+				"root-class",
+				"classes",
+				"styles"
+			]);
+		};
+	}
+});
+export { ActionBarButton_vue_vue_type_script_setup_true_lang_default as default };

package/dist/action-bar/ActionBarIcon.js

@@ -0,0 +1,4 @@
+import ActionBarIcon_vue_vue_type_script_setup_true_lang_default from "./ActionBarIcon.vue_vue_type_script_setup_true_lang.js";
+// src/action-bar/ActionBarIcon.vue
+var ActionBarIcon_default = ActionBarIcon_vue_vue_type_script_setup_true_lang_default;
+export { ActionBarIcon_default as default };

package/dist/action-bar/ActionBarIcon.vue.d.ts

@@ -0,0 +1,26 @@
+import type { ActionBarIconProps, ActionBarIconSlots } from './interface';
+import '../style';
+import './style/index.css';
+type __VLS_Slots = ActionBarIconSlots;
+declare const __VLS_base: import("vue").DefineComponent<ActionBarIconProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    click: (event: MouseEvent) => any;
+}, string, import("vue").PublicProps, Readonly<ActionBarIconProps> & Readonly<{
+    onClick?: ((event: MouseEvent) => any) | undefined;
+}>, {
+    text: string | number | boolean | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }> | import("vue").VNodeArrayChildren | (() => import("vue").VNodeChild) | null;
+    icon: string | number | boolean | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }> | import("vue").VNodeArrayChildren | (() => import("vue").VNodeChild) | null;
+    disabled: boolean;
+    badge: string | number | 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;
+    };
+};