@pzerelles/headlessui-svelte 2.1.2-next.3 → 2.1.2-next.31

package/dist/focus-trap/FocusTrap.svelte

@@ -11,6 +11,7 @@ import { match } from "../utils/match.js";
 import { useDisposables } from "../utils/disposables.js";
 import Hidden, { HiddenFeatures } from "../internal/Hidden.svelte";
 import ElementOrComponent from "../utils/ElementOrComponent.svelte";
+import { FocusTrapFeatures } from "./FocusTrapFeatures.js";
 function resolveContainers(containers) {
   if (!containers) return /* @__PURE__ */ new Set();
   if (typeof containers === "function") return new Set(containers());
@@ -23,15 +24,7 @@ function resolveContainers(containers) {
   return all;
 }
 let DEFAULT_FOCUS_TRAP_TAG = "div";
-export var FocusTrapFeatures = /* @__PURE__ */ ((FocusTrapFeatures2) => {
-  FocusTrapFeatures2[FocusTrapFeatures2["None"] = 0] = "None";
-  FocusTrapFeatures2[FocusTrapFeatures2["InitialFocus"] = 1] = "InitialFocus";
-  FocusTrapFeatures2[FocusTrapFeatures2["TabLock"] = 2] = "TabLock";
-  FocusTrapFeatures2[FocusTrapFeatures2["FocusLock"] = 4] = "FocusLock";
-  FocusTrapFeatures2[FocusTrapFeatures2["RestoreFocus"] = 8] = "RestoreFocus";
-  FocusTrapFeatures2[FocusTrapFeatures2["AutoFocus"] = 16] = "AutoFocus";
-  return FocusTrapFeatures2;
-})(FocusTrapFeatures || {});
+export * from "./FocusTrapFeatures.js";
 function useRestoreElement(options) {
   const { enabled } = $derived(options ?? { enabled: true });
   let localHistory = $state(history.slice());
@@ -58,7 +51,7 @@ function useRestoreElement(options) {
 }
 function useRestoreFocus(options) {
   const { features, ownerDocument } = $derived(options);
-  const enabled = $derived(Boolean(features & 8 /* RestoreFocus */));
+  const enabled = $derived(Boolean(features & FocusTrapFeatures.RestoreFocus));
   const restoreElement = useRestoreElement({
     get enabled() {
       return enabled;
@@ -85,14 +78,14 @@ function useInitialFocus(options) {
   let previousActiveElement = $state(null);
   let enabled = useIsTopLayer({
     get enabled() {
-      return Boolean(features & 1 /* InitialFocus */);
+      return Boolean(features & FocusTrapFeatures.InitialFocus);
     },
     scope: "focus-trap#initial-focus"
   });
   let mounted = useIsMounted();
   useWatch({
     action: () => {
-      if (features === 0 /* None */) {
+      if (features === FocusTrapFeatures.None) {
         return;
       }
       if (!enabled) {
@@ -120,7 +113,7 @@ function useInitialFocus(options) {
         if (initialFocus) {
           focusElement(initialFocus);
         } else {
-          if (features & 16 /* AutoFocus */) {
+          if (features & FocusTrapFeatures.AutoFocus) {
             if (focusIn(containerElement, Focus.First | Focus.AutoFocus) !== FocusResult.Error) {
               return;
             }
@@ -154,7 +147,7 @@ function useInitialFocus(options) {
 function useFocusLock(options) {
   let { features, ownerDocument, container, containers, previousActiveElement } = $derived(options);
   const mounted = useIsMounted();
-  const enabled = $derived(Boolean(features & 4 /* FocusLock */));
+  const enabled = $derived(Boolean(features & FocusTrapFeatures.FocusLock));
   useEventListener({
     get element() {
       return ownerDocument?.defaultView;

package/dist/focus-trap/FocusTrap.svelte.d.ts

@@ -1,20 +1,8 @@
 import type { ElementType, Props } from "../utils/types.js";
+import { FocusTrapFeatures } from "./FocusTrapFeatures.js";
 type Containers = (() => Iterable<HTMLElement>) | Iterable<HTMLElement>;
 declare let DEFAULT_FOCUS_TRAP_TAG: "div";
-export declare enum FocusTrapFeatures {
-    /** No features enabled for the focus trap. */
-    None = 0,
-    /** Ensure that we move focus initially into the container. */
-    InitialFocus = 1,
-    /** Ensure that pressing `Tab` and `Shift+Tab` is trapped within the container. */
-    TabLock = 2,
-    /** Ensure that programmatically moving focus outside of the container is disallowed. */
-    FocusLock = 4,
-    /** Ensure that we restore the focus when unmounting the focus trap. */
-    RestoreFocus = 8,
-    /** Initial focus should look for the `data-autofocus` */
-    AutoFocus = 16
-}
+export * from "./FocusTrapFeatures.js";
 type FocusTrapRenderPropArg = {};
 type FocusTrapPropsWeControl = never;
 export type FocusTrapProps<TTag extends ElementType = typeof DEFAULT_FOCUS_TRAP_TAG> = Props<TTag, FocusTrapRenderPropArg, FocusTrapPropsWeControl, {
@@ -26,20 +14,20 @@ export type FocusTrapProps<TTag extends ElementType = typeof DEFAULT_FOCUS_TRAP_
 declare class __sveltets_Render<TTag extends ElementType = typeof DEFAULT_FOCUS_TRAP_TAG> {
     props(): {
         as?: TTag | undefined;
-    } & (Exclude<keyof import("../utils/types.js").PropsOf<TTag>, ("as" | "children" | "refName" | "class") | "features" | "containers" | "initialFocus" | "initialFocusFallback"> extends infer T extends keyof import("../utils/types.js").PropsOf<TTag> ? { [P in T]: import("../utils/types.js").PropsOf<TTag>[P]; } : never) & {
-        children?: import("../utils/types.js").Children<FocusTrapRenderPropArg> | undefined;
+    } & (Exclude<keyof import("../utils/types.js").PropsOf<TTag>, ("slot" | "as" | "children" | "class" | "ref") | "features" | "containers" | "initialFocus" | "initialFocusFallback"> extends infer T extends keyof import("../utils/types.js").PropsOf<TTag> ? { [P in T]: import("../utils/types.js").PropsOf<TTag>[P]; } : never) & {
+        children?: import("svelte").Snippet<[{
+            slot: FocusTrapRenderPropArg;
+            props: Record<string, any>;
+        }]> | undefined;
+        class?: string | ((bag: FocusTrapRenderPropArg) => string) | null | 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: FocusTrapRenderPropArg) => string) | undefined;
-    } : {}) & {
+    } & {
         initialFocus?: HTMLElement;
         initialFocusFallback?: HTMLElement;
         features?: FocusTrapFeatures;
         containers?: Containers;
     };
-    events(): {} & {
-        [evt: string]: CustomEvent<any>;
-    };
+    events(): {};
     slots(): {};
     bindings(): "ref";
     exports(): {};
@@ -48,9 +36,7 @@ interface $$IsomorphicComponent {
     new <TTag extends ElementType = typeof DEFAULT_FOCUS_TRAP_TAG>(options: import('svelte').ComponentConstructorOptions<ReturnType<__sveltets_Render<TTag>['props']>>): import('svelte').SvelteComponent<ReturnType<__sveltets_Render<TTag>['props']>, ReturnType<__sveltets_Render<TTag>['events']>, ReturnType<__sveltets_Render<TTag>['slots']>> & {
         $$bindings?: ReturnType<__sveltets_Render<TTag>['bindings']>;
     } & ReturnType<__sveltets_Render<TTag>['exports']>;
-    <TTag extends ElementType = typeof DEFAULT_FOCUS_TRAP_TAG>(internal: unknown, props: ReturnType<__sveltets_Render<TTag>['props']> & {
-        $$events?: ReturnType<__sveltets_Render<TTag>['events']>;
-    }): ReturnType<__sveltets_Render<TTag>['exports']>;
+    <TTag extends ElementType = typeof DEFAULT_FOCUS_TRAP_TAG>(internal: unknown, props: ReturnType<__sveltets_Render<TTag>['props']> & {}): ReturnType<__sveltets_Render<TTag>['exports']>;
     z_$$bindings?: ReturnType<__sveltets_Render<any>['bindings']>;
 }
 declare const FocusTrap: $$IsomorphicComponent;

package/dist/focus-trap/FocusTrapFeatures.d.ts

@@ -0,0 +1,14 @@
+export declare enum FocusTrapFeatures {
+    /** No features enabled for the focus trap. */
+    None = 0,
+    /** Ensure that we move focus initially into the container. */
+    InitialFocus = 1,
+    /** Ensure that pressing `Tab` and `Shift+Tab` is trapped within the container. */
+    TabLock = 2,
+    /** Ensure that programmatically moving focus outside of the container is disallowed. */
+    FocusLock = 4,
+    /** Ensure that we restore the focus when unmounting the focus trap. */
+    RestoreFocus = 8,
+    /** Initial focus should look for the `data-autofocus` */
+    AutoFocus = 16
+}

package/dist/focus-trap/FocusTrapFeatures.js

@@ -0,0 +1,15 @@
+export var FocusTrapFeatures;
+(function (FocusTrapFeatures) {
+    /** No features enabled for the focus trap. */
+    FocusTrapFeatures[FocusTrapFeatures["None"] = 0] = "None";
+    /** Ensure that we move focus initially into the container. */
+    FocusTrapFeatures[FocusTrapFeatures["InitialFocus"] = 1] = "InitialFocus";
+    /** Ensure that pressing `Tab` and `Shift+Tab` is trapped within the container. */
+    FocusTrapFeatures[FocusTrapFeatures["TabLock"] = 2] = "TabLock";
+    /** Ensure that programmatically moving focus outside of the container is disallowed. */
+    FocusTrapFeatures[FocusTrapFeatures["FocusLock"] = 4] = "FocusLock";
+    /** Ensure that we restore the focus when unmounting the focus trap. */
+    FocusTrapFeatures[FocusTrapFeatures["RestoreFocus"] = 8] = "RestoreFocus";
+    /** Initial focus should look for the `data-autofocus` */
+    FocusTrapFeatures[FocusTrapFeatures["AutoFocus"] = 16] = "AutoFocus";
+})(FocusTrapFeatures || (FocusTrapFeatures = {}));

package/dist/hooks/use-controllable.svelte.js

@@ -27,7 +27,8 @@ export function useControllable(input, onchange, defaultValue) {
             }
             else {
                 internalValue = value;
-                input.controlledValue = value;
+                if (isControlled)
+                    input.controlledValue = value;
             }
         },
     };

package/dist/hooks/use-did-element-move.svelte.js

@@ -1,23 +1,18 @@
 export function useDidElementMove(options) {
     const { enabled, element } = $derived(options);
-    let elementPosition = $state({ left: 0, top: 0 });
+    let elementPosition = $state();
     $effect(() => {
         if (!element)
             return;
-        let DOMRect = element.getBoundingClientRect();
+        const DOMRect = element.getBoundingClientRect();
         if (DOMRect)
             elementPosition = DOMRect;
     });
     const value = $derived.by(() => {
-        if (element == null)
+        if (element == null || !enabled || element === document.activeElement || elementPosition === undefined)
             return false;
-        if (!enabled)
-            return false;
-        if (element === document.activeElement)
-            return false;
-        let buttonRect = element.getBoundingClientRect();
-        let didElementMove = buttonRect.top !== elementPosition.top || buttonRect.left !== elementPosition.left;
-        return didElementMove;
+        const buttonRect = element.getBoundingClientRect();
+        return buttonRect.top !== elementPosition.top || buttonRect.left !== elementPosition.left;
     });
     return {
         get value() {

package/dist/hooks/use-disabled.d.ts

@@ -1,3 +1,8 @@
 export declare const useDisabled: () => {
-    readonly value: boolean;
+    readonly current: boolean;
+};
+export declare const provideDisabled: (disabled: () => boolean, options?: {
+    ignoreParent?: boolean;
+}) => {
+    readonly current: boolean;
 };

package/dist/hooks/use-disabled.js

@@ -1,9 +1,14 @@
-import { getContext } from "svelte";
+import { getContext, setContext } from "svelte";
 export const useDisabled = () => {
-    const context = getContext("DisabledContext");
-    return {
-        get value() {
-            return context?.value ?? false;
+    return getContext("DisabledContext") ?? { current: false };
+};
+export const provideDisabled = (disabled, options) => {
+    const parentDisabled = options?.ignoreParent ? { current: false } : useDisabled();
+    const context = {
+        get current() {
+            return disabled() || parentDisabled.current;
         },
     };
+    setContext("DisabledContext", context);
+    return context;
 };

package/dist/hooks/use-event-listener.svelte.d.ts

@@ -1,6 +1,6 @@
 export declare function useEventListener<TType extends keyof WindowEventMap>(params: {
     element: HTMLElement | Document | Window | EventTarget | null | undefined;
     type: TType;
-    listener: (event: WindowEventMap[TType]) => any;
+    listener: (event: WindowEventMap[TType]) => unknown;
     options?: boolean | AddEventListenerOptions;
 }): void;

package/dist/hooks/use-event-listener.svelte.js

@@ -1,5 +1,7 @@
 export function useEventListener(params) {
-    let { element = window, type, listener, options } = $derived(params);
+    if (typeof window === "undefined")
+        return;
+    const { element = window, type, listener, options } = $derived(params);
     $effect(() => {
         if (!element)
             return;

package/dist/hooks/use-root-containers.svelte.d.ts

@@ -1,8 +1,8 @@
 export { default as MainTreeProvider, useMainTreeNode } from "../internal/MainTreeProvider.svelte";
 export declare function useRootContainers(options?: {
-    defaultContainers?: (HTMLElement | null)[];
+    defaultContainers?: (HTMLElement | undefined | null)[];
     portals?: HTMLElement[];
-    mainTreeNode?: HTMLElement | null;
+    mainTreeNode?: HTMLElement | undefined | null;
 }): {
     readonly resolvedContainers: HTMLElement[];
     contains: (element: HTMLElement) => boolean;

package/dist/hooks/use-root-containers.svelte.js

@@ -6,21 +6,21 @@ export function useRootContainers(options = {}) {
     mainTreeNode, } = $derived(options);
     const ownerDocument = $derived(getOwnerDocument(mainTreeNode));
     const resolvedContainers = $derived.by(() => {
-        let containers = [];
+        const containers = [];
         // Resolve default containers
-        for (let container of defaultContainers) {
-            if (container === null)
+        for (const container of defaultContainers) {
+            if (!container)
                 continue;
             containers.push(container);
         }
         // Resolve portal containers
         if (portals) {
-            for (let portal of portals) {
+            for (const portal of portals) {
                 containers.push(portal);
             }
         }
         // Resolve third party (root) containers
-        for (let container of ownerDocument?.querySelectorAll("html > *, body > *") ?? []) {
+        for (const container of ownerDocument?.querySelectorAll("html > *, body > *") ?? []) {
             if (container === document.body)
                 continue; // Skip `<body>`
             if (container === document.head)

package/dist/hooks/use-tab-direction.svelte.js

@@ -6,7 +6,7 @@ export var Direction;
 })(Direction || (Direction = {}));
 export function useTabDirection() {
     let direction = $state(Direction.Forwards);
-    let enabled = true;
+    const enabled = true;
     useWindowEvent({
         enabled,
         type: "keydown",

package/dist/index.d.ts

@@ -11,10 +11,12 @@ export * from "./label/index.js";
 export * from "./legend/index.js";
 export * from "./listbox/index.js";
 export * from "./menu/index.js";
+export * from "./popover/index.js";
+export * from "./select/index.js";
 export * from "./switch/index.js";
 export * from "./tabs/index.js";
 export * from "./textarea/index.js";
 export * from "./transition/index.js";
+export * from "./utils/index.js";
 export * from "./hooks/use-id.js";
-export * from "./utils/types.js";
-export { mergeProps } from "./utils/render.js";
+export * from "./hooks/use-disabled.js";

package/dist/index.js

@@ -11,10 +11,12 @@ export * from "./label/index.js";
 export * from "./legend/index.js";
 export * from "./listbox/index.js";
 export * from "./menu/index.js";
+export * from "./popover/index.js";
+export * from "./select/index.js";
 export * from "./switch/index.js";
 export * from "./tabs/index.js";
 export * from "./textarea/index.js";
 export * from "./transition/index.js";
+export * from "./utils/index.js";
 export * from "./hooks/use-id.js";
-export * from "./utils/types.js";
-export { mergeProps } from "./utils/render.js";
+export * from "./hooks/use-disabled.js";

package/dist/input/Input.svelte

@@ -3,7 +3,7 @@
 
 <script lang="ts" generics="TTag extends ElementType = typeof DEFAULT_INPUT_TAG, TValue = string">import { htmlid } from "../utils/id.js";
 import { useDisabled } from "../hooks/use-disabled.js";
-import { useProvidedId } from "../internal/id.js";
+import { useProvidedId } from "../utils/id.js";
 import { useLabelledBy } from "../label/context.svelte.js";
 import { useDescribedBy } from "../description/context.svelte.js";
 import { useHover } from "../hooks/use-hover.svelte.js";
@@ -16,13 +16,13 @@ const providedDisabled = useDisabled();
 let {
   ref = $bindable(),
   value = $bindable(),
-  id = providedId?.value || `headlessui-input-${internalId}`,
+  id = providedId || `headlessui-input-${internalId}`,
   disabled: theirDisabled = false,
   autofocus = false,
   invalid = false,
   ...theirProps
 } = $props();
-const disabled = $derived(providedDisabled?.value ?? theirDisabled);
+const disabled = $derived(providedDisabled.current || theirDisabled);
 const labelledBy = useLabelledBy();
 const describedBy = useDescribedBy();
 const { isHovered: hover, hoverProps } = $derived(

package/dist/input/Input.svelte.d.ts

@@ -1,4 +1,4 @@
-import type { ElementType, Props } from "../utils/types.js";
+import type { ElementType, Props, PropsOf } from "../utils/types.js";
 declare const DEFAULT_INPUT_TAG: "input";
 type InputRenderPropArg = {
     disabled: boolean;
@@ -9,7 +9,6 @@ type InputRenderPropArg = {
 };
 type InputPropsWeControl = "aria-labelledby" | "aria-describedby";
 export type InputProps<TTag extends ElementType = typeof DEFAULT_INPUT_TAG, TValue = string> = Props<TTag, InputRenderPropArg, InputPropsWeControl, {
-    id?: string;
     value?: TValue;
     disabled?: boolean;
     invalid?: boolean;
@@ -19,21 +18,20 @@ declare class __sveltets_Render<TTag extends ElementType = typeof DEFAULT_INPUT_
     props(): {
         as?: TTag | undefined;
         value?: TValue | undefined;
-    } & (Exclude<keyof import("../utils/types.js").PropsOf<TTag>, ("as" | "children" | "refName" | "class") | "invalid" | "disabled" | "autofocus" | "value" | "id" | InputPropsWeControl> extends infer T extends keyof import("../utils/types.js").PropsOf<TTag> ? { [P in T]: import("../utils/types.js").PropsOf<TTag>[P]; } : never) & {
-        children?: import("../utils/types.js").Children<InputRenderPropArg> | undefined;
+    } & (Exclude<keyof PropsOf<TTag>, ("slot" | "as" | "children" | "class" | "ref") | "invalid" | "disabled" | "autofocus" | "value" | InputPropsWeControl> extends infer T extends keyof PropsOf<TTag> ? { [P in T]: PropsOf<TTag>[P]; } : never) & {
+        children?: import("svelte").Snippet<[{
+            slot: InputRenderPropArg;
+            props: Record<string, any>;
+        }]> | undefined;
+        class?: string | ((bag: InputRenderPropArg) => string) | null | 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: InputRenderPropArg) => string) | undefined;
-    } : {}) & {
-        id?: string;
+    } & {
         value?: TValue | undefined;
         disabled?: boolean;
         invalid?: boolean;
         autofocus?: boolean;
     };
-    events(): {} & {
-        [evt: string]: CustomEvent<any>;
-    };
+    events(): {};
     slots(): {};
     bindings(): "ref" | "value";
     exports(): {};
@@ -42,9 +40,7 @@ interface $$IsomorphicComponent {
     new <TTag extends ElementType = typeof DEFAULT_INPUT_TAG, TValue = string>(options: import('svelte').ComponentConstructorOptions<ReturnType<__sveltets_Render<TTag, TValue>['props']>>): import('svelte').SvelteComponent<ReturnType<__sveltets_Render<TTag, TValue>['props']>, ReturnType<__sveltets_Render<TTag, TValue>['events']>, ReturnType<__sveltets_Render<TTag, TValue>['slots']>> & {
         $$bindings?: ReturnType<__sveltets_Render<TTag, TValue>['bindings']>;
     } & ReturnType<__sveltets_Render<TTag, TValue>['exports']>;
-    <TTag extends ElementType = typeof DEFAULT_INPUT_TAG, TValue = string>(internal: unknown, props: ReturnType<__sveltets_Render<TTag, TValue>['props']> & {
-        $$events?: ReturnType<__sveltets_Render<TTag, TValue>['events']>;
-    }): ReturnType<__sveltets_Render<TTag, TValue>['exports']>;
+    <TTag extends ElementType = typeof DEFAULT_INPUT_TAG, TValue = string>(internal: unknown, props: ReturnType<__sveltets_Render<TTag, TValue>['props']> & {}): ReturnType<__sveltets_Render<TTag, TValue>['exports']>;
     z_$$bindings?: ReturnType<__sveltets_Render<any, any>['bindings']>;
 }
 declare const Input: $$IsomorphicComponent;

package/dist/internal/FloatingProvider.svelte

@@ -0,0 +1,12 @@
+<script lang="ts" module></script>
+
+<script lang="ts">import { useFloatingProvider } from "./floating-provider.svelte.js";
+const { children, enabled = true } = $props();
+useFloatingProvider({
+  get enabled() {
+    return enabled;
+  }
+});
+</script>
+
+{#if children}{@render children()}{/if}

package/dist/internal/FloatingProvider.svelte.d.ts

@@ -0,0 +1,6 @@
+import type { Snippet } from "svelte";
+declare const FloatingProvider: import("svelte").Component<{
+    children: Snippet;
+    enabled?: boolean;
+}, {}, "">;
+export default FloatingProvider;

package/dist/internal/FocusSentinel.svelte.d.ts

@@ -1,20 +1,4 @@
-interface $$__sveltets_2_IsomorphicComponent<Props extends Record<string, any> = any, Events extends Record<string, any> = any, Slots extends Record<string, any> = any, Exports = {}, Bindings = string> {
-    new (options: import('svelte').ComponentConstructorOptions<Props>): import('svelte').SvelteComponent<Props, Events, Slots> & {
-        $$bindings?: Bindings;
-    } & Exports;
-    (internal: unknown, props: Props & {
-        $$events?: Events;
-        $$slots?: Slots;
-    }): Exports & {
-        $set?: any;
-        $on?: any;
-    };
-    z_$$bindings?: Bindings;
-}
-declare const FocusSentinel: $$__sveltets_2_IsomorphicComponent<{
+declare const FocusSentinel: import("svelte").Component<{
     onfocus: () => boolean;
-}, {
-    [evt: string]: CustomEvent<any>;
-}, {}, {}, "">;
-type FocusSentinel = InstanceType<typeof FocusSentinel>;
+}, {}, "">;
 export default FocusSentinel;

package/dist/internal/ForcePortalRoot.svelte.d.ts

@@ -1,22 +1,6 @@
 import type { Snippet } from "svelte";
-interface $$__sveltets_2_IsomorphicComponent<Props extends Record<string, any> = any, Events extends Record<string, any> = any, Slots extends Record<string, any> = any, Exports = {}, Bindings = string> {
-    new (options: import('svelte').ComponentConstructorOptions<Props>): import('svelte').SvelteComponent<Props, Events, Slots> & {
-        $$bindings?: Bindings;
-    } & Exports;
-    (internal: unknown, props: Props & {
-        $$events?: Events;
-        $$slots?: Slots;
-    }): Exports & {
-        $set?: any;
-        $on?: any;
-    };
-    z_$$bindings?: Bindings;
-}
-declare const ForcePortalRoot: $$__sveltets_2_IsomorphicComponent<{
+declare const ForcePortalRoot: import("svelte").Component<{
     force: boolean;
     children: Snippet;
-}, {
-    [evt: string]: CustomEvent<any>;
-}, {}, {}, "">;
-type ForcePortalRoot = InstanceType<typeof ForcePortalRoot>;
+}, {}, "">;
 export default ForcePortalRoot;

package/dist/internal/FormFields.svelte

@@ -1,7 +1,7 @@
 <script lang="ts">import { disposables } from "../utils/disposables.js";
 import { objectToFormEntries } from "../utils/form.js";
 import FormResolver from "./FormResolver.svelte";
-import HoistFormFields from "./HoistFormFields.svelte";
+import { hoistFormFields } from "./form-fields.svelte.js";
 import Hidden, { HiddenFeatures } from "./Hidden.svelte";
 import { compact } from "../utils/object.js";
 let {
@@ -18,25 +18,28 @@ $effect(() => {
   if (!form) return;
   return d.addEventListener(form, "reset", onReset);
 });
+const fields = $derived(
+  objectToFormEntries(data).map(
+    ([name, value]) => compact({
+      key: name,
+      as: "input",
+      type: "hidden",
+      form: formId,
+      disabled,
+      name,
+      value,
+      ...overrides
+    })
+  )
+);
+const hoisted = hoistFormFields(formFields);
 </script>
 
-<HoistFormFields>
+{#snippet formFields()}
   <FormResolver setForm={(value) => (form = value)} {formId} />
-  {#each objectToFormEntries(data) as [name, value]}
-    <Hidden
-      features={HiddenFeatures.Hidden}
-      {...compact({
-        key: name,
-        as: "input",
-        type: "hidden",
-        hidden: true,
-        readOnly: true,
-        form: formId,
-        disabled,
-        name,
-        value,
-        ...overrides,
-      })}
-    />
+  {#each fields as props}
+    <Hidden features={HiddenFeatures.Hidden} {...props} />
   {/each}
-</HoistFormFields>
+{/snippet}
+
+{#if !hoisted}{@render formFields()}{/if}

package/dist/internal/FormFields.svelte.d.ts

@@ -1,24 +1,8 @@
-interface $$__sveltets_2_IsomorphicComponent<Props extends Record<string, any> = any, Events extends Record<string, any> = any, Slots extends Record<string, any> = any, Exports = {}, Bindings = string> {
-    new (options: import('svelte').ComponentConstructorOptions<Props>): import('svelte').SvelteComponent<Props, Events, Slots> & {
-        $$bindings?: Bindings;
-    } & Exports;
-    (internal: unknown, props: Props & {
-        $$events?: Events;
-        $$slots?: Slots;
-    }): Exports & {
-        $set?: any;
-        $on?: any;
-    };
-    z_$$bindings?: Bindings;
-}
-declare const FormFields: $$__sveltets_2_IsomorphicComponent<{
+declare const FormFields: import("svelte").Component<{
     data: Record<string, any>;
     overrides?: Record<string, any>;
     form?: string;
     disabled?: boolean;
     onReset?: (e: Event) => void;
-}, {
-    [evt: string]: CustomEvent<any>;
-}, {}, {}, "">;
-type FormFields = InstanceType<typeof FormFields>;
+}, {}, "">;
 export default FormFields;

package/dist/internal/FormFieldsProvider.svelte

@@ -0,0 +1,13 @@
+<script lang="ts">import Hidden, { HiddenFeatures } from "./Hidden.svelte";
+import { createFormFieldsContext } from "./form-fields.svelte.js";
+const { children } = $props();
+const context = createFormFieldsContext();
+const { fields } = $derived(context);
+</script>
+
+{#if children}{@render children()}{/if}
+<Hidden features={HiddenFeatures.Hidden}>
+  {#each fields as field}
+    {@render field()}
+  {/each}
+</Hidden>

package/dist/internal/FormFieldsProvider.svelte.d.ts

@@ -0,0 +1,5 @@
+import type { Snippet } from "svelte";
+declare const FormFieldsProvider: import("svelte").Component<{
+    children?: Snippet;
+}, {}, "">;
+export default FormFieldsProvider;

package/dist/internal/FormResolver.svelte.d.ts

@@ -1,21 +1,5 @@
-interface $$__sveltets_2_IsomorphicComponent<Props extends Record<string, any> = any, Events extends Record<string, any> = any, Slots extends Record<string, any> = any, Exports = {}, Bindings = string> {
-    new (options: import('svelte').ComponentConstructorOptions<Props>): import('svelte').SvelteComponent<Props, Events, Slots> & {
-        $$bindings?: Bindings;
-    } & Exports;
-    (internal: unknown, props: Props & {
-        $$events?: Events;
-        $$slots?: Slots;
-    }): Exports & {
-        $set?: any;
-        $on?: any;
-    };
-    z_$$bindings?: Bindings;
-}
-declare const FormResolver: $$__sveltets_2_IsomorphicComponent<{
+declare const FormResolver: import("svelte").Component<{
     setForm: (form: HTMLFormElement) => void;
     formId?: string;
-}, {
-    [evt: string]: CustomEvent<any>;
-}, {}, {}, "">;
-type FormResolver = InstanceType<typeof FormResolver>;
+}, {}, "">;
 export default FormResolver;