@1771technologies/lytenyte-pro 0.0.39

package/dist/useAnchorPositioning-Cm44rb7y.js

@@ -0,0 +1,252 @@
+import * as React from "react";
+import { a as useLatestRef, s as shift, l as limitShift, b as size, c as arrow, h as hide, g as getSide, d as useFloating, u as useEnhancedEffect, e as autoUpdate, f as getAlignment, o as offset, i as flip } from "./InternalBackdrop-Dm9czgoC.js";
+const DirectionContext = /* @__PURE__ */ React.createContext(void 0);
+if (process.env.NODE_ENV !== "production") {
+  DirectionContext.displayName = "DirectionContext";
+}
+function useDirection(optional = true) {
+  const context = React.useContext(DirectionContext);
+  if (context === void 0 && !optional) {
+    throw new Error("Base UI: DirectionContext is missing.");
+  }
+  return context?.direction ?? "ltr";
+}
+function getLogicalSide(sideParam, renderedSide, isRtl) {
+  const isLogicalSideParam = sideParam === "inline-start" || sideParam === "inline-end";
+  const logicalRight = isRtl ? "inline-start" : "inline-end";
+  const logicalLeft = isRtl ? "inline-end" : "inline-start";
+  return {
+    top: "top",
+    right: isLogicalSideParam ? logicalRight : "right",
+    bottom: "bottom",
+    left: isLogicalSideParam ? logicalLeft : "left"
+  }[renderedSide];
+}
+function useAnchorPositioning(params) {
+  const {
+    // Public parameters
+    anchor,
+    positionMethod = "absolute",
+    side: sideParam = "bottom",
+    sideOffset = 0,
+    align = "center",
+    alignOffset = 0,
+    collisionBoundary,
+    collisionPadding = 5,
+    sticky = false,
+    arrowPadding = 5,
+    // Private parameters
+    keepMounted = false,
+    floatingRootContext,
+    mounted,
+    trackAnchor = true,
+    nodeId
+  } = params;
+  const direction = useDirection();
+  const isRtl = direction === "rtl";
+  const side = {
+    top: "top",
+    right: "right",
+    bottom: "bottom",
+    left: "left",
+    "inline-end": isRtl ? "left" : "right",
+    "inline-start": isRtl ? "right" : "left"
+  }[sideParam];
+  const placement = align === "center" ? side : `${side}-${align}`;
+  const commonCollisionProps = {
+    boundary: collisionBoundary === "clipping-ancestors" ? "clippingAncestors" : collisionBoundary,
+    padding: collisionPadding
+  };
+  const arrowRef = React.useRef(null);
+  const sideOffsetRef = useLatestRef(sideOffset);
+  const alignOffsetRef = useLatestRef(alignOffset);
+  const sideOffsetDep = typeof sideOffset !== "function" ? sideOffset : 0;
+  const alignOffsetDep = typeof alignOffset !== "function" ? alignOffset : 0;
+  const middleware = [offset(({
+    rects,
+    placement: currentPlacement
+  }) => {
+    const data = {
+      side: getLogicalSide(sideParam, getSide(currentPlacement), isRtl),
+      align: getAlignment(currentPlacement) || "center",
+      anchor: {
+        width: rects.reference.width,
+        height: rects.reference.height
+      },
+      positioner: {
+        width: rects.floating.width,
+        height: rects.floating.height
+      }
+    };
+    const sideAxis = typeof sideOffsetRef.current === "function" ? sideOffsetRef.current(data) : sideOffsetRef.current;
+    const alignAxis = typeof alignOffsetRef.current === "function" ? alignOffsetRef.current(data) : alignOffsetRef.current;
+    return {
+      mainAxis: sideAxis,
+      crossAxis: alignAxis,
+      alignmentAxis: alignAxis
+    };
+  }, [sideOffsetDep, alignOffsetDep, isRtl, sideParam])];
+  const flipMiddleware = flip(commonCollisionProps);
+  const shiftMiddleware = shift({
+    ...commonCollisionProps,
+    crossAxis: sticky,
+    limiter: sticky ? void 0 : limitShift(() => {
+      if (!arrowRef.current) {
+        return {};
+      }
+      const {
+        height
+      } = arrowRef.current.getBoundingClientRect();
+      return {
+        offset: height / 2 + (typeof collisionPadding === "number" ? collisionPadding : 0)
+      };
+    })
+  });
+  if (align !== "center") {
+    middleware.push(flipMiddleware, shiftMiddleware);
+  } else {
+    middleware.push(shiftMiddleware, flipMiddleware);
+  }
+  middleware.push(size({
+    ...commonCollisionProps,
+    apply({
+      elements: {
+        floating
+      },
+      rects: {
+        reference
+      },
+      availableWidth,
+      availableHeight
+    }) {
+      Object.entries({
+        "--available-width": `${availableWidth}px`,
+        "--available-height": `${availableHeight}px`,
+        "--anchor-width": `${reference.width}px`,
+        "--anchor-height": `${reference.height}px`
+      }).forEach(([key, value]) => {
+        floating.style.setProperty(key, value);
+      });
+    }
+  }), arrow(() => ({
+    // `transform-origin` calculations rely on an element existing. If the arrow hasn't been set,
+    // we'll create a fake element.
+    element: arrowRef.current || document.createElement("div"),
+    padding: arrowPadding
+  }), [arrowPadding]), hide(), {
+    name: "transformOrigin",
+    fn({
+      elements: elements2,
+      middlewareData: middlewareData2,
+      placement: renderedPlacement2
+    }) {
+      const currentRenderedSide = getSide(renderedPlacement2);
+      const arrowEl = arrowRef.current;
+      const arrowX = middlewareData2.arrow?.x ?? 0;
+      const arrowY = middlewareData2.arrow?.y ?? 0;
+      const arrowWidth = arrowEl?.clientWidth ?? 0;
+      const arrowHeight = arrowEl?.clientHeight ?? 0;
+      const transformX = arrowX + arrowWidth / 2;
+      const transformY = arrowY + arrowHeight / 2;
+      const transformOrigin = {
+        top: `${transformX}px calc(100% + ${sideOffset}px)`,
+        bottom: `${transformX}px ${-sideOffset}px`,
+        left: `calc(100% + ${sideOffset}px) ${transformY}px`,
+        right: `${-sideOffset}px ${transformY}px`
+      }[currentRenderedSide];
+      elements2.floating.style.setProperty("--transform-origin", transformOrigin);
+      return {};
+    }
+  });
+  let rootContext = floatingRootContext;
+  if (!mounted && floatingRootContext) {
+    rootContext = {
+      ...floatingRootContext,
+      elements: {
+        reference: null,
+        floating: null,
+        domReference: null
+      }
+    };
+  }
+  const autoUpdateOptions = React.useMemo(() => ({
+    elementResize: trackAnchor && typeof ResizeObserver !== "undefined",
+    layoutShift: trackAnchor && typeof IntersectionObserver !== "undefined"
+  }), [trackAnchor]);
+  const {
+    refs,
+    elements,
+    floatingStyles,
+    middlewareData,
+    update,
+    placement: renderedPlacement,
+    context,
+    isPositioned
+  } = useFloating({
+    rootContext,
+    placement,
+    middleware,
+    strategy: positionMethod,
+    whileElementsMounted: keepMounted ? void 0 : (...args) => autoUpdate(...args, autoUpdateOptions),
+    nodeId
+  });
+  const registeredPositionReferenceRef = React.useRef(null);
+  useEnhancedEffect(() => {
+    if (!mounted) {
+      return;
+    }
+    const resolvedAnchor = typeof anchor === "function" ? anchor() : anchor;
+    if (resolvedAnchor) {
+      const unwrappedElement = isRef(resolvedAnchor) ? resolvedAnchor.current : resolvedAnchor;
+      refs.setPositionReference(unwrappedElement);
+      registeredPositionReferenceRef.current = unwrappedElement;
+    }
+  }, [mounted, refs, anchor]);
+  React.useEffect(() => {
+    if (!mounted) {
+      return;
+    }
+    if (typeof anchor === "function") {
+      return;
+    }
+    if (isRef(anchor) && anchor.current !== registeredPositionReferenceRef.current) {
+      refs.setPositionReference(anchor.current);
+      registeredPositionReferenceRef.current = anchor.current;
+    }
+  }, [mounted, refs, anchor]);
+  React.useEffect(() => {
+    if (keepMounted && mounted && elements.domReference && elements.floating) {
+      return autoUpdate(elements.domReference, elements.floating, update, autoUpdateOptions);
+    }
+    return void 0;
+  }, [keepMounted, mounted, elements, update, autoUpdateOptions]);
+  const renderedSide = getSide(renderedPlacement);
+  const logicalRenderedSide = getLogicalSide(sideParam, renderedSide, isRtl);
+  const renderedAlign = getAlignment(renderedPlacement) || "center";
+  const anchorHidden = Boolean(middlewareData.hide?.referenceHidden);
+  const arrowStyles = React.useMemo(() => ({
+    position: "absolute",
+    top: middlewareData.arrow?.y,
+    left: middlewareData.arrow?.x
+  }), [middlewareData.arrow]);
+  const arrowUncentered = middlewareData.arrow?.centerOffset !== 0;
+  return React.useMemo(() => ({
+    positionerStyles: floatingStyles,
+    arrowStyles,
+    arrowRef,
+    arrowUncentered,
+    side: logicalRenderedSide,
+    align: renderedAlign,
+    anchorHidden,
+    refs,
+    context,
+    isPositioned
+  }), [floatingStyles, arrowStyles, arrowRef, arrowUncentered, logicalRenderedSide, renderedAlign, anchorHidden, refs, context, isPositioned]);
+}
+function isRef(param) {
+  return param != null && "current" in param;
+}
+export {
+  useDirection as a,
+  useAnchorPositioning as u
+};

package/dist/useBaseUiId-J66PFGv_.js

@@ -0,0 +1,48 @@
+import * as React from "react";
+const STARTING_HOOK = {
+  "data-starting-style": ""
+};
+const ENDING_HOOK = {
+  "data-ending-style": ""
+};
+const transitionStatusMapping = {
+  transitionStatus(value) {
+    if (value === "starting") {
+      return STARTING_HOOK;
+    }
+    if (value === "ending") {
+      return ENDING_HOOK;
+    }
+    return null;
+  }
+};
+let globalId = 0;
+function useGlobalId(idOverride, prefix = "mui") {
+  const [defaultId, setDefaultId] = React.useState(idOverride);
+  const id = idOverride || defaultId;
+  React.useEffect(() => {
+    if (defaultId == null) {
+      globalId += 1;
+      setDefaultId(`${prefix}-${globalId}`);
+    }
+  }, [defaultId, prefix]);
+  return id;
+}
+const safeReact = {
+  ...React
+};
+const maybeReactUseId = safeReact.useId;
+function useId(idOverride, prefix) {
+  if (maybeReactUseId !== void 0) {
+    const reactId = maybeReactUseId();
+    return idOverride ?? `${prefix}-${reactId}`;
+  }
+  return useGlobalId(idOverride, prefix);
+}
+function useBaseUiId(idOverride) {
+  return useId(idOverride, "base-ui");
+}
+export {
+  transitionStatusMapping as t,
+  useBaseUiId as u
+};

package/dist/useButton-Cy7tjZ__.js

@@ -0,0 +1,183 @@
+import * as React from "react";
+import { u as useEnhancedEffect, j as useEventCallback, k as useForkRef, m as mergeProps, n as makeEventPreventable } from "./InternalBackdrop-Dm9czgoC.js";
+let set;
+if (process.env.NODE_ENV !== "production") {
+  set = /* @__PURE__ */ new Set();
+}
+function warn(...messages) {
+  if (process.env.NODE_ENV !== "production") {
+    const messageKey = messages.join(" ");
+    if (!set.has(messageKey)) {
+      set.add(messageKey);
+      console.warn(`Base UI: ${messageKey}`);
+    }
+  }
+}
+function useRootElementName(parameters) {
+  const {
+    rootElementName: rootElementNameProp = ""
+  } = parameters;
+  const [rootElementName, setRootElementName] = React.useState(rootElementNameProp.toUpperCase());
+  if (process.env.NODE_ENV !== "production") {
+    useEnhancedEffect(() => {
+      if (rootElementNameProp && rootElementName !== rootElementNameProp.toUpperCase()) {
+        warn(`useRootElementName expected the '${rootElementNameProp}' element, but a '${rootElementName.toLowerCase()}' was rendered instead`, "This may cause hydration issues in an SSR context, for example in a Next.js app");
+      }
+    }, [rootElementNameProp, rootElementName]);
+  }
+  const updateRootElementName = React.useCallback((element) => {
+    setRootElementName(element?.tagName ?? "");
+  }, []);
+  return {
+    rootElementName,
+    updateRootElementName
+  };
+}
+const CompositeRootContext = /* @__PURE__ */ React.createContext(void 0);
+if (process.env.NODE_ENV !== "production") {
+  CompositeRootContext.displayName = "CompositeRootContext";
+}
+function useCompositeRootContext(optional = false) {
+  const context = React.useContext(CompositeRootContext);
+  if (context === void 0 && !optional) {
+    throw new Error("Base UI: CompositeRootContext is missing. Composite parts must be placed within <Composite.Root>.");
+  }
+  return context;
+}
+function useButton(parameters = {}) {
+  const {
+    buttonRef: externalRef,
+    disabled = false,
+    focusableWhenDisabled,
+    tabIndex,
+    type,
+    elementName: elementNameProp
+  } = parameters;
+  const buttonRef = React.useRef(null);
+  const {
+    rootElementName: elementName,
+    updateRootElementName
+  } = useRootElementName({
+    rootElementName: elementNameProp
+  });
+  const isCompositeItem = useCompositeRootContext(true) !== void 0;
+  const isNativeButton = useEventCallback(() => {
+    const element = buttonRef.current;
+    return elementName === "BUTTON" || elementName === "INPUT" && ["button", "submit", "reset"].includes(element?.type);
+  });
+  const isValidLink = useEventCallback(() => {
+    const element = buttonRef.current;
+    return Boolean(elementName === "A" && element?.href);
+  });
+  const mergedRef = useForkRef(updateRootElementName, externalRef, buttonRef);
+  const buttonProps = React.useMemo(() => {
+    const additionalProps = {};
+    if (tabIndex !== void 0 && !isCompositeItem) {
+      additionalProps.tabIndex = tabIndex;
+    }
+    if (elementName === "BUTTON" || elementName === "INPUT") {
+      if (focusableWhenDisabled || isCompositeItem) {
+        additionalProps["aria-disabled"] = disabled;
+      } else if (!isCompositeItem) {
+        additionalProps.disabled = disabled;
+      }
+    } else if (elementName !== "") {
+      if (elementName !== "A") {
+        additionalProps.role = "button";
+        if (!isCompositeItem) {
+          additionalProps.tabIndex = tabIndex ?? 0;
+        }
+      } else if (tabIndex && !isCompositeItem) {
+        additionalProps.tabIndex = tabIndex;
+      }
+      if (disabled) {
+        additionalProps["aria-disabled"] = disabled;
+        if (!isCompositeItem) {
+          additionalProps.tabIndex = focusableWhenDisabled ? tabIndex ?? 0 : -1;
+        }
+      }
+    }
+    return additionalProps;
+  }, [disabled, elementName, focusableWhenDisabled, isCompositeItem, tabIndex]);
+  useEnhancedEffect(() => {
+    const element = buttonRef.current;
+    if (!(element instanceof HTMLButtonElement)) {
+      return;
+    }
+    if (isCompositeItem && disabled && buttonProps.disabled === void 0 && element.disabled) {
+      element.disabled = false;
+    }
+  }, [disabled, buttonProps.disabled, isCompositeItem]);
+  const getButtonProps = React.useCallback((externalProps = {}) => {
+    const {
+      onClick: externalOnClick,
+      onMouseDown: externalOnMouseDown,
+      onKeyUp: externalOnKeyUp,
+      onKeyDown: externalOnKeyDown,
+      onPointerDown: externalOnPointerDown,
+      ...otherExternalProps
+    } = externalProps;
+    return mergeProps({
+      type,
+      onClick(event) {
+        if (disabled) {
+          event.preventDefault();
+          return;
+        }
+        externalOnClick?.(event);
+      },
+      onMouseDown(event) {
+        if (!disabled) {
+          externalOnMouseDown?.(event);
+        }
+      },
+      onKeyDown(event) {
+        if (
+          // allow Tabbing away from focusableWhenDisabled buttons
+          disabled && focusableWhenDisabled && event.key !== "Tab" || event.target === event.currentTarget && !isNativeButton() && event.key === " "
+        ) {
+          event.preventDefault();
+        }
+        if (!disabled) {
+          makeEventPreventable(event);
+          externalOnKeyDown?.(event);
+        }
+        if (event.baseUIHandlerPrevented) {
+          return;
+        }
+        if (event.target === event.currentTarget && !isNativeButton() && !isValidLink() && event.key === "Enter" && !disabled) {
+          externalOnClick?.(event);
+          event.preventDefault();
+        }
+      },
+      onKeyUp(event) {
+        if (!disabled) {
+          makeEventPreventable(event);
+          externalOnKeyUp?.(event);
+        }
+        if (event.baseUIHandlerPrevented) {
+          return;
+        }
+        if (event.target === event.currentTarget && !isNativeButton() && !disabled && event.key === " ") {
+          externalOnClick?.(event);
+        }
+      },
+      onPointerDown(event) {
+        if (disabled) {
+          event.preventDefault();
+          return;
+        }
+        externalOnPointerDown?.(event);
+      },
+      ref: mergedRef
+    }, buttonProps, otherExternalProps);
+  }, [buttonProps, disabled, focusableWhenDisabled, isNativeButton, isValidLink, mergedRef, type]);
+  return {
+    getButtonProps,
+    buttonRef: mergedRef
+  };
+}
+export {
+  useButton as u,
+  warn as w
+};

package/dist/useCompositeListItem-I14CpQPi.js

@@ -0,0 +1,51 @@
+import * as React from "react";
+import { u as useEnhancedEffect } from "./InternalBackdrop-Dm9czgoC.js";
+import { u as useCompositeListContext } from "./useScrollLock-D6h5lZYs.js";
+function useCompositeListItem(params = {}) {
+  const {
+    label,
+    metadata
+  } = params;
+  const {
+    register,
+    unregister,
+    map,
+    elementsRef,
+    labelsRef
+  } = useCompositeListContext();
+  const [index, setIndex] = React.useState(null);
+  const componentRef = React.useRef(null);
+  const ref = React.useCallback((node) => {
+    componentRef.current = node;
+    if (index !== null) {
+      elementsRef.current[index] = node;
+      if (labelsRef) {
+        const isLabelDefined = label !== void 0;
+        labelsRef.current[index] = isLabelDefined ? label : node?.textContent ?? null;
+      }
+    }
+  }, [index, elementsRef, labelsRef, label]);
+  useEnhancedEffect(() => {
+    const node = componentRef.current;
+    if (node) {
+      register(node, metadata);
+      return () => {
+        unregister(node);
+      };
+    }
+    return void 0;
+  }, [register, unregister, metadata]);
+  useEnhancedEffect(() => {
+    const i = componentRef.current ? map.get(componentRef.current)?.index : null;
+    if (i != null) {
+      setIndex(i);
+    }
+  }, [map]);
+  return React.useMemo(() => ({
+    ref,
+    index: index == null ? -1 : index
+  }), [index, ref]);
+}
+export {
+  useCompositeListItem as u
+};