@arc-ui/components 12.0.0-beta.13 → 12.0.0-beta.14.1

package/lib/Tooltip/Tooltip.mjs

@@ -0,0 +1,534 @@
+import { _ as __rest, a as __assign, f as filterAttrs } from '../_shared/esm/filter-attrs-B6CM-NUr.mjs';
+import * as React from 'react';
+import React__default from 'react';
+import { P as Primitive, c as createPopperScope, u as useComposedRefs, A as Anchor, a as composeEventHandlers, b as Presence, D as DismissableLayer, C as Content, S as Slottable, d as Arrow, R as Root2, e as Portal$1 } from '../_shared/esm/index-DBBWLR4b.mjs';
+import { c as createContextScope, e as useId, d as useControllableState, u as useThemeElement } from '../_shared/esm/index-DKUZMeu5.mjs';
+import { jsx, jsxs } from 'react/jsx-runtime';
+import { S as Surface } from '../_shared/esm/Surface-Colbp3Zx.mjs';
+import { I as Icon } from '../_shared/esm/Icon-B626JGP1.mjs';
+import { T as Text } from '../_shared/esm/Text-CBlnm5CT.mjs';
+import '../_shared/esm/index-DTF1_dbG.mjs';
+import 'react-dom';
+import '../_shared/esm/index-5C0-U8cc.mjs';
+import '../_shared/esm/index-Spae4j7j.mjs';
+import '../_shared/esm/suffix-modifier-B_pO0UkF.mjs';
+
+// packages/react/visually-hidden/src/VisuallyHidden.tsx
+var NAME = "VisuallyHidden";
+var VisuallyHidden = React.forwardRef(
+  (props, forwardedRef) => {
+    return /* @__PURE__ */ jsx(
+      Primitive.span,
+      {
+        ...props,
+        ref: forwardedRef,
+        style: {
+          // See: https://github.com/twbs/bootstrap/blob/master/scss/mixins/_screen-reader.scss
+          position: "absolute",
+          border: 0,
+          width: 1,
+          height: 1,
+          padding: 0,
+          margin: -1,
+          overflow: "hidden",
+          clip: "rect(0, 0, 0, 0)",
+          whiteSpace: "nowrap",
+          wordWrap: "normal",
+          ...props.style
+        }
+      }
+    );
+  }
+);
+VisuallyHidden.displayName = NAME;
+var Root = VisuallyHidden;
+
+var [createTooltipContext, createTooltipScope] = createContextScope("Tooltip", [
+  createPopperScope
+]);
+var usePopperScope = createPopperScope();
+var PROVIDER_NAME = "TooltipProvider";
+var DEFAULT_DELAY_DURATION = 700;
+var TOOLTIP_OPEN = "tooltip.open";
+var [TooltipProviderContextProvider, useTooltipProviderContext] = createTooltipContext(PROVIDER_NAME);
+var TooltipProvider = (props) => {
+  const {
+    __scopeTooltip,
+    delayDuration = DEFAULT_DELAY_DURATION,
+    skipDelayDuration = 300,
+    disableHoverableContent = false,
+    children
+  } = props;
+  const [isOpenDelayed, setIsOpenDelayed] = React.useState(true);
+  const isPointerInTransitRef = React.useRef(false);
+  const skipDelayTimerRef = React.useRef(0);
+  React.useEffect(() => {
+    const skipDelayTimer = skipDelayTimerRef.current;
+    return () => window.clearTimeout(skipDelayTimer);
+  }, []);
+  return /* @__PURE__ */ jsx(
+    TooltipProviderContextProvider,
+    {
+      scope: __scopeTooltip,
+      isOpenDelayed,
+      delayDuration,
+      onOpen: React.useCallback(() => {
+        window.clearTimeout(skipDelayTimerRef.current);
+        setIsOpenDelayed(false);
+      }, []),
+      onClose: React.useCallback(() => {
+        window.clearTimeout(skipDelayTimerRef.current);
+        skipDelayTimerRef.current = window.setTimeout(
+          () => setIsOpenDelayed(true),
+          skipDelayDuration
+        );
+      }, [skipDelayDuration]),
+      isPointerInTransitRef,
+      onPointerInTransitChange: React.useCallback((inTransit) => {
+        isPointerInTransitRef.current = inTransit;
+      }, []),
+      disableHoverableContent,
+      children
+    }
+  );
+};
+TooltipProvider.displayName = PROVIDER_NAME;
+var TOOLTIP_NAME = "Tooltip";
+var [TooltipContextProvider, useTooltipContext] = createTooltipContext(TOOLTIP_NAME);
+var Tooltip$1 = (props) => {
+  const {
+    __scopeTooltip,
+    children,
+    open: openProp,
+    defaultOpen = false,
+    onOpenChange,
+    disableHoverableContent: disableHoverableContentProp,
+    delayDuration: delayDurationProp
+  } = props;
+  const providerContext = useTooltipProviderContext(TOOLTIP_NAME, props.__scopeTooltip);
+  const popperScope = usePopperScope(__scopeTooltip);
+  const [trigger, setTrigger] = React.useState(null);
+  const contentId = useId();
+  const openTimerRef = React.useRef(0);
+  const disableHoverableContent = disableHoverableContentProp ?? providerContext.disableHoverableContent;
+  const delayDuration = delayDurationProp ?? providerContext.delayDuration;
+  const wasOpenDelayedRef = React.useRef(false);
+  const [open = false, setOpen] = useControllableState({
+    prop: openProp,
+    defaultProp: defaultOpen,
+    onChange: (open2) => {
+      if (open2) {
+        providerContext.onOpen();
+        document.dispatchEvent(new CustomEvent(TOOLTIP_OPEN));
+      } else {
+        providerContext.onClose();
+      }
+      onOpenChange?.(open2);
+    }
+  });
+  const stateAttribute = React.useMemo(() => {
+    return open ? wasOpenDelayedRef.current ? "delayed-open" : "instant-open" : "closed";
+  }, [open]);
+  const handleOpen = React.useCallback(() => {
+    window.clearTimeout(openTimerRef.current);
+    openTimerRef.current = 0;
+    wasOpenDelayedRef.current = false;
+    setOpen(true);
+  }, [setOpen]);
+  const handleClose = React.useCallback(() => {
+    window.clearTimeout(openTimerRef.current);
+    openTimerRef.current = 0;
+    setOpen(false);
+  }, [setOpen]);
+  const handleDelayedOpen = React.useCallback(() => {
+    window.clearTimeout(openTimerRef.current);
+    openTimerRef.current = window.setTimeout(() => {
+      wasOpenDelayedRef.current = true;
+      setOpen(true);
+      openTimerRef.current = 0;
+    }, delayDuration);
+  }, [delayDuration, setOpen]);
+  React.useEffect(() => {
+    return () => {
+      if (openTimerRef.current) {
+        window.clearTimeout(openTimerRef.current);
+        openTimerRef.current = 0;
+      }
+    };
+  }, []);
+  return /* @__PURE__ */ jsx(Root2, { ...popperScope, children: /* @__PURE__ */ jsx(
+    TooltipContextProvider,
+    {
+      scope: __scopeTooltip,
+      contentId,
+      open,
+      stateAttribute,
+      trigger,
+      onTriggerChange: setTrigger,
+      onTriggerEnter: React.useCallback(() => {
+        if (providerContext.isOpenDelayed) handleDelayedOpen();
+        else handleOpen();
+      }, [providerContext.isOpenDelayed, handleDelayedOpen, handleOpen]),
+      onTriggerLeave: React.useCallback(() => {
+        if (disableHoverableContent) {
+          handleClose();
+        } else {
+          window.clearTimeout(openTimerRef.current);
+          openTimerRef.current = 0;
+        }
+      }, [handleClose, disableHoverableContent]),
+      onOpen: handleOpen,
+      onClose: handleClose,
+      disableHoverableContent,
+      children
+    }
+  ) });
+};
+Tooltip$1.displayName = TOOLTIP_NAME;
+var TRIGGER_NAME = "TooltipTrigger";
+var TooltipTrigger = React.forwardRef(
+  (props, forwardedRef) => {
+    const { __scopeTooltip, ...triggerProps } = props;
+    const context = useTooltipContext(TRIGGER_NAME, __scopeTooltip);
+    const providerContext = useTooltipProviderContext(TRIGGER_NAME, __scopeTooltip);
+    const popperScope = usePopperScope(__scopeTooltip);
+    const ref = React.useRef(null);
+    const composedRefs = useComposedRefs(forwardedRef, ref, context.onTriggerChange);
+    const isPointerDownRef = React.useRef(false);
+    const hasPointerMoveOpenedRef = React.useRef(false);
+    const handlePointerUp = React.useCallback(() => isPointerDownRef.current = false, []);
+    React.useEffect(() => {
+      return () => document.removeEventListener("pointerup", handlePointerUp);
+    }, [handlePointerUp]);
+    return /* @__PURE__ */ jsx(Anchor, { asChild: true, ...popperScope, children: /* @__PURE__ */ jsx(
+      Primitive.button,
+      {
+        "aria-describedby": context.open ? context.contentId : void 0,
+        "data-state": context.stateAttribute,
+        ...triggerProps,
+        ref: composedRefs,
+        onPointerMove: composeEventHandlers(props.onPointerMove, (event) => {
+          if (event.pointerType === "touch") return;
+          if (!hasPointerMoveOpenedRef.current && !providerContext.isPointerInTransitRef.current) {
+            context.onTriggerEnter();
+            hasPointerMoveOpenedRef.current = true;
+          }
+        }),
+        onPointerLeave: composeEventHandlers(props.onPointerLeave, () => {
+          context.onTriggerLeave();
+          hasPointerMoveOpenedRef.current = false;
+        }),
+        onPointerDown: composeEventHandlers(props.onPointerDown, () => {
+          isPointerDownRef.current = true;
+          document.addEventListener("pointerup", handlePointerUp, { once: true });
+        }),
+        onFocus: composeEventHandlers(props.onFocus, () => {
+          if (!isPointerDownRef.current) context.onOpen();
+        }),
+        onBlur: composeEventHandlers(props.onBlur, context.onClose),
+        onClick: composeEventHandlers(props.onClick, context.onClose)
+      }
+    ) });
+  }
+);
+TooltipTrigger.displayName = TRIGGER_NAME;
+var PORTAL_NAME = "TooltipPortal";
+var [PortalProvider, usePortalContext] = createTooltipContext(PORTAL_NAME, {
+  forceMount: void 0
+});
+var TooltipPortal = (props) => {
+  const { __scopeTooltip, forceMount, children, container } = props;
+  const context = useTooltipContext(PORTAL_NAME, __scopeTooltip);
+  return /* @__PURE__ */ jsx(PortalProvider, { scope: __scopeTooltip, forceMount, children: /* @__PURE__ */ jsx(Presence, { present: forceMount || context.open, children: /* @__PURE__ */ jsx(Portal$1, { asChild: true, container, children }) }) });
+};
+TooltipPortal.displayName = PORTAL_NAME;
+var CONTENT_NAME = "TooltipContent";
+var TooltipContent = React.forwardRef(
+  (props, forwardedRef) => {
+    const portalContext = usePortalContext(CONTENT_NAME, props.__scopeTooltip);
+    const { forceMount = portalContext.forceMount, side = "top", ...contentProps } = props;
+    const context = useTooltipContext(CONTENT_NAME, props.__scopeTooltip);
+    return /* @__PURE__ */ jsx(Presence, { present: forceMount || context.open, children: context.disableHoverableContent ? /* @__PURE__ */ jsx(TooltipContentImpl, { side, ...contentProps, ref: forwardedRef }) : /* @__PURE__ */ jsx(TooltipContentHoverable, { side, ...contentProps, ref: forwardedRef }) });
+  }
+);
+var TooltipContentHoverable = React.forwardRef((props, forwardedRef) => {
+  const context = useTooltipContext(CONTENT_NAME, props.__scopeTooltip);
+  const providerContext = useTooltipProviderContext(CONTENT_NAME, props.__scopeTooltip);
+  const ref = React.useRef(null);
+  const composedRefs = useComposedRefs(forwardedRef, ref);
+  const [pointerGraceArea, setPointerGraceArea] = React.useState(null);
+  const { trigger, onClose } = context;
+  const content = ref.current;
+  const { onPointerInTransitChange } = providerContext;
+  const handleRemoveGraceArea = React.useCallback(() => {
+    setPointerGraceArea(null);
+    onPointerInTransitChange(false);
+  }, [onPointerInTransitChange]);
+  const handleCreateGraceArea = React.useCallback(
+    (event, hoverTarget) => {
+      const currentTarget = event.currentTarget;
+      const exitPoint = { x: event.clientX, y: event.clientY };
+      const exitSide = getExitSideFromRect(exitPoint, currentTarget.getBoundingClientRect());
+      const paddedExitPoints = getPaddedExitPoints(exitPoint, exitSide);
+      const hoverTargetPoints = getPointsFromRect(hoverTarget.getBoundingClientRect());
+      const graceArea = getHull([...paddedExitPoints, ...hoverTargetPoints]);
+      setPointerGraceArea(graceArea);
+      onPointerInTransitChange(true);
+    },
+    [onPointerInTransitChange]
+  );
+  React.useEffect(() => {
+    return () => handleRemoveGraceArea();
+  }, [handleRemoveGraceArea]);
+  React.useEffect(() => {
+    if (trigger && content) {
+      const handleTriggerLeave = (event) => handleCreateGraceArea(event, content);
+      const handleContentLeave = (event) => handleCreateGraceArea(event, trigger);
+      trigger.addEventListener("pointerleave", handleTriggerLeave);
+      content.addEventListener("pointerleave", handleContentLeave);
+      return () => {
+        trigger.removeEventListener("pointerleave", handleTriggerLeave);
+        content.removeEventListener("pointerleave", handleContentLeave);
+      };
+    }
+  }, [trigger, content, handleCreateGraceArea, handleRemoveGraceArea]);
+  React.useEffect(() => {
+    if (pointerGraceArea) {
+      const handleTrackPointerGrace = (event) => {
+        const target = event.target;
+        const pointerPosition = { x: event.clientX, y: event.clientY };
+        const hasEnteredTarget = trigger?.contains(target) || content?.contains(target);
+        const isPointerOutsideGraceArea = !isPointInPolygon(pointerPosition, pointerGraceArea);
+        if (hasEnteredTarget) {
+          handleRemoveGraceArea();
+        } else if (isPointerOutsideGraceArea) {
+          handleRemoveGraceArea();
+          onClose();
+        }
+      };
+      document.addEventListener("pointermove", handleTrackPointerGrace);
+      return () => document.removeEventListener("pointermove", handleTrackPointerGrace);
+    }
+  }, [trigger, content, pointerGraceArea, onClose, handleRemoveGraceArea]);
+  return /* @__PURE__ */ jsx(TooltipContentImpl, { ...props, ref: composedRefs });
+});
+var [VisuallyHiddenContentContextProvider, useVisuallyHiddenContentContext] = createTooltipContext(TOOLTIP_NAME, { isInside: false });
+var TooltipContentImpl = React.forwardRef(
+  (props, forwardedRef) => {
+    const {
+      __scopeTooltip,
+      children,
+      "aria-label": ariaLabel,
+      onEscapeKeyDown,
+      onPointerDownOutside,
+      ...contentProps
+    } = props;
+    const context = useTooltipContext(CONTENT_NAME, __scopeTooltip);
+    const popperScope = usePopperScope(__scopeTooltip);
+    const { onClose } = context;
+    React.useEffect(() => {
+      document.addEventListener(TOOLTIP_OPEN, onClose);
+      return () => document.removeEventListener(TOOLTIP_OPEN, onClose);
+    }, [onClose]);
+    React.useEffect(() => {
+      if (context.trigger) {
+        const handleScroll = (event) => {
+          const target = event.target;
+          if (target?.contains(context.trigger)) onClose();
+        };
+        window.addEventListener("scroll", handleScroll, { capture: true });
+        return () => window.removeEventListener("scroll", handleScroll, { capture: true });
+      }
+    }, [context.trigger, onClose]);
+    return /* @__PURE__ */ jsx(
+      DismissableLayer,
+      {
+        asChild: true,
+        disableOutsidePointerEvents: false,
+        onEscapeKeyDown,
+        onPointerDownOutside,
+        onFocusOutside: (event) => event.preventDefault(),
+        onDismiss: onClose,
+        children: /* @__PURE__ */ jsxs(
+          Content,
+          {
+            "data-state": context.stateAttribute,
+            ...popperScope,
+            ...contentProps,
+            ref: forwardedRef,
+            style: {
+              ...contentProps.style,
+              // re-namespace exposed content custom properties
+              ...{
+                "--radix-tooltip-content-transform-origin": "var(--radix-popper-transform-origin)",
+                "--radix-tooltip-content-available-width": "var(--radix-popper-available-width)",
+                "--radix-tooltip-content-available-height": "var(--radix-popper-available-height)",
+                "--radix-tooltip-trigger-width": "var(--radix-popper-anchor-width)",
+                "--radix-tooltip-trigger-height": "var(--radix-popper-anchor-height)"
+              }
+            },
+            children: [
+              /* @__PURE__ */ jsx(Slottable, { children }),
+              /* @__PURE__ */ jsx(VisuallyHiddenContentContextProvider, { scope: __scopeTooltip, isInside: true, children: /* @__PURE__ */ jsx(Root, { id: context.contentId, role: "tooltip", children: ariaLabel || children }) })
+            ]
+          }
+        )
+      }
+    );
+  }
+);
+TooltipContent.displayName = CONTENT_NAME;
+var ARROW_NAME = "TooltipArrow";
+var TooltipArrow = React.forwardRef(
+  (props, forwardedRef) => {
+    const { __scopeTooltip, ...arrowProps } = props;
+    const popperScope = usePopperScope(__scopeTooltip);
+    const visuallyHiddenContentContext = useVisuallyHiddenContentContext(
+      ARROW_NAME,
+      __scopeTooltip
+    );
+    return visuallyHiddenContentContext.isInside ? null : /* @__PURE__ */ jsx(Arrow, { ...popperScope, ...arrowProps, ref: forwardedRef });
+  }
+);
+TooltipArrow.displayName = ARROW_NAME;
+function getExitSideFromRect(point, rect) {
+  const top = Math.abs(rect.top - point.y);
+  const bottom = Math.abs(rect.bottom - point.y);
+  const right = Math.abs(rect.right - point.x);
+  const left = Math.abs(rect.left - point.x);
+  switch (Math.min(top, bottom, right, left)) {
+    case left:
+      return "left";
+    case right:
+      return "right";
+    case top:
+      return "top";
+    case bottom:
+      return "bottom";
+    default:
+      throw new Error("unreachable");
+  }
+}
+function getPaddedExitPoints(exitPoint, exitSide, padding = 5) {
+  const paddedExitPoints = [];
+  switch (exitSide) {
+    case "top":
+      paddedExitPoints.push(
+        { x: exitPoint.x - padding, y: exitPoint.y + padding },
+        { x: exitPoint.x + padding, y: exitPoint.y + padding }
+      );
+      break;
+    case "bottom":
+      paddedExitPoints.push(
+        { x: exitPoint.x - padding, y: exitPoint.y - padding },
+        { x: exitPoint.x + padding, y: exitPoint.y - padding }
+      );
+      break;
+    case "left":
+      paddedExitPoints.push(
+        { x: exitPoint.x + padding, y: exitPoint.y - padding },
+        { x: exitPoint.x + padding, y: exitPoint.y + padding }
+      );
+      break;
+    case "right":
+      paddedExitPoints.push(
+        { x: exitPoint.x - padding, y: exitPoint.y - padding },
+        { x: exitPoint.x - padding, y: exitPoint.y + padding }
+      );
+      break;
+  }
+  return paddedExitPoints;
+}
+function getPointsFromRect(rect) {
+  const { top, right, bottom, left } = rect;
+  return [
+    { x: left, y: top },
+    { x: right, y: top },
+    { x: right, y: bottom },
+    { x: left, y: bottom }
+  ];
+}
+function isPointInPolygon(point, polygon) {
+  const { x, y } = point;
+  let inside = false;
+  for (let i = 0, j = polygon.length - 1; i < polygon.length; j = i++) {
+    const xi = polygon[i].x;
+    const yi = polygon[i].y;
+    const xj = polygon[j].x;
+    const yj = polygon[j].y;
+    const intersect = yi > y !== yj > y && x < (xj - xi) * (y - yi) / (yj - yi) + xi;
+    if (intersect) inside = !inside;
+  }
+  return inside;
+}
+function getHull(points) {
+  const newPoints = points.slice();
+  newPoints.sort((a, b) => {
+    if (a.x < b.x) return -1;
+    else if (a.x > b.x) return 1;
+    else if (a.y < b.y) return -1;
+    else if (a.y > b.y) return 1;
+    else return 0;
+  });
+  return getHullPresorted(newPoints);
+}
+function getHullPresorted(points) {
+  if (points.length <= 1) return points.slice();
+  const upperHull = [];
+  for (let i = 0; i < points.length; i++) {
+    const p = points[i];
+    while (upperHull.length >= 2) {
+      const q = upperHull[upperHull.length - 1];
+      const r = upperHull[upperHull.length - 2];
+      if ((q.x - r.x) * (p.y - r.y) >= (q.y - r.y) * (p.x - r.x)) upperHull.pop();
+      else break;
+    }
+    upperHull.push(p);
+  }
+  upperHull.pop();
+  const lowerHull = [];
+  for (let i = points.length - 1; i >= 0; i--) {
+    const p = points[i];
+    while (lowerHull.length >= 2) {
+      const q = lowerHull[lowerHull.length - 1];
+      const r = lowerHull[lowerHull.length - 2];
+      if ((q.x - r.x) * (p.y - r.y) >= (q.y - r.y) * (p.x - r.x)) lowerHull.pop();
+      else break;
+    }
+    lowerHull.push(p);
+  }
+  lowerHull.pop();
+  if (upperHull.length === 1 && lowerHull.length === 1 && upperHull[0].x === lowerHull[0].x && upperHull[0].y === lowerHull[0].y) {
+    return upperHull;
+  } else {
+    return upperHull.concat(lowerHull);
+  }
+}
+var Root3 = Tooltip$1;
+var Trigger = TooltipTrigger;
+var Portal = TooltipPortal;
+var Content2 = TooltipContent;
+var Arrow2 = TooltipArrow;
+
+/** Use `Tooltip` to display information related to an element when the element receives keyboard focus or the mouse hovers over it */
+var Tooltip = function (_a) {
+    var children = _a.children, side = _a.side, sideOffset = _a.sideOffset, align = _a.align, alignContent = _a.alignContent, title = _a.title, supportingCopy = _a.supportingCopy, icon = _a.icon, _b = _a.maxWidth, maxWidth = _b === void 0 ? "450px" : _b, _c = _a.delayDuration, delayDuration = _c === void 0 ? 300 : _c, open = _a.open, onOpenChange = _a.onOpenChange, _d = _a.zIndex, zIndex = _d === void 0 ? 100 : _d, props = __rest(_a, ["children", "side", "sideOffset", "align", "alignContent", "title", "supportingCopy", "icon", "maxWidth", "delayDuration", "open", "onOpenChange", "zIndex"]);
+    var _e = useThemeElement(), themeElement = _e[0], setThemeElement = _e[1];
+    return (React__default.createElement("div", __assign({}, filterAttrs(props)),
+        React__default.createElement(TooltipProvider, null,
+            React__default.createElement(Root3, __assign({ delayDuration: delayDuration, open: open, onOpenChange: onOpenChange }, filterAttrs(props)),
+                React__default.createElement(Trigger, { className: "arc-Tooltip-trigger" }, children),
+                React__default.createElement("div", { ref: setThemeElement },
+                    React__default.createElement(Portal, { container: themeElement },
+                        React__default.createElement(Content2, __assign({ side: side, sideOffset: sideOffset, align: align, alignOffset: align === "start" ? -4 : align === "end" ? -4 : undefined, style: { zIndex: zIndex } }, props),
+                            React__default.createElement(Surface, { background: "dark-neutral-01", isTransparent: true },
+                                React__default.createElement("div", { className: "arc-Tooltip-content", style: { maxWidth: maxWidth, textAlign: alignContent } },
+                                    React__default.createElement("div", { style: { display: "flex", gap: 4, alignItems: "center" } },
+                                        icon && (React__default.createElement("div", { style: { flexShrink: 0 } },
+                                            React__default.createElement(Icon, { icon: icon, size: 24 }))),
+                                        React__default.createElement(Text, { size: "s" }, title)),
+                                    React__default.createElement(Text, { tone: "supporting", size: "s" }, supportingCopy),
+                                    React__default.createElement(Arrow2, { className: "arc-Tooltip-arrow" }))))))))));
+};
+
+export { Tooltip };

package/lib/Tooltip/styles.css

@@ -0,0 +1 @@
+.arc-v12-0-0-beta-14-1 .arc .arc-Tooltip-arrow{background:#434343;border-bottom:1px solid #2a2a2a;border-bottom-right-radius:1px;border-right:1px solid #2a2a2a;fill:none;height:10px;position:relative;transform:translate(0,-52%) rotate(45deg);width:10px}.arc-v12-0-0-beta-14-1 .arc .arc-Tooltip-trigger{all:unset;cursor:pointer}.arc-v12-0-0-beta-14-1 .arc .arc-Tooltip-content{background:#434343;border:1px solid #2a2a2a;border-radius:5px;box-shadow:var(--elevation-02);padding:4px 8px;text-align:center}.arc-v12-0-0-beta-14-1 .arc .arc-Tooltip-trigger:focus{border-radius:var(--focus-border-radius-s);outline:var(--focus-border-weight-s) solid transparent;outline-offset:2px}.arc-v12-0-0-beta-14-1 .arc .arc-Tooltip-trigger:focus-visible{outline-color:var(--focus-colors-light-border-subtle)}

package/lib/Truncate/Truncate.cjs

@@ -0,0 +1,12 @@
+'use strict';
+
+var filterAttrs = require('../_shared/cjs/filter-attrs-eK6E_34o.cjs');
+var React = require('react');
+
+/** Use `Truncate` component to shorten text with an ellipsis. Add a `title` attribute to the truncated element so the full text remains accessible. */
+var Truncate = function (_a) {
+    var _b = _a.maxWidth, maxWidth = _b === void 0 ? "100%" : _b, title = _a.title, children = _a.children, props = filterAttrs.__rest(_a, ["maxWidth", "title", "children"]);
+    return (React.createElement("div", filterAttrs.__assign({ className: "arc-Truncate", style: { maxWidth: maxWidth }, title: title }, filterAttrs.filterAttrs(props)), children));
+};
+
+exports.Truncate = Truncate;

package/lib/Truncate/Truncate.mjs

@@ -0,0 +1,10 @@
+import { _ as __rest, a as __assign, f as filterAttrs } from '../_shared/esm/filter-attrs-B6CM-NUr.mjs';
+import React__default from 'react';
+
+/** Use `Truncate` component to shorten text with an ellipsis. Add a `title` attribute to the truncated element so the full text remains accessible. */
+var Truncate = function (_a) {
+    var _b = _a.maxWidth, maxWidth = _b === void 0 ? "100%" : _b, title = _a.title, children = _a.children, props = __rest(_a, ["maxWidth", "title", "children"]);
+    return (React__default.createElement("div", __assign({ className: "arc-Truncate", style: { maxWidth: maxWidth }, title: title }, filterAttrs(props)), children));
+};
+
+export { Truncate };

package/lib/Truncate/styles.css

@@ -0,0 +1 @@
+.arc-v12-0-0-beta-14-1 .arc .arc-Truncate>*,.arc-v12-0-0-beta-14-1 .arc .arc-Truncate{display:inherit;overflow:hidden;text-overflow:ellipsis;vertical-align:baseline;vertical-align:initial;white-space:nowrap}

package/lib/TypographyCard/TypographyCard.cjs

@@ -0,0 +1,36 @@
+'use strict';
+
+var filterAttrs = require('../_shared/cjs/filter-attrs-eK6E_34o.cjs');
+var React = require('react');
+var index = require('../_shared/cjs/index-CTlXMLug.cjs');
+var Surface = require('../_shared/cjs/Surface-BFx1yNsq.cjs');
+var CardHeading = require('../_shared/cjs/CardHeading-DJHqAMXm.cjs');
+var CardFooter = require('../_shared/cjs/CardFooter-BA8K3lsL.cjs');
+require('../_shared/cjs/index-DR8Rkav9.cjs');
+require('../_shared/cjs/Heading-ByiXEHGj.cjs');
+require('../_shared/cjs/suffix-modifier-DLUGR-yG.cjs');
+require('../_shared/cjs/BtIconArrowRight-tlOxlRcu.cjs');
+require('../_shared/cjs/BtIconPlayFill-1FkY9-lL.cjs');
+require('../_shared/cjs/Icon-DdqFr6bT.cjs');
+require('../_shared/cjs/index-BLRjGROQ.cjs');
+
+/** Use `TypographyCard` for content that benefits from larger and energetic typography. */
+var TypographyCard = function (_a) {
+    var url = _a.url, onClick = _a.onClick, heading = _a.heading, metaText = _a.metaText, label = _a.label, minHeight = _a.minHeight, _b = _a.headingSize, headingSize = _b === void 0 ? "m" : _b, _c = _a.linkData, linkData = _c === void 0 ? {} : _c, _d = _a.pathway, pathway = _d === void 0 ? "light" : _d, _e = _a.buttonIcon, buttonIcon = _e === void 0 ? "arrow" : _e, _f = _a.headingLevel, headingLevel = _f === void 0 ? "2" : _f, props = filterAttrs.__rest(_a, ["url", "onClick", "heading", "metaText", "label", "minHeight", "headingSize", "linkData", "pathway", "buttonIcon", "headingLevel"]);
+    var surface = React.useContext(Surface.Context).surface;
+    var _g = React.useState(false), showHoverState = _g[0], setShowHoverState = _g[1];
+    var handleShowHoverState = function (show) { return function () { return setShowHoverState(show); }; };
+    var isDarkPathway = pathway === "dark";
+    return (React.createElement("div", filterAttrs.__assign({ style: { minHeight: minHeight }, className: index.classNames("arc-TypographyCard", {
+            "arc-TypographyCard--outlined": showHoverState,
+            "arc-TypographyCard--darkPathway": isDarkPathway,
+            "arc-TypographyCard--lightPathway": !isDarkPathway,
+            "arc-TypographyCard--onDarkSurface": surface === "dark",
+        }) }, filterAttrs.filterAttrs(props)),
+        React.createElement("div", { className: "arc-TypographyCard-contentContainer" },
+            label && (React.createElement("div", { className: "arc-TypographyCard-label" }, label.toUpperCase())),
+            React.createElement(CardHeading.CardHeading, { size: headingSize, linkData: linkData, heading: heading, headingLevel: headingLevel, href: url, onClick: onClick, onMouseEnter: handleShowHoverState(true), onMouseLeave: handleShowHoverState(false), onFocus: handleShowHoverState(true), onBlur: handleShowHoverState(false) })),
+        React.createElement(CardFooter.CardFooter, { showButton: true, isDarkPathway: isDarkPathway, buttonIcon: buttonIcon, metaText: metaText, isHovered: showHoverState })));
+};
+
+exports.TypographyCard = TypographyCard;

package/lib/TypographyCard/TypographyCard.mjs

@@ -0,0 +1,34 @@
+import { _ as __rest, a as __assign, f as filterAttrs } from '../_shared/esm/filter-attrs-B6CM-NUr.mjs';
+import React__default, { useContext, useState } from 'react';
+import { c as classNames } from '../_shared/esm/index-5C0-U8cc.mjs';
+import { C as Context } from '../_shared/esm/Surface-Colbp3Zx.mjs';
+import { C as CardHeading } from '../_shared/esm/CardHeading-C7ZPtnmj.mjs';
+import { C as CardFooter } from '../_shared/esm/CardFooter-B1zkMZd9.mjs';
+import '../_shared/esm/index-Spae4j7j.mjs';
+import '../_shared/esm/Heading-CtGuamJw.mjs';
+import '../_shared/esm/suffix-modifier-B_pO0UkF.mjs';
+import '../_shared/esm/BtIconArrowRight-26CZetOo.mjs';
+import '../_shared/esm/BtIconPlayFill-Bi65YfLF.mjs';
+import '../_shared/esm/Icon-B626JGP1.mjs';
+import '../_shared/esm/index-Cr6KeQLU.mjs';
+
+/** Use `TypographyCard` for content that benefits from larger and energetic typography. */
+var TypographyCard = function (_a) {
+    var url = _a.url, onClick = _a.onClick, heading = _a.heading, metaText = _a.metaText, label = _a.label, minHeight = _a.minHeight, _b = _a.headingSize, headingSize = _b === void 0 ? "m" : _b, _c = _a.linkData, linkData = _c === void 0 ? {} : _c, _d = _a.pathway, pathway = _d === void 0 ? "light" : _d, _e = _a.buttonIcon, buttonIcon = _e === void 0 ? "arrow" : _e, _f = _a.headingLevel, headingLevel = _f === void 0 ? "2" : _f, props = __rest(_a, ["url", "onClick", "heading", "metaText", "label", "minHeight", "headingSize", "linkData", "pathway", "buttonIcon", "headingLevel"]);
+    var surface = useContext(Context).surface;
+    var _g = useState(false), showHoverState = _g[0], setShowHoverState = _g[1];
+    var handleShowHoverState = function (show) { return function () { return setShowHoverState(show); }; };
+    var isDarkPathway = pathway === "dark";
+    return (React__default.createElement("div", __assign({ style: { minHeight: minHeight }, className: classNames("arc-TypographyCard", {
+            "arc-TypographyCard--outlined": showHoverState,
+            "arc-TypographyCard--darkPathway": isDarkPathway,
+            "arc-TypographyCard--lightPathway": !isDarkPathway,
+            "arc-TypographyCard--onDarkSurface": surface === "dark",
+        }) }, filterAttrs(props)),
+        React__default.createElement("div", { className: "arc-TypographyCard-contentContainer" },
+            label && (React__default.createElement("div", { className: "arc-TypographyCard-label" }, label.toUpperCase())),
+            React__default.createElement(CardHeading, { size: headingSize, linkData: linkData, heading: heading, headingLevel: headingLevel, href: url, onClick: onClick, onMouseEnter: handleShowHoverState(true), onMouseLeave: handleShowHoverState(false), onFocus: handleShowHoverState(true), onBlur: handleShowHoverState(false) })),
+        React__default.createElement(CardFooter, { showButton: true, isDarkPathway: isDarkPathway, buttonIcon: buttonIcon, metaText: metaText, isHovered: showHoverState })));
+};
+
+export { TypographyCard };

package/lib/TypographyCard/styles.css

@@ -0,0 +1 @@
+.arc-v12-0-0-beta-14-1 .arc .arc-TypographyCard{border-radius:var(--card-border-radius-s);box-shadow:0 0 1px var(--card-border-weight-s) var(--card-colors-light-border-default);color:var(--card-colors-light-text-default);display:flex;flex-direction:column;height:100%;outline:var(--focus-border-weight-s) solid transparent;outline-offset:2px;overflow:hidden;padding:var(--card-padding-s);position:relative;transition:outline 0.2s ease-in-out}.arc-v12-0-0-beta-14-1 .arc .arc-TypographyCard-contentContainer{display:flex;flex:1 1 auto;flex-direction:column;margin-bottom:24px}.arc-v12-0-0-beta-14-1 .arc .arc-TypographyCard-label{color:var(--card-colors-light-text-support);font:var(--sem-type-body-semi-s);margin-bottom:var(--card-gap-m)}.arc-v12-0-0-beta-14-1 .arc .arc-TypographyCard--outlined{box-shadow:0 0 0 2px var(--card-colors-light-border-hover)}.arc-v12-0-0-beta-14-1 .arc .arc-TypographyCard--outlined:not(.arc-TypographyCard--darkPathway) .arc-CardHeading-link{color:var(--card-colors-light-text-hover)}.arc-v12-0-0-beta-14-1 .arc .arc-TypographyCard--darkPathway.arc-TypographyCard--outlined .arc-CardHeading{color:var(--card-colors-dark-text-hover)}.arc-v12-0-0-beta-14-1 .arc .arc-TypographyCard--darkPathway.arc-TypographyCard--outlined{box-shadow:0 0 0 2px var(--card-colors-dark-border-hover)}.arc-v12-0-0-beta-14-1 .arc .arc-TypographyCard--darkPathway.arc-TypographyCard--outlined[focus-within]{box-shadow:0 0 0 2px transparent}.arc-v12-0-0-beta-14-1 .arc .arc-TypographyCard--darkPathway.arc-TypographyCard--outlined:focus-within{box-shadow:0 0 0 2px transparent}.arc-v12-0-0-beta-14-1 .arc .arc-TypographyCard--outlined[focus-within]{box-shadow:0 0 0 1px var(--card-colors-light-border-default);outline-color:var(--focus-colors-light-border-subtle)}.arc-v12-0-0-beta-14-1 .arc .arc-TypographyCard--outlined:focus-within{box-shadow:0 0 0 1px var(--card-colors-light-border-default);outline-color:var(--focus-colors-light-border-subtle)}.arc-v12-0-0-beta-14-1 .arc .arc-TypographyCard--lightPathway{background:var(--card-colors-light-bg-emphasis)}.arc-v12-0-0-beta-14-1 .arc .arc-TypographyCard--darkPathway{background:var(--card-colors-dark-bg-emphasis);box-shadow:0 0 0 1px transparent;color:var(--card-colors-dark-text-default)}.arc-v12-0-0-beta-14-1 .arc .arc-TypographyCard--darkPathway .arc-TypographyCard-label{color:var(--card-colors-dark-text-support)}.arc-v12-0-0-beta-14-1 .arc .arc-TypographyCard--onDarkSurface.arc-TypographyCard--outlined[focus-within]{box-shadow:0 0 0 1px transparent;outline-color:var(--focus-colors-dark-border-subtle)}.arc-v12-0-0-beta-14-1 .arc .arc-TypographyCard--onDarkSurface.arc-TypographyCard--outlined:focus-within{box-shadow:0 0 0 1px transparent;outline-color:var(--focus-colors-dark-border-subtle)}@media (min-width:636px){.arc-v12-0-0-beta-14-1 .arc .arc-TypographyCard{padding:var(--card-padding-m)}}

package/lib/UniversalHeader/UniversalHeader.cjs

@@ -0,0 +1,12 @@
+'use strict';
+
+var UniversalHeader = require('../_shared/cjs/UniversalHeader-DUo1yR-g.cjs');
+require('../_shared/cjs/filter-attrs-eK6E_34o.cjs');
+require('react');
+require('../_shared/cjs/index-CTlXMLug.cjs');
+require('../_shared/cjs/Surface-BFx1yNsq.cjs');
+require('../_shared/cjs/index-DR8Rkav9.cjs');
+
+
+
+exports.UniversalHeader = UniversalHeader.UniversalHeader;

package/lib/UniversalHeader/UniversalHeader.mjs

@@ -0,0 +1,6 @@
+export { U as UniversalHeader } from '../_shared/esm/UniversalHeader-4Qm-HxD7.mjs';
+import '../_shared/esm/filter-attrs-B6CM-NUr.mjs';
+import 'react';
+import '../_shared/esm/index-5C0-U8cc.mjs';
+import '../_shared/esm/Surface-Colbp3Zx.mjs';
+import '../_shared/esm/index-Spae4j7j.mjs';