@antdv-next/mobile 0.0.0-stage → 0.1.0

package/dist/slider/style/index.css

@@ -0,0 +1,253 @@
+.am-slider {
+  /* component tokens */
+  --am-slider-rail-size: 4px;
+  --am-slider-handle-size: 24px;
+  --am-slider-dot-size: 8px;
+  --am-slider-rail-bg: var(--am-color-fill-secondary);
+  --am-slider-track-bg: var(--am-color-primary);
+  --am-slider-handle-bg: var(--am-color-white);
+  --am-slider-handle-shadow: 0 1px 4px 0 rgb(0 0 0 / 24%), 0 0 1px 0 rgb(0 0 0 / 16%);
+  --am-slider-dot-border-color: var(--am-color-border);
+  --am-slider-vertical-height: 200px;
+
+  position: relative;
+  display: block;
+  box-sizing: border-box;
+  /* keeps the handle inside the box and gives the rail a comfortable touch target */
+  padding: calc((var(--am-control-height) - var(--am-slider-rail-size)) / 2) calc(var(--am-slider-handle-size) / 2);
+  color: var(--am-color-text);
+  font-size: var(--am-font-size);
+  font-family: var(--am-font-family);
+  line-height: var(--am-line-height);
+  cursor: pointer;
+  user-select: none;
+  touch-action: pan-y;
+  -webkit-tap-highlight-color: transparent;
+}
+
+.am-slider-body {
+  position: relative;
+  height: var(--am-slider-rail-size);
+}
+
+.am-slider-rail {
+  position: absolute;
+  inset: 0;
+  background: var(--am-slider-rail-bg);
+  border-radius: var(--am-slider-rail-size);
+}
+
+.am-slider-track {
+  position: absolute;
+  top: 0;
+  height: 100%;
+  background: var(--am-slider-track-bg);
+  border-radius: var(--am-slider-rail-size);
+}
+
+.am-slider-step {
+  position: absolute;
+  inset: 0;
+  pointer-events: none;
+}
+
+.am-slider-dot {
+  position: absolute;
+  top: 50%;
+  box-sizing: border-box;
+  width: var(--am-slider-dot-size);
+  height: var(--am-slider-dot-size);
+  margin-top: calc(var(--am-slider-dot-size) / -2);
+  margin-inline: calc(var(--am-slider-dot-size) / -2);
+  background: var(--am-color-bg-container);
+  border: 2px solid var(--am-slider-dot-border-color);
+  border-radius: 50%;
+}
+
+.am-slider-dot-active {
+  border-color: var(--am-slider-track-bg);
+}
+
+.am-slider-handle {
+  position: absolute;
+  top: 50%;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  width: var(--am-slider-handle-size);
+  height: var(--am-slider-handle-size);
+  margin-top: calc(var(--am-slider-handle-size) / -2);
+  margin-inline: calc(var(--am-slider-handle-size) / -2);
+  outline: none;
+  cursor: grab;
+}
+
+/* enlarges the touch target of the handle to 44px */
+.am-slider-handle::before {
+  position: absolute;
+  inset: calc((var(--am-slider-handle-size) - 44px) / 2);
+  content: '';
+}
+
+.am-slider-thumb {
+  position: relative;
+  box-sizing: border-box;
+  width: 100%;
+  height: 100%;
+  background: var(--am-slider-handle-bg);
+  border-radius: 50%;
+  box-shadow: var(--am-slider-handle-shadow);
+  transition: transform var(--am-motion-duration-fast);
+}
+
+.am-slider-handle-active {
+  z-index: 1;
+  cursor: grabbing;
+}
+
+.am-slider-handle-active .am-slider-thumb {
+  transform: scale(1.12);
+}
+
+.am-slider-handle:focus-visible .am-slider-thumb {
+  outline: 2px solid var(--am-color-primary-border);
+  outline-offset: 1px;
+}
+
+.am-slider-tooltip {
+  position: absolute;
+  bottom: calc(100% + 10px);
+  left: 50%;
+  z-index: 1;
+  min-width: 28px;
+  padding: 4px 8px;
+  color: var(--am-color-text-light-solid);
+  font-size: var(--am-font-size-sm);
+  line-height: 1.4;
+  white-space: nowrap;
+  text-align: center;
+  background: var(--am-color-bg-spotlight);
+  border-radius: var(--am-border-radius-sm);
+  box-shadow: var(--am-box-shadow-secondary);
+  transform: translateX(-50%);
+  pointer-events: none;
+}
+
+.am-slider-tooltip::after {
+  position: absolute;
+  top: 100%;
+  left: 50%;
+  margin-left: -4px;
+  border: 4px solid transparent;
+  border-top-color: var(--am-color-bg-spotlight);
+  content: '';
+}
+
+.am-slider-mark {
+  position: absolute;
+  top: calc(var(--am-slider-rail-size) + var(--am-slider-handle-size) / 2 + 2px);
+  right: 0;
+  left: 0;
+}
+
+.am-slider-mark-text {
+  position: absolute;
+  color: var(--am-color-text-tertiary);
+  font-size: var(--am-font-size-sm);
+  white-space: nowrap;
+  transform: translateX(-50%);
+}
+
+.am-slider-mark-text-active {
+  color: var(--am-color-text);
+}
+
+.am-slider-horizontal.am-slider-with-marks {
+  margin-bottom: var(--am-margin-xs);
+  padding-bottom: calc((var(--am-control-height) - var(--am-slider-rail-size)) / 2 + 12px);
+}
+
+.am-slider-horizontal.am-slider-reverse .am-slider-mark-text,
+[dir='rtl'] .am-slider-horizontal .am-slider-mark-text {
+  transform: translateX(50%);
+}
+
+[dir='rtl'] .am-slider-horizontal.am-slider-reverse .am-slider-mark-text {
+  transform: translateX(-50%);
+}
+
+/* ---------- vertical ---------- */
+.am-slider-vertical {
+  display: inline-block;
+  height: var(--am-slider-vertical-height);
+  padding: calc(var(--am-slider-handle-size) / 2) calc((var(--am-control-height) - var(--am-slider-rail-size)) / 2);
+  vertical-align: top;
+  touch-action: pan-x;
+}
+
+.am-slider-vertical .am-slider-body {
+  width: var(--am-slider-rail-size);
+  height: 100%;
+}
+
+.am-slider-vertical .am-slider-track {
+  top: auto;
+  left: 0;
+  width: 100%;
+  height: auto;
+}
+
+.am-slider-vertical .am-slider-dot,
+.am-slider-vertical .am-slider-handle {
+  top: auto;
+  left: 50%;
+  margin-inline: 0;
+}
+
+.am-slider-vertical .am-slider-dot {
+  margin: calc(var(--am-slider-dot-size) / -2);
+}
+
+.am-slider-vertical .am-slider-handle {
+  margin: calc(var(--am-slider-handle-size) / -2);
+}
+
+.am-slider-vertical .am-slider-mark {
+  top: 0;
+  right: auto;
+  bottom: 0;
+  left: calc(var(--am-slider-rail-size) + var(--am-slider-handle-size) / 2 + 6px);
+}
+
+.am-slider-vertical .am-slider-mark-text {
+  transform: translateY(50%);
+}
+
+.am-slider-vertical.am-slider-reverse .am-slider-mark-text {
+  transform: translateY(-50%);
+}
+
+[dir='rtl'] .am-slider-vertical .am-slider-mark {
+  right: calc(var(--am-slider-rail-size) + var(--am-slider-handle-size) / 2 + 6px);
+  left: auto;
+}
+
+/* ---------- disabled ---------- */
+.am-slider-disabled {
+  cursor: not-allowed;
+}
+
+.am-slider-disabled .am-slider-track,
+.am-slider-disabled .am-slider-dot-active {
+  opacity: var(--am-opacity-disabled);
+}
+
+.am-slider-disabled .am-slider-handle {
+  cursor: not-allowed;
+}
+
+@media (prefers-reduced-motion: reduce) {
+  .am-slider-thumb {
+    transition: none;
+  }
+}

package/dist/space/Space.js

@@ -0,0 +1,4 @@
+import Space_vue_vue_type_script_setup_true_lang_default from "./Space.vue_vue_type_script_setup_true_lang.js";
+// src/space/Space.vue
+var Space_default = Space_vue_vue_type_script_setup_true_lang_default;
+export { Space_default as default };

package/dist/space/Space.vue.d.ts

@@ -0,0 +1,18 @@
+import type { SpaceProps, SpaceSize, SpaceSlots } from './interface';
+import '../style';
+import './style/index.css';
+type __VLS_Slots = SpaceSlots;
+declare const __VLS_base: import("vue").DefineComponent<SpaceProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<SpaceProps> & Readonly<{}>, {
+    block: boolean;
+    size: string | number | [SpaceSize, SpaceSize];
+    wrap: boolean;
+    vertical: 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/space/Space.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,107 @@
+import { addUnit } from "../_util/index.js";
+import RenderNode_default from "../_util/RenderNode.js";
+import { flattenChildren, mergeAttrsStyle } from "../_util/vnode.js";
+import "../style/index2.js";
+import './style/index.css';/* empty css            */
+import { Fragment, computed, createCommentVNode, createElementBlock, createElementVNode, createVNode, defineComponent, mergeProps, normalizeClass, normalizeStyle, openBlock, renderList, renderSlot, unref, useSlots } from "vue";
+// src/space/Space.vue?vue&type=script&setup=true&lang.ts
+var Space_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComponent({
+	name: "AmSpace",
+	inheritAttrs: false,
+	__name: "Space",
+	props: {
+		size: { default: "small" },
+		orientation: {},
+		direction: {},
+		vertical: {
+			type: Boolean,
+			default: void 0
+		},
+		align: {},
+		wrap: {
+			type: Boolean,
+			default: false
+		},
+		separator: { type: [
+			Object,
+			String,
+			Number,
+			Boolean,
+			null,
+			Array,
+			Function
+		] },
+		block: {
+			type: Boolean,
+			default: false
+		},
+		rootClass: {},
+		classes: {},
+		styles: {}
+	},
+	setup(__props) {
+		const props = __props;
+		const slots = useSlots();
+		const presetSizes = [
+			"small",
+			"middle",
+			"large"
+		];
+		const isPreset = (size) => typeof size === "string" && presetSizes.includes(size);
+		const isVertical = computed(() => props.vertical ?? (props.orientation ?? props.direction) === "vertical");
+		const mergedAlign = computed(() => props.align ?? (isVertical.value ? void 0 : "center"));
+		const sizes = computed(() => {
+			const [h, v] = Array.isArray(props.size) ? props.size : [props.size, props.size];
+			return [h ?? "small", v ?? "small"];
+		});
+		const hasSeparator = computed(() => !!slots.separator || props.separator !== void 0 && props.separator !== null && props.separator !== false);
+		const classNames = computed(() => {
+			const [h, v] = sizes.value;
+			return [
+				"am-space",
+				isVertical.value ? "am-space-vertical" : "am-space-horizontal",
+				{
+					[`am-space-align-${mergedAlign.value}`]: !!mergedAlign.value,
+					"am-space-wrap": props.wrap,
+					"am-space-block": props.block,
+					[`am-space-gap-col-${h}`]: isPreset(h),
+					[`am-space-gap-row-${v}`]: isPreset(v)
+				},
+				props.rootClass,
+				props.classes?.root
+			];
+		});
+		const mergedStyle = computed(() => {
+			const [h, v] = sizes.value;
+			const style = {};
+			if (!isPreset(h)) style.columnGap = addUnit(h);
+			if (!isPreset(v)) style.rowGap = addUnit(v);
+			return {
+				...style,
+				...props.styles?.root
+			};
+		});
+		let children = [];
+		function collectChildren() {
+			children = flattenChildren(slots.default?.());
+			return children.length > 0;
+		}
+		const getChildren = () => children;
+		return (_ctx, _cache) => {
+			return collectChildren() ? (openBlock(), createElementBlock("div", mergeProps({ key: 0 }, _ctx.$attrs, {
+				class: classNames.value,
+				style: unref(mergeAttrsStyle)(mergedStyle.value, _ctx.$attrs.style)
+			}), [(openBlock(true), createElementBlock(Fragment, null, renderList(getChildren(), (child, index) => {
+				return openBlock(), createElementBlock(Fragment, { key: index }, [createElementVNode("div", {
+					class: normalizeClass(["am-space-item", __props.classes?.item]),
+					style: normalizeStyle(__props.styles?.item)
+				}, [createVNode(unref(RenderNode_default), { node: child }, null, 8, ["node"])], 6), hasSeparator.value && index < getChildren().length - 1 ? (openBlock(), createElementBlock("span", {
+					key: 0,
+					class: normalizeClass(["am-space-item-separator", __props.classes?.separator]),
+					style: normalizeStyle(__props.styles?.separator)
+				}, [renderSlot(_ctx.$slots, "separator", {}, () => [createVNode(unref(RenderNode_default), { node: __props.separator }, null, 8, ["node"])])], 6)) : createCommentVNode("", true)], 64);
+			}), 128))], 16)) : createCommentVNode("", true);
+		};
+	}
+});
+export { Space_vue_vue_type_script_setup_true_lang_default as default };

package/dist/space/SpaceAddon.js

@@ -0,0 +1,4 @@
+import SpaceAddon_vue_vue_type_script_setup_true_lang_default from "./SpaceAddon.vue_vue_type_script_setup_true_lang.js";
+// src/space/SpaceAddon.vue
+var SpaceAddon_default = SpaceAddon_vue_vue_type_script_setup_true_lang_default;
+export { SpaceAddon_default as default };

package/dist/space/SpaceAddon.vue.d.ts

@@ -0,0 +1,16 @@
+import type { SpaceAddonProps, SpaceAddonSlots } from './interface';
+import '../style';
+import './style/compact.css';
+type __VLS_Slots = SpaceAddonSlots;
+declare const __VLS_base: import("vue").DefineComponent<SpaceAddonProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<SpaceAddonProps> & Readonly<{}>, {
+    disabled: boolean;
+    variant: "outlined" | "filled" | "borderless";
+}, {}, {}, {}, 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/space/SpaceAddon.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,39 @@
+import { useCompactItemContext } from "../_base/compact.js";
+import { useDisabled, useSize } from "../config-provider/context.js";
+import "../style/index2.js";
+import './style/compact.css';/* empty css              */
+import { createElementBlock, defineComponent, mergeProps, openBlock, renderSlot, unref } from "vue";
+// src/space/SpaceAddon.vue?vue&type=script&setup=true&lang.ts
+var SpaceAddon_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComponent({
+	name: "AmSpaceAddon",
+	inheritAttrs: false,
+	__name: "SpaceAddon",
+	props: {
+		variant: { default: "outlined" },
+		size: {},
+		disabled: {
+			type: Boolean,
+			default: void 0
+		},
+		rootClass: {}
+	},
+	setup(__props) {
+		const props = __props;
+		const compact = useCompactItemContext();
+		const size = useSize(() => props.size ?? compact.size.value);
+		const disabled = useDisabled(() => props.disabled);
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock("div", mergeProps(_ctx.$attrs, { class: ["am-space-addon", [
+				`am-space-addon-${__props.variant}`,
+				{
+					"am-space-addon-sm": unref(size) === "small",
+					"am-space-addon-lg": unref(size) === "large",
+					"am-space-addon-disabled": unref(disabled)
+				},
+				unref(compact).classes.value,
+				__props.rootClass
+			]] }), [renderSlot(_ctx.$slots, "default")], 16);
+		};
+	}
+});
+export { SpaceAddon_vue_vue_type_script_setup_true_lang_default as default };

package/dist/space/SpaceCompact.js

@@ -0,0 +1,4 @@
+import SpaceCompact_vue_vue_type_script_setup_true_lang_default from "./SpaceCompact.vue_vue_type_script_setup_true_lang.js";
+// src/space/SpaceCompact.vue
+var SpaceCompact_default = SpaceCompact_vue_vue_type_script_setup_true_lang_default;
+export { SpaceCompact_default as default };

package/dist/space/SpaceCompact.vue.d.ts

@@ -0,0 +1,16 @@
+import type { SpaceCompactProps, SpaceCompactSlots } from './interface';
+import '../style';
+import './style/compact.css';
+type __VLS_Slots = SpaceCompactSlots;
+declare const __VLS_base: import("vue").DefineComponent<SpaceCompactProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<SpaceCompactProps> & Readonly<{}>, {
+    block: boolean;
+    vertical: 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/space/SpaceCompact.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,57 @@
+import { CompactItem, compactItemContextKey } from "../_base/compact.js";
+import { flattenChildren } from "../_util/vnode.js";
+import { useSize } from "../config-provider/context.js";
+import "../style/index2.js";
+import './style/compact.css';/* empty css              */
+import { computed, createElementBlock, createVNode, defineComponent, h, inject, mergeProps, openBlock, unref, useSlots } from "vue";
+// src/space/SpaceCompact.vue?vue&type=script&setup=true&lang.ts
+var SpaceCompact_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComponent({
+	name: "AmSpaceCompact",
+	inheritAttrs: false,
+	__name: "SpaceCompact",
+	props: {
+		size: {},
+		orientation: {},
+		direction: {},
+		vertical: {
+			type: Boolean,
+			default: void 0
+		},
+		block: {
+			type: Boolean,
+			default: false
+		},
+		rootClass: {}
+	},
+	setup(__props) {
+		const props = __props;
+		const slots = useSlots();
+		const parent = inject(compactItemContextKey, null);
+		const size = useSize(() => props.size ?? parent?.value.size);
+		const orientation = computed(() => {
+			if (props.vertical !== void 0) return props.vertical ? "vertical" : "horizontal";
+			return props.orientation ?? props.direction ?? "horizontal";
+		});
+		/** Each child gets its own context with its position in the group. */
+		function Items() {
+			const children = flattenChildren(slots.default?.());
+			const last = children.length - 1;
+			return children.map((child, index) => h(CompactItem, {
+				key: child?.key ?? `am-compact-${index}`,
+				size: size.value,
+				orientation: orientation.value,
+				isFirstItem: index === 0 && (!parent || parent.value.isFirstItem),
+				isLastItem: index === last && (!parent || parent.value.isLastItem)
+			}, () => child));
+		}
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock("div", mergeProps(_ctx.$attrs, { class: ["am-space-compact", [{
+				"am-space-compact-block": __props.block,
+				"am-space-compact-vertical": orientation.value === "vertical",
+				"am-space-compact-sm": unref(size) === "small",
+				"am-space-compact-lg": unref(size) === "large"
+			}, __props.rootClass]] }), [createVNode(Items)], 16);
+		};
+	}
+});
+export { SpaceCompact_vue_vue_type_script_setup_true_lang_default as default };

package/dist/space/index.d.ts

@@ -0,0 +1,131 @@
+export { useCompactItemContext } from '../_base/compact';
+export type { UseCompactItemContextReturn } from '../_base/compact';
+export type * from './interface';
+export declare const SpaceCompact: import("../_util/withInstall").WithInstall<{
+    new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("./interface").SpaceCompactProps> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {
+        block: boolean;
+        vertical: boolean;
+    }, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import("./interface").SpaceCompactProps> & Readonly<{}>, {}, {}, {}, {}, {
+        block: boolean;
+        vertical: boolean;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import("vue").ComponentOptionsBase<Readonly<import("./interface").SpaceCompactProps> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
+    block: boolean;
+    vertical: 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").SpaceCompactSlots;
+}), object>;
+export declare const SpaceAddon: import("../_util/withInstall").WithInstall<{
+    new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("./interface").SpaceAddonProps> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {
+        disabled: boolean;
+        variant: "outlined" | "filled" | "borderless";
+    }, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import("./interface").SpaceAddonProps> & Readonly<{}>, {}, {}, {}, {}, {
+        disabled: boolean;
+        variant: "outlined" | "filled" | "borderless";
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import("vue").ComponentOptionsBase<Readonly<import("./interface").SpaceAddonProps> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
+    disabled: boolean;
+    variant: "outlined" | "filled" | "borderless";
+}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+    $slots: import("./interface").SpaceAddonSlots;
+}), object>;
+declare const Space: import("../_util/withInstall").WithInstall<{
+    new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("./interface").SpaceProps> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {
+        block: boolean;
+        size: string | number | [import("./interface").SpaceSize, import("./interface").SpaceSize];
+        wrap: boolean;
+        vertical: boolean;
+    }, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import("./interface").SpaceProps> & Readonly<{}>, {}, {}, {}, {}, {
+        block: boolean;
+        size: string | number | [import("./interface").SpaceSize, import("./interface").SpaceSize];
+        wrap: boolean;
+        vertical: boolean;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import("vue").ComponentOptionsBase<Readonly<import("./interface").SpaceProps> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
+    block: boolean;
+    size: string | number | [import("./interface").SpaceSize, import("./interface").SpaceSize];
+    wrap: boolean;
+    vertical: 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").SpaceSlots;
+}), {
+    Compact: import("../_util/withInstall").WithInstall<{
+        new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("./interface").SpaceCompactProps> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {
+            block: boolean;
+            vertical: boolean;
+        }, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly<import("./interface").SpaceCompactProps> & Readonly<{}>, {}, {}, {}, {}, {
+            block: boolean;
+            vertical: boolean;
+        }>;
+        __isFragment?: never;
+        __isTeleport?: never;
+        __isSuspense?: never;
+    } & import("vue").ComponentOptionsBase<Readonly<import("./interface").SpaceCompactProps> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
+        block: boolean;
+        vertical: 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").SpaceCompactSlots;
+    }), object>;
+    Addon: import("../_util/withInstall").WithInstall<{
+        new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("./interface").SpaceAddonProps> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {
+            disabled: boolean;
+            variant: "outlined" | "filled" | "borderless";
+        }, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly<import("./interface").SpaceAddonProps> & Readonly<{}>, {}, {}, {}, {}, {
+            disabled: boolean;
+            variant: "outlined" | "filled" | "borderless";
+        }>;
+        __isFragment?: never;
+        __isTeleport?: never;
+        __isSuspense?: never;
+    } & import("vue").ComponentOptionsBase<Readonly<import("./interface").SpaceAddonProps> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
+        disabled: boolean;
+        variant: "outlined" | "filled" | "borderless";
+    }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+        $slots: import("./interface").SpaceAddonSlots;
+    }), object>;
+}>;
+export default Space;

package/dist/space/index.js

@@ -0,0 +1,13 @@
+import { withInstall } from "../_util/withInstall.js";
+import "../_base/compact.js";
+import Space_default from "./Space.js";
+import SpaceAddon_default from "./SpaceAddon.js";
+import SpaceCompact_default from "./SpaceCompact.js";
+// src/space/index.ts
+var SpaceCompact = withInstall(SpaceCompact_default, "AmSpaceCompact");
+var SpaceAddon = withInstall(SpaceAddon_default, "AmSpaceAddon");
+var Space = withInstall(Space_default, "AmSpace", {
+	Compact: SpaceCompact,
+	Addon: SpaceAddon
+});
+export { SpaceAddon, SpaceCompact, Space as default };