@powerhousedao/powerhouse-vetra-packages 6.2.3-dev.10 → 6.2.3-dev.11

package/dist/browser/folder-view-CzItU0hn.js

@@ -0,0 +1,957 @@
+import { n as PowerhouseButton, o as Icon, r as useWindowSize } from "./src-CVV6HzQZ-D-OQvEkh.js";
+import { h as twMerge } from "./dist-D3_ER0Dn.js";
+import * as React$1 from "react";
+import React, { useRef, useState } from "react";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { flushSync } from "react-dom";
+import { CreateDocumentWithTypeModal, FileItem, FolderItem } from "@powerhousedao/design-system/connect";
+import { addDocument, isFileNodeKind, isFolderNodeKind, preloadEditorModule, setSelectedNode, useAllowedDocumentModelModules, useDisabledEditors, useEditorModules, useNodesInSelectedDriveOrFolder, useParentFolderForSelectedNode, useSelectedDriveSafe, useSelectedFolder, useStudioMode, useUserPermissions } from "@powerhousedao/reactor-browser";
+//#region editors/generic-drive-explorer/utils/select-creatable-modules.ts
+/**
+* The modules a user may pick from when creating a new document. Outside
+* studio mode only the latest version of each document type is offered: new
+* documents should never start on an outdated schema. Builders testing
+* migrations run in studio mode and still get every version.
+*/
+function selectCreatableModules(modules, studioMode) {
+	if (studioMode) return [...modules];
+	const latestByType = /* @__PURE__ */ new Map();
+	for (const module of modules) {
+		const id = module.documentModel.global.id;
+		const current = latestByType.get(id);
+		if (!current || (module.version ?? 1) > (current.version ?? 1)) latestByType.set(id, module);
+	}
+	return [...latestByType.values()];
+}
+//#endregion
+//#region editors/generic-drive-explorer/components/create-document.tsx
+function toDocumentTypeOption(doc, studioMode) {
+	const spec = doc.documentModel.global;
+	return {
+		documentType: spec.id,
+		name: spec.name,
+		version: studioMode ? doc.version : void 0,
+		description: spec.description
+	};
+}
+function CreateDocument() {
+	const [showModal, setShowModal] = useState(false);
+	const { isAllowedToCreateDocuments } = useUserPermissions();
+	const allowedDocumentModelModules = useAllowedDocumentModelModules();
+	const editorModules = useEditorModules();
+	const disabledEditors = useDisabledEditors() ?? [];
+	const [selectedDrive] = useSelectedDriveSafe();
+	const selectedFolder = useSelectedFolder();
+	const parentFolder = useParentFolderForSelectedNode();
+	const DRIVE_CONTAINER_TYPES = ["powerhouse/document-drive", "powerhouse/reactor-drive"];
+	const studioMode = useStudioMode() ?? false;
+	const visibleDocumentModelModules = selectCreatableModules(allowedDocumentModelModules ?? [], studioMode).filter((module) => {
+		const id = module.documentModel.global.id;
+		return !DRIVE_CONTAINER_TYPES.includes(id) && !disabledEditors.includes(id);
+	});
+	const preloadEditorsForType = (documentType) => editorModules?.filter((editorModule) => editorModule.documentTypes.includes(documentType)).forEach((editorModule) => {
+		preloadEditorModule(editorModule);
+	});
+	const handleCreate = async ({ name, documentType, version }) => {
+		setShowModal(false);
+		if (!selectedDrive) return;
+		try {
+			setSelectedNode(await addDocument(selectedDrive.header.id, name, documentType, selectedFolder?.id ?? parentFolder?.id, void 0, void 0, void 0, version));
+		} catch (error) {
+			console.error("Failed to create document:", error);
+		}
+	};
+	if (!isAllowedToCreateDocuments) return null;
+	if (!visibleDocumentModelModules.length) return null;
+	return /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx(PowerhouseButton, {
+		className: "py-2",
+		color: "blue",
+		icon: /* @__PURE__ */ jsx(Icon, {
+			name: "Plus",
+			size: 14
+		}),
+		onClick: () => setShowModal(true),
+		size: "small",
+		children: "Create New Document"
+	}), /* @__PURE__ */ jsx(CreateDocumentWithTypeModal, {
+		documentTypes: visibleDocumentModelModules.map((module) => toDocumentTypeOption(module, studioMode)),
+		onCreate: (input) => void handleCreate(input),
+		onOpenChange: setShowModal,
+		onTypeSelected: preloadEditorsForType,
+		open: showModal
+	})] });
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@tanstack+virtual-core@3.13.19/node_modules/@tanstack/virtual-core/dist/esm/utils.js
+function memo$1(getDeps, fn, opts) {
+	let deps = opts.initialDeps ?? [];
+	let result;
+	let isInitial = true;
+	function memoizedFunction() {
+		var _a, _b, _c;
+		let depTime;
+		if (opts.key && ((_a = opts.debug) == null ? void 0 : _a.call(opts))) depTime = Date.now();
+		const newDeps = getDeps();
+		if (!(newDeps.length !== deps.length || newDeps.some((dep, index) => deps[index] !== dep))) return result;
+		deps = newDeps;
+		let resultTime;
+		if (opts.key && ((_b = opts.debug) == null ? void 0 : _b.call(opts))) resultTime = Date.now();
+		result = fn(...newDeps);
+		if (opts.key && ((_c = opts.debug) == null ? void 0 : _c.call(opts))) {
+			const depEndTime = Math.round((Date.now() - depTime) * 100) / 100;
+			const resultEndTime = Math.round((Date.now() - resultTime) * 100) / 100;
+			const resultFpsPercentage = resultEndTime / 16;
+			const pad = (str, num) => {
+				str = String(str);
+				while (str.length < num) str = " " + str;
+				return str;
+			};
+			console.info(`%c⏱ ${pad(resultEndTime, 5)} /${pad(depEndTime, 5)} ms`, `
+            font-size: .6rem;
+            font-weight: bold;
+            color: hsl(${Math.max(0, Math.min(120 - 120 * resultFpsPercentage, 120))}deg 100% 31%);`, opts == null ? void 0 : opts.key);
+		}
+		if ((opts == null ? void 0 : opts.onChange) && !(isInitial && opts.skipInitialOnChange)) opts.onChange(result);
+		isInitial = false;
+		return result;
+	}
+	memoizedFunction.updateDeps = (newDeps) => {
+		deps = newDeps;
+	};
+	return memoizedFunction;
+}
+function notUndefined(value, msg) {
+	if (value === void 0) throw new Error(`Unexpected undefined${msg ? `: ${msg}` : ""}`);
+	else return value;
+}
+const approxEqual = (a, b) => Math.abs(a - b) < 1.01;
+const debounce = (targetWindow, fn, ms) => {
+	let timeoutId;
+	return function(...args) {
+		targetWindow.clearTimeout(timeoutId);
+		timeoutId = targetWindow.setTimeout(() => fn.apply(this, args), ms);
+	};
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@tanstack+virtual-core@3.13.19/node_modules/@tanstack/virtual-core/dist/esm/index.js
+const getRect = (element) => {
+	const { offsetWidth, offsetHeight } = element;
+	return {
+		width: offsetWidth,
+		height: offsetHeight
+	};
+};
+const defaultKeyExtractor = (index) => index;
+const defaultRangeExtractor = (range) => {
+	const start = Math.max(range.startIndex - range.overscan, 0);
+	const end = Math.min(range.endIndex + range.overscan, range.count - 1);
+	const arr = [];
+	for (let i = start; i <= end; i++) arr.push(i);
+	return arr;
+};
+const observeElementRect = (instance, cb) => {
+	const element = instance.scrollElement;
+	if (!element) return;
+	const targetWindow = instance.targetWindow;
+	if (!targetWindow) return;
+	const handler = (rect) => {
+		const { width, height } = rect;
+		cb({
+			width: Math.round(width),
+			height: Math.round(height)
+		});
+	};
+	handler(getRect(element));
+	if (!targetWindow.ResizeObserver) return () => {};
+	const observer = new targetWindow.ResizeObserver((entries) => {
+		const run = () => {
+			const entry = entries[0];
+			if (entry == null ? void 0 : entry.borderBoxSize) {
+				const box = entry.borderBoxSize[0];
+				if (box) {
+					handler({
+						width: box.inlineSize,
+						height: box.blockSize
+					});
+					return;
+				}
+			}
+			handler(getRect(element));
+		};
+		instance.options.useAnimationFrameWithResizeObserver ? requestAnimationFrame(run) : run();
+	});
+	observer.observe(element, { box: "border-box" });
+	return () => {
+		observer.unobserve(element);
+	};
+};
+const addEventListenerOptions = { passive: true };
+const supportsScrollend = typeof window == "undefined" ? true : "onscrollend" in window;
+const observeElementOffset = (instance, cb) => {
+	const element = instance.scrollElement;
+	if (!element) return;
+	const targetWindow = instance.targetWindow;
+	if (!targetWindow) return;
+	let offset = 0;
+	const fallback = instance.options.useScrollendEvent && supportsScrollend ? () => void 0 : debounce(targetWindow, () => {
+		cb(offset, false);
+	}, instance.options.isScrollingResetDelay);
+	const createHandler = (isScrolling) => () => {
+		const { horizontal, isRtl } = instance.options;
+		offset = horizontal ? element["scrollLeft"] * (isRtl && -1 || 1) : element["scrollTop"];
+		fallback();
+		cb(offset, isScrolling);
+	};
+	const handler = createHandler(true);
+	const endHandler = createHandler(false);
+	element.addEventListener("scroll", handler, addEventListenerOptions);
+	const registerScrollendEvent = instance.options.useScrollendEvent && supportsScrollend;
+	if (registerScrollendEvent) element.addEventListener("scrollend", endHandler, addEventListenerOptions);
+	return () => {
+		element.removeEventListener("scroll", handler);
+		if (registerScrollendEvent) element.removeEventListener("scrollend", endHandler);
+	};
+};
+const measureElement = (element, entry, instance) => {
+	if (entry == null ? void 0 : entry.borderBoxSize) {
+		const box = entry.borderBoxSize[0];
+		if (box) return Math.round(box[instance.options.horizontal ? "inlineSize" : "blockSize"]);
+	}
+	return element[instance.options.horizontal ? "offsetWidth" : "offsetHeight"];
+};
+const elementScroll = (offset, { adjustments = 0, behavior }, instance) => {
+	var _a, _b;
+	const toOffset = offset + adjustments;
+	(_b = (_a = instance.scrollElement) == null ? void 0 : _a.scrollTo) == null || _b.call(_a, {
+		[instance.options.horizontal ? "left" : "top"]: toOffset,
+		behavior
+	});
+};
+var Virtualizer = class {
+	constructor(opts) {
+		this.unsubs = [];
+		this.scrollElement = null;
+		this.targetWindow = null;
+		this.isScrolling = false;
+		this.currentScrollToIndex = null;
+		this.measurementsCache = [];
+		this.itemSizeCache = /* @__PURE__ */ new Map();
+		this.laneAssignments = /* @__PURE__ */ new Map();
+		this.pendingMeasuredCacheIndexes = [];
+		this.prevLanes = void 0;
+		this.lanesChangedFlag = false;
+		this.lanesSettling = false;
+		this.scrollRect = null;
+		this.scrollOffset = null;
+		this.scrollDirection = null;
+		this.scrollAdjustments = 0;
+		this.elementsCache = /* @__PURE__ */ new Map();
+		this.observer = /* @__PURE__ */ (() => {
+			let _ro = null;
+			const get = () => {
+				if (_ro) return _ro;
+				if (!this.targetWindow || !this.targetWindow.ResizeObserver) return null;
+				return _ro = new this.targetWindow.ResizeObserver((entries) => {
+					entries.forEach((entry) => {
+						const run = () => {
+							this._measureElement(entry.target, entry);
+						};
+						this.options.useAnimationFrameWithResizeObserver ? requestAnimationFrame(run) : run();
+					});
+				});
+			};
+			return {
+				disconnect: () => {
+					var _a;
+					(_a = get()) == null || _a.disconnect();
+					_ro = null;
+				},
+				observe: (target) => {
+					var _a;
+					return (_a = get()) == null ? void 0 : _a.observe(target, { box: "border-box" });
+				},
+				unobserve: (target) => {
+					var _a;
+					return (_a = get()) == null ? void 0 : _a.unobserve(target);
+				}
+			};
+		})();
+		this.range = null;
+		this.setOptions = (opts2) => {
+			Object.entries(opts2).forEach(([key, value]) => {
+				if (typeof value === "undefined") delete opts2[key];
+			});
+			this.options = {
+				debug: false,
+				initialOffset: 0,
+				overscan: 1,
+				paddingStart: 0,
+				paddingEnd: 0,
+				scrollPaddingStart: 0,
+				scrollPaddingEnd: 0,
+				horizontal: false,
+				getItemKey: defaultKeyExtractor,
+				rangeExtractor: defaultRangeExtractor,
+				onChange: () => {},
+				measureElement,
+				initialRect: {
+					width: 0,
+					height: 0
+				},
+				scrollMargin: 0,
+				gap: 0,
+				indexAttribute: "data-index",
+				initialMeasurementsCache: [],
+				lanes: 1,
+				isScrollingResetDelay: 150,
+				enabled: true,
+				isRtl: false,
+				useScrollendEvent: false,
+				useAnimationFrameWithResizeObserver: false,
+				...opts2
+			};
+		};
+		this.notify = (sync) => {
+			var _a, _b;
+			(_b = (_a = this.options).onChange) == null || _b.call(_a, this, sync);
+		};
+		this.maybeNotify = memo$1(() => {
+			this.calculateRange();
+			return [
+				this.isScrolling,
+				this.range ? this.range.startIndex : null,
+				this.range ? this.range.endIndex : null
+			];
+		}, (isScrolling) => {
+			this.notify(isScrolling);
+		}, {
+			key: false,
+			debug: () => this.options.debug,
+			initialDeps: [
+				this.isScrolling,
+				this.range ? this.range.startIndex : null,
+				this.range ? this.range.endIndex : null
+			]
+		});
+		this.cleanup = () => {
+			this.unsubs.filter(Boolean).forEach((d) => d());
+			this.unsubs = [];
+			this.observer.disconnect();
+			this.scrollElement = null;
+			this.targetWindow = null;
+		};
+		this._didMount = () => {
+			return () => {
+				this.cleanup();
+			};
+		};
+		this._willUpdate = () => {
+			var _a;
+			const scrollElement = this.options.enabled ? this.options.getScrollElement() : null;
+			if (this.scrollElement !== scrollElement) {
+				this.cleanup();
+				if (!scrollElement) {
+					this.maybeNotify();
+					return;
+				}
+				this.scrollElement = scrollElement;
+				if (this.scrollElement && "ownerDocument" in this.scrollElement) this.targetWindow = this.scrollElement.ownerDocument.defaultView;
+				else this.targetWindow = ((_a = this.scrollElement) == null ? void 0 : _a.window) ?? null;
+				this.elementsCache.forEach((cached) => {
+					this.observer.observe(cached);
+				});
+				this.unsubs.push(this.options.observeElementRect(this, (rect) => {
+					this.scrollRect = rect;
+					this.maybeNotify();
+				}));
+				this.unsubs.push(this.options.observeElementOffset(this, (offset, isScrolling) => {
+					this.scrollAdjustments = 0;
+					this.scrollDirection = isScrolling ? this.getScrollOffset() < offset ? "forward" : "backward" : null;
+					this.scrollOffset = offset;
+					this.isScrolling = isScrolling;
+					this.maybeNotify();
+				}));
+				this._scrollToOffset(this.getScrollOffset(), {
+					adjustments: void 0,
+					behavior: void 0
+				});
+			}
+		};
+		this.getSize = () => {
+			if (!this.options.enabled) {
+				this.scrollRect = null;
+				return 0;
+			}
+			this.scrollRect = this.scrollRect ?? this.options.initialRect;
+			return this.scrollRect[this.options.horizontal ? "width" : "height"];
+		};
+		this.getScrollOffset = () => {
+			if (!this.options.enabled) {
+				this.scrollOffset = null;
+				return 0;
+			}
+			this.scrollOffset = this.scrollOffset ?? (typeof this.options.initialOffset === "function" ? this.options.initialOffset() : this.options.initialOffset);
+			return this.scrollOffset;
+		};
+		this.getFurthestMeasurement = (measurements, index) => {
+			const furthestMeasurementsFound = /* @__PURE__ */ new Map();
+			const furthestMeasurements = /* @__PURE__ */ new Map();
+			for (let m = index - 1; m >= 0; m--) {
+				const measurement = measurements[m];
+				if (furthestMeasurementsFound.has(measurement.lane)) continue;
+				const previousFurthestMeasurement = furthestMeasurements.get(measurement.lane);
+				if (previousFurthestMeasurement == null || measurement.end > previousFurthestMeasurement.end) furthestMeasurements.set(measurement.lane, measurement);
+				else if (measurement.end < previousFurthestMeasurement.end) furthestMeasurementsFound.set(measurement.lane, true);
+				if (furthestMeasurementsFound.size === this.options.lanes) break;
+			}
+			return furthestMeasurements.size === this.options.lanes ? Array.from(furthestMeasurements.values()).sort((a, b) => {
+				if (a.end === b.end) return a.index - b.index;
+				return a.end - b.end;
+			})[0] : void 0;
+		};
+		this.getMeasurementOptions = memo$1(() => [
+			this.options.count,
+			this.options.paddingStart,
+			this.options.scrollMargin,
+			this.options.getItemKey,
+			this.options.enabled,
+			this.options.lanes
+		], (count, paddingStart, scrollMargin, getItemKey, enabled, lanes) => {
+			if (this.prevLanes !== void 0 && this.prevLanes !== lanes) this.lanesChangedFlag = true;
+			this.prevLanes = lanes;
+			this.pendingMeasuredCacheIndexes = [];
+			return {
+				count,
+				paddingStart,
+				scrollMargin,
+				getItemKey,
+				enabled,
+				lanes
+			};
+		}, { key: false });
+		this.getMeasurements = memo$1(() => [this.getMeasurementOptions(), this.itemSizeCache], ({ count, paddingStart, scrollMargin, getItemKey, enabled, lanes }, itemSizeCache) => {
+			if (!enabled) {
+				this.measurementsCache = [];
+				this.itemSizeCache.clear();
+				this.laneAssignments.clear();
+				return [];
+			}
+			if (this.laneAssignments.size > count) {
+				for (const index of this.laneAssignments.keys()) if (index >= count) this.laneAssignments.delete(index);
+			}
+			if (this.lanesChangedFlag) {
+				this.lanesChangedFlag = false;
+				this.lanesSettling = true;
+				this.measurementsCache = [];
+				this.itemSizeCache.clear();
+				this.laneAssignments.clear();
+				this.pendingMeasuredCacheIndexes = [];
+			}
+			if (this.measurementsCache.length === 0 && !this.lanesSettling) {
+				this.measurementsCache = this.options.initialMeasurementsCache;
+				this.measurementsCache.forEach((item) => {
+					this.itemSizeCache.set(item.key, item.size);
+				});
+			}
+			const min = this.lanesSettling ? 0 : this.pendingMeasuredCacheIndexes.length > 0 ? Math.min(...this.pendingMeasuredCacheIndexes) : 0;
+			this.pendingMeasuredCacheIndexes = [];
+			if (this.lanesSettling && this.measurementsCache.length === count) this.lanesSettling = false;
+			const measurements = this.measurementsCache.slice(0, min);
+			const laneLastIndex = new Array(lanes).fill(void 0);
+			for (let m = 0; m < min; m++) {
+				const item = measurements[m];
+				if (item) laneLastIndex[item.lane] = m;
+			}
+			for (let i = min; i < count; i++) {
+				const key = getItemKey(i);
+				const cachedLane = this.laneAssignments.get(i);
+				let lane;
+				let start;
+				if (cachedLane !== void 0 && this.options.lanes > 1) {
+					lane = cachedLane;
+					const prevIndex = laneLastIndex[lane];
+					const prevInLane = prevIndex !== void 0 ? measurements[prevIndex] : void 0;
+					start = prevInLane ? prevInLane.end + this.options.gap : paddingStart + scrollMargin;
+				} else {
+					const furthestMeasurement = this.options.lanes === 1 ? measurements[i - 1] : this.getFurthestMeasurement(measurements, i);
+					start = furthestMeasurement ? furthestMeasurement.end + this.options.gap : paddingStart + scrollMargin;
+					lane = furthestMeasurement ? furthestMeasurement.lane : i % this.options.lanes;
+					if (this.options.lanes > 1) this.laneAssignments.set(i, lane);
+				}
+				const measuredSize = itemSizeCache.get(key);
+				const size = typeof measuredSize === "number" ? measuredSize : this.options.estimateSize(i);
+				const end = start + size;
+				measurements[i] = {
+					index: i,
+					start,
+					size,
+					end,
+					key,
+					lane
+				};
+				laneLastIndex[lane] = i;
+			}
+			this.measurementsCache = measurements;
+			return measurements;
+		}, {
+			key: false,
+			debug: () => this.options.debug
+		});
+		this.calculateRange = memo$1(() => [
+			this.getMeasurements(),
+			this.getSize(),
+			this.getScrollOffset(),
+			this.options.lanes
+		], (measurements, outerSize, scrollOffset, lanes) => {
+			return this.range = measurements.length > 0 && outerSize > 0 ? calculateRange({
+				measurements,
+				outerSize,
+				scrollOffset,
+				lanes
+			}) : null;
+		}, {
+			key: false,
+			debug: () => this.options.debug
+		});
+		this.getVirtualIndexes = memo$1(() => {
+			let startIndex = null;
+			let endIndex = null;
+			const range = this.calculateRange();
+			if (range) {
+				startIndex = range.startIndex;
+				endIndex = range.endIndex;
+			}
+			this.maybeNotify.updateDeps([
+				this.isScrolling,
+				startIndex,
+				endIndex
+			]);
+			return [
+				this.options.rangeExtractor,
+				this.options.overscan,
+				this.options.count,
+				startIndex,
+				endIndex
+			];
+		}, (rangeExtractor, overscan, count, startIndex, endIndex) => {
+			return startIndex === null || endIndex === null ? [] : rangeExtractor({
+				startIndex,
+				endIndex,
+				overscan,
+				count
+			});
+		}, {
+			key: false,
+			debug: () => this.options.debug
+		});
+		this.indexFromElement = (node) => {
+			const attributeName = this.options.indexAttribute;
+			const indexStr = node.getAttribute(attributeName);
+			if (!indexStr) {
+				console.warn(`Missing attribute name '${attributeName}={index}' on measured element.`);
+				return -1;
+			}
+			return parseInt(indexStr, 10);
+		};
+		this._measureElement = (node, entry) => {
+			const index = this.indexFromElement(node);
+			const item = this.measurementsCache[index];
+			if (!item) return;
+			const key = item.key;
+			const prevNode = this.elementsCache.get(key);
+			if (prevNode !== node) {
+				if (prevNode) this.observer.unobserve(prevNode);
+				this.observer.observe(node);
+				this.elementsCache.set(key, node);
+			}
+			if (node.isConnected) this.resizeItem(index, this.options.measureElement(node, entry, this));
+		};
+		this.resizeItem = (index, size) => {
+			const item = this.measurementsCache[index];
+			if (!item) return;
+			const delta = size - (this.itemSizeCache.get(item.key) ?? item.size);
+			if (delta !== 0) {
+				if (this.shouldAdjustScrollPositionOnItemSizeChange !== void 0 ? this.shouldAdjustScrollPositionOnItemSizeChange(item, delta, this) : item.start < this.getScrollOffset() + this.scrollAdjustments) this._scrollToOffset(this.getScrollOffset(), {
+					adjustments: this.scrollAdjustments += delta,
+					behavior: void 0
+				});
+				this.pendingMeasuredCacheIndexes.push(item.index);
+				this.itemSizeCache = new Map(this.itemSizeCache.set(item.key, size));
+				this.notify(false);
+			}
+		};
+		this.measureElement = (node) => {
+			if (!node) {
+				this.elementsCache.forEach((cached, key) => {
+					if (!cached.isConnected) {
+						this.observer.unobserve(cached);
+						this.elementsCache.delete(key);
+					}
+				});
+				return;
+			}
+			this._measureElement(node, void 0);
+		};
+		this.getVirtualItems = memo$1(() => [this.getVirtualIndexes(), this.getMeasurements()], (indexes, measurements) => {
+			const virtualItems = [];
+			for (let k = 0, len = indexes.length; k < len; k++) {
+				const measurement = measurements[indexes[k]];
+				virtualItems.push(measurement);
+			}
+			return virtualItems;
+		}, {
+			key: false,
+			debug: () => this.options.debug
+		});
+		this.getVirtualItemForOffset = (offset) => {
+			const measurements = this.getMeasurements();
+			if (measurements.length === 0) return;
+			return notUndefined(measurements[findNearestBinarySearch(0, measurements.length - 1, (index) => notUndefined(measurements[index]).start, offset)]);
+		};
+		this.getMaxScrollOffset = () => {
+			if (!this.scrollElement) return 0;
+			if ("scrollHeight" in this.scrollElement) return this.options.horizontal ? this.scrollElement.scrollWidth - this.scrollElement.clientWidth : this.scrollElement.scrollHeight - this.scrollElement.clientHeight;
+			else {
+				const doc = this.scrollElement.document.documentElement;
+				return this.options.horizontal ? doc.scrollWidth - this.scrollElement.innerWidth : doc.scrollHeight - this.scrollElement.innerHeight;
+			}
+		};
+		this.getOffsetForAlignment = (toOffset, align, itemSize = 0) => {
+			if (!this.scrollElement) return 0;
+			const size = this.getSize();
+			const scrollOffset = this.getScrollOffset();
+			if (align === "auto") align = toOffset >= scrollOffset + size ? "end" : "start";
+			if (align === "center") toOffset += (itemSize - size) / 2;
+			else if (align === "end") toOffset -= size;
+			const maxOffset = this.getMaxScrollOffset();
+			return Math.max(Math.min(maxOffset, toOffset), 0);
+		};
+		this.getOffsetForIndex = (index, align = "auto") => {
+			index = Math.max(0, Math.min(index, this.options.count - 1));
+			const item = this.measurementsCache[index];
+			if (!item) return;
+			const size = this.getSize();
+			const scrollOffset = this.getScrollOffset();
+			if (align === "auto") if (item.end >= scrollOffset + size - this.options.scrollPaddingEnd) align = "end";
+			else if (item.start <= scrollOffset + this.options.scrollPaddingStart) align = "start";
+			else return [scrollOffset, align];
+			if (align === "end" && index === this.options.count - 1) return [this.getMaxScrollOffset(), align];
+			const toOffset = align === "end" ? item.end + this.options.scrollPaddingEnd : item.start - this.options.scrollPaddingStart;
+			return [this.getOffsetForAlignment(toOffset, align, item.size), align];
+		};
+		this.isDynamicMode = () => this.elementsCache.size > 0;
+		this.scrollToOffset = (toOffset, { align = "start", behavior } = {}) => {
+			if (behavior === "smooth" && this.isDynamicMode()) console.warn("The `smooth` scroll behavior is not fully supported with dynamic size.");
+			this._scrollToOffset(this.getOffsetForAlignment(toOffset, align), {
+				adjustments: void 0,
+				behavior
+			});
+		};
+		this.scrollToIndex = (index, { align: initialAlign = "auto", behavior } = {}) => {
+			if (behavior === "smooth" && this.isDynamicMode()) console.warn("The `smooth` scroll behavior is not fully supported with dynamic size.");
+			index = Math.max(0, Math.min(index, this.options.count - 1));
+			this.currentScrollToIndex = index;
+			let attempts = 0;
+			const maxAttempts = 10;
+			const tryScroll = (currentAlign) => {
+				if (!this.targetWindow) return;
+				const offsetInfo = this.getOffsetForIndex(index, currentAlign);
+				if (!offsetInfo) {
+					console.warn("Failed to get offset for index:", index);
+					return;
+				}
+				const [offset, align] = offsetInfo;
+				this._scrollToOffset(offset, {
+					adjustments: void 0,
+					behavior
+				});
+				this.targetWindow.requestAnimationFrame(() => {
+					if (!this.targetWindow) return;
+					const verify = () => {
+						if (this.currentScrollToIndex !== index) return;
+						const currentOffset = this.getScrollOffset();
+						const afterInfo = this.getOffsetForIndex(index, align);
+						if (!afterInfo) {
+							console.warn("Failed to get offset for index:", index);
+							return;
+						}
+						if (!approxEqual(afterInfo[0], currentOffset)) scheduleRetry(align);
+					};
+					if (this.isDynamicMode()) this.targetWindow.requestAnimationFrame(verify);
+					else verify();
+				});
+			};
+			const scheduleRetry = (align) => {
+				if (!this.targetWindow) return;
+				if (this.currentScrollToIndex !== index) return;
+				attempts++;
+				if (attempts < maxAttempts) this.targetWindow.requestAnimationFrame(() => tryScroll(align));
+				else console.warn(`Failed to scroll to index ${index} after ${maxAttempts} attempts.`);
+			};
+			tryScroll(initialAlign);
+		};
+		this.scrollBy = (delta, { behavior } = {}) => {
+			if (behavior === "smooth" && this.isDynamicMode()) console.warn("The `smooth` scroll behavior is not fully supported with dynamic size.");
+			this._scrollToOffset(this.getScrollOffset() + delta, {
+				adjustments: void 0,
+				behavior
+			});
+		};
+		this.getTotalSize = () => {
+			var _a;
+			const measurements = this.getMeasurements();
+			let end;
+			if (measurements.length === 0) end = this.options.paddingStart;
+			else if (this.options.lanes === 1) end = ((_a = measurements[measurements.length - 1]) == null ? void 0 : _a.end) ?? 0;
+			else {
+				const endByLane = Array(this.options.lanes).fill(null);
+				let endIndex = measurements.length - 1;
+				while (endIndex >= 0 && endByLane.some((val) => val === null)) {
+					const item = measurements[endIndex];
+					if (endByLane[item.lane] === null) endByLane[item.lane] = item.end;
+					endIndex--;
+				}
+				end = Math.max(...endByLane.filter((val) => val !== null));
+			}
+			return Math.max(end - this.options.scrollMargin + this.options.paddingEnd, 0);
+		};
+		this._scrollToOffset = (offset, { adjustments, behavior }) => {
+			this.options.scrollToFn(offset, {
+				behavior,
+				adjustments
+			}, this);
+		};
+		this.measure = () => {
+			this.itemSizeCache = /* @__PURE__ */ new Map();
+			this.laneAssignments = /* @__PURE__ */ new Map();
+			this.notify(false);
+		};
+		this.setOptions(opts);
+	}
+};
+const findNearestBinarySearch = (low, high, getCurrentValue, value) => {
+	while (low <= high) {
+		const middle = (low + high) / 2 | 0;
+		const currentValue = getCurrentValue(middle);
+		if (currentValue < value) low = middle + 1;
+		else if (currentValue > value) high = middle - 1;
+		else return middle;
+	}
+	if (low > 0) return low - 1;
+	else return 0;
+};
+function calculateRange({ measurements, outerSize, scrollOffset, lanes }) {
+	const lastIndex = measurements.length - 1;
+	const getOffset = (index) => measurements[index].start;
+	if (measurements.length <= lanes) return {
+		startIndex: 0,
+		endIndex: lastIndex
+	};
+	let startIndex = findNearestBinarySearch(0, lastIndex, getOffset, scrollOffset);
+	let endIndex = startIndex;
+	if (lanes === 1) while (endIndex < lastIndex && measurements[endIndex].end < scrollOffset + outerSize) endIndex++;
+	else if (lanes > 1) {
+		const endPerLane = Array(lanes).fill(0);
+		while (endIndex < lastIndex && endPerLane.some((pos) => pos < scrollOffset + outerSize)) {
+			const item = measurements[endIndex];
+			endPerLane[item.lane] = item.end;
+			endIndex++;
+		}
+		const startPerLane = Array(lanes).fill(scrollOffset + outerSize);
+		while (startIndex >= 0 && startPerLane.some((pos) => pos >= scrollOffset)) {
+			const item = measurements[startIndex];
+			startPerLane[item.lane] = item.start;
+			startIndex--;
+		}
+		startIndex = Math.max(0, startIndex - startIndex % lanes);
+		endIndex = Math.min(lastIndex, endIndex + (lanes - 1 - endIndex % lanes));
+	}
+	return {
+		startIndex,
+		endIndex
+	};
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@tanstack+react-virtual@3.13.19_react-dom@19.2.6_react@19.2.6__react@19.2.6/node_modules/@tanstack/react-virtual/dist/esm/index.js
+const useIsomorphicLayoutEffect = typeof document !== "undefined" ? React$1.useLayoutEffect : React$1.useEffect;
+function useVirtualizerBase({ useFlushSync = true, ...options }) {
+	const rerender = React$1.useReducer(() => ({}), {})[1];
+	const resolvedOptions = {
+		...options,
+		onChange: (instance2, sync) => {
+			var _a;
+			if (useFlushSync && sync) flushSync(rerender);
+			else rerender();
+			(_a = options.onChange) == null || _a.call(options, instance2, sync);
+		}
+	};
+	const [instance] = React$1.useState(() => new Virtualizer(resolvedOptions));
+	instance.setOptions(resolvedOptions);
+	useIsomorphicLayoutEffect(() => {
+		return instance._didMount();
+	}, []);
+	useIsomorphicLayoutEffect(() => {
+		return instance._willUpdate();
+	});
+	return instance;
+}
+function useVirtualizer(options) {
+	return useVirtualizerBase({
+		observeElementRect,
+		observeElementOffset,
+		scrollToFn: elementScroll,
+		...options
+	});
+}
+//#endregion
+//#region editors/generic-drive-explorer/components/file-content-view.tsx
+const GAP = 8;
+const ITEM_WIDTH = 256;
+const ITEM_HEIGHT = 48;
+const USED_SPACE = 420;
+function FileContentView() {
+	const parentRef = useRef(null);
+	const availableWidth = useWindowSize().innerWidth - USED_SPACE;
+	const fileNodes = useNodesInSelectedDriveOrFolder().filter((n) => isFileNodeKind(n));
+	const columnCount = Math.floor(availableWidth / (ITEM_WIDTH + GAP)) || 1;
+	const rowVirtualizer = useVirtualizer({
+		count: Math.ceil(fileNodes.length / columnCount),
+		getScrollElement: () => parentRef.current,
+		estimateSize: (index) => {
+			if (index > 0) return ITEM_HEIGHT + GAP;
+			return ITEM_HEIGHT;
+		},
+		overscan: 5
+	});
+	const columnVirtualizer = useVirtualizer({
+		horizontal: true,
+		count: columnCount,
+		getScrollElement: () => parentRef.current,
+		estimateSize: (index) => {
+			if (index > 0) return ITEM_WIDTH + GAP;
+			return ITEM_WIDTH;
+		},
+		overscan: 5
+	});
+	const getItemIndex = (rowIndex, columnIndex) => rowIndex * columnCount + columnIndex;
+	const getItem = (rowIndex, columnIndex) => {
+		return fileNodes[getItemIndex(rowIndex, columnIndex)] || null;
+	};
+	if (fileNodes.length === 0) return /* @__PURE__ */ jsx("div", {
+		className: "mb-8 text-sm text-muted-foreground",
+		children: "No documents or files 📄"
+	});
+	const renderItem = (rowIndex, columnIndex) => {
+		const fileNode = getItem(rowIndex, columnIndex);
+		if (!fileNode) return null;
+		return /* @__PURE__ */ jsx("div", {
+			style: { marginLeft: columnIndex === 0 ? 0 : GAP },
+			children: /* @__PURE__ */ jsx(FileItem, { fileNode }, fileNode.id)
+		});
+	};
+	return /* @__PURE__ */ jsx("div", {
+		ref: parentRef,
+		style: {
+			width: `100%`,
+			overflow: "auto"
+		},
+		children: /* @__PURE__ */ jsx("div", {
+			style: {
+				height: `${rowVirtualizer.getTotalSize()}px`,
+				width: `${columnVirtualizer.getTotalSize()}px`,
+				position: "relative"
+			},
+			children: rowVirtualizer.getVirtualItems().map((virtualRow) => /* @__PURE__ */ jsx(React.Fragment, { children: columnVirtualizer.getVirtualItems().map((virtualColumn) => /* @__PURE__ */ jsx("div", {
+				style: {
+					position: "absolute",
+					top: 0,
+					left: 0,
+					marginTop: virtualRow.index === 0 ? 0 : GAP,
+					width: `${virtualColumn.size}px`,
+					height: `${ITEM_HEIGHT}px`,
+					overflow: "hidden",
+					transform: `translateX(${virtualColumn.start}px) translateY(${virtualRow.start}px)`
+				},
+				children: renderItem(virtualRow.index, virtualColumn.index)
+			}, virtualColumn.key)) }, virtualRow.key))
+		})
+	});
+}
+//#endregion
+//#region editors/generic-drive-explorer/components/layout.tsx
+function DriveLayout({ children, className, ...props }) {
+	return /* @__PURE__ */ jsx(DriveLayout.Container, {
+		className,
+		...props,
+		children
+	});
+}
+DriveLayout.Container = function DriveLayoutContainer({ children, className, containerProps, ...props }) {
+	return /* @__PURE__ */ jsx("div", {
+		className: twMerge("flex grow flex-col overflow-auto", className),
+		...containerProps,
+		...props,
+		children
+	});
+};
+DriveLayout.Header = function DriveLayoutHeader({ children, className, containerProps, ...props }) {
+	return /* @__PURE__ */ jsx("div", {
+		className: twMerge("flex-0", className),
+		...containerProps,
+		...props,
+		children
+	});
+};
+DriveLayout.Content = function DriveLayoutContent({ children, className, containerProps, ...props }) {
+	return /* @__PURE__ */ jsx("div", {
+		className: twMerge("mb-5 flex-1 px-4", className),
+		...containerProps,
+		...props,
+		children
+	});
+};
+DriveLayout.ContentSection = function DriveLayoutContentSection({ title, actions, children, className, containerProps, ...props }) {
+	return /* @__PURE__ */ jsxs("div", {
+		className: twMerge(className),
+		...containerProps,
+		...props,
+		children: [(title || actions) && /* @__PURE__ */ jsxs("div", {
+			className: "mb-4 flex items-center justify-between gap-3",
+			children: [title && /* @__PURE__ */ jsx("div", {
+				className: "text-base font-semibold text-foreground",
+				children: title
+			}), actions]
+		}), /* @__PURE__ */ jsx("div", {
+			className: "flex flex-wrap gap-2",
+			children
+		})]
+	});
+};
+//#endregion
+//#region editors/generic-drive-explorer/components/folder-view.tsx
+function FolderView(props) {
+	const { className } = props;
+	const folderNodes = useNodesInSelectedDriveOrFolder().filter((n) => isFolderNodeKind(n));
+	return /* @__PURE__ */ jsxs("div", {
+		className: twMerge("rounded-md border-2 border-transparent p-2", className),
+		children: [/* @__PURE__ */ jsx(DriveLayout.ContentSection, {
+			title: "Folders",
+			className: "mb-4",
+			children: folderNodes.length > 0 ? folderNodes.map((folderNode) => /* @__PURE__ */ jsx(FolderItem, { folderNode }, folderNode.id)) : /* @__PURE__ */ jsx("div", {
+				className: "mb-8 text-sm text-muted-foreground",
+				children: "No documents or files 📄"
+			})
+		}), /* @__PURE__ */ jsx(DriveLayout.ContentSection, {
+			title: "Documents and files",
+			actions: /* @__PURE__ */ jsx(CreateDocument, {}),
+			children: /* @__PURE__ */ jsx("div", {
+				className: "w-full",
+				children: /* @__PURE__ */ jsx(FileContentView, {})
+			})
+		})]
+	});
+}
+//#endregion
+export { CreateDocument as i, DriveLayout as n, FileContentView as r, FolderView as t };
+
+//# sourceMappingURL=folder-view-CzItU0hn.js.map