@sprinklrjs/spaceweb 12.14.4 → 12.33.2

package/esm/baseui/tree-view/styled-components.d.ts

@@ -0,0 +1,6 @@
+export declare const StyledTreeItemList: import("../../style/styled").StyledComponent;
+export declare const StyledTreeItem: import("../../style/styled").StyledComponent;
+export declare const StyledItemContent: import("../../style/styled").StyledComponent;
+export declare const StyledIconContainer: import("../../style/styled").StyledComponent;
+export declare const StyledNoIconContainer: import("../../style/styled").StyledComponent;
+export declare const StyledLabelInteractable: import("../../style/styled").StyledComponent;

package/esm/baseui/tree-view/styled-components.js

@@ -0,0 +1,38 @@
+/*
+Copyright (c) Uber Technologies, Inc.
+
+This source code is licensed under the MIT license found in the
+LICENSE file in the root directory of this source tree.
+*/
+import { styled } from '../../style';
+export var StyledTreeItemList = styled('ul', 'my-0 overflow-auto py-0 relative outline-none', function (_, _a) {
+    var $indentGuides = _a.$indentGuides, $isChildNode = _a.$isChildNode, _b = _a.$expanded, $expanded = _b === void 0 ? true : _b;
+    return {
+        marginLeft: $isChildNode ? '14px' : 0,
+        paddingLeft: $isChildNode ? '6px' : 0,
+        display: $expanded ? 'block' : 'none',
+        borderLeftWidth: $indentGuides && $isChildNode ? '1px' : 'none',
+        borderLeftStyle: $indentGuides && $isChildNode ? 'solid' : 'none',
+        borderLeftColor: $indentGuides && $isChildNode ? 'transparent' : 'none',
+    };
+});
+StyledTreeItemList.displayName = 'StyledTreeItemList';
+export var StyledTreeItem = styled('li', 'm-0 overflow-auto p-0 relative outline-none', function (_, _a) {
+    var $isLeafNode = _a.$isLeafNode;
+    return ({
+        cursor: $isLeafNode ? 'auto' : 'pointer',
+    });
+});
+StyledTreeItem.displayName = 'StyledTreeItem';
+export var StyledItemContent = styled('div', 'text-14 leading-10 px-1.5 py-1 items-center flex border-box m-0', {
+    outlineOffset: '-3px',
+});
+StyledItemContent.displayName = 'StyledItemContent';
+export var StyledIconContainer = styled('div', 'flex items-center my-0 mr-1.5 h-4 w-4 justify-center');
+StyledIconContainer.displayName = 'StyledIconContainer';
+export var StyledNoIconContainer = styled('div', 'my-0 w-0 mr-1.5 items-center flex justify-center', function () { return ({
+    height: '1em',
+}); });
+StyledNoIconContainer.displayName = 'StyledNoIconContainer';
+export var StyledLabelInteractable = styled('div', 'w-full');
+StyledLabelInteractable.displayName = 'StyledLabelInteractable';

package/esm/baseui/tree-view/tree-label-interactable.d.ts

@@ -0,0 +1,8 @@
+import type { Override } from '../helpers/overrides';
+import type { ComponentType, PropsWithChildren } from 'react';
+declare const TreeLabelInteractable: ComponentType<PropsWithChildren<{
+    overrides?: {
+        LabelInteractable: Override;
+    };
+}>>;
+export default TreeLabelInteractable;

package/esm/baseui/tree-view/tree-label-interactable.js

@@ -0,0 +1,18 @@
+import { __assign, __rest } from "tslib";
+import { jsx as _jsx } from "react/jsx-runtime";
+import { StyledLabelInteractable } from './styled-components';
+import { getOverride } from '../helpers/overrides';
+var TreeLabelInteractable = function (_a) {
+    var _b = _a.overrides, overrides = _b === void 0 ? {} : _b, props = __rest(_a, ["overrides"]);
+    var LabelInteractable = getOverride(overrides.LabelInteractable) || StyledLabelInteractable;
+    return (
+    // $FlowExpectedError[cannot-spread-inexact]
+    _jsx(LabelInteractable
+    // @ts-ignore
+    , __assign({ 
+        // @ts-ignore
+        onClick: function (e) { return e.stopPropagation(); }, 
+        // @ts-ignore
+        onKeyDown: function (e) { return e.stopPropagation(); } }, props), void 0));
+};
+export default TreeLabelInteractable;

package/esm/baseui/tree-view/tree-label.d.ts

@@ -0,0 +1,4 @@
+import type { TreeLabelProps } from './types';
+import type { ComponentType } from 'react';
+declare const TreeLabel: ComponentType<TreeLabelProps>;
+export default TreeLabel;

package/esm/baseui/tree-view/tree-label.js

@@ -0,0 +1,26 @@
+import { __assign, __read, __rest } from "tslib";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { StyledIconContainer, StyledItemContent } from './styled-components';
+import ChevronRight from '../../icon/components/chevron-right';
+import ChevronDown from '../../icon/components/chevron-down';
+import { getOverride, getOverrideProps, getOverrides } from '../helpers/overrides';
+import { Box } from '../../box';
+var TreeLabel = function (_a) {
+    var hasChildren = _a.hasChildren, isExpanded = _a.isExpanded, label = _a.label, _b = _a.overrides, overrides = _b === void 0 ? {} : _b, node = _a.node, isSelected = _a.isSelected, isFocusVisible = _a.isFocusVisible, props = __rest(_a, ["hasChildren", "isExpanded", "label", "overrides", "node", "isSelected", "isFocusVisible"]);
+    var sharedProps = {
+        $isExpanded: !!isExpanded,
+        $isSelected: !!isSelected,
+        $isFocusVisible: !!isFocusVisible,
+        $hasChildren: !!hasChildren,
+    };
+    var IconContainerOverride = overrides.IconContainer, ExpandIconOverride = overrides.ExpandIcon, CollapseIconOverride = overrides.CollapseIcon, LeafIconContainerOverride = overrides.LeafIconContainer, LeafIconOverride = overrides.LeafIcon, TreeItemContentOverride = overrides.TreeItemContent;
+    var IconContainer = getOverride(IconContainerOverride) || StyledIconContainer;
+    var _c = __read(getOverrides(ExpandIconOverride, ChevronRight), 2), Right = _c[0], RightProps = _c[1];
+    var CollapseIcon = getOverride(CollapseIconOverride) || ChevronDown;
+    var LeafIconContainer = getOverride(LeafIconContainerOverride) || StyledIconContainer;
+    var TreeItemContent = getOverride(TreeItemContentOverride) || StyledItemContent;
+    return (
+    // $FlowExpectedError[cannot-spread-inexact]
+    _jsxs(TreeItemContent, __assign({}, sharedProps, props, { children: [hasChildren && (_jsx(IconContainer, __assign({}, sharedProps, getOverrideProps(IconContainerOverride), { children: !isExpanded ? (_jsx(Right, __assign({ size: 8 }, sharedProps, RightProps), void 0)) : (_jsx(CollapseIcon, __assign({ size: 8 }, sharedProps, getOverrideProps(CollapseIconOverride)), void 0)) }), void 0)), !hasChildren && (_jsx(LeafIconContainer, __assign({}, sharedProps, getOverrideProps(LeafIconContainerOverride), { children: _jsx(Box, { className: "h-4 w-4 bg-white" }, void 0) }), void 0)), typeof label === 'function' ? label(node) : label] }), void 0));
+};
+export default TreeLabel;

package/esm/baseui/tree-view/tree-node.d.ts

@@ -0,0 +1,11 @@
+import * as React from 'react';
+import type { TreeNodeProps } from './types';
+import type { SyntheticEvent } from 'react';
+export default class TreeNode extends React.Component<TreeNodeProps> {
+    treeItemRef: React.RefObject<HTMLLIElement>;
+    componentDidMount(): void;
+    componentWillUnmount(): void;
+    onToggle: () => void;
+    onFocus: (e: SyntheticEvent) => void;
+    render(): import("react/jsx-runtime").JSX.Element;
+}

package/esm/baseui/tree-view/tree-node.js

@@ -0,0 +1,52 @@
+import { __assign, __extends } from "tslib";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/*
+Copyright (c) Uber Technologies, Inc.
+
+This source code is licensed under the MIT license found in the
+LICENSE file in the root directory of this source tree.
+*/
+import * as React from 'react';
+import { StyledTreeItemList, StyledTreeItem } from './styled-components';
+import StyledTreeLabel from './tree-label';
+import { getOverride, getOverrideProps } from '../helpers/overrides';
+var TreeNode = /** @class */ (function (_super) {
+    __extends(TreeNode, _super);
+    function TreeNode() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.treeItemRef = React.createRef();
+        _this.onToggle = function () {
+            var _a = _this.props, onToggle = _a.onToggle, node = _a.node;
+            if (onToggle) {
+                onToggle(node);
+            }
+        };
+        _this.onFocus = function (e) {
+            if (e && e.target !== _this.treeItemRef.current)
+                return;
+            var onFocus = _this.props.onFocus;
+            if (onFocus) {
+                onFocus(e);
+            }
+        };
+        return _this;
+    }
+    TreeNode.prototype.componentDidMount = function () {
+        this.props.addRef(this.props.getId(this.props.node), this.treeItemRef);
+    };
+    TreeNode.prototype.componentWillUnmount = function () {
+        this.props.removeRef(this.props.getId(this.props.node));
+    };
+    TreeNode.prototype.render = function () {
+        var _a = this.props, indentGuides = _a.indentGuides, node = _a.node, getId = _a.getId, onToggle = _a.onToggle, _b = _a.overrides, overrides = _b === void 0 ? {} : _b, renderAll = _a.renderAll, selectedNodeId = _a.selectedNodeId, onKeyDown = _a.onKeyDown, onFocus = _a.onFocus, onBlur = _a.onBlur, addRef = _a.addRef, removeRef = _a.removeRef, isFocusVisible = _a.isFocusVisible;
+        var children = node.children, isExpanded = node.isExpanded, label = node.label;
+        var hasChildren = children && children.length !== 0;
+        var TreeItemListOverride = overrides.TreeItemList, TreeItemOverride = overrides.TreeItem, TreeLabelOverride = overrides.TreeLabel;
+        var TreeItemList = getOverride(TreeItemListOverride) || StyledTreeItemList;
+        var TreeItem = getOverride(TreeItemOverride) || StyledTreeItem;
+        var TreeLabel = getOverride(TreeLabelOverride) || StyledTreeLabel;
+        return (_jsxs(TreeItem, __assign({ role: "treeitem", ref: this.treeItemRef, "data-nodeid": getId(node), tabIndex: selectedNodeId === getId(node) ? 0 : -1, onKeyDown: function (e) { return onKeyDown && onKeyDown(e, node); }, onBlur: onBlur, onFocus: this.onFocus, "aria-expanded": isExpanded, "$isLeafNode": !hasChildren }, getOverrideProps(TreeItemOverride), { children: [_jsx(TreeLabel, __assign({ onClick: this.onToggle, node: node, hasChildren: hasChildren, isExpanded: isExpanded, isSelected: selectedNodeId === getId(node), isFocusVisible: isFocusVisible, label: label, overrides: overrides }, getOverrideProps(TreeLabelOverride)), void 0), children && (isExpanded || renderAll) && (_jsx(TreeItemList, __assign({ role: "group", "$indentGuides": !!indentGuides, "$isChildNode": true, "$expanded": !!isExpanded }, getOverrideProps(TreeItemListOverride), { children: children.map(function (node, index) { return (_jsx(TreeNode, { indentGuides: !!indentGuides, renderAll: renderAll, node: node, getId: getId, onToggle: onToggle, overrides: overrides, selectedNodeId: selectedNodeId, onKeyDown: onKeyDown, onFocus: onFocus, onBlur: onBlur, addRef: addRef, removeRef: removeRef, isFocusVisible: isFocusVisible }, index)); }) }), void 0))] }), void 0));
+    };
+    return TreeNode;
+}(React.Component));
+export default TreeNode;

package/esm/baseui/tree-view/tree-view.d.ts

@@ -0,0 +1,2 @@
+import type { TreeViewProps } from './types';
+export default function TreeView(props: TreeViewProps): import("react/jsx-runtime").JSX.Element;

package/esm/baseui/tree-view/tree-view.js

@@ -0,0 +1,126 @@
+import { __assign, __read } from "tslib";
+import { jsx as _jsx } from "react/jsx-runtime";
+/*
+Copyright (c) Uber Technologies, Inc.
+
+This source code is licensed under the MIT license found in the
+LICENSE file in the root directory of this source tree.
+*/
+import * as React from 'react';
+import TreeNode from './tree-node';
+import { StyledTreeItemList } from './styled-components';
+import { getPrevId, getNextId, getParentId, getFirstChildId, getEndId, getExpandableSiblings, defaultGetId, getCharMatchId, } from './utils';
+import { isFocusVisible } from '../utils/focusVisible';
+import { getOverride, getOverrideProps } from '../helpers/overrides';
+export default function TreeView(props) {
+    var data = props.data, _a = props.indentGuides, indentGuides = _a === void 0 ? false : _a, onToggle = props.onToggle, _b = props.overrides, overrides = _b === void 0 ? {} : _b, renderAll = props.renderAll, _c = props.getId, getId = _c === void 0 ? defaultGetId : _c;
+    var RootOverride = overrides.Root;
+    var Root = getOverride(RootOverride) || StyledTreeItemList;
+    var firstId = data.length > 0 ? getId(data[0]) : 0;
+    var _d = __read(React.useState(firstId), 2), selectedNodeId = _d[0], setSelectedNodeId = _d[1];
+    var _e = __read(React.useState(false), 2), focusVisible = _e[0], setFocusVisible = _e[1];
+    var _f = __read(React.useState(''), 2), typeAheadChars = _f[0], setTypeAheadChars = _f[1];
+    var timeOutRef = React.useRef(null);
+    var treeItemRefs = {};
+    var focusTreeItem = function (id) {
+        if (!id)
+            return;
+        setSelectedNodeId(id);
+        var refs = treeItemRefs[id];
+        // @ts-expect-error
+        var node = refs && refs.current;
+        if (node)
+            node.focus();
+    };
+    var onKeyDown = function (e, node) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        var elementId = e.target.getAttribute('data-nodeid');
+        // this check prevents bubbling
+        // @ts-ignore
+        if (elementId !== getId(node) && parseInt(elementId) !== getId(node)) {
+            return;
+        }
+        switch (e.key) {
+            case 'ArrowRight':
+                e.preventDefault();
+                if (typeof node.isExpanded === 'boolean' && !node.isExpanded) {
+                    onToggle && onToggle(node);
+                }
+                else {
+                    focusTreeItem(getFirstChildId(data, selectedNodeId, getId));
+                }
+                break;
+            case 'ArrowLeft':
+                e.preventDefault();
+                if (typeof node.isExpanded === 'boolean' && node.isExpanded) {
+                    onToggle && onToggle(node);
+                }
+                else {
+                    focusTreeItem(getParentId(data, selectedNodeId, null, getId));
+                }
+                break;
+            case 'ArrowUp':
+                e.preventDefault();
+                focusTreeItem(getPrevId(data, selectedNodeId, null, getId));
+                break;
+            case 'ArrowDown':
+                e.preventDefault();
+                focusTreeItem(getNextId(data, selectedNodeId, null, getId));
+                break;
+            case ' ':
+            case 'Enter':
+                e.preventDefault();
+                onToggle && onToggle(node);
+                break;
+            case 'Home':
+                e.preventDefault();
+                if (data.length) {
+                    focusTreeItem(getId(data[0]));
+                }
+                break;
+            case 'End':
+                e.preventDefault();
+                focusTreeItem(getEndId(data, getId));
+                break;
+            case '*':
+                e.preventDefault();
+                getExpandableSiblings(data, selectedNodeId, getId).forEach(
+                // @ts-ignore
+                function (node) { return onToggle && onToggle(node); });
+                break;
+            default:
+                if (timeOutRef.current !== null) {
+                    clearTimeout(timeOutRef.current);
+                }
+                setTypeAheadChars(typeAheadChars + e.key);
+                // @ts-ignore
+                timeOutRef.current = setTimeout(function () {
+                    setTypeAheadChars('');
+                }, 500);
+                focusTreeItem(getCharMatchId(data, selectedNodeId, typeAheadChars + e.key, null, getId));
+                break;
+        }
+    };
+    var onFocus = function (event) {
+        if (isFocusVisible(event)) {
+            setFocusVisible(true);
+        }
+        if (selectedNodeId === null && data.length) {
+            setSelectedNodeId(getId(data[0]));
+        }
+    };
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    var onBlur = function (event) {
+        if (focusVisible) {
+            setFocusVisible(false);
+        }
+    };
+    return (_jsx(Root, __assign({ role: "tree" }, getOverrideProps(RootOverride), { children: data.map(function (node) { return (_jsx(TreeNode, { indentGuides: indentGuides, node: node, getId: getId, onToggle: function (node) {
+                onToggle && onToggle(node);
+                focusTreeItem(getId(node));
+            }, overrides: overrides, renderAll: renderAll, selectedNodeId: selectedNodeId, onKeyDown: onKeyDown, onFocus: onFocus, onBlur: onBlur, addRef: function (id, ref) {
+                treeItemRefs[id] = ref;
+            }, removeRef: function (id) {
+                delete treeItemRefs[id];
+            }, isFocusVisible: focusVisible }, getId(node))); }) }), void 0));
+}

package/esm/baseui/tree-view/types.d.ts

@@ -0,0 +1,67 @@
+import type * as React from 'react';
+import type { Override } from '../helpers/overrides';
+export declare type TreeLabelOverrides = {
+    TreeItemContent?: Override;
+    IconContainer?: Override;
+    ExpandIcon?: Override;
+    CollapseIcon?: Override;
+    LeafIconContainer?: Override;
+    LeafIcon?: Override;
+};
+export declare type TreeViewOverrides = {
+    Root?: Override;
+    TreeItemList?: Override;
+    TreeItem?: Override;
+    TreeLabel?: Override;
+} & TreeLabelOverrides;
+export declare type TreeNodeId = number | string;
+export declare type TreeNodeData<T = any> = {
+    id?: TreeNodeId;
+    children?: TreeNodeData[];
+    isExpanded?: boolean;
+    label: ((node: TreeNodeData) => React.ReactNode) | string;
+    info?: T;
+    [key: string]: any;
+};
+export declare type TreeLabelProps = {
+    hasChildren: boolean;
+    isExpanded?: boolean;
+    isSelected?: boolean;
+    isFocusVisible?: boolean;
+    label: ((node: TreeNodeData) => React.ReactNode) | string;
+    overrides?: TreeLabelOverrides;
+    node: TreeNodeData;
+};
+export declare type SharedStyleProps = {
+    $hasChildren: boolean;
+    $isExpanded: boolean;
+    $isSelected: boolean;
+    $isFocusVisible: boolean;
+};
+export declare type TreeNodeProps = {
+    node: TreeNodeData;
+    getId: (node: TreeNodeData) => TreeNodeId;
+    onToggle?: (node: TreeNodeData) => void;
+    overrides?: TreeViewOverrides;
+    renderAll?: boolean;
+    onKeyDown?: (e: KeyboardEvent, node: TreeNodeData) => unknown;
+    onFocus?: (event: React.SyntheticEvent) => unknown;
+    onBlur?: (event: React.SyntheticEvent) => unknown;
+    selectedNodeId?: TreeNodeId;
+    addRef: (id: TreeNodeId, ref: React.Ref<HTMLLIElement>) => unknown;
+    removeRef: (id: TreeNodeId) => unknown;
+    isFocusVisible?: boolean;
+    indentGuides?: boolean;
+};
+export declare type StatefulContainerProps = {
+    children: (props: TreeViewProps) => React.ReactNode;
+} & TreeViewProps;
+export declare type TreeViewProps = {
+    data: TreeNodeData[];
+    indentGuides?: boolean;
+    onToggle?: (node: TreeNodeData) => void;
+    overrides?: TreeViewOverrides;
+    renderAll?: boolean;
+    getId?: (node: TreeNodeData) => TreeNodeId;
+    singleExpanded?: boolean;
+};

package/esm/baseui/tree-view/types.js

@@ -0,0 +1 @@
+export {};

package/esm/baseui/tree-view/utils.d.ts

@@ -0,0 +1,11 @@
+import type { TreeNodeData, TreeNodeId } from './types';
+export declare const getParentId: (nodes: TreeNodeData[], nodeId: TreeNodeId, parentId: TreeNodeId | null, getId: (a: TreeNodeData) => TreeNodeId) => any;
+export declare const getPrevId: (nodes: TreeNodeData[], nodeId: TreeNodeId, parentId: TreeNodeId | null, getId: (a: TreeNodeData) => TreeNodeId) => any;
+export declare const getFirstChildId: (nodes: TreeNodeData[], nodeId: TreeNodeId, getId: (a: TreeNodeData) => TreeNodeId) => any;
+export declare const getNextId: (nodes: TreeNodeData[], nodeId: TreeNodeId, closestOmmer: TreeNodeId | null, getId: (a: TreeNodeData) => TreeNodeId) => any;
+export declare const getEndId: (nodes: TreeNodeData[], getId: (a: TreeNodeData) => TreeNodeId) => any;
+export declare const getExpandableSiblings: (nodes: TreeNodeData[], nodeId: TreeNodeId, getId: (a: TreeNodeData) => TreeNodeId) => any;
+export declare const toggleIsExpanded: (arr: TreeNodeData[], toggledNode: TreeNodeData, getId?: (node: TreeNodeData) => TreeNodeId) => TreeNodeData[];
+export declare const getCharMatchId: (nodes: TreeNodeData[], nodeId: TreeNodeId, chars: string, closestOmmer: TreeNodeId | null, getId: (a: TreeNodeData) => TreeNodeId) => any;
+export declare const matchString: (nodes: TreeNodeData[], nodeId: TreeNodeId, chars: string, closestOmmer: TreeNodeId | null, getId: (a: TreeNodeData) => TreeNodeId, matchPrefix: boolean) => any;
+export declare const defaultGetId: (node: TreeNodeData) => TreeNodeId;

package/esm/baseui/tree-view/utils.js

@@ -0,0 +1,181 @@
+import { __assign } from "tslib";
+// @ts-ignore
+var getLastLeafId = function (node, getId) {
+    if (node.isExpanded && node.children && node.children.length) {
+        return getLastLeafId(node.children[node.children.length - 1], getId);
+    }
+    return getId(node);
+};
+// @ts-ignore
+export var getParentId = function (nodes, nodeId, parentId, getId) {
+    for (var i = 0; i < nodes.length; i++) {
+        if (getId(nodes[i]) === nodeId) {
+            return parentId;
+        }
+        // @ts-ignore
+        if (nodes[i].isExpanded && nodes[i].children && nodes[i].children.length) {
+            // @ts-ignore
+            var foundId = getParentId(nodes[i].children, nodeId, getId(nodes[i]), getId);
+            if (foundId) {
+                return foundId;
+            }
+        }
+    }
+    return null;
+};
+// @ts-ignore
+export var getPrevId = function (nodes, nodeId, parentId, getId) {
+    for (var i = 0; i < nodes.length; i++) {
+        if (getId(nodes[i]) === nodeId) {
+            if (i === 0) {
+                return parentId;
+            }
+            else {
+                return getLastLeafId(nodes[i - 1], getId);
+            }
+        }
+        // @ts-ignore
+        if (nodes[i].isExpanded && nodes[i].children && nodes[i].children.length) {
+            // @ts-ignore
+            var foundId = getPrevId(nodes[i].children, nodeId, getId(nodes[i]), getId);
+            if (foundId) {
+                return foundId;
+            }
+        }
+    }
+    return null;
+};
+// @ts-ignore
+export var getFirstChildId = function (nodes, nodeId, getId) {
+    for (var i = 0; i < nodes.length; i++) {
+        if (getId(nodes[i]) === nodeId) {
+            // @ts-ignore
+            if (nodes[i].isExpanded && nodes[i].children && nodes[i].children.length) {
+                // @ts-ignore
+                return getId(nodes[i].children[0]);
+            }
+        }
+        // @ts-ignore
+        if (nodes[i].isExpanded && nodes[i].children && nodes[i].children.length) {
+            // @ts-ignore
+            var foundId = getFirstChildId(nodes[i].children, nodeId, getId);
+            if (foundId) {
+                return foundId;
+            }
+        }
+    }
+    return null;
+};
+// @ts-ignore
+export var getNextId = function (nodes, nodeId, closestOmmer, getId) {
+    for (var i = 0; i < nodes.length; i++) {
+        if (getId(nodes[i]) === nodeId) {
+            // @ts-ignore
+            if (nodes[i].isExpanded && nodes[i].children && nodes[i].children.length) {
+                // @ts-ignore
+                return getId(nodes[i].children[0]);
+            }
+            else if (nodes[i + 1]) {
+                return getId(nodes[i + 1]);
+            }
+            else {
+                return closestOmmer;
+            }
+        }
+        // @ts-ignore
+        if (nodes[i].isExpanded && nodes[i].children && nodes[i].children.length) {
+            // @ts-ignore
+            var foundId = getNextId(
+            // @ts-ignore
+            nodes[i].children, nodeId, nodes[i + 1] ? getId(nodes[i + 1]) : closestOmmer, getId);
+            if (foundId) {
+                return foundId;
+            }
+        }
+    }
+    return null;
+};
+// @ts-ignore
+export var getEndId = function (nodes, getId) {
+    var endNode = nodes[nodes.length - 1];
+    if (endNode.isExpanded && endNode.children && endNode.children.length) {
+        return getEndId(endNode.children, getId);
+    }
+    return getId(endNode);
+};
+// @ts-ignore
+export var getExpandableSiblings = function (nodes, nodeId, getId) {
+    for (var i = 0; i < nodes.length; i++) {
+        if (getId(nodes[i]) === nodeId) {
+            var expandableSiblings = [];
+            for (var j = 0; j < nodes.length; j++) {
+                // @ts-ignore
+                if (!nodes[j].isExpanded && nodes[j].children && nodes[j].children.length) {
+                    // @ts-ignore
+                    expandableSiblings.push(nodes[j]);
+                }
+            }
+            return expandableSiblings;
+        }
+        // @ts-ignore
+        if (nodes[i].isExpanded && nodes[i].children && nodes[i].children.length) {
+            // @ts-ignore
+            var result = getExpandableSiblings(nodes[i].children, nodeId, getId);
+            if (result.length) {
+                return result;
+            }
+        }
+    }
+    return [];
+};
+export var toggleIsExpanded = function (arr, toggledNode, getId) {
+    if (getId === void 0) { getId = function (node) { return (node.id ? node.id : ''); }; }
+    return arr.map(function (node) {
+        var newNode = __assign({}, node);
+        if (getId(newNode) === getId(toggledNode)) {
+            newNode.isExpanded = !newNode.isExpanded;
+        }
+        if (newNode.children && newNode.children.length) {
+            newNode.children = toggleIsExpanded(newNode.children, toggledNode);
+        }
+        return newNode;
+    });
+};
+export var getCharMatchId = function (nodes, nodeId, chars, closestOmmer, getId) {
+    var foundid = matchString(nodes, nodeId, chars, closestOmmer, getId, true);
+    if (foundid)
+        return foundid;
+    foundid = matchString(nodes, nodeId, chars, closestOmmer, getId, false);
+    return foundid;
+};
+// @ts-ignore
+export var matchString = function (nodes, nodeId, chars, closestOmmer, getId, 
+//set true, match the prefix; set false, match full text
+matchPrefix) {
+    for (var i = 0; i < nodes.length; i++) {
+        var label = nodes[i].label;
+        if (label && typeof label === 'string') {
+            if ((matchPrefix && label.toUpperCase().indexOf(chars.toUpperCase()) === 0) ||
+                (!matchPrefix && label.toUpperCase().indexOf(chars.toUpperCase()) > 0)) {
+                return getId(nodes[i]);
+            }
+        }
+        // @ts-ignore
+        if (nodes[i].isExpanded && nodes[i].children && nodes[i].children.length) {
+            // @ts-ignore
+            var foundId = matchString(
+            // @ts-ignore
+            nodes[i].children, nodeId, chars, nodes[i + 1] ? getId(nodes[i + 1]) : closestOmmer, getId, matchPrefix);
+            if (foundId) {
+                return foundId;
+            }
+        }
+    }
+    return null;
+};
+export var defaultGetId = function (node) {
+    if (!node.id) {
+        throw Error('There needs to be an unique node.id. You can implement a custom mapping with getId.');
+    }
+    return node.id;
+};

package/esm/baseui/utils/create-event.d.ts

@@ -0,0 +1 @@
+export default function createEvent(eventName: string): any;

package/esm/baseui/utils/create-event.js

@@ -0,0 +1,11 @@
+export default function createEvent(eventName) {
+    var event;
+    if (typeof window.Event === 'function') {
+        event = new window.Event(eventName, { bubbles: true, cancelable: true });
+    }
+    else {
+        event = document.createEvent('Event');
+        event.initEvent(eventName, true, true);
+    }
+    return event;
+}

package/esm/baseui/utils/deep-merge.d.ts

@@ -0,0 +1 @@
+export default function deepMerge(target?: {} | null, ...sources: Array<null | {} | undefined | null>): any;

package/esm/baseui/utils/deep-merge.js

@@ -0,0 +1,37 @@
+/*
+Copyright (c) Uber Technologies, Inc.
+
+This source code is licensed under the MIT license found in the
+LICENSE file in the root directory of this source tree.
+*/
+function isCloneable(obj) {
+    /* eslint-disable-next-line eqeqeq */
+    return Array.isArray(obj) || {}.toString.call(obj) == '[object Object]';
+}
+export default function deepMerge(target) {
+    var sources = [];
+    for (var _i = 1; _i < arguments.length; _i++) {
+        sources[_i - 1] = arguments[_i];
+    }
+    target = target || {};
+    sources.forEach(function (source) {
+        var obj = source || {};
+        Object.keys(obj).forEach(function (key) {
+            // @ts-ignore
+            var value = obj[key];
+            if (typeof value !== 'undefined') {
+                if (isCloneable(value)) {
+                    // @ts-ignore
+                    target[key] = deepMerge(
+                    // @ts-ignore
+                    target[key] || (Array.isArray(value) ? [] : {}), value);
+                }
+                else {
+                    // @ts-ignore
+                    target[key] = value;
+                }
+            }
+        });
+    });
+    return target;
+}

package/esm/baseui/utils/focusVisible.d.ts

@@ -0,0 +1,10 @@
+import type * as React from 'react';
+export declare function teardown(doc: any): void;
+export declare function isFocusVisible(event: any): any;
+/**
+ * Should be called if a blur event is fired on a focus-visible element
+ */
+export declare function handleBlurVisible(): void;
+export declare function initFocusVisible(node: any): void;
+export declare const forkFocus: (rootProps: any, handler: (e: React.FocusEvent) => void) => (e: React.FocusEvent) => void;
+export declare const forkBlur: (rootProps: any, handler: (e: React.FocusEvent) => void) => (e: React.FocusEvent) => void;