@sprawlify/svelte 0.0.48 → 0.0.50

package/dist/components/toggle-group/toggle-group-anatomy.d.ts

@@ -0,0 +1 @@
+export declare const toggleGroupAnatomy: import("@sprawlify/primitives/anatomy").Anatomy<"root" | "item">;

package/dist/components/toggle-group/toggle-group-anatomy.js

@@ -0,0 +1,2 @@
+import { createAnatomy } from '@sprawlify/primitives/anatomy';
+export const toggleGroupAnatomy = createAnatomy('toggle-group', ['root', 'item']);

package/dist/components/toggle-group/toggle-group-context.svelte

@@ -0,0 +1,18 @@
+<script module lang="ts">
+  import type { Snippet } from 'svelte'
+  import type { UseToggleGroupContext } from './use-toggle-group-context'
+
+  export interface ToggleGroupContextProps {
+    render: Snippet<[UseToggleGroupContext]>
+  }
+</script>
+
+<script lang="ts">
+  import { useToggleGroupContext } from './use-toggle-group-context'
+
+  const { render }: ToggleGroupContextProps = $props()
+
+  const context = useToggleGroupContext()
+</script>
+
+{@render render(context)}

package/dist/components/toggle-group/toggle-group-context.svelte.d.ts

@@ -0,0 +1,8 @@
+import type { Snippet } from 'svelte';
+import type { UseToggleGroupContext } from './use-toggle-group-context';
+export interface ToggleGroupContextProps {
+    render: Snippet<[UseToggleGroupContext]>;
+}
+declare const ToggleGroupContext: import("svelte").Component<ToggleGroupContextProps, {}, "">;
+type ToggleGroupContext = ReturnType<typeof ToggleGroupContext>;
+export default ToggleGroupContext;

package/dist/components/toggle-group/toggle-group-item.svelte

@@ -0,0 +1,23 @@
+<script module lang="ts">
+  import type { Assign, HTMLProps, PolymorphicProps, RefAttribute } from '../../types'
+  import type { ItemProps } from '@sprawlify/primitives/machines/toggle-group'
+
+  export interface ToggleGroupItemBaseProps extends ItemProps, PolymorphicProps<'button'>, RefAttribute {}
+  export interface ToggleGroupItemProps extends Assign<HTMLProps<'button'>, ToggleGroupItemBaseProps> {}
+</script>
+
+<script lang="ts">
+  import { mergeProps } from '../../core'
+  import { createSplitProps } from '../../utils/create-split-props'
+  import { Sprawlify } from '../factory'
+  import { useToggleGroupContext } from './use-toggle-group-context'
+
+  let { ref = $bindable(null), ...props }: ToggleGroupItemProps = $props()
+
+  const [itemProps, localProps] = $derived(createSplitProps<ItemProps>()(props, ['value', 'disabled']))
+
+  const toggleGroup = useToggleGroupContext()
+  const mergedProps = $derived(mergeProps(toggleGroup().getItemProps(itemProps), localProps))
+</script>
+
+<Sprawlify as="button" bind:ref {...mergedProps} />

package/dist/components/toggle-group/toggle-group-item.svelte.d.ts

@@ -0,0 +1,9 @@
+import type { Assign, HTMLProps, PolymorphicProps, RefAttribute } from '../../types';
+import type { ItemProps } from '@sprawlify/primitives/machines/toggle-group';
+export interface ToggleGroupItemBaseProps extends ItemProps, PolymorphicProps<'button'>, RefAttribute {
+}
+export interface ToggleGroupItemProps extends Assign<HTMLProps<'button'>, ToggleGroupItemBaseProps> {
+}
+declare const ToggleGroupItem: import("svelte").Component<ToggleGroupItemProps, {}, "ref">;
+type ToggleGroupItem = ReturnType<typeof ToggleGroupItem>;
+export default ToggleGroupItem;

package/dist/components/toggle-group/toggle-group-root-provider.svelte

@@ -0,0 +1,26 @@
+<script module lang="ts">
+  import type { Assign, HTMLProps, PolymorphicProps, RefAttribute } from '../../types'
+  import type { UseToggleGroupReturn } from './use-toggle-group.svelte'
+
+  interface RootProviderProps {
+    value: UseToggleGroupReturn
+  }
+
+  export interface ToggleGroupRootProviderBaseProps extends RootProviderProps, PolymorphicProps<'div'>, RefAttribute {}
+  export interface ToggleGroupRootProviderProps extends Assign<HTMLProps<'div'>, ToggleGroupRootProviderBaseProps> {}
+</script>
+
+<!-- svelte-ignore state_referenced_locally -->
+<script lang="ts">
+  import { mergeProps } from '../../core'
+  import { Sprawlify } from '../factory'
+  import { ToggleGroupProvider } from './use-toggle-group-context'
+
+  let { ref = $bindable(null), value, ...props }: ToggleGroupRootProviderProps = $props()
+
+  const mergedProps = $derived(mergeProps(value().getRootProps(), props))
+
+  ToggleGroupProvider(value)
+</script>
+
+<Sprawlify as="div" bind:ref {...mergedProps} />

package/dist/components/toggle-group/toggle-group-root-provider.svelte.d.ts

@@ -0,0 +1,12 @@
+import type { Assign, HTMLProps, PolymorphicProps, RefAttribute } from '../../types';
+import type { UseToggleGroupReturn } from './use-toggle-group.svelte';
+interface RootProviderProps {
+    value: UseToggleGroupReturn;
+}
+export interface ToggleGroupRootProviderBaseProps extends RootProviderProps, PolymorphicProps<'div'>, RefAttribute {
+}
+export interface ToggleGroupRootProviderProps extends Assign<HTMLProps<'div'>, ToggleGroupRootProviderBaseProps> {
+}
+declare const ToggleGroupRootProvider: import("svelte").Component<ToggleGroupRootProviderProps, {}, "ref">;
+type ToggleGroupRootProvider = ReturnType<typeof ToggleGroupRootProvider>;
+export default ToggleGroupRootProvider;

package/dist/components/toggle-group/toggle-group-root.svelte

@@ -0,0 +1,52 @@
+<script module lang="ts">
+  import type { Assign, HTMLProps, PolymorphicProps, RefAttribute } from '../../types'
+  import type { UseToggleGroupProps } from './use-toggle-group.svelte'
+
+  export interface ToggleGroupRootBaseProps extends UseToggleGroupProps, PolymorphicProps<'div'>, RefAttribute {}
+  export interface ToggleGroupRootProps extends Assign<HTMLProps<'div'>, ToggleGroupRootBaseProps> {}
+</script>
+
+<script lang="ts">
+  import { createSplitProps } from '../../utils/create-split-props'
+  import { mergeProps } from '../../core'
+  import { Sprawlify } from '../factory'
+  import { ToggleGroupProvider } from './use-toggle-group-context'
+  import { useToggleGroup } from './use-toggle-group.svelte'
+
+  let { ref = $bindable(null), value = $bindable<string[]>(), ...props }: ToggleGroupRootProps = $props()
+
+  const [useToggleGroupProps, localProps] = $derived(
+    createSplitProps<UseToggleGroupProps>()(props, [
+      'defaultValue',
+      'deselectable',
+      'disabled',
+      'id',
+      'ids',
+      'loopFocus',
+      'multiple',
+      'onValueChange',
+      'orientation',
+      'rovingFocus',
+      'value',
+    ]),
+  )
+
+  const id = $props.id()
+
+  const machineProps = $derived.by<UseToggleGroupProps>(() => ({
+    ...useToggleGroupProps,
+    id: useToggleGroupProps.id ?? id,
+    value,
+    onValueChange(details) {
+      useToggleGroupProps.onValueChange?.(details)
+      if (value !== undefined) value = details.value
+    },
+  }))
+
+  const toggleGroup = useToggleGroup(() => machineProps)
+  const mergedProps = $derived(mergeProps(toggleGroup().getRootProps(), localProps))
+
+  ToggleGroupProvider(toggleGroup)
+</script>
+
+<Sprawlify as="div" bind:ref {...mergedProps} />

package/dist/components/toggle-group/toggle-group-root.svelte.d.ts

@@ -0,0 +1,9 @@
+import type { Assign, HTMLProps, PolymorphicProps, RefAttribute } from '../../types';
+import type { UseToggleGroupProps } from './use-toggle-group.svelte';
+export interface ToggleGroupRootBaseProps extends UseToggleGroupProps, PolymorphicProps<'div'>, RefAttribute {
+}
+export interface ToggleGroupRootProps extends Assign<HTMLProps<'div'>, ToggleGroupRootBaseProps> {
+}
+declare const ToggleGroupRoot: import("svelte").Component<ToggleGroupRootProps, {}, "value" | "ref">;
+type ToggleGroupRoot = ReturnType<typeof ToggleGroupRoot>;
+export default ToggleGroupRoot;

package/dist/components/toggle-group/toggle-group.d.ts

@@ -0,0 +1,4 @@
+export { default as Context, type ToggleGroupContextProps as ContextProps } from './toggle-group-context.svelte';
+export { default as Item, type ToggleGroupItemBaseProps as ItemBaseProps, type ToggleGroupItemProps as ItemProps, } from './toggle-group-item.svelte';
+export { default as Root, type ToggleGroupRootBaseProps as RootBaseProps, type ToggleGroupRootProps as RootProps, } from './toggle-group-root.svelte';
+export { default as RootProvider, type ToggleGroupRootProviderBaseProps as RootProviderBaseProps, type ToggleGroupRootProviderProps as RootProviderProps, } from './toggle-group-root-provider.svelte';

package/dist/components/toggle-group/toggle-group.js

@@ -0,0 +1,4 @@
+export { default as Context } from './toggle-group-context.svelte';
+export { default as Item, } from './toggle-group-item.svelte';
+export { default as Root, } from './toggle-group-root.svelte';
+export { default as RootProvider, } from './toggle-group-root-provider.svelte';

package/dist/components/toggle-group/use-toggle-group-context.d.ts

@@ -0,0 +1,4 @@
+import type { UseToggleGroupReturn } from './use-toggle-group.svelte';
+export interface UseToggleGroupContext extends UseToggleGroupReturn {
+}
+export declare const ToggleGroupProvider: (opts: UseToggleGroupContext) => void, useToggleGroupContext: (fallback?: UseToggleGroupContext | undefined) => UseToggleGroupContext;

package/dist/components/toggle-group/use-toggle-group-context.js

@@ -0,0 +1,6 @@
+import { createContext } from '../../utils/create-context';
+export const [ToggleGroupProvider, useToggleGroupContext] = createContext({
+    name: 'ToggleGroupContext',
+    hookName: 'useToggleGroupContext',
+    providerName: '<ToggleGroupProvider />',
+});

package/dist/components/toggle-group/use-toggle-group.svelte.d.ts

@@ -0,0 +1,9 @@
+import type { Accessor, Optional } from '../../types';
+import { type PropTypes } from '../../core';
+import * as toggleGroup from '@sprawlify/primitives/machines/toggle-group';
+import { type MaybeFunction } from '@sprawlify/primitives/utils';
+export interface UseToggleGroupProps extends Optional<Omit<toggleGroup.Props, 'dir' | 'getRootNode'>, 'id'> {
+}
+export interface UseToggleGroupReturn extends Accessor<toggleGroup.Api<PropTypes>> {
+}
+export declare const useToggleGroup: (props?: MaybeFunction<UseToggleGroupProps>) => UseToggleGroupReturn;

package/dist/components/toggle-group/use-toggle-group.svelte.js

@@ -0,0 +1,20 @@
+import { useEnvironmentContext } from '../../providers/environment';
+import { useLocaleContext } from '../../providers/locale';
+import { normalizeProps, useMachine } from '../../core';
+import * as toggleGroup from '@sprawlify/primitives/machines/toggle-group';
+import { runIfFn } from '@sprawlify/primitives/utils';
+export const useToggleGroup = (props = {}) => {
+    const env = useEnvironmentContext();
+    const locale = useLocaleContext();
+    const machineProps = $derived.by(() => {
+        const resolvedProps = runIfFn(props);
+        return {
+            dir: locale().dir,
+            getRootNode: env().getRootNode,
+            ...resolvedProps,
+        };
+    });
+    const service = useMachine(toggleGroup.machine, () => machineProps);
+    const api = $derived(toggleGroup.connect(service, normalizeProps));
+    return () => api;
+};

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

@@ -0,0 +1,13 @@
+export type { OpenChangeDetails as TooltipOpenChangeDetails } from '@sprawlify/primitives/machines/tooltip';
+export { default as TooltipArrow, type TooltipArrowBaseProps, type TooltipArrowProps } from './tooltip-arrow.svelte';
+export { default as TooltipArrowTip, type TooltipArrowTipBaseProps, type TooltipArrowTipProps, } from './tooltip-arrow-tip.svelte';
+export { default as TooltipContent, type TooltipContentBaseProps, type TooltipContentProps, } from './tooltip-content.svelte';
+export { default as TooltipContext, type TooltipContextProps } from './tooltip-context.svelte';
+export { default as TooltipPositioner, type TooltipPositionerBaseProps, type TooltipPositionerProps, } from './tooltip-positioner.svelte';
+export { default as TooltipRoot, type TooltipRootBaseProps, type TooltipRootProps } from './tooltip-root.svelte';
+export { default as TooltipRootProvider, type TooltipRootProviderBaseProps, type TooltipRootProviderProps, } from './tooltip-root-provider.svelte';
+export { default as TooltipTrigger, type TooltipTriggerBaseProps, type TooltipTriggerProps, } from './tooltip-trigger.svelte';
+export { tooltipAnatomy } from './tooltip-anatomy';
+export { useTooltipContext, type UseTooltipContext } from './use-tooltip-context';
+export { useTooltip, type UseTooltipProps, type UseTooltipReturn } from './use-tooltip.svelte';
+export * as Tooltip from './tooltip';

package/dist/components/tooltip/index.js

@@ -0,0 +1,12 @@
+export { default as TooltipArrow } from './tooltip-arrow.svelte';
+export { default as TooltipArrowTip, } from './tooltip-arrow-tip.svelte';
+export { default as TooltipContent, } from './tooltip-content.svelte';
+export { default as TooltipContext } from './tooltip-context.svelte';
+export { default as TooltipPositioner, } from './tooltip-positioner.svelte';
+export { default as TooltipRoot } from './tooltip-root.svelte';
+export { default as TooltipRootProvider, } from './tooltip-root-provider.svelte';
+export { default as TooltipTrigger, } from './tooltip-trigger.svelte';
+export { tooltipAnatomy } from './tooltip-anatomy';
+export { useTooltipContext } from './use-tooltip-context';
+export { useTooltip } from './use-tooltip.svelte';
+export * as Tooltip from './tooltip';

package/dist/components/tooltip/tooltip-anatomy.d.ts

@@ -0,0 +1 @@
+export { anatomy as tooltipAnatomy } from '@sprawlify/primitives/machines/tooltip';

package/dist/components/tooltip/tooltip-anatomy.js

@@ -0,0 +1 @@
+export { anatomy as tooltipAnatomy } from '@sprawlify/primitives/machines/tooltip';

package/dist/components/tooltip/tooltip-arrow-tip.svelte

@@ -0,0 +1,18 @@
+<script module lang="ts">
+  import type { Assign, HTMLProps, PolymorphicProps, RefAttribute } from '../../types'
+
+  export interface TooltipArrowTipBaseProps extends PolymorphicProps<'div'>, RefAttribute {}
+  export interface TooltipArrowTipProps extends Assign<HTMLProps<'div'>, TooltipArrowTipBaseProps> {}
+</script>
+
+<script lang="ts">
+  import { mergeProps } from '../../core'
+  import { Sprawlify } from '../factory'
+  import { useTooltipContext } from './use-tooltip-context'
+
+  let { ref = $bindable(null), ...props }: TooltipArrowTipProps = $props()
+  const tooltip = useTooltipContext()
+  const mergedProps = $derived(mergeProps(tooltip().getArrowTipProps(), props))
+</script>
+
+<Sprawlify as="div" bind:ref {...mergedProps} />

package/dist/components/tooltip/tooltip-arrow-tip.svelte.d.ts

@@ -0,0 +1,8 @@
+import type { Assign, HTMLProps, PolymorphicProps, RefAttribute } from '../../types';
+export interface TooltipArrowTipBaseProps extends PolymorphicProps<'div'>, RefAttribute {
+}
+export interface TooltipArrowTipProps extends Assign<HTMLProps<'div'>, TooltipArrowTipBaseProps> {
+}
+declare const TooltipArrowTip: import("svelte").Component<TooltipArrowTipProps, {}, "ref">;
+type TooltipArrowTip = ReturnType<typeof TooltipArrowTip>;
+export default TooltipArrowTip;

package/dist/components/tooltip/tooltip-arrow.svelte

@@ -0,0 +1,18 @@
+<script module lang="ts">
+  import type { Assign, HTMLProps, PolymorphicProps, RefAttribute } from '../../types'
+
+  export interface TooltipArrowBaseProps extends PolymorphicProps<'div'>, RefAttribute {}
+  export interface TooltipArrowProps extends Assign<HTMLProps<'div'>, TooltipArrowBaseProps> {}
+</script>
+
+<script lang="ts">
+  import { mergeProps } from '../../core'
+  import { Sprawlify } from '../factory'
+  import { useTooltipContext } from './use-tooltip-context'
+
+  let { ref = $bindable(null), ...props }: TooltipArrowProps = $props()
+  const tooltip = useTooltipContext()
+  const mergedProps = $derived(mergeProps(tooltip().getArrowProps(), props))
+</script>
+
+<Sprawlify as="div" bind:ref {...mergedProps} />

package/dist/components/tooltip/tooltip-arrow.svelte.d.ts

@@ -0,0 +1,8 @@
+import type { Assign, HTMLProps, PolymorphicProps, RefAttribute } from '../../types';
+export interface TooltipArrowBaseProps extends PolymorphicProps<'div'>, RefAttribute {
+}
+export interface TooltipArrowProps extends Assign<HTMLProps<'div'>, TooltipArrowBaseProps> {
+}
+declare const TooltipArrow: import("svelte").Component<TooltipArrowProps, {}, "ref">;
+type TooltipArrow = ReturnType<typeof TooltipArrow>;
+export default TooltipArrow;

package/dist/components/tooltip/tooltip-content.svelte

@@ -0,0 +1,27 @@
+<script module lang="ts">
+  import type { Assign, HTMLProps, PolymorphicProps, RefAttribute } from '../../types'
+
+  export interface TooltipContentBaseProps extends PolymorphicProps<'div'>, RefAttribute {}
+  export interface TooltipContentProps extends Assign<HTMLProps<'div'>, TooltipContentBaseProps> {}
+</script>
+
+<script lang="ts">
+  import { mergeProps } from '../../core'
+  import { Sprawlify } from '../factory'
+  import { usePresenceContext } from '../presence'
+  import { useTooltipContext } from './use-tooltip-context'
+
+  let { ref = $bindable(null), ...props }: TooltipContentProps = $props()
+
+  const tooltip = useTooltipContext()
+  const presence = usePresenceContext()
+  const mergedProps = $derived(mergeProps(tooltip().getContentProps(), presence().getPresenceProps(), props))
+
+  function setNode(node: Element | null) {
+    presence().setNode(node)
+  }
+</script>
+
+{#if !presence().unmounted}
+  <Sprawlify as="div" bind:ref {...mergedProps} {@attach setNode} />
+{/if}

package/dist/components/tooltip/tooltip-content.svelte.d.ts

@@ -0,0 +1,8 @@
+import type { Assign, HTMLProps, PolymorphicProps, RefAttribute } from '../../types';
+export interface TooltipContentBaseProps extends PolymorphicProps<'div'>, RefAttribute {
+}
+export interface TooltipContentProps extends Assign<HTMLProps<'div'>, TooltipContentBaseProps> {
+}
+declare const TooltipContent: import("svelte").Component<TooltipContentProps, {}, "ref">;
+type TooltipContent = ReturnType<typeof TooltipContent>;
+export default TooltipContent;

package/dist/components/tooltip/tooltip-context.svelte

@@ -0,0 +1,18 @@
+<script module lang="ts">
+  import type { Snippet } from 'svelte'
+  import type { UseTooltipContext } from './use-tooltip-context'
+
+  export interface TooltipContextProps {
+    render?: Snippet<[UseTooltipContext]>
+  }
+</script>
+
+<script lang="ts">
+  import { useTooltipContext } from './use-tooltip-context'
+
+  const { render }: TooltipContextProps = $props()
+
+  const context = useTooltipContext()
+</script>
+
+{@render render?.(context)}

package/dist/components/tooltip/tooltip-context.svelte.d.ts

@@ -0,0 +1,8 @@
+import type { Snippet } from 'svelte';
+import type { UseTooltipContext } from './use-tooltip-context';
+export interface TooltipContextProps {
+    render?: Snippet<[UseTooltipContext]>;
+}
+declare const TooltipContext: import("svelte").Component<TooltipContextProps, {}, "">;
+type TooltipContext = ReturnType<typeof TooltipContext>;
+export default TooltipContext;

package/dist/components/tooltip/tooltip-positioner.svelte

@@ -0,0 +1,22 @@
+<script module lang="ts">
+  import type { Assign, HTMLProps, PolymorphicProps, RefAttribute } from '../../types'
+
+  export interface TooltipPositionerBaseProps extends PolymorphicProps<'div'>, RefAttribute {}
+  export interface TooltipPositionerProps extends Assign<HTMLProps<'div'>, TooltipPositionerBaseProps> {}
+</script>
+
+<script lang="ts">
+  import { mergeProps } from '../../core'
+  import { Sprawlify } from '../factory'
+  import { usePresenceContext } from '../presence'
+  import { useTooltipContext } from './use-tooltip-context'
+
+  let { ref = $bindable(null), ...props }: TooltipPositionerProps = $props()
+  const tooltip = useTooltipContext()
+  const presence = usePresenceContext()
+  const mergedProps = $derived(mergeProps(tooltip().getPositionerProps(), props))
+</script>
+
+{#if !presence().unmounted}
+  <Sprawlify as="div" bind:ref {...mergedProps} />
+{/if}

package/dist/components/tooltip/tooltip-positioner.svelte.d.ts

@@ -0,0 +1,8 @@
+import type { Assign, HTMLProps, PolymorphicProps, RefAttribute } from '../../types';
+export interface TooltipPositionerBaseProps extends PolymorphicProps<'div'>, RefAttribute {
+}
+export interface TooltipPositionerProps extends Assign<HTMLProps<'div'>, TooltipPositionerBaseProps> {
+}
+declare const TooltipPositioner: import("svelte").Component<TooltipPositionerProps, {}, "ref">;
+type TooltipPositioner = ReturnType<typeof TooltipPositioner>;
+export default TooltipPositioner;

package/dist/components/tooltip/tooltip-root-provider.svelte

@@ -0,0 +1,36 @@
+<script module lang="ts">
+  import type { Snippet } from 'svelte'
+  import type { UsePresenceProps } from '../presence'
+  import type { UseTooltipReturn } from './use-tooltip.svelte'
+
+  interface RootProviderProps {
+    value: UseTooltipReturn
+  }
+
+  export interface TooltipRootProviderBaseProps extends RootProviderProps, UsePresenceProps {}
+  export interface TooltipRootProviderProps extends TooltipRootProviderBaseProps {
+    children?: Snippet
+  }
+</script>
+
+<script lang="ts">
+  import { PresenceProvider, usePresence } from '../presence'
+  import { splitPresenceProps } from '../presence/split-presence-props.svelte'
+  import { TooltipProvider } from './use-tooltip-context'
+
+  const props: TooltipRootProviderProps = $props()
+
+  const [presenceProps, rootProviderProps] = $derived(splitPresenceProps(props))
+
+  const machineProps = $derived.by<UsePresenceProps>(() => ({
+    ...presenceProps,
+    present: rootProviderProps.value().open,
+  }))
+
+  const presence = usePresence(() => machineProps)
+
+  TooltipProvider(() => rootProviderProps.value())
+  PresenceProvider(presence)
+</script>
+
+{@render props.children?.()}

package/dist/components/tooltip/tooltip-root-provider.svelte.d.ts

@@ -0,0 +1,14 @@
+import type { Snippet } from 'svelte';
+import type { UsePresenceProps } from '../presence';
+import type { UseTooltipReturn } from './use-tooltip.svelte';
+interface RootProviderProps {
+    value: UseTooltipReturn;
+}
+export interface TooltipRootProviderBaseProps extends RootProviderProps, UsePresenceProps {
+}
+export interface TooltipRootProviderProps extends TooltipRootProviderBaseProps {
+    children?: Snippet;
+}
+declare const TooltipRootProvider: import("svelte").Component<TooltipRootProviderProps, {}, "">;
+type TooltipRootProvider = ReturnType<typeof TooltipRootProvider>;
+export default TooltipRootProvider;

package/dist/components/tooltip/tooltip-root.svelte

@@ -0,0 +1,45 @@
+<script module lang="ts">
+  import type { Snippet } from 'svelte'
+  import type { UsePresenceProps } from '../presence'
+  import type { UseTooltipProps } from './use-tooltip.svelte'
+
+  export interface TooltipRootBaseProps extends UseTooltipProps, UsePresenceProps {}
+  export interface TooltipRootProps extends TooltipRootBaseProps {
+    children?: Snippet
+  }
+</script>
+
+<script lang="ts">
+  import { PresenceProvider, usePresence } from '../presence'
+  import { splitPresenceProps } from '../presence/split-presence-props.svelte'
+  import { TooltipProvider } from './use-tooltip-context'
+  import { useTooltip } from './use-tooltip.svelte'
+
+  let { open = $bindable(), ...props }: TooltipRootProps = $props()
+  const providedId = $props.id()
+
+  const [presenceProps, localProps] = $derived(splitPresenceProps(props))
+  const { children, ...useTooltipProps } = $derived(localProps)
+
+  const resolvedProps = $derived<UseTooltipProps>({
+    ...useTooltipProps,
+    id: providedId,
+    onOpenChange(details) {
+      useTooltipProps.onOpenChange?.(details)
+      if (open !== undefined) open = details.open
+    },
+  })
+
+  const tooltip = useTooltip(() => resolvedProps)
+  const machineProps = $derived<UsePresenceProps>({
+    ...presenceProps,
+    present: tooltip().open,
+  })
+
+  const presence = usePresence(() => machineProps)
+
+  TooltipProvider(tooltip)
+  PresenceProvider(presence)
+</script>
+
+{@render children?.()}

package/dist/components/tooltip/tooltip-root.svelte.d.ts

@@ -0,0 +1,11 @@
+import type { Snippet } from 'svelte';
+import type { UsePresenceProps } from '../presence';
+import type { UseTooltipProps } from './use-tooltip.svelte';
+export interface TooltipRootBaseProps extends UseTooltipProps, UsePresenceProps {
+}
+export interface TooltipRootProps extends TooltipRootBaseProps {
+    children?: Snippet;
+}
+declare const TooltipRoot: import("svelte").Component<TooltipRootProps, {}, "open">;
+type TooltipRoot = ReturnType<typeof TooltipRoot>;
+export default TooltipRoot;

package/dist/components/tooltip/tooltip-trigger.svelte

@@ -0,0 +1,18 @@
+<script module lang="ts">
+  import type { Assign, HTMLProps, PolymorphicProps, RefAttribute } from '../../types'
+
+  export interface TooltipTriggerBaseProps extends PolymorphicProps<'button'>, RefAttribute {}
+  export interface TooltipTriggerProps extends Assign<HTMLProps<'button'>, TooltipTriggerBaseProps> {}
+</script>
+
+<script lang="ts">
+  import { mergeProps } from '../../core'
+  import { Sprawlify } from '../factory'
+  import { useTooltipContext } from './use-tooltip-context'
+
+  let { ref = $bindable(null), ...props }: TooltipTriggerProps = $props()
+  const tooltip = useTooltipContext()
+  const mergedProps = $derived(mergeProps(tooltip().getTriggerProps(), props))
+</script>
+
+<Sprawlify as="button" bind:ref {...mergedProps} />

package/dist/components/tooltip/tooltip-trigger.svelte.d.ts

@@ -0,0 +1,8 @@
+import type { Assign, HTMLProps, PolymorphicProps, RefAttribute } from '../../types';
+export interface TooltipTriggerBaseProps extends PolymorphicProps<'button'>, RefAttribute {
+}
+export interface TooltipTriggerProps extends Assign<HTMLProps<'button'>, TooltipTriggerBaseProps> {
+}
+declare const TooltipTrigger: import("svelte").Component<TooltipTriggerProps, {}, "ref">;
+type TooltipTrigger = ReturnType<typeof TooltipTrigger>;
+export default TooltipTrigger;

package/dist/components/tooltip/tooltip.d.ts

@@ -0,0 +1,9 @@
+export type { OpenChangeDetails } from '@sprawlify/primitives/machines/tooltip';
+export { default as Arrow, type TooltipArrowBaseProps as ArrowBaseProps, type TooltipArrowProps as ArrowProps, } from './tooltip-arrow.svelte';
+export { default as ArrowTip, type TooltipArrowTipBaseProps as ArrowTipBaseProps, type TooltipArrowTipProps as ArrowTipProps, } from './tooltip-arrow-tip.svelte';
+export { default as Content, type TooltipContentBaseProps as ContentBaseProps, type TooltipContentProps as ContentProps, } from './tooltip-content.svelte';
+export { default as Context, type TooltipContextProps as ContextProps } from './tooltip-context.svelte';
+export { default as Positioner, type TooltipPositionerBaseProps as PositionerBaseProps, type TooltipPositionerProps as PositionerProps, } from './tooltip-positioner.svelte';
+export { default as Root, type TooltipRootBaseProps as RootBaseProps, type TooltipRootProps as RootProps, } from './tooltip-root.svelte';
+export { default as RootProvider, type TooltipRootProviderBaseProps as RootProviderBaseProps, type TooltipRootProviderProps as RootProviderProps, } from './tooltip-root-provider.svelte';
+export { default as Trigger, type TooltipTriggerBaseProps as TriggerBaseProps, type TooltipTriggerProps as TriggerProps, } from './tooltip-trigger.svelte';

package/dist/components/tooltip/tooltip.js

@@ -0,0 +1,8 @@
+export { default as Arrow, } from './tooltip-arrow.svelte';
+export { default as ArrowTip, } from './tooltip-arrow-tip.svelte';
+export { default as Content, } from './tooltip-content.svelte';
+export { default as Context } from './tooltip-context.svelte';
+export { default as Positioner, } from './tooltip-positioner.svelte';
+export { default as Root, } from './tooltip-root.svelte';
+export { default as RootProvider, } from './tooltip-root-provider.svelte';
+export { default as Trigger, } from './tooltip-trigger.svelte';

package/dist/components/tooltip/use-tooltip-context.d.ts

@@ -0,0 +1,4 @@
+import type { UseTooltipReturn } from './use-tooltip.svelte';
+export interface UseTooltipContext extends UseTooltipReturn {
+}
+export declare const TooltipProvider: (opts: UseTooltipContext) => void, useTooltipContext: (fallback?: UseTooltipContext | undefined) => UseTooltipContext;

package/dist/components/tooltip/use-tooltip-context.js

@@ -0,0 +1,4 @@
+import { createContext } from '../../utils/create-context';
+export const [TooltipProvider, useTooltipContext] = createContext({
+    name: 'TooltipContext',
+});

package/dist/components/tooltip/use-tooltip.svelte.d.ts

@@ -0,0 +1,9 @@
+import type { Accessor } from '../../types';
+import { type PropTypes } from '../../core';
+import * as tooltip from '@sprawlify/primitives/machines/tooltip';
+import { type MaybeFunction } from '@sprawlify/primitives/utils';
+export interface UseTooltipProps extends Omit<tooltip.Props, 'dir' | 'getRootNode'> {
+}
+export interface UseTooltipReturn extends Accessor<tooltip.Api<PropTypes>> {
+}
+export declare const useTooltip: (props?: MaybeFunction<UseTooltipProps>) => UseTooltipReturn;