@zerodep-dev/vue-tsx-pro-ui 0.0.0-stage → 0.1.0

package/dist/utils/virtual/virtualizer.d.ts

@@ -0,0 +1,145 @@
+/** 一个要渲染的项；位置都相对列表开头，单位 px */
+export interface VirtualItem {
+    /** 在数据里的序号 */
+    readonly index: number;
+    /** getItemKey 给出的 key，测量结果按它缓存 */
+    readonly key: PropertyKey;
+    /** 起始位置 */
+    readonly start: number;
+    /** 大小：测量过的为真实大小，否则为估计值 */
+    readonly size: number;
+    /** 结束位置（start + size） */
+    readonly end: number;
+}
+/** 可见范围（不含 overscan），两端都包含 */
+export interface VisibleRange {
+    /** 第一个可见项 */
+    readonly startIndex: number;
+    /** 最后一个可见项 */
+    readonly endIndex: number;
+}
+/** 交给 rangeExtractor 的范围：可见范围、overscan 与总数 */
+export interface ExtractorRange extends VisibleRange {
+    /** 可见范围前后各多渲染几项 */
+    readonly overscan: number;
+    /** 总项数 */
+    readonly count: number;
+}
+/** 滚动到某一项时，它停在视口的什么位置 */
+export interface ScrollAligns {
+    /** 顶端（横向时为起始端）对齐视口开头 */
+    start: unknown;
+    /** 居中 */
+    center: unknown;
+    /** 末端对齐视口末尾 */
+    end: unknown;
+    /** 已经完整可见就不动，否则就近对齐开头或末尾（默认） */
+    auto: unknown;
+}
+/** scrollToIndex、scrollToOffset 的选项 */
+export interface VirtualScrollOptions {
+    /** 目标项停在视口的什么位置，默认 auto（scrollToOffset 不用） */
+    align?: keyof ScrollAligns;
+    /** 滚动方式，同 Element.scrollTo；smooth 时动态大小的项可能停得不够准 */
+    behavior?: ScrollBehavior;
+}
+/** Virtualizer 的选项 */
+export interface VirtualizerOptions {
+    /** 总项数 */
+    count: number;
+    /** 滚动容器：元素或 window；还没有时返回 null */
+    getScrollElement: () => HTMLElement | Window | null;
+    /** 第 index 项的估计大小（px）；渲染后以测量值为准，估计得越接近，滚动条越稳 */
+    estimateSize: (index: number) => number;
+    /** 第 index 项的 key，默认就是 index；数据会重排、增删时给稳定的 key，测量结果才对得上 */
+    getItemKey?: (index: number) => PropertyKey;
+    /** 可见范围前后各多渲染几项，默认 3：快速滚动时不露白 */
+    overscan?: number;
+    /** 横向滚动 */
+    horizontal?: boolean;
+    /** 列表开头距滚动内容开头的距离（px），如列表上方还有其他内容；函数在每次滚动时读取，默认 0 */
+    scrollMargin?: () => number;
+    /** 视口开头被吸顶的内容（表头）遮住的部分（px）：scrollToIndex 对齐时避开，被遮住的项不算可见；函数在滚动时读取 */
+    scrollPaddingStart?: () => number;
+    /** 视口末尾被吸底的内容（合计行）遮住的部分（px）；吸底的内容要在列表之后的正常流里 */
+    scrollPaddingEnd?: () => number;
+    /** 改写要渲染哪些项（序号升序）：吸顶行、固定行在这里加上，默认是可见范围加 overscan */
+    rangeExtractor?: (range: ExtractorRange) => number[];
+    /** 渲染范围或总大小变了：重新渲染 */
+    onChange?: (virtualizer: Virtualizer) => void;
+}
+/** 按大小依次排出每项的位置 */
+export declare function computeMeasurements(count: number, sizeOf: (index: number, key: PropertyKey) => number, keyOf: (index: number) => PropertyKey): VirtualItem[];
+/** 与 [offset, offset + viewport) 相交的项；视口为 0 时只有 offset 处的一项；没有项时为 null */
+export declare function findVisibleRange(items: readonly VirtualItem[], offset: number, viewport: number): VisibleRange | null;
+/** 默认的渲染范围：可见范围前后各加 overscan 项 */
+export declare function defaultRangeExtractor({ startIndex, endIndex, overscan, count, }: ExtractorRange): number[];
+/** 滚动容器是不是 window（整页滚动） */
+export declare const isWindow: (target: HTMLElement | Window) => target is Window;
+/** 虚拟滚动的状态与计算：位置表、可见范围、测量、滚动到指定项（用法见文件开头） */
+export declare class Virtualizer {
+    private options;
+    /** key → 测量到的大小 */
+    private readonly sizes;
+    /** 位置表；前 valid 项是准的，之后的在下次读取时从第 valid 项往后重排 */
+    private measurements;
+    private valid;
+    /** 同一轮里的多次测量只通知一次 */
+    private updateQueued;
+    /** 每测到一次新的大小加一：scrollToIndex 据此判断位置是否已经稳定 */
+    private sizeVersion;
+    /** 滚动位置，相对列表开头 */
+    private offset;
+    private viewport;
+    private range;
+    private scrollElement;
+    private itemObserver;
+    private readonly observed;
+    /** 这一批新渲染、还没量过的项 */
+    private readonly unmeasured;
+    private pendingScroll;
+    constructor(options: VirtualizerOptions);
+    /** 换一组选项（总数、估计大小、key 等）：重新排位置表，测量过的大小按 key 保留 */
+    setOptions(options: VirtualizerOptions): void;
+    /** 开始监听滚动容器的滚动与大小变化；返回清理函数 */
+    mount(): () => void;
+    /** 每项的位置表 */
+    getMeasurements(): readonly VirtualItem[];
+    /**
+     * 位置表补算到第 index 项为止：只从第一个变了大小的项往后重排，不是每次测量都重建整张表
+     * （一万行时每次重建要几毫秒，滚动时每帧都有新的项被测量）
+     */
+    private measureUpTo;
+    /** 列表的总大小（px）：撑开滚动区域 */
+    getTotalSize(): number;
+    /** 可见范围（不含 overscan）；没有项时为 null */
+    getVisibleRange(): VisibleRange | null;
+    /** 要渲染的项，序号升序 */
+    getVirtualItems(): VirtualItem[];
+    /**
+     * 测量渲染出来的项：作为元素的 ref 回调，元素要带 data-index。同一批渲染的项在微任务里一起量，
+     * 之后大小变化由 ResizeObserver 自动更新。传 null（元素卸载）时不再观察已经离开文档的元素。
+     */
+    measureElement: (element: Element | null) => void;
+    /**
+     * 量这一批新渲染的项：先全部读完再更新。边读边改（调整滚动位置）时每次读取都强制重新布局，
+     * 一次渲染很多项（如滚动容器没有限高，所有项都“可见”）时是平方级的布局，页面会卡死。
+     * 量布局尺寸（offsetHeight）而不是 getBoundingClientRect：浮层进场的 scale 变换会把后者缩小，
+     * 元素之后被复用（列表过滤、重排）时 ResizeObserver 不会再报，缩小的值就一直留着，行与行叠在一起
+     */
+    private measureRendered;
+    /** 滚动到第 index 项 */
+    scrollToIndex(index: number, { align, behavior }?: VirtualScrollOptions): void;
+    /** 滚动到相对列表开头的 offset（px） */
+    scrollToOffset(offset: number, { behavior }?: VirtualScrollOptions): void;
+    /** 第 index 项按 align 对齐时的滚动位置；auto 且已经完整可见时为 null */
+    private offsetForIndex;
+    private resizeItem;
+    private borderBoxSize;
+    private scrollBy;
+    private scrollMargin;
+    private readViewport;
+    private readScroll;
+    /** 重新算可见范围；范围变了或 force 时通知 */
+    private update;
+}

package/dist/utils/virtual/virtualizer.js

@@ -0,0 +1,316 @@
+import { clamp } from "../data/number.js";
+//#region src/utils/virtual/virtualizer.ts
+/**
+* 虚拟滚动的核心：只渲染可见范围内的项（COMPONENTS.md §10.7）。不依赖 Vue，VirtualList、DataTable 都建在它上面。
+* 算法参考 @tanstack/virtual-core：先按估计大小排出位置表，渲染后测量真实大小并按 key 缓存；
+* 可见范围用二分查找；可视区上方的项大小变化时同步调整滚动位置，可见内容不跳。
+*
+*   const virtualizer = new Virtualizer({ count, estimateSize: () => 36, getScrollElement: () => el, onChange });
+*   const cleanup = virtualizer.mount();
+*   virtualizer.getVirtualItems()   // 要渲染的项：index、start（相对列表开头的偏移）、size
+*   <div data-index={item.index} ref={virtualizer.measureElement}>  // 测量真实大小
+*/
+/** 按大小依次排出每项的位置 */
+function computeMeasurements(count, sizeOf, keyOf) {
+	const items = new Array(count);
+	let start = 0;
+	for (let index = 0; index < count; index++) {
+		const key = keyOf(index);
+		const size = sizeOf(index, key);
+		items[index] = {
+			index,
+			key,
+			start,
+			size,
+			end: start + size
+		};
+		start += size;
+	}
+	return items;
+}
+/** 与 [offset, offset + viewport) 相交的项；视口为 0 时只有 offset 处的一项；没有项时为 null */
+function findVisibleRange(items, offset, viewport) {
+	if (!items.length) return null;
+	let low = 0;
+	let high = items.length - 1;
+	while (low < high) {
+		const middle = low + high >> 1;
+		if (items[middle].end > offset) high = middle;
+		else low = middle + 1;
+	}
+	let endIndex = low;
+	while (endIndex < items.length - 1 && items[endIndex].end < offset + viewport) endIndex++;
+	return {
+		startIndex: low,
+		endIndex
+	};
+}
+/** 默认的渲染范围：可见范围前后各加 overscan 项 */
+function defaultRangeExtractor({ startIndex, endIndex, overscan, count }) {
+	const from = Math.max(0, startIndex - overscan);
+	const to = Math.min(count - 1, endIndex + overscan);
+	return Array.from({ length: to - from + 1 }, (_, index) => from + index);
+}
+/** 滚动容器是不是 window（整页滚动） */
+var isWindow = (target) => typeof window !== "undefined" && target === window;
+/** 动态大小下 scrollToIndex 重新对准的最多次数 */
+var MAX_SCROLL_ATTEMPTS = 10;
+/** 虚拟滚动的状态与计算：位置表、可见范围、测量、滚动到指定项（用法见文件开头） */
+var Virtualizer = class {
+	options;
+	/** key → 测量到的大小 */
+	sizes = /* @__PURE__ */ new Map();
+	/** 位置表；前 valid 项是准的，之后的在下次读取时从第 valid 项往后重排 */
+	measurements = null;
+	valid = 0;
+	/** 同一轮里的多次测量只通知一次 */
+	updateQueued = false;
+	/** 每测到一次新的大小加一：scrollToIndex 据此判断位置是否已经稳定 */
+	sizeVersion = 0;
+	/** 滚动位置，相对列表开头 */
+	offset = 0;
+	viewport = 0;
+	range = null;
+	scrollElement = null;
+	itemObserver = null;
+	observed = /* @__PURE__ */ new Set();
+	/** 这一批新渲染、还没量过的项 */
+	unmeasured = [];
+	pendingScroll = 0;
+	constructor(options) {
+		this.options = options;
+	}
+	/** 换一组选项（总数、估计大小、key 等）：重新排位置表，测量过的大小按 key 保留 */
+	setOptions(options) {
+		this.options = options;
+		this.measurements = null;
+		this.valid = 0;
+		this.update(true);
+	}
+	/** 开始监听滚动容器的滚动与大小变化；返回清理函数 */
+	mount() {
+		const element = this.options.getScrollElement();
+		if (!element) return () => {};
+		this.scrollElement = element;
+		const onScroll = () => this.readScroll();
+		const onResize = () => {
+			this.readViewport();
+			this.readScroll();
+		};
+		element.addEventListener("scroll", onScroll, { passive: true });
+		let viewportObserver;
+		if (isWindow(element)) window.addEventListener("resize", onResize);
+		else if (typeof ResizeObserver !== "undefined") {
+			viewportObserver = new ResizeObserver(onResize);
+			viewportObserver.observe(element);
+		}
+		if (typeof ResizeObserver !== "undefined") {
+			this.itemObserver = new ResizeObserver((entries) => {
+				const sizes = entries.map((entry) => [entry.target, this.borderBoxSize(entry)]);
+				requestAnimationFrame(() => {
+					for (const [target, size] of sizes) this.resizeItem(target, size);
+				});
+			});
+			for (const element of this.observed) this.itemObserver.observe(element);
+		}
+		this.readViewport();
+		this.readScroll();
+		return () => {
+			element.removeEventListener("scroll", onScroll);
+			if (isWindow(element)) window.removeEventListener("resize", onResize);
+			viewportObserver?.disconnect();
+			this.itemObserver?.disconnect();
+			this.itemObserver = null;
+			for (const observed of this.observed) if (!observed.isConnected) this.observed.delete(observed);
+			cancelAnimationFrame(this.pendingScroll);
+			this.scrollElement = null;
+		};
+	}
+	/** 每项的位置表 */
+	getMeasurements() {
+		return this.measureUpTo(this.options.count - 1);
+	}
+	/**
+	* 位置表补算到第 index 项为止：只从第一个变了大小的项往后重排，不是每次测量都重建整张表
+	* （一万行时每次重建要几毫秒，滚动时每帧都有新的项被测量）
+	*/
+	measureUpTo(index) {
+		const { count, estimateSize, getItemKey = (i) => i } = this.options;
+		const sizeOf = (i, key) => this.sizes.get(key) ?? estimateSize(i);
+		if (!this.measurements || this.measurements.length !== count) {
+			this.measurements = computeMeasurements(count, sizeOf, getItemKey);
+			this.valid = count;
+			return this.measurements;
+		}
+		const items = this.measurements;
+		const end = Math.min(index, count - 1);
+		let start = this.valid > 0 ? items[this.valid - 1].end : 0;
+		for (let i = this.valid; i <= end; i++) {
+			const key = getItemKey(i);
+			const size = sizeOf(i, key);
+			items[i] = {
+				index: i,
+				key,
+				start,
+				size,
+				end: start + size
+			};
+			start += size;
+		}
+		this.valid = Math.max(this.valid, end + 1);
+		return items;
+	}
+	/** 列表的总大小（px）：撑开滚动区域 */
+	getTotalSize() {
+		return this.getMeasurements().at(-1)?.end ?? 0;
+	}
+	/** 可见范围（不含 overscan）；没有项时为 null */
+	getVisibleRange() {
+		return this.range;
+	}
+	/** 要渲染的项，序号升序 */
+	getVirtualItems() {
+		if (!this.range) return [];
+		const { count, overscan = 3, rangeExtractor = defaultRangeExtractor } = this.options;
+		const measurements = this.getMeasurements();
+		return rangeExtractor({
+			...this.range,
+			overscan,
+			count
+		}).map((index) => measurements[index]).filter((item) => item != null);
+	}
+	/**
+	* 测量渲染出来的项：作为元素的 ref 回调，元素要带 data-index。同一批渲染的项在微任务里一起量，
+	* 之后大小变化由 ResizeObserver 自动更新。传 null（元素卸载）时不再观察已经离开文档的元素。
+	*/
+	measureElement = (element) => {
+		if (!element) {
+			for (const observed of this.observed) {
+				if (observed.isConnected) continue;
+				this.itemObserver?.unobserve(observed);
+				this.observed.delete(observed);
+			}
+			return;
+		}
+		if (this.observed.has(element)) return;
+		this.observed.add(element);
+		this.itemObserver?.observe(element);
+		this.unmeasured.push(element);
+		if (this.unmeasured.length === 1) queueMicrotask(() => this.measureRendered());
+	};
+	/**
+	* 量这一批新渲染的项：先全部读完再更新。边读边改（调整滚动位置）时每次读取都强制重新布局，
+	* 一次渲染很多项（如滚动容器没有限高，所有项都“可见”）时是平方级的布局，页面会卡死。
+	* 量布局尺寸（offsetHeight）而不是 getBoundingClientRect：浮层进场的 scale 变换会把后者缩小，
+	* 元素之后被复用（列表过滤、重排）时 ResizeObserver 不会再报，缩小的值就一直留着，行与行叠在一起
+	*/
+	measureRendered() {
+		const { horizontal } = this.options;
+		const sizes = this.unmeasured.splice(0).map((element) => [element, horizontal ? element.offsetWidth : element.offsetHeight]);
+		for (const [element, size] of sizes) this.resizeItem(element, size);
+	}
+	/** 滚动到第 index 项 */
+	scrollToIndex(index, { align = "auto", behavior } = {}) {
+		cancelAnimationFrame(this.pendingScroll);
+		const target = () => this.offsetForIndex(index, align);
+		const first = target();
+		if (first == null) return;
+		this.scrollToOffset(first, { behavior });
+		if (behavior === "smooth") return;
+		let attempts = 0;
+		let version = this.sizeVersion;
+		const settle = () => {
+			if (++attempts > MAX_SCROLL_ATTEMPTS) return;
+			const next = target();
+			const measured = version !== this.sizeVersion;
+			version = this.sizeVersion;
+			if (next != null && Math.abs(next - this.offset) >= 1) this.scrollToOffset(next);
+			else if (!measured) return;
+			this.pendingScroll = requestAnimationFrame(settle);
+		};
+		this.pendingScroll = requestAnimationFrame(settle);
+	}
+	/** 滚动到相对列表开头的 offset（px） */
+	scrollToOffset(offset, { behavior } = {}) {
+		const element = this.scrollElement;
+		if (!element) return;
+		const position = offset + this.scrollMargin();
+		element.scrollTo(this.options.horizontal ? {
+			left: position,
+			behavior
+		} : {
+			top: position,
+			behavior
+		});
+	}
+	/** 第 index 项按 align 对齐时的滚动位置；auto 且已经完整可见时为 null */
+	offsetForIndex(index, align) {
+		const item = this.getMeasurements()[clamp(index, 0, this.options.count - 1)];
+		if (!item) return null;
+		const { offset, viewport } = this;
+		const before = this.options.scrollPaddingStart?.() ?? 0;
+		const after = this.options.scrollPaddingEnd?.() ?? 0;
+		let target;
+		if (align === "auto") {
+			if (item.start >= offset + before && item.end <= offset + viewport - after) return null;
+			target = item.start < offset + before ? item.start - before : item.end - viewport + after;
+		} else if (align === "start") target = item.start - before;
+		else if (align === "end") target = item.end - viewport + after;
+		else target = item.start + item.size / 2 - (viewport + before - after) / 2;
+		return clamp(target, -before, Math.max(0, this.getTotalSize() - viewport + after));
+	}
+	resizeItem(element, size) {
+		if (!size || !element.isConnected) return;
+		const index = Number(element.getAttribute("data-index"));
+		const item = this.measureUpTo(index)[index];
+		if (!item || item.size === size) return;
+		if (item.start < this.offset) this.scrollBy(size - item.size);
+		this.sizes.set(item.key, size);
+		this.sizeVersion++;
+		this.valid = Math.min(this.valid, index);
+		if (this.updateQueued) return;
+		this.updateQueued = true;
+		queueMicrotask(() => {
+			this.updateQueued = false;
+			this.update(true);
+		});
+	}
+	borderBoxSize(entry) {
+		const box = entry.borderBoxSize?.[0];
+		if (!box) return this.options.horizontal ? entry.contentRect.width : entry.contentRect.height;
+		return this.options.horizontal ? box.inlineSize : box.blockSize;
+	}
+	scrollBy(delta) {
+		this.offset += delta;
+		this.scrollElement?.scrollBy(this.options.horizontal ? { left: delta } : { top: delta });
+	}
+	scrollMargin() {
+		return this.options.scrollMargin?.() ?? 0;
+	}
+	readViewport() {
+		const element = this.scrollElement;
+		if (!element) return;
+		const { horizontal } = this.options;
+		if (isWindow(element)) this.viewport = horizontal ? window.innerWidth : window.innerHeight;
+		else this.viewport = horizontal ? element.clientWidth : element.clientHeight;
+	}
+	readScroll() {
+		const element = this.scrollElement;
+		if (!element) return;
+		const { horizontal } = this.options;
+		const position = isWindow(element) ? horizontal ? window.scrollX : window.scrollY : horizontal ? element.scrollLeft : element.scrollTop;
+		this.offset = position - this.scrollMargin();
+		this.update(false);
+	}
+	/** 重新算可见范围；范围变了或 force 时通知 */
+	update(force) {
+		const range = findVisibleRange(this.getMeasurements(), this.offset, this.viewport);
+		const changed = range?.startIndex !== this.range?.startIndex || range?.endIndex !== this.range?.endIndex;
+		this.range = range;
+		if (changed || force) this.options.onChange?.(this);
+	}
+};
+//#endregion
+export { Virtualizer, computeMeasurements, defaultRangeExtractor, findVisibleRange, isWindow };
+
+//# sourceMappingURL=virtualizer.js.map

package/dist/utils/virtual/virtualizer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"virtualizer.js","names":[],"sources":["../../../src/utils/virtual/virtualizer.ts"],"sourcesContent":["/**\n * 虚拟滚动的核心：只渲染可见范围内的项（COMPONENTS.md §10.7）。不依赖 Vue，VirtualList、DataTable 都建在它上面。\n * 算法参考 @tanstack/virtual-core：先按估计大小排出位置表，渲染后测量真实大小并按 key 缓存；\n * 可见范围用二分查找；可视区上方的项大小变化时同步调整滚动位置，可见内容不跳。\n *\n *   const virtualizer = new Virtualizer({ count, estimateSize: () => 36, getScrollElement: () => el, onChange });\n *   const cleanup = virtualizer.mount();\n *   virtualizer.getVirtualItems()   // 要渲染的项：index、start（相对列表开头的偏移）、size\n *   <div data-index={item.index} ref={virtualizer.measureElement}>  // 测量真实大小\n */\nimport { clamp } from '../data/number';\n\n/** 一个要渲染的项；位置都相对列表开头，单位 px */\nexport interface VirtualItem {\n  /** 在数据里的序号 */\n  readonly index: number;\n  /** getItemKey 给出的 key，测量结果按它缓存 */\n  readonly key: PropertyKey;\n  /** 起始位置 */\n  readonly start: number;\n  /** 大小：测量过的为真实大小，否则为估计值 */\n  readonly size: number;\n  /** 结束位置（start + size） */\n  readonly end: number;\n}\n\n/** 可见范围（不含 overscan），两端都包含 */\nexport interface VisibleRange {\n  /** 第一个可见项 */\n  readonly startIndex: number;\n  /** 最后一个可见项 */\n  readonly endIndex: number;\n}\n\n/** 交给 rangeExtractor 的范围：可见范围、overscan 与总数 */\nexport interface ExtractorRange extends VisibleRange {\n  /** 可见范围前后各多渲染几项 */\n  readonly overscan: number;\n  /** 总项数 */\n  readonly count: number;\n}\n\n/** 滚动到某一项时，它停在视口的什么位置 */\nexport interface ScrollAligns {\n  /** 顶端（横向时为起始端）对齐视口开头 */\n  start: unknown;\n  /** 居中 */\n  center: unknown;\n  /** 末端对齐视口末尾 */\n  end: unknown;\n  /** 已经完整可见就不动，否则就近对齐开头或末尾（默认） */\n  auto: unknown;\n}\n\n/** scrollToIndex、scrollToOffset 的选项 */\nexport interface VirtualScrollOptions {\n  /** 目标项停在视口的什么位置，默认 auto（scrollToOffset 不用） */\n  align?: keyof ScrollAligns;\n  /** 滚动方式，同 Element.scrollTo；smooth 时动态大小的项可能停得不够准 */\n  behavior?: ScrollBehavior;\n}\n\n/** Virtualizer 的选项 */\nexport interface VirtualizerOptions {\n  /** 总项数 */\n  count: number;\n  /** 滚动容器：元素或 window；还没有时返回 null */\n  getScrollElement: () => HTMLElement | Window | null;\n  /** 第 index 项的估计大小（px）；渲染后以测量值为准，估计得越接近，滚动条越稳 */\n  estimateSize: (index: number) => number;\n  /** 第 index 项的 key，默认就是 index；数据会重排、增删时给稳定的 key，测量结果才对得上 */\n  getItemKey?: (index: number) => PropertyKey;\n  /** 可见范围前后各多渲染几项，默认 3：快速滚动时不露白 */\n  overscan?: number;\n  /** 横向滚动 */\n  horizontal?: boolean;\n  /** 列表开头距滚动内容开头的距离（px），如列表上方还有其他内容；函数在每次滚动时读取，默认 0 */\n  scrollMargin?: () => number;\n  /** 视口开头被吸顶的内容（表头）遮住的部分（px）：scrollToIndex 对齐时避开，被遮住的项不算可见；函数在滚动时读取 */\n  scrollPaddingStart?: () => number;\n  /** 视口末尾被吸底的内容（合计行）遮住的部分（px）；吸底的内容要在列表之后的正常流里 */\n  scrollPaddingEnd?: () => number;\n  /** 改写要渲染哪些项（序号升序）：吸顶行、固定行在这里加上，默认是可见范围加 overscan */\n  rangeExtractor?: (range: ExtractorRange) => number[];\n  /** 渲染范围或总大小变了：重新渲染 */\n  onChange?: (virtualizer: Virtualizer) => void;\n}\n\n/** 按大小依次排出每项的位置 */\nexport function computeMeasurements(\n  count: number,\n  sizeOf: (index: number, key: PropertyKey) => number,\n  keyOf: (index: number) => PropertyKey,\n): VirtualItem[] {\n  const items: VirtualItem[] = new Array(count);\n  let start = 0;\n  for (let index = 0; index < count; index++) {\n    const key = keyOf(index);\n    const size = sizeOf(index, key);\n    items[index] = { index, key, start, size, end: start + size };\n    start += size;\n  }\n  return items;\n}\n\n/** 与 [offset, offset + viewport) 相交的项；视口为 0 时只有 offset 处的一项；没有项时为 null */\nexport function findVisibleRange(\n  items: readonly VirtualItem[],\n  offset: number,\n  viewport: number,\n): VisibleRange | null {\n  if (!items.length) return null;\n  // 二分查找第一个 end > offset 的项\n  let low = 0;\n  let high = items.length - 1;\n  while (low < high) {\n    const middle = (low + high) >> 1;\n    if (items[middle]!.end > offset) high = middle;\n    else low = middle + 1;\n  }\n  let endIndex = low;\n  while (endIndex < items.length - 1 && items[endIndex]!.end < offset + viewport) endIndex++;\n  return { startIndex: low, endIndex };\n}\n\n/** 默认的渲染范围：可见范围前后各加 overscan 项 */\nexport function defaultRangeExtractor({\n  startIndex,\n  endIndex,\n  overscan,\n  count,\n}: ExtractorRange): number[] {\n  const from = Math.max(0, startIndex - overscan);\n  const to = Math.min(count - 1, endIndex + overscan);\n  return Array.from({ length: to - from + 1 }, (_, index) => from + index);\n}\n\n/** 滚动容器是不是 window（整页滚动） */\nexport const isWindow = (target: HTMLElement | Window): target is Window =>\n  typeof window !== 'undefined' && target === window;\n\n/** 动态大小下 scrollToIndex 重新对准的最多次数 */\nconst MAX_SCROLL_ATTEMPTS = 10;\n\n/** 虚拟滚动的状态与计算：位置表、可见范围、测量、滚动到指定项（用法见文件开头） */\nexport class Virtualizer {\n  private options: VirtualizerOptions;\n  /** key → 测量到的大小 */\n  private readonly sizes = new Map<PropertyKey, number>();\n  /** 位置表；前 valid 项是准的，之后的在下次读取时从第 valid 项往后重排 */\n  private measurements: VirtualItem[] | null = null;\n  private valid = 0;\n  /** 同一轮里的多次测量只通知一次 */\n  private updateQueued = false;\n  /** 每测到一次新的大小加一：scrollToIndex 据此判断位置是否已经稳定 */\n  private sizeVersion = 0;\n  /** 滚动位置，相对列表开头 */\n  private offset = 0;\n  private viewport = 0;\n  private range: VisibleRange | null = null;\n  private scrollElement: HTMLElement | Window | null = null;\n  private itemObserver: ResizeObserver | null = null;\n  private readonly observed = new Set<Element>();\n  /** 这一批新渲染、还没量过的项 */\n  private readonly unmeasured: HTMLElement[] = [];\n  private pendingScroll = 0;\n\n  constructor(options: VirtualizerOptions) {\n    this.options = options;\n  }\n\n  /** 换一组选项（总数、估计大小、key 等）：重新排位置表，测量过的大小按 key 保留 */\n  setOptions(options: VirtualizerOptions): void {\n    this.options = options;\n    this.measurements = null;\n    this.valid = 0;\n    this.update(true);\n  }\n\n  /** 开始监听滚动容器的滚动与大小变化；返回清理函数 */\n  mount(): () => void {\n    const element = this.options.getScrollElement();\n    if (!element) return () => {};\n    this.scrollElement = element;\n    const onScroll = () => this.readScroll();\n    const onResize = () => {\n      this.readViewport();\n      this.readScroll();\n    };\n    element.addEventListener('scroll', onScroll, { passive: true });\n    let viewportObserver: ResizeObserver | undefined;\n    if (isWindow(element)) window.addEventListener('resize', onResize);\n    else if (typeof ResizeObserver !== 'undefined') {\n      viewportObserver = new ResizeObserver(onResize);\n      viewportObserver.observe(element);\n    }\n    if (typeof ResizeObserver !== 'undefined') {\n      // 测量结果下一帧再用：在回调里同步改布局（重排位置、调整滚动），浏览器会报\n      // “ResizeObserver loop completed with undelivered notifications”。第一次测量在 measureRendered 里已经做过\n      this.itemObserver = new ResizeObserver((entries) => {\n        const sizes = entries.map((entry) => [entry.target, this.borderBoxSize(entry)] as const);\n        requestAnimationFrame(() => {\n          for (const [target, size] of sizes) this.resizeItem(target, size);\n        });\n      });\n      // 项的 ref 回调早于外层组件的 onMounted：挂载前就登记过的项这里补上观察，否则它们之后的大小变化永远收不到\n      for (const element of this.observed) this.itemObserver.observe(element);\n    }\n    this.readViewport();\n    this.readScroll();\n\n    return () => {\n      element.removeEventListener('scroll', onScroll);\n      if (isWindow(element)) window.removeEventListener('resize', onResize);\n      viewportObserver?.disconnect();\n      this.itemObserver?.disconnect();\n      this.itemObserver = null;\n      // 换滚动容器时会重新 mount：还在文档里的项留着，下次 mount 接着观察（它们的 ref 回调不会再来）\n      for (const observed of this.observed)\n        if (!observed.isConnected) this.observed.delete(observed);\n      cancelAnimationFrame(this.pendingScroll);\n      this.scrollElement = null;\n    };\n  }\n\n  /** 每项的位置表 */\n  getMeasurements(): readonly VirtualItem[] {\n    return this.measureUpTo(this.options.count - 1);\n  }\n\n  /**\n   * 位置表补算到第 index 项为止：只从第一个变了大小的项往后重排，不是每次测量都重建整张表\n   * （一万行时每次重建要几毫秒，滚动时每帧都有新的项被测量）\n   */\n  private measureUpTo(index: number): VirtualItem[] {\n    const { count, estimateSize, getItemKey = (i) => i } = this.options;\n    const sizeOf = (i: number, key: PropertyKey) => this.sizes.get(key) ?? estimateSize(i);\n    if (!this.measurements || this.measurements.length !== count) {\n      this.measurements = computeMeasurements(count, sizeOf, getItemKey);\n      this.valid = count;\n      return this.measurements;\n    }\n    const items = this.measurements;\n    const end = Math.min(index, count - 1);\n    let start = this.valid > 0 ? items[this.valid - 1]!.end : 0;\n    for (let i = this.valid; i <= end; i++) {\n      const key = getItemKey(i);\n      const size = sizeOf(i, key);\n      items[i] = { index: i, key, start, size, end: start + size };\n      start += size;\n    }\n    this.valid = Math.max(this.valid, end + 1);\n    return items;\n  }\n\n  /** 列表的总大小（px）：撑开滚动区域 */\n  getTotalSize(): number {\n    return this.getMeasurements().at(-1)?.end ?? 0;\n  }\n\n  /** 可见范围（不含 overscan）；没有项时为 null */\n  getVisibleRange(): VisibleRange | null {\n    return this.range;\n  }\n\n  /** 要渲染的项，序号升序 */\n  getVirtualItems(): VirtualItem[] {\n    if (!this.range) return [];\n    const { count, overscan = 3, rangeExtractor = defaultRangeExtractor } = this.options;\n    const measurements = this.getMeasurements();\n    return rangeExtractor({ ...this.range, overscan, count })\n      .map((index) => measurements[index])\n      .filter((item): item is VirtualItem => item != null);\n  }\n\n  /**\n   * 测量渲染出来的项：作为元素的 ref 回调，元素要带 data-index。同一批渲染的项在微任务里一起量，\n   * 之后大小变化由 ResizeObserver 自动更新。传 null（元素卸载）时不再观察已经离开文档的元素。\n   */\n  measureElement = (element: Element | null): void => {\n    if (!element) {\n      for (const observed of this.observed) {\n        if (observed.isConnected) continue;\n        this.itemObserver?.unobserve(observed);\n        this.observed.delete(observed);\n      }\n      return;\n    }\n    // 只在元素第一次出现时量（这一批渲染完、绘制之前）：之后的变化交给 ResizeObserver\n    if (this.observed.has(element)) return;\n    this.observed.add(element);\n    this.itemObserver?.observe(element);\n    this.unmeasured.push(element as HTMLElement);\n    if (this.unmeasured.length === 1) queueMicrotask(() => this.measureRendered());\n  };\n\n  /**\n   * 量这一批新渲染的项：先全部读完再更新。边读边改（调整滚动位置）时每次读取都强制重新布局，\n   * 一次渲染很多项（如滚动容器没有限高，所有项都“可见”）时是平方级的布局，页面会卡死。\n   * 量布局尺寸（offsetHeight）而不是 getBoundingClientRect：浮层进场的 scale 变换会把后者缩小，\n   * 元素之后被复用（列表过滤、重排）时 ResizeObserver 不会再报，缩小的值就一直留着，行与行叠在一起\n   */\n  private measureRendered() {\n    const { horizontal } = this.options;\n    const sizes = this.unmeasured\n      .splice(0)\n      .map(\n        (element) => [element, horizontal ? element.offsetWidth : element.offsetHeight] as const,\n      );\n    for (const [element, size] of sizes) this.resizeItem(element, size);\n  }\n\n  /** 滚动到第 index 项 */\n  scrollToIndex(index: number, { align = 'auto', behavior }: VirtualScrollOptions = {}): void {\n    cancelAnimationFrame(this.pendingScroll);\n    const target = () => this.offsetForIndex(index, align);\n    const first = target();\n    if (first == null) return;\n    this.scrollToOffset(first, { behavior });\n    if (behavior === 'smooth') return;\n    // 滚过去之后周围的项才被测量，位置可能变化：下一帧重新对准；\n    // 对准了、而且这一帧没有新的测量才算稳定（WebKit 的测量可能晚一两帧才到，对准后又变）\n    let attempts = 0;\n    let version = this.sizeVersion;\n    const settle = () => {\n      if (++attempts > MAX_SCROLL_ATTEMPTS) return;\n      const next = target();\n      const measured = version !== this.sizeVersion;\n      version = this.sizeVersion;\n      if (next != null && Math.abs(next - this.offset) >= 1) this.scrollToOffset(next);\n      else if (!measured) return;\n      this.pendingScroll = requestAnimationFrame(settle);\n    };\n    this.pendingScroll = requestAnimationFrame(settle);\n  }\n\n  /** 滚动到相对列表开头的 offset（px） */\n  scrollToOffset(offset: number, { behavior }: VirtualScrollOptions = {}): void {\n    const element = this.scrollElement;\n    if (!element) return;\n    const position = offset + this.scrollMargin();\n    element.scrollTo(\n      this.options.horizontal ? { left: position, behavior } : { top: position, behavior },\n    );\n  }\n\n  /** 第 index 项按 align 对齐时的滚动位置；auto 且已经完整可见时为 null */\n  private offsetForIndex(index: number, align: keyof ScrollAligns): number | null {\n    const item = this.getMeasurements()[clamp(index, 0, this.options.count - 1)];\n    if (!item) return null;\n    const { offset, viewport } = this;\n    const before = this.options.scrollPaddingStart?.() ?? 0;\n    const after = this.options.scrollPaddingEnd?.() ?? 0;\n    let target: number;\n    if (align === 'auto') {\n      if (item.start >= offset + before && item.end <= offset + viewport - after) return null;\n      target = item.start < offset + before ? item.start - before : item.end - viewport + after;\n    } else if (align === 'start') target = item.start - before;\n    else if (align === 'end') target = item.end - viewport + after;\n    else target = item.start + item.size / 2 - (viewport + before - after) / 2;\n    // 开头可以负到 -before：第一项对齐开头时回到最顶上，表头下面就是它\n    return clamp(target, -before, Math.max(0, this.getTotalSize() - viewport + after));\n  }\n\n  private resizeItem(element: Element, size: number) {\n    // 0 是还没排版（display: none、刚离开文档），保留原来的值\n    if (!size || !element.isConnected) return;\n    const index = Number(element.getAttribute('data-index'));\n    const item = this.measureUpTo(index)[index];\n    if (!item || item.size === size) return;\n    // 可视区上方的项变大或变小：同步调整滚动位置，可见内容不跳\n    if (item.start < this.offset) this.scrollBy(size - item.size);\n    this.sizes.set(item.key, size);\n    this.sizeVersion++;\n    this.valid = Math.min(this.valid, index);\n    // 渲染时一批新项依次测量：合并成一次通知，等这一批量完再重新算范围\n    if (this.updateQueued) return;\n    this.updateQueued = true;\n    queueMicrotask(() => {\n      this.updateQueued = false;\n      this.update(true);\n    });\n  }\n\n  private borderBoxSize(entry: ResizeObserverEntry) {\n    const box = entry.borderBoxSize?.[0];\n    if (!box) return this.options.horizontal ? entry.contentRect.width : entry.contentRect.height;\n    return this.options.horizontal ? box.inlineSize : box.blockSize;\n  }\n\n  private scrollBy(delta: number) {\n    this.offset += delta;\n    this.scrollElement?.scrollBy(this.options.horizontal ? { left: delta } : { top: delta });\n  }\n\n  private scrollMargin() {\n    return this.options.scrollMargin?.() ?? 0;\n  }\n\n  private readViewport() {\n    const element = this.scrollElement;\n    if (!element) return;\n    const { horizontal } = this.options;\n    if (isWindow(element)) this.viewport = horizontal ? window.innerWidth : window.innerHeight;\n    else this.viewport = horizontal ? element.clientWidth : element.clientHeight;\n  }\n\n  private readScroll() {\n    const element = this.scrollElement;\n    if (!element) return;\n    const { horizontal } = this.options;\n    const position = isWindow(element)\n      ? horizontal\n        ? window.scrollX\n        : window.scrollY\n      : horizontal\n        ? element.scrollLeft\n        : element.scrollTop;\n    this.offset = position - this.scrollMargin();\n    this.update(false);\n  }\n\n  /** 重新算可见范围；范围变了或 force 时通知 */\n  private update(force: boolean) {\n    const range = findVisibleRange(this.getMeasurements(), this.offset, this.viewport);\n    const changed =\n      range?.startIndex !== this.range?.startIndex || range?.endIndex !== this.range?.endIndex;\n    this.range = range;\n    if (changed || force) this.options.onChange?.(this);\n  }\n}\n"],"mappings":"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"}

package/dist/xlsx/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Excel 读写（子路径 `@zerodep-dev/vue-tsx-pro-ui/xlsx`）：导出带分组表头、数字格式的 .xlsx，读取时展开合并单元格、连起多行表头。
+ * 依赖可选的 peer exceljs，用到这个子路径时安装。见 workbook.ts。
+ *
+ *   import { exportXlsx, readXlsx } from '@zerodep-dev/vue-tsx-pro-ui/xlsx';
+ */
+export { exportXlsx, readXlsx, tableToXlsx, type XlsxExportOptions, type XlsxReadOptions, type XlsxSheet, } from './workbook';

package/dist/xlsx/index.js

@@ -0,0 +1 @@
+export { exportXlsx, readXlsx, tableToXlsx } from "./workbook.js";

package/dist/xlsx/workbook.d.ts

@@ -0,0 +1,33 @@
+import { type DataTableColumn, type DataTableColumnGroup } from '../table/columns';
+import { type SheetMatrixOptions, type SheetTable } from '../table/sheet';
+/** 导出的一张工作表 */
+export interface XlsxSheet<T> {
+    /** 工作表名（Excel 限 31 个字，不能有 \ / ? * [ ]） */
+    name: string;
+    /** 数据 */
+    rows: readonly T[];
+    /** 列定义（同 DataTable；只导出要的列时先筛掉操作列） */
+    columns: readonly DataTableColumn<T>[];
+    /** 分组表头（同 DataTable 的 columnGroups）：导出成两行表头，组标题横向合并 */
+    groups?: readonly DataTableColumnGroup[];
+}
+/** 导出的选项 */
+export interface XlsxExportOptions {
+    /** 金额列的币种（ISO 4217），默认 CNY；跟随语言时传 lang.currency */
+    currency?: string;
+    /** 金额符号按哪种语言取，默认 zh-CN */
+    locale?: string;
+    /** 合计行第一列的文字，默认“合计” */
+    summaryLabel?: string;
+}
+/** 读取的选项 */
+export interface XlsxReadOptions extends SheetMatrixOptions {
+    /** 只读这些工作表（名字）；默认全部 */
+    sheets?: readonly string[];
+}
+/** 表 → .xlsx 文件的内容（ArrayBuffer）；下载用 exportXlsx */
+export declare function tableToXlsx<T>(sheets: readonly XlsxSheet<T>[], { currency, locale, summaryLabel }?: XlsxExportOptions): Promise<ArrayBuffer>;
+/** 导出并下载 .xlsx：fileName 不带扩展名时自动加上 */
+export declare function exportXlsx<T>(fileName: string, sheets: readonly XlsxSheet<T>[], options?: XlsxExportOptions): Promise<void>;
+/** 读 .xlsx 文件：每张工作表一个 SheetTable（见文件开头） */
+export declare function readXlsx(file: Blob, options?: XlsxReadOptions): Promise<SheetTable[]>;