@uipath/apollo-wind 2.79.0 → 2.79.2

package/dist/components/ui/json-tree-view/NodeKey.js

@@ -1,12 +1,12 @@
 import { jsx, jsxs } from "react/jsx-runtime";
 import { cn } from "../../../lib/index.js";
-import { useJsonTreeViewStrings } from "./strings.js";
 import { JsonTreeTooltip } from "./JsonTreeTooltip.js";
+import { useJsonTreeViewStrings } from "./strings.js";
 function NodeKey({ node, label, displayPath, onCopyPath, className }) {
     const strings = useJsonTreeViewStrings();
     const text = label ?? node.key;
     const copyPathText = displayPath ?? node.path;
-    const keyClass = cn('min-w-4 max-w-[45%] truncate text-xs text-foreground', null != label ? 'font-medium' : 'font-mono', void 0 === node.value && 'text-foreground-muted', className);
+    const keyClass = cn('min-w-4 truncate text-xs text-foreground', null != label ? 'font-medium' : 'font-mono', void 0 === node.value && 'text-foreground-muted', className);
     if (!onCopyPath) return /*#__PURE__*/ jsx("span", {
         className: keyClass,
         children: text

package/dist/components/ui/json-tree-view/RowActions.cjs

@@ -27,14 +27,14 @@ __webpack_require__.d(__webpack_exports__, {
     RowActions: ()=>RowActions
 });
 const jsx_runtime_namespaceObject = require("react/jsx-runtime");
-const external_button_cjs_namespaceObject = require("../button.cjs");
-const index_cjs_namespaceObject = require("../../../lib/index.cjs");
-const external_dropdown_menu_cjs_namespaceObject = require("../dropdown-menu.cjs");
 const external_lucide_react_namespaceObject = require("lucide-react");
 const external_react_namespaceObject = require("react");
-const external_strings_cjs_namespaceObject = require("./strings.cjs");
+const external_button_cjs_namespaceObject = require("../button.cjs");
+const external_dropdown_menu_cjs_namespaceObject = require("../dropdown-menu.cjs");
+const index_cjs_namespaceObject = require("../../../lib/index.cjs");
 const external_JsonTreeTooltip_cjs_namespaceObject = require("./JsonTreeTooltip.cjs");
-const ACTION_BUTTON_CLASS = 'shrink-0 rounded text-foreground-subtle opacity-0 hover:text-foreground hover:bg-surface-raised group-hover:opacity-100 group-focus-within:opacity-100 focus-visible:opacity-100';
+const external_strings_cjs_namespaceObject = require("./strings.cjs");
+const ACTION_BUTTON_CLASS = 'shrink-0 rounded text-foreground-subtle opacity-0 hover:text-foreground hover:bg-surface-raised group-hover:opacity-100 group-focus-within/row:opacity-100';
 const ACTION_TONE_CLASS = {
     neutral: '',
     info: 'text-info hover:text-info',
@@ -65,7 +65,7 @@ function RowActions({ node, actions, maxInline, meta }) {
             })
         }, action.id);
     return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsxs)("span", {
-        className: "ml-auto flex shrink-0 items-center gap-0.5",
+        className: "flex shrink-0 items-center gap-0.5",
         children: [
             inline.filter((action)=>'start' === action.placement).map(renderInline),
             null != meta && /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)("span", {

package/dist/components/ui/json-tree-view/RowActions.js

@@ -1,12 +1,12 @@
 import { jsx, jsxs } from "react/jsx-runtime";
-import { Button } from "../button.js";
-import { cn } from "../../../lib/index.js";
-import { DropdownMenu, DropdownMenuContent, DropdownMenuItem, DropdownMenuTrigger } from "../dropdown-menu.js";
 import { MoreHorizontal } from "lucide-react";
 import { useState } from "react";
-import { useJsonTreeViewStrings } from "./strings.js";
+import { Button } from "../button.js";
+import { DropdownMenu, DropdownMenuContent, DropdownMenuItem, DropdownMenuTrigger } from "../dropdown-menu.js";
+import { cn } from "../../../lib/index.js";
 import { JsonTreeTooltip } from "./JsonTreeTooltip.js";
-const ACTION_BUTTON_CLASS = 'shrink-0 rounded text-foreground-subtle opacity-0 hover:text-foreground hover:bg-surface-raised group-hover:opacity-100 group-focus-within:opacity-100 focus-visible:opacity-100';
+import { useJsonTreeViewStrings } from "./strings.js";
+const ACTION_BUTTON_CLASS = 'shrink-0 rounded text-foreground-subtle opacity-0 hover:text-foreground hover:bg-surface-raised group-hover:opacity-100 group-focus-within/row:opacity-100';
 const ACTION_TONE_CLASS = {
     neutral: '',
     info: 'text-info hover:text-info',
@@ -37,7 +37,7 @@ function RowActions({ node, actions, maxInline, meta }) {
             })
         }, action.id);
     return /*#__PURE__*/ jsxs("span", {
-        className: "ml-auto flex shrink-0 items-center gap-0.5",
+        className: "flex shrink-0 items-center gap-0.5",
         children: [
             inline.filter((action)=>'start' === action.placement).map(renderInline),
             null != meta && /*#__PURE__*/ jsx("span", {

package/dist/components/ui/json-tree-view/buildJsonTree.cjs

@@ -246,12 +246,31 @@ function flattenJsonTree(nodes, options = {}, depth = 0) {
         if (filterPredicate && !selfPredicateMatch && !predicateMatches?.below.has(node)) continue;
         rows.push({
             node,
-            depth: nodeDepth
+            depth: nodeDepth,
+            posInSet: 0,
+            setSize: 0
         });
         if (node.children && !isPathCollapsed(collapsed, node.path)) pushChildren(node.children, nodeDepth + 1, selfQueryMatch ? '' : query, selfPredicateMatch ? void 0 : filterPredicate);
     }
+    numberSiblingSets(rows, depth);
     return rows;
 }
+function numberSiblingSets(rows, baseDepth) {
+    const openSets = [];
+    const close = (set)=>{
+        for (const [position, row] of set.entries()){
+            row.posInSet = position + 1;
+            row.setSize = set.length;
+        }
+    };
+    for (const row of rows){
+        const level = row.depth - baseDepth;
+        for (const set of openSets.splice(level + 1))close(set);
+        openSets[level] ??= [];
+        openSets[level].push(row);
+    }
+    for (const set of openSets)close(set);
+}
 function collectContainerPaths(nodes, depth = 0) {
     const paths = [];
     const stack = [];

package/dist/components/ui/json-tree-view/buildJsonTree.d.ts

@@ -37,6 +37,10 @@ export declare function isArrayItemTemplateRoot(node: JsonTreeNode): boolean;
 export interface FlatJsonTreeRow {
     node: JsonTreeNode;
     depth: number;
+    /** 1-based position among the visible siblings (`aria-posinset`). */
+    posInSet: number;
+    /** Number of visible siblings, this row included (`aria-setsize`). */
+    setSize: number;
 }
 /** Consumer display texts for a node, so search can match them alongside the raw key. */
 export type NodeDisplayTexts = (node: JsonTreeNode) => {

package/dist/components/ui/json-tree-view/buildJsonTree.js

@@ -206,12 +206,31 @@ function flattenJsonTree(nodes, options = {}, depth = 0) {
         if (filterPredicate && !selfPredicateMatch && !predicateMatches?.below.has(node)) continue;
         rows.push({
             node,
-            depth: nodeDepth
+            depth: nodeDepth,
+            posInSet: 0,
+            setSize: 0
         });
         if (node.children && !isPathCollapsed(collapsed, node.path)) pushChildren(node.children, nodeDepth + 1, selfQueryMatch ? '' : query, selfPredicateMatch ? void 0 : filterPredicate);
     }
+    numberSiblingSets(rows, depth);
     return rows;
 }
+function numberSiblingSets(rows, baseDepth) {
+    const openSets = [];
+    const close = (set)=>{
+        for (const [position, row] of set.entries()){
+            row.posInSet = position + 1;
+            row.setSize = set.length;
+        }
+    };
+    for (const row of rows){
+        const level = row.depth - baseDepth;
+        for (const set of openSets.splice(level + 1))close(set);
+        openSets[level] ??= [];
+        openSets[level].push(row);
+    }
+    for (const set of openSets)close(set);
+}
 function collectContainerPaths(nodes, depth = 0) {
     const paths = [];
     const stack = [];

package/dist/components/ui/json-tree-view/strings.cjs

@@ -33,6 +33,7 @@ const jsx_runtime_namespaceObject = require("react/jsx-runtime");
 const external_react_namespaceObject = require("react");
 const index_cjs_namespaceObject = require("../../../lib/index.cjs");
 const DEFAULT_JSON_TREE_VIEW_STRINGS = {
+    treeLabel: 'JSON fields',
     arrayItem: 'item',
     emptySearch: 'No fields match your search.',
     emptyDefault: 'No fields to display.',
@@ -43,6 +44,7 @@ const DEFAULT_JSON_TREE_VIEW_STRINGS = {
     requiredMarker: 'required',
     referenceType: (typeLabel)=>`${typeLabel} · reference`,
     pathCopied: 'Path copied',
+    valueCopied: 'Value copied',
     copyPathHint: 'Click to copy this path',
     copyPathFor: (path)=>`Copy path for ${path}`,
     wrapValue: 'Wrap value',

package/dist/components/ui/json-tree-view/strings.d.ts

@@ -6,6 +6,12 @@ import { type ReactNode } from 'react';
  * `DEFAULT_JSON_TREE_VIEW_STRINGS`.
  */
 export interface JsonTreeViewStrings {
+    /**
+     * Accessible name of the tree grid when the host passes no `aria-label` or
+     * `aria-labelledby`. Optional so catalogs written before it was added still
+     * type-check; falls back to the English default.
+     */
+    treeLabel?: string;
     /** Label for the synthesized array-item preview row. */
     arrayItem: string;
     emptySearch: string;
@@ -22,7 +28,13 @@ export interface JsonTreeViewStrings {
      * back to the English default.
      */
     referenceType?: (typeLabel: string) => string;
+    /** Announced to screen readers after a path is copied. */
     pathCopied: string;
+    /**
+     * Announced to screen readers after a value is copied. Optional so catalogs
+     * written before it was added still type-check; falls back to the English default.
+     */
+    valueCopied?: string;
     copyPathHint: string;
     copyPathFor: (path: string) => string;
     wrapValue: string;

package/dist/components/ui/json-tree-view/strings.js

@@ -2,6 +2,7 @@ import { jsx } from "react/jsx-runtime";
 import { createContext, useContext, useMemo } from "react";
 import { cn } from "../../../lib/index.js";
 const DEFAULT_JSON_TREE_VIEW_STRINGS = {
+    treeLabel: 'JSON fields',
     arrayItem: 'item',
     emptySearch: 'No fields match your search.',
     emptyDefault: 'No fields to display.',
@@ -12,6 +13,7 @@ const DEFAULT_JSON_TREE_VIEW_STRINGS = {
     requiredMarker: 'required',
     referenceType: (typeLabel)=>`${typeLabel} · reference`,
     pathCopied: 'Path copied',
+    valueCopied: 'Value copied',
     copyPathHint: 'Click to copy this path',
     copyPathFor: (path)=>`Copy path for ${path}`,
     wrapValue: 'Wrap value',

package/dist/components/ui/json-tree-view/treeGrid.cjs

@@ -0,0 +1,306 @@
+"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__, {
+    isParentRow: ()=>isParentRow,
+    useTreeGrid: ()=>useTreeGrid
+});
+const external_react_namespaceObject = require("react");
+const use_isomorphic_layout_effect_cjs_namespaceObject = require("../../../lib/use-isomorphic-layout-effect.cjs");
+const external_buildJsonTree_cjs_namespaceObject = require("./buildJsonTree.cjs");
+const EDITOR_ATTR = 'data-json-tree-editor';
+const SKIP_ATTR = 'data-json-tree-skip';
+const MANAGED_ATTR = 'data-json-tree-tabindex';
+const ROW_SELECTOR = '[role="row"]';
+const CONTROL_SELECTOR = 'button, a[href], input, select, textarea, [contenteditable="true"], [tabindex]:not([role="gridcell"])';
+const TEXT_ENTRY_SELECTOR = `input, textarea, select, [contenteditable="true"], [${EDITOR_ATTR}]`;
+const HANDLED_KEYS = new Set([
+    'ArrowDown',
+    'ArrowUp',
+    'ArrowLeft',
+    'ArrowRight',
+    'PageDown',
+    'PageUp',
+    'Home',
+    'End',
+    'Enter'
+]);
+const PAGE_SIZE = 10;
+function isOwnRow(grid, row) {
+    return row.closest('[role="treegrid"]') === grid;
+}
+function isNavigable(element) {
+    return !element.hasAttribute('disabled') && !element.closest(`[${EDITOR_ATTR}], [${SKIP_ATTR}], [aria-hidden="true"]`);
+}
+function cellsOf(row) {
+    return Array.from(row.querySelectorAll('[role="gridcell"]'));
+}
+function stopsOf(cell) {
+    const controls = Array.from(cell.querySelectorAll(CONTROL_SELECTOR)).filter(isNavigable);
+    if (controls.length > 0) return controls;
+    return cell.textContent?.trim() ? [
+        cell
+    ] : [];
+}
+function rowStops(row) {
+    return cellsOf(row).flatMap(stopsOf);
+}
+function cellNameOf(element) {
+    return element.closest('[role="gridcell"]')?.dataset.cell;
+}
+function findRow(grid, path) {
+    return Array.from(grid.querySelectorAll(ROW_SELECTOR)).find((row)=>row.dataset.path === path && isOwnRow(grid, row));
+}
+function focusInRow(row, cell) {
+    const target = cell ? cellsOf(row).find((c)=>c.dataset.cell === cell) : void 0;
+    const stop = target ? stopsOf(target)[0] : void 0;
+    (stop ?? row).focus();
+}
+function syncRowTabOrder(row, tabbable) {
+    for (const control of row.querySelectorAll(CONTROL_SELECTOR)){
+        if (control.closest(`[${SKIP_ATTR}]`)) continue;
+        const saved = control.getAttribute(MANAGED_ATTR);
+        if (tabbable) {
+            if (null === saved) continue;
+            if ('' === saved) control.removeAttribute('tabindex');
+            else control.setAttribute('tabindex', saved);
+            control.removeAttribute(MANAGED_ATTR);
+        } else if (null === saved) {
+            control.setAttribute(MANAGED_ATTR, control.getAttribute('tabindex') ?? '');
+            control.setAttribute('tabindex', '-1');
+        }
+    }
+}
+function ancestorPaths(segments) {
+    const paths = [];
+    let path = '';
+    for (const segment of segments.slice(0, -1)){
+        path = (0, external_buildJsonTree_cjs_namespaceObject.appendPathSegment)(path, segment);
+        paths.unshift(path);
+    }
+    return paths;
+}
+function isParentRow(row) {
+    return !!row.node.children?.length;
+}
+function useTreeGrid({ rows, indexByPath, collapsed, toggle }) {
+    const [grid, setGrid] = (0, external_react_namespaceObject.useState)(null);
+    const [active, setActive] = (0, external_react_namespaceObject.useState)(null);
+    const activePath = (0, external_react_namespaceObject.useMemo)(()=>{
+        if (active && indexByPath.has(active.path)) return active.path;
+        const ancestor = active && ancestorPaths(active.segments).find((path)=>indexByPath.has(path));
+        return ancestor ?? rows[0]?.node.path ?? null;
+    }, [
+        active,
+        indexByPath,
+        rows
+    ]);
+    const pendingFocusRef = (0, external_react_namespaceObject.useRef)(null);
+    const openEditorsRef = (0, external_react_namespaceObject.useRef)({});
+    const lastFocusedRef = (0, external_react_namespaceObject.useRef)(null);
+    const activePathRef = (0, external_react_namespaceObject.useRef)(activePath);
+    const syncedPathRef = (0, external_react_namespaceObject.useRef)(null);
+    (0, use_isomorphic_layout_effect_cjs_namespaceObject.useIsomorphicLayoutEffect)(()=>{
+        activePathRef.current = activePath;
+        const previous = syncedPathRef.current;
+        syncedPathRef.current = activePath;
+        if (!grid || previous === activePath) return;
+        for (const path of [
+            previous,
+            activePath
+        ]){
+            const row = null === path ? void 0 : findRow(grid, path);
+            if (row) syncRowTabOrder(row, path === activePath);
+        }
+    }, [
+        grid,
+        activePath
+    ]);
+    (0, use_isomorphic_layout_effect_cjs_namespaceObject.useIsomorphicLayoutEffect)(()=>{
+        if (!grid) return;
+        const sync = (row)=>syncRowTabOrder(row, row.dataset.path === activePathRef.current);
+        for (const row of grid.querySelectorAll(ROW_SELECTOR))sync(row);
+        const observer = new MutationObserver((mutations)=>{
+            const touched = new Set();
+            for (const mutation of mutations)for (const added of mutation.addedNodes){
+                if (!(added instanceof Element)) continue;
+                const row = added.closest(ROW_SELECTOR);
+                if (row) touched.add(row);
+                for (const inner of added.querySelectorAll(ROW_SELECTOR))touched.add(inner);
+            }
+            for (const row of touched)sync(row);
+        });
+        observer.observe(grid, {
+            childList: true,
+            subtree: true
+        });
+        return ()=>observer.disconnect();
+    }, [
+        grid
+    ]);
+    (0, use_isomorphic_layout_effect_cjs_namespaceObject.useIsomorphicLayoutEffect)(()=>{
+        const pending = pendingFocusRef.current;
+        pendingFocusRef.current = null;
+        if (!grid) return;
+        const row = pending && findRow(grid, pending.path);
+        if (pending && row) {
+            const { opener } = pending;
+            if (opener instanceof HTMLElement && opener.isConnected && row.contains(opener)) opener.focus();
+            else focusInRow(row, pending.cell);
+            return;
+        }
+        const lost = lastFocusedRef.current;
+        const focusDropped = !document.activeElement || document.activeElement === document.body;
+        if (lost && !lost.isConnected && focusDropped && activePath) findRow(grid, activePath)?.focus();
+    });
+    const focusRow = (index, cell)=>{
+        const row = rows[index];
+        if (!row) return;
+        const element = grid && findRow(grid, row.node.path);
+        if (element) return void focusInRow(element, cell);
+        pendingFocusRef.current = {
+            path: row.node.path,
+            cell
+        };
+        setActive({
+            path: row.node.path,
+            segments: row.node.segments
+        });
+    };
+    const trackEditor = (kind, set)=>(path)=>{
+            if (null !== path) {
+                const opener = document.activeElement;
+                const cell = (opener && cellNameOf(opener)) ?? ('json' === kind ? 'actions' : void 0);
+                openEditorsRef.current[kind] = {
+                    path,
+                    cell,
+                    opener
+                };
+            } else {
+                const open = openEditorsRef.current[kind];
+                openEditorsRef.current[kind] = void 0;
+                if (open && grid && findRow(grid, open.path)?.contains(document.activeElement)) pendingFocusRef.current = open;
+            }
+            set(path);
+        };
+    const onKeyDown = (event)=>{
+        if (!HANDLED_KEYS.has(event.key) || event.altKey || event.metaKey || event.shiftKey) return;
+        if (event.ctrlKey && 'Home' !== event.key && 'End' !== event.key) return;
+        const { target, currentTarget } = event;
+        if (!(target instanceof HTMLElement) || !currentTarget.contains(target)) return;
+        if (target.closest(TEXT_ENTRY_SELECTOR)) return;
+        const row = target.closest(ROW_SELECTOR);
+        if (!row || !isOwnRow(currentTarget, row)) return;
+        const path = row.dataset.path;
+        const index = void 0 === path ? void 0 : indexByPath.get(path);
+        const flatRow = void 0 === index ? void 0 : rows[index];
+        if (void 0 === path || void 0 === index || !flatRow) return;
+        const isParent = isParentRow(flatRow);
+        const expanded = isParent && !(0, external_buildJsonTree_cjs_namespaceObject.isPathCollapsed)(collapsed, path);
+        const onRow = target === row;
+        const stops = onRow ? [] : rowStops(row);
+        const at = stops.indexOf(target);
+        const cell = onRow ? void 0 : cellNameOf(target);
+        const last = rows.length - 1;
+        const moveTo = (next)=>focusRow(Math.max(0, Math.min(last, next)), cell);
+        switch(event.key){
+            case 'ArrowDown':
+                moveTo(index + 1);
+                break;
+            case 'ArrowUp':
+                moveTo(index - 1);
+                break;
+            case 'PageDown':
+                moveTo(index + PAGE_SIZE);
+                break;
+            case 'PageUp':
+                moveTo(index - PAGE_SIZE);
+                break;
+            case 'Home':
+                if (onRow || event.ctrlKey) moveTo(0);
+                else stops[0]?.focus();
+                break;
+            case 'End':
+                if (onRow || event.ctrlKey) moveTo(last);
+                else stops[stops.length - 1]?.focus();
+                break;
+            case 'ArrowRight':
+                if (onRow) if (isParent && !expanded && toggle) toggle(path);
+                else rowStops(row)[0]?.focus();
+                else stops[at + 1]?.focus();
+                break;
+            case 'ArrowLeft':
+                if (onRow) if (expanded && toggle) toggle(path);
+                else {
+                    const parentPath = ancestorPaths(flatRow.node.segments)[0];
+                    const parent = void 0 === parentPath ? void 0 : indexByPath.get(parentPath);
+                    if (void 0 !== parent) focusRow(parent, void 0);
+                }
+                else (stops[at - 1] ?? row).focus();
+                break;
+            case 'Enter':
+                if (!onRow || !isParent || !toggle) return;
+                toggle(path);
+                break;
+        }
+        event.preventDefault();
+        event.stopPropagation();
+    };
+    const onFocus = (event)=>{
+        const { target } = event;
+        if (!(target instanceof HTMLElement)) return;
+        lastFocusedRef.current = target;
+        const path = target.closest(ROW_SELECTOR)?.dataset.path;
+        const index = void 0 === path ? void 0 : indexByPath.get(path);
+        const row = void 0 === index ? void 0 : rows[index];
+        if (void 0 === path || !row || path === active?.path) return;
+        setActive({
+            path,
+            segments: row.node.segments
+        });
+    };
+    const onBlur = (event)=>{
+        if (!event.currentTarget.contains(event.relatedTarget)) lastFocusedRef.current = null;
+    };
+    return {
+        activePath,
+        gridHandlers: {
+            ref: setGrid,
+            onFocus,
+            onBlur,
+            onKeyDownCapture: onKeyDown
+        },
+        trackEditor
+    };
+}
+exports.isParentRow = __webpack_exports__.isParentRow;
+exports.useTreeGrid = __webpack_exports__.useTreeGrid;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "isParentRow",
+    "useTreeGrid"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/components/ui/json-tree-view/treeGrid.d.ts

@@ -0,0 +1,36 @@
+import { type FocusEvent, type KeyboardEvent } from 'react';
+import { type FlatJsonTreeRow } from './buildJsonTree';
+/**
+ * The tree's keyboard model, the APG treegrid pattern: one Tab stop for the
+ * whole tree, arrows between rows and across a row's controls.
+ */
+/** The cells every row renders, in reading order. Up/Down keeps focus in the same one. */
+export type TreeGridCell = 'name' | 'value' | 'actions' | 'detail';
+/** Rows that can expand: a container with at least one child row to show. */
+export declare function isParentRow(row: FlatJsonTreeRow): boolean;
+/** The leaf editors (inline and wrapped) and the JSON editor, which can be open at once. */
+type EditorKind = 'leaf' | 'json';
+export interface UseTreeGridOptions {
+    rows: FlatJsonTreeRow[];
+    indexByPath: Map<string, number>;
+    collapsed: Record<string, boolean>;
+    /** Undefined when the host fixes expansion. */
+    toggle?: (path: string) => void;
+}
+/**
+ * Focus and keyboard state for the grid: which row holds the Tab stop, the Tab
+ * order that follows it, arrow-key moves, and putting focus back when an editor
+ * closes or the focused row leaves the view.
+ */
+export declare function useTreeGrid({ rows, indexByPath, collapsed, toggle }: UseTreeGridOptions): {
+    /** The row holding the Tab stop, kept mounted by a virtualized tree. */
+    activePath: string;
+    gridHandlers: {
+        ref: import("react").Dispatch<import("react").SetStateAction<HTMLDivElement | null>>;
+        onFocus: (event: FocusEvent<HTMLElement>) => void;
+        onBlur: (event: FocusEvent<HTMLElement>) => void;
+        onKeyDownCapture: (event: KeyboardEvent<HTMLElement>) => void;
+    };
+    trackEditor: (kind: EditorKind, set: (path: string | null) => void) => (path: string | null) => void;
+};
+export {};