@uipath/apollo-wind 2.78.0 → 2.79.1

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 {};

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

@@ -0,0 +1,269 @@
+import { useMemo, useRef, useState } from "react";
+import { useIsomorphicLayoutEffect } from "../../../lib/use-isomorphic-layout-effect.js";
+import { appendPathSegment, isPathCollapsed } from "./buildJsonTree.js";
+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 = 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] = useState(null);
+    const [active, setActive] = useState(null);
+    const activePath = 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 = useRef(null);
+    const openEditorsRef = useRef({});
+    const lastFocusedRef = useRef(null);
+    const activePathRef = useRef(activePath);
+    const syncedPathRef = useRef(null);
+    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
+    ]);
+    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
+    ]);
+    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 && !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
+    };
+}
+export { isParentRow, useTreeGrid };

package/dist/components/ui/tool-call.cjs

@@ -40,6 +40,7 @@ const external_lucide_react_namespaceObject = require("lucide-react");
 const external_react_namespaceObject = require("react");
 const index_cjs_namespaceObject = require("../../lib/index.cjs");
 const disclosure_row_cjs_namespaceObject = require("../../lib/disclosure-row.cjs");
+const use_isomorphic_layout_effect_cjs_namespaceObject = require("../../lib/use-isomorphic-layout-effect.cjs");
 const external_collapsible_cjs_namespaceObject = require("./collapsible.cjs");
 const external_json_tree_view_index_cjs_namespaceObject = require("./json-tree-view/index.cjs");
 const DEFAULT_TOOL_CALL_STRINGS = {
@@ -70,7 +71,6 @@ function mergeStrings(overrides) {
     }
     return merged;
 }
-const useIsomorphicLayoutEffect = "u" < typeof window ? external_react_namespaceObject.useEffect : external_react_namespaceObject.useLayoutEffect;
 const TOGGLE_CLASSES = `${disclosure_row_cjs_namespaceObject.disclosureRowClassName} hover:text-foreground`;
 const toolCallVariants = (0, external_class_variance_authority_namespaceObject.cva)('group/tool-call flex w-full min-w-0 flex-col text-muted-foreground', {
     variants: {
@@ -191,7 +191,7 @@ const ToolCallHeader = /*#__PURE__*/ external_react_namespaceObject.forwardRef((
 ToolCallHeader.displayName = 'ToolCallHeader';
 const ToolCallContent = /*#__PURE__*/ external_react_namespaceObject.forwardRef(({ className, ...props }, ref)=>{
     const { registerContent } = useToolCallContext('ToolCallContent');
-    useIsomorphicLayoutEffect(()=>registerContent(), [
+    (0, use_isomorphic_layout_effect_cjs_namespaceObject.useIsomorphicLayoutEffect)(()=>registerContent(), [
         registerContent
     ]);
     return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(external_collapsible_cjs_namespaceObject.CollapsibleContent, {

package/dist/components/ui/tool-call.js

@@ -1,9 +1,10 @@
 import { Fragment, jsx, jsxs } from "react/jsx-runtime";
 import { cva } from "class-variance-authority";
 import { ChevronDown, ChevronRight, CircleCheck, CircleX, Clock, Loader2 } from "lucide-react";
-import { createContext, forwardRef, useCallback, useContext, useEffect, useLayoutEffect, useMemo, useState } from "react";
+import { createContext, forwardRef, useCallback, useContext, useMemo, useState } from "react";
 import { cn } from "../../lib/index.js";
 import { disclosureRowClassName } from "../../lib/disclosure-row.js";
+import { useIsomorphicLayoutEffect } from "../../lib/use-isomorphic-layout-effect.js";
 import { Collapsible, CollapsibleContent, CollapsibleTrigger } from "./collapsible.js";
 import { JsonTreeView, buildJsonTree, collectContainerPaths } from "./json-tree-view/index.js";
 const DEFAULT_TOOL_CALL_STRINGS = {
@@ -34,7 +35,6 @@ function mergeStrings(overrides) {
     }
     return merged;
 }
-const useIsomorphicLayoutEffect = "u" < typeof window ? useEffect : useLayoutEffect;
 const TOGGLE_CLASSES = `${disclosureRowClassName} hover:text-foreground`;
 const toolCallVariants = cva('group/tool-call flex w-full min-w-0 flex-col text-muted-foreground', {
     variants: {

package/dist/lib/clipboard.cjs

@@ -37,6 +37,7 @@ async function copyTextToClipboard(text) {
     textarea.setAttribute('readonly', '');
     textarea.style.position = 'fixed';
     textarea.style.opacity = '0';
+    const previousFocus = document.activeElement;
     document.body.appendChild(textarea);
     const selection = document.getSelection();
     const previousRange = selection && selection.rangeCount > 0 ? selection.getRangeAt(0) : null;
@@ -48,6 +49,9 @@ async function copyTextToClipboard(text) {
         copied = false;
     }
     textarea.remove();
+    if (previousFocus instanceof HTMLElement) previousFocus.focus({
+        preventScroll: true
+    });
     if (previousRange && selection) {
         selection.removeAllRanges();
         selection.addRange(previousRange);