@pzerelles/headlessui-svelte 2.1.2-next.22 → 2.1.2-next.24

package/dist/data-interactive/DataInteractive.svelte

@@ -1,34 +1,60 @@
-<script lang="ts" module>import { useFocusRing } from "../hooks/use-focus-ring.svelte.js";
-import { useActivePress } from "../hooks/use-active-press.svelte.js";
-import { useHover } from "../hooks/use-hover.svelte.js";
-import { mergeProps } from "../utils/render.js";
-import ElementOrComponent from "../utils/ElementOrComponent.svelte";
-const DEFAULT_DATA_INTERACTIVE_TAG = "svelte:fragment";
+<script lang="ts" module>
+  import type { Props, ElementType } from "../utils/types.js"
+  import { useFocusRing } from "../hooks/use-focus-ring.svelte.js"
+  import { useActivePress } from "../hooks/use-active-press.svelte.js"
+  import type { Snippet } from "svelte"
+  import { useHover } from "../hooks/use-hover.svelte.js"
+  import { mergeProps } from "../utils/render.js"
+  import ElementOrComponent from "../utils/ElementOrComponent.svelte"
+
+  const DEFAULT_DATA_INTERACTIVE_TAG = "svelte:fragment" as const
+
+  type DataInteractiveRenderPropArg = {
+    hover: boolean
+    focus: boolean
+    active: boolean
+  }
+  type DataInteractivePropsWeControl = never
+
+  export type DataInteractiveProps<TTag extends ElementType = typeof DEFAULT_DATA_INTERACTIVE_TAG> = Props<
+    TTag,
+    DataInteractiveRenderPropArg,
+    DataInteractivePropsWeControl,
+    {}
+  >
 </script>
 
-<script lang="ts" generics="TTag extends ElementType = typeof DEFAULT_DATA_INTERACTIVE_TAG">let { ref = $bindable(), ...theirProps } = $props();
-const disabled = false;
-const { isHovered: hover, hoverProps } = $derived(
-  useHover({
-    get disabled() {
-      return disabled;
-    }
-  })
-);
-const { pressed: active, pressProps } = $derived(
-  useActivePress({
-    get disabled() {
-      return disabled;
-    }
-  })
-);
-const { isFocusVisible: focus, focusProps } = $derived(useFocusRing());
-const slot = $derived({
-  hover,
-  focus,
-  active
-});
-const ourProps = $derived(mergeProps(focusProps, hoverProps, pressProps));
+<script lang="ts" generics="TTag extends ElementType = typeof DEFAULT_DATA_INTERACTIVE_TAG">
+  let { ref = $bindable(), ...theirProps }: { as?: TTag } & DataInteractiveProps<TTag> = $props()
+
+  // Ideally we can use a `disabled` prop, but that would depend on the props of the child element
+  // and we don't have access to that in this component.
+
+  const disabled = false
+
+  const { isHovered: hover, hoverProps } = $derived(
+    useHover({
+      get disabled() {
+        return disabled
+      },
+    })
+  )
+  const { pressed: active, pressProps } = $derived(
+    useActivePress({
+      get disabled() {
+        return disabled
+      },
+    })
+  )
+  const { isFocusVisible: focus, focusProps } = $derived(useFocusRing())
+
+  const slot = $derived({
+    hover,
+    focus,
+    active,
+  } satisfies DataInteractiveRenderPropArg)
+
+  const ourProps = $derived(mergeProps(focusProps, hoverProps, pressProps))
 </script>
 
 <ElementOrComponent

package/dist/data-interactive/DataInteractive.svelte.d.ts

@@ -8,15 +8,17 @@ type DataInteractiveRenderPropArg = {
 };
 type DataInteractivePropsWeControl = never;
 export type DataInteractiveProps<TTag extends ElementType = typeof DEFAULT_DATA_INTERACTIVE_TAG> = Props<TTag, DataInteractiveRenderPropArg, DataInteractivePropsWeControl, {}>;
-export type DataInteractiveChildren = Snippet<[DataInteractiveRenderPropArg]>;
 declare class __sveltets_Render<TTag extends ElementType = typeof DEFAULT_DATA_INTERACTIVE_TAG> {
     props(): {
         as?: TTag | undefined;
-    } & (Exclude<keyof import("../utils/types.js").PropsOf<TTag>, "as" | "children" | "refName" | "class"> extends infer T extends keyof import("../utils/types.js").PropsOf<TTag> ? { [P in T]: import("../utils/types.js").PropsOf<TTag>[P]; } : never) & {
-        children?: Snippet<[DataInteractiveRenderPropArg, Record<string, any>]> | undefined;
+    } & (Exclude<keyof import("../utils/types.js").PropsOf<TTag>, "as" | "children" | "class"> extends infer T extends keyof import("../utils/types.js").PropsOf<TTag> ? { [P in T]: import("../utils/types.js").PropsOf<TTag>[P]; } : never) & {
+        children?: Snippet<[{
+            slot: DataInteractiveRenderPropArg;
+            props: Record<string, any>;
+        }]> | undefined;
         ref?: HTMLElement;
-    } & (true extends (import("../utils/types.js").PropsOf<TTag> extends infer T_1 ? T_1 extends import("../utils/types.js").PropsOf<TTag> ? T_1 extends never ? never : "class" extends infer T_2 ? T_2 extends "class" ? T_2 extends keyof T_1 ? true : never : never : never : never : never) ? {
-        class?: import("../utils/types.js").PropsOf<TTag>["class"] | ((bag: DataInteractiveRenderPropArg) => string) | undefined;
+    } & (true extends (import("svelte/elements").SvelteHTMLElements[TTag] extends infer T_1 ? T_1 extends import("svelte/elements").SvelteHTMLElements[TTag] ? T_1 extends never ? never : "class" extends infer T_2 ? T_2 extends "class" ? T_2 extends keyof T_1 ? true : never : never : never : never : never) ? {
+        class?: string | ((bag: DataInteractiveRenderPropArg) => string) | null | undefined;
     } : {});
     events(): {} & {
         [evt: string]: CustomEvent<any>;

package/dist/description/Description.svelte

@@ -1,28 +1,43 @@
-<script lang="ts" module>let DEFAULT_DESCRIPTION_TAG = "p";
+<script lang="ts" module>
+  import type { ElementType, Props, PropsOf } from "../utils/types.js"
+
+  let DEFAULT_DESCRIPTION_TAG = "p" as const
+
+  export type DescriptionProps<TTag extends ElementType = typeof DEFAULT_DESCRIPTION_TAG> = Props<TTag>
 </script>
 
-<script lang="ts" generics="TTag extends ElementType = typeof DEFAULT_DESCRIPTION_TAG">import { htmlid } from "../utils/id.js";
-import { stateFromSlot } from "../utils/state.js";
-import { useDisabled } from "../hooks/use-disabled.js";
-import { onMount } from "svelte";
-import { useDescriptionContext } from "./context.svelte.js";
-const internalId = htmlid();
-const providedDisabled = useDisabled();
-let {
-  as,
-  id = `headlessui-description-${internalId}`,
-  children,
-  ...theirProps
-} = $props();
-const context = useDescriptionContext();
-onMount(() => {
-  context.register(id);
-});
-const disabled = $derived(providedDisabled.value || false);
-const slot = $derived({ disabled });
-const ourProps = $derived({ id, ...stateFromSlot(slot) });
+<script lang="ts" generics="TTag extends ElementType = typeof DEFAULT_DESCRIPTION_TAG">
+  import { useId } from "../hooks/use-id.js"
+  import { useDisabled } from "../hooks/use-disabled.js"
+  import { useDescriptionContext } from "./context.svelte.js"
+  import ElementOrComponent from "../utils/ElementOrComponent.svelte"
+  import { untrack } from "svelte"
+
+  const internalId = useId()
+  const providedDisabled = useDisabled()
+
+  let {
+    ref = $bindable(),
+    id = `headlessui-description-${internalId}` as PropsOf<TTag>["id"],
+    ...theirProps
+  }: { as?: TTag } & DescriptionProps<TTag> = $props()
+
+  const { register } = useDescriptionContext()
+  $effect(() => {
+    id
+    return untrack(() => register(id))
+  })
+
+  const disabled = $derived(providedDisabled.current || false)
+  const slot = $derived({ disabled })
+  const ourProps = $derived({ id })
 </script>
 
-<svelte:element this={as ?? DEFAULT_DESCRIPTION_TAG} {...ourProps} {...theirProps}>
-  {#if children}{@render children(slot, {})}{/if}
-</svelte:element>
+<ElementOrComponent
+  {ourProps}
+  {theirProps}
+  slots={slot}
+  defaultTag={DEFAULT_DESCRIPTION_TAG}
+  name="Description"
+  bind:ref
+/>

package/dist/description/Description.svelte.d.ts

@@ -4,17 +4,20 @@ export type DescriptionProps<TTag extends ElementType = typeof DEFAULT_DESCRIPTI
 declare class __sveltets_Render<TTag extends ElementType = typeof DEFAULT_DESCRIPTION_TAG> {
     props(): {
         as?: TTag | undefined;
-    } & (Exclude<keyof PropsOf<TTag>, "as" | "children" | "refName" | "class"> extends infer T extends keyof PropsOf<TTag> ? { [P in T]: PropsOf<TTag>[P]; } : never) & {
-        children?: import("svelte").Snippet<[{}, Record<string, any>]> | undefined;
+    } & (Exclude<keyof PropsOf<TTag>, "as" | "children" | "class"> extends infer T extends keyof PropsOf<TTag> ? { [P in T]: PropsOf<TTag>[P]; } : never) & {
+        children?: import("svelte").Snippet<[{
+            slot: {};
+            props: Record<string, any>;
+        }]> | undefined;
         ref?: HTMLElement;
-    } & (true extends (PropsOf<TTag> extends infer T_1 ? T_1 extends PropsOf<TTag> ? T_1 extends never ? never : "class" extends infer T_2 ? T_2 extends "class" ? T_2 extends keyof T_1 ? true : never : never : never : never : never) ? {
-        class?: PropsOf<TTag>["class"] | ((bag: {}) => string) | undefined;
+    } & (true extends (import("svelte/elements.js").SvelteHTMLElements[TTag] extends infer T_1 ? T_1 extends import("svelte/elements.js").SvelteHTMLElements[TTag] ? T_1 extends never ? never : "class" extends infer T_2 ? T_2 extends "class" ? T_2 extends keyof T_1 ? true : never : never : never : never : never) ? {
+        class?: string | ((bag: {}) => string) | null | undefined;
     } : {});
     events(): {} & {
         [evt: string]: CustomEvent<any>;
     };
     slots(): {};
-    bindings(): "";
+    bindings(): "ref";
     exports(): {};
 }
 interface $$IsomorphicComponent {

package/dist/description/context.svelte.js

@@ -1,8 +1,8 @@
 import { getContext, setContext } from "svelte";
 export function useDescriptionContext() {
-    let context = getContext("DescriptionContext");
+    const context = getContext("DescriptionContext");
     if (!context) {
-        let err = new Error("You used a <Description /> component, but it is not inside a relevant parent.");
+        const err = new Error("You used a <Description /> component, but it is not inside a relevant parent.");
         if (Error.captureStackTrace)
             Error.captureStackTrace(err, useDescriptionContext);
         throw err;
@@ -18,10 +18,19 @@ export function useDescribedBy() {
     };
 }
 export const useDescriptions = (options = {}) => {
-    const { slot, name, props, inherit } = $derived(options);
-    let descriptionIds = $state([]);
+    const { slot, name, props } = $derived(options);
+    const descriptionIds = $state([]);
+    const register = (value) => {
+        descriptionIds.push(value);
+        return () => {
+            const idx = descriptionIds.indexOf(value);
+            if (idx !== -1)
+                descriptionIds.splice(idx, 1);
+        };
+    };
     const value = $derived(descriptionIds.length > 0 ? descriptionIds.join(" ") : undefined);
     const context = {
+        register,
         get slot() {
             return slot;
         },
@@ -34,17 +43,6 @@ export const useDescriptions = (options = {}) => {
         get value() {
             return value;
         },
-        register(value) {
-            descriptionIds.push(value);
-            return () => {
-                const clone = descriptionIds.slice();
-                const idx = clone.indexOf(value);
-                if (idx !== -1)
-                    clone.splice(idx, 1);
-                descriptionIds = clone;
-                return descriptionIds;
-            };
-        },
     };
     setContext("DescriptionContext", context);
     return context;

package/dist/dialog/Dialog.svelte

@@ -1,51 +1,371 @@
-<script lang="ts" module>import { MainTreeProvider } from "../hooks/use-root-containers.svelte.js";
-import { useOpenClosed } from "../internal/open-closed.js";
-import { RenderFeatures } from "../utils/render.js";
-import { getContext } from "svelte";
-import InternalDialog from "./InternalDialog.svelte";
-import Transition from "../transition/Transition.svelte";
-export const DEFAULT_DIALOG_TAG = "div";
-export const DialogRenderFeatures = RenderFeatures.RenderStrategy | RenderFeatures.Static;
-</script>
+<script lang="ts" module>
+  import type { ElementType, Props } from "../utils/types.js"
+  import { RenderFeatures, type PropsForFeatures } from "../utils/render.js"
 
-<script lang="ts" generics="TTag extends ElementType = typeof DEFAULT_DIALOG_TAG">let { ref = $bindable(), transition = false, open, ...rest } = $props();
-const usesOpenClosedState = useOpenClosed();
-const hasOpen = $derived(open !== void 0 || usesOpenClosedState);
-const hasOnClose = $derived(rest.hasOwnProperty("onclose"));
-$effect(() => {
-  if (!hasOpen && !hasOnClose) {
-    throw new Error(`You have to provide an \`open\` and an \`onclose\` prop to the \`Dialog\` component.`);
-  }
-  if (!hasOpen) {
-    throw new Error(`You provided an \`onclose\` prop to the \`Dialog\`, but forgot an \`open\` prop.`);
-  }
-  if (!hasOnClose) {
-    throw new Error(`You provided an \`open\` prop to the \`Dialog\`, but forgot an \`onclose\` prop.`);
+  export const DEFAULT_DIALOG_TAG = "div" as const
+  export type DialogRenderPropArg = {
+    open: boolean
   }
-  if (!usesOpenClosedState && typeof open !== "boolean") {
-    throw new Error(
-      `You provided an \`open\` prop to the \`Dialog\`, but the value is not a boolean. Received: ${open}`
-    );
-  }
-  if (typeof rest.onclose !== "function") {
-    throw new Error(
-      `You provided an \`onclose\` prop to the \`Dialog\`, but the value is not a function. Received: ${rest.onclose}`
-    );
+  type DialogPropsWeControl = "aria-describedby" | "aria-labelledby" | "aria-modal"
+
+  export const DialogRenderFeatures = RenderFeatures.RenderStrategy | RenderFeatures.Static
+
+  export type DialogProps<TTag extends ElementType = typeof DEFAULT_DIALOG_TAG> = Props<
+    TTag,
+    DialogRenderPropArg,
+    DialogPropsWeControl,
+    PropsForFeatures<typeof DialogRenderFeatures> & {
+      as?: TTag
+      id?: string
+      open?: boolean
+      onclose(value: boolean): void
+      initialFocus?: HTMLElement
+      role?: "dialog" | "alertdialog"
+      autofocus?: boolean
+      transition?: boolean
+      __demoMode?: boolean
+    }
+  >
+</script>
+
+<script lang="ts" generics="TTag extends ElementType = typeof DEFAULT_DIALOG_TAG">
+  import { useId } from "../hooks/use-id.js"
+  import { useMainTreeNode, useRootContainers } from "../hooks/use-root-containers.svelte.js"
+  import { clearOpenClosedContext, State, useOpenClosed } from "../internal/open-closed.js"
+  import { useNestedPortals } from "../portal/InternalPortal.svelte"
+  import { getOwnerDocument } from "../utils/owner.js"
+  import { useInertOthers } from "../hooks/use-inert-others.svelte.js"
+  import { useOutsideClick } from "../hooks/use-outside-click.svelte.js"
+  import { useEscape } from "../hooks/use-escape.svelte.js"
+  import { useScrollLock } from "../hooks/use-scroll-lock.svelte.js"
+  import { useOnDisappear } from "../hooks/use-on-disappear.svelte.js"
+  import { setContext } from "svelte"
+  import { useIsTouchDevice } from "../hooks/use-is-touch-device.svelte.js"
+  import FocusTrap, { FocusTrapFeatures } from "../focus-trap/FocusTrap.svelte"
+  import Portal from "../portal/Portal.svelte"
+  import PortalGroup from "../portal/PortalGroup.svelte"
+  import ForcePortalRoot from "../internal/ForcePortalRoot.svelte"
+  import { createCloseContext } from "../internal/close-provider.js"
+  import ElementOrComponent from "../utils/ElementOrComponent.svelte"
+  import { DialogStates, type DialogContext, type StateDefinition } from "./context.svelte.js"
+  import { useDescriptions } from "../description/context.svelte.js"
+  import MainTreeProvider from "../internal/MainTreeProvider.svelte"
+  import Transition from "../transition/Transition.svelte"
+
+  const internalId = useId()
+  let {
+    ref = $bindable(),
+    id = `headlessui-dialog-${internalId}`,
+    open: theirOpen,
+    onclose,
+    initialFocus,
+    role: theirRole = "dialog",
+    autofocus = true,
+    __demoMode = false,
+    unmount = false,
+    transition = false,
+    ...theirProps
+  }: { as?: TTag } & DialogProps<TTag> = $props()
+
+  // Validations
+  const usesOpenClosedState = useOpenClosed()
+  const hasOpen = $derived(theirOpen !== undefined || usesOpenClosedState)
+  const hasOnClose = $derived(theirProps.hasOwnProperty("onclose"))
+
+  $effect(() => {
+    if (!hasOpen && !hasOnClose) {
+      throw new Error(`You have to provide an \`open\` and an \`onclose\` prop to the \`Dialog\` component.`)
+    }
+
+    if (!hasOpen) {
+      throw new Error(`You provided an \`onclose\` prop to the \`Dialog\`, but forgot an \`open\` prop.`)
+    }
+
+    if (!hasOnClose) {
+      throw new Error(`You provided an \`open\` prop to the \`Dialog\`, but forgot an \`onclose\` prop.`)
+    }
+
+    if (!usesOpenClosedState && typeof open !== "boolean") {
+      throw new Error(
+        `You provided an \`open\` prop to the \`Dialog\`, but the value is not a boolean. Received: ${open}`
+      )
+    }
+
+    if (typeof theirProps.onclose !== "function") {
+      throw new Error(
+        `You provided an \`onclose\` prop to the \`Dialog\`, but the value is not a function. Received: ${theirProps.onclose}`
+      )
+    }
+  })
+
+  let didWarnOnRole = $state(false)
+
+  const role = $derived.by(() => {
+    if (theirRole === "dialog" || theirRole === "alertdialog") {
+      return theirRole
+    }
+
+    if (!didWarnOnRole) {
+      didWarnOnRole = true
+      console.warn(
+        `Invalid role [${theirRole}] passed to <Dialog />. Only \`dialog\` and and \`alertdialog\` are supported. Using \`dialog\` instead.`
+      )
+    }
+
+    return "dialog"
+  })
+
+  // Update the `open` prop based on the open closed state
+  const open = $derived(
+    theirOpen === undefined && usesOpenClosedState !== null
+      ? (usesOpenClosedState.value & State.Open) === State.Open
+      : theirOpen
+  )
+
+  const ownerDocument = $derived(getOwnerDocument(ref))
+
+  const dialogState = $derived(open ? DialogStates.Open : DialogStates.Closed)
+
+  let _state = $state({
+    titleId: null,
+    panelRef: null,
+  } as StateDefinition)
+
+  const close = $derived(() => onclose(false))
+
+  const setTitleId = (id: string | null) => (_state.titleId = id)
+
+  const enabled = $derived(dialogState === DialogStates.Open)
+  const nestedPortals = useNestedPortals()
+  const { portals } = $derived(nestedPortals)
+
+  // We use this because reading these values during initial render(s)
+  // can result in `null` rather then the actual elements
+  // This doesn't happen when using certain components like a
+  // `<Dialog.Title>` because they cause the parent to re-render
+  const defaultContainer: { readonly current: HTMLElement | undefined } = {
+    get current() {
+      return _state.panelRef ?? ref
+    },
   }
-});
-const DialogComponent = InternalDialog;
+
+  const mainTreeNode = useMainTreeNode()
+  let { resolvedContainers: resolvedRootContainers } = $derived(
+    useRootContainers({
+      get mainTreeNode() {
+        return mainTreeNode.node
+      },
+      get portals() {
+        return portals
+      },
+      get defaultContainers() {
+        return defaultContainer.current ? [defaultContainer.current] : []
+      },
+    })
+  )
+
+  // When the `Dialog` is wrapped in a `Transition` (or another Headless UI component that exposes
+  // the OpenClosed state) then we get some information via context about its state. When the
+  // `Transition` is about to close, then the `State.Closing` state will be exposed. This allows us
+  // to enable/disable certain functionality in the `Dialog` upfront instead of waiting until the
+  // `Transition` is done transitioning.
+  const isClosing = $derived(
+    usesOpenClosedState !== null ? (usesOpenClosedState.value & State.Closing) === State.Closing : false
+  )
+
+  // Ensure other elements can't be interacted with
+  const inertOthersEnabled = $derived(__demoMode ? false : isClosing ? false : enabled)
+  useInertOthers({
+    get enabled() {
+      return inertOthersEnabled
+    },
+    elements: {
+      get allowed() {
+        return [
+          // Allow the headlessui-portal of the Dialog to be interactive. This
+          // contains the current dialog and the necessary focus guard elements.
+          ref?.closest<HTMLElement>("[data-headlessui-portal]") ?? null,
+        ]
+      },
+      get disallowed() {
+        return [
+          // Disallow the "main" tree root node
+          mainTreeNode.node?.closest<HTMLElement>("body > *:not(#headlessui-portal-root)") ?? null,
+        ]
+      },
+    },
+  })
+
+  // Close Dialog on outside click
+  useOutsideClick({
+    get enabled() {
+      return enabled
+    },
+    get containers() {
+      return resolvedRootContainers
+    },
+    cb(event) {
+      event.preventDefault()
+      close()
+    },
+  })
+
+  // Handle `Escape` to close
+  useEscape({
+    get enabled() {
+      return enabled
+    },
+    get view() {
+      return ownerDocument?.defaultView ?? null
+    },
+    cb(event) {
+      event.preventDefault()
+      event.stopPropagation()
+
+      // Ensure that we blur the current activeElement to prevent maintaining
+      // focus and potentially scrolling the page to the end (because the Dialog
+      // is rendered in a Portal at the end of the document.body and the browser
+      // tries to keep the focused element in view)
+      //
+      // Typically only happens in Safari.
+      if (
+        document.activeElement &&
+        "blur" in document.activeElement &&
+        typeof document.activeElement.blur === "function"
+      ) {
+        document.activeElement.blur()
+      }
+
+      close()
+    },
+  })
+
+  // Scroll lock
+  const scrollLockEnabled = $derived(__demoMode ? false : isClosing ? false : enabled)
+  useScrollLock({
+    get enabled() {
+      return scrollLockEnabled
+    },
+    get ownerDocument() {
+      return ownerDocument
+    },
+    resolveAllowedContainers() {
+      return resolvedRootContainers
+    },
+  })
+
+  // Ensure we close the dialog as soon as the dialog itself becomes hidden
+  useOnDisappear({
+    get enabled() {
+      return enabled
+    },
+    get ref() {
+      return ref
+    },
+    get ondisappear() {
+      return close
+    },
+  })
+
+  const describedby = useDescriptions()
+
+  setContext<DialogContext>("DialogContext", {
+    get titleId() {
+      return _state.titleId
+    },
+    get panelRef() {
+      return _state.panelRef
+    },
+    get dialogState() {
+      return dialogState
+    },
+    get close() {
+      return close
+    },
+    get unmount() {
+      return unmount
+    },
+    setTitleId,
+  })
+
+  const slot = $derived({ open: dialogState === DialogStates.Open } satisfies DialogRenderPropArg)
+
+  const ourProps = $derived({
+    id,
+    role,
+    tabIndex: -1,
+    "aria-modal": __demoMode ? undefined : dialogState === DialogStates.Open ? true : undefined,
+    "aria-labelledby": _state.titleId,
+    "aria-describedby": describedby.value,
+    unmount,
+  })
+
+  const shouldMoveFocusInside = !useIsTouchDevice().value
+  const focusTrapFeatures = $derived.by(() => {
+    let focusTrapFeatures = FocusTrapFeatures.None
+
+    if (enabled && !__demoMode) {
+      focusTrapFeatures |= FocusTrapFeatures.RestoreFocus
+      focusTrapFeatures |= FocusTrapFeatures.TabLock
+
+      if (autofocus) {
+        focusTrapFeatures |= FocusTrapFeatures.AutoFocus
+      }
+
+      if (shouldMoveFocusInside) {
+        focusTrapFeatures |= FocusTrapFeatures.InitialFocus
+      }
+    }
+
+    return focusTrapFeatures
+  })
+
+  clearOpenClosedContext()
+  createCloseContext({
+    get close() {
+      return close
+    },
+  })
 </script>
 
-{#if (open !== undefined || transition) && !rest.static}
+{#snippet internal(transitionProps?: Record<string, any>)}
+  <ForcePortalRoot force={true}>
+    <Portal>
+      <PortalGroup target={ref ?? null}>
+        <ForcePortalRoot force={false}>
+          <FocusTrap
+            {initialFocus}
+            initialFocusFallback={ref}
+            containers={resolvedRootContainers}
+            features={focusTrapFeatures}
+          >
+            <ElementOrComponent
+              {ourProps}
+              theirProps={{ ...theirProps, ...transitionProps }}
+              slots={slot}
+              defaultTag={DEFAULT_DIALOG_TAG}
+              features={DialogRenderFeatures}
+              visible={dialogState === DialogStates.Open}
+              name="Dialog"
+              bind:ref
+            />
+          </FocusTrap>
+        </ForcePortalRoot>
+      </PortalGroup>
+    </Portal>
+  </ForcePortalRoot>
+{/snippet}
+
+{#if (open !== undefined || transition) && !theirProps.static}
   <MainTreeProvider>
-    <Transition show={open} {transition} unmount={rest.unmount} {ref}>
-      {#snippet children(slot, props)}
-        <DialogComponent bind:ref {...props} {...rest} />
+    <Transition show={open} {transition} unmount={theirProps.unmount} {ref}>
+      {#snippet children({ props })}
+        {@render internal(props)}
       {/snippet}
     </Transition>
   </MainTreeProvider>
 {:else}
   <MainTreeProvider>
-    <DialogComponent bind:ref {open} {...rest} />
+    {@render internal()}
   </MainTreeProvider>
 {/if}