import { dynamic } from "@solidjs/web";
import { createEffect, createMemo, omit, onCleanup, untrack } from "solid-js";
import { composeRefs, userRef } from "../../internals/compose-refs.jsx";
import { useDelayGroup } from "../../internals/floating-ui/components/floating-delay-group.jsx";
import { useHover } from "../../internals/floating-ui/hooks/use-hover.jsx";
import { safePolygon } from "../../internals/floating-ui/safe-polygon.jsx";
import { mergeRootProps } from "../../internals/merge-root-props.jsx";
import { resolveClassStyle } from "../../internals/resolve-class-style.jsx";
import { useButton } from "../../internals/use-button/use-button.jsx";
import { useIsoLayoutEffect } from "../../internals/use-iso-layout-effect.jsx";
import { OPEN_DELAY } from "../constants.jsx";
import { useTooltipProviderContext } from "../tooltip-provider-context.jsx";
import { useTooltipRootContext } from "../tooltip-root-context.jsx";
/**
 * An element to attach the tooltip to. Renders a `<button>` element.
 *
 * Solid 2.0-native rewire (§1 wave 2): replaces `renderElement` with
 * `dynamic(() => props.as ?? "button")` and composes hover +
 * useButton + reference props + state-attr getters via `mergeRootProps`.
 */
export function TooltipTrigger(props) {
  const rootContext = useTooltipRootContext();
  const disabled = () => {
    const own = props.disabled;
    if (own !== undefined) return Boolean(own);
    return rootContext.disabled();
  };
  const nativeButton = () => props.nativeButton ?? true;
  const delayProp = () => props.delay ?? OPEN_DELAY;
  const closeDelayProp = () => props.closeDelay ?? 0;
  const delayGroup = useDelayGroup(rootContext.floatingRootContext, {
    get open() {
      return rootContext.open();
    }
  });
  useIsoLayoutEffect(() => delayGroup.isInstantPhase, phase => {
    rootContext.setIsInstantPhase(phase);
    if (phase) {
      rootContext.setInstantType("delay");
    }
  });
  const providerContext = useTooltipProviderContext();
  useIsoLayoutEffect(() => props.closeOnClick ?? false, v => {
    rootContext.setCloseOnClick(v);
  });
  const hoverProps = useHover(rootContext.floatingRootContext, {
    get enabled() {
      return !disabled();
    },
    mouseOnly: true,
    get handleClose() {
      return rootContext.disableHoverablePopup() ? null : safePolygon();
    },
    delay: () => {
      const groupDelay = delayGroup.delayRef.current;
      const providerOpen = providerContext?.delay;
      const providerClose = providerContext?.closeDelay;
      const groupOpenValue = typeof groupDelay === "object" ? groupDelay.open : undefined;
      const groupCloseValue = typeof groupDelay === "object" ? groupDelay.close : undefined;
      let open = delayProp();
      if (delayGroup.hasProvider && groupOpenValue === 0) {
        open = 0;
      } else if (delayGroup.hasProvider) {
        open = props.delay ?? providerOpen ?? delayProp();
      }
      let close = closeDelayProp();
      if (props.closeDelay == null && delayGroup.hasProvider) {
        close = groupCloseValue ?? providerClose ?? closeDelayProp();
      }
      return {
        open,
        close
      };
    }
  });
  const {
    props: buttonProps,
    ref: buttonRef
  } = useButton({
    disabled,
    focusableWhenDisabled: () => true,
    native: nativeButton
  });
  const interactions = rootContext.interactions;
  const referenceProps = interactions.getReferenceProps();
  const isActive = createMemo(() => {
    const id = props.id;
    if (id === undefined) return true;
    return rootContext.activeTriggerId() === id;
  });
  const state = createMemo(() => ({
    open: rootContext.open() && isActive()
  }));

  // Trigger registration in the store's trigger map.
  const store = () => props.handle?.store ?? rootContext.store;
  let registeredId = null;
  let registeredElement = null;
  const triggerRef = el => untrack(() => {
    const id = props.id;
    const s = store();
    if (registeredId !== null && registeredElement !== null) {
      const current = s.context.triggerElements.getById(registeredId);
      if (current === registeredElement) {
        s.context.triggerElements.delete(registeredId);
      }
      registeredId = null;
      registeredElement = null;
    }
    if (el && id !== undefined) {
      s.context.triggerElements.add(id, el);
      registeredId = id;
      registeredElement = el;
    }
    if (id === undefined || isActive()) {
      rootContext.setTriggerElement(el);
    }
  });
  onCleanup(() => {
    if (registeredId !== null && registeredElement !== null) {
      const s = store();
      const current = s.context.triggerElements.getById(registeredId);
      if (current === registeredElement) {
        s.context.triggerElements.delete(registeredId);
      }
    }
  });
  createEffect(
  // `"payload" in props` is a reactive `has` read — snapshot it in
  // compute; the apply scope is strict-read.
  () => ({
    active: isActive(),
    payload: props.payload,
    hasPayload: "payload" in props
  }), ({
    active,
    payload,
    hasPayload
  }) => {
    if (active && hasPayload) {
      rootContext.setPayload(payload);
    }
  });
  const markActive = () => {
    const id = props.id;
    if (id !== undefined) {
      rootContext.setActiveTriggerId(id);
    }
    if ("payload" in props) {
      rootContext.setPayload(props.payload);
    }
  };
  const stateAttrs = {
    get "data-popup-open"() {
      return state().open ? "" : undefined;
    },
    get id() {
      return props.id;
    },
    onPointerEnter: markActive,
    onFocus: markActive,
    onClick: markActive
  };
  const userClassStyle = resolveClassStyle(props, () => state());
  const userProps = omit(props, "as", "class", "style", "attrs", "disabled", "nativeButton", "delay", "closeDelay", "closeOnClick", "handle", "payload");
  let merged = mergeRootProps(hoverProps.reference ?? {}, referenceProps);
  merged = mergeRootProps(merged, buttonProps);
  merged = mergeRootProps(merged, stateAttrs);
  merged = mergeRootProps(merged, userClassStyle);
  merged = mergeRootProps(merged, userProps);
  const Tag = dynamic(() => props.as ?? "button");
  return <Tag {...merged} ref={composeRefs(buttonRef, triggerRef, userRef(props))} />;
}
//# sourceMappingURL=tooltip-trigger.jsx.map