@antdv-next/mobile 0.0.0-stage → 0.1.0

package/dist/mask/Mask.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,97 @@
+import Portal_default from "../_base/Portal.js";
+import { useLockScroll } from "../_util/hooks/useLockScroll.js";
+import "../style/index2.js";
+import './style/index.css';/* empty css            */
+import { Transition, computed, createBlock, createCommentVNode, createElementBlock, createVNode, defineComponent, mergeProps, openBlock, ref, renderSlot, unref, vShow, watch, withCtx, withDirectives } from "vue";
+// src/mask/Mask.vue?vue&type=script&setup=true&lang.ts
+var _hoisted_1 = ["dir"];
+var Mask_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComponent({
+	name: "AmMask",
+	inheritAttrs: false,
+	__name: "Mask",
+	props: {
+		open: {
+			type: Boolean,
+			default: false
+		},
+		zIndex: {},
+		lockScroll: {
+			type: Boolean,
+			default: true
+		},
+		color: { default: "default" },
+		closable: {
+			type: Boolean,
+			default: false
+		},
+		getContainer: {
+			type: [
+				String,
+				Function,
+				Boolean
+			],
+			default: false
+		},
+		destroyOnHidden: {
+			type: Boolean,
+			default: false
+		},
+		rootClass: {}
+	},
+	emits: [
+		"update:open",
+		"click",
+		"afterOpenChange"
+	],
+	setup(__props, { emit: __emit }) {
+		const props = __props;
+		const emit = __emit;
+		const rootRef = ref();
+		const rendered = ref(props.open);
+		watch(() => props.open, (open) => {
+			if (open) rendered.value = true;
+		});
+		useLockScroll(rootRef, () => props.open && props.lockScroll);
+		const background = computed(() => {
+			if (props.color === "default") return void 0;
+			if (props.color === "white") return "rgb(255 255 255 / 60%)";
+			return props.color;
+		});
+		function onClick(event) {
+			if (event.target !== event.currentTarget) return;
+			emit("click", event);
+			if (props.closable) emit("update:open", false);
+		}
+		function onAfterLeave() {
+			if (props.destroyOnHidden) rendered.value = false;
+			emit("afterOpenChange", false);
+		}
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(unref(Portal_default), { "get-container": __props.getContainer }, {
+				default: withCtx(({ theme }) => [createVNode(Transition, {
+					name: "am-fade",
+					appear: "",
+					onAfterEnter: _cache[0] || (_cache[0] = ($event) => emit("afterOpenChange", true)),
+					onAfterLeave
+				}, {
+					default: withCtx(() => [rendered.value ? withDirectives((openBlock(), createElementBlock("div", mergeProps({
+						key: 0,
+						ref_key: "rootRef",
+						ref: rootRef
+					}, _ctx.$attrs, {
+						class: ["am-mask", [theme.class, __props.rootClass]],
+						style: [theme.style, {
+							zIndex: __props.zIndex,
+							background: background.value
+						}],
+						dir: theme.dir,
+						onClick
+					}), [renderSlot(_ctx.$slots, "default")], 16, _hoisted_1)), [[vShow, __props.open]]) : createCommentVNode("", true)]),
+					_: 2
+				}, 1024)]),
+				_: 3
+			}, 8, ["get-container"]);
+		};
+	}
+});
+export { Mask_vue_vue_type_script_setup_true_lang_default as default };

package/dist/mask/index.d.ts

@@ -0,0 +1,58 @@
+export type * from './interface';
+declare const Mask: import("../_util/withInstall").WithInstall<{
+    new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("./interface").MaskProps> & Readonly<{
+        onClick?: ((event: MouseEvent) => any) | undefined;
+        "onUpdate:open"?: ((open: boolean) => any) | undefined;
+        onAfterOpenChange?: ((open: boolean) => any) | undefined;
+    }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+        click: (event: MouseEvent) => any;
+        "update:open": (open: boolean) => any;
+        afterOpenChange: (open: boolean) => any;
+    }, import("vue").PublicProps, {
+        color: string;
+        open: boolean;
+        getContainer: import("../index.ts").GetContainer;
+        lockScroll: boolean;
+        closable: boolean;
+        destroyOnHidden: boolean;
+    }, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import("./interface").MaskProps> & Readonly<{
+        onClick?: ((event: MouseEvent) => any) | undefined;
+        "onUpdate:open"?: ((open: boolean) => any) | undefined;
+        onAfterOpenChange?: ((open: boolean) => any) | undefined;
+    }>, {}, {}, {}, {}, {
+        color: string;
+        open: boolean;
+        getContainer: import("../index.ts").GetContainer;
+        lockScroll: boolean;
+        closable: boolean;
+        destroyOnHidden: boolean;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import("vue").ComponentOptionsBase<Readonly<import("./interface").MaskProps> & Readonly<{
+    onClick?: ((event: MouseEvent) => any) | undefined;
+    "onUpdate:open"?: ((open: boolean) => any) | undefined;
+    onAfterOpenChange?: ((open: boolean) => any) | undefined;
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    click: (event: MouseEvent) => any;
+    "update:open": (open: boolean) => any;
+    afterOpenChange: (open: boolean) => any;
+}, string, {
+    color: string;
+    open: boolean;
+    getContainer: import("../index.ts").GetContainer;
+    lockScroll: boolean;
+    closable: boolean;
+    destroyOnHidden: 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").MaskSlots;
+}), object>;
+export default Mask;

package/dist/mask/index.js

@@ -0,0 +1,5 @@
+import { withInstall } from "../_util/withInstall.js";
+import Mask_default from "./Mask.js";
+// src/mask/index.ts
+var Mask = withInstall(Mask_default, "AmMask");
+export { Mask as default };

package/dist/mask/interface.d.ts

@@ -0,0 +1,24 @@
+import type { GetContainer } from '../_util/type';
+export interface MaskProps {
+    /** Whether the mask is visible. Supports `v-model:open`. */
+    open?: boolean;
+    zIndex?: number;
+    /** Lock page scroll while visible */
+    lockScroll?: boolean;
+    /** `'default'` uses the mask token, `'white'` a light translucent layer, or any css color */
+    color?: 'default' | 'white' | string;
+    /** Close (emit `update:open` false) when clicked */
+    closable?: boolean;
+    /** Teleport target. `false` (default) renders in place. */
+    getContainer?: GetContainer;
+    destroyOnHidden?: boolean;
+    rootClass?: string;
+}
+export interface MaskEmits {
+    'update:open': [open: boolean];
+    'click': [event: MouseEvent];
+    'afterOpenChange': [open: boolean];
+}
+export interface MaskSlots {
+    default?: () => any;
+}

package/dist/mask/style/index.css

@@ -0,0 +1,10 @@
+.am-mask {
+  --am-mask-z-index: var(--am-z-index-popup-base);
+
+  position: fixed;
+  inset: 0;
+  z-index: var(--am-mask-z-index);
+  box-sizing: border-box;
+  background: var(--am-color-bg-mask);
+  touch-action: none;
+}

package/dist/masonry/Masonry.js

@@ -0,0 +1,4 @@
+import Masonry_vue_vue_type_script_setup_true_lang_default from "./Masonry.vue_vue_type_script_setup_true_lang.js";
+// src/masonry/Masonry.vue
+var Masonry_default = Masonry_vue_vue_type_script_setup_true_lang_default;
+export { Masonry_default as default };

package/dist/masonry/Masonry.vue.d.ts

@@ -0,0 +1,25 @@
+import type { MasonryLayoutInfo, MasonryProps, MasonrySlots } from './interface';
+import '../style';
+import './style/index.css';
+type __VLS_Slots = MasonrySlots;
+/** Batches every re-layout request of a frame into one measuring pass. */
+declare function scheduleMeasure(): void;
+declare const __VLS_base: import("vue").DefineComponent<MasonryProps, {
+    readonly nativeElement: HTMLDivElement | undefined;
+    layout: typeof scheduleMeasure;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    layoutChange: (sortInfo: MasonryLayoutInfo<any>[]) => any;
+}, string, import("vue").PublicProps, Readonly<MasonryProps> & Readonly<{
+    onLayoutChange?: ((sortInfo: MasonryLayoutInfo<any>[]) => any) | undefined;
+}>, {
+    columns: number;
+    fresh: 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/masonry/Masonry.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,245 @@
+import { addUnit, cancelRaf, isDef, isNumeric, isRenderable, raf } from "../_util/index.js";
+import { useEventListener } from "../_util/hooks/useEventListener.js";
+import RenderNode_default from "../_util/RenderNode.js";
+import { mergeAttrsStyle } from "../_util/vnode.js";
+import { computeMasonryLayout, normalizeColumns } from "./layout.js";
+import "../style/index2.js";
+import './style/index.css';/* empty css            */
+import { Fragment, computed, createBlock, createElementBlock, createVNode, defineComponent, mergeProps, normalizeClass, normalizeStyle, onBeforeUnmount, onMounted, openBlock, ref, renderList, renderSlot, shallowRef, unref, watch } from "vue";
+// src/masonry/Masonry.vue?vue&type=script&setup=true&lang.ts
+var Masonry_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComponent({
+	name: "AmMasonry",
+	inheritAttrs: false,
+	__name: "Masonry",
+	props: {
+		items: {},
+		columns: { default: 2 },
+		gutter: {},
+		itemRender: {},
+		fresh: {
+			type: Boolean,
+			default: false
+		},
+		rootClass: {},
+		classes: {},
+		styles: {}
+	},
+	emits: ["layoutChange"],
+	setup(__props, { expose: __expose, emit: __emit }) {
+		const props = __props;
+		const emit = __emit;
+		const rootRef = ref();
+		const entries = computed(() => (props.items ?? []).map((item, index) => ({
+			item,
+			index,
+			key: item.key ?? index
+		})));
+		const columnCount = computed(() => normalizeColumns(props.columns));
+		const gutters = computed(() => {
+			const [x, y] = Array.isArray(props.gutter) ? props.gutter : [props.gutter, void 0];
+			const hasValue = (value) => isDef(value) && value !== "";
+			return [hasValue(x) ? x : void 0, hasValue(y) && Number(y) !== 0 ? y : void 0];
+		});
+		/** Vertical gutter in px when it can be told without the DOM (numbers), `undefined` for CSS lengths / the token. */
+		const staticGutterY = computed(() => {
+			const value = gutters.value[1] ?? gutters.value[0];
+			return isNumeric(value) ? Number(value) : void 0;
+		});
+		/** Vertical gutter in px read back from the DOM (CSS lengths, the default token). */
+		const computedGutterY = ref(0);
+		const gutterY = computed(() => staticGutterY.value ?? computedGutterY.value);
+		const measuredHeights = shallowRef(/* @__PURE__ */ new Map());
+		/** Items that kept a position for at least one frame: only those animate when they move. */
+		const settledKeys = shallowRef(/* @__PURE__ */ new Set());
+		const layout = computed(() => computeMasonryLayout(entries.value.map(({ item, key }) => ({
+			key,
+			height: measuredHeights.value.get(key) ?? item.height,
+			column: item.column
+		})), columnCount.value, gutterY.value));
+		const classNames = computed(() => [
+			"am-masonry",
+			props.rootClass,
+			props.classes?.root
+		]);
+		const mergedStyle = computed(() => {
+			const [x, y] = gutters.value;
+			const style = {
+				"--am-masonry-columns": columnCount.value,
+				"height": `${layout.value.height}px`
+			};
+			if (x !== void 0) style["--am-masonry-gutter-x"] = addUnit(x);
+			if (y !== void 0) style["--am-masonry-gutter-y"] = addUnit(y);
+			return {
+				...style,
+				...props.styles?.root
+			};
+		});
+		const renderEntries = computed(() => entries.value.map((entry) => {
+			const { item, index, key } = entry;
+			const position = layout.value.positions.get(key);
+			const column = position?.column ?? 0;
+			const style = {
+				...props.styles?.item,
+				...item.style
+			};
+			if (position) {
+				style["--am-masonry-item-column"] = column;
+				style["--am-masonry-item-top"] = `${position.top}px`;
+			}
+			return {
+				...entry,
+				position,
+				info: {
+					...item,
+					key,
+					index,
+					column
+				},
+				class: [
+					"am-masonry-item",
+					{
+						"am-masonry-item-pending": !position,
+						"am-masonry-item-motion": !!position && settledKeys.value.has(key)
+					},
+					props.classes?.item,
+					item.class
+				],
+				style
+			};
+		}));
+		let measureId = 0;
+		let settleId = 0;
+		let observer;
+		const observedItems = /* @__PURE__ */ new Set();
+		function getItemElements() {
+			const root = rootRef.value;
+			return root ? Array.from(root.children).filter((el) => el.classList.contains("am-masonry-item")) : [];
+		}
+		function getHeight(el) {
+			const { height } = el.getBoundingClientRect();
+			const { offsetHeight } = el;
+			return Math.abs(height - offsetHeight) > 1 ? offsetHeight : height;
+		}
+		function sameHeights(a, b) {
+			if (a.size !== b.size) return false;
+			for (const [key, value] of b) if (a.get(key) !== value) return false;
+			return true;
+		}
+		function settle() {
+			settleId = 0;
+			const next = new Set(layout.value.positions.keys());
+			const prev = settledKeys.value;
+			if (next.size !== prev.size || [...next].some((key) => !prev.has(key))) settledKeys.value = next;
+		}
+		function measure() {
+			measureId = 0;
+			const root = rootRef.value;
+			if (!root) return;
+			const elements = getItemElements();
+			const next = /* @__PURE__ */ new Map();
+			entries.value.forEach(({ key }, index) => {
+				const el = elements[index];
+				if (el) next.set(key, getHeight(el));
+			});
+			if (!sameHeights(measuredHeights.value, next)) measuredHeights.value = next;
+			if (staticGutterY.value === void 0) computedGutterY.value = Number.parseFloat(window.getComputedStyle(root).rowGap) || 0;
+			cancelRaf(settleId);
+			settleId = raf(settle);
+		}
+		/** Batches every re-layout request of a frame into one measuring pass. */
+		function scheduleMeasure() {
+			if (measureId || !rootRef.value) return;
+			measureId = raf(measure);
+		}
+		function syncObserver() {
+			if (!observer || !rootRef.value) return;
+			const targets = /* @__PURE__ */ new Set([rootRef.value, ...props.fresh ? getItemElements() : []]);
+			observedItems.forEach((el) => {
+				if (!targets.has(el)) {
+					observer.unobserve(el);
+					observedItems.delete(el);
+				}
+			});
+			targets.forEach((el) => {
+				if (!observedItems.has(el)) {
+					observer.observe(el);
+					observedItems.add(el);
+				}
+			});
+		}
+		onMounted(() => {
+			if (typeof ResizeObserver !== "undefined") observer = new ResizeObserver(scheduleMeasure);
+			syncObserver();
+			scheduleMeasure();
+		});
+		onBeforeUnmount(() => {
+			cancelRaf(measureId);
+			cancelRaf(settleId);
+			observer?.disconnect();
+			observer = void 0;
+			observedItems.clear();
+		});
+		watch([
+			entries,
+			columnCount,
+			gutters,
+			() => props.fresh
+		], () => {
+			syncObserver();
+			scheduleMeasure();
+		}, { flush: "post" });
+		useEventListener("load", scheduleMeasure, {
+			target: rootRef,
+			capture: true
+		});
+		useEventListener("error", scheduleMeasure, {
+			target: rootRef,
+			capture: true
+		});
+		let lastColumns = "";
+		watch(layout, ({ positions, complete }) => {
+			if (!entries.value.length || !complete) return;
+			const sortInfo = entries.value.map(({ item, key }) => ({
+				...item,
+				key,
+				column: positions.get(key).column
+			}));
+			const signature = sortInfo.map(({ key, column }) => `${typeof key}:${key}:${column}`).join("|");
+			if (signature !== lastColumns) {
+				lastColumns = signature;
+				emit("layoutChange", sortInfo);
+			}
+		}, {
+			immediate: true,
+			flush: "post"
+		});
+		__expose({
+			get nativeElement() {
+				return rootRef.value;
+			},
+			layout: scheduleMeasure
+		});
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock("div", mergeProps({
+				ref_key: "rootRef",
+				ref: rootRef
+			}, _ctx.$attrs, {
+				class: classNames.value,
+				style: unref(mergeAttrsStyle)(mergedStyle.value, _ctx.$attrs.style)
+			}), [(openBlock(true), createElementBlock(Fragment, null, renderList(renderEntries.value, (entry) => {
+				return openBlock(), createElementBlock("div", {
+					key: entry.key,
+					class: normalizeClass(entry.class),
+					style: normalizeStyle(entry.style)
+				}, [unref(isRenderable)(entry.item.children) ? (openBlock(), createBlock(unref(RenderNode_default), {
+					key: 0,
+					node: entry.item.children
+				}, null, 8, ["node"])) : renderSlot(_ctx.$slots, "itemRender", mergeProps({ ref_for: true }, entry.info), () => [createVNode(unref(RenderNode_default), {
+					node: __props.itemRender,
+					params: entry.info
+				}, null, 8, ["node", "params"])], void 0, 1)], 6);
+			}), 128))], 16);
+		};
+	}
+});
+export { Masonry_vue_vue_type_script_setup_true_lang_default as default };

package/dist/masonry/index.d.ts

@@ -0,0 +1,45 @@
+export type * from './interface';
+declare const Masonry: import("../_util/withInstall").WithInstall<{
+    new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("./interface").MasonryProps> & Readonly<{
+        onLayoutChange?: ((sortInfo: import("./interface").MasonryLayoutInfo<any>[]) => any) | undefined;
+    }>, {
+        readonly nativeElement: HTMLDivElement | undefined;
+        layout: () => void;
+    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+        layoutChange: (sortInfo: import("./interface").MasonryLayoutInfo<any>[]) => any;
+    }, import("vue").PublicProps, {
+        columns: number;
+        fresh: boolean;
+    }, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import("./interface").MasonryProps> & Readonly<{
+        onLayoutChange?: ((sortInfo: import("./interface").MasonryLayoutInfo<any>[]) => any) | undefined;
+    }>, {
+        readonly nativeElement: HTMLDivElement | undefined;
+        layout: () => void;
+    }, {}, {}, {}, {
+        columns: number;
+        fresh: boolean;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import("vue").ComponentOptionsBase<Readonly<import("./interface").MasonryProps> & Readonly<{
+    onLayoutChange?: ((sortInfo: import("./interface").MasonryLayoutInfo<any>[]) => any) | undefined;
+}>, {
+    readonly nativeElement: HTMLDivElement | undefined;
+    layout: () => void;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    layoutChange: (sortInfo: import("./interface").MasonryLayoutInfo<any>[]) => any;
+}, string, {
+    columns: number;
+    fresh: 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").MasonrySlots;
+}), object>;
+export default Masonry;

package/dist/masonry/index.js

@@ -0,0 +1,5 @@
+import { withInstall } from "../_util/withInstall.js";
+import Masonry_default from "./Masonry.js";
+// src/masonry/index.ts
+var Masonry = withInstall(Masonry_default, "AmMasonry");
+export { Masonry as default };

package/dist/masonry/interface.d.ts

@@ -0,0 +1,61 @@
+import type { CSSProperties, VNodeChild } from 'vue';
+import type { Key, VueNode } from '../_util/type';
+export type MasonryGutter = number | string;
+export interface MasonryItemType<T = any> {
+    key: Key;
+    /** Pin the item to a column (0-based); out-of-range values are clamped */
+    column?: number;
+    /** Known height in px: the item is placed before it is measured; the measured height wins afterwards */
+    height?: number;
+    /** Content of the item, wins over `itemRender` */
+    children?: VueNode;
+    /** Custom data, handed to `itemRender` */
+    data: T;
+    class?: string;
+    style?: CSSProperties;
+}
+export interface MasonryItemRenderInfo<T = any> extends MasonryItemType<T> {
+    index: number;
+    /** Column the item currently sits in (`0` until it is placed) */
+    column: number;
+}
+export interface MasonryLayoutInfo<T = any> extends MasonryItemType<T> {
+    column: number;
+}
+export interface MasonrySemanticClassNames {
+    root?: string;
+    item?: string;
+}
+export interface MasonrySemanticStyles {
+    root?: CSSProperties;
+    item?: CSSProperties;
+}
+export interface MasonryProps {
+    items?: MasonryItemType[];
+    /** Number of columns */
+    columns?: number;
+    /**
+     * Spacing between items, `[horizontal, vertical]` for both directions (vertical falls back to horizontal).
+     * Numbers are px, strings are CSS lengths. Defaults to the `--am-masonry-gutter` token.
+     */
+    gutter?: MasonryGutter | [MasonryGutter, MasonryGutter];
+    /** Custom item render; the same-named slot wins */
+    itemRender?: (itemInfo: MasonryItemRenderInfo) => VNodeChild;
+    /** Keep observing the size of every item and re-layout when one changes */
+    fresh?: boolean;
+    rootClass?: string;
+    classes?: MasonrySemanticClassNames;
+    styles?: MasonrySemanticStyles;
+}
+export interface MasonryEmits {
+    /** The column of an item changed (fired once every item is placed) */
+    layoutChange: [sortInfo: MasonryLayoutInfo[]];
+}
+export interface MasonrySlots {
+    itemRender?: (itemInfo: MasonryItemRenderInfo) => any;
+}
+export interface MasonryRef {
+    nativeElement: HTMLDivElement | undefined;
+    /** Measure the items again and re-layout (e.g. after a font or theme change) */
+    layout: () => void;
+}

package/dist/masonry/layout.d.ts

@@ -0,0 +1,27 @@
+import type { Key } from '../_util/type';
+export interface MasonryLayoutInput {
+    key: Key;
+    /** Rendered (or estimated) height in px; `undefined` while it is unknown */
+    height?: number;
+    /** Fixed column index */
+    column?: number;
+}
+export interface MasonryPosition {
+    column: number;
+    top: number;
+}
+export interface MasonryLayoutResult {
+    positions: Map<Key, MasonryPosition>;
+    /** Height of the tallest column (without a trailing gutter) */
+    height: number;
+    /** Whether every item got a position */
+    complete: boolean;
+}
+export declare function normalizeColumns(columns: unknown, fallback?: number): number;
+/**
+ * Masonry placement (same rule as antdv-next `usePositions`): items are visited in data order and each one
+ * goes to its fixed `column` or to the currently shortest column (the first one on a tie), so positions
+ * are stable for a given order. Placement stops at the first item whose height is still unknown:
+ * everything after it would have to move once that height is measured.
+ */
+export declare function computeMasonryLayout(items: MasonryLayoutInput[], columns: number, gutter?: number): MasonryLayoutResult;

package/dist/masonry/layout.js

@@ -0,0 +1,39 @@
+// src/masonry/layout.ts
+function normalizeColumns(columns, fallback = 2) {
+	const count = Math.floor(Number(columns));
+	return Number.isFinite(count) && count > 0 ? count : fallback;
+}
+/**
+* Masonry placement (same rule as antdv-next `usePositions`): items are visited in data order and each one
+* goes to its fixed `column` or to the currently shortest column (the first one on a tie), so positions
+* are stable for a given order. Placement stops at the first item whose height is still unknown:
+* everything after it would have to move once that height is measured.
+*/
+function computeMasonryLayout(items, columns, gutter = 0) {
+	const count = normalizeColumns(columns, 1);
+	const gap = Number.isFinite(gutter) && gutter > 0 ? gutter : 0;
+	const columnHeights = Array.from({ length: count }).fill(0);
+	const positions = /* @__PURE__ */ new Map();
+	let complete = true;
+	for (let i = 0; i < items.length; i += 1) {
+		const { key, height, column } = items[i];
+		if (typeof height !== "number" || !Number.isFinite(height)) {
+			complete = false;
+			break;
+		}
+		let target = 0;
+		if (typeof column === "number" && Number.isFinite(column)) target = Math.min(Math.max(Math.floor(column), 0), count - 1);
+		else for (let c = 1; c < count; c += 1) if (columnHeights[c] < columnHeights[target]) target = c;
+		positions.set(key, {
+			column: target,
+			top: columnHeights[target]
+		});
+		columnHeights[target] += Math.max(height, 0) + gap;
+	}
+	return {
+		positions,
+		height: Math.max(0, Math.max(...columnHeights) - gap),
+		complete
+	};
+}
+export { computeMasonryLayout, normalizeColumns };