@uipath/apollo-wind 2.60.0 → 2.61.0

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

@@ -0,0 +1,86 @@
+"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__, {
+    JsonLeafValueEditor: ()=>JsonLeafValueEditor
+});
+const jsx_runtime_namespaceObject = require("react/jsx-runtime");
+const index_cjs_namespaceObject = require("../../../lib/index.cjs");
+const external_react_namespaceObject = require("react");
+const external_strings_cjs_namespaceObject = require("./strings.cjs");
+const external_leafEditTypes_cjs_namespaceObject = require("./leafEditTypes.cjs");
+function JsonLeafValueEditor({ node, onCommit, onCancel, className }) {
+    const strings = (0, external_strings_cjs_namespaceObject.useJsonTreeViewStrings)();
+    const editType = (0, external_leafEditTypes_cjs_namespaceObject.resolveLeafEditType)(node.type, node.schema);
+    const initial = void 0 === node.value || null === node.value ? String(node.schema?.default ?? '') : String(node.value);
+    const [raw, setRaw] = (0, external_react_namespaceObject.useState)(initial);
+    const cancelledRef = (0, external_react_namespaceObject.useRef)(false);
+    const inputRef = (0, external_react_namespaceObject.useRef)(null);
+    const invalid = void 0 === (0, external_leafEditTypes_cjs_namespaceObject.parseLeafValue)(raw, editType);
+    (0, external_react_namespaceObject.useEffect)(()=>{
+        inputRef.current?.focus();
+    }, []);
+    const commit = ()=>{
+        const parsed = (0, external_leafEditTypes_cjs_namespaceObject.parseLeafValue)(raw, editType);
+        if (void 0 === parsed) return;
+        onCommit(parsed);
+    };
+    return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)("input", {
+        ref: inputRef,
+        type: "text",
+        value: raw,
+        inputMode: 'integer' === editType ? 'numeric' : 'number' === editType ? 'decimal' : void 0,
+        onChange: (e)=>setRaw(e.target.value),
+        onFocus: (e)=>e.target.select(),
+        onBlur: ()=>{
+            if (cancelledRef.current) {
+                cancelledRef.current = false;
+                return;
+            }
+            if (invalid) onCancel();
+            else commit();
+        },
+        onKeyDown: (e)=>{
+            if ('Enter' === e.key) commit();
+            if ('Escape' === e.key) {
+                e.preventDefault();
+                e.stopPropagation();
+                cancelledRef.current = true;
+                onCancel();
+            }
+        },
+        "aria-label": strings.editValueOf(node.key),
+        "aria-invalid": invalid || void 0,
+        placeholder: (0, external_leafEditTypes_cjs_namespaceObject.isNumericEdit)(editType) ? strings.enterNumber : strings.enterValue,
+        className: (0, index_cjs_namespaceObject.cn)('min-w-0 flex-1 rounded bg-transparent font-mono text-xs text-foreground outline-none ring-1', invalid ? 'ring-error' : 'ring-brand', className)
+    });
+}
+exports.JsonLeafValueEditor = __webpack_exports__.JsonLeafValueEditor;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "JsonLeafValueEditor"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,12 @@
+import type { JsonTreeNode, JsonValue } from './JsonTree.types';
+export interface JsonLeafValueEditorProps {
+    node: JsonTreeNode;
+    onCommit: (value: JsonValue) => void;
+    onCancel: () => void;
+    className?: string;
+}
+/**
+ * Inline editor for scalar leaves (string, number, null). Commits on Enter or
+ * blur, cancels on Escape. Invalid numbers are flagged and never committed.
+ */
+export declare function JsonLeafValueEditor({ node, onCommit, onCancel, className, }: JsonLeafValueEditorProps): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,52 @@
+import { jsx } from "react/jsx-runtime";
+import { cn } from "../../../lib/index.js";
+import { useEffect, useRef, useState } from "react";
+import { useJsonTreeViewStrings } from "./strings.js";
+import { isNumericEdit, parseLeafValue, resolveLeafEditType } from "./leafEditTypes.js";
+function JsonLeafValueEditor({ node, onCommit, onCancel, className }) {
+    const strings = useJsonTreeViewStrings();
+    const editType = resolveLeafEditType(node.type, node.schema);
+    const initial = void 0 === node.value || null === node.value ? String(node.schema?.default ?? '') : String(node.value);
+    const [raw, setRaw] = useState(initial);
+    const cancelledRef = useRef(false);
+    const inputRef = useRef(null);
+    const invalid = void 0 === parseLeafValue(raw, editType);
+    useEffect(()=>{
+        inputRef.current?.focus();
+    }, []);
+    const commit = ()=>{
+        const parsed = parseLeafValue(raw, editType);
+        if (void 0 === parsed) return;
+        onCommit(parsed);
+    };
+    return /*#__PURE__*/ jsx("input", {
+        ref: inputRef,
+        type: "text",
+        value: raw,
+        inputMode: 'integer' === editType ? 'numeric' : 'number' === editType ? 'decimal' : void 0,
+        onChange: (e)=>setRaw(e.target.value),
+        onFocus: (e)=>e.target.select(),
+        onBlur: ()=>{
+            if (cancelledRef.current) {
+                cancelledRef.current = false;
+                return;
+            }
+            if (invalid) onCancel();
+            else commit();
+        },
+        onKeyDown: (e)=>{
+            if ('Enter' === e.key) commit();
+            if ('Escape' === e.key) {
+                e.preventDefault();
+                e.stopPropagation();
+                cancelledRef.current = true;
+                onCancel();
+            }
+        },
+        "aria-label": strings.editValueOf(node.key),
+        "aria-invalid": invalid || void 0,
+        placeholder: isNumericEdit(editType) ? strings.enterNumber : strings.enterValue,
+        className: cn('min-w-0 flex-1 rounded bg-transparent font-mono text-xs text-foreground outline-none ring-1', invalid ? 'ring-error' : 'ring-brand', className)
+    });
+}
+export { JsonLeafValueEditor };

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

@@ -0,0 +1,74 @@
+"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__, {
+    JsonMultilineLeafEditor: ()=>JsonMultilineLeafEditor
+});
+const jsx_runtime_namespaceObject = require("react/jsx-runtime");
+const index_cjs_namespaceObject = require("../../../lib/index.cjs");
+const external_react_namespaceObject = require("react");
+const external_strings_cjs_namespaceObject = require("./strings.cjs");
+const external_EditorChrome_cjs_namespaceObject = require("./EditorChrome.cjs");
+const external_leafEditTypes_cjs_namespaceObject = require("./leafEditTypes.cjs");
+function JsonMultilineLeafEditor({ node, onCommit, onCancel, className }) {
+    const strings = (0, external_strings_cjs_namespaceObject.useJsonTreeViewStrings)();
+    const editType = (0, external_leafEditTypes_cjs_namespaceObject.resolveLeafEditType)(node.type, node.schema);
+    const initial = void 0 === node.value || null === node.value ? String(node.schema?.default ?? '') : String(node.value);
+    const [raw, setRaw] = (0, external_react_namespaceObject.useState)(initial);
+    const invalid = void 0 === (0, external_leafEditTypes_cjs_namespaceObject.parseLeafValue)(raw, editType);
+    const apply = ()=>{
+        const parsed = (0, external_leafEditTypes_cjs_namespaceObject.parseLeafValue)(raw, editType);
+        if (void 0 === parsed) return;
+        onCommit(parsed);
+    };
+    return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsxs)("div", {
+        className: (0, index_cjs_namespaceObject.cn)('flex flex-col gap-1.5', className),
+        children: [
+            /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(external_EditorChrome_cjs_namespaceObject.EditorTextarea, {
+                value: raw,
+                onChange: setRaw,
+                onApply: apply,
+                onCancel: onCancel,
+                invalid: invalid,
+                rows: Math.min(10, Math.max(3, raw.split('\n').length + 1)),
+                ariaLabel: strings.editValueOf(node.key),
+                placeholder: (0, external_leafEditTypes_cjs_namespaceObject.isNumericEdit)(editType) ? strings.enterNumber : strings.enterValue,
+                className: "whitespace-pre-wrap"
+            }),
+            /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(external_EditorChrome_cjs_namespaceObject.EditorActions, {
+                onApply: apply,
+                onCancel: onCancel,
+                applyDisabled: invalid
+            })
+        ]
+    });
+}
+exports.JsonMultilineLeafEditor = __webpack_exports__.JsonMultilineLeafEditor;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "JsonMultilineLeafEditor"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,13 @@
+import type { JsonTreeNode, JsonValue } from './JsonTree.types';
+export interface JsonMultilineLeafEditorProps {
+    node: JsonTreeNode;
+    onCommit: (value: JsonValue) => void;
+    onCancel: () => void;
+    className?: string;
+}
+/**
+ * Multiline editor for scalar leaves, used by the expanded row view so long
+ * values can wrap. Applies with the Apply button or Ctrl/Cmd+Enter; Escape
+ * cancels. Commits with the same type rules as the inline leaf editor.
+ */
+export declare function JsonMultilineLeafEditor({ node, onCommit, onCancel, className, }: JsonMultilineLeafEditorProps): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,40 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+import { cn } from "../../../lib/index.js";
+import { useState } from "react";
+import { useJsonTreeViewStrings } from "./strings.js";
+import { EditorActions, EditorTextarea } from "./EditorChrome.js";
+import { isNumericEdit, parseLeafValue, resolveLeafEditType } from "./leafEditTypes.js";
+function JsonMultilineLeafEditor({ node, onCommit, onCancel, className }) {
+    const strings = useJsonTreeViewStrings();
+    const editType = resolveLeafEditType(node.type, node.schema);
+    const initial = void 0 === node.value || null === node.value ? String(node.schema?.default ?? '') : String(node.value);
+    const [raw, setRaw] = useState(initial);
+    const invalid = void 0 === parseLeafValue(raw, editType);
+    const apply = ()=>{
+        const parsed = parseLeafValue(raw, editType);
+        if (void 0 === parsed) return;
+        onCommit(parsed);
+    };
+    return /*#__PURE__*/ jsxs("div", {
+        className: cn('flex flex-col gap-1.5', className),
+        children: [
+            /*#__PURE__*/ jsx(EditorTextarea, {
+                value: raw,
+                onChange: setRaw,
+                onApply: apply,
+                onCancel: onCancel,
+                invalid: invalid,
+                rows: Math.min(10, Math.max(3, raw.split('\n').length + 1)),
+                ariaLabel: strings.editValueOf(node.key),
+                placeholder: isNumericEdit(editType) ? strings.enterNumber : strings.enterValue,
+                className: "whitespace-pre-wrap"
+            }),
+            /*#__PURE__*/ jsx(EditorActions, {
+                onApply: apply,
+                onCancel: onCancel,
+                applyDisabled: invalid
+            })
+        ]
+    });
+}
+export { JsonMultilineLeafEditor };

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

@@ -0,0 +1,253 @@
+"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__, {
+    JsonTreeView: ()=>JsonTreeView
+});
+const jsx_runtime_namespaceObject = require("react/jsx-runtime");
+const react_virtual_namespaceObject = require("@tanstack/react-virtual");
+const external_react_namespaceObject = require("react");
+const index_cjs_namespaceObject = require("../../../lib/index.cjs");
+const external_buildJsonTree_cjs_namespaceObject = require("./buildJsonTree.cjs");
+const external_clipboard_cjs_namespaceObject = require("./clipboard.cjs");
+const external_JsonTreeRow_cjs_namespaceObject = require("./JsonTreeRow.cjs");
+const external_JsonTreeTooltip_cjs_namespaceObject = require("./JsonTreeTooltip.cjs");
+const external_strings_cjs_namespaceObject = require("./strings.cjs");
+const useIsomorphicLayoutEffect = "u" < typeof window ? external_react_namespaceObject.useEffect : external_react_namespaceObject.useLayoutEffect;
+const VIRTUAL_OVERSCAN = 10;
+function scrollMarginOf(element, scrollElement) {
+    return Math.round(element.getBoundingClientRect().top - scrollElement.getBoundingClientRect().top + scrollElement.scrollTop);
+}
+function VirtualRows({ rows, container, scrollElement, pinnedPaths }) {
+    const [scrollMargin, setScrollMargin] = (0, external_react_namespaceObject.useState)(0);
+    const getItemKey = (0, external_react_namespaceObject.useCallback)((index)=>rows[index]?.node.path ?? index, [
+        rows
+    ]);
+    const virtualizer = (0, react_virtual_namespaceObject.useVirtualizer)({
+        count: rows.length,
+        getScrollElement: ()=>scrollElement ?? container,
+        estimateSize: ()=>external_JsonTreeRow_cjs_namespaceObject.ROW_MIN_HEIGHT_PX,
+        getItemKey,
+        overscan: VIRTUAL_OVERSCAN,
+        scrollMargin
+    });
+    useIsomorphicLayoutEffect(()=>{
+        if (!container || !scrollElement) {
+            if (0 !== scrollMargin) setScrollMargin(0);
+            return;
+        }
+        if (virtualizer.isScrolling) return;
+        const next = scrollMarginOf(container, scrollElement);
+        if (next !== scrollMargin) setScrollMargin(next);
+    });
+    const isPinning = pinnedPaths.length > 0;
+    const indexByPath = (0, external_react_namespaceObject.useMemo)(()=>{
+        if (!isPinning) return;
+        const byPath = new Map();
+        for (const [index, row] of rows.entries())byPath.set(row.node.path, index);
+        return byPath;
+    }, [
+        isPinning,
+        rows
+    ]);
+    const items = virtualizer.getVirtualItems();
+    const firstWindowed = items[0]?.index ?? -1;
+    const lastWindowed = items[items.length - 1]?.index ?? -2;
+    const pinnedItems = [];
+    if (indexByPath) for (const path of pinnedPaths){
+        const index = indexByPath.get(path);
+        if (void 0 === index || index >= firstWindowed && index <= lastWindowed) continue;
+        const measurement = virtualizer.measurementsCache[index];
+        if (measurement) pinnedItems.push(measurement);
+    }
+    const rendered = 0 === pinnedItems.length ? items : [
+        ...pinnedItems.filter((item)=>item.index < firstWindowed),
+        ...items,
+        ...pinnedItems.filter((item)=>item.index > lastWindowed)
+    ];
+    return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)("div", {
+        className: "relative",
+        style: {
+            height: virtualizer.getTotalSize()
+        },
+        children: rendered.map((item)=>{
+            const row = rows[item.index];
+            if (!row) return null;
+            return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)("div", {
+                "data-index": item.index,
+                ref: virtualizer.measureElement,
+                className: "absolute top-0 left-0 w-full",
+                style: {
+                    transform: `translateY(${item.start - virtualizer.options.scrollMargin}px)`
+                },
+                children: /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(external_JsonTreeRow_cjs_namespaceObject.JsonTreeRow, {
+                    node: row.node,
+                    depth: row.depth
+                })
+            }, item.key);
+        })
+    });
+}
+function valueAsText(node) {
+    if ('string' == typeof node.value) return node.value;
+    if (void 0 === node.value) return 'null';
+    return JSON.stringify(node.value, null, 2);
+}
+const DefaultRowWrapper = ({ className, style, onClick, children })=>/*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)("div", {
+        className: className,
+        style: style,
+        onClick: onClick,
+        children: children
+    });
+function JsonTreeView({ strings, tooltipContentClassName, ...props }) {
+    return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(external_strings_cjs_namespaceObject.JsonTreeViewProvider, {
+        strings: strings,
+        tooltipContentClassName: tooltipContentClassName,
+        children: /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(JsonTreeViewContent, {
+            ...props
+        })
+    });
+}
+function JsonTreeViewContent({ nodes, collapsed = {}, onToggleCollapsed, query, filterPredicate, readOnly = false, onEdit, rowWrapper, decorateNode, deriveTypeIcon, renderValue, nodeActions, maxInlineActions = 3, renderCodeEditor, pathForCopy, onCopy, virtualized = false, scrollElement, emptyMessage, className }) {
+    const strings = (0, external_strings_cjs_namespaceObject.useJsonTreeViewStrings)();
+    const [container, setContainer] = (0, external_react_namespaceObject.useState)(null);
+    const usesAncestorScroller = virtualized && !!scrollElement;
+    const RowWrapper = rowWrapper ?? DefaultRowWrapper;
+    const [editingPath, setEditingPath] = (0, external_react_namespaceObject.useState)(null);
+    const [jsonEditingPath, setJsonEditingPath] = (0, external_react_namespaceObject.useState)(null);
+    const [wrappedPaths, setWrappedPaths] = (0, external_react_namespaceObject.useState)({});
+    const pinnedPaths = (0, external_react_namespaceObject.useMemo)(()=>[
+            ...new Set([
+                editingPath,
+                jsonEditingPath
+            ].filter((path)=>null !== path))
+        ], [
+        editingPath,
+        jsonEditingPath
+    ]);
+    const [copied, setCopied] = (0, external_react_namespaceObject.useState)(null);
+    const copyTimerRef = (0, external_react_namespaceObject.useRef)(null);
+    (0, external_react_namespaceObject.useEffect)(()=>()=>{
+            if (copyTimerRef.current) clearTimeout(copyTimerRef.current);
+        }, []);
+    const copy = (node, kind, text)=>{
+        (0, external_clipboard_cjs_namespaceObject.copyTextToClipboard)(text).then((ok)=>{
+            if (!ok) return;
+            setCopied({
+                path: node.path,
+                kind
+            });
+            if (copyTimerRef.current) clearTimeout(copyTimerRef.current);
+            copyTimerRef.current = setTimeout(()=>setCopied(null), 1500);
+            onCopy?.({
+                kind,
+                path: node.path,
+                text
+            });
+        });
+    };
+    const copyPath = (node)=>copy(node, 'path', pathForCopy?.(node.path) ?? node.path);
+    const copyValue = (node)=>copy(node, 'value', valueAsText(node));
+    const toggleWrapped = (node)=>{
+        setWrappedPaths((prev)=>({
+                ...prev,
+                [node.path]: !prev[node.path]
+            }));
+        if (editingPath === node.path) setEditingPath(null);
+    };
+    const commitEdit = (node, value)=>onEdit?.(node, value);
+    const canEdit = !readOnly && !!onEdit;
+    const rows = (0, external_react_namespaceObject.useMemo)(()=>(0, external_buildJsonTree_cjs_namespaceObject.flattenJsonTree)(nodes, {
+            collapsed,
+            query,
+            filterPredicate,
+            displayTexts: decorateNode
+        }), [
+        nodes,
+        collapsed,
+        query,
+        filterPredicate,
+        decorateNode
+    ]);
+    const templateItemLabel = strings.arrayItem;
+    const filtering = !!query?.trim() || !!filterPredicate;
+    const resolvedEmptyMessage = filtering ? strings.emptySearch : emptyMessage ?? strings.emptyDefault;
+    const rowContext = {
+        collapsed,
+        onToggleCollapsed,
+        readOnly,
+        decorateNode,
+        deriveTypeIcon,
+        renderValue,
+        nodeActions,
+        maxInlineActions,
+        renderCodeEditor,
+        pathForCopy,
+        canEdit,
+        RowWrapper,
+        templateItemLabel,
+        editingPath,
+        jsonEditingPath,
+        wrappedPaths,
+        copied,
+        setEditingPath,
+        setJsonEditingPath,
+        copyPath,
+        copyValue,
+        toggleWrapped,
+        commitEdit
+    };
+    return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(external_JsonTreeTooltip_cjs_namespaceObject.JsonTreeTooltipProvider, {
+        children: /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(external_JsonTreeRow_cjs_namespaceObject.JsonTreeRowContextProvider, {
+            value: rowContext,
+            children: /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsxs)("div", {
+                ref: setContainer,
+                className: (0, index_cjs_namespaceObject.cn)(usesAncestorScroller ? 'overflow-x-clip' : 'h-full overflow-y-auto overflow-x-hidden', virtualized && !usesAncestorScroller && 'max-h-screen', virtualized && '[overflow-anchor:none]', className),
+                children: [
+                    virtualized ? /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(VirtualRows, {
+                        rows: rows,
+                        container: container,
+                        scrollElement: scrollElement,
+                        pinnedPaths: pinnedPaths
+                    }) : rows.map(({ node, depth })=>/*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(external_JsonTreeRow_cjs_namespaceObject.JsonTreeRow, {
+                            node: node,
+                            depth: depth
+                        }, node.path)),
+                    0 === rows.length && /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)("span", {
+                        className: "p-4 text-center text-xs text-foreground-subtle",
+                        children: resolvedEmptyMessage
+                    })
+                ]
+            })
+        })
+    });
+}
+exports.JsonTreeView = __webpack_exports__.JsonTreeView;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "JsonTreeView"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,81 @@
+import type { CopyEvent, DeriveTypeIcon, JsonTreeNode, JsonTreeRowWrapper, JsonValue, NodeActionsResolver, NodeDecoration, RenderCodeEditor, RenderValueCell } from './JsonTree.types';
+import { type JsonTreeViewStrings } from './strings';
+export interface JsonTreeViewProps {
+    /** Tree built with `buildJsonTree`. */
+    nodes: JsonTreeNode[];
+    /** Collapsed container paths. */
+    collapsed?: Record<string, boolean>;
+    onToggleCollapsed?: (path: string) => void;
+    /** Search query matched against keys and scalar values. */
+    query?: string;
+    /**
+     * Rows are kept when the node (or any descendant) matches; a node that
+     * matches directly shows its whole subtree.
+     */
+    filterPredicate?: (node: JsonTreeNode) => boolean;
+    /** Hides all editing affordances. */
+    readOnly?: boolean;
+    /** Called with the node and its new value after an inline edit. Undefined removes the value. */
+    onEdit?: (node: JsonTreeNode, value: JsonValue | undefined) => void;
+    /**
+     * Custom row container (e.g. to make rows drag sources). Renders `children`
+     * inside a single element applying `className`/`style`. Must be a stable
+     * component reference (module scope or memoized), not an inline arrow.
+     */
+    rowWrapper?: JsonTreeRowWrapper;
+    /** Per-node visual annotations (labels, chips, badge overrides). None by default. */
+    decorateNode?: (node: JsonTreeNode) => NodeDecoration | undefined;
+    /** Custom type-badge icons per node. Return undefined to keep the default type icon. */
+    deriveTypeIcon?: DeriveTypeIcon;
+    /** Custom value cell renderer; return undefined to keep the default cell. */
+    renderValue?: RenderValueCell;
+    /**
+     * Customizes the trailing row actions per node: compose with the built-ins
+     * via `ctx.defaultActions`, return `[]` to omit them, or `undefined` to keep
+     * the defaults.
+     */
+    nodeActions?: NodeActionsResolver;
+    /**
+     * Maximum row actions shown inline before the surplus collapses into an
+     * overflow menu. Default 3.
+     */
+    maxInlineActions?: number;
+    /** Renders the object/array editing surface as a code editor (defaults to a textarea). */
+    renderCodeEditor?: RenderCodeEditor;
+    /** Builds the text copied when a field name is clicked. Defaults to the path itself. */
+    pathForCopy?: (path: string) => string;
+    /** Called after something is copied to the clipboard. */
+    onCopy?: (event: CopyEvent) => void;
+    /**
+     * Mounts only the rows in view (plus a small overscan) instead of every row,
+     * for values with thousands of fields. Rows are measured, so wrapped values
+     * and inline editors keep their height. The tree scrolls inside its own box,
+     * capped at the viewport height, unless `scrollElement` names the scroller.
+     * Off by default.
+     */
+    virtualized?: boolean;
+    /**
+     * With `virtualized`, the ancestor that scrolls the tree. The tree then grows
+     * to its content and windows its rows by that element's scroll position, so
+     * the panel keeps its single scrollbar. The element must be height-bound: one
+     * that grows with its content never scrolls, and every row would count as in
+     * view.
+     */
+    scrollElement?: HTMLElement | null;
+    emptyMessage?: string;
+    /**
+     * Overrides for the tree's user-facing strings. Omitted keys fall back to an outer
+     * `JsonTreeViewProvider`, then to `DEFAULT_JSON_TREE_VIEW_STRINGS` (English).
+     */
+    strings?: Partial<JsonTreeViewStrings>;
+    /** Extra classes for every tooltip panel (e.g. a z-index above a host's overlays). */
+    tooltipContentClassName?: string;
+    className?: string;
+}
+/**
+ * Interactive tree of a JSON value merged with its schema. Containers
+ * collapse, leaves edit inline (all JSON types), field names copy their
+ * path, and the row actions copy the value or wrap long scalars
+ * into a full-width block with a multiline editor.
+ */
+export declare function JsonTreeView({ strings, tooltipContentClassName, ...props }: JsonTreeViewProps): import("react/jsx-runtime").JSX.Element;