@solid2-aria/stately 0.0.0-stage → 0.0.1

package/dist/virtualizer/scroll-anchor.js

@@ -0,0 +1,150 @@
+/*
+ * Copyright 2026 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+/*
+ * Derived from Adobe React Spectrum: packages/react-stately/src/virtualizer/ScrollAnchor.ts.
+ * Modified for Solid Aria: adapted imports, collection descriptors, and reactive state APIs for Solid 2.
+ * Licensed under Apache-2.0. See LICENSES/Apache-2.0.txt and NOTICE.txt at the repository root.
+ */
+import { Rect } from "./rect.js";
+// src/virtualizer/scroll-anchor.ts
+/**
+* Minimum overlap an item must have with the viewport, along the scroll axis,
+* to be eligible as a scroll anchor. Without this, an item that only overlaps the viewport
+* by a sliver (e.g. 1px, essentially scrolled out of view) can still "win" the anchor
+* tie-break over a substantially visible item.
+*/
+const MIN_ANCHOR_OVERLAP = 4;
+function dimensionForAxis(axis) {
+	return axis === "x" ? "width" : "height";
+}
+/**
+* Given a previously-captured anchor, computes the new viewport coordinate (along `axis`) needed
+* to keep it at the same offset from the viewport's start.
+*/
+function computeScrollAnchorTarget(anchor, axis, getLayoutInfo, visibleRect, contentSize) {
+	const finalInfo = getLayoutInfo(anchor.key);
+	if (!finalInfo) return null;
+	const adjustment = finalInfo.rect[anchor.corner][axis] - visibleRect[axis] - anchor.offset;
+	if (adjustment === 0) return null;
+	const target = visibleRect[axis] + adjustment;
+	const dimension = dimensionForAxis(axis);
+	const max = Math.max(0, contentSize[dimension] - visibleRect[dimension]);
+	const clamped = Math.max(0, Math.min(max, target));
+	return clamped === visibleRect[axis] ? null : clamped;
+}
+/**
+* Picks the item to anchor scroll to: the one nearest the top of the viewport when
+* anchoring to 'end', or nearest the bottom when anchoring to 'start'. Callers can
+* exclude certain items (like loaders) with `isAnchorable`.
+*/
+function captureScrollAnchor(edge, axis, visibleRect, visibleLayoutInfos, isAnchorable = () => true) {
+	const dimension = dimensionForAxis(axis);
+	let best = null;
+	for (const [key, layoutInfo] of visibleLayoutInfos) {
+		if (!isAnchorable(layoutInfo)) continue;
+		const overlap = layoutInfo.rect.intersection(visibleRect)[dimension];
+		if (layoutInfo.rect.area > 0 && overlap >= MIN_ANCHOR_OVERLAP) {
+			const corner = layoutInfo.rect.getCornerInRect(visibleRect) ?? "topLeft";
+			const offset = layoutInfo.rect[corner][axis] - visibleRect[axis];
+			if (!best || (edge === "end" ? offset < best.offset : offset > best.offset)) best = {
+				corner,
+				key,
+				offset
+			};
+		}
+	}
+	return best;
+}
+/** Returns the viewport coordinate (along `axis`) that pins the viewport to `edge` of the content. */
+function getEdgeSnapTarget(edge, axis, contentSize, previousVisibleRect) {
+	if (edge === "start") return 0;
+	const dimension = dimensionForAxis(axis);
+	return Math.max(0, contentSize[dimension] - previousVisibleRect[dimension]);
+}
+/**
+* Whether the viewport is currently within `threshold` px of the anchored edge — used by
+* Virtualizer to compute wasNearAnchorEdge generically, without any layout-specific state.
+*/
+function isNearEdge(visibleRect, contentSize, edge, axis, threshold) {
+	if (edge === "start") return visibleRect[axis] <= threshold;
+	const dimension = dimensionForAxis(axis);
+	return contentSize[dimension] - (visibleRect[axis] + visibleRect[dimension]) <= threshold;
+}
+/**
+* Works out the new scroll position after content changes. Tries to keep the anchor
+* item where it was. If that doesn't apply, sticks the view to the edge instead, but
+* only if the user was already near the edge and didn't just scroll away on their own.
+*/
+function resolveScrollAdjustment(edge, axis, anchor, wasNearAnchorEdge, isScrolling, itemSizeChanged, contentSizeDelta, getLayoutInfo, previousVisibleRect, contentSize) {
+	const withTarget = (target) => axis === "x" ? new Rect(target, previousVisibleRect.y, previousVisibleRect.width, previousVisibleRect.height) : new Rect(previousVisibleRect.x, target, previousVisibleRect.width, previousVisibleRect.height);
+	if (anchor) {
+		const target = computeScrollAnchorTarget(anchor, axis, getLayoutInfo, previousVisibleRect, contentSize);
+		if (target !== null && target !== void 0) return withTarget(target);
+	}
+	if (wasNearAnchorEdge && !isScrolling && (!itemSizeChanged || contentSizeDelta > 0)) {
+		const target = withTarget(getEdgeSnapTarget(edge, axis, contentSize, previousVisibleRect));
+		return target.equals(previousVisibleRect) ? null : target;
+	}
+	return null;
+}
+/**
+* Tracks the cross-pass state needed to keep the viewport anchored to a layout's edge across
+* relayouts.
+*/
+var ScrollAnchorTracker = class {
+	hasSnappedToEdge = false;
+	hadEstimatedVisibleItems = false;
+	wasNearAnchorEdge = false;
+	/** Resets all tracked state, e.g. when the virtualizer's layout instance changes. */
+	reset() {
+		this.hasSnappedToEdge = false;
+		this.hadEstimatedVisibleItems = false;
+		this.wasNearAnchorEdge = false;
+	}
+	/**
+	* Captures the anchor from pre-layout view positions.
+	*/
+	captureBeforeLayout(anchorInfo, preLayoutInfos, visibleRect) {
+		if (!anchorInfo) return null;
+		return captureScrollAnchor(anchorInfo.edge, anchorInfo.axis, visibleRect, preLayoutInfos, anchorInfo.isAnchorable);
+	}
+	/**
+	* Runs the full post-layout decision: updates the tracked state for the next pass, and
+	* returns the resolved scroll target, or null if nothing should change.
+	*/
+	resolveAfterLayout(options) {
+		const { anchorInfo, anchor, postLayoutInfos, previousVisibleRect, previousContentSize, contentSize, itemSizeChanged, isScrolling, getLayoutInfo } = options;
+		if (!anchorInfo) return null;
+		const wasSettlingLastPass = this.hadEstimatedVisibleItems;
+		const wasNearAnchorEdgeLastPass = this.wasNearAnchorEdge;
+		let hasEstimated = false;
+		for (const layoutInfo of postLayoutInfos.values()) if (layoutInfo.estimatedSize) {
+			hasEstimated = true;
+			break;
+		}
+		this.hadEstimatedVisibleItems = hasEstimated;
+		if (!wasSettlingLastPass) this.wasNearAnchorEdge = isNearEdge(previousVisibleRect, previousContentSize, anchorInfo.edge, anchorInfo.axis, anchorInfo.threshold);
+		if (previousVisibleRect.area === 0) return null;
+		const dimension = anchorInfo.axis === "x" ? "width" : "height";
+		const contentSizeDelta = contentSize[dimension] - previousContentSize[dimension];
+		const isFirstAnchoredLayout = !this.hasSnappedToEdge;
+		this.hasSnappedToEdge = true;
+		if (!isFirstAnchoredLayout && contentSizeDelta === 0 && !itemSizeChanged) return null;
+		const wasNearAnchorEdge = isFirstAnchoredLayout || wasSettlingLastPass && wasNearAnchorEdgeLastPass || isNearEdge(previousVisibleRect, previousContentSize, anchorInfo.edge, anchorInfo.axis, anchorInfo.threshold);
+		if (!wasSettlingLastPass) this.wasNearAnchorEdge = wasNearAnchorEdge;
+		const effectiveAnchor = isFirstAnchoredLayout || wasSettlingLastPass && wasNearAnchorEdgeLastPass ? null : anchor;
+		return resolveScrollAdjustment(anchorInfo.edge, anchorInfo.axis, effectiveAnchor, wasNearAnchorEdge, isScrolling, itemSizeChanged, contentSizeDelta, getLayoutInfo, previousVisibleRect, contentSize);
+	}
+};
+export { ScrollAnchorTracker, captureScrollAnchor, computeScrollAnchorTarget, getEdgeSnapTarget, isNearEdge, resolveScrollAdjustment };
+
+//# sourceMappingURL=scroll-anchor.js.map

package/dist/virtualizer/scroll-anchor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"scroll-anchor.js","names":[],"sources":["../../src/virtualizer/scroll-anchor.ts"],"sourcesContent":["/*\n * Copyright 2026 Adobe. All rights reserved.\n * This file is licensed to you under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License. You may obtain a copy\n * of the License at http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under\n * the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n * OF ANY KIND, either express or implied. See the License for the specific language\n * governing permissions and limitations under the License.\n */\n/*\n * Derived from Adobe React Spectrum: packages/react-stately/src/virtualizer/ScrollAnchor.ts.\n * Modified for Solid Aria: adapted imports, collection descriptors, and reactive state APIs for Solid 2.\n * Licensed under Apache-2.0. See LICENSES/Apache-2.0.txt and NOTICE.txt at the repository root.\n */\n\nimport type { Key } from \"@solid2-aria/types-shared\";\n\nimport type { LayoutInfo } from \"./layout-info\";\nimport { Rect } from \"./rect\";\nimport type { RectCorner } from \"./rect\";\nimport type { Size } from \"./size\";\n\nexport type ScrollAnchorAxis = \"x\" | \"y\";\n\nexport type ScrollAnchorEdge = \"start\" | \"end\";\n\nexport interface ScrollAnchor {\n  key: Key;\n  corner: RectCorner;\n  offset: number;\n}\n\nexport interface ScrollAnchorInfo {\n  /** Which edge of the content the viewport should stay anchored to. */\n  edge: \"start\" | \"end\";\n  /** Which axis `edge` refers to — 'y' for vertical lists, 'x' for horizontal. */\n  axis: \"x\" | \"y\";\n  /** Distance (px) from `edge` within which the viewport is considered \"following\" it. */\n  threshold: number;\n  /**\n   * Optional classifier excluding structural/ephemeral layout infos (e.g. loaders) from being\n   * selected as the anchor. Defaults to allowing any layoutInfo.\n   */\n  isAnchorable?: (layoutInfo: LayoutInfo) => boolean;\n}\n\n/**\n * Minimum overlap an item must have with the viewport, along the scroll axis,\n * to be eligible as a scroll anchor. Without this, an item that only overlaps the viewport\n * by a sliver (e.g. 1px, essentially scrolled out of view) can still \"win\" the anchor\n * tie-break over a substantially visible item.\n */\nconst MIN_ANCHOR_OVERLAP = 4;\n\nfunction dimensionForAxis(axis: ScrollAnchorAxis): \"width\" | \"height\" {\n  return axis === \"x\" ? \"width\" : \"height\";\n}\n\n/**\n * Given a previously-captured anchor, computes the new viewport coordinate (along `axis`) needed\n * to keep it at the same offset from the viewport's start.\n */\nexport function computeScrollAnchorTarget(\n  anchor: ScrollAnchor,\n  axis: ScrollAnchorAxis,\n  getLayoutInfo: (key: Key) => LayoutInfo | null,\n  visibleRect: Rect,\n  contentSize: Size\n): number | null {\n  const finalInfo = getLayoutInfo(anchor.key);\n\n  if (!finalInfo) {\n    return null;\n  }\n\n  const adjustment =\n    finalInfo.rect[anchor.corner][axis] - visibleRect[axis] - anchor.offset;\n\n  if (adjustment === 0) {\n    return null;\n  }\n\n  const target = visibleRect[axis] + adjustment;\n  const dimension = dimensionForAxis(axis);\n  const max = Math.max(0, contentSize[dimension] - visibleRect[dimension]);\n  const clamped = Math.max(0, Math.min(max, target));\n\n  return clamped === visibleRect[axis] ? null : clamped;\n}\n\n/**\n * Picks the item to anchor scroll to: the one nearest the top of the viewport when\n * anchoring to 'end', or nearest the bottom when anchoring to 'start'. Callers can\n * exclude certain items (like loaders) with `isAnchorable`.\n */\nexport function captureScrollAnchor(\n  edge: ScrollAnchorEdge,\n  axis: ScrollAnchorAxis,\n  visibleRect: Rect,\n  visibleLayoutInfos: Iterable<[Key, LayoutInfo]>,\n  isAnchorable: (layoutInfo: LayoutInfo) => boolean = () => true\n): ScrollAnchor | null {\n  const dimension = dimensionForAxis(axis);\n  let best: ScrollAnchor | null = null;\n\n  for (const [key, layoutInfo] of visibleLayoutInfos) {\n    if (!isAnchorable(layoutInfo)) {\n      continue;\n    }\n\n    const overlap = layoutInfo.rect.intersection(visibleRect)[dimension];\n\n    if (layoutInfo.rect.area > 0 && overlap >= MIN_ANCHOR_OVERLAP) {\n      const corner = layoutInfo.rect.getCornerInRect(visibleRect) ?? \"topLeft\";\n      const offset = layoutInfo.rect[corner][axis] - visibleRect[axis];\n\n      const isBetter =\n        !best || (edge === \"end\" ? offset < best.offset : offset > best.offset);\n\n      if (isBetter) {\n        best = { corner, key, offset };\n      }\n    }\n  }\n\n  return best;\n}\n\n/** Returns the viewport coordinate (along `axis`) that pins the viewport to `edge` of the content. */\nexport function getEdgeSnapTarget(\n  edge: ScrollAnchorEdge,\n  axis: ScrollAnchorAxis,\n  contentSize: Size,\n  previousVisibleRect: Rect\n): number {\n  if (edge === \"start\") {\n    return 0;\n  }\n\n  const dimension = dimensionForAxis(axis);\n\n  return Math.max(0, contentSize[dimension] - previousVisibleRect[dimension]);\n}\n\n/**\n * Whether the viewport is currently within `threshold` px of the anchored edge — used by\n * Virtualizer to compute wasNearAnchorEdge generically, without any layout-specific state.\n */\nexport function isNearEdge(\n  visibleRect: Rect,\n  contentSize: Size,\n  edge: ScrollAnchorEdge,\n  axis: ScrollAnchorAxis,\n  threshold: number\n): boolean {\n  if (edge === \"start\") {\n    return visibleRect[axis] <= threshold;\n  }\n\n  const dimension = dimensionForAxis(axis);\n\n  const distanceFromEnd =\n    contentSize[dimension] - (visibleRect[axis] + visibleRect[dimension]);\n\n  return distanceFromEnd <= threshold;\n}\n\n/**\n * Works out the new scroll position after content changes. Tries to keep the anchor\n * item where it was. If that doesn't apply, sticks the view to the edge instead, but\n * only if the user was already near the edge and didn't just scroll away on their own.\n */\nexport function resolveScrollAdjustment(\n  edge: ScrollAnchorEdge,\n  axis: ScrollAnchorAxis,\n  anchor: ScrollAnchor | null,\n  wasNearAnchorEdge: boolean,\n  isScrolling: boolean,\n  itemSizeChanged: boolean,\n  contentSizeDelta: number,\n  getLayoutInfo: (key: Key) => LayoutInfo | null,\n  previousVisibleRect: Rect,\n  contentSize: Size\n): Rect | null {\n  const withTarget = (target: number): Rect =>\n    axis === \"x\"\n      ? new Rect(\n          target,\n          previousVisibleRect.y,\n          previousVisibleRect.width,\n          previousVisibleRect.height\n        )\n      : new Rect(\n          previousVisibleRect.x,\n          target,\n          previousVisibleRect.width,\n          previousVisibleRect.height\n        );\n\n  if (anchor) {\n    const target = computeScrollAnchorTarget(\n      anchor,\n      axis,\n      getLayoutInfo,\n      previousVisibleRect,\n      contentSize\n    );\n\n    if (target !== null && target !== undefined) {\n      return withTarget(target);\n    }\n  }\n\n  if (\n    wasNearAnchorEdge &&\n    !isScrolling &&\n    (!itemSizeChanged || contentSizeDelta > 0)\n  ) {\n    const target = withTarget(\n      getEdgeSnapTarget(edge, axis, contentSize, previousVisibleRect)\n    );\n\n    return target.equals(previousVisibleRect) ? null : target;\n  }\n\n  return null;\n}\n\nexport interface ResolveAfterLayoutOptions {\n  anchorInfo: ScrollAnchorInfo | null;\n  /** The anchor captured by `captureBeforeLayout` before this pass's `layout.update()` ran. */\n  anchor: ScrollAnchor | null;\n  /** The full post-layout visible layout infos, i.e. `virtualizer.getVisibleLayoutInfos()`. */\n  postLayoutInfos: Map<Key, LayoutInfo>;\n  previousVisibleRect: Rect;\n  previousContentSize: Size;\n  contentSize: Size;\n  itemSizeChanged: boolean;\n  isScrolling: boolean;\n  getLayoutInfo: (key: Key) => LayoutInfo | null;\n}\n\n/**\n * Tracks the cross-pass state needed to keep the viewport anchored to a layout's edge across\n * relayouts.\n */\nexport class ScrollAnchorTracker {\n  private hasSnappedToEdge = false;\n  private hadEstimatedVisibleItems = false;\n  private wasNearAnchorEdge = false;\n  /** Resets all tracked state, e.g. when the virtualizer's layout instance changes. */\n  reset(): void {\n    this.hasSnappedToEdge = false;\n    this.hadEstimatedVisibleItems = false;\n    this.wasNearAnchorEdge = false;\n  }\n  /**\n   * Captures the anchor from pre-layout view positions.\n   */\n  captureBeforeLayout(\n    anchorInfo: ScrollAnchorInfo | null,\n    preLayoutInfos: Iterable<[Key, LayoutInfo]>,\n    visibleRect: Rect\n  ): ScrollAnchor | null {\n    if (!anchorInfo) {\n      return null;\n    }\n\n    return captureScrollAnchor(\n      anchorInfo.edge,\n      anchorInfo.axis,\n      visibleRect,\n      preLayoutInfos,\n      anchorInfo.isAnchorable\n    );\n  }\n  /**\n   * Runs the full post-layout decision: updates the tracked state for the next pass, and\n   * returns the resolved scroll target, or null if nothing should change.\n   */\n  resolveAfterLayout(options: ResolveAfterLayoutOptions): Rect | null {\n    const {\n      anchorInfo,\n      anchor,\n      postLayoutInfos,\n      previousVisibleRect,\n      previousContentSize,\n      contentSize,\n      itemSizeChanged,\n      isScrolling,\n      getLayoutInfo,\n    } = options;\n\n    if (!anchorInfo) {\n      return null;\n    }\n\n    // Read the previous pass's state into locals before any writes below overwrite it.\n    const wasSettlingLastPass = this.hadEstimatedVisibleItems;\n    const wasNearAnchorEdgeLastPass = this.wasNearAnchorEdge;\n    let hasEstimated = false;\n\n    for (const layoutInfo of postLayoutInfos.values()) {\n      if (layoutInfo.estimatedSize) {\n        hasEstimated = true;\n        break;\n      }\n    }\n\n    this.hadEstimatedVisibleItems = hasEstimated;\n\n    // Don't recheck \"near edge?\" mid-resize because it could look like a scroll that never happened.\n    // Reuse the answer from before the resizing started.\n    if (!wasSettlingLastPass) {\n      this.wasNearAnchorEdge = isNearEdge(\n        previousVisibleRect,\n        previousContentSize,\n        anchorInfo.edge,\n        anchorInfo.axis,\n        anchorInfo.threshold\n      );\n    }\n\n    if (previousVisibleRect.area === 0) {\n      return null;\n    }\n\n    const dimension: \"width\" | \"height\" =\n      anchorInfo.axis === \"x\" ? \"width\" : \"height\";\n\n    const contentSizeDelta =\n      contentSize[dimension] - previousContentSize[dimension];\n\n    const isFirstAnchoredLayout = !this.hasSnappedToEdge;\n    this.hasSnappedToEdge = true;\n\n    // Only modify scroll when content actually changed (or this is the first layout, which always snaps)\n    if (!isFirstAnchoredLayout && contentSizeDelta === 0 && !itemSizeChanged) {\n      return null;\n    }\n\n    const wasNearAnchorEdge =\n      isFirstAnchoredLayout ||\n      (wasSettlingLastPass && wasNearAnchorEdgeLastPass) ||\n      isNearEdge(\n        previousVisibleRect,\n        previousContentSize,\n        anchorInfo.edge,\n        anchorInfo.axis,\n        anchorInfo.threshold\n      );\n\n    // A first-ever layout always snaps to the edge, even if the raw distance check says\n    // otherwise. Save that real decision here so later passes in this cascade reuse it.\n    if (!wasSettlingLastPass) {\n      this.wasNearAnchorEdge = wasNearAnchorEdge;\n    }\n\n    // Skip restoring to the captured anchor while still resizing because items above it are also still growing,\n    // and following it would fall short of the edge.\n    const effectiveAnchor =\n      isFirstAnchoredLayout ||\n      (wasSettlingLastPass && wasNearAnchorEdgeLastPass)\n        ? null\n        : anchor;\n\n    return resolveScrollAdjustment(\n      anchorInfo.edge,\n      anchorInfo.axis,\n      effectiveAnchor,\n      wasNearAnchorEdge,\n      isScrolling,\n      itemSizeChanged,\n      contentSizeDelta,\n      getLayoutInfo,\n      previousVisibleRect,\n      contentSize\n    );\n  }\n}\n"],"mappings":"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"}

package/dist/virtualizer/size.d.ts

@@ -0,0 +1,34 @@
+/*
+ * Copyright 2020 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+/*
+ * Derived from Adobe React Spectrum: packages/react-stately/src/virtualizer/Size.ts.
+ * Modified for Solid Aria: adapted imports, collection descriptors, and reactive state APIs for Solid 2.
+ * Licensed under Apache-2.0. See LICENSES/Apache-2.0.txt and NOTICE.txt at the repository root.
+ */
+export declare class Size {
+  width: number;
+  height: number;
+  constructor(width?: number, height?: number);
+  /**
+   * Returns a copy of this size.
+   */
+  copy(): Size;
+  /**
+   * Returns whether this size is equal to another one.
+   */
+  equals(other: Size): boolean;
+  /**
+   * The total area of the Size.
+   */
+  get area(): number;
+}
+//# sourceMappingURL=size.d.ts.map

package/dist/virtualizer/size.js

@@ -0,0 +1,46 @@
+/*
+ * Copyright 2020 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+/*
+ * Derived from Adobe React Spectrum: packages/react-stately/src/virtualizer/Size.ts.
+ * Modified for Solid Aria: adapted imports, collection descriptors, and reactive state APIs for Solid 2.
+ * Licensed under Apache-2.0. See LICENSES/Apache-2.0.txt and NOTICE.txt at the repository root.
+ */
+// src/virtualizer/size.ts
+var Size = class Size {
+	width;
+	height;
+	constructor(width = 0, height = 0) {
+		this.width = Math.max(width, 0);
+		this.height = Math.max(height, 0);
+	}
+	/**
+	* Returns a copy of this size.
+	*/
+	copy() {
+		return new Size(this.width, this.height);
+	}
+	/**
+	* Returns whether this size is equal to another one.
+	*/
+	equals(other) {
+		return this.width === other.width && this.height === other.height;
+	}
+	/**
+	* The total area of the Size.
+	*/
+	get area() {
+		return this.width * this.height;
+	}
+};
+export { Size };
+
+//# sourceMappingURL=size.js.map

package/dist/virtualizer/size.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"size.js","names":[],"sources":["../../src/virtualizer/size.ts"],"sourcesContent":["/*\n * Copyright 2020 Adobe. All rights reserved.\n * This file is licensed to you under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License. You may obtain a copy\n * of the License at http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under\n * the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n * OF ANY KIND, either express or implied. See the License for the specific language\n * governing permissions and limitations under the License.\n */\n/*\n * Derived from Adobe React Spectrum: packages/react-stately/src/virtualizer/Size.ts.\n * Modified for Solid Aria: adapted imports, collection descriptors, and reactive state APIs for Solid 2.\n * Licensed under Apache-2.0. See LICENSES/Apache-2.0.txt and NOTICE.txt at the repository root.\n */\n\nexport class Size {\n  width: number;\n  height: number;\n\n  constructor(width = 0, height = 0) {\n    this.width = Math.max(width, 0);\n    this.height = Math.max(height, 0);\n  }\n\n  /**\n   * Returns a copy of this size.\n   */\n  copy(): Size {\n    return new Size(this.width, this.height);\n  }\n\n  /**\n   * Returns whether this size is equal to another one.\n   */\n  equals(other: Size): boolean {\n    return this.width === other.width && this.height === other.height;\n  }\n\n  /**\n   * The total area of the Size.\n   */\n  get area(): number {\n    return this.width * this.height;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AAiBA,IAAa,OAAb,MAAa,KAAK;CAChB;CACA;CAEA,YAAY,QAAQ,GAAG,SAAS,GAAG;EACjC,KAAK,QAAQ,KAAK,IAAI,OAAO,CAAC;EAC9B,KAAK,SAAS,KAAK,IAAI,QAAQ,CAAC;CAClC;;;;CAKA,OAAa;EACX,OAAO,IAAI,KAAK,KAAK,OAAO,KAAK,MAAM;CACzC;;;;CAKA,OAAO,OAAsB;EAC3B,OAAO,KAAK,UAAU,MAAM,SAAS,KAAK,WAAW,MAAM;CAC7D;;;;CAKA,IAAI,OAAe;EACjB,OAAO,KAAK,QAAQ,KAAK;CAC3B;AACF"}

package/dist/virtualizer/types.d.ts

@@ -0,0 +1,47 @@
+/*
+ * Copyright 2020 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+/*
+ * Derived from Adobe React Spectrum: packages/react-stately/src/virtualizer/types.ts.
+ * Modified for Solid Aria: adapted imports, collection descriptors, and reactive state APIs for Solid 2.
+ * Licensed under Apache-2.0. See LICENSES/Apache-2.0.txt and NOTICE.txt at the repository root.
+ */
+import { Size } from "./size.js";
+import { Rect } from "./rect.js";
+import { Layout } from "./layout.js";
+import { Collection, Key } from "@solid2-aria/types-shared";
+export interface InvalidationContext<O = unknown> {
+  contentChanged?: boolean;
+  offsetChanged?: boolean;
+  sizeChanged?: boolean;
+  widthChanged?: boolean;
+  heightChanged?: boolean;
+  itemSizeChanged?: boolean;
+  layoutOptionsChanged?: boolean;
+  layoutOptions?: O;
+}
+export interface VirtualizerDelegate<T extends object, V> {
+  setVisibleRect: (rect: Rect) => void;
+  renderView: (type: string, content: T | null) => V;
+  invalidate: (ctx: InvalidationContext) => void;
+}
+export interface VirtualizerRenderOptions<T extends object, O = unknown> {
+  layout: Layout<T>;
+  collection: Collection<T>;
+  persistedKeys?: Set<Key> | null;
+  visibleRect: Rect;
+  size: Size;
+  invalidationContext: InvalidationContext;
+  isScrolling: boolean;
+  layoutOptions?: O;
+}
+export type Mutable<T> = { -readonly [P in keyof T]: T[P]; };
+//# sourceMappingURL=types.d.ts.map

package/dist/virtualizer/types.js

@@ -0,0 +1,16 @@
+/*
+ * Copyright 2020 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+/*
+ * Derived from Adobe React Spectrum: packages/react-stately/src/virtualizer/types.ts.
+ * Modified for Solid Aria: adapted imports, collection descriptors, and reactive state APIs for Solid 2.
+ * Licensed under Apache-2.0. See LICENSES/Apache-2.0.txt and NOTICE.txt at the repository root.
+ */

package/dist/virtualizer/utils.d.ts

@@ -0,0 +1,19 @@
+/*
+ * Copyright 2020 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+/*
+ * Derived from Adobe React Spectrum: packages/react-stately/src/virtualizer/utils.ts.
+ * Modified for Solid Aria: adapted imports, collection descriptors, and reactive state APIs for Solid 2.
+ * Licensed under Apache-2.0. See LICENSES/Apache-2.0.txt and NOTICE.txt at the repository root.
+ */
+/** Returns whether two sets are equal. */
+export declare function isSetEqual<T>(a: Set<T>, b: Set<T>): boolean;
+//# sourceMappingURL=utils.d.ts.map

package/dist/virtualizer/utils.js

@@ -0,0 +1,27 @@
+/*
+ * Copyright 2020 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+/*
+ * Derived from Adobe React Spectrum: packages/react-stately/src/virtualizer/utils.ts.
+ * Modified for Solid Aria: adapted imports, collection descriptors, and reactive state APIs for Solid 2.
+ * Licensed under Apache-2.0. See LICENSES/Apache-2.0.txt and NOTICE.txt at the repository root.
+ */
+// src/virtualizer/utils.ts
+/** Returns whether two sets are equal. */
+function isSetEqual(a, b) {
+	if (a === b) return true;
+	if (a.size !== b.size) return false;
+	for (const key of a) if (!b.has(key)) return false;
+	return true;
+}
+export { isSetEqual };
+
+//# sourceMappingURL=utils.js.map

package/dist/virtualizer/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","names":[],"sources":["../../src/virtualizer/utils.ts"],"sourcesContent":["/*\n * Copyright 2020 Adobe. All rights reserved.\n * This file is licensed to you under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License. You may obtain a copy\n * of the License at http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under\n * the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n * OF ANY KIND, either express or implied. See the License for the specific language\n * governing permissions and limitations under the License.\n */\n/*\n * Derived from Adobe React Spectrum: packages/react-stately/src/virtualizer/utils.ts.\n * Modified for Solid Aria: adapted imports, collection descriptors, and reactive state APIs for Solid 2.\n * Licensed under Apache-2.0. See LICENSES/Apache-2.0.txt and NOTICE.txt at the repository root.\n */\n\n/** Returns whether two sets are equal. */\nexport function isSetEqual<T>(a: Set<T>, b: Set<T>): boolean {\n  if (a === b) {\n    return true;\n  }\n\n  if (a.size !== b.size) {\n    return false;\n  }\n\n  for (const key of a) {\n    if (!b.has(key)) {\n      return false;\n    }\n  }\n\n  return true;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAkBA,SAAgB,WAAc,GAAW,GAAoB;CAC3D,IAAI,MAAM,GACR,OAAO;CAGT,IAAI,EAAE,SAAS,EAAE,MACf,OAAO;CAGT,KAAK,MAAM,OAAO,GAChB,IAAI,CAAC,EAAE,IAAI,GAAG,GACZ,OAAO;CAIX,OAAO;AACT"}

package/dist/virtualizer/virtualizer.d.ts

@@ -0,0 +1,99 @@
+/*
+ * Copyright 2020 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+/*
+ * Derived from Adobe React Spectrum: packages/react-stately/src/virtualizer/Virtualizer.ts.
+ * Modified for Solid Aria: adapted imports, collection descriptors, and reactive state APIs for Solid 2.
+ * Licensed under Apache-2.0. See LICENSES/Apache-2.0.txt and NOTICE.txt at the repository root.
+ */
+import { Point } from "./point.js";
+import { Size } from "./size.js";
+import { Rect } from "./rect.js";
+import { LayoutInfo } from "./layout-info.js";
+import { InvalidationContext, VirtualizerDelegate, VirtualizerRenderOptions } from "./types.js";
+import { ReusableView } from "./reusable-view.js";
+import { Layout } from "./layout.js";
+import { Collection, Key } from "@solid2-aria/types-shared";
+interface VirtualizerOptions<T extends object, V> {
+  delegate: VirtualizerDelegate<T, V>;
+  collection: Collection<T>;
+  layout: Layout<T>;
+}
+/**
+ * The Virtualizer class renders a scrollable collection of data using customizable layouts.
+ * It supports very large collections by only rendering visible views to the DOM, reusing
+ * them as you scroll. Virtualizer can present any type of view, including non-item views
+ * such as section headers and footers.
+ *
+ * Virtualizer uses `Layout` objects to compute what views should be visible, and how
+ * to position and style them. This means that virtualizer can have its items arranged in
+ * a stack, a grid, a circle, or any other layout you can think of. The layout can be changed
+ * dynamically at runtime as well.
+ *
+ * Layouts produce information on what views should appear in the virtualizer, but do not create the
+ * views themselves directly. It is the responsibility of the `VirtualizerDelegate` object to render
+ * elements for each layout info. The virtualizer manages a set of `ReusableView` objects, which are
+ * reused as the user scrolls by swapping their content with cached elements returned by the
+ * delegate.
+ */
+export declare class Virtualizer<T extends object, V> {
+  /**
+   * The virtualizer delegate. The delegate is used by the virtualizer
+   * to create and configure views.
+   */
+  delegate: VirtualizerDelegate<T, V>;
+  /** The current content of the virtualizer. */
+  private _collection;
+  get collection(): Collection<T>;
+  /** The layout object that determines the visible views. */
+  private _layout;
+  get layout(): Layout<T>;
+  /** The size of the scrollable content. */
+  private _contentSize;
+  get contentSize(): Size;
+  /** The currently visible rectangle. */
+  private _visibleRect;
+  get visibleRect(): Rect;
+  /** The size of the virtualizer scroll view. */
+  private _size;
+  get size(): Size;
+  /** The set of persisted keys that are always present in the DOM, even if not currently in view. */
+  private _persistedKeys;
+  get persistedKeys(): Set<Key>;
+  private readonly _visibleViews;
+  private readonly _renderedContent;
+  private readonly _rootView;
+  private _isScrolling;
+  private _invalidationContext;
+  private readonly _overscanManager;
+  private readonly _scrollAnchor;
+  constructor(options: VirtualizerOptions<T, V>);
+  /** Returns whether the given key, or an ancestor, is persisted. */
+  isPersistedKey(key: Key): boolean;
+  private getParentView;
+  private getReusableView;
+  private _renderView;
+  private _renderContent;
+  /**
+   * Returns the key for the item view currently at the given point.
+   */
+  keyAtPoint(point: Point): Key | null;
+  private relayout;
+  getVisibleLayoutInfos(): Map<Key, LayoutInfo>;
+  private updateSubviews;
+  /** Performs layout and updates visible views as needed. */
+  render(opts: VirtualizerRenderOptions<T>): ReusableView<T, V>[];
+  getVisibleView(key: Key): ReusableView<T, V> | undefined;
+  invalidate(context: InvalidationContext): void;
+  updateItemSize(key: Key, size: Size): void;
+}
+export {};
+//# sourceMappingURL=virtualizer.d.ts.map