@solid2-aria/stately 0.0.0-stage → 0.0.1

package/dist/layout/grid-layout.js

@@ -0,0 +1,253 @@
+/*
+ * Copyright 2024 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/layout/GridLayout.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 { getNodeProps } from "../utils/get-node-props.js";
+import { requireValue } from "../utils/require-value.js";
+import { Layout } from "../virtualizer/layout.js";
+import { LayoutInfo } from "../virtualizer/layout-info.js";
+import { Rect } from "../virtualizer/rect.js";
+import { Size } from "../virtualizer/size.js";
+// src/layout/grid-layout.ts
+const DEFAULT_OPTIONS = {
+	dropIndicatorThickness: 2,
+	loaderHeight: 48,
+	maxColumns: Infinity,
+	maxItemSize: new Size(Infinity, Infinity),
+	maxSpace: Infinity,
+	minItemSize: new Size(200, 200),
+	minSpace: new Size(18, 18),
+	preserveAspectRatio: false
+};
+/**
+* GridLayout is a virtualizer Layout implementation
+* that arranges its items in a grid.
+* The items are sized between a minimum and maximum size
+* depending on the width of the container.
+*/
+var GridLayout = class extends Layout {
+	gap = DEFAULT_OPTIONS.minSpace;
+	dropIndicatorThickness = 2;
+	numColumns = 0;
+	direction = "ltr";
+	contentSize = new Size();
+	layoutInfos = /* @__PURE__ */ new Map();
+	margin = 0;
+	shouldInvalidateLayoutOptions(newOptions, oldOptions) {
+		return newOptions.maxColumns !== oldOptions.maxColumns || newOptions.dropIndicatorThickness !== oldOptions.dropIndicatorThickness || newOptions.preserveAspectRatio !== oldOptions.preserveAspectRatio || !(newOptions.minItemSize ?? DEFAULT_OPTIONS.minItemSize).equals(oldOptions.minItemSize ?? DEFAULT_OPTIONS.minItemSize) || !(newOptions.maxItemSize ?? DEFAULT_OPTIONS.maxItemSize).equals(oldOptions.maxItemSize ?? DEFAULT_OPTIONS.maxItemSize) || !(newOptions.minSpace ?? DEFAULT_OPTIONS.minSpace).equals(oldOptions.minSpace ?? DEFAULT_OPTIONS.minSpace) || newOptions.maxHorizontalSpace !== oldOptions.maxHorizontalSpace || newOptions.loaderHeight !== oldOptions.loaderHeight || newOptions.direction !== oldOptions.direction;
+	}
+	update(invalidationContext) {
+		const measureGrid = () => {
+			const { minItemSize = DEFAULT_OPTIONS.minItemSize, maxItemSize = DEFAULT_OPTIONS.maxItemSize, preserveAspectRatio = DEFAULT_OPTIONS.preserveAspectRatio, minSpace = DEFAULT_OPTIONS.minSpace, maxHorizontalSpace = DEFAULT_OPTIONS.maxSpace, maxColumns = DEFAULT_OPTIONS.maxColumns, dropIndicatorThickness = DEFAULT_OPTIONS.dropIndicatorThickness, direction = "ltr" } = invalidationContext.layoutOptions ?? {};
+			const loaderHeight = invalidationContext.layoutOptions?.loaderHeight ?? DEFAULT_OPTIONS.loaderHeight;
+			this.dropIndicatorThickness = dropIndicatorThickness;
+			this.direction = direction;
+			const virtualizerWidth = this.attachedVirtualizer.size.width;
+			const maxItemWidth = Math.min(maxItemSize.width, virtualizerWidth);
+			const maxItemHeight = Number.isFinite(maxItemSize.height) ? maxItemSize.height : Math.floor(minItemSize.height / minItemSize.width * maxItemWidth);
+			const columns = Math.floor(virtualizerWidth / (minItemSize.width + minSpace.width));
+			const numColumns = Math.max(1, Math.min(maxColumns, columns));
+			this.numColumns = numColumns;
+			const width = virtualizerWidth - minSpace.width * Math.max(0, numColumns);
+			let itemWidth = Math.floor(width / numColumns);
+			itemWidth = Math.max(minItemSize.width, Math.min(maxItemWidth, itemWidth));
+			const t = (itemWidth - minItemSize.width) / Math.max(1, maxItemWidth - minItemSize.width);
+			let itemHeight = minItemSize.height + Math.floor((maxItemHeight - minItemSize.height) * t);
+			itemHeight = Math.max(minItemSize.height, Math.min(maxItemHeight, itemHeight));
+			const horizontalSpacing = Math.min(Math.max(maxHorizontalSpace, minSpace.width), Math.floor((virtualizerWidth - numColumns * itemWidth) / (numColumns + 1)));
+			this.gap = new Size(horizontalSpacing, minSpace.height);
+			this.margin = Math.floor((virtualizerWidth - numColumns * itemWidth - horizontalSpacing * (numColumns + 1)) / 2);
+			return {
+				horizontalSpacing,
+				itemHeight,
+				itemWidth,
+				loaderHeight,
+				minSpace,
+				numColumns,
+				preserveAspectRatio,
+				virtualizerWidth
+			};
+		};
+		const { virtualizerWidth, numColumns, itemWidth, itemHeight, horizontalSpacing, minSpace, preserveAspectRatio, loaderHeight: initialLoaderHeight } = measureGrid();
+		let loaderHeight = initialLoaderHeight;
+		const { collection } = this.attachedVirtualizer;
+		let collectionSize = collection.size;
+		let lastKey = collection.getLastKey();
+		for (let i = 0; i < 2 && lastKey !== null && lastKey !== void 0; i += 1) {
+			if (collection.getItem(lastKey)?.type === "skeleton") {
+				collectionSize += 1;
+				break;
+			}
+			lastKey = collection.getKeyBefore(lastKey);
+		}
+		let rows = Math.ceil(collectionSize / numColumns);
+		const iterator = collection[Symbol.iterator]();
+		let y = rows > 0 ? minSpace.height : 0;
+		const newLayoutInfos = /* @__PURE__ */ new Map();
+		let skeleton = null;
+		let skeletonCount = 0;
+		const buildRow = () => {
+			let maxHeight = 0;
+			const rowLayoutInfos = [];
+			for (let col = 0; col < numColumns; col += 1) {
+				const next = iterator.next();
+				const node = skeleton ?? (next.done === true ? void 0 : next.value);
+				if (!node) break;
+				if (node.type === "loader") continue;
+				if (node.type === "skeleton") skeleton = node;
+				const key = skeleton ? `${skeleton.key}-${skeletonCount}` : node.key;
+				if (skeleton) skeletonCount += 1;
+				const oldLayoutInfo = this.layoutInfos.get(key);
+				let content = node;
+				if (skeleton) content = oldLayoutInfo && oldLayoutInfo.content?.key === key ? oldLayoutInfo.content : {
+					...skeleton,
+					key
+				};
+				const x = horizontalSpacing + col * (itemWidth + horizontalSpacing) + this.margin;
+				let height = itemHeight;
+				let estimatedSize = !preserveAspectRatio;
+				if (oldLayoutInfo && estimatedSize) {
+					({height} = oldLayoutInfo.rect);
+					estimatedSize = invalidationContext.layoutOptionsChanged === true || invalidationContext.sizeChanged === true || oldLayoutInfo.estimatedSize || oldLayoutInfo.content !== content;
+				}
+				const rect = new Rect(x, y, itemWidth, height);
+				const layoutInfo = new LayoutInfo(node.type, key, rect);
+				layoutInfo.estimatedSize = estimatedSize;
+				layoutInfo.allowOverflow = true;
+				layoutInfo.content = content;
+				newLayoutInfos.set(key, layoutInfo);
+				rowLayoutInfos.push(layoutInfo);
+				maxHeight = Math.max(maxHeight, layoutInfo.rect.height);
+			}
+			for (const layoutInfo of rowLayoutInfos) layoutInfo.rect.height = maxHeight;
+			return maxHeight;
+		};
+		for (let row = 0; row < rows; row += 1) {
+			const maxHeight = buildRow();
+			y += maxHeight + minSpace.height;
+			if (skeleton !== null && row === rows - 1 && y < this.attachedVirtualizer.size.height) rows += 1;
+		}
+		const boundaryKey = collection.getLastKey();
+		const lastNode = boundaryKey === null ? null : collection.getItem(boundaryKey);
+		if (lastNode?.type === "loader") {
+			if (skeletonCount > 0 || !getNodeProps(lastNode).isLoading) loaderHeight = 0;
+			const loaderWidth = virtualizerWidth - horizontalSpacing * 2;
+			const rect = new Rect(horizontalSpacing, y, loaderWidth, loaderHeight);
+			const layoutInfo = new LayoutInfo("loader", lastNode.key, rect);
+			newLayoutInfos.set(lastNode.key, layoutInfo);
+			y = layoutInfo.rect.maxY;
+		}
+		this.layoutInfos = newLayoutInfos;
+		this.contentSize = new Size(this.attachedVirtualizer.size.width, y);
+	}
+	getLayoutInfo(key) {
+		return this.layoutInfos.get(key) ?? null;
+	}
+	getContentSize() {
+		return this.contentSize;
+	}
+	getVisibleLayoutInfos(rect) {
+		const layoutInfos = [];
+		for (const layoutInfo of this.layoutInfos.values()) if (layoutInfo.rect.intersects(rect) || this.attachedVirtualizer.isPersistedKey(layoutInfo.key) || layoutInfo.type === "loader") layoutInfos.push(layoutInfo);
+		return layoutInfos;
+	}
+	updateItemSize(key, size) {
+		const layoutInfo = this.layoutInfos.get(key);
+		if (!layoutInfo) return false;
+		if (size.height !== layoutInfo.rect.height) {
+			const newLayoutInfo = layoutInfo.copy();
+			newLayoutInfo.rect.height = size.height;
+			newLayoutInfo.estimatedSize = false;
+			this.layoutInfos.set(key, newLayoutInfo);
+			return true;
+		}
+		return false;
+	}
+	getDropTargetKey(x, y) {
+		let key = null;
+		if (this.numColumns === 1) {
+			const searchRect = new Rect(x, Math.max(0, y - this.gap.height), 1, Math.max(1, this.gap.height * 2));
+			const candidates = this.getVisibleLayoutInfos(searchRect);
+			let minDistance = Infinity;
+			for (const candidate of candidates) {
+				if (!candidate.rect.intersects(searchRect)) continue;
+				const yDist = Math.abs(candidate.rect.y - y);
+				const maxYDist = Math.abs(candidate.rect.maxY - y);
+				const dist = Math.min(yDist, maxYDist);
+				if (dist < minDistance) {
+					minDistance = dist;
+					({key} = candidate);
+				}
+			}
+		} else {
+			const searchRect = new Rect(Math.max(0, x - this.gap.width), y, this.gap.width * 2, 1);
+			const candidates = this.getVisibleLayoutInfos(searchRect);
+			let minDistance = Infinity;
+			for (const candidate of candidates) {
+				if (!candidate.rect.intersects(searchRect)) continue;
+				const xDist = Math.abs(candidate.rect.x - x);
+				const maxXDist = Math.abs(candidate.rect.maxX - x);
+				const dist = Math.min(xDist, maxXDist);
+				if (dist < minDistance) {
+					minDistance = dist;
+					({key} = candidate);
+				}
+			}
+		}
+		return key;
+	}
+	getDropTargetFromPoint(initialX, initialY, isValidDropTarget) {
+		let x = initialX;
+		let y = initialY;
+		if (this.layoutInfos.size === 0) return { type: "root" };
+		x += this.attachedVirtualizer.visibleRect.x;
+		y += this.attachedVirtualizer.visibleRect.y;
+		if (this.direction === "rtl" && this.numColumns > 1) x = this.contentSize.width - x;
+		const key = this.getDropTargetKey(x, y);
+		const layoutInfo = key === null || key === void 0 ? null : this.getLayoutInfo(key);
+		if (!layoutInfo) return { type: "root" };
+		const target = {
+			dropPosition: "on",
+			key: layoutInfo.key,
+			type: "item"
+		};
+		const pos = this.numColumns === 1 ? y : x;
+		const layoutInfoPos = this.numColumns === 1 ? layoutInfo.rect.y : layoutInfo.rect.x;
+		const size = this.numColumns === 1 ? layoutInfo.rect.height : layoutInfo.rect.width;
+		if (isValidDropTarget(target)) {
+			if (pos < layoutInfoPos + 5) target.dropPosition = "before";
+			else if (pos > layoutInfoPos + size - 5) target.dropPosition = "after";
+		} else {
+			const mid = layoutInfoPos + size / 2;
+			if (pos <= mid && isValidDropTarget({
+				...target,
+				dropPosition: "before"
+			})) target.dropPosition = "before";
+			else if (pos >= mid && isValidDropTarget({
+				...target,
+				dropPosition: "after"
+			})) target.dropPosition = "after";
+		}
+		return target;
+	}
+	getDropTargetLayoutInfo(target) {
+		const layoutInfo = requireValue(this.getLayoutInfo(target.key), "Drop targets must have layout information.");
+		const rect = this.numColumns === 1 ? new Rect(layoutInfo.rect.x, target.dropPosition === "before" ? layoutInfo.rect.y - this.gap.height / 2 - this.dropIndicatorThickness / 2 : layoutInfo.rect.maxY + this.gap.height / 2 - this.dropIndicatorThickness / 2, layoutInfo.rect.width, this.dropIndicatorThickness) : new Rect(target.dropPosition === "before" ? layoutInfo.rect.x - this.gap.width / 2 - this.dropIndicatorThickness / 2 : layoutInfo.rect.maxX + this.gap.width / 2 - this.dropIndicatorThickness / 2, layoutInfo.rect.y, this.dropIndicatorThickness, layoutInfo.rect.height);
+		return new LayoutInfo("dropIndicator", `${target.key}:${target.dropPosition}`, rect);
+	}
+};
+export { GridLayout };
+
+//# sourceMappingURL=grid-layout.js.map

package/dist/layout/grid-layout.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"grid-layout.js","names":[],"sources":["../../src/layout/grid-layout.ts"],"sourcesContent":["/*\n * Copyright 2024 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/layout/GridLayout.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 {\n  DropTarget,\n  DropTargetDelegate,\n  ItemDropTarget,\n  Key,\n  Node,\n} from \"@solid2-aria/types-shared\";\n\nimport { getNodeProps } from \"../utils/get-node-props\";\nimport { requireValue } from \"../utils/require-value\";\nimport { Layout } from \"../virtualizer/layout\";\nimport { LayoutInfo } from \"../virtualizer/layout-info\";\nimport { Rect } from \"../virtualizer/rect\";\nimport { Size } from \"../virtualizer/size\";\nimport type { InvalidationContext } from \"../virtualizer/types\";\n\nexport interface GridLayoutOptions {\n  /**\n   * The minimum item size.\n   *\n   * @default 200 x 200\n   */\n  minItemSize?: Size;\n  /**\n   * The maximum item size.\n   *\n   * @default Infinity\n   */\n  maxItemSize?: Size;\n  /**\n   * Whether to preserve the aspect ratio of the `minItemSize`.\n   * By default, grid rows may have variable heights. When `preserveAspectRatio`\n   * is true, all rows will have equal heights.\n   *\n   * @default false\n   */\n  preserveAspectRatio?: boolean;\n  /**\n   * The minimum space required between items.\n   *\n   * @default 18 x 18\n   */\n  minSpace?: Size;\n  /**\n   * The maximum allowed horizontal space between items.\n   *\n   * @default Infinity\n   */\n  maxHorizontalSpace?: number;\n  /**\n   * The maximum number of columns.\n   *\n   * @default Infinity\n   */\n  maxColumns?: number;\n  /**\n   * The thickness of the drop indicator.\n   *\n   * @default 2\n   */\n  dropIndicatorThickness?: number;\n  /**\n   * The fixed height of a loader element in px. This loader is specifically for \"load more\"\n   * elements rendered when loading more rows at the root level or inside nested row/sections.\n   *\n   * @default 48\n   */\n  loaderHeight?: number;\n  /**\n   * The layout direction. When `'rtl'`, drop target positions (`'before'`/`'after'`)\n   * are computed correctly for right-to-left locales in multi-column grids.\n   *\n   * @default 'ltr'\n   */\n  direction?: \"ltr\" | \"rtl\";\n}\n\nconst DEFAULT_OPTIONS = {\n  dropIndicatorThickness: 2,\n  loaderHeight: 48,\n  maxColumns: Infinity,\n  maxItemSize: new Size(Infinity, Infinity),\n  maxSpace: Infinity,\n  minItemSize: new Size(200, 200),\n  minSpace: new Size(18, 18),\n  preserveAspectRatio: false,\n};\n\n/**\n * GridLayout is a virtualizer Layout implementation\n * that arranges its items in a grid.\n * The items are sized between a minimum and maximum size\n * depending on the width of the container.\n */\nexport class GridLayout<T, O extends GridLayoutOptions = GridLayoutOptions>\n  extends Layout<Node<T>, O>\n  implements DropTargetDelegate\n{\n  protected gap: Size = DEFAULT_OPTIONS.minSpace;\n  protected dropIndicatorThickness = 2;\n  protected numColumns = 0;\n  protected direction: \"ltr\" | \"rtl\" = \"ltr\";\n  private contentSize: Size = new Size();\n  private layoutInfos = new Map<Key, LayoutInfo<Node<T>>>();\n  private margin = 0;\n  override shouldInvalidateLayoutOptions(\n    newOptions: O,\n    oldOptions: O\n  ): boolean {\n    return (\n      newOptions.maxColumns !== oldOptions.maxColumns ||\n      newOptions.dropIndicatorThickness !== oldOptions.dropIndicatorThickness ||\n      newOptions.preserveAspectRatio !== oldOptions.preserveAspectRatio ||\n      !(newOptions.minItemSize ?? DEFAULT_OPTIONS.minItemSize).equals(\n        oldOptions.minItemSize ?? DEFAULT_OPTIONS.minItemSize\n      ) ||\n      !(newOptions.maxItemSize ?? DEFAULT_OPTIONS.maxItemSize).equals(\n        oldOptions.maxItemSize ?? DEFAULT_OPTIONS.maxItemSize\n      ) ||\n      !(newOptions.minSpace ?? DEFAULT_OPTIONS.minSpace).equals(\n        oldOptions.minSpace ?? DEFAULT_OPTIONS.minSpace\n      ) ||\n      newOptions.maxHorizontalSpace !== oldOptions.maxHorizontalSpace ||\n      newOptions.loaderHeight !== oldOptions.loaderHeight ||\n      newOptions.direction !== oldOptions.direction\n    );\n  }\n  override update(invalidationContext: InvalidationContext<O>): void {\n    const measureGrid = () => {\n      const {\n        minItemSize = DEFAULT_OPTIONS.minItemSize,\n        maxItemSize = DEFAULT_OPTIONS.maxItemSize,\n        preserveAspectRatio = DEFAULT_OPTIONS.preserveAspectRatio,\n        minSpace = DEFAULT_OPTIONS.minSpace,\n        maxHorizontalSpace = DEFAULT_OPTIONS.maxSpace,\n        maxColumns = DEFAULT_OPTIONS.maxColumns,\n        dropIndicatorThickness = DEFAULT_OPTIONS.dropIndicatorThickness,\n        direction = \"ltr\" as const,\n      } = invalidationContext.layoutOptions ?? {};\n\n      const loaderHeight =\n        invalidationContext.layoutOptions?.loaderHeight ??\n        DEFAULT_OPTIONS.loaderHeight;\n\n      this.dropIndicatorThickness = dropIndicatorThickness;\n      this.direction = direction;\n      const virtualizerWidth = this.attachedVirtualizer.size.width;\n      // The max item width is always the entire viewport.\n      // If the max item height is infinity, scale in proportion to the max width.\n      const maxItemWidth = Math.min(maxItemSize.width, virtualizerWidth);\n\n      const maxItemHeight = Number.isFinite(maxItemSize.height)\n        ? maxItemSize.height\n        : Math.floor((minItemSize.height / minItemSize.width) * maxItemWidth);\n\n      // Compute the number of rows and columns needed to display the content\n      const columns = Math.floor(\n        virtualizerWidth / (minItemSize.width + minSpace.width)\n      );\n\n      const numColumns = Math.max(1, Math.min(maxColumns, columns));\n      this.numColumns = numColumns;\n      // Compute the available width (minus the space between items)\n      const width = virtualizerWidth - minSpace.width * Math.max(0, numColumns);\n      // Compute the item width based on the space available\n      let itemWidth = Math.floor(width / numColumns);\n      itemWidth = Math.max(\n        minItemSize.width,\n        Math.min(maxItemWidth, itemWidth)\n      );\n\n      // Compute the item height, which is proportional to the item width\n      const t =\n        (itemWidth - minItemSize.width) /\n        Math.max(1, maxItemWidth - minItemSize.width);\n\n      let itemHeight =\n        minItemSize.height +\n        Math.floor((maxItemHeight - minItemSize.height) * t);\n\n      itemHeight = Math.max(\n        minItemSize.height,\n        Math.min(maxItemHeight, itemHeight)\n      );\n\n      // Compute the horizontal spacing, content height and horizontal margin\n      const horizontalSpacing = Math.min(\n        Math.max(maxHorizontalSpace, minSpace.width),\n        Math.floor(\n          (virtualizerWidth - numColumns * itemWidth) / (numColumns + 1)\n        )\n      );\n\n      this.gap = new Size(horizontalSpacing, minSpace.height);\n      this.margin = Math.floor(\n        (virtualizerWidth -\n          numColumns * itemWidth -\n          horizontalSpacing * (numColumns + 1)) /\n          2\n      );\n\n      return {\n        horizontalSpacing,\n        itemHeight,\n        itemWidth,\n        loaderHeight,\n        minSpace,\n        numColumns,\n        preserveAspectRatio,\n        virtualizerWidth,\n      };\n    };\n\n    const {\n      virtualizerWidth,\n      numColumns,\n      itemWidth,\n      itemHeight,\n      horizontalSpacing,\n      minSpace,\n      preserveAspectRatio,\n      loaderHeight: initialLoaderHeight,\n    } = measureGrid();\n\n    let loaderHeight = initialLoaderHeight;\n    // If there is a skeleton loader within the last 2 items in the collection, increment the collection size\n    // so that an additional row is added for the skeletons.\n    const { collection } = this.attachedVirtualizer;\n    let collectionSize = collection.size;\n    let lastKey = collection.getLastKey();\n\n    for (\n      let i = 0;\n      i < 2 && lastKey !== null && lastKey !== undefined;\n      i += 1\n    ) {\n      const item = collection.getItem(lastKey);\n\n      if (item?.type === \"skeleton\") {\n        collectionSize += 1;\n        break;\n      }\n\n      lastKey = collection.getKeyBefore(lastKey);\n    }\n\n    let rows = Math.ceil(collectionSize / numColumns);\n    const iterator = collection[Symbol.iterator]();\n    let y = rows > 0 ? minSpace.height : 0;\n    const newLayoutInfos = new Map<Key, LayoutInfo<Node<T>>>();\n    let skeleton: Node<T> | null = null;\n    let skeletonCount = 0;\n\n    const buildRow = () => {\n      let maxHeight = 0;\n      const rowLayoutInfos: LayoutInfo[] = [];\n\n      for (let col = 0; col < numColumns; col += 1) {\n        // Repeat skeleton until the end of the current row.\n        const next = iterator.next();\n\n        const node: Node<T> | undefined =\n          skeleton ?? (next.done === true ? undefined : next.value);\n\n        if (!node) {\n          break;\n        }\n\n        // We will add the loader after the skeletons so skip here\n        if (node.type === \"loader\") {\n          continue;\n        }\n\n        if (node.type === \"skeleton\") {\n          skeleton = node;\n        }\n\n        const key = skeleton ? `${skeleton.key}-${skeletonCount}` : node.key;\n\n        if (skeleton) {\n          skeletonCount += 1;\n        }\n\n        const oldLayoutInfo = this.layoutInfos.get(key);\n        let content = node;\n\n        if (skeleton) {\n          content =\n            oldLayoutInfo && oldLayoutInfo.content?.key === key\n              ? oldLayoutInfo.content\n              : { ...skeleton, key };\n        }\n\n        const x =\n          horizontalSpacing +\n          col * (itemWidth + horizontalSpacing) +\n          this.margin;\n\n        let height = itemHeight;\n        let estimatedSize = !preserveAspectRatio;\n\n        if (oldLayoutInfo && estimatedSize) {\n          ({ height } = oldLayoutInfo.rect);\n          estimatedSize =\n            invalidationContext.layoutOptionsChanged === true ||\n            invalidationContext.sizeChanged === true ||\n            oldLayoutInfo.estimatedSize ||\n            oldLayoutInfo.content !== content;\n        }\n\n        const rect = new Rect(x, y, itemWidth, height);\n        const layoutInfo = new LayoutInfo<Node<T>>(node.type, key, rect);\n        layoutInfo.estimatedSize = estimatedSize;\n        layoutInfo.allowOverflow = true;\n        layoutInfo.content = content;\n        newLayoutInfos.set(key, layoutInfo);\n        rowLayoutInfos.push(layoutInfo);\n        maxHeight = Math.max(maxHeight, layoutInfo.rect.height);\n      }\n\n      for (const layoutInfo of rowLayoutInfos) {\n        layoutInfo.rect.height = maxHeight;\n      }\n\n      return maxHeight;\n    };\n\n    for (let row = 0; row < rows; row += 1) {\n      const maxHeight = buildRow();\n      y += maxHeight + minSpace.height;\n\n      // Keep adding skeleton rows until we fill the viewport\n      if (\n        skeleton !== null &&\n        row === rows - 1 &&\n        y < this.attachedVirtualizer.size.height\n      ) {\n        rows += 1;\n      }\n    }\n\n    // Always add the loader sentinel if present in the collection so we can make sure it is never virtualized out.\n    const boundaryKey = collection.getLastKey();\n\n    const lastNode =\n      boundaryKey === null ? null : collection.getItem(boundaryKey);\n\n    if (lastNode?.type === \"loader\") {\n      if (skeletonCount > 0 || !getNodeProps(lastNode).isLoading) {\n        loaderHeight = 0;\n      }\n\n      const loaderWidth = virtualizerWidth - horizontalSpacing * 2;\n      // Note that if the user provides isLoading to their sentinel during a case where they only want to render the emptyState, this will reserve\n      // room for the loader alongside rendering the emptyState\n      const rect = new Rect(horizontalSpacing, y, loaderWidth, loaderHeight);\n      const layoutInfo = new LayoutInfo<Node<T>>(\"loader\", lastNode.key, rect);\n      newLayoutInfos.set(lastNode.key, layoutInfo);\n      y = layoutInfo.rect.maxY;\n    }\n\n    this.layoutInfos = newLayoutInfos;\n    this.contentSize = new Size(this.attachedVirtualizer.size.width, y);\n  }\n  getLayoutInfo(key: Key): LayoutInfo | null {\n    return this.layoutInfos.get(key) ?? null;\n  }\n  getContentSize(): Size {\n    return this.contentSize;\n  }\n  getVisibleLayoutInfos(rect: Rect): LayoutInfo[] {\n    const layoutInfos: LayoutInfo[] = [];\n\n    for (const layoutInfo of this.layoutInfos.values()) {\n      if (\n        layoutInfo.rect.intersects(rect) ||\n        this.attachedVirtualizer.isPersistedKey(layoutInfo.key) ||\n        layoutInfo.type === \"loader\"\n      ) {\n        layoutInfos.push(layoutInfo);\n      }\n    }\n\n    return layoutInfos;\n  }\n  override updateItemSize(key: Key, size: Size): boolean {\n    const layoutInfo = this.layoutInfos.get(key);\n\n    if (!layoutInfo) {\n      return false;\n    }\n\n    if (size.height !== layoutInfo.rect.height) {\n      const newLayoutInfo = layoutInfo.copy();\n      newLayoutInfo.rect.height = size.height;\n      newLayoutInfo.estimatedSize = false;\n      this.layoutInfos.set(key, newLayoutInfo);\n\n      return true;\n    }\n\n    return false;\n  }\n  private getDropTargetKey(x: number, y: number): Key | null {\n    let key: Key | null = null;\n\n    if (this.numColumns === 1) {\n      const searchRect = new Rect(\n        x,\n        Math.max(0, y - this.gap.height),\n        1,\n        Math.max(1, this.gap.height * 2)\n      );\n\n      const candidates = this.getVisibleLayoutInfos(searchRect);\n      let minDistance = Infinity;\n\n      for (const candidate of candidates) {\n        // Ignore items outside the search rect, e.g. persisted keys.\n        if (!candidate.rect.intersects(searchRect)) {\n          continue;\n        }\n\n        const yDist = Math.abs(candidate.rect.y - y);\n        const maxYDist = Math.abs(candidate.rect.maxY - y);\n        const dist = Math.min(yDist, maxYDist);\n\n        if (dist < minDistance) {\n          minDistance = dist;\n          ({ key } = candidate);\n        }\n      }\n    } else {\n      const searchRect = new Rect(\n        Math.max(0, x - this.gap.width),\n        y,\n        this.gap.width * 2,\n        1\n      );\n\n      const candidates = this.getVisibleLayoutInfos(searchRect);\n      let minDistance = Infinity;\n\n      for (const candidate of candidates) {\n        // Ignore items outside the search rect, e.g. persisted keys.\n        if (!candidate.rect.intersects(searchRect)) {\n          continue;\n        }\n\n        const xDist = Math.abs(candidate.rect.x - x);\n        const maxXDist = Math.abs(candidate.rect.maxX - x);\n        const dist = Math.min(xDist, maxXDist);\n\n        if (dist < minDistance) {\n          minDistance = dist;\n          ({ key } = candidate);\n        }\n      }\n    }\n\n    return key;\n  }\n  getDropTargetFromPoint(\n    initialX: number,\n    initialY: number,\n    isValidDropTarget: (target: DropTarget) => boolean\n  ): DropTarget {\n    let x = initialX;\n\n    let y = initialY;\n\n    if (this.layoutInfos.size === 0) {\n      return { type: \"root\" };\n    }\n\n    x += this.attachedVirtualizer.visibleRect.x;\n    y += this.attachedVirtualizer.visibleRect.y;\n\n    // In RTL mode the virtualizer positions items using CSS `right` with the\n    // layout rect's x value as the right-offset, but pointer coordinates are\n    // in visual (left-origin) space. Flip x so it matches the layout coords.\n    if (this.direction === \"rtl\" && this.numColumns > 1) {\n      x = this.contentSize.width - x;\n    }\n\n    // Find the closest item within on either side of the point using the gap width.\n    const key = this.getDropTargetKey(x, y);\n\n    const layoutInfo =\n      key === null || key === undefined ? null : this.getLayoutInfo(key);\n\n    if (!layoutInfo) {\n      return { type: \"root\" };\n    }\n\n    const target: DropTarget = {\n      dropPosition: \"on\",\n      key: layoutInfo.key,\n      type: \"item\",\n    };\n\n    const pos = this.numColumns === 1 ? y : x;\n\n    const layoutInfoPos =\n      this.numColumns === 1 ? layoutInfo.rect.y : layoutInfo.rect.x;\n\n    const size =\n      this.numColumns === 1 ? layoutInfo.rect.height : layoutInfo.rect.width;\n\n    if (isValidDropTarget(target)) {\n      // If dropping on the item is accepted, try the before/after positions\n      // if within 5px of the start or end of the item.\n      if (pos < layoutInfoPos + 5) {\n        target.dropPosition = \"before\";\n      } else if (pos > layoutInfoPos + size - 5) {\n        target.dropPosition = \"after\";\n      }\n    } else {\n      // If dropping on the item isn't accepted, try the target before or after depending on the position.\n      const mid = layoutInfoPos + size / 2;\n\n      if (\n        pos <= mid &&\n        isValidDropTarget({ ...target, dropPosition: \"before\" })\n      ) {\n        target.dropPosition = \"before\";\n      } else if (\n        pos >= mid &&\n        isValidDropTarget({ ...target, dropPosition: \"after\" })\n      ) {\n        target.dropPosition = \"after\";\n      }\n    }\n\n    return target;\n  }\n  override getDropTargetLayoutInfo(target: ItemDropTarget): LayoutInfo {\n    const layoutInfo = requireValue(\n      this.getLayoutInfo(target.key),\n      \"Drop targets must have layout information.\"\n    );\n\n    const rect =\n      this.numColumns === 1\n        ? new Rect(\n            layoutInfo.rect.x,\n            target.dropPosition === \"before\"\n              ? layoutInfo.rect.y -\n                  this.gap.height / 2 -\n                  this.dropIndicatorThickness / 2\n              : layoutInfo.rect.maxY +\n                  this.gap.height / 2 -\n                  this.dropIndicatorThickness / 2,\n            layoutInfo.rect.width,\n            this.dropIndicatorThickness\n          )\n        : new Rect(\n            target.dropPosition === \"before\"\n              ? layoutInfo.rect.x -\n                  this.gap.width / 2 -\n                  this.dropIndicatorThickness / 2\n              : layoutInfo.rect.maxX +\n                  this.gap.width / 2 -\n                  this.dropIndicatorThickness / 2,\n            layoutInfo.rect.y,\n            this.dropIndicatorThickness,\n            layoutInfo.rect.height\n          );\n\n    return new LayoutInfo<Node<T>>(\n      \"dropIndicator\",\n      `${target.key}:${target.dropPosition}`,\n      rect\n    );\n  }\n}\n"],"mappings":"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"}

package/dist/layout/list-layout.d.ts

@@ -0,0 +1,187 @@
+/*
+ * 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/layout/ListLayout.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 "../virtualizer/size.js";
+import { Rect } from "../virtualizer/rect.js";
+import { LayoutInfo } from "../virtualizer/layout-info.js";
+import { InvalidationContext } from "../virtualizer/types.js";
+import { Layout } from "../virtualizer/layout.js";
+import { Collection, DropTarget, DropTargetDelegate, ItemDropTarget, Key, Node, Orientation } from "@solid2-aria/types-shared";
+export interface ListLayoutOptions {
+  /**
+   * The primary orientation of the items. Usually this is the direction that the collection
+   * scrolls.
+   *
+   * @default 'vertical'
+   */
+  orientation?: Orientation;
+  /**
+   * The fixed size of a row in px with respect to the applied orientation.
+   *
+   * @default 48
+   */
+  rowSize?: number;
+  /**
+   * The estimated size of a row in px with respect to the applied orientation, when row sizes are
+   * variable.
+   */
+  estimatedRowSize?: number;
+  /**
+   * The fixed size of a section header in px with respect to the applied orientation.
+   *
+   * @default 48
+   */
+  headingSize?: number;
+  /**
+   * The estimated size of a section header in px with respect to the applied orientation, when
+   * heading sizes are variable.
+   */
+  estimatedHeadingSize?: number;
+  /**
+   * The fixed size of a loader element in px with respect to the applied orientation. This loader
+   * is specifically for "load more" elements rendered when loading more rows at the root level or
+   * inside nested row/sections.
+   *
+   * @default 48
+   */
+  loaderSize?: number;
+  /**
+   * The thickness of the drop indicator.
+   *
+   * @default 2
+   */
+  dropIndicatorThickness?: number;
+  /**
+   * The gap between items.
+   *
+   * @default 0
+   */
+  gap?: number;
+  /**
+   * The padding around the list.
+   *
+   * @default 0
+   */
+  padding?: number;
+  /**
+   * The fixed height of a row in px.
+   *
+   * @deprecated Use `rowSize` instead.
+   * @default 48
+   */
+  rowHeight?: number;
+  /**
+   * The estimated height of a row, when row heights are variable.
+   *
+   * @deprecated Use `estimatedRowSize` instead.
+   */
+  estimatedRowHeight?: number;
+  /**
+   * The fixed height of a section header in px.
+   *
+   * @deprecated Use `headingSize` instead.
+   * @default 48
+   */
+  headingHeight?: number;
+  /**
+   * The estimated height of a section header, when the height is variable.
+   *
+   * @deprecated Use `estimatedHeadingSize` instead.
+   */
+  estimatedHeadingHeight?: number;
+  /**
+   * The fixed height of a loader element in px. This loader is specifically for "load more"
+   * elements rendered when loading more rows at the root level or inside nested row/sections.
+   *
+   * @deprecated Use `loaderSize` instead.
+   * @default 48
+   */
+  loaderHeight?: number;
+}
+export interface LayoutNode {
+  node?: Node<unknown>;
+  layoutInfo: LayoutInfo;
+  children?: LayoutNode[];
+  validRect: Rect;
+  index?: number;
+}
+/**
+ * ListLayout is a virtualizer Layout implementation
+ * that arranges its items in a stack along its applied orientation.
+ * It supports both fixed and variable size items.
+ */
+export declare class ListLayout<T, O extends ListLayoutOptions = ListLayoutOptions> extends Layout<Node<T>, O> implements DropTargetDelegate {
+  protected rowSize: number | null;
+  protected orientation: Orientation;
+  protected estimatedRowSize: number | null;
+  protected headingSize: number | null;
+  protected estimatedHeadingSize: number | null;
+  protected loaderSize: number | null;
+  protected dropIndicatorThickness: number;
+  protected gap: number;
+  protected padding: number;
+  protected layoutNodes: Map<Key, LayoutNode>;
+  protected contentSize: Size;
+  protected lastCollection: Collection<Node<T>> | null;
+  protected rootNodes: LayoutNode[];
+  private invalidateEverything;
+  /** The rectangle containing currently valid layout infos. */
+  protected validRect: Rect;
+  /** The rectangle of requested layout infos so far. */
+  protected requestedRect: Rect;
+  /**
+   * Creates a new ListLayout with options. See the list of properties below for a description
+   * of the options that can be provided.
+   */
+  constructor(initialOptions?: ListLayoutOptions);
+  protected get collection(): Collection<Node<T>>;
+  /** @deprecated Use `rowSize` instead. */
+  protected get rowHeight(): number | null;
+  /** @deprecated Use `estimatedRowSize` instead. */
+  protected get estimatedRowHeight(): number | null;
+  /** @deprecated Use `headingSize` instead. */
+  protected get headingHeight(): number | null;
+  /** @deprecated Use `estimatedHeadingSize` instead. */
+  protected get estimatedHeadingHeight(): number | null;
+  /** @deprecated Use `loaderSize` instead. */
+  protected get loaderHeight(): number | null;
+  getLayoutInfo(key: Key): LayoutInfo | null;
+  getVisibleLayoutInfos(initialRect: Rect): LayoutInfo[];
+  protected layoutIfNeeded(rect: Rect): void;
+  private ensureLayoutInfo;
+  protected isVisible(node: LayoutNode, rect: Rect): boolean;
+  protected shouldInvalidateEverything(invalidationContext: InvalidationContext<O>): boolean;
+  shouldInvalidateLayoutOptions(initialNewOptions: O, initialOldOptions: O): boolean;
+  update(invalidationContext: InvalidationContext<O>): void;
+  private updateOptions;
+  protected buildCollection(initialOffset?: number): LayoutNode[];
+  protected isValid(node: Node<T>, offset: number): boolean;
+  protected buildChild(node: Node<T>, x: number, y: number, parentKey: Key | null): LayoutNode;
+  protected buildNode(node: Node<T>, x: number, y: number): LayoutNode;
+  protected buildLoader(node: Node<T>, x: number, y: number): LayoutNode;
+  protected buildSection(node: Node<T>, x: number, y: number): LayoutNode;
+  protected buildSectionHeader(node: Node<T>, x: number, y: number): LayoutNode;
+  protected buildItem(node: Node<T>, x: number, y: number): LayoutNode;
+  updateItemSize(key: Key, size: Size): boolean;
+  private updateLayoutNode;
+  getContentSize(): Size;
+  private getNearestDropKey;
+  getDropTargetFromPoint(initialX: number, initialY: number, isValidDropTarget: (target: DropTarget) => boolean): DropTarget | null;
+  getDropTargetLayoutInfo(target: ItemDropTarget): LayoutInfo;
+}
+/** Normalizes legacy height options once at the layout boundary. Modern values take precedence. */
+export declare function normalizeListLayoutOptions(options: ListLayoutOptions): ListLayoutOptions;
+//# sourceMappingURL=list-layout.d.ts.map