@ark-ui/solid/dist/chunk/NJVZNV63.js

A collection of unstyled, accessible UI components for Solid, utilizing state machines for seamless interaction.

import { usePresence } from './X22PRPOR.js';
import { composeRefs } from './ROP6QZQ7.js';
import { swapAnatomy, parts } from './ORFQCCEF.js';
import { runIfFn } from './DT73WLR4.js';
import { ark } from './EPLBB4QN.js';
import { createContext } from './THN5C4U6.js';
import { __export } from './ESLJRKWD.js';
import { createComponent, mergeProps as mergeProps$1 } from 'solid-js/web';
import { mergeProps } from '@zag-js/solid';
import { splitProps, Show, createMemo } from 'solid-js';

// src/components/swap/swap.ts
var swap_exports = {};
__export(swap_exports, {
  Indicator: () => SwapIndicator,
  Root: () => SwapRoot,
  RootProvider: () => SwapRootProvider,
  swapAnatomy: () => swapAnatomy
});

// src/components/swap/use-swap-context.ts
var [SwapProvider, useSwapContext] = createContext({
  hookName: "useSwapContext",
  providerName: "<SwapProvider />"
});

// src/components/swap/swap-indicator.tsx
var SwapIndicator = (props) => {
  const [localProps, restProps] = splitProps(props, ["type", "ref"]);
  const swap = useSwapContext();
  const presence = () => {
    const p = localProps.type === "on" ? swap().onPresence : swap().offPresence;
    return p();
  };
  const mergedProps = mergeProps(() => swap().getIndicatorProps({
    type: localProps.type
  }), restProps);
  return createComponent(Show, {
    get when() {
      return !presence().unmounted;
    },
    get children() {
      return createComponent(ark.span, mergeProps$1(mergedProps, {
        ref(r$) {
          var _ref$ = composeRefs(presence().ref, localProps.ref);
          typeof _ref$ === "function" && _ref$(r$);
        }
      }));
    }
  });
};
var useSwap = (props = {}) => {
  const resolved = createMemo(() => runIfFn(props));
  const onPresence = usePresence(
    mergeProps(() => ({
      present: resolved().swap ?? false,
      lazyMount: resolved().lazyMount,
      unmountOnExit: resolved().unmountOnExit,
      skipAnimationOnMount: true
    }))
  );
  const offPresence = usePresence(
    mergeProps(() => ({
      present: !(resolved().swap ?? false),
      lazyMount: resolved().lazyMount,
      unmountOnExit: resolved().unmountOnExit,
      skipAnimationOnMount: true
    }))
  );
  return createMemo(() => {
    const swap = resolved().swap ?? false;
    return {
      swap,
      onPresence,
      offPresence,
      getRootProps() {
        return {
          ...parts.root.attrs,
          "data-swap": swap ? "on" : "off",
          style: { display: "inline-grid" }
        };
      },
      getIndicatorProps({ type }) {
        const presence = type === "on" ? onPresence() : offPresence();
        return {
          ...parts.indicator.attrs,
          ...presence.presenceProps,
          "data-type": type,
          style: { "grid-area": "1 / 1", display: "inline-flex" }
        };
      }
    };
  });
};

// src/components/swap/swap-root.tsx
var SwapRoot = (props) => {
  const [swapProps, localProps] = splitProps(props, ["swap", "lazyMount", "unmountOnExit"]);
  const swap = useSwap(() => swapProps);
  const mergedProps = mergeProps(() => swap().getRootProps(), localProps);
  return createComponent(SwapProvider, {
    value: swap,
    get children() {
      return createComponent(ark.span, mergedProps);
    }
  });
};
var SwapRootProvider = (props) => {
  const [providerProps, localProps] = splitProps(props, ["value"]);
  const mergedProps = mergeProps(() => providerProps.value().getRootProps(), localProps);
  return createComponent(SwapProvider, {
    get value() {
      return providerProps.value;
    },
    get children() {
      return createComponent(ark.span, mergedProps);
    }
  });
};

export { SwapIndicator, SwapRoot, SwapRootProvider, swap_exports, useSwap, useSwapContext };