@uipath/apollo-wind 2.61.0 → 2.63.0

package/dist/components/ui/folder-picker/folder-picker.d.ts

@@ -0,0 +1,34 @@
+import type { FolderPickerContentProps, FolderPickerProps } from './types';
+/**
+ * Browsing surface for embedding in a consumer-owned popover, dialog or sheet.
+ *
+ * Follows the platform chooser convention: a single click highlights a row as
+ * the pending selection, a double click or the trailing chevron opens it, the
+ * breadcrumb jumps back up, and the footer confirms. With nothing highlighted,
+ * Select confirms the folder currently being browsed, so a folder can be chosen
+ * by opening it. At the root with no highlight there is nothing valid to
+ * confirm and Select is disabled.
+ */
+export declare function FolderPickerContent({ onLoadChildren, onSelect, onCancel, initialPath, rootLabel, breadcrumbLabel, searchPlaceholder, clearSearchLabel, initialSearch, emptyText, noMatchText, openFolderLabel, loadingText, loadErrorText, retryLabel, listLabel, footerLeading, cancelLabel, selectLabel, className, }: FolderPickerContentProps): import("react/jsx-runtime").JSX.Element;
+/**
+ * Holds a Radix surface open while the picker's search has text, so Escape
+ * clears the search instead of dismissing, wherever focus is in the picker.
+ * Radix hears Escape in the capture phase, before the picker's own handlers,
+ * so the picker cannot stop the dismissal itself. It clears the search as the
+ * key reaches it.
+ *
+ * `FolderPicker` applies it to its popover. Pass it as `onEscapeKeyDown` to a
+ * Dialog, Sheet or Popover that hosts `FolderPickerContent`.
+ */
+export declare function keepFolderSearchOnEscape(event: {
+    target: EventTarget | null;
+    preventDefault(): void;
+}): void;
+/**
+ * Field-and-popover folder picker over a lazily loaded tree.
+ *
+ * The trigger leads with its icon and then the value, matching the date field,
+ * so an empty folder field does not read as bare chrome next to it.
+ */
+export declare function FolderPicker({ value, placeholder, disabled, clearable, clearAriaLabel, dialogLabel, children, align, open: controlledOpen, onOpenChange, trailingAdornment, contentClassName, className, id, 'aria-labelledby': ariaLabelledBy, 'aria-describedby': ariaDescribedBy, onSelect, ...contentProps }: FolderPickerProps): import("react/jsx-runtime").JSX.Element;
+export type { FolderPickerContentProps, FolderPickerEntry, FolderPickerLoadChildren, FolderPickerProps, } from './types';

package/dist/components/ui/folder-picker/folder-picker.js

@@ -0,0 +1,425 @@
+"use client";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { FolderOpen, X } from "lucide-react";
+import { useCallback, useEffect, useLayoutEffect, useMemo, useRef, useState } from "react";
+import { Popover, PopoverContent, PopoverTrigger } from "../popover.js";
+import { cn } from "../../../lib/index.js";
+import { FolderBreadcrumb } from "./components/folder-breadcrumb.js";
+import { FolderPickerEmptyState } from "./components/folder-picker-empty-state.js";
+import { FolderPickerFooter } from "./components/folder-picker-footer.js";
+import { FolderPickerSearch } from "./components/folder-picker-search.js";
+import { FolderRow } from "./components/folder-row.js";
+import { cacheKey, isValidSegment, joinPath } from "./types.js";
+const listedDraft = (current, entries, segments)=>entries.some((entry)=>!entry.disabled && joinPath([
+            ...segments,
+            entry.name
+        ]) === current) ? current : null;
+function FolderPickerContent({ onLoadChildren, onSelect, onCancel, initialPath, rootLabel = 'Root', breadcrumbLabel, searchPlaceholder = 'Search...', clearSearchLabel, initialSearch = '', emptyText = 'No subfolders.', noMatchText, openFolderLabel, loadingText = 'Loading…', loadErrorText = 'Could not load this folder.', retryLabel = 'Retry', listLabel = 'Folders', footerLeading, cancelLabel = 'Cancel', selectLabel = 'Select', className }) {
+    const initialSegments = useMemo(()=>(initialPath ?? '').split('/').filter(Boolean), [
+        initialPath
+    ]);
+    const [pathStack, setPathStack] = useState(()=>initialSegments.slice(0, -1));
+    const [draft, setDraft] = useState(()=>initialSegments.length > 0 ? joinPath(initialSegments) : null);
+    const [search, setSearch] = useState(initialSearch);
+    const [levels, setLevels] = useState(()=>new Map());
+    const [loadingPath, setLoadingPath] = useState(()=>joinPath(initialSegments.slice(0, -1)));
+    const [error, setError] = useState(null);
+    const [activeName, setActiveName] = useState(()=>initialSegments[initialSegments.length - 1] ?? null);
+    const rowRefs = useRef(new Map());
+    const listRef = useRef(null);
+    const rootRef = useRef(null);
+    const focusAfterNavigateRef = useRef(false);
+    const requestRef = useRef(0);
+    const mountedRef = useRef(true);
+    useEffect(()=>{
+        mountedRef.current = true;
+        return ()=>{
+            mountedRef.current = false;
+        };
+    }, []);
+    const loadLevel = useCallback(async (segments, { keepDraft = false, keepSearch = false, nextActive } = {})=>{
+        const key = cacheKey(segments);
+        const requestId = ++requestRef.current;
+        const cached = levels.get(key);
+        if (cached) {
+            setLoadingPath(null);
+            setError(null);
+            setPathStack(segments);
+            if (void 0 !== nextActive) setActiveName(nextActive);
+            if (keepDraft) setDraft((current)=>listedDraft(current, cached, segments));
+            return;
+        }
+        setLoadingPath(joinPath(segments));
+        setError(null);
+        try {
+            const loaded = await onLoadChildren(segments);
+            if (!mountedRef.current || requestRef.current !== requestId) return;
+            const seen = new Set();
+            const entries = loaded.filter((entry)=>{
+                if (!isValidSegment(entry.name) || seen.has(entry.name)) return false;
+                seen.add(entry.name);
+                return true;
+            });
+            if (entries.length < loaded.length) console.warn('FolderPicker: dropped entries whose name is empty, contains "/" or repeats a sibling, which paths cannot represent.');
+            setLevels((current)=>new Map(current).set(key, entries));
+            setPathStack(segments);
+            if (void 0 !== nextActive) setActiveName(nextActive);
+            if (keepDraft) setDraft((current)=>listedDraft(current, entries, segments));
+            else {
+                setDraft(null);
+                if (!keepSearch) setSearch('');
+            }
+        } catch (cause) {
+            if (!mountedRef.current || requestRef.current !== requestId) return;
+            if (keepDraft) setDraft(null);
+            setError({
+                message: cause instanceof Error && cause.message ? cause.message : loadErrorText,
+                segments
+            });
+        } finally{
+            if (mountedRef.current && requestRef.current === requestId) setLoadingPath(null);
+        }
+    }, [
+        levels,
+        onLoadChildren,
+        loadErrorText
+    ]);
+    const initialStack = useRef(pathStack);
+    const didLoadInitial = useRef(false);
+    useEffect(()=>{
+        if (didLoadInitial.current) return;
+        didLoadInitial.current = true;
+        loadLevel(initialStack.current, {
+            keepDraft: true
+        });
+    }, [
+        loadLevel
+    ]);
+    const handleEscape = (event)=>{
+        if ('Escape' !== event.key || !search) return;
+        event.preventDefault();
+        event.stopPropagation();
+        setSearch('');
+    };
+    const navigateTo = (segments)=>{
+        if (loadingPath === joinPath(segments)) return;
+        setDraft(null);
+        setSearch('');
+        const isAncestor = segments.every((segment, index)=>pathStack[index] === segment);
+        loadLevel(segments, {
+            nextActive: isAncestor ? pathStack[segments.length] ?? null : null
+        });
+    };
+    const currentKey = cacheKey(pathStack);
+    const entries = levels.get(currentKey) ?? [];
+    const isLoadingCurrentLevel = null !== loadingPath && !levels.has(currentKey);
+    const levelError = levels.has(currentKey) ? null : error?.message ?? null;
+    const drillError = levels.has(currentKey) ? error?.message ?? null : null;
+    const normalizedQuery = search.trim().toLowerCase();
+    const visibleEntries = normalizedQuery ? entries.filter((entry)=>(entry.label ?? entry.name).toLowerCase().includes(normalizedQuery)) : entries;
+    const visibleDraft = visibleEntries.some((entry)=>joinPath([
+            ...pathStack,
+            entry.name
+        ]) === draft) ? draft : null;
+    const effectiveSelection = levels.has(currentKey) ? visibleDraft ?? (pathStack.length > 0 ? joinPath(pathStack) : null) : null;
+    const focusableEntries = visibleEntries.filter((entry)=>!entry.disabled);
+    const activeEntryName = focusableEntries.find((entry)=>entry.name === activeName)?.name ?? focusableEntries[0]?.name ?? null;
+    useEffect(()=>{
+        if (!focusAfterNavigateRef.current || null !== loadingPath) return;
+        focusAfterNavigateRef.current = false;
+        const tree = listRef.current;
+        const focused = tree?.ownerDocument.activeElement;
+        const focusLost = !focused || focused === tree?.ownerDocument.body;
+        const onRowOrFallback = focused === tree || focused?.getAttribute('role') === 'treeitem';
+        if (!focusLost && !(onRowOrFallback && tree?.contains(focused))) return;
+        const row = null === activeEntryName ? void 0 : rowRefs.current.get(activeEntryName);
+        (row ?? listRef.current)?.focus();
+    });
+    const syncedPath = useRef(initialPath);
+    useEffect(()=>{
+        if (syncedPath.current === initialPath) return;
+        syncedPath.current = initialPath;
+        const root = rootRef.current;
+        if (root?.contains(root.ownerDocument.activeElement)) focusAfterNavigateRef.current = true;
+        setDraft(initialSegments.length > 0 ? joinPath(initialSegments) : null);
+        setSearch('');
+        loadLevel(initialSegments.slice(0, -1), {
+            keepDraft: true,
+            nextActive: initialSegments[initialSegments.length - 1] ?? null
+        });
+    }, [
+        initialPath,
+        initialSegments,
+        loadLevel
+    ]);
+    const focusRow = (name)=>{
+        setActiveName(name);
+        rowRefs.current.get(name)?.focus();
+    };
+    const openFolder = (segments)=>{
+        focusAfterNavigateRef.current = true;
+        navigateTo(segments);
+    };
+    const handleTreeKeyDown = (event)=>{
+        const target = event.target;
+        if (target !== listRef.current && 'treeitem' !== target.getAttribute('role')) return;
+        const index = target === listRef.current ? -1 : focusableEntries.findIndex((entry)=>entry.name === activeEntryName);
+        let next;
+        switch(event.key){
+            case 'ArrowDown':
+                next = focusableEntries[Math.min(index + 1, focusableEntries.length - 1)];
+                break;
+            case 'ArrowUp':
+                next = focusableEntries[Math.max(index - 1, 0)];
+                break;
+            case 'Home':
+                next = focusableEntries[0];
+                break;
+            case 'End':
+                next = focusableEntries[focusableEntries.length - 1];
+                break;
+            case 'ArrowLeft':
+                if (0 === pathStack.length) return;
+                event.preventDefault();
+                openFolder(pathStack.slice(0, -1));
+                return;
+            default:
+                return;
+        }
+        event.preventDefault();
+        if (next) focusRow(next.name);
+    };
+    const crumbs = [
+        {
+            key: '/',
+            label: rootLabel,
+            stack: []
+        },
+        ...pathStack.map((segment, index)=>{
+            const stack = pathStack.slice(0, index + 1);
+            const parent = levels.get(cacheKey(pathStack.slice(0, index)));
+            const label = parent?.find((entry)=>entry.name === segment)?.label ?? segment;
+            return {
+                key: joinPath(stack),
+                label,
+                stack
+            };
+        })
+    ];
+    return /*#__PURE__*/ jsxs("div", {
+        ref: rootRef,
+        "data-slot": "folder-picker",
+        className: cn('flex min-w-0 flex-col overflow-hidden', className),
+        onKeyDown: handleEscape,
+        children: [
+            /*#__PURE__*/ jsx(FolderBreadcrumb, {
+                crumbs: crumbs,
+                onJump: openFolder,
+                label: breadcrumbLabel
+            }),
+            /*#__PURE__*/ jsx(FolderPickerSearch, {
+                value: search,
+                onChange: setSearch,
+                placeholder: searchPlaceholder,
+                clearLabel: clearSearchLabel
+            }),
+            /*#__PURE__*/ jsxs("div", {
+                ref: listRef,
+                role: "group",
+                "aria-label": listLabel,
+                tabIndex: null === activeEntryName ? 0 : -1,
+                className: "max-h-56 min-h-0 flex-1 overflow-y-auto py-1 outline-none focus-visible:ring-2 focus-visible:ring-inset focus-visible:ring-ring",
+                onKeyDown: handleTreeKeyDown,
+                children: [
+                    0 === visibleEntries.length && /*#__PURE__*/ jsx(FolderPickerEmptyState, {
+                        error: levelError,
+                        loading: isLoadingCurrentLevel,
+                        query: search.trim(),
+                        emptyText: emptyText,
+                        noMatchText: noMatchText,
+                        loadingText: loadingText,
+                        retryLabel: retryLabel,
+                        onRetry: ()=>{
+                            if (!error) return;
+                            listRef.current?.focus();
+                            focusAfterNavigateRef.current = true;
+                            if (cacheKey(error.segments) === currentKey) loadLevel(pathStack, {
+                                keepSearch: true
+                            });
+                            else navigateTo(error.segments);
+                        }
+                    }),
+                    drillError && /*#__PURE__*/ jsx("div", {
+                        role: "alert",
+                        className: "px-3 py-2 text-xs text-destructive",
+                        children: drillError
+                    }),
+                    (visibleEntries.length > 0 || isLoadingCurrentLevel) && /*#__PURE__*/ jsx("div", {
+                        role: "tree",
+                        "aria-label": listLabel,
+                        "aria-busy": isLoadingCurrentLevel || void 0,
+                        children: visibleEntries.map((entry)=>{
+                            const segments = [
+                                ...pathStack,
+                                entry.name
+                            ];
+                            const fullPath = joinPath(segments);
+                            const isSelected = draft === fullPath;
+                            return /*#__PURE__*/ jsx(FolderRow, {
+                                entry: entry,
+                                level: pathStack.length + 1,
+                                selected: isSelected,
+                                active: entry.name === activeEntryName,
+                                loading: loadingPath === fullPath,
+                                rowRef: (node)=>{
+                                    if (node) rowRefs.current.set(entry.name, node);
+                                    else rowRefs.current.delete(entry.name);
+                                },
+                                onFocus: ()=>setActiveName(entry.name),
+                                onToggleSelect: ()=>setDraft(isSelected ? null : fullPath),
+                                onOpen: ()=>openFolder(segments),
+                                openLabel: openFolderLabel
+                            }, fullPath);
+                        })
+                    })
+                ]
+            }),
+            /*#__PURE__*/ jsx(FolderPickerFooter, {
+                leading: footerLeading,
+                onCancel: onCancel,
+                onSelect: ()=>effectiveSelection && onSelect(effectiveSelection),
+                selectDisabled: !effectiveSelection,
+                cancelLabel: cancelLabel,
+                selectLabel: selectLabel
+            })
+        ]
+    });
+}
+function keepFolderSearchOnEscape(event) {
+    const target = event.target;
+    if (!(target instanceof Element)) return;
+    const search = target.closest('[data-slot="folder-picker"]')?.querySelector('input[data-slot="folder-picker-search"]');
+    if (search?.value) event.preventDefault();
+}
+function FolderPicker({ value = '', placeholder = 'Select a folder…', disabled = false, clearable = true, clearAriaLabel = 'Clear folder', dialogLabel = 'Choose a folder', children, align = 'start', open: controlledOpen, onOpenChange, trailingAdornment, contentClassName, className, id, 'aria-labelledby': ariaLabelledBy, 'aria-describedby': ariaDescribedBy, onSelect, ...contentProps }) {
+    const [uncontrolledOpen, setUncontrolledOpen] = useState(false);
+    const requestedOpen = controlledOpen ?? uncontrolledOpen;
+    const open = requestedOpen && !disabled;
+    const closedByDisable = disabled && requestedOpen;
+    useEffect(()=>{
+        if (!closedByDisable) return;
+        setUncontrolledOpen(false);
+        onOpenChange?.(false);
+    }, [
+        closedByDisable
+    ]);
+    const contentRef = useRef(null);
+    const browsePath = useRef(value);
+    if (open) browsePath.current = value;
+    const triggerRef = useRef(null);
+    const trailingRef = useRef(null);
+    const [trailingWidth, setTrailingWidth] = useState(0);
+    const showClear = clearable && Boolean(value) && !disabled && !children;
+    const showAdornment = Boolean(trailingAdornment) && !children;
+    const hasTrailing = showAdornment || showClear;
+    useLayoutEffect(()=>{
+        const el = trailingRef.current;
+        if (!el) return void setTrailingWidth(0);
+        setTrailingWidth(el.offsetWidth);
+        if ("u" < typeof ResizeObserver) return;
+        const observer = new ResizeObserver(()=>setTrailingWidth(el.offsetWidth));
+        observer.observe(el);
+        return ()=>observer.disconnect();
+    }, [
+        hasTrailing
+    ]);
+    const setOpen = (nextOpen)=>{
+        if (nextOpen && disabled) return;
+        if (void 0 === controlledOpen) setUncontrolledOpen(nextOpen);
+        onOpenChange?.(nextOpen);
+    };
+    return /*#__PURE__*/ jsxs("div", {
+        className: cn('group relative min-w-0', className),
+        children: [
+            /*#__PURE__*/ jsxs(Popover, {
+                open: open,
+                onOpenChange: setOpen,
+                children: [
+                    /*#__PURE__*/ jsx(PopoverTrigger, {
+                        asChild: true,
+                        disabled: disabled,
+                        children: children ?? /*#__PURE__*/ jsxs("button", {
+                            ref: triggerRef,
+                            type: "button",
+                            disabled: disabled,
+                            id: id,
+                            "aria-labelledby": ariaLabelledBy,
+                            "aria-describedby": ariaDescribedBy,
+                            role: "combobox",
+                            "aria-haspopup": "dialog",
+                            "aria-expanded": open,
+                            style: trailingWidth > 0 ? {
+                                paddingRight: trailingWidth + 20
+                            } : void 0,
+                            className: cn('flex h-9 w-full min-w-0 cursor-pointer items-center gap-2 rounded-md border border-input bg-transparent pl-3 pr-3 text-left text-base transition-colors md:text-sm', 'focus:outline-none focus:ring-2 focus:ring-ring focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring', 'disabled:cursor-not-allowed disabled:opacity-50', 'future:h-10 future:rounded-xl future:border-0 future:bg-surface-overlay future:px-4 future:font-normal future:hover:bg-surface-hover'),
+                            children: [
+                                /*#__PURE__*/ jsx(FolderOpen, {
+                                    size: 16,
+                                    className: "shrink-0 text-foreground-muted"
+                                }),
+                                /*#__PURE__*/ jsx("span", {
+                                    className: cn('min-w-0 flex-1 truncate', value ? 'text-foreground' : 'text-foreground-subtle'),
+                                    children: value || placeholder
+                                })
+                            ]
+                        })
+                    }),
+                    /*#__PURE__*/ jsx(PopoverContent, {
+                        "aria-label": dialogLabel,
+                        align: align,
+                        sideOffset: 4,
+                        className: cn('w-(--radix-popover-trigger-width) min-w-72 overflow-hidden p-0', contentClassName),
+                        ref: contentRef,
+                        onOpenAutoFocus: (event)=>{
+                            event.preventDefault();
+                            contentRef.current?.querySelector('input')?.focus();
+                        },
+                        onEscapeKeyDown: keepFolderSearchOnEscape,
+                        children: /*#__PURE__*/ jsx(FolderPickerContent, {
+                            ...contentProps,
+                            initialPath: browsePath.current,
+                            onCancel: ()=>setOpen(false),
+                            onSelect: (path)=>{
+                                onSelect(path);
+                                setOpen(false);
+                            }
+                        })
+                    })
+                ]
+            }),
+            hasTrailing && /*#__PURE__*/ jsxs("span", {
+                ref: trailingRef,
+                className: "pointer-events-none absolute inset-y-0 right-2 flex items-center gap-0.5",
+                children: [
+                    showClear && /*#__PURE__*/ jsx("button", {
+                        type: "button",
+                        "aria-label": clearAriaLabel,
+                        className: "pointer-events-auto grid size-4 cursor-pointer place-items-center rounded text-foreground-muted opacity-0 transition-opacity hover:text-foreground group-hover:opacity-100 focus-visible:opacity-100",
+                        onClick: ()=>{
+                            triggerRef.current?.focus();
+                            onSelect('');
+                        },
+                        children: /*#__PURE__*/ jsx(X, {
+                            size: 11
+                        })
+                    }),
+                    showAdornment && /*#__PURE__*/ jsx("span", {
+                        className: "pointer-events-auto flex items-center",
+                        children: trailingAdornment
+                    })
+                ]
+            })
+        ]
+    });
+}
+export { FolderPicker, FolderPickerContent, keepFolderSearchOnEscape };

package/dist/components/ui/folder-picker/index.cjs

@@ -0,0 +1,42 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    FolderPickerContent: ()=>external_folder_picker_cjs_namespaceObject.FolderPickerContent,
+    FolderPicker: ()=>external_folder_picker_cjs_namespaceObject.FolderPicker,
+    keepFolderSearchOnEscape: ()=>external_folder_picker_cjs_namespaceObject.keepFolderSearchOnEscape
+});
+const external_folder_picker_cjs_namespaceObject = require("./folder-picker.cjs");
+exports.FolderPicker = __webpack_exports__.FolderPicker;
+exports.FolderPickerContent = __webpack_exports__.FolderPickerContent;
+exports.keepFolderSearchOnEscape = __webpack_exports__.keepFolderSearchOnEscape;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "FolderPicker",
+    "FolderPickerContent",
+    "keepFolderSearchOnEscape"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/components/ui/folder-picker/index.d.ts

@@ -0,0 +1,2 @@
+export type { FolderPickerContentProps, FolderPickerEntry, FolderPickerLoadChildren, FolderPickerProps, } from './folder-picker';
+export { FolderPicker, FolderPickerContent, keepFolderSearchOnEscape } from './folder-picker';

package/dist/components/ui/folder-picker/index.js

@@ -0,0 +1,2 @@
+import { FolderPicker, FolderPickerContent, keepFolderSearchOnEscape } from "./folder-picker.js";
+export { FolderPicker, FolderPickerContent, keepFolderSearchOnEscape };

package/dist/components/ui/folder-picker/types.cjs

@@ -0,0 +1,44 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    cacheKey: ()=>cacheKey,
+    isValidSegment: ()=>isValidSegment,
+    joinPath: ()=>joinPath
+});
+const joinPath = (segments)=>`/${segments.join('/')}`;
+const cacheKey = (segments)=>JSON.stringify(segments);
+const isValidSegment = (name)=>'' !== name && !name.includes('/');
+exports.cacheKey = __webpack_exports__.cacheKey;
+exports.isValidSegment = __webpack_exports__.isValidSegment;
+exports.joinPath = __webpack_exports__.joinPath;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "cacheKey",
+    "isValidSegment",
+    "joinPath"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/components/ui/folder-picker/types.d.ts

@@ -0,0 +1,97 @@
+import type { ReactElement, ReactNode } from 'react';
+export interface FolderPickerEntry {
+    /**
+     * Segment name as it appears in the path. Unique among its siblings, and
+     * non-empty without a `/`, since paths are `/`-joined strings. An entry that
+     * breaks this, or repeats an earlier sibling's name, is dropped with a
+     * warning rather than collide with another path.
+     */
+    name: string;
+    /** Row label. Defaults to `name`. */
+    label?: string;
+    /** False marks a known leaf, which hides its open affordance. Unknown by default. */
+    hasChildren?: boolean;
+    disabled?: boolean;
+}
+/**
+ * Loads one level of the tree. The root is requested with an empty path.
+ * Resolved levels are cached, so navigating back up does not re-request.
+ */
+export type FolderPickerLoadChildren = (path: string[]) => Promise<FolderPickerEntry[]>;
+export interface FolderPickerContentProps {
+    /** Loads a level of the tree. Called for the root when the content mounts. */
+    onLoadChildren: FolderPickerLoadChildren;
+    /** Confirms a folder path, such as `/Finance/Invoices`. */
+    onSelect: (path: string) => void;
+    /** Closes the surface without confirming. */
+    onCancel?: () => void;
+    /** Browsing resumes at this path's parent, with the path itself highlighted. */
+    initialPath?: string;
+    /** Label for the breadcrumb's first segment. */
+    rootLabel?: string;
+    /** Accessible name for the breadcrumb's navigation landmark. */
+    breadcrumbLabel?: string;
+    searchPlaceholder?: string;
+    /** Accessible name for the search's clear control. */
+    clearSearchLabel?: string;
+    /** Seeds the search box, as VariablePicker's `initialQuery` does. */
+    initialSearch?: string;
+    emptyText?: string;
+    /** Shown when the search matches no folder in the level being browsed. */
+    noMatchText?: (query: string) => string;
+    /** Accessible name for a row's Open control, given the row's label. */
+    openFolderLabel?: (label: string) => string;
+    /** Shown while a level that has never resolved is loading. */
+    loadingText?: string;
+    /**
+     * Shown when a load fails without a message of its own: a rejection that is
+     * not an `Error`, or one whose message is empty. Otherwise that message is
+     * shown as given.
+     */
+    loadErrorText?: string;
+    /** Action offered when the level being browsed failed to load. */
+    retryLabel?: string;
+    /** Accessible name for the folder list. */
+    listLabel?: string;
+    /** Content for the footer's leading slot, such as a count or an "Add new" link. */
+    footerLeading?: ReactNode;
+    cancelLabel?: string;
+    selectLabel?: string;
+    className?: string;
+}
+export interface FolderPickerProps extends Omit<FolderPickerContentProps, 'onCancel' | 'initialPath' | 'className'> {
+    /** Selected folder path, or an empty string. */
+    value?: string;
+    placeholder?: string;
+    disabled?: boolean;
+    /** Hides the field's hover-revealed clear control. */
+    clearable?: boolean;
+    clearAriaLabel?: string;
+    /** Accessible name for the popover, which is a dialog. */
+    dialogLabel?: string;
+    /**
+     * A single element Radix can anchor the popover to. Replaces the default
+     * field, along with its clear control and `trailingAdornment`.
+     */
+    children?: ReactElement;
+    align?: 'start' | 'center' | 'end';
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    /**
+     * Rendered inside the default field at its trailing edge, such as a
+     * field-mode menu. Ignored with custom `children`, which own their layout.
+     */
+    trailingAdornment?: ReactNode;
+    /** Applied to the default trigger, so a `<label htmlFor>` pointing at it associates correctly. */
+    id?: string;
+    /** Id of the element naming this control, forwarded to the default trigger. */
+    'aria-labelledby'?: string;
+    'aria-describedby'?: string;
+    contentClassName?: string;
+    className?: string;
+}
+export declare const joinPath: (segments: string[]) => string;
+/** Collision-free, unlike a `/`-join, should a segment ever contain a `/`. */
+export declare const cacheKey: (segments: string[]) => string;
+/** A name that survives the round trip through a `/`-joined path. */
+export declare const isValidSegment: (name: string) => boolean;

package/dist/components/ui/folder-picker/types.js

@@ -0,0 +1,4 @@
+const joinPath = (segments)=>`/${segments.join('/')}`;
+const cacheKey = (segments)=>JSON.stringify(segments);
+const isValidSegment = (name)=>'' !== name && !name.includes('/');
+export { cacheKey, isValidSegment, joinPath };