@banyan_cloud/roots 2.0.65 → 2.0.66

package/dist/esm/components/tooltip/types/index.d.ts

@@ -50,7 +50,7 @@ export interface TooltipProps {
      */
     showPointer?: boolean;
     /**
-     * Keeps tooltip open on mouse leave and closes it only on outside click.
+     * Enables interactive hover behavior so users can move from trigger to tooltip content before it closes.
      */
     clickOutsideToClose?: boolean;
 }

package/dist/esm/components/v2/breadcrumbs/Breadcrumbs.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import type { BreadcrumbsProps } from './types';
+declare const Breadcrumbs: React.FC<BreadcrumbsProps>;
+export default Breadcrumbs;

package/dist/esm/components/v2/breadcrumbs/InteractiveBreadcrumbs.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+import type { BreadcrumbType } from './types';
+interface Props {
+    type?: BreadcrumbType;
+}
+declare const InteractiveBreadcrumbs: React.FC<Props>;
+export default InteractiveBreadcrumbs;

package/dist/esm/components/v2/breadcrumbs/assets/breadcrumbsArrow.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+interface BreadcrumbsArrowProps {
+    width?: number;
+    height?: number;
+    color?: string;
+    className?: string;
+    style?: React.CSSProperties;
+}
+declare const BreadcrumbsArrow: React.FC<BreadcrumbsArrowProps>;
+export default BreadcrumbsArrow;

package/dist/esm/components/v2/breadcrumbs/assets/breadcrumbsHome.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+interface BreadcrumbsHomeProps {
+    width?: number;
+    height?: number;
+    color?: string;
+    className?: string;
+    style?: React.CSSProperties;
+}
+declare const BreadcrumbsHome: React.FC<BreadcrumbsHomeProps>;
+export default BreadcrumbsHome;

package/dist/esm/components/v2/breadcrumbs/assets/breadcrumbsSplash.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+interface BreadcrumbsSplashProps {
+    width?: number;
+    height?: number;
+    color?: string;
+    className?: string;
+    style?: React.CSSProperties;
+}
+declare const BreadcrumbsSplash: React.FC<BreadcrumbsSplashProps>;
+export default BreadcrumbsSplash;

package/dist/esm/components/v2/breadcrumbs/index.d.ts

@@ -0,0 +1,2 @@
+export { default } from './Breadcrumbs';
+export type { BreadcrumbDropdownOption, BreadcrumbItem, BreadcrumbSeparator, BreadcrumbsProps, BreadcrumbType, } from './types';

package/dist/esm/components/v2/breadcrumbs/types/index.d.ts

@@ -0,0 +1,30 @@
+export type BreadcrumbSeparator = 'chevron' | 'slash';
+export type BreadcrumbType = 'text' | 'text-with-line' | 'button';
+export interface BreadcrumbItem {
+    id: string;
+    label: string | undefined;
+    href?: string | undefined;
+    onClick?: () => void | undefined;
+    isDisabled?: boolean | undefined;
+    dropdownOptions?: BreadcrumbDropdownOption[] | undefined;
+}
+export interface SeparatorProps {
+    separator: BreadcrumbSeparator;
+}
+export interface DropdownProps {
+    options: BreadcrumbDropdownOption[];
+    onClose: () => void;
+    anchorRef: React.RefObject<HTMLSpanElement | null>;
+}
+export interface BreadcrumbDropdownOption {
+    label: string;
+    value: string;
+    onClick?: () => void | undefined;
+}
+export interface BreadcrumbsProps {
+    crumbs: BreadcrumbItem[];
+    type?: BreadcrumbType | undefined;
+    separator?: BreadcrumbSeparator | undefined;
+    className?: string | undefined;
+    activeIndex?: number | undefined;
+}

package/dist/esm/components/v2/buttons/baseButton/types/index.d.ts

@@ -1,7 +1,7 @@
 import type { BaseCellProps } from 'components/cell';
 import type { MouseEvent, ReactElement } from 'react';
 type ButtonType = 'button' | 'submit' | 'reset';
-type ButtonVariant = 'contained' | 'outlined' | 'text';
+type ButtonVariant = 'contained' | 'outlined' | 'text' | 'unstyled';
 export interface BaseButtonProps extends BaseCellProps<'button', false> {
     title?: ReactElement | string | undefined;
     disabled?: boolean | undefined;

package/dist/esm/components/v2/buttons/button/types/index.d.ts

@@ -1,5 +1,5 @@
 import type { ComponentType, JSXElementConstructor, MouseEvent, ReactElement } from 'react';
-export type ButtonVariant = 'primary' | 'secondary' | 'Soft' | 'outlined' | 'ghost';
+export type ButtonVariant = 'primary' | 'secondary' | 'Soft' | 'outlined' | 'ghost' | 'unstyled';
 export type ButtonTextSize = 'sm' | 'md';
 export type ButtonSize = 'xs' | 'sm' | 'md' | 'lg' | 'auto';
 export interface ButtonProps {

package/dist/esm/components/v2/inlineLoader/InlineLoader.d.ts

@@ -0,0 +1,2 @@
+import type { InlineLoaderProps } from './types';
+export declare const InlineLoader: ({ status, text, className }: InlineLoaderProps) => import("react/jsx-runtime").JSX.Element;

package/dist/esm/components/v2/inlineLoader/index.d.ts

@@ -0,0 +1 @@
+export * from './InlineLoader';

package/dist/esm/components/v2/inlineLoader/types/index.d.ts

@@ -0,0 +1,14 @@
+export interface InlineLoaderProps {
+    /**
+     * The current state of the inline loader.
+     */
+    status: 'loading' | 'success' | 'error';
+    /**
+     * The optional text label displayed next to the icon.
+     */
+    text?: string | undefined;
+    /**
+     * Additional CSS classes.
+     */
+    className?: string | undefined;
+}

package/dist/esm/components/v2/link/Link.d.ts

@@ -1,4 +1,3 @@
-import { type RefObject } from 'react';
 import type { LinkProps } from './types';
-declare const Link: import("react").ForwardRefExoticComponent<LinkProps & import("react").RefAttributes<RefObject<HTMLAnchorElement>>>;
+declare const Link: import("react").ForwardRefExoticComponent<LinkProps & import("react").RefAttributes<HTMLAnchorElement>>;
 export default Link;

package/dist/esm/components/v2/link/types/index.d.ts

@@ -1,9 +1,12 @@
+import type { HTMLAttributeAnchorTarget } from 'react';
 type LinkSize = 'sm' | 'md' | 'lg';
+export type LinkVariant = 'styled' | 'unstyled';
 export interface LinkProps {
     children: React.ReactNode;
     href: string;
     target?: '_blank' | '_self' | '_parent' | '_top';
-    onClick?: () => void;
+    onClick?: (e: HTMLAttributeAnchorTarget) => void;
+    variant?: LinkVariant;
     size?: LinkSize;
     withIcon?: boolean;
     disabled?: boolean;

package/dist/esm/index.js

@@ -8445,6 +8445,208 @@ function getChildren(nodes, id) {
   return allChildren;
 }
 
+function isPointInPolygon(point, polygon) {
+  const [x, y] = point;
+  let isInside = false;
+  const length = polygon.length;
+
+  for (let i = 0, j = length - 1; i < length; j = i++) {
+    const [xi, yi] = polygon[i] || [0, 0];
+    const [xj, yj] = polygon[j] || [0, 0];
+    const intersect = yi >= y !== yj >= y && x <= (xj - xi) * (y - yi) / (yj - yi) + xi;
+
+    if (intersect) {
+      isInside = !isInside;
+    }
+  }
+
+  return isInside;
+}
+
+function safePolygon(_temp) {
+  let {
+    restMs = 0,
+    buffer = 0.5,
+    blockPointerEvents = true,
+    debug = null
+  } = _temp === void 0 ? {} : _temp;
+  let timeoutId;
+  let polygonIsDestroyed = false;
+
+  const fn = _ref => {
+    let {
+      x,
+      y,
+      placement,
+      refs,
+      onClose,
+      nodeId,
+      tree,
+      leave = false
+    } = _ref;
+    return function onPointerMove(event) {
+      var _refs$domReference$cu, _refs$floating$curren, _refs$floating$curren2;
+
+      clearTimeout(timeoutId);
+
+      function close() {
+        clearTimeout(timeoutId);
+        onClose();
+      }
+
+      if (event.pointerType && event.pointerType !== 'mouse') {
+        return;
+      }
+
+      const {
+        clientX,
+        clientY
+      } = event;
+      const target = 'composedPath' in event ? event.composedPath()[0] : event.target;
+      const targetNode = target; // If the pointer is over the reference, there is no need to run the logic
+
+      if (event.type === 'pointermove' && (_refs$domReference$cu = refs.domReference.current) != null && _refs$domReference$cu.contains(targetNode)) {
+        return;
+      } // Prevent overlapping floating element from being stuck in an open-close
+      // loop: https://github.com/floating-ui/floating-ui/issues/1910
+
+
+      if (event.type === 'mouseleave' && isElement(event.relatedTarget) && (_refs$floating$curren = refs.floating.current) != null && _refs$floating$curren.contains(event.relatedTarget)) {
+        return;
+      } // If any nested child is open, abort.
+
+
+      if (tree && getChildren(tree.nodesRef.current, nodeId).some(_ref2 => {
+        let {
+          context
+        } = _ref2;
+        return context == null ? void 0 : context.open;
+      })) {
+        return;
+      } // The cursor landed, so we destroy the polygon logic
+
+
+      if ((_refs$floating$curren2 = refs.floating.current) != null && _refs$floating$curren2.contains(targetNode) && !leave) {
+        polygonIsDestroyed = true;
+        return;
+      }
+
+      if (!refs.domReference.current || !refs.floating.current || placement == null || x == null || y == null) {
+        return;
+      }
+
+      const refRect = refs.domReference.current.getBoundingClientRect();
+      const rect = refs.floating.current.getBoundingClientRect();
+      const side = placement.split('-')[0];
+      const cursorLeaveFromRight = x > rect.right - rect.width / 2;
+      const cursorLeaveFromBottom = y > rect.bottom - rect.height / 2; // If the pointer is leaving from the opposite side, the "buffer" logic
+      // creates a point where the floating element remains open, but should be
+      // ignored.
+      // A constant of 1 handles floating point rounding errors.
+
+      if (side === 'top' && y >= refRect.bottom - 1 || side === 'bottom' && y <= refRect.top + 1 || side === 'left' && x >= refRect.right - 1 || side === 'right' && x <= refRect.left + 1) {
+        return close();
+      } // Ignore when the cursor is within the rectangular trough between the
+      // two elements. Since the triangle is created from the cursor point,
+      // which can start beyond the ref element's edge, traversing back and
+      // forth from the ref to the floating element can cause it to close. This
+      // ensures it always remains open in that case.
+
+
+      switch (side) {
+        case 'top':
+          if (clientX >= rect.left && clientX <= rect.right && clientY >= rect.top && clientY <= refRect.top + 1) {
+            return;
+          }
+
+          break;
+
+        case 'bottom':
+          if (clientX >= rect.left && clientX <= rect.right && clientY >= refRect.bottom - 1 && clientY <= rect.bottom) {
+            return;
+          }
+
+          break;
+
+        case 'left':
+          if (clientX >= rect.left && clientX <= refRect.left + 1 && clientY >= rect.top && clientY <= rect.bottom) {
+            return;
+          }
+
+          break;
+
+        case 'right':
+          if (clientX >= refRect.right - 1 && clientX <= rect.right && clientY >= rect.top && clientY <= rect.bottom) {
+            return;
+          }
+
+          break;
+      }
+
+      if (polygonIsDestroyed) {
+        return close();
+      }
+
+      function getPolygon(_ref3) {
+        let [x, y] = _ref3;
+        const isFloatingWider = rect.width > refRect.width;
+        const isFloatingTaller = rect.height > refRect.height;
+
+        switch (side) {
+          case 'top':
+            {
+              const cursorPointOne = [isFloatingWider ? x + buffer / 2 : cursorLeaveFromRight ? x + buffer * 4 : x - buffer * 4, y + buffer + 1];
+              const cursorPointTwo = [isFloatingWider ? x - buffer / 2 : cursorLeaveFromRight ? x + buffer * 4 : x - buffer * 4, y + buffer + 1];
+              const commonPoints = [[rect.left, cursorLeaveFromRight ? rect.bottom - buffer : isFloatingWider ? rect.bottom - buffer : rect.top], [rect.right, cursorLeaveFromRight ? isFloatingWider ? rect.bottom - buffer : rect.top : rect.bottom - buffer]];
+              return [cursorPointOne, cursorPointTwo, ...commonPoints];
+            }
+
+          case 'bottom':
+            {
+              const cursorPointOne = [isFloatingWider ? x + buffer / 2 : cursorLeaveFromRight ? x + buffer * 4 : x - buffer * 4, y - buffer];
+              const cursorPointTwo = [isFloatingWider ? x - buffer / 2 : cursorLeaveFromRight ? x + buffer * 4 : x - buffer * 4, y - buffer];
+              const commonPoints = [[rect.left, cursorLeaveFromRight ? rect.top + buffer : isFloatingWider ? rect.top + buffer : rect.bottom], [rect.right, cursorLeaveFromRight ? isFloatingWider ? rect.top + buffer : rect.bottom : rect.top + buffer]];
+              return [cursorPointOne, cursorPointTwo, ...commonPoints];
+            }
+
+          case 'left':
+            {
+              const cursorPointOne = [x + buffer + 1, isFloatingTaller ? y + buffer / 2 : cursorLeaveFromBottom ? y + buffer * 4 : y - buffer * 4];
+              const cursorPointTwo = [x + buffer + 1, isFloatingTaller ? y - buffer / 2 : cursorLeaveFromBottom ? y + buffer * 4 : y - buffer * 4];
+              const commonPoints = [[cursorLeaveFromBottom ? rect.right - buffer : isFloatingTaller ? rect.right - buffer : rect.left, rect.top], [cursorLeaveFromBottom ? isFloatingTaller ? rect.right - buffer : rect.left : rect.right - buffer, rect.bottom]];
+              return [...commonPoints, cursorPointOne, cursorPointTwo];
+            }
+
+          case 'right':
+            {
+              const cursorPointOne = [x - buffer, isFloatingTaller ? y + buffer / 2 : cursorLeaveFromBottom ? y + buffer * 4 : y - buffer * 4];
+              const cursorPointTwo = [x - buffer, isFloatingTaller ? y - buffer / 2 : cursorLeaveFromBottom ? y + buffer * 4 : y - buffer * 4];
+              const commonPoints = [[cursorLeaveFromBottom ? rect.left + buffer : isFloatingTaller ? rect.left + buffer : rect.right, rect.top], [cursorLeaveFromBottom ? isFloatingTaller ? rect.left + buffer : rect.right : rect.left + buffer, rect.bottom]];
+              return [cursorPointOne, cursorPointTwo, ...commonPoints];
+            }
+        }
+      }
+
+      const poly = getPolygon([x, y]);
+
+      if (process.env.NODE_ENV !== "production") {
+        debug == null ? void 0 : debug(poly.slice(0, 4).join(', '));
+      }
+
+      if (!isPointInPolygon([clientX, clientY], poly)) {
+        close();
+      } else if (restMs) {
+        timeoutId = setTimeout(onClose, restMs);
+      }
+    };
+  };
+
+  fn.__options = {
+    blockPointerEvents
+  };
+  return fn;
+}
+
 const DEFAULT_ID = 'floating-ui-root';
 const useFloatingPortalNode = function (_temp) {
   let {
@@ -14611,7 +14813,7 @@ var Tooltip = /*#__PURE__*/forwardRef(function (props, propRef) {
   // Event listeners to change the open state
   var hover = useHover(context, {
     move: true,
-    enabled: !clickOutsideToClose
+    handleClose: clickOutsideToClose ? safePolygon() : undefined
   });
   var focus = useFocus(context, {
     enabled: !clickOutsideToClose