@openviking/react 0.1.0 → 0.1.2

package/dist/n~0.js

@@ -0,0 +1,727 @@
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { forwardRef, useCallback, useEffect, useImperativeHandle, useRef, useState } from "react";
+import { FolderOpenIcon, FolderIcon, ChevronRightIcon, DocumentIcon } from "./k~0.js";
+function FileTreeFolderIcon({ open }) {
+    return /*#__PURE__*/ jsxs("span", {
+        className: "ov-file-tree__folder",
+        children: [
+            /*#__PURE__*/ jsx(FolderIcon, {
+                className: "ov-file-tree__folder-layer",
+                "data-open": !open
+            }),
+            /*#__PURE__*/ jsx(FolderOpenIcon, {
+                className: "ov-file-tree__folder-layer",
+                "data-open": open
+            })
+        ]
+    });
+}
+function FileTreeFileIcon() {
+    return /*#__PURE__*/ jsx(DocumentIcon, {
+        className: "ov-file-tree__file-icon"
+    });
+}
+function FileTreeChevron({ open }) {
+    return /*#__PURE__*/ jsx(ChevronRightIcon, {
+        className: "ov-file-tree__chevron",
+        "data-expanded": open || void 0,
+        width: 12,
+        height: 12
+    });
+}
+const TOOLTIP_ONLY_KEYS = new Set([
+    'profile',
+    'preferences',
+    'entities',
+    'events',
+    'identity',
+    'soul',
+    'cases',
+    'trajectories',
+    'experiences'
+]);
+const ROOT_KEY_BY_SEGMENT = {
+    agent: 'agentRoot',
+    agents: 'agentRoot',
+    memory: 'memoryRoot',
+    memories: 'memoryRoot',
+    resource: 'resourceRoot',
+    resources: 'resourceRoot',
+    session: 'sessionRoot',
+    sessions: 'sessionRoot',
+    system: 'systemRoot'
+};
+const USER_SCOPE_KEY_BY_SEGMENT = {
+    memories: 'memories',
+    peers: 'peers',
+    privacy: 'privacy',
+    resources: 'userResources',
+    sessions: 'sessions',
+    skills: 'skills'
+};
+const MEMORY_KEY_BY_SEGMENT = {
+    'profile.md': 'profile',
+    preferences: 'preferences',
+    entities: 'entities',
+    events: 'events',
+    'identity.md': 'identity',
+    'soul.md': 'soul',
+    cases: 'cases',
+    trajectories: 'trajectories',
+    experiences: 'experiences'
+};
+const USER_SEGMENTS = new Set([
+    'user',
+    'users'
+]);
+function splitVikingUri(uri) {
+    const withoutScheme = uri.replace(/^viking:\/*/i, '');
+    const withoutQuery = withoutScheme.split(/[?#]/)[0] ?? '';
+    return withoutQuery.split('/').map((segment)=>segment.trim()).filter(Boolean).map((segment)=>segment.toLowerCase());
+}
+function resolveFileTreeInfoKey(uri) {
+    const segments = splitVikingUri(uri);
+    const first = segments[0];
+    if (!first) return null;
+    if (USER_SEGMENTS.has(first)) {
+        if (segments.length <= 2) return 'userRoot';
+        const third = segments[2];
+        if (!third) return null;
+        if (3 === segments.length) return USER_SCOPE_KEY_BY_SEGMENT[third] ?? null;
+        if ('memories' !== third || 4 !== segments.length) return null;
+        const fourth = segments[3];
+        return fourth ? MEMORY_KEY_BY_SEGMENT[fourth] ?? null : null;
+    }
+    if (1 === segments.length) {
+        if ('resources' === first) return 'sharedResources';
+        return ROOT_KEY_BY_SEGMENT[first] ?? null;
+    }
+    return null;
+}
+function showsInlineDescription(key) {
+    return null !== key && !TOOLTIP_ONLY_KEYS.has(key);
+}
+const DESCRIPTION = {
+    userRoot: 'Context data for the current user',
+    memories: 'Long-term memory accumulated across sessions',
+    peers: 'Context isolated per application or workspace',
+    privacy: 'Keys and other sensitive configuration',
+    userResources: 'Private knowledge of this user',
+    sessions: 'Conversation and task execution records',
+    skills: 'Skills and tools available to the agent',
+    profile: 'User identity and background',
+    preferences: 'Personalized user preferences',
+    entities: 'People, projects, organizations and other entities',
+    events: 'Key events archived by date',
+    identity: 'Agent name and persona',
+    soul: 'Agent behaviour guidelines and boundaries',
+    cases: 'Interaction cases used to train experience',
+    trajectories: 'Reusable task execution trajectories',
+    experiences: 'Execution experience distilled automatically',
+    sharedResources: 'External resources the agent can reference',
+    agentRoot: 'Agent capabilities, tools and experience',
+    memoryRoot: 'Long-term memory and accumulated information',
+    resourceRoot: 'External knowledge the agent can reference',
+    sessionRoot: 'Raw session records of the user',
+    systemRoot: 'Built-in system resources'
+};
+const TRIGGER_BEHAVIOR = {
+    userRoot: 'Created from the current user identity; no manual setup needed',
+    memories: 'Committed sessions, explicit requests to remember, or continuous extraction from sessions',
+    peers: 'Created when connecting as a specific peer, isolating memory and material per peer_id',
+    userResources: 'Imported material, uploaded to this user’s private resource directory',
+    sessions: 'Created when a session calls OpenViking; messages, tool calls and archives are saved continuously',
+    skills: 'Created, installed or imported as a personal skill',
+    profile: 'A stable, explicit user background or working style appears in conversation',
+    preferences: 'The user explicitly states a specific preference, habit or style',
+    entities: 'A person, project or organization worth keeping appears in conversation',
+    events: 'An important decision, commitment, arrangement, progress or result appears in dialogue',
+    identity: 'Initialized on the first memory extraction run; later updated by write operations',
+    soul: 'Initialized on the first memory extraction run; later adjusted by write operations',
+    cases: 'A session with a clear task and an evaluable execution result is committed',
+    trajectories: 'A task containing decisions, tool calls or multi-step execution is committed',
+    experiences: 'Distilled from task cases and execution trajectories',
+    sharedResources: 'Imported material, uploaded to a shared resource space'
+};
+const DEFAULT_INFO_LABELS = {
+    description: DESCRIPTION,
+    triggerBehavior: TRIGGER_BEHAVIOR,
+    field: {
+        description: "Description",
+        triggerBehavior: 'Trigger',
+        path: 'Path'
+    }
+};
+function resolveInfoCopy(key, hostLabels) {
+    const description = hostLabels?.description?.[key] ?? DESCRIPTION[key] ?? void 0;
+    const triggerBehavior = hostLabels?.triggerBehavior?.[key] ?? TRIGGER_BEHAVIOR[key] ?? void 0;
+    return {
+        description: description || void 0,
+        triggerBehavior: triggerBehavior || void 0
+    };
+}
+const DEFAULT_FIELDS = {
+    description: "Description",
+    triggerBehavior: 'Trigger',
+    path: 'Path'
+};
+function resolveFileTreeInfoCopy(row, infoLabels) {
+    const key = resolveFileTreeInfoKey(row.uri);
+    const builtIn = key ? resolveInfoCopy(key, infoLabels) : {};
+    const description = row.description ?? builtIn.description;
+    if (!description && !builtIn.triggerBehavior) return null;
+    return {
+        title: row.name,
+        description,
+        triggerBehavior: builtIn.triggerBehavior,
+        path: row.uri,
+        fields: {
+            ...DEFAULT_FIELDS,
+            ...infoLabels?.field
+        }
+    };
+}
+function FileTreeInfoTooltip({ copy }) {
+    const { description, fields, path, title, triggerBehavior } = copy;
+    return /*#__PURE__*/ jsxs("span", {
+        className: "ov-file-tree__info",
+        children: [
+            /*#__PURE__*/ jsx("span", {
+                className: "ov-file-tree__info-title",
+                children: title
+            }),
+            description ? /*#__PURE__*/ jsxs("span", {
+                className: "ov-file-tree__info-row",
+                children: [
+                    /*#__PURE__*/ jsx("span", {
+                        className: "ov-file-tree__info-label",
+                        children: fields.description
+                    }),
+                    /*#__PURE__*/ jsx("span", {
+                        className: "ov-file-tree__info-value",
+                        children: description
+                    })
+                ]
+            }) : null,
+            triggerBehavior ? /*#__PURE__*/ jsxs("span", {
+                className: "ov-file-tree__info-row",
+                children: [
+                    /*#__PURE__*/ jsx("span", {
+                        className: "ov-file-tree__info-label",
+                        children: fields.triggerBehavior
+                    }),
+                    /*#__PURE__*/ jsx("span", {
+                        className: "ov-file-tree__info-value",
+                        children: triggerBehavior
+                    })
+                ]
+            }) : null,
+            /*#__PURE__*/ jsxs("span", {
+                className: "ov-file-tree__info-row",
+                children: [
+                    /*#__PURE__*/ jsx("span", {
+                        className: "ov-file-tree__info-label",
+                        children: fields.path
+                    }),
+                    /*#__PURE__*/ jsx("span", {
+                        className: "ov-file-tree__info-path",
+                        children: path
+                    })
+                ]
+            })
+        ]
+    });
+}
+function FileTreeTooltipSurface({ row, infoLabels, renderRowTooltip }) {
+    if (renderRowTooltip) {
+        const custom = renderRowTooltip(row);
+        if (null == custom || false === custom) return null;
+        return /*#__PURE__*/ jsx("span", {
+            role: "tooltip",
+            className: "ov-file-tree__tooltip",
+            children: custom
+        });
+    }
+    const copy = resolveFileTreeInfoCopy(row, infoLabels);
+    if (!copy) return null;
+    return /*#__PURE__*/ jsx("span", {
+        role: "tooltip",
+        className: "ov-file-tree__tooltip",
+        children: /*#__PURE__*/ jsx(FileTreeInfoTooltip, {
+            copy: copy
+        })
+    });
+}
+const INDENT = 20;
+const CHEVRON_SIZE = 16;
+function rowStyle(depth) {
+    return {
+        paddingLeft: 8 + depth * INDENT
+    };
+}
+function Guides({ depth }) {
+    return /*#__PURE__*/ jsx(Fragment, {
+        children: Array.from({
+            length: depth
+        }, (_, level)=>/*#__PURE__*/ jsx("span", {
+                "aria-hidden": "true",
+                className: "ov-file-tree__guide",
+                style: {
+                    left: 8 + level * INDENT + CHEVRON_SIZE / 2
+                }
+            }, level))
+    });
+}
+const FILE_TREE_ROW_ATTRIBUTE = 'data-file-tree-row-id';
+function FileTreeRowView({ row, ctx }) {
+    const { text, selectedId, tooltipRowId, getRowAttributes, renderDashboard, renderRowTooltip, renderRowIcon, onSelect, onToggleExpand, onOpenRetentionSettings, onRowKeyDown, onRowEnter, onRowLeave } = ctx;
+    const isDirectory = 'directory' === row.type;
+    const canExpand = isDirectory && false !== row.hasChildren;
+    const isExpanded = Boolean(row.expanded);
+    const isSelected = selectedId === row.id;
+    const extra = getRowAttributes?.(row) ?? {};
+    const { className: extraClassName, style: extraStyle, ...extraAttributes } = extra;
+    const dashboard = renderDashboard?.(row) ?? null;
+    const infoKey = resolveFileTreeInfoKey(row.uri);
+    const description = row.description ?? (infoKey && showsInlineDescription(infoKey) ? resolveInfoCopy(infoKey, ctx.infoLabels).description : void 0);
+    const handleClick = (event)=>{
+        if (event.target.closest('[data-role="toggle"]')) return;
+        if (row.disabled) return;
+        onSelect?.(row);
+    };
+    const handleToggle = (event)=>{
+        event.stopPropagation();
+        onToggleExpand?.(row);
+    };
+    return /*#__PURE__*/ jsxs("div", {
+        role: "treeitem",
+        tabIndex: 0,
+        "aria-level": row.depth + 1,
+        "aria-selected": isSelected,
+        "aria-expanded": canExpand ? isExpanded : void 0,
+        "aria-disabled": row.disabled || void 0,
+        ...extraAttributes,
+        [FILE_TREE_ROW_ATTRIBUTE]: row.id,
+        className: [
+            'ov-file-tree__row',
+            extraClassName
+        ].filter(Boolean).join(' '),
+        "data-selected": isSelected || void 0,
+        "data-disabled": row.disabled || void 0,
+        "data-kind": row.kind,
+        style: {
+            ...rowStyle(row.depth),
+            ...extraStyle
+        },
+        onClick: handleClick,
+        onKeyDown: (event)=>onRowKeyDown(event, row),
+        onMouseEnter: ()=>onRowEnter(row.id),
+        onMouseLeave: onRowLeave,
+        onFocus: ()=>onRowEnter(row.id),
+        onBlur: onRowLeave,
+        children: [
+            /*#__PURE__*/ jsx(Guides, {
+                depth: row.depth
+            }),
+            canExpand ? /*#__PURE__*/ jsx("button", {
+                type: "button",
+                "data-role": "toggle",
+                className: "ov-file-tree__toggle",
+                "aria-label": isExpanded ? text.collapse.replace('{name}', row.name) : text.expand.replace('{name}', row.name),
+                tabIndex: -1,
+                disabled: !onToggleExpand || row.disabled,
+                onClick: handleToggle,
+                children: row.busy ? ctx.renderSpinner?.() ?? /*#__PURE__*/ jsx("span", {
+                    className: "ov-file-tree__spinner"
+                }) : /*#__PURE__*/ jsx(FileTreeChevron, {
+                    open: isExpanded
+                })
+            }) : /*#__PURE__*/ jsx("span", {
+                "aria-hidden": "true",
+                className: "ov-file-tree__toggle-spacer"
+            }),
+            /*#__PURE__*/ jsx("span", {
+                className: "ov-file-tree__icon-slot",
+                children: isDirectory ? /*#__PURE__*/ jsx(FileTreeFolderIcon, {
+                    open: isExpanded
+                }) : renderRowIcon?.(row) ?? /*#__PURE__*/ jsx(FileTreeFileIcon, {})
+            }),
+            /*#__PURE__*/ jsxs("span", {
+                className: "ov-file-tree__label-group",
+                children: [
+                    /*#__PURE__*/ jsx("span", {
+                        className: "ov-file-tree__label",
+                        title: row.name,
+                        children: row.name
+                    }),
+                    description ? /*#__PURE__*/ jsx("span", {
+                        className: "ov-file-tree__description",
+                        children: description
+                    }) : null
+                ]
+            }),
+            row.busy && !canExpand ? /*#__PURE__*/ jsx("span", {
+                className: "ov-file-tree__spinner"
+            }) : null,
+            row.expiresAt ? /*#__PURE__*/ jsx("span", {
+                className: "ov-file-tree__expiry",
+                children: onOpenRetentionSettings ? /*#__PURE__*/ jsx("button", {
+                    type: "button",
+                    className: "ov-file-tree__expiry-action",
+                    onClick: (event)=>{
+                        event.stopPropagation();
+                        onOpenRetentionSettings(row.uri);
+                    },
+                    children: row.expiresAt
+                }) : row.expiresAt
+            }) : null,
+            row.levelLabel ? /*#__PURE__*/ jsx("span", {
+                className: "ov-file-tree__level",
+                children: row.levelLabel
+            }) : null,
+            dashboard ? /*#__PURE__*/ jsx("span", {
+                className: "ov-file-tree__dashboard",
+                children: dashboard
+            }) : null,
+            tooltipRowId === row.id ? /*#__PURE__*/ jsx(FileTreeTooltipSurface, {
+                row: row,
+                infoLabels: ctx.infoLabels,
+                renderRowTooltip: renderRowTooltip
+            }) : null
+        ]
+    });
+}
+function FileTreeStateRow({ row, ctx }) {
+    const { text, onLoadMore, onRetry, getRowAttributes, renderSpinner } = ctx;
+    const spinner = renderSpinner?.() ?? /*#__PURE__*/ jsx("span", {
+        className: "ov-file-tree__spinner"
+    });
+    const extra = getRowAttributes?.(row) ?? {};
+    const { className: extraClassName, style: extraStyle, ...extraAttributes } = extra;
+    const shell = (children, busy = false)=>/*#__PURE__*/ jsxs("div", {
+            role: "treeitem",
+            "aria-level": row.depth + 1,
+            "aria-selected": false,
+            "aria-busy": busy || void 0,
+            ...extraAttributes,
+            [FILE_TREE_ROW_ATTRIBUTE]: row.id,
+            className: [
+                'ov-file-tree__state-row',
+                extraClassName
+            ].filter(Boolean).join(' '),
+            style: {
+                ...rowStyle(row.depth),
+                ...extraStyle
+            },
+            children: [
+                /*#__PURE__*/ jsx(Guides, {
+                    depth: row.depth
+                }),
+                children
+            ]
+        });
+    switch(row.kind){
+        case 'loading':
+            return shell(/*#__PURE__*/ jsxs(Fragment, {
+                children: [
+                    /*#__PURE__*/ jsx("span", {
+                        className: "ov-file-tree__toggle-spacer"
+                    }),
+                    spinner,
+                    /*#__PURE__*/ jsx("span", {
+                        className: "ov-file-tree__muted",
+                        children: text.loading
+                    })
+                ]
+            }), true);
+        case 'load-more':
+            return shell(/*#__PURE__*/ jsxs(Fragment, {
+                children: [
+                    /*#__PURE__*/ jsx("span", {
+                        className: "ov-file-tree__toggle-spacer"
+                    }),
+                    row.loading ? spinner : null,
+                    /*#__PURE__*/ jsx("button", {
+                        type: "button",
+                        className: "ov-file-tree__action",
+                        disabled: row.loading || !onLoadMore,
+                        onClick: ()=>onLoadMore?.(row),
+                        children: row.loading ? text.loading : text.loadMore
+                    })
+                ]
+            }), Boolean(row.loading));
+        case 'error':
+            return shell(/*#__PURE__*/ jsxs(Fragment, {
+                children: [
+                    /*#__PURE__*/ jsx("span", {
+                        className: "ov-file-tree__toggle-spacer"
+                    }),
+                    /*#__PURE__*/ jsx("span", {
+                        className: "ov-file-tree__muted",
+                        children: row.message ?? text.error
+                    }),
+                    /*#__PURE__*/ jsx("button", {
+                        type: "button",
+                        className: "ov-file-tree__action",
+                        disabled: !onRetry,
+                        onClick: ()=>onRetry?.(row),
+                        children: text.retry
+                    })
+                ]
+            }));
+        case 'empty':
+            return shell(/*#__PURE__*/ jsxs(Fragment, {
+                children: [
+                    /*#__PURE__*/ jsx("span", {
+                        className: "ov-file-tree__toggle-spacer"
+                    }),
+                    /*#__PURE__*/ jsx("span", {
+                        className: "ov-file-tree__muted",
+                        children: text.empty
+                    })
+                ]
+            }));
+        default:
+            return null;
+    }
+}
+function isWholeTreeError(rows) {
+    if (1 !== rows.length) return false;
+    const [row] = rows;
+    return row?.kind === 'error' && !row.parentId;
+}
+function FileTreeBody({ rows, isReady, text, loadingFallback, errorFallback, emptyFallback, ctx }) {
+    if (!isReady) return /*#__PURE__*/ jsx("div", {
+        className: "ov-file-tree__state",
+        children: loadingFallback ?? /*#__PURE__*/ jsx("span", {
+            className: "ov-file-tree__muted",
+            children: text.loading
+        })
+    });
+    if (isWholeTreeError(rows)) {
+        const message = rows[0].message ?? text.error;
+        return /*#__PURE__*/ jsx("div", {
+            className: "ov-file-tree__state",
+            children: errorFallback ?? /*#__PURE__*/ jsx("span", {
+                className: "ov-file-tree__muted",
+                children: message
+            })
+        });
+    }
+    if (0 === rows.length) return /*#__PURE__*/ jsx("div", {
+        className: "ov-file-tree__state",
+        children: emptyFallback ?? /*#__PURE__*/ jsx("span", {
+            className: "ov-file-tree__muted",
+            children: text.empty
+        })
+    });
+    return /*#__PURE__*/ jsx("div", {
+        role: "group",
+        className: "ov-file-tree__rows",
+        children: rows.map((row)=>'entry' === row.kind ? /*#__PURE__*/ jsx(FileTreeRowView, {
+                row: row,
+                ctx: ctx
+            }, row.id) : /*#__PURE__*/ jsx(FileTreeStateRow, {
+                row: row,
+                ctx: ctx
+            }, row.id))
+    });
+}
+function visibleRows(root) {
+    if (!root) return [];
+    return Array.from(root.querySelectorAll(`[${FILE_TREE_ROW_ATTRIBUTE}]`));
+}
+function handleRowKeyDown(event, { root, row, onSelect, onToggleExpand }) {
+    const isDirectory = 'directory' === row.type;
+    const expanded = Boolean(row.expanded);
+    const canToggle = isDirectory && !row.disabled;
+    switch(event.key){
+        case 'ArrowDown':
+        case 'ArrowUp':
+            {
+                event.preventDefault();
+                const rows = visibleRows(root);
+                const index = rows.indexOf(event.currentTarget);
+                if (-1 === index) return;
+                rows[index + ('ArrowDown' === event.key ? 1 : -1)]?.focus();
+                return;
+            }
+        case 'ArrowRight':
+            if (canToggle && !expanded) {
+                event.preventDefault();
+                onToggleExpand?.(row);
+            }
+            return;
+        case 'ArrowLeft':
+            if (canToggle && expanded) {
+                event.preventDefault();
+                onToggleExpand?.(row);
+            }
+            return;
+        case 'Enter':
+        case ' ':
+            event.preventDefault();
+            if (!row.disabled) onSelect?.(row);
+            return;
+        default:
+            return;
+    }
+}
+const DEFAULT_DELAY = 400;
+function useRowTooltip(delay = DEFAULT_DELAY) {
+    const [tooltipRowId, setTooltipRowId] = useState(null);
+    const timerRef = useRef(void 0);
+    const clear = useCallback(()=>{
+        if (void 0 !== timerRef.current) {
+            window.clearTimeout(timerRef.current);
+            timerRef.current = void 0;
+        }
+    }, []);
+    useEffect(()=>clear, [
+        clear
+    ]);
+    const show = useCallback((rowId)=>{
+        clear();
+        timerRef.current = window.setTimeout(()=>{
+            setTooltipRowId(rowId);
+            timerRef.current = void 0;
+        }, delay);
+    }, [
+        clear,
+        delay
+    ]);
+    const hide = useCallback(()=>{
+        clear();
+        setTooltipRowId(null);
+    }, [
+        clear
+    ]);
+    return {
+        tooltipRowId,
+        show,
+        hide
+    };
+}
+function useFileTreeActions(props) {
+    const pending = useRef(new Set());
+    const { select, toggleExpand, loadMore, retry, openRetentionSettings } = props.operations ?? {};
+    async function run(key, execute, notify, value) {
+        if (pending.current.has(key)) return;
+        pending.current.add(key);
+        try {
+            await execute(value);
+        } catch  {
+            return;
+        } finally{
+            pending.current.delete(key);
+        }
+        notify?.(value);
+    }
+    return {
+        onSelect: select ? (row)=>void run(`select:${row.id}`, select, props.onSelect, row) : void 0,
+        onToggleExpand: toggleExpand ? (row)=>void run(`toggle:${row.id}`, toggleExpand, props.onToggleExpand, row) : void 0,
+        onLoadMore: loadMore ? (row)=>void run(`load:${row.id}`, loadMore, props.onLoadMore, row) : void 0,
+        onRetry: retry ? (row)=>void run(`retry:${row.id}`, retry, props.onRetry, row) : void 0,
+        onOpenRetentionSettings: openRetentionSettings ? (uri)=>void run(`retention:${uri}`, openRetentionSettings, props.onOpenRetentionSettings, uri) : void 0
+    };
+}
+function FileTreeSpinner({ className, ...rest }) {
+    return /*#__PURE__*/ jsx("span", {
+        "aria-hidden": "true",
+        ...rest,
+        className: [
+            'ov-file-tree__spinner',
+            className
+        ].filter(Boolean).join(' ')
+    });
+}
+const DEFAULT_LABELS = {
+    empty: 'No files yet',
+    error: 'Failed to load',
+    retry: 'Retry',
+    loadMore: 'Load more',
+    loading: 'Loading…',
+    expand: 'Expand {name}',
+    collapse: 'Collapse {name}'
+};
+function findRow(root, id) {
+    return root?.querySelector(`[${FILE_TREE_ROW_ATTRIBUTE}="${CSS.escape(id)}"]`) ?? null;
+}
+const file_tree_FileTree = /*#__PURE__*/ forwardRef(function({ rows, operations, selectedId, isReady = true, loadingFallback, errorFallback, emptyFallback, slots, labels, getRowAttributes, renderDashboard, renderRowTooltip, renderRowIcon, onSelect, onToggleExpand, onLoadMore, onRetry, onOpenRetentionSettings, className, ...rest }, ref) {
+    const rootRef = useRef(null);
+    const text = {
+        ...DEFAULT_LABELS,
+        ...labels,
+        info: labels?.info ?? DEFAULT_LABELS.info
+    };
+    const tooltip = useRowTooltip();
+    const actions = useFileTreeActions({
+        operations,
+        onSelect,
+        onToggleExpand,
+        onLoadMore,
+        onRetry,
+        onOpenRetentionSettings
+    });
+    useImperativeHandle(ref, ()=>({
+            getRowElement: (id)=>findRow(rootRef.current, id),
+            scrollToRow: (id, options)=>{
+                const element = findRow(rootRef.current, id);
+                if (!element) return false;
+                element.scrollIntoView({
+                    block: 'nearest',
+                    ...options
+                });
+                return true;
+            }
+        }), []);
+    const ctx = {
+        text,
+        infoLabels: labels?.info,
+        selectedId,
+        tooltipRowId: tooltip.tooltipRowId,
+        getRowAttributes,
+        renderDashboard,
+        renderRowTooltip,
+        renderRowIcon,
+        renderSpinner: slots?.spinner ? ()=>slots.spinner : void 0,
+        ...actions,
+        onRowKeyDown: (event, row)=>handleRowKeyDown(event, {
+                root: rootRef.current,
+                row,
+                onSelect: actions.onSelect,
+                onToggleExpand: actions.onToggleExpand
+            }),
+        onRowEnter: tooltip.show,
+        onRowLeave: tooltip.hide
+    };
+    return /*#__PURE__*/ jsxs("div", {
+        ...rest,
+        ref: rootRef,
+        className: [
+            'ov-file-tree',
+            className
+        ].filter(Boolean).join(' '),
+        children: [
+            slots?.toolbar ? /*#__PURE__*/ jsx("div", {
+                className: "ov-file-tree__toolbar",
+                children: slots.toolbar
+            }) : null,
+            /*#__PURE__*/ jsx("div", {
+                role: "tree",
+                "aria-label": rest['aria-label'],
+                className: "ov-file-tree__body",
+                children: /*#__PURE__*/ jsx(FileTreeBody, {
+                    rows: rows,
+                    isReady: isReady,
+                    text: text,
+                    loadingFallback: loadingFallback,
+                    errorFallback: errorFallback,
+                    emptyFallback: emptyFallback,
+                    ctx: ctx
+                })
+            })
+        ]
+    });
+});
+export { DEFAULT_INFO_LABELS, FILE_TREE_ROW_ATTRIBUTE, FileTreeSpinner, file_tree_FileTree as FileTree, resolveFileTreeInfoKey, resolveInfoCopy, showsInlineDescription, splitVikingUri };