@antdv-next/mobile 0.0.0-stage → 0.1.1

package/dist/date-picker/style/index.css

@@ -0,0 +1,93 @@
+/* DatePicker / RangePicker are composed of the shared picker trigger, picker popup, Segmented and PickerView. */
+.am-date-picker-view {
+  --am-date-picker-view-font-size: var(--am-font-size-lg);
+
+  font-size: var(--am-date-picker-view-font-size);
+  font-variant-numeric: tabular-nums;
+}
+
+/* ---------- RangePicker: trigger ---------- */
+.am-range-picker {
+  --am-range-picker-separator-color: var(--am-color-text-quaternary);
+  --am-range-picker-gap: var(--am-padding-xs);
+}
+
+.am-range-picker .am-range-picker-content {
+  display: flex;
+  gap: var(--am-range-picker-gap);
+  align-items: center;
+}
+
+.am-range-picker-input {
+  flex: 1 1 0;
+  min-width: 0;
+  overflow: hidden;
+  white-space: nowrap;
+  text-overflow: ellipsis;
+  font-variant-numeric: tabular-nums;
+}
+
+.am-range-picker-input-placeholder {
+  color: var(--am-picker-trigger-placeholder-color);
+}
+
+.am-range-picker-input-disabled {
+  color: var(--am-color-text-disabled);
+}
+
+.am-range-picker-separator {
+  display: inline-flex;
+  flex: none;
+  align-items: center;
+  color: var(--am-range-picker-separator-color);
+}
+
+[dir='rtl'] .am-range-picker-separator > .anticon {
+  transform: scaleX(-1);
+}
+
+/* ---------- RangePicker: start / end tabs of the popup ---------- */
+.am-range-picker-tabs {
+  --am-range-picker-tabs-padding: var(--am-padding-xs) var(--am-padding);
+  --am-range-picker-tab-padding-block: 6px;
+  --am-range-picker-tab-title-font-size: var(--am-font-size-sm);
+  --am-range-picker-tab-value-font-size: var(--am-font-size);
+  --am-range-picker-tab-active-color: var(--am-color-primary);
+
+  flex: none;
+  box-sizing: border-box;
+  padding: var(--am-range-picker-tabs-padding);
+}
+
+.am-range-picker-tab {
+  padding-block: var(--am-range-picker-tab-padding-block);
+}
+
+.am-range-picker-tab-label {
+  display: flex;
+  flex-direction: column;
+  gap: 2px;
+  align-items: center;
+  max-width: 100%;
+}
+
+.am-range-picker-tab-title {
+  font-size: var(--am-range-picker-tab-title-font-size);
+}
+
+.am-range-picker-tab-value {
+  max-width: 100%;
+  overflow: hidden;
+  font-size: var(--am-range-picker-tab-value-font-size);
+  text-overflow: ellipsis;
+  font-variant-numeric: tabular-nums;
+}
+
+.am-segmented-item-selected .am-range-picker-tab-value {
+  color: var(--am-range-picker-tab-active-color);
+}
+
+.am-range-picker-tab-value-empty,
+.am-segmented-item-selected .am-range-picker-tab-value-empty {
+  color: var(--am-color-text-placeholder);
+}

package/dist/date-picker/util.d.ts

@@ -0,0 +1,39 @@
+import type { Dayjs } from 'dayjs';
+import type { Locale } from '../locale/interface';
+import type { PickerOption } from '../picker-view/interface';
+import type { DatePickerBaseProps, DatePickerColumnType, DatePickerMode, DatePickerValue } from './interface';
+export interface DateContext {
+    picker: DatePickerMode;
+    types: DatePickerColumnType[];
+    /** undefined: unbounded (time-only pickers) */
+    min?: Dayjs;
+    max?: Dayjs;
+    use12Hours: boolean;
+    hourStep: number;
+    minuteStep: number;
+    secondStep: number;
+    /** display format */
+    format: string | ((value: Dayjs) => string);
+    valueFormat?: string;
+    disabledDate?: DatePickerBaseProps['disabledDate'];
+    disabledTime?: DatePickerBaseProps['disabledTime'];
+    filter?: DatePickerBaseProps['filter'];
+    renderLabel?: DatePickerBaseProps['renderLabel'];
+    locale: Locale['DatePicker'];
+}
+/** Parses a bound value: dayjs objects pass through, strings are read with `valueFormat` (then `fallbackFormat`). */
+export declare function toDayjs(value: DatePickerValue | Date | number | null | undefined, valueFormat?: string, fallbackFormat?: string): Dayjs | undefined;
+export declare function createDateContext(props: DatePickerBaseProps, locale: Locale['DatePicker'], now?: Dayjs): DateContext;
+export declare function formatDate(ctx: DateContext, date: Dayjs | undefined): string;
+/** dayjs -> bound value (`valueFormat` string or dayjs) */
+export declare function toValue(ctx: DateContext, date: Dayjs): DatePickerValue;
+export declare function clampDate(date: Dayjs, min?: Dayjs, max?: Dayjs): Dayjs;
+export declare function generateColumns(ctx: DateContext, date: Dayjs): PickerOption[][];
+export declare function dateToValues(ctx: DateContext, date: Dayjs): number[];
+/** Applies wheel values on top of `base`, keeping the result a real date (e.g. Jan 31 -> Feb 29). */
+export declare function valuesToDate(ctx: DateContext, values: (number | string | undefined)[], base: Dayjs): Dayjs;
+/**
+ * Makes `date` selectable: clamps it into `[min, max]`, then walks the columns from coarse to fine and
+ * snaps every value that is missing (steps, filters, bounds) or disabled to the nearest enabled option.
+ */
+export declare function settleDate(ctx: DateContext, input: Dayjs): Dayjs;

package/dist/date-picker/util.js

@@ -0,0 +1,264 @@
+import { padZero } from "../_util/index.js";
+import dayjs from "dayjs";
+import advancedFormat from "dayjs/plugin/advancedFormat";
+import customParseFormat from "dayjs/plugin/customParseFormat";
+import isoWeek from "dayjs/plugin/isoWeek";
+import quarterOfYear from "dayjs/plugin/quarterOfYear";
+// src/date-picker/util.ts
+dayjs.extend(customParseFormat);
+dayjs.extend(advancedFormat);
+dayjs.extend(isoWeek);
+dayjs.extend(quarterOfYear);
+var DEFAULT_TIME_FORMAT = "HH:mm:ss";
+var DEFAULT_FORMATS = {
+	date: "YYYY-MM-DD",
+	month: "YYYY-MM",
+	year: "YYYY",
+	quarter: "YYYY-[Q]Q",
+	week: "GGGG-[W]WW"
+};
+/** Parses a bound value: dayjs objects pass through, strings are read with `valueFormat` (then `fallbackFormat`). */
+function toDayjs(value, valueFormat, fallbackFormat) {
+	if (value === void 0 || value === null || value === "") return void 0;
+	if (dayjs.isDayjs(value)) return value.isValid() ? value : void 0;
+	if (typeof value === "string") {
+		if (valueFormat) {
+			const parsed = dayjs(value, valueFormat);
+			if (parsed.isValid()) return parsed;
+		}
+		const loose = dayjs(value);
+		if (loose.isValid()) return loose;
+		if (fallbackFormat) {
+			const parsed = dayjs(value, fallbackFormat);
+			if (parsed.isValid()) return parsed;
+		}
+		return;
+	}
+	const parsed = dayjs(value);
+	return parsed.isValid() ? parsed : void 0;
+}
+function getTimeTypes(format, config, use12Hours) {
+	const tokens = format.replace(/\[[^\]]*\]/g, "");
+	const types = [];
+	if (/h/i.test(tokens) && config.showHour !== false) types.push("hour");
+	if (tokens.includes("m") && config.showMinute !== false) types.push("minute");
+	if (tokens.includes("s") && config.showSecond !== false) types.push("second");
+	if (use12Hours && types.includes("hour")) types.push("meridiem");
+	return types;
+}
+function createDateContext(props, locale, now = dayjs()) {
+	const picker = props.picker ?? "date";
+	const showTime = picker === "time" || picker === "date" && props.showTime ? typeof props.showTime === "object" ? props.showTime : {} : void 0;
+	let types = [];
+	let format = props.format ?? "";
+	let use12Hours = false;
+	if (showTime) {
+		const explicit12 = showTime.use12Hours ?? props.use12Hours;
+		let timeFormat = showTime.format;
+		if (!timeFormat && picker === "time" && typeof props.format === "string") timeFormat = props.format;
+		const tokens = (timeFormat ?? "").replace(/\[[^\]]*\]/g, "");
+		use12Hours = explicit12 ?? (tokens.includes("h") || /a/i.test(tokens));
+		if (!timeFormat) timeFormat = use12Hours ? "h:mm:ss a" : DEFAULT_TIME_FORMAT;
+		types = getTimeTypes(timeFormat, showTime, use12Hours);
+		if (!props.format) format = picker === "time" ? timeFormat : `${DEFAULT_FORMATS.date} ${timeFormat}`;
+	}
+	if (picker !== "time") {
+		types = [...{
+			date: [
+				"year",
+				"month",
+				"day"
+			],
+			month: ["year", "month"],
+			year: ["year"],
+			quarter: ["year", "quarter"],
+			week: ["year", "week"]
+		}[picker], ...types];
+		if (!format) format = DEFAULT_FORMATS[picker];
+	}
+	const bounded = picker !== "time";
+	let min = toDayjs(props.minDate, props.valueFormat) ?? (bounded ? now.subtract(10, "year").startOf("year") : void 0);
+	let max = toDayjs(props.maxDate, props.valueFormat) ?? (bounded ? now.add(10, "year").endOf("year") : void 0);
+	if (min && max && min.isAfter(max)) [min, max] = [max, min];
+	return {
+		picker,
+		types,
+		min,
+		max,
+		use12Hours,
+		hourStep: Math.max(showTime?.hourStep ?? props.hourStep ?? 1, 1),
+		minuteStep: Math.max(showTime?.minuteStep ?? props.minuteStep ?? 1, 1),
+		secondStep: Math.max(showTime?.secondStep ?? props.secondStep ?? 1, 1),
+		format,
+		valueFormat: props.valueFormat,
+		disabledDate: props.disabledDate,
+		disabledTime: props.disabledTime,
+		filter: props.filter,
+		renderLabel: props.renderLabel,
+		locale
+	};
+}
+function formatDate(ctx, date) {
+	if (!date) return "";
+	return typeof ctx.format === "function" ? ctx.format(date) : date.format(ctx.format);
+}
+/** dayjs -> bound value (`valueFormat` string or dayjs) */
+function toValue(ctx, date) {
+	return ctx.valueFormat ? date.format(ctx.valueFormat) : date;
+}
+function clampDate(date, min, max) {
+	if (min && date.isBefore(min)) return min;
+	if (max && date.isAfter(max)) return max;
+	return date;
+}
+function range(from, to, step = 1) {
+	const list = [];
+	for (let value = Math.ceil(from / step) * step; value <= to; value += step) list.push(value);
+	return list;
+}
+/** ISO weeks of a year: Dec 28th is always in the last week */
+var isoWeeksInYear = (year) => dayjs(new Date(year, 11, 28)).isoWeek();
+/** Monday of an ISO week: Jan 4th is always in week 1 */
+var isoWeekStart = (year, week) => dayjs(new Date(year, 0, 4)).startOf("isoWeek").add(week - 1, "week");
+var yearOf = (ctx, date) => ctx.picker === "week" ? date.isoWeekYear() : date.year();
+var toHour12 = (hour) => hour % 12 || 12;
+function defaultLabel(ctx, type, value) {
+	const { locale } = ctx;
+	if (type === "meridiem") return value ? locale.pm : locale.am;
+	const unit = locale[type];
+	const text = type === "hour" || type === "minute" || type === "second" ? padZero(value) : String(value);
+	return /^[a-z]$/i.test(unit) ? `${unit}${text}` : `${text}${unit}`;
+}
+function getColumn(ctx, type, date) {
+	const { min, max, picker } = ctx;
+	const year = yearOf(ctx, date);
+	const same = (bound, unit) => !!bound && date.isSame(bound, unit);
+	const disabledTimes = type === "hour" || type === "minute" || type === "second" ? ctx.disabledTime?.(date) : void 0;
+	let values = [];
+	let isDisabled;
+	switch (type) {
+		case "year":
+			values = range(min ? yearOf(ctx, min) : year - 10, max ? yearOf(ctx, max) : year + 10);
+			if (picker === "year" && ctx.disabledDate) isDisabled = (value) => ctx.disabledDate(date.year(value), { type: picker });
+			break;
+		case "quarter":
+			values = range(same(min, "year") ? min.quarter() : 1, same(max, "year") ? max.quarter() : 4);
+			if (ctx.disabledDate) isDisabled = (value) => ctx.disabledDate(date.month((value - 1) * 3).startOf("month"), { type: picker });
+			break;
+		case "month":
+			values = range(same(min, "year") ? min.month() + 1 : 1, same(max, "year") ? max.month() + 1 : 12);
+			if (picker === "month" && ctx.disabledDate) isDisabled = (value) => ctx.disabledDate(date.date(1).month(value - 1), { type: picker });
+			break;
+		case "week":
+			values = range(min && min.isoWeekYear() === year ? min.isoWeek() : 1, max && max.isoWeekYear() === year ? max.isoWeek() : isoWeeksInYear(year));
+			if (ctx.disabledDate) isDisabled = (value) => ctx.disabledDate(isoWeekStart(year, value), { type: picker });
+			break;
+		case "day":
+			values = range(same(min, "month") ? min.date() : 1, same(max, "month") ? max.date() : date.daysInMonth());
+			if (ctx.disabledDate) isDisabled = (value) => ctx.disabledDate(date.date(value), { type: picker });
+			break;
+		case "hour": {
+			let hours = range(same(min, "day") ? min.hour() : 0, same(max, "day") ? max.hour() : 23, ctx.hourStep);
+			const disabledHours = disabledTimes?.disabledHours?.() ?? [];
+			if (ctx.use12Hours) {
+				const pm = date.hour() >= 12;
+				hours = hours.filter((hour) => hour >= 12 === pm);
+				isDisabled = (value) => disabledHours.includes(value % 12 + (pm ? 12 : 0));
+				values = hours.map(toHour12);
+			} else {
+				isDisabled = (value) => disabledHours.includes(value);
+				values = hours;
+			}
+			break;
+		}
+		case "minute": {
+			values = range(same(min, "hour") ? min.minute() : 0, same(max, "hour") ? max.minute() : 59, ctx.minuteStep);
+			const disabledMinutes = disabledTimes?.disabledMinutes?.(date.hour()) ?? [];
+			isDisabled = (value) => disabledMinutes.includes(value);
+			break;
+		}
+		case "second": {
+			values = range(same(min, "minute") ? min.second() : 0, same(max, "minute") ? max.second() : 59, ctx.secondStep);
+			const disabledSeconds = disabledTimes?.disabledSeconds?.(date.hour(), date.minute()) ?? [];
+			isDisabled = (value) => disabledSeconds.includes(value);
+			break;
+		}
+		case "meridiem": values = [0, 1].filter((value) => !(value === 0 && same(min, "day") && min.hour() >= 12) && !(value === 1 && same(max, "day") && max.hour() < 12));
+	}
+	const options = values.map((value) => ({
+		label: ctx.renderLabel ? ctx.renderLabel(type, value) : defaultLabel(ctx, type, value),
+		value,
+		disabled: isDisabled?.(value) || void 0
+	}));
+	return ctx.filter ? ctx.filter(type, options) : options;
+}
+function generateColumns(ctx, date) {
+	return ctx.types.map((type) => getColumn(ctx, type, date));
+}
+function getValue(ctx, type, date) {
+	switch (type) {
+		case "year": return yearOf(ctx, date);
+		case "quarter": return date.quarter();
+		case "month": return date.month() + 1;
+		case "week": return date.isoWeek();
+		case "day": return date.date();
+		case "hour": return ctx.use12Hours ? toHour12(date.hour()) : date.hour();
+		case "minute": return date.minute();
+		case "second": return date.second();
+		default: return date.hour() >= 12 ? 1 : 0;
+	}
+}
+function dateToValues(ctx, date) {
+	return ctx.types.map((type) => getValue(ctx, type, date));
+}
+/** Applies wheel values on top of `base`, keeping the result a real date (e.g. Jan 31 -> Feb 29). */
+function valuesToDate(ctx, values, base) {
+	const get = (type) => {
+		const index = ctx.types.indexOf(type);
+		const value = index < 0 ? void 0 : values[index];
+		return value === void 0 ? void 0 : Number(value);
+	};
+	let date = base;
+	const year = get("year") ?? yearOf(ctx, date);
+	if (ctx.picker === "week") return isoWeekStart(year, Math.min(get("week") ?? date.isoWeek(), isoWeeksInYear(year)));
+	if (ctx.picker !== "time") {
+		const quarter = get("quarter");
+		const month = quarter !== void 0 ? (quarter - 1) * 3 : (get("month") ?? date.month() + 1) - 1;
+		const first = date.date(1).year(year).month(month);
+		date = first.date(Math.min(get("day") ?? date.date(), first.daysInMonth()));
+		if (ctx.picker === "year") date = date.startOf("year");
+		else if (ctx.picker === "month" || ctx.picker === "quarter") date = date.startOf("month");
+	}
+	const hour = get("hour");
+	if (hour !== void 0) {
+		if (ctx.use12Hours) {
+			const meridiem = get("meridiem") ?? (date.hour() >= 12 ? 1 : 0);
+			date = date.hour(hour % 12 + meridiem * 12);
+		} else date = date.hour(hour);
+		const minute = get("minute");
+		const second = get("second");
+		date = date.minute(minute ?? (ctx.types.includes("minute") ? date.minute() : 0)).second(second ?? (ctx.types.includes("second") ? date.second() : 0)).millisecond(0);
+	}
+	return date;
+}
+/**
+* Makes `date` selectable: clamps it into `[min, max]`, then walks the columns from coarse to fine and
+* snaps every value that is missing (steps, filters, bounds) or disabled to the nearest enabled option.
+*/
+function settleDate(ctx, input) {
+	let date = clampDate(input, ctx.min, ctx.max);
+	for (let index = 0; index < ctx.types.length; index++) {
+		const column = getColumn(ctx, ctx.types[index], date);
+		const values = dateToValues(ctx, date);
+		const current = values[index];
+		const hit = column.find((option) => option.value === current);
+		if (hit && !hit.disabled) continue;
+		const enabled = column.filter((option) => !option.disabled);
+		if (!enabled.length) continue;
+		const nearest = enabled.reduce((best, option) => Math.abs(Number(option.value) - current) < Math.abs(Number(best.value) - current) ? option : best);
+		values[index] = Number(nearest.value);
+		date = clampDate(valuesToDate(ctx, values, date), ctx.min, ctx.max);
+	}
+	return date;
+}
+export { clampDate, createDateContext, dateToValues, formatDate, generateColumns, settleDate, toDayjs, toValue, valuesToDate };

package/dist/descriptions/Descriptions.js

@@ -0,0 +1,4 @@
+import Descriptions_vue_vue_type_script_setup_true_lang_default from "./Descriptions.vue_vue_type_script_setup_true_lang.js";
+// src/descriptions/Descriptions.vue
+var Descriptions_default = Descriptions_vue_vue_type_script_setup_true_lang_default;
+export { Descriptions_default as default };

package/dist/descriptions/Descriptions.vue.d.ts

@@ -0,0 +1,18 @@
+import type { DescriptionsProps, DescriptionsSlots } from './interface';
+import '../style';
+import './style/index.css';
+type __VLS_Slots = DescriptionsSlots;
+declare const __VLS_base: import("vue").DefineComponent<DescriptionsProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<DescriptionsProps> & Readonly<{}>, {
+    column: number;
+    layout: "horizontal" | "vertical";
+    colon: boolean;
+    contentAlign: "start" | "end";
+}, {}, {}, {}, 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/descriptions/Descriptions.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,168 @@
+import { clamp, isRenderable } from "../_util/index.js";
+import RenderNode_default from "../_util/RenderNode.js";
+import { useSize } from "../config-provider/context.js";
+import "../style/index2.js";
+import './style/index.css';/* empty css            */
+import { Fragment, computed, createBlock, createCommentVNode, createElementBlock, createElementVNode, createVNode, defineComponent, mergeProps, normalizeClass, normalizeStyle, openBlock, renderList, renderSlot, unref, useSlots } from "vue";
+// src/descriptions/Descriptions.vue?vue&type=script&setup=true&lang.ts
+var Descriptions_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComponent({
+	name: "AmDescriptions",
+	inheritAttrs: false,
+	__name: "Descriptions",
+	props: {
+		title: { type: [
+			Object,
+			String,
+			Number,
+			Boolean,
+			null,
+			Array,
+			Function
+		] },
+		extra: { type: [
+			Object,
+			String,
+			Number,
+			Boolean,
+			null,
+			Array,
+			Function
+		] },
+		items: {},
+		column: { default: 1 },
+		layout: { default: "horizontal" },
+		bordered: { type: Boolean },
+		size: {},
+		colon: {
+			type: Boolean,
+			default: true
+		},
+		contentAlign: { default: "start" },
+		labelRender: {},
+		contentRender: {},
+		rootClass: {},
+		classes: {},
+		styles: {}
+	},
+	setup(__props) {
+		const props = __props;
+		const slots = useSlots();
+		const size = useSize(() => props.size);
+		const hasTitle = computed(() => !!slots.title || isRenderable(props.title));
+		const hasExtra = computed(() => !!slots.extra || isRenderable(props.extra));
+		const mergedColumn = computed(() => {
+			const column = Math.floor(Number(props.column));
+			return column >= 1 ? column : 1;
+		});
+		/** Resolves every item's span so that each row is completely filled (needed by the bordered grid). */
+		const mergedItems = computed(() => {
+			const column = mergedColumn.value;
+			const list = [];
+			let rest = column;
+			const fillPrevious = () => {
+				const last = list[list.length - 1];
+				if (last && rest > 0 && rest < column) last.span += rest;
+				rest = column;
+			};
+			(props.items ?? []).forEach((item, index) => {
+				let span;
+				if (item.span === "filled") span = rest;
+				else {
+					span = clamp(Math.floor(Number(item.span)) || 1, 1, column);
+					if (span > rest) fillPrevious();
+				}
+				list.push({
+					key: item.key ?? index,
+					item,
+					index,
+					content: isRenderable(item.content) ? item.content : item.children,
+					span
+				});
+				rest -= span;
+				if (rest <= 0) rest = column;
+			});
+			fillPrevious();
+			return list;
+		});
+		const classNames = computed(() => [
+			"am-descriptions",
+			`am-descriptions-${props.layout}`,
+			{
+				"am-descriptions-bordered": props.bordered,
+				"am-descriptions-sm": size.value === "small",
+				"am-descriptions-lg": size.value === "large",
+				"am-descriptions-content-end": props.contentAlign === "end" && props.layout === "horizontal"
+			},
+			props.rootClass,
+			props.classes?.root
+		]);
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock("div", mergeProps(_ctx.$attrs, {
+				class: classNames.value,
+				style: __props.styles?.root
+			}), [hasTitle.value || hasExtra.value ? (openBlock(), createElementBlock("div", {
+				key: 0,
+				class: normalizeClass(["am-descriptions-header", __props.classes?.header]),
+				style: normalizeStyle(__props.styles?.header)
+			}, [hasTitle.value ? (openBlock(), createElementBlock("div", {
+				key: 0,
+				class: normalizeClass(["am-descriptions-title", __props.classes?.title]),
+				style: normalizeStyle(__props.styles?.title)
+			}, [renderSlot(_ctx.$slots, "title", {}, () => [createVNode(unref(RenderNode_default), { node: __props.title }, null, 8, ["node"])])], 6)) : createCommentVNode("", true), hasExtra.value ? (openBlock(), createElementBlock("div", {
+				key: 1,
+				class: normalizeClass(["am-descriptions-extra", __props.classes?.extra]),
+				style: normalizeStyle(__props.styles?.extra)
+			}, [renderSlot(_ctx.$slots, "extra", {}, () => [createVNode(unref(RenderNode_default), { node: __props.extra }, null, 8, ["node"])])], 6)) : createCommentVNode("", true)], 6)) : createCommentVNode("", true), createElementVNode("div", {
+				class: "am-descriptions-view",
+				style: normalizeStyle({ gridTemplateColumns: `repeat(${mergedColumn.value}, minmax(0, 1fr))` })
+			}, [(openBlock(true), createElementBlock(Fragment, null, renderList(mergedItems.value, (node) => {
+				return openBlock(), createElementBlock("div", {
+					key: node.key,
+					class: normalizeClass(["am-descriptions-item", node.item.class]),
+					style: normalizeStyle([{ gridColumn: `span ${node.span}` }, node.item.style])
+				}, [createElementVNode("span", {
+					class: normalizeClass(["am-descriptions-item-label", [
+						{ "am-descriptions-item-no-colon": !__props.colon },
+						__props.classes?.label,
+						node.item.classes?.label
+					]]),
+					style: normalizeStyle([__props.styles?.label, node.item.styles?.label])
+				}, [renderSlot(_ctx.$slots, "labelRender", {
+					item: node.item,
+					index: node.index,
+					value: node.item.label
+				}, () => [__props.labelRender ? (openBlock(), createBlock(unref(RenderNode_default), {
+					key: 0,
+					node: __props.labelRender,
+					params: {
+						item: node.item,
+						index: node.index,
+						value: node.item.label
+					}
+				}, null, 8, ["node", "params"])) : (openBlock(), createBlock(unref(RenderNode_default), {
+					key: 1,
+					node: node.item.label
+				}, null, 8, ["node"]))])], 6), createElementVNode("span", {
+					class: normalizeClass(["am-descriptions-item-content", [__props.classes?.content, node.item.classes?.content]]),
+					style: normalizeStyle([__props.styles?.content, node.item.styles?.content])
+				}, [renderSlot(_ctx.$slots, "contentRender", {
+					item: node.item,
+					index: node.index,
+					value: node.content
+				}, () => [__props.contentRender ? (openBlock(), createBlock(unref(RenderNode_default), {
+					key: 0,
+					node: __props.contentRender,
+					params: {
+						item: node.item,
+						index: node.index,
+						value: node.content
+					}
+				}, null, 8, ["node", "params"])) : (openBlock(), createBlock(unref(RenderNode_default), {
+					key: 1,
+					node: node.content
+				}, null, 8, ["node"]))])], 6)], 6);
+			}), 128))], 4)], 16);
+		};
+	}
+});
+export { Descriptions_vue_vue_type_script_setup_true_lang_default as default };

package/dist/descriptions/index.d.ts

@@ -0,0 +1,32 @@
+export type * from './interface';
+declare const Descriptions: import("../_util/withInstall").WithInstall<{
+    new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("./interface").DescriptionsProps> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {
+        column: number;
+        layout: "horizontal" | "vertical";
+        colon: boolean;
+        contentAlign: "start" | "end";
+    }, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import("./interface").DescriptionsProps> & Readonly<{}>, {}, {}, {}, {}, {
+        column: number;
+        layout: "horizontal" | "vertical";
+        colon: boolean;
+        contentAlign: "start" | "end";
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import("vue").ComponentOptionsBase<Readonly<import("./interface").DescriptionsProps> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
+    column: number;
+    layout: "horizontal" | "vertical";
+    colon: boolean;
+    contentAlign: "start" | "end";
+}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+    $slots: import("./interface").DescriptionsSlots;
+}), object>;
+export default Descriptions;

package/dist/descriptions/index.js

@@ -0,0 +1,5 @@
+import { withInstall } from "../_util/withInstall.js";
+import Descriptions_default from "./Descriptions.js";
+// src/descriptions/index.ts
+var Descriptions = withInstall(Descriptions_default, "AmDescriptions");
+export { Descriptions as default };