@botiverse/raft-ui 0.51.0 → 0.52.0

package/dist/components/virtual-list/utils/measure.mjs

@@ -0,0 +1,77 @@
+//#region src/components/virtual-list/utils/measure.ts
+/**
+* Where each in-flow row starts in the visible-items element `container`, and where the rows end: in one
+* pass of reads, no writes, so the browser lays out at most once.
+*
+* `starts[i]` is the top of the border box of `rows[i]` (in document order), relative to the container's
+* padding edge; `end` is the container's inner height. The container is a block formatting context
+* (`display: flow-root`, see `constants.ts`) and `position: relative`, so it is the rows' offsetParent, the
+* first row's top margin and the last row's bottom margin stay inside it, and between two rows sits their
+* collapsed margin, whatever the consumer's CSS (a child's margins collapsing through a row included).
+*
+* Read from the boxes' rects (sub-pixel, so a span does not change with the rounding of its position), but
+* checked against the layout's own `offsetTop` / `clientHeight` (whole pixels, and blind to transforms):
+* where they disagree by more than a pixel, a transform is at work (the row's own, say an entrance
+* animation, or a scale on an ancestor, say a dialog zooming in) and the layout's value is used, since
+* the rows are laid out, and measured again on resize, without it.
+*
+* A row that is not laid out (`display: none`, so no offsetParent) takes no space: it starts where the
+* next one does.
+*/
+function measureRowStarts(container, rows) {
+	const frame = readFrame(container);
+	const starts = rows.map((row) => readRowStart(frame, row));
+	let next = frame.end;
+	for (let i = starts.length - 1; i >= 0; --i) next = starts[i] ??= next;
+	return {
+		starts,
+		end: frame.end
+	};
+}
+/** Where `row` starts in `container` (see `measureRowStarts`); 0 when it is not laid out. */
+function measureRowStart(container, row) {
+	return readRowStart(readFrame(container), row) ?? 0;
+}
+function readFrame(container) {
+	const rect = container.getBoundingClientRect();
+	const layoutHeight = container.offsetHeight;
+	const scaled = Math.abs(rect.height - layoutHeight) > 1;
+	const borderY = layoutHeight - container.clientHeight;
+	return {
+		container,
+		scaled,
+		innerTop: rect.top + container.clientTop,
+		end: scaled ? container.clientHeight : toLayoutUnit(rect.height - borderY)
+	};
+}
+function readRowStart({ container, scaled, innerTop }, row) {
+	if (row.offsetParent !== container) return null;
+	const layoutTop = row.offsetTop;
+	if (scaled) return layoutTop;
+	const rectTop = toLayoutUnit(row.getBoundingClientRect().top - innerTop);
+	return Math.abs(rectTop - layoutTop) > 1 ? layoutTop : rectTop;
+}
+/**
+* The space each of `rows` takes: from where it starts to where the next one starts, the last one to the
+* end of the rows (see `measureRowStarts`). So the collapsed margin between two rows belongs to the upper
+* one, and the spans add up to the rows' laid-out height from the first row's border box on. `firstStart`
+* is where the first row starts (its top margin, plus the margins of its first children that collapse
+* through it): space before the rows that no span holds (the list keeps it apart, see VirtualList's
+* `leadingMarginRef` and `applyLayoutStyles`).
+*/
+function measureRowSpans(container, rows) {
+	const { starts, end } = measureRowStarts(container, rows);
+	return {
+		spans: starts.map((start, i) => (i + 1 < starts.length ? starts[i + 1] : end) - start),
+		firstStart: starts[0] ?? 0
+	};
+}
+/**
+* Rounded to 1/64px, the unit browsers lay out in: rect differences carry floating-point noise (with page
+* zoom), and a size that differs from the cached one by noise alone would count as a resize.
+*/
+function toLayoutUnit(value) {
+	return Math.round(value * 64) / 64;
+}
+//#endregion
+export { measureRowSpans, measureRowStart, measureRowStarts };

package/dist/components/virtual-list/utils/platform.mjs

@@ -0,0 +1,39 @@
+/**
+* An iPhone, iPad or iPod, or an iPad that reports itself as a Mac with touch points
+* (`navigator.platform` is deprecated, but it still tells iPadOS from macOS here).
+*/
+const isIOS = !!(typeof document !== "undefined" && typeof window !== "undefined") && (/iPad|iPhone|iPod/.test(navigator.platform) || navigator.platform === "MacIntel" && navigator.maxTouchPoints > 1) && !window.MSStream;
+let coarsePointerCache;
+let devicePixelRatioCache;
+/** Whether the primary pointer is coarse (a touch screen); read once. */
+function isCoarsePointer() {
+	if (coarsePointerCache === void 0) coarsePointerCache = "matchMedia" in window && window.matchMedia("(pointer:coarse)").matches;
+	return coarsePointerCache;
+}
+/**
+* What wheel deltas are divided by: `devicePixelRatio` in Chromium (`"chrome" in window`), else 1;
+* read once.
+*/
+function getWheelDeltaScale() {
+	if (typeof document === "undefined") return 1;
+	if (devicePixelRatioCache === void 0) devicePixelRatioCache = "chrome" in window ? window.devicePixelRatio : 1;
+	return devicePixelRatioCache;
+}
+/**
+* Makes a runner that runs a callback in the next animation frame. Each runner requests one frame at
+* a time: a callback given before it fires replaces the previous one. One per list, so lists never
+* replace each other's callbacks.
+*/
+function createLatestInNextFrame() {
+	let nextFrameCallback;
+	let nextFrameHandle;
+	return (callback) => {
+		nextFrameCallback = callback;
+		if (nextFrameHandle === void 0) nextFrameHandle = requestAnimationFrame(() => {
+			nextFrameHandle = void 0;
+			nextFrameCallback?.();
+		});
+	};
+}
+//#endregion
+export { createLatestInNextFrame, getWheelDeltaScale, isCoarsePointer, isIOS };

package/dist/components/virtual-list/utils/range.mjs

@@ -0,0 +1,103 @@
+//#region src/components/virtual-list/utils/range.ts
+/**
+* The items to render: from the item at `scrollTop - paddingTop` through as many items as fit in
+* `listHeight` at their minimum size, plus one (the overscan is `getOverscannedRange`'s). Empty
+* (`0..-1`) before the list has been
+* measured or when there are no items.
+*/
+function getVerticalRange({ fenwickTree, scrollTop, listHeight, itemMinSize, itemCount, paddingTop }) {
+	if (listHeight === void 0 || itemCount === 0) return {
+		startIndex: 0,
+		endIndex: -1
+	};
+	const startIndex = Math.max(fenwickTree.getBound(scrollTop - paddingTop), 0);
+	return {
+		startIndex,
+		endIndex: Math.min(startIndex + Math.ceil(listHeight / itemMinSize + 1), itemCount - 1)
+	};
+}
+const OVERSCAN_MIN = .25;
+const OVERSCAN_TARGET = 1;
+const OVERSCAN_MAX = 2.5;
+const OVERSCAN_BELOW = .25;
+/**
+* The last row needed to fill the view from row `startIndex` down: measured rows (`isMeasured`) count at
+* their size, the others at `itemMinSize`, so the view is filled whatever the unmeasured rows turn out
+* to be. `viewTop` is the view's top in item offsets.
+*/
+function getNeededEnd({ fenwickTree, startIndex, viewTop, listHeight, itemMinSize, itemCount, isMeasured }) {
+	const bottom = viewTop + listHeight;
+	let offset = fenwickTree.sum(startIndex);
+	let index = startIndex;
+	for (; index < itemCount - 1; ++index) {
+		offset += isMeasured(index) ? fenwickTree.get(index) : Math.max(itemMinSize, 1);
+		if (offset >= bottom) break;
+	}
+	return index;
+}
+/**
+* The items to render with overscan (see above), from the range in view (`view`, as `getVerticalRange`
+* gives it), the last row needed to fill the view (`neededEnd`) and the rendered range (`prev`).
+* `viewTop` is the view's top in item offsets, `moved` how far it moved since the last range update,
+* `movingUp` whether it last moved up, `settling` whether a jump is settling, `plannedSize` the size a
+* row is counted at when planning how many rows to mount above the view. With a `listHeight` of 0
+* (not laid out) there is no overscan: `view` is returned.
+*/
+function getOverscannedRange({ fenwickTree, view, prev, neededEnd, viewTop, moved, movingUp, settling, plannedSize, listHeight, itemCount }) {
+	const last = itemCount - 1;
+	const min = OVERSCAN_MIN * listHeight;
+	const target = OVERSCAN_TARGET * listHeight;
+	const max = OVERSCAN_MAX * listHeight;
+	const apart = view.startIndex > prev.endIndex || view.endIndex < prev.startIndex;
+	if (listHeight <= 0 || view.endIndex < view.startIndex || prev.endIndex < prev.startIndex || prev.endIndex > last || moved > max || apart && moved === 0) return view;
+	let ahead = view.startIndex;
+	for (let above = viewTop - fenwickTree.sum(ahead); ahead > 0 && above < target;) {
+		ahead -= 1;
+		above += plannedSize(ahead);
+	}
+	let startIndex = prev.startIndex;
+	if (prev.startIndex > view.startIndex) startIndex = movingUp && !settling ? ahead : view.startIndex;
+	else if (!settling) {
+		const above = viewTop - fenwickTree.sum(prev.startIndex);
+		if (movingUp ? above < min : above > max) startIndex = movingUp ? Math.min(ahead, prev.startIndex) : ahead;
+	}
+	const needed = Math.min(neededEnd, view.endIndex);
+	const neededBottom = fenwickTree.sum(needed + 1);
+	let endIndex = prev.endIndex;
+	if (prev.endIndex < needed || movingUp && !settling && fenwickTree.sum(prev.endIndex + 1) - neededBottom > max) endIndex = Math.min(Math.max(fenwickTree.getBound(neededBottom + OVERSCAN_BELOW * listHeight), needed), last);
+	return {
+		startIndex,
+		endIndex
+	};
+}
+/** The columns to render: the ones in `scrollLeft .. scrollLeft + listWidth`, plus one on each side. */
+function getHorizontalRange({ xFenwickTree, scrollLeft, listWidth, columnCount }) {
+	if (xFenwickTree === null || columnCount === 0) return {
+		startIndex: 0,
+		endIndex: 0
+	};
+	else return {
+		startIndex: Math.max(xFenwickTree.getBound(scrollLeft) - 1, 0),
+		endIndex: Math.min(xFenwickTree.getBound(scrollLeft + listWidth) + 1, columnCount - 1)
+	};
+}
+/** Whether `a` and `b` have the same length and every key of `a` is in `b`. */
+function haveSameKeys(a, b) {
+	if (a.length !== b.length) return false;
+	for (const key of a) if (!b.includes(key)) return false;
+	return true;
+}
+/** Whether `el` or one of its ancestors is hidden with an inline `display: none`. */
+function isHiddenByDisplayNone(el) {
+	let current = el;
+	while (current !== null) {
+		if (current.style.display === "none") return true;
+		current = current.parentElement;
+	}
+	return false;
+}
+function px(value) {
+	if (value !== void 0) return `${value}px`;
+}
+//#endregion
+export { getHorizontalRange, getNeededEnd, getOverscannedRange, getVerticalRange, haveSameKeys, isHiddenByDisplayNone, px };

package/dist/components/virtual-list/utils/size-cache.mjs

@@ -0,0 +1,35 @@
+//#region src/components/virtual-list/utils/size-cache.ts
+/**
+* Records `size` as the measured size of row `key` in `offsets`, kept even when it equals the estimate
+* (an offset of 0), so the row counts as measured. Returns whether the cache changed.
+*/
+function recordMeasuredSize(offsets, key, size, itemEstimatedSize) {
+	const offset = size - itemEstimatedSize;
+	if (offsets.get(key) === offset) return false;
+	offsets.set(key, offset);
+	return true;
+}
+function createTypicalSizeCache() {
+	return {
+		version: -1,
+		itemEstimatedSize: NaN,
+		size: 0
+	};
+}
+/**
+* The size rows typically are: the mean size of the measured rows (`offsets`), or `itemEstimatedSize`
+* before any is measured, and at least `itemMinSize` (and 1). Kept in `cache` and computed again only
+* when `version` (bumped whenever `offsets` changes) or `itemEstimatedSize` changes.
+*/
+function getTypicalSize(cache, offsets, version, itemEstimatedSize, itemMinSize) {
+	if (cache.version !== version || cache.itemEstimatedSize !== itemEstimatedSize) {
+		let total = 0;
+		for (const offset of offsets.values()) total += offset;
+		cache.size = itemEstimatedSize + (offsets.size === 0 ? 0 : total / offsets.size);
+		cache.version = version;
+		cache.itemEstimatedSize = itemEstimatedSize;
+	}
+	return Math.max(cache.size, itemMinSize, 1);
+}
+//#endregion
+export { createTypicalSizeCache, getTypicalSize, recordMeasuredSize };

package/dist/components/workspace-button/index.d.mts

@@ -0,0 +1,2 @@
+import { WorkspaceButton, WorkspaceButtonName, WorkspaceButtonNameProps, WorkspaceButtonProps } from "./workspace-button.mjs";
+export { WorkspaceButton, WorkspaceButtonName, type WorkspaceButtonNameProps, type WorkspaceButtonProps };

package/dist/components/workspace-button/workspace-button.d.mts

@@ -0,0 +1,9 @@
+import { ButtonProps } from "../button/button.mjs";
+import "../button/index.mjs";
+import { ComponentPropsWithRef } from "react";
+//#region src/components/workspace-button/workspace-button.d.ts
+export type WorkspaceButtonProps = Omit<ButtonProps, "variant" | "size">;
+export declare function WorkspaceButton({ className, children, ...props }: WorkspaceButtonProps): import("react").JSX.Element;
+export type WorkspaceButtonNameProps = ComponentPropsWithRef<"span">;
+export declare function WorkspaceButtonName({ className, ...props }: WorkspaceButtonNameProps): import("react").JSX.Element;
+//#endregion

package/dist/components/workspace-button/workspace-button.mjs

@@ -0,0 +1,28 @@
+import { cn } from "../../cn.mjs";
+import { Button } from "../button/button.mjs";
+import { ChevronDown } from "lucide-react";
+import { jsx, jsxs } from "react/jsx-runtime";
+//#region src/components/workspace-button/workspace-button.tsx
+function WorkspaceButton({ className, children, ...props }) {
+	return /* @__PURE__ */ jsxs(Button, {
+		...props,
+		variant: "on-frame",
+		size: "md",
+		"data-slot": "workspace-button",
+		className: cn("max-w-full min-w-0 shrink justify-start gap-2", "*:data-[slot=button-content]:max-w-full [&>[data-slot=button-content]]:min-w-0", className),
+		children: [children, /* @__PURE__ */ jsx(ChevronDown, {
+			"aria-hidden": true,
+			"data-slot": "workspace-button-chevron",
+			className: "-ml-1 size-4 shrink-0"
+		})]
+	});
+}
+function WorkspaceButtonName({ className, ...props }) {
+	return /* @__PURE__ */ jsx("span", {
+		"data-slot": "workspace-button-name",
+		className: cn("max-w-[200px] min-w-0 truncate", className),
+		...props
+	});
+}
+//#endregion
+export { WorkspaceButton, WorkspaceButtonName };