@parallelworks/ui 0.18.0 → 0.19.1

package/dist/file-explorer/FilePreview/readCappedBytes.js

@@ -0,0 +1,196 @@
+//#region src/file-explorer/FilePreview/readCappedBytes.ts
+/** Read a Response body but stop once it passes `maxBytes` (returning `tooLarge`), so an object whose listed size is missing or under-reported can't be pulled fully into the tab. */
+async function readCappedBytes(response, maxBytes) {
+	const reader = response.body?.getReader();
+	if (!reader) {
+		const header = response.headers.get("content-length");
+		const declared = header === null ? NaN : Number(header);
+		if (!Number.isFinite(declared) || declared > maxBytes) return {
+			bytes: /* @__PURE__ */ new Uint8Array(0),
+			tooLarge: true
+		};
+		const buffer = new Uint8Array(await response.arrayBuffer());
+		return buffer.byteLength > maxBytes ? {
+			bytes: /* @__PURE__ */ new Uint8Array(0),
+			tooLarge: true
+		} : {
+			bytes: buffer,
+			tooLarge: false
+		};
+	}
+	const chunks = [];
+	let total = 0;
+	for (let chunk = await reader.read(); !chunk.done; chunk = await reader.read()) {
+		total += chunk.value.byteLength;
+		if (total > maxBytes) {
+			await reader.cancel();
+			return {
+				bytes: /* @__PURE__ */ new Uint8Array(0),
+				tooLarge: true
+			};
+		}
+		chunks.push(chunk.value);
+	}
+	const bytes = new Uint8Array(total);
+	let offset = 0;
+	for (const chunk of chunks) {
+		bytes.set(chunk, offset);
+		offset += chunk.byteLength;
+	}
+	return {
+		bytes,
+		tooLarge: false
+	};
+}
+function countNewlines(text) {
+	let count = 0;
+	for (let i = 0; i < text.length; i++) if (text[i] === "\n") count++;
+	return count;
+}
+/** Lines a preview will render; a trailing newline doesn't open another line. */
+function countLines(text) {
+	if (text === "") return 0;
+	return countNewlines(text) + (text.endsWith("\n") ? 0 : 1);
+}
+function capLines(text, maxLines) {
+	if (maxLines === void 0) return text;
+	let count = 0;
+	for (let i = 0; i < text.length; i++) if (text[i] === "\n") {
+		count++;
+		if (count >= maxLines) return text.slice(0, i + 1);
+	}
+	return text;
+}
+/** Reading one line past the cap is what makes `truncated` exact: a body that ends
+* right at `maxLines` is complete, not cut short. */
+function capToLines(text, maxLines) {
+	if (maxLines === void 0) return {
+		text,
+		tooLarge: false,
+		truncated: false
+	};
+	const capped = capLines(text, maxLines);
+	return {
+		text: capped,
+		tooLarge: false,
+		truncated: capped.length < text.length
+	};
+}
+/** What a read yields when the byte cap trips mid-stream. Complete lines already read
+* are a usable preview, so the cap cuts them short rather than refusing; only a body
+* with no line break leaves nothing to show. */
+function capAtBytes(text, lines, maxLines) {
+	if (maxLines === void 0 || lines === 0) return {
+		text: "",
+		tooLarge: true,
+		truncated: false
+	};
+	return {
+		text: capLines(text, lines),
+		tooLarge: false,
+		truncated: true
+	};
+}
+/** Read a Response as text capped at `maxBytes`; when `maxLines` is given, cancel the stream
+* once that many `\n` arrive. Cutting on `\n` keeps the returned prefix on a clean UTF-8 boundary. */
+async function readCappedText(response, maxBytes, maxLines) {
+	const probeLines = maxLines === void 0 ? void 0 : maxLines + 1;
+	const reader = response.body?.getReader();
+	if (!reader) {
+		const { bytes, tooLarge } = await readCappedBytes(response, maxBytes);
+		if (tooLarge) return {
+			text: "",
+			tooLarge: true,
+			truncated: false
+		};
+		return capToLines(new TextDecoder().decode(bytes), maxLines);
+	}
+	const decoder = new TextDecoder();
+	let text = "";
+	let lines = 0;
+	let total = 0;
+	for (let chunk = await reader.read(); !chunk.done; chunk = await reader.read()) {
+		total += chunk.value.byteLength;
+		if (total > maxBytes) {
+			await reader.cancel();
+			return capAtBytes(text, lines, maxLines);
+		}
+		const piece = decoder.decode(chunk.value, { stream: true });
+		text += piece;
+		if (probeLines !== void 0) {
+			lines += countNewlines(piece);
+			if (lines >= probeLines) {
+				await reader.cancel();
+				return capToLines(text, maxLines);
+			}
+		}
+	}
+	text += decoder.decode();
+	return capToLines(text, maxLines);
+}
+/** Keep the last `maxLines` lines, ignoring a single trailing newline so a file
+* ending in one doesn't spend a line on the empty remainder. */
+function lastLines(text, maxLines) {
+	const end = text.endsWith("\n") ? text.length - 1 : text.length;
+	let count = 0;
+	for (let i = end - 1; i >= 0; i--) if (text[i] === "\n") {
+		count++;
+		if (count === maxLines) return {
+			text: text.slice(i + 1),
+			truncated: true
+		};
+	}
+	return {
+		text,
+		truncated: false
+	};
+}
+/** Range header for reading the last `maxBytes` of an object. A closed range is a
+* CORS-safelisted header value, so it travels without a preflight that a bucket's
+* CORS rules may not answer; the suffix form is not safelisted, and is only reached
+* for workspace files, which are same-origin and list no size. Closing the range at
+* the listed size also bounds the window: left open, an object that grew since the
+* listing would serve more than `maxBytes` and the read would refuse it. */
+function tailRangeFor(knownSize, maxBytes) {
+	if (typeof knownSize !== "number") return `bytes=-${maxBytes}`;
+	const start = knownSize - maxBytes;
+	return start > 0 ? `bytes=${start}-${knownSize - 1}` : null;
+}
+/** What a ranged response actually delivered: whether its first line arrives cut in
+* half, or `null` when the body can't be the object's end at all. */
+function tailWindow(response, maxBytes) {
+	if (response.status === 206) {
+		const range = response.headers.get("content-range");
+		return { startsMidObject: range === null || !range.startsWith("bytes 0-") };
+	}
+	const length = response.headers.get("content-length");
+	if (length === null) return null;
+	const size = Number(length);
+	return Number.isFinite(size) && size <= maxBytes ? { startsMidObject: false } : null;
+}
+/** Read a range covering the end of an object as text. `startsMidObject` says the
+* range began at an arbitrary byte, so the first line arrives cut in half. */
+async function readTailText(response, maxBytes, maxLines, startsMidObject) {
+	const { bytes, tooLarge } = await readCappedBytes(response, maxBytes);
+	if (tooLarge) return {
+		text: "",
+		tooLarge: true,
+		truncated: false
+	};
+	let text = new TextDecoder().decode(bytes);
+	if (startsMidObject) {
+		const firstBreak = text.indexOf("\n");
+		if (firstBreak !== -1) text = text.slice(firstBreak + 1);
+	}
+	const limited = maxLines === void 0 ? {
+		text,
+		truncated: false
+	} : lastLines(text, maxLines);
+	return {
+		text: limited.text,
+		tooLarge: false,
+		truncated: startsMidObject || limited.truncated
+	};
+}
+//#endregion
+export { countLines, lastLines, readCappedBytes, readCappedText, readTailText, tailRangeFor, tailWindow };

package/dist/file-explorer/FilePreview/useObjectBlobUrl.js

@@ -0,0 +1,95 @@
+import { CorsError } from "../lib/errors.js";
+import { fetchPreviewObject, loadPreviewContent, peekPreviewContent } from "./previewCache.js";
+import { readCappedBytes } from "./readCappedBytes.js";
+import { useEffect, useState } from "react";
+//#region src/file-explorer/FilePreview/useObjectBlobUrl.ts
+function toState(result) {
+	return {
+		blobUrl: result.blobUrl,
+		loading: false,
+		error: null,
+		tooLarge: result.tooLarge,
+		corsError: false
+	};
+}
+function disposeBlob(result) {
+	if (result.blobUrl) URL.revokeObjectURL(result.blobUrl);
+}
+/** Fetch an object into a blob URL with a forced MIME type so e.g. PDFs render inline even when served as octet-stream; cached per `cacheKey` so repeated mounts share one download and one blob URL, revoked when the cache drops it. */
+function useObjectBlobUrl(url, { enabled, maxBytes, knownSize, mimeType, cacheKey }) {
+	const [state, setState] = useState({
+		blobUrl: null,
+		loading: enabled,
+		error: null,
+		tooLarge: false,
+		corsError: false
+	});
+	const tooLarge = typeof knownSize === "number" && knownSize > maxBytes;
+	const key = enabled ? cacheKey : null;
+	useEffect(() => {
+		if (!enabled || !url || !key) return;
+		if (tooLarge) {
+			setState({
+				blobUrl: null,
+				loading: false,
+				error: null,
+				tooLarge: true,
+				corsError: false
+			});
+			return;
+		}
+		let cancelled = false;
+		const record = loadPreviewContent(key, async (signal) => {
+			const response = await fetchPreviewObject(key, url, signal);
+			const { bytes, tooLarge: exceeded } = await readCappedBytes(response, maxBytes);
+			if (exceeded) return {
+				blobUrl: null,
+				tooLarge: true
+			};
+			return {
+				blobUrl: URL.createObjectURL(new Blob([bytes], { type: mimeType })),
+				tooLarge: false
+			};
+		}, disposeBlob);
+		setState(record.value ? toState(record.value) : {
+			blobUrl: null,
+			loading: true,
+			error: null,
+			tooLarge: false,
+			corsError: false
+		});
+		record.promise.then((result) => {
+			if (!cancelled) setState(toState(result));
+		}).catch((err) => {
+			if (err instanceof DOMException && err.name === "AbortError") return;
+			if (!cancelled) setState({
+				blobUrl: null,
+				loading: false,
+				error: err instanceof Error ? err.message : "Failed to load file",
+				tooLarge: false,
+				corsError: err instanceof CorsError
+			});
+		});
+		return () => {
+			cancelled = true;
+		};
+	}, [
+		url,
+		enabled,
+		key,
+		maxBytes,
+		mimeType,
+		tooLarge
+	]);
+	if (tooLarge) return {
+		blobUrl: null,
+		loading: false,
+		error: null,
+		tooLarge: true,
+		corsError: false
+	};
+	const cached = key ? peekPreviewContent(key) : void 0;
+	return cached ? toState(cached) : state;
+}
+//#endregion
+export { useObjectBlobUrl };

package/dist/file-explorer/FilePreview/useObjectText.js

@@ -0,0 +1,109 @@
+import { CorsError } from "../lib/errors.js";
+import { fetchPreviewObject, loadPreviewContent, peekPreviewContent } from "./previewCache.js";
+import { readCappedText, readTailText, tailRangeFor, tailWindow } from "./readCappedBytes.js";
+import { useEffect, useState } from "react";
+//#region src/file-explorer/FilePreview/useObjectText.ts
+var IDLE = {
+	text: null,
+	loading: false,
+	error: null,
+	tooLarge: false,
+	truncated: false,
+	corsError: false
+};
+function toState(result) {
+	return {
+		...IDLE,
+		...result
+	};
+}
+async function readObjectText(signal, { url, cacheKey, maxBytes, maxLines, knownSize, tail }) {
+	const range = tail ? tailRangeFor(knownSize, maxBytes) : null;
+	const response = await fetchPreviewObject(cacheKey, url, signal, range ? { Range: range } : void 0);
+	let startsMidObject = false;
+	if (range) {
+		const window = tailWindow(response, maxBytes);
+		if (!window) throw new Error("range request was not honored");
+		startsMidObject = window.startsMidObject;
+	}
+	const result = tail ? await readTailText(response, maxBytes, maxLines, startsMidObject) : await readCappedText(response, maxBytes, maxLines);
+	return {
+		text: result.tooLarge ? null : result.text,
+		tooLarge: result.tooLarge,
+		truncated: result.truncated
+	};
+}
+/** Fetch a text object from a presigned URL, cached per `cacheKey` so repeated mounts
+* download it once. `maxLines` stops the read early and `maxBytes` cuts short what it
+* hasn't. `tail` reads the end of the object instead of the start, and caches
+* separately because the same object yields different text. */
+function useObjectText(url, { enabled, maxBytes, maxLines, knownSize, cacheKey, tail = false }) {
+	const tooLarge = maxLines === void 0 && !tail && typeof knownSize === "number" && knownSize > maxBytes;
+	const key = enabled ? tail ? `${cacheKey}#tail` : cacheKey : null;
+	const [state, setState] = useState({
+		...IDLE,
+		loading: enabled
+	});
+	const [stateKey, setStateKey] = useState(key);
+	if (stateKey !== key) {
+		setStateKey(key);
+		setState({
+			...IDLE,
+			loading: key !== null
+		});
+	}
+	useEffect(() => {
+		if (!enabled || !url || !key) return;
+		if (tooLarge) {
+			setState({
+				...IDLE,
+				tooLarge: true
+			});
+			return;
+		}
+		let cancelled = false;
+		const record = loadPreviewContent(key, (signal) => readObjectText(signal, {
+			url,
+			cacheKey,
+			maxBytes,
+			maxLines,
+			knownSize,
+			tail
+		}));
+		setState(record.value ? toState(record.value) : {
+			...IDLE,
+			loading: true
+		});
+		record.promise.then((result) => {
+			if (!cancelled) setState(toState(result));
+		}).catch((err) => {
+			if (err instanceof DOMException && err.name === "AbortError") return;
+			if (!cancelled) setState({
+				...IDLE,
+				error: err instanceof Error ? err.message : "Failed to load file",
+				corsError: err instanceof CorsError
+			});
+		});
+		return () => {
+			cancelled = true;
+		};
+	}, [
+		url,
+		enabled,
+		key,
+		maxBytes,
+		maxLines,
+		tooLarge,
+		tail,
+		cacheKey,
+		knownSize
+	]);
+	if (tooLarge) return {
+		...IDLE,
+		tooLarge: true
+	};
+	const cached = key ? peekPreviewContent(key) : void 0;
+	return cached ? toState(cached) : state;
+}
+//#endregion
+export { useObjectText };

package/dist/file-explorer/FilePreview/usePresignedUrl.js

@@ -0,0 +1,73 @@
+import { loadPreviewUrl, peekPreviewUrl } from "./previewCache.js";
+import { useEffect, useRef, useState } from "react";
+//#region src/file-explorer/FilePreview/usePresignedUrl.ts
+function toState([url, error], linkErrorMessage) {
+	if (error || !url) return {
+		url: null,
+		loading: false,
+		error: error?.message ?? linkErrorMessage
+	};
+	return {
+		url,
+		loading: false,
+		error: null
+	};
+}
+/** Fetch a presigned URL per file, cached so repeated mounts share one request; callbacks come from refs so the effect keys only on file identity. */
+function usePresignedUrl(node, getPresignedUrl, { enabled, linkErrorMessage }) {
+	const path = enabled ? node?.path ?? null : null;
+	const [state, setState] = useState({
+		url: null,
+		loading: false,
+		error: null
+	});
+	const [statePath, setStatePath] = useState(path);
+	if (statePath !== path) {
+		setStatePath(path);
+		setState({
+			url: null,
+			loading: path !== null,
+			error: null
+		});
+	}
+	const getUrlRef = useRef(getPresignedUrl);
+	getUrlRef.current = getPresignedUrl;
+	const linkErrorRef = useRef(linkErrorMessage);
+	linkErrorRef.current = linkErrorMessage;
+	const nodeRef = useRef(node);
+	nodeRef.current = node;
+	useEffect(() => {
+		const node = nodeRef.current;
+		if (!path || !node) {
+			setState({
+				url: null,
+				loading: false,
+				error: null
+			});
+			return;
+		}
+		let cancelled = false;
+		const record = loadPreviewUrl(path, () => getUrlRef.current(node));
+		setState(record.value ? toState(record.value, linkErrorRef.current) : {
+			url: null,
+			loading: true,
+			error: null
+		});
+		record.promise.then((result) => {
+			if (!cancelled) setState(toState(result, linkErrorRef.current));
+		}).catch((err) => {
+			if (!cancelled) setState({
+				url: null,
+				loading: false,
+				error: err instanceof Error ? err.message : linkErrorRef.current
+			});
+		});
+		return () => {
+			cancelled = true;
+		};
+	}, [path]);
+	const cached = path ? peekPreviewUrl(path) : void 0;
+	return cached ? toState(cached, linkErrorRef.current) : state;
+}
+//#endregion
+export { usePresignedUrl };

package/dist/file-explorer/FileRow.d.ts

@@ -1,5 +1,5 @@
-import { type OpenMenu, type RowMenuItem } from '../list/index.js';
 import type { ReactNode } from 'react';
+import { type OpenMenu, type RowMenuItem } from '../list/index.js';
 import type { TreeNode } from './lib/types.js';
 export declare const ROW_HEIGHT_SHORT = 45;
 export declare const ROW_HEIGHT_TALL = 52.25;

package/dist/file-explorer/FileRow.js

@@ -0,0 +1,165 @@
+import { useStrings } from "../components/Provider.js";
+import { EyeIcon } from "../icons.js";
+import { TOOLTIP_ID } from "../components/Tooltip.js";
+import { MoreButton, useRowMenuActive } from "../list/RowContextMenu.js";
+import { Table } from "../components/Table.js";
+import { RowSelectCheckbox } from "../list/ListTable.js";
+import { formatFileSize } from "./lib/utils.js";
+import cx from "classnames";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { DateTime } from "luxon";
+var ROW_HEIGHT_TALL = 52.25;
+function isTwoLineRow(node) {
+	return node.type !== "directory" && !!node.contentType;
+}
+/** Pure function of the node, so the virtualizer sizes rows without measuring. */
+function fileRowHeight(node) {
+	return isTwoLineRow(node) ? ROW_HEIGHT_TALL : 45;
+}
+function isInteractiveTarget(e) {
+	return !!e.target.closest("a,button,input,label");
+}
+function lazyContextMenuProps(openMenu, getItems) {
+	return { onContextMenu: (e) => {
+		const items = getItems();
+		e.preventDefault();
+		if (items.length > 0) e.stopPropagation();
+		openMenu(e.clientX, e.clientY, items);
+	} };
+}
+function UserRow({ node, icon, storageCount, getItems, openMenu, onOpen }) {
+	const t = useStrings().fileExplorer;
+	const { active: menuActive, openMenu: openRowMenu } = useRowMenuActive(openMenu);
+	const handleRowClick = (e) => {
+		if (isInteractiveTarget(e)) return;
+		onOpen(node);
+	};
+	return /* @__PURE__ */ jsxs("tr", {
+		className: cx("group cursor-pointer", menuActive ? "theme-hover" : "hover:theme-hover"),
+		onClick: handleRowClick,
+		...lazyContextMenuProps(openRowMenu, getItems),
+		children: [
+			/* @__PURE__ */ jsx(Table.Item, {
+				className: "py-2.5",
+				children: /* @__PURE__ */ jsxs("div", {
+					className: "flex min-w-0 items-center gap-3",
+					children: [/* @__PURE__ */ jsx("span", {
+						className: "flex h-8 w-8 shrink-0 items-center justify-center rounded-full theme-muted-panel *:m-0",
+						children: icon
+					}), /* @__PURE__ */ jsx("span", {
+						className: "truncate text-[13px] font-medium text-(--theme-app)",
+						children: node.displayName || node.name
+					})]
+				})
+			}),
+			/* @__PURE__ */ jsx(Table.Item, {
+				className: "py-2.5 text-xs uppercase tracking-wider text-(--theme-muted-text-color)",
+				children: t.preview.userType
+			}),
+			/* @__PURE__ */ jsx(Table.Item, {
+				className: "py-2.5 tabular-nums text-(--theme-muted-text-color)",
+				children: storageCount
+			}),
+			/* @__PURE__ */ jsx(Table.Item, {
+				className: "relative py-2.5",
+				children: /* @__PURE__ */ jsx("div", {
+					className: "absolute inset-y-0 right-0 flex items-center pr-4",
+					children: /* @__PURE__ */ jsx(MoreButton, {
+						active: menuActive,
+						onOpen: (x, y) => openRowMenu(x, y, getItems())
+					})
+				})
+			})
+		]
+	});
+}
+function FileRow({ node, icon, rowId, rowIndex, active, checked, canPreview, getItems, openMenu, onOpen, onToggleCheck, onPreview }) {
+	const t = useStrings().fileExplorer;
+	const { active: menuActive, openMenu: openRowMenu } = useRowMenuActive(openMenu);
+	const isDir = node.type === "directory";
+	const modifiedDt = node.modified ? DateTime.fromISO(node.modified) : null;
+	const typeLabel = node.root ? node.storageType ?? node.type : node.type;
+	const handleRowClick = (e) => {
+		if (isInteractiveTarget(e)) return;
+		onOpen(node);
+	};
+	return /* @__PURE__ */ jsxs("tr", {
+		id: rowId,
+		"aria-rowindex": rowIndex,
+		"aria-selected": checked,
+		className: cx("group", checked ? "bg-blue-500/5" : menuActive ? "theme-hover" : "hover:theme-hover", active && "group-focus-visible/grid:ring-1 group-focus-visible/grid:ring-inset group-focus-visible/grid:ring-(--theme-link)", "cursor-pointer"),
+		onClick: handleRowClick,
+		style: { height: fileRowHeight(node) },
+		...lazyContextMenuProps(openRowMenu, getItems),
+		children: [
+			/* @__PURE__ */ jsx(Table.Item, {
+				className: "py-2.5",
+				children: /* @__PURE__ */ jsxs("div", {
+					className: "flex min-w-0 items-center gap-2.5",
+					children: [
+						/* @__PURE__ */ jsx(RowSelectCheckbox, {
+							checked,
+							label: t.preview.select(node.name),
+							onToggle: () => onToggleCheck(node, !checked)
+						}),
+						/* @__PURE__ */ jsx("span", {
+							className: "flex h-5 w-5 shrink-0 items-center justify-center *:m-0",
+							children: icon
+						}),
+						/* @__PURE__ */ jsxs("div", {
+							className: "min-w-0",
+							children: [/* @__PURE__ */ jsx("div", {
+								className: "truncate text-[13px] font-medium leading-tight text-(--theme-app)",
+								children: node.displayName || node.name
+							}), !isDir && node.contentType && /* @__PURE__ */ jsx("div", {
+								className: "truncate text-xs leading-tight text-(--theme-muted-text-color)",
+								children: node.contentType
+							})]
+						})
+					]
+				})
+			}),
+			/* @__PURE__ */ jsx(Table.Item, {
+				className: "truncate py-2.5 text-sm tabular-nums text-(--theme-muted-text-color)",
+				children: typeof node.size === "number" ? formatFileSize(node.size) : "—"
+			}),
+			/* @__PURE__ */ jsx(Table.Item, {
+				className: "truncate py-2.5 text-xs uppercase tracking-wider text-(--theme-muted-text-color)",
+				children: typeLabel
+			}),
+			/* @__PURE__ */ jsx(Table.Item, {
+				className: "truncate py-2.5 text-sm text-(--theme-muted-text-color)",
+				children: /* @__PURE__ */ jsx("span", {
+					"data-tooltip-id": TOOLTIP_ID,
+					"data-tooltip-content": node.modified ?? "",
+					"data-tooltip-place": "top",
+					children: !isDir && modifiedDt?.isValid ? modifiedDt.toRelative() : "—"
+				})
+			}),
+			/* @__PURE__ */ jsx(Table.Item, {
+				className: "relative py-2.5",
+				children: /* @__PURE__ */ jsxs("div", {
+					className: "absolute inset-y-0 right-0 flex items-center gap-0.5 pr-4",
+					children: [!isDir && canPreview && /* @__PURE__ */ jsx("button", {
+						type: "button",
+						"aria-label": t.preview.preview,
+						"data-tooltip-id": "global-tooltip",
+						"data-tooltip-content": t.preview.preview,
+						"data-tooltip-place": "bottom",
+						onClick: (e) => {
+							e.stopPropagation();
+							onPreview(node);
+						},
+						className: cx("rounded p-1 text-(--theme-muted-text-color) transition-colors hover:bg-(--theme-muted-panel-bg) hover:text-(--theme-app) [&>svg]:h-4 [&>svg]:w-4", menuActive ? "opacity-100" : "opacity-0 group-hover:opacity-100 focus-visible:opacity-100"),
+						children: /* @__PURE__ */ jsx(EyeIcon, {})
+					}), /* @__PURE__ */ jsx(MoreButton, {
+						active: menuActive,
+						onOpen: (x, y) => openRowMenu(x, y, getItems())
+					})]
+				})
+			})
+		]
+	});
+}
+//#endregion
+export { FileRow, ROW_HEIGHT_TALL, UserRow, fileRowHeight, isTwoLineRow };