@qw-ui/core 0.3.0-next.40 → 0.3.0-next.43

package/dist/upload/upload.d.ts

@@ -0,0 +1,172 @@
+import { type Machine, type Service } from "@zag-js/core";
+import type { NormalizeProps, PropTypes } from "@zag-js/types";
+/** Stable DOM parts shared by every adapter. */
+export declare const UPLOAD_PARTS: readonly ["root", "input", "trigger", "list", "item", "preview", "name", "status", "retry", "cancel", "remove", "live"];
+export declare const UPLOAD_STATUSES: readonly ["pending", "uploading", "done", "error"];
+export type UploadStatus = (typeof UPLOAD_STATUSES)[number];
+/** Serializable list entry. The File itself stays private to Core (used for retry and form sync). */
+export interface UploadItem {
+    id: string;
+    name: string;
+    size: number;
+    type: string;
+    status: UploadStatus;
+    /** Remote or caller-provided URL; preferred over the Core-owned preview and never revoked by Core. */
+    url?: string;
+    error?: string;
+    /** 0–100, only when the caller reports progress through onProgress. */
+    progress?: number;
+}
+export type UploadRejectReason = "accept" | "max-size" | "max-count";
+export interface UploadRejection {
+    file: File;
+    reason: UploadRejectReason;
+}
+export interface UploadRejectDetails {
+    rejections: UploadRejection[];
+}
+export interface UploadChangeDetails {
+    value: UploadItem[];
+}
+export interface UploadResult {
+    url?: string;
+}
+export interface UploadRequestContext {
+    /** Aborted when the item is cancelled, removed, replaced out of the list or the component unmounts. */
+    signal: AbortSignal;
+    /** Optional real progress (0–100). Core never fabricates progress. */
+    onProgress(percent: number): void;
+}
+/** Caller-injected transport: resolve (optionally with { url }) on success, reject or throw on failure. */
+export type UploadRequest = (file: File, context: UploadRequestContext) => Promise<UploadResult | void> | UploadResult | void;
+export interface QwUploadProps {
+    id?: string;
+    /** Native form field name on the file input. */
+    name?: string;
+    /** Native accept list: extensions (.png), wildcards (image/*) or exact MIME types. */
+    accept?: string;
+    multiple?: boolean;
+    /** Maximum list length; invalid or ≤0 means unlimited. */
+    maxCount?: number;
+    /** Maximum file size in bytes; invalid or ≤0 means unlimited. */
+    maxSize?: number;
+    /** Controlled list; undefined lets Core own it (seeded by defaultValue). */
+    value?: readonly UploadItem[];
+    defaultValue?: readonly UploadItem[];
+    onChange?: (details: UploadChangeDetails) => void;
+    upload?: UploadRequest;
+    onReject?: (details: UploadRejectDetails) => void;
+    /** Create object-URL previews for image files; default true. */
+    preview?: boolean;
+    disabled?: boolean;
+    readOnly?: boolean;
+    triggerText?: string;
+    /** Remove button name with {name}; default 删除 {name}. */
+    removeLabel?: string;
+    retryText?: string;
+    cancelText?: string;
+    errorText?: string;
+    cancelledText?: string;
+}
+export interface ResolvedUploadState {
+    name: string | undefined;
+    accept: string;
+    multiple: boolean;
+    maxCount: number;
+    maxSize: number;
+    preview: boolean;
+    disabled: boolean;
+    readOnly: boolean;
+    triggerText: string;
+    removeLabel: string;
+    retryText: string;
+    cancelText: string;
+    errorText: string;
+    cancelledText: string;
+}
+export declare function resolveUploadState(props?: QwUploadProps): ResolvedUploadState;
+/** Normalize caller items; unknown status becomes done, duplicate or empty ids are dropped. */
+export declare function normalizeUploadItems(items: readonly UploadItem[] | undefined): UploadItem[];
+/** Native accept semantics: case-insensitive extension, type/* prefix or exact MIME; empty accepts everything. */
+export declare function matchesUploadAccept(file: {
+    name: string;
+    type: string;
+}, accept: string): boolean;
+export declare function createUploadProps(props?: QwUploadProps): QwUploadProps;
+export interface QwUploadSchema {
+    props: QwUploadProps;
+    context: {
+        value: UploadItem[];
+        announcement: string;
+    };
+    refs: {
+        files: Map<string, File>;
+        controllers: Map<string, AbortController>;
+        urls: Map<string, string>;
+        seq: number;
+        active: boolean;
+    };
+    state: "ready";
+    action: "add" | "remove" | "retry" | "cancel" | "settle" | "sync";
+    effect: "lifecycle";
+    event: {
+        type: "FILES";
+        files: readonly File[];
+    } | {
+        type: "REMOVE";
+        id: string;
+    } | {
+        type: "RETRY";
+        id: string;
+    } | {
+        type: "CANCEL";
+        id: string;
+    } | {
+        type: "SETTLE";
+        id: string;
+        controller: AbortController;
+        patch: Partial<UploadItem>;
+        final: boolean;
+    } | {
+        type: "SYNC";
+    };
+}
+export type QwUploadMachine = Machine<QwUploadSchema>;
+export type QwUploadService = Service<QwUploadSchema>;
+/** Core owns validation, the list, caller-upload lifecycle with AbortSignal, object-URL ownership and announcements. */
+export declare const uploadMachine: QwUploadMachine;
+export interface UploadViewItem extends UploadItem {
+    /** item.url, else the Core-owned object URL for images, else undefined. */
+    previewUrl: string | undefined;
+    statusText: string;
+    removeLabel: string;
+}
+export interface UploadInputEvent {
+    readonly currentTarget: unknown;
+}
+export interface QwUploadApi<T extends PropTypes = PropTypes> {
+    items: UploadViewItem[];
+    announcement: string;
+    triggerText: string;
+    retryText: string;
+    cancelText: string;
+    /** False while disabled, read-only or at maxCount. */
+    canAdd: boolean;
+    addFiles(files: readonly File[]): void;
+    remove(id: string): void;
+    retry(id: string): void;
+    cancel(id: string): void;
+    getRootProps(): T["element"];
+    getInputProps(): T["input"];
+    getTriggerProps(): T["label"];
+    getListProps(): T["element"];
+    getItemProps(item: UploadViewItem): T["element"];
+    getPreviewProps(item: UploadViewItem): T["img"];
+    getNameProps(item: UploadViewItem): T["element"];
+    getStatusProps(item: UploadViewItem): T["element"];
+    getRetryProps(item: UploadViewItem): T["button"];
+    getCancelProps(item: UploadViewItem): T["button"];
+    getRemoveProps(item: UploadViewItem): T["button"];
+    getLiveProps(): T["element"];
+}
+export declare function connectUpload<T extends PropTypes>(service: QwUploadService, normalize: NormalizeProps<T>): QwUploadApi<T>;

package/dist/virtual-list/index.d.ts

@@ -0,0 +1 @@
+export * from "./virtual-list.js";

package/dist/virtual-list/index.js

@@ -0,0 +1,445 @@
+import { createMachine } from "@zag-js/core";
+//#region src/virtual-list/virtual-list.ts
+/** Stable DOM parts shared by every adapter. */
+const VIRTUAL_LIST_PARTS = [
+	"root",
+	"list",
+	"item",
+	"empty"
+];
+/** scrollToIndex alignment vocabulary; any other value is treated as auto. */
+const VIRTUAL_LIST_ALIGNS = [
+	"auto",
+	"start",
+	"center",
+	"end"
+];
+/** Fixed row height in CSS pixels used when itemHeight is missing or invalid. */
+const VIRTUAL_LIST_DEFAULT_ITEM_HEIGHT = 48;
+/** Rows rendered before and after the visible rows. */
+const VIRTUAL_LIST_DEFAULT_OVERSCAN = 3;
+/** Rows assumed visible before the viewport has been measured (SSR, hidden containers). */
+const VIRTUAL_LIST_DEFAULT_INITIAL_COUNT = 10;
+const text = (value, fallback) => typeof value === "string" && value.trim() ? value : fallback;
+const positive = (value, fallback) => typeof value === "number" && Number.isFinite(value) && value > 0 ? value : fallback;
+const whole = (value, fallback) => typeof value === "number" && Number.isFinite(value) && value >= 0 ? Math.floor(value) : fallback;
+const clamp = (value, min, max) => Math.min(max, Math.max(min, value));
+const field = (item, name) => item !== null && typeof item === "object" ? item[name] : void 0;
+const accessor = (value) => typeof value === "function" || typeof value === "string" && value.trim() ? value : void 0;
+/** O(1): items are referenced, never copied or scanned. */
+function resolveVirtualListState(props = {}) {
+	const items = Array.isArray(props.items) ? props.items : [];
+	return {
+		items,
+		count: items.length,
+		itemHeight: positive(props.itemHeight, 48),
+		overscan: whole(props.overscan, 3),
+		initialVisibleCount: whole(props.initialVisibleCount, 10),
+		target: typeof props.target === "string" && props.target.trim() ? props.target : void 0,
+		label: text(props.label, "列表"),
+		emptyText: text(props.emptyText, "暂无数据"),
+		itemKey: accessor(props.itemKey),
+		itemText: accessor(props.itemText)
+	};
+}
+/** Unique row identity. Missing, empty or non-finite keys throw: a silent fallback would break row identity. */
+function resolveVirtualListKey(item, index, itemKey) {
+	const raw = itemKey === void 0 ? index : typeof itemKey === "function" ? itemKey(item, index) : field(item, itemKey);
+	if (typeof raw === "string" && raw.length) return raw;
+	if (typeof raw === "number" && Number.isFinite(raw)) return String(raw);
+	throw new TypeError(`VirtualList item ${index} requires a nonempty string or finite number key`);
+}
+/** Default text: never throws; anything other than a string or finite number renders as an empty string. */
+function resolveVirtualListText(item, index, itemText) {
+	const raw = typeof itemText === "function" ? itemText(item, index) : typeof itemText === "string" ? field(item, itemText) : item;
+	return typeof raw === "string" ? raw : typeof raw === "number" && Number.isFinite(raw) ? String(raw) : "";
+}
+/**
+* Fixed-height window. scrollTop is the list-relative offset: an offset beyond the last full viewport is clamped
+* (stale offsets stay valid after the data shrinks); a negative offset means the list starts below an external viewport's top.
+*/
+function getVirtualListRange(input) {
+	const count = Math.max(0, Math.floor(input.count) || 0), height = positive(input.itemHeight, 48);
+	const viewport = Number.isFinite(input.viewport) ? Math.max(0, input.viewport) : 0, overscan = whole(input.overscan, 0);
+	if (!count) return {
+		start: 0,
+		end: 0,
+		visibleStart: 0,
+		visibleEnd: 0,
+		count: 0
+	};
+	const top = Math.min(Number.isFinite(input.scrollTop) ? input.scrollTop : 0, Math.max(0, count * height - viewport));
+	const visibleStart = clamp(Math.floor(top / height), 0, count);
+	const visibleEnd = clamp(Math.ceil((top + viewport) / height), visibleStart, count);
+	return {
+		start: Math.max(0, visibleStart - overscan),
+		end: Math.min(count, visibleEnd + overscan),
+		visibleStart,
+		visibleEnd,
+		count
+	};
+}
+/** Upper bound of windowed rows for any offset: ceil(viewport / itemHeight) + 1 partial row + 2 × overscan (a focused pinned row adds at most 1). */
+function getVirtualListRenderLimit(viewport, itemHeight, overscan) {
+	return Math.ceil(Math.max(0, viewport) / positive(itemHeight, 48)) + 1 + 2 * whole(overscan, 0);
+}
+/** List-relative offset that brings index into view, or null when nothing should scroll. The index is clamped into [0, count - 1]. */
+function getVirtualListScrollTop(input) {
+	const count = Math.max(0, Math.floor(input.count) || 0), height = positive(input.itemHeight, 48);
+	if (!count || !Number.isFinite(input.index)) return null;
+	const viewport = Number.isFinite(input.viewport) ? Math.max(0, input.viewport) : 0, current = Number.isFinite(input.scrollTop) ? input.scrollTop : 0;
+	const top = clamp(Math.floor(input.index), 0, count - 1) * height, bottom = top + height;
+	const align = VIRTUAL_LIST_ALIGNS.includes(input.align ?? "") ? input.align : "auto";
+	let next;
+	if (align === "start") next = top;
+	else if (align === "end") next = bottom - viewport;
+	else if (align === "center") next = top - (viewport - height) / 2;
+	else if (top >= current && bottom <= current + viewport) return null;
+	else next = top < current || height >= viewport ? top : bottom - viewport;
+	return clamp(next, 0, Math.max(0, count * height - viewport));
+}
+/** Row index currently holding focus: O(1) when unchanged, otherwise one scan by key; -1 when the row is gone. */
+function findVirtualListFocus(state, focus) {
+	if (!focus) return -1;
+	const keyAt = (index) => {
+		try {
+			return resolveVirtualListKey(state.items[index], index, state.itemKey);
+		} catch {
+			return;
+		}
+	};
+	if (focus.index >= 0 && focus.index < state.count && keyAt(focus.index) === focus.key) return focus.index;
+	for (let index = 0; index < state.count; index++) if (keyAt(index) === focus.key) return index;
+	return -1;
+}
+function createVirtualListProps(props = {}) {
+	if (props.id !== void 0 && (typeof props.id !== "string" || !props.id.trim())) throw new TypeError("VirtualList requires a nonempty instance id when provided");
+	return { ...props };
+}
+const ids = (scope) => {
+	const base = `virtual-list:${scope.id}`;
+	return {
+		root: base,
+		list: `${base}:list`
+	};
+};
+const live = (service) => resolveVirtualListState({
+	items: service.prop("items"),
+	itemHeight: service.prop("itemHeight"),
+	itemKey: service.prop("itemKey"),
+	itemText: service.prop("itemText"),
+	overscan: service.prop("overscan"),
+	target: service.prop("target"),
+	initialVisibleCount: service.prop("initialVisibleCount"),
+	label: service.prop("label"),
+	emptyText: service.prop("emptyText")
+});
+/** A zero measurement (SSR, jsdom, display:none) keeps the initialVisibleCount fallback instead of collapsing the window. */
+const viewportOf = (state, measured) => measured > 0 ? measured : state.initialVisibleCount * state.itemHeight;
+const rangeOf = (state, context) => getVirtualListRange({
+	count: state.count,
+	itemHeight: state.itemHeight,
+	viewport: viewportOf(state, context.get("viewport")),
+	scrollTop: context.get("scrollTop"),
+	overscan: state.overscan
+});
+/** Primitive identity per items array: zag tracks primitives, and comparing 10k rows by value on every publish would be O(n). */
+const identities = /* @__PURE__ */ new WeakMap();
+let nextIdentity = 0;
+function identityOf(value) {
+	if (!value || typeof value !== "object") return 0;
+	let identity = identities.get(value);
+	if (identity === void 0) {
+		identity = ++nextIdentity;
+		identities.set(value, identity);
+	}
+	return identity;
+}
+const rangeKey = (range) => `${range.start}:${range.end}:${range.visibleStart}:${range.visibleEnd}:${range.count}`;
+/** Platform boundary: self, the target element in the root's own tree, or null for the page viewport. */
+function resolveScroller(root, target) {
+	if (!target) return root;
+	return root.getRootNode().getElementById?.(target) ?? root.ownerDocument.getElementById(target);
+}
+/** List-relative offset and viewport size of the resolved scroller. */
+function readViewport(root, list, scroller) {
+	if (scroller === root) return {
+		scrollTop: root.scrollTop,
+		viewport: root.clientHeight
+	};
+	const listTop = (list ?? root).getBoundingClientRect().top;
+	if (scroller) return {
+		scrollTop: scroller.getBoundingClientRect().top + scroller.clientTop - listTop,
+		viewport: scroller.clientHeight
+	};
+	return {
+		scrollTop: -listTop,
+		viewport: root.ownerDocument.defaultView?.innerHeight ?? 0
+	};
+}
+/** The row element of this list containing node; nested lists inside a row are ignored. */
+function rowOf(root, list, node) {
+	for (let current = node; list && current && current !== root; current = current.parentNode) if (current.parentNode === list && current.getAttribute?.("data-part") === "item") return current;
+	return null;
+}
+/** Core owns measurement, windowing, the focused-row pin, scrollToIndex, range notifications and cleanup. */
+const virtualListMachine = createMachine({
+	props: ({ props }) => createVirtualListProps(props),
+	initialState: () => "ready",
+	states: { ready: {} },
+	context: ({ bindable }) => ({
+		scrollTop: bindable(() => ({ defaultValue: 0 })),
+		viewport: bindable(() => ({ defaultValue: 0 })),
+		focus: bindable(() => ({
+			defaultValue: null,
+			hash: (value) => value ? `${value.index}\u0000${value.key}` : ""
+		}))
+	}),
+	refs: () => ({
+		rebind: null,
+		restore: null
+	}),
+	watch({ track, prop, context, action }) {
+		track([() => prop("target")], () => action(["rebind"]));
+		track([() => identityOf(prop("items")), () => prop("items")?.length], () => action(["reconcile"]));
+		track([() => rangeKey(rangeOf(live({ prop }), context))], () => action(["notifyRange"]));
+	},
+	on: {
+		MEASURE: { actions: ["measure"] },
+		"FOCUS.SET": { actions: ["setFocus"] },
+		"FOCUS.CLEAR": { actions: ["clearFocus"] },
+		"SCROLL.TO": { actions: ["scrollToIndex"] }
+	},
+	effects: ["trackViewport"],
+	implementations: {
+		actions: {
+			measure({ event, context }) {
+				if (event.type !== "MEASURE") return;
+				if (event.scrollTop !== context.get("scrollTop")) context.set("scrollTop", event.scrollTop);
+				if (event.viewport !== context.get("viewport")) context.set("viewport", event.viewport);
+			},
+			setFocus({ event, context }) {
+				if (event.type === "FOCUS.SET") context.set("focus", {
+					key: event.key,
+					index: event.index
+				});
+			},
+			clearFocus({ context }) {
+				if (context.get("focus")) context.set("focus", null);
+			},
+			rebind({ refs }) {
+				refs.get("rebind")?.();
+			},
+			reconcile({ context, prop, refs }) {
+				const focus = context.get("focus");
+				if (!focus) return;
+				const index = findVirtualListFocus(live({ prop }), focus);
+				if (index === -1) {
+					context.set("focus", null);
+					refs.get("restore")?.();
+				} else if (index !== focus.index) context.set("focus", {
+					key: focus.key,
+					index
+				});
+			},
+			notifyRange({ prop, context }) {
+				prop("onRangeChange")?.(rangeOf(live({ prop }), context));
+			},
+			scrollToIndex({ event, context, prop, scope }) {
+				if (event.type !== "SCROLL.TO") return;
+				const state = live({ prop }), id = ids(scope), root = scope.getById(id.root);
+				const scroller = root ? resolveScroller(root, state.target) : void 0;
+				const current = root ? readViewport(root, scope.getById(id.list), scroller ?? null) : {
+					scrollTop: context.get("scrollTop"),
+					viewport: context.get("viewport")
+				};
+				const next = getVirtualListScrollTop({
+					index: event.index,
+					align: event.align,
+					count: state.count,
+					itemHeight: state.itemHeight,
+					viewport: viewportOf(state, current.viewport),
+					scrollTop: current.scrollTop
+				});
+				if (next === null) return;
+				if (root) {
+					const win = root.ownerDocument.defaultView;
+					if (scroller === root) root.scrollTop = next;
+					else if (scroller) scroller.scrollTop += next - current.scrollTop;
+					else win?.scrollTo(win.scrollX, win.scrollY + next - current.scrollTop);
+				}
+				context.set("scrollTop", next);
+			}
+		},
+		effects: { trackViewport({ scope, prop, context, send, refs }) {
+			const id = ids(scope), root = scope.getById(id.root), doc = root?.ownerDocument, win = doc?.defaultView;
+			if (!root || !doc || !win) return;
+			let frame = 0, disposed = false, scroller = root, events = null, observer = null;
+			const pending = /* @__PURE__ */ new Set();
+			const measure = () => {
+				frame = 0;
+				if (disposed) return;
+				const next = readViewport(root, scope.getById(id.list), scroller);
+				if (next.scrollTop !== context.get("scrollTop") || next.viewport !== context.get("viewport")) send({
+					type: "MEASURE",
+					...next
+				});
+			};
+			const schedule = () => {
+				if (!disposed && !frame) frame = win.requestAnimationFrame(measure);
+			};
+			const later = (run) => {
+				const handle = win.requestAnimationFrame(() => {
+					pending.delete(handle);
+					if (!disposed) run();
+				});
+				pending.add(handle);
+			};
+			const bind = () => {
+				if (disposed) return;
+				events?.removeEventListener("scroll", schedule);
+				observer?.disconnect();
+				observer = null;
+				scroller = resolveScroller(root, live({ prop }).target);
+				events = scroller ?? win;
+				events.addEventListener("scroll", schedule, { passive: true });
+				const Observer = win.ResizeObserver;
+				if (Observer && scroller) {
+					observer = new Observer(schedule);
+					observer.observe(scroller);
+				}
+				measure();
+			};
+			const restore = () => later(() => {
+				const active = doc.activeElement;
+				if (!active || active === doc.body) root.focus({ preventScroll: true });
+			});
+			const onFocusIn = (event) => {
+				const row = rowOf(root, scope.getById(id.list), event.target), key = row?.getAttribute("data-key"), index = Number(row?.getAttribute("data-index"));
+				const current = context.get("focus");
+				if (row && key != null && Number.isInteger(index)) {
+					if (current?.key !== key || current.index !== index) send({
+						type: "FOCUS.SET",
+						key,
+						index
+					});
+				} else if (current) send({ type: "FOCUS.CLEAR" });
+			};
+			const onFocusOut = () => later(() => {
+				const active = doc.activeElement, focus = context.get("focus");
+				if (active && root.contains(active)) return;
+				if (focus && (!active || active === doc.body) && findVirtualListFocus(live({ prop }), focus) === -1) {
+					root.focus({ preventScroll: true });
+					return;
+				}
+				send({ type: "FOCUS.CLEAR" });
+			});
+			refs.set("rebind", bind);
+			refs.set("restore", restore);
+			win.addEventListener("resize", schedule);
+			root.addEventListener("focusin", onFocusIn);
+			root.addEventListener("focusout", onFocusOut);
+			bind();
+			return () => {
+				disposed = true;
+				refs.set("rebind", null);
+				refs.set("restore", null);
+				if (frame) win.cancelAnimationFrame(frame);
+				for (const handle of pending) win.cancelAnimationFrame(handle);
+				pending.clear();
+				events?.removeEventListener("scroll", schedule);
+				observer?.disconnect();
+				win.removeEventListener("resize", schedule);
+				root.removeEventListener("focusin", onFocusIn);
+				root.removeEventListener("focusout", onFocusOut);
+			};
+		} }
+	}
+});
+function connectVirtualList(service, normalize) {
+	const base = live(service), state = base, id = ids(service.scope), range = rangeOf(base, service.context);
+	const row = (index, pinned) => {
+		const item = state.items[index];
+		return {
+			key: resolveVirtualListKey(item, index, state.itemKey),
+			index,
+			item,
+			text: resolveVirtualListText(item, index, state.itemText),
+			pinned
+		};
+	};
+	const rows = [];
+	for (let index = range.start; index < range.end; index++) rows.push(row(index, false));
+	const focused = findVirtualListFocus(base, service.context.get("focus"));
+	if (focused !== -1 && (focused < range.start || focused >= range.end)) if (focused < range.start) rows.unshift(row(focused, true));
+	else rows.push(row(focused, true));
+	const seen = /* @__PURE__ */ new Set();
+	for (const entry of rows) {
+		if (seen.has(entry.key)) throw new TypeError(`VirtualList item keys must be unique: ${entry.key}`);
+		seen.add(entry.key);
+	}
+	const empty = state.count === 0, self = state.target === void 0, totalHeight = state.count * state.itemHeight;
+	const part = (name) => ({
+		"data-scope": "virtual-list",
+		"data-part": name
+	});
+	return {
+		rows,
+		count: state.count,
+		empty,
+		range,
+		itemHeight: state.itemHeight,
+		totalHeight,
+		label: state.label,
+		emptyText: state.emptyText,
+		scrollToIndex: (index, align) => service.send({
+			type: "SCROLL.TO",
+			index,
+			align
+		}),
+		getRootProps: () => normalize.element({
+			...part("root"),
+			id: id.root,
+			role: "group",
+			"aria-label": state.label,
+			tabIndex: self ? 0 : -1,
+			"data-scroller": self ? "self" : "target",
+			"data-empty": empty ? "true" : void 0
+		}),
+		getListProps: () => normalize.element({
+			...part("list"),
+			id: id.list,
+			role: "list",
+			hidden: empty || void 0,
+			style: {
+				position: "relative",
+				blockSize: `${totalHeight}px`
+			}
+		}),
+		getItemProps: (entry) => normalize.element({
+			...part("item"),
+			role: "listitem",
+			"aria-setsize": state.count,
+			"aria-posinset": entry.index + 1,
+			"data-index": entry.index,
+			"data-key": entry.key,
+			"data-pinned": entry.pinned ? "true" : void 0,
+			style: {
+				position: "absolute",
+				insetInlineStart: "0",
+				insetInlineEnd: "0",
+				insetBlockStart: `${entry.index * state.itemHeight}px`,
+				blockSize: `${state.itemHeight}px`
+			}
+		}),
+		getEmptyProps: () => normalize.element({
+			...part("empty"),
+			role: "status",
+			hidden: !empty || void 0
+		})
+	};
+}
+//#endregion
+export { VIRTUAL_LIST_ALIGNS, VIRTUAL_LIST_DEFAULT_INITIAL_COUNT, VIRTUAL_LIST_DEFAULT_ITEM_HEIGHT, VIRTUAL_LIST_DEFAULT_OVERSCAN, VIRTUAL_LIST_PARTS, connectVirtualList, createVirtualListProps, findVirtualListFocus, getVirtualListRange, getVirtualListRenderLimit, getVirtualListScrollTop, resolveVirtualListKey, resolveVirtualListState, resolveVirtualListText, virtualListMachine };
+
+//# sourceMappingURL=index.js.map