@splunk/react-ui 5.0.0 → 5.1.0

package/types/src/Tooltip/Tooltip.d.ts

@@ -27,6 +27,8 @@ interface AnchorProps {
 interface TooltipPropsBase {
     /** @private */
     appearance?: 'normal' | 'inverted' | 'none';
+    /** @private Generally passed by parent component rather than added directly. */
+    append?: boolean;
     /**
      * Provide a node to replace the default question mark.
      * For accessibility, ensure that the child can take focus, and that it
@@ -34,10 +36,7 @@ interface TooltipPropsBase {
      * on the appropriate internal element.
      */
     children?: React.ReactNode;
-    /**
-     * @private
-     *
-     */
+    /** @private */
     closeWhen?: 'default' | 'notOnClick';
     /**
      * The content of the tooltip. If the content is falsy and the `open` prop
@@ -95,6 +94,8 @@ interface TooltipPropsBase {
      * The onRequestClose and onRequestOpen callbacks are usually used.
      */
     open?: boolean;
+    /** @private Generally passed by parent component rather than added directly. */
+    prepend?: boolean;
     /**
      * A function for rendering the element that the tooltip is bound to. If both `renderAnchor` and
      * `children` are passed, `children` will be ignored. The function gets as input props object
@@ -121,11 +122,13 @@ type TooltipProps = ComponentProps<TooltipPropsBase, 'span'>;
  * The Tooltip component wraps arbitrary content to be displayed when the target element is hovered
  * or focused.
  */
-declare function Tooltip({ appearance, children, closeDelay, closeWhen, content, contentRelationship, defaultPlacement, elementRef, inline, onRequestClose, onRequestOpen, open: openProp, openDelay, renderAnchor, ...otherProps }: TooltipProps): React.JSX.Element;
+declare function Tooltip({ appearance, append, children, closeDelay, closeWhen, content, contentRelationship, defaultPlacement, elementRef, inline, onRequestClose, onRequestOpen, open: openProp, openDelay, renderAnchor, prepend, ...otherProps }: TooltipProps): React.JSX.Element;
 declare namespace Tooltip {
     var propTypes: {
         /** @private */
         appearance: PropTypes.Requireable<string>;
+        /** @private */
+        append: PropTypes.Requireable<boolean>;
         children: PropTypes.Requireable<PropTypes.ReactNodeLike>;
         closeDelay: PropTypes.Requireable<number>;
         /** @private */
@@ -139,6 +142,8 @@ declare namespace Tooltip {
         onRequestOpen: PropTypes.Requireable<(...args: any[]) => any>;
         open: PropTypes.Requireable<boolean>;
         openDelay: PropTypes.Requireable<NonNullable<string | number | null | undefined>>;
+        /** @private */
+        prepend: PropTypes.Requireable<boolean>;
         renderAnchor: PropTypes.Requireable<(...args: any[]) => any>;
     };
     var possibleOpenReasons: TooltipPossibleOpenReason[];

package/types/src/Tree/Item.d.ts

@@ -0,0 +1,63 @@
+import React from 'react';
+import PropTypes from 'prop-types';
+import { ComponentProps } from '../utils/types';
+interface TreeItemPropsBase {
+    /** A unique `id` for this item and used by `Tree` to keep track of the focused item. */
+    id: string;
+    /** Should contain `Tree.Item`s, can also include other elements to display in between tree items. */
+    children?: React.ReactNode;
+    /** Content to show on the `Tree.Item`. */
+    content?: React.ReactNode;
+    /** Custom indent to show before `Tree.Item` content. */
+    customIndent?: React.ReactNode;
+    /**
+     * A React ref which is set to the DOM element when the component mounts and null when it unmounts.
+     */
+    elementRef?: React.Ref<HTMLLIElement>;
+    /**
+     * @private Used only by JSONTree - artifact from before Tree was public.
+     * Conventional `endAdornment` in all other cases would instead be just done by including the desired element in `content`.
+     * Left in for JSONTree because the need to support the endAdornment conditionally going to the end of the unordered list of children in the expanded view.
+     * This is required in JSONTree to handle closing bracket/braces but does not have a known use case for other Tree uses.
+     */
+    endAdornment?: React.ReactNode;
+    /** Expansion state of the `Tree.Item`. */
+    expanded?: boolean;
+    labelledBy?: string;
+    onFocus?: React.FocusEventHandler<HTMLLIElement>;
+    onKeyDown?: React.KeyboardEventHandler<HTMLLIElement>;
+    /** Called on expansion state change of the `Tree.Item` and should be used to maintain `expanded`. For proper keyboard accessibility this is required when a `Tree.Item` has children. */
+    onToggleExpansion?: TreeItemToggleExpansionHandler;
+    /** Called on selection state change of the `Tree.Item` and can be used to maintain optional external `Tree.Item` selection state. */
+    onToggleSelection?: TreeItemToggleSelectionHandler;
+}
+type TreeItemProps = ComponentProps<TreeItemPropsBase, 'li'>;
+type TreeItemClickHandler = (event: React.MouseEvent<HTMLSpanElement>, id: string) => void;
+type TreeItemKeyDownHandler = (event: React.KeyboardEvent<HTMLLIElement>, id: string, isExpanded: boolean | undefined, childrenCleaned: React.ReactElement[] | undefined | null, handleToggleExpansion: TreeItemToggleExpansionHandler) => void;
+/** @public */
+type TreeItemToggleExpansionHandler = (event: React.KeyboardEvent<HTMLLIElement> | React.MouseEvent<HTMLSpanElement>, data?: {
+    treeItemId?: string;
+}) => void;
+/** @public */
+type TreeItemToggleSelectionHandler = (event: React.KeyboardEvent<HTMLLIElement> | React.MouseEvent<HTMLSpanElement>, data?: {
+    treeItemId?: string;
+}) => void;
+declare function Item({ id, children, content, customIndent, elementRef, endAdornment, expanded, labelledBy, onFocus, onKeyDown, onToggleExpansion, onToggleSelection, ...otherProps }: TreeItemProps): React.JSX.Element;
+declare namespace Item {
+    var propTypes: {
+        id: PropTypes.Requireable<string>;
+        children: PropTypes.Requireable<PropTypes.ReactNodeLike>;
+        content: PropTypes.Requireable<PropTypes.ReactNodeLike>;
+        customIndent: PropTypes.Requireable<PropTypes.ReactNodeLike>;
+        elementRef: PropTypes.Requireable<object>;
+        endAdornment: PropTypes.Requireable<PropTypes.ReactNodeLike>;
+        expanded: PropTypes.Requireable<boolean>;
+        labelledBy: PropTypes.Requireable<string>;
+        onFocus: PropTypes.Requireable<(...args: any[]) => any>;
+        onKeyDown: PropTypes.Requireable<(...args: any[]) => any>;
+        onToggleSelection: PropTypes.Requireable<(...args: any[]) => any>;
+        onToggleExpansion: PropTypes.Requireable<(...args: any[]) => any>;
+    };
+}
+export default Item;
+export { TreeItemClickHandler, TreeItemKeyDownHandler, TreeItemPropsBase, TreeItemToggleExpansionHandler, TreeItemToggleSelectionHandler, };

package/types/src/Tree/Tree.d.ts

@@ -1,24 +1,31 @@
 import React from 'react';
 import PropTypes from 'prop-types';
+import Item from './Item';
 import { ComponentProps } from '../utils/types';
-import TreeItem from './TreeItem';
 type RemoveNodeHandler = (id: string) => void;
 type SetNodeHandler = (id: string, path?: string) => void;
 interface TreePropsBase {
-    /** Should contain TreeItems, can also include other elements to display in between tree items. */
+    /** Should contain `Tree.Item`s, can also include other elements to display in between tree items. */
     children?: React.ReactNode;
     /** Removes default indent from list styles if set to false. */
     defaultIndent?: boolean;
+    /**
+     * A React ref which is set to the DOM element when the component mounts and null when it unmounts.
+     */
+    elementRef?: React.Ref<HTMLUListElement>;
 }
 type TreeProps = ComponentProps<TreePropsBase, 'ul'>;
-declare function Tree({ children, defaultIndent, ...otherProps }: TreeProps): React.JSX.Element;
+/**
+ * Used to present a hierarchical list.
+ */
+declare function Tree({ children, defaultIndent, elementRef, ...otherProps }: TreeProps): React.JSX.Element;
 declare namespace Tree {
     var propTypes: {
         children: PropTypes.Requireable<PropTypes.ReactNodeLike>;
         defaultIndent: PropTypes.Requireable<boolean>;
+        elementRef: PropTypes.Requireable<object>;
     };
-    var TreeItem: typeof import("./TreeItem").default;
+    var Item: typeof import("./Item").default;
 }
 export default Tree;
-export { TreeItem };
-export { RemoveNodeHandler, SetNodeHandler };
+export { RemoveNodeHandler, SetNodeHandler, Item };

package/types/src/Tree/TreeContext.d.ts

@@ -1,5 +1,5 @@
+import { TreeItemClickHandler, TreeItemKeyDownHandler } from './Item';
 import { RemoveNodeHandler, SetNodeHandler } from './Tree';
-import { TreeItemClickHandler, TreeItemKeyDownHandler } from './TreeItem';
 export interface TreeContext {
     defaultIndent?: boolean;
     onItemKeyDown?: TreeItemKeyDownHandler;

package/types/src/Tree/index.d.ts

@@ -1,3 +1,3 @@
 export { default } from './Tree';
 export * from './Tree';
-export * from './TreeItem';
+export * from './Item';

package/types/src/useControlled/useControlled.d.ts

@@ -1,4 +1,6 @@
 import { MutableRefObject } from 'react';
+declare function isPrimitive(value: unknown): boolean;
+declare function isAllowedType(value: unknown): boolean;
 interface DefaultValueProps {
     componentProps: {
         [key: string]: any;
@@ -19,4 +21,4 @@ interface DefaultValueProps {
  */
 declare function useControlled({ componentProps, componentName, defaultValuePropName, valuePropName, }: DefaultValueProps): MutableRefObject<boolean>['current'];
 export default useControlled;
-export { DefaultValueProps };
+export { DefaultValueProps, isPrimitive, isAllowedType };

package/useControlled.js

@@ -19,9 +19,9 @@
     /******/ // The require function
     /******/    function t(o) {
         /******/ // Check if module is in cache
-        /******/ var a = r[o];
-        /******/        if (a !== undefined) {
-            /******/ return a.exports;
+        /******/ var n = r[o];
+        /******/        if (n !== undefined) {
+            /******/ return n.exports;
             /******/        }
         /******/ // Create a new module (and put it into the cache)
         /******/        var u = r[o] = {
@@ -96,14 +96,30 @@
         t.r(o);
         // EXPORTS
                 t.d(o, {
-            default: () => /* reexport */ n
+            default: () => /* reexport */ l,
+            isAllowedType: () => /* reexport */ f,
+            isPrimitive: () => /* reexport */ a
         });
         // EXTERNAL MODULE: external "react"
                 var e = t(9497);
+        // CONCATENATED MODULE: external "lodash/isEqual"
+        const r = require("lodash/isEqual");
         // EXTERNAL MODULE: external "lodash/has"
-                var r = t(5919);
-        var a =  t.n(r);
+                var n = t(5919);
+        var u =  t.n(n);
         // CONCATENATED MODULE: ./src/useControlled/useControlled.tsx
+        function a(e) {
+            return e === null || e === undefined || typeof e === "boolean" || typeof e === "string" || typeof e === "number";
+        }
+        function f(e) {
+            if (a(e)) {
+                return true;
+            }
+            if (Array.isArray(e)) {
+                return e.every(a);
+            }
+            return false;
+        }
         /**
  * This is a private component not intended for use outside @splunk/react-ui
  *
@@ -113,21 +129,21 @@
  * are not happening.
  *
  * Return the controlled state of the component.
- */
-        function u(r) {
-            var t = r.componentProps, o = r.componentName, u = o === void 0 ? "this component" : o, n = r.defaultValuePropName, f = n === void 0 ? "defaultValue" : n, i = r.valuePropName, l = i === void 0 ? "value" : i;
-            var s = (0, e.useRef)(a()(t, l));
+ */        function i(r) {
+            var t = r.componentProps, o = r.componentName, n = o === void 0 ? "this component" : o, a = r.defaultValuePropName, f = a === void 0 ? "defaultValue" : a, i = r.valuePropName, l = i === void 0 ? "value" : i;
+            var s = (0, e.useRef)(u()(t, l));
             var d = (0, e.useRef)(t[f]);
             (0, e.useEffect)((function() {
                 if (false) {}
-            }), [ u, t, f, l ]);
+            }), [ n, t, f, l ]);
             (0, e.useEffect)((function() {
                 if (false) {}
                 if (false) {}
-            }), [ u, t, f, l ]);
+                if (false) {}
+            }), [ n, t, f, l ]);
             return s.current;
         }
-        /* harmony default export */        const n = u;
+        /* harmony default export */        const l = i;
     }) // CONCATENATED MODULE: ./src/useControlled/index.ts
     ();
     module.exports = o;

package/types/src/Tree/TreeItem.d.ts

@@ -1,44 +0,0 @@
-import React from 'react';
-import PropTypes from 'prop-types';
-import { ComponentProps } from '../utils/types';
-interface TreeItemPropsBase {
-    /** A unique `id` for this item and used by `Tree` to keep track of the focused item. */
-    id: string;
-    /** Should contain `TreeItems`, can also include other elements to display in between tree items. */
-    children?: React.ReactNode;
-    /** Content to show on the TreeItem. */
-    content?: React.ReactNode;
-    /** Custom indent to show before TreeItem content. */
-    customIndent?: React.ReactNode;
-    endAdornment?: React.ReactNode;
-    labelledBy?: string;
-    onFocus?: React.FocusEventHandler<HTMLLIElement>;
-    onKeyDown?: React.KeyboardEventHandler<HTMLLIElement>;
-    onToggle?: TreeItemToggleHandler;
-    /** Default open state of the node. */
-    open?: boolean;
-    /** Toggle to pass that opens/closes the node on click. */
-    toggle?: React.ReactElement;
-}
-type TreeItemProps = ComponentProps<TreeItemPropsBase, 'li'>;
-type TreeItemClickHandler = (event: React.MouseEvent<HTMLSpanElement>, id: string) => void;
-type TreeItemKeyDownHandler = (event: React.KeyboardEvent<HTMLLIElement>, id: string, showChildren: boolean | undefined, childrenCleaned: React.ReactElement[] | undefined | null, handleToggle: TreeItemToggleHandler) => void;
-type TreeItemToggleHandler = (isOpen: boolean, event?: React.KeyboardEvent<HTMLLIElement> | React.MouseEvent<HTMLSpanElement>) => void;
-declare function TreeItem({ id, children, content, customIndent, endAdornment, labelledBy, onFocus, onKeyDown, onToggle, open, toggle, ...otherProps }: TreeItemProps): React.JSX.Element;
-declare namespace TreeItem {
-    var propTypes: {
-        id: PropTypes.Requireable<string>;
-        children: PropTypes.Requireable<PropTypes.ReactNodeLike>;
-        content: PropTypes.Requireable<PropTypes.ReactNodeLike>;
-        customIndent: PropTypes.Requireable<PropTypes.ReactNodeLike>;
-        endAdornment: PropTypes.Requireable<PropTypes.ReactNodeLike>;
-        labelledBy: PropTypes.Requireable<string>;
-        onFocus: PropTypes.Requireable<(...args: any[]) => any>;
-        onKeyDown: PropTypes.Requireable<(...args: any[]) => any>;
-        onToggle: PropTypes.Requireable<(...args: any[]) => any>;
-        open: PropTypes.Requireable<boolean>;
-        toggle: PropTypes.Requireable<PropTypes.ReactNodeLike>;
-    };
-}
-export default TreeItem;
-export { TreeItemClickHandler, TreeItemKeyDownHandler, TreeItemPropsBase, TreeItemToggleHandler };