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

package/dist/tabs/context.svelte.js

@@ -0,0 +1,134 @@
+import { sortByDomNode } from "../utils/focus-management.js";
+import { match } from "../utils/match.js";
+import { getContext, setContext } from "svelte";
+export var Direction;
+(function (Direction) {
+    Direction[Direction["Forwards"] = 0] = "Forwards";
+    Direction[Direction["Backwards"] = 1] = "Backwards";
+})(Direction || (Direction = {}));
+export var Ordering;
+(function (Ordering) {
+    Ordering[Ordering["Less"] = -1] = "Less";
+    Ordering[Ordering["Equal"] = 0] = "Equal";
+    Ordering[Ordering["Greater"] = 1] = "Greater";
+})(Ordering || (Ordering = {}));
+export function useTabs(component) {
+    const context = getContext("TabsContext");
+    if (!context) {
+        const err = new Error(`<${component} /> is missing a parent <TabGroup /> component.`);
+        if (Error.captureStackTrace)
+            Error.captureStackTrace(err, useTabs);
+        throw err;
+    }
+    return context;
+}
+export const createTabContext = (props) => {
+    let _selectedIndex = $state($state.snapshot(props.selectedIndex ?? props.defaultIndex));
+    let tabs = $state.raw([]);
+    let panels = $state.raw([]);
+    const isControlled = $derived(props.selectedIndex !== undefined);
+    const context = {
+        info: {
+            get isControlled() {
+                return isControlled;
+            },
+        },
+        get orientation() {
+            return props.vertical ? "vertical" : "horizontal";
+        },
+        get activation() {
+            return props.manual ? "manual" : "auto";
+        },
+        get selectedIndex() {
+            return _selectedIndex;
+        },
+        set selectedIndex(index) {
+            if (index === _selectedIndex)
+                return;
+            tabs = sortByDomNode(tabs, (tab) => tab.current ?? null);
+            panels = sortByDomNode(panels, (panel) => panel.current ?? null);
+            const focusableTabs = tabs.filter((tab) => !tab?.current?.hasAttribute("disabled"));
+            if (
+            // Underflow
+            index < 0 ||
+                // Overflow
+                index > tabs.length - 1) {
+                const direction = match(Math.sign(index - _selectedIndex), {
+                    [Ordering.Less]: () => Direction.Backwards,
+                    [Ordering.Equal]: () => {
+                        return match(Math.sign(index), {
+                            [Ordering.Less]: () => Direction.Forwards,
+                            [Ordering.Equal]: () => Direction.Forwards,
+                            [Ordering.Greater]: () => Direction.Backwards,
+                        });
+                    },
+                    [Ordering.Greater]: () => Direction.Forwards,
+                });
+                // If there are no focusable tabs then.
+                // We won't change the selected index
+                // because it's likely the user is
+                // lazy loading tabs and there's
+                // nothing to focus on yet
+                if (focusableTabs.length === 0)
+                    return;
+                const nextSelectedIndex = match(direction, {
+                    [Direction.Forwards]: () => tabs.findIndex((tab) => tab === focusableTabs[0]),
+                    [Direction.Backwards]: () => tabs.findIndex((tab) => tab === focusableTabs[focusableTabs.length - 1]),
+                });
+                if (nextSelectedIndex !== -1)
+                    _selectedIndex = nextSelectedIndex;
+                return;
+            }
+            // Middle
+            const before = tabs.slice(0, index);
+            const after = tabs.slice(index);
+            const next = [...after, ...before].find((tab) => focusableTabs.some((_tab) => _tab === tab));
+            if (!next)
+                return;
+            let selectedIndex = tabs.findIndex((tab) => tab === next) ?? _selectedIndex;
+            if (selectedIndex === -1)
+                selectedIndex = _selectedIndex;
+            if (selectedIndex !== _selectedIndex)
+                _selectedIndex = selectedIndex;
+        },
+        get tabs() {
+            return tabs;
+        },
+        get panels() {
+            return panels;
+        },
+        registerTab(tab) {
+            const unregisterTab = (tab) => {
+                tabs = tabs.filter((_tab) => _tab !== tab);
+            };
+            if (tabs.some((_tab) => _tab === tab))
+                return () => unregisterTab(tab);
+            tabs = sortByDomNode([...tabs, tab], (tab) => tab.current ?? null);
+            const activeTab = tabs[_selectedIndex];
+            // When the component is uncontrolled, then we want to maintain the actively
+            // selected tab even if new tabs are inserted or removed before the active
+            // tab.
+            //
+            // When the component is controlled, then we don't want to do this and
+            // instead we want to select the tab based on the `selectedIndex` prop.
+            if (isControlled) {
+                const selectedIndex = tabs.findIndex((tab) => tab === activeTab);
+                if (selectedIndex !== _selectedIndex)
+                    _selectedIndex = selectedIndex;
+            }
+            return () => unregisterTab(tab);
+        },
+        registerPanel(panel) {
+            const unregisterPanel = (panel) => {
+                panels = panels.filter((_panel) => _panel !== panel);
+            };
+            if (!panels.some((_panel) => _panel === panel)) {
+                panels = sortByDomNode([...panels, panel], (panel) => panel.current ?? null);
+            }
+            return () => unregisterPanel(panel);
+        },
+        change: props.change,
+    };
+    setContext("TabsContext", context);
+    return context;
+};

package/dist/textarea/Textarea.svelte

@@ -1,9 +1,9 @@
 <script lang="ts" module>const DEFAULT_TEXTAREA_TAG = "textarea";
 </script>
 
-<script lang="ts" generics="TTag extends ElementType = typeof DEFAULT_TEXTAREA_TAG">import { htmlid } from "../utils/id.js";
+<script lang="ts" generics="TTag extends ElementType = typeof DEFAULT_TEXTAREA_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 { isFocusVisible: focus, focusProps } = $derived(

package/dist/textarea/Textarea.svelte.d.ts

@@ -8,40 +8,41 @@ type TextareaRenderPropArg = {
     invalid: boolean;
 };
 type TextareaPropsWeControl = "aria-labelledby" | "aria-describedby";
-export type TextareaProps<TTag extends ElementType = typeof DEFAULT_TEXTAREA_TAG> = Props<TTag, TextareaRenderPropArg, TextareaPropsWeControl, {
+export type TextareaProps<TTag extends ElementType = typeof DEFAULT_TEXTAREA_TAG, TValue = string> = Props<TTag, TextareaRenderPropArg, TextareaPropsWeControl, {
+    value?: TValue;
     disabled?: boolean;
     invalid?: boolean;
-    autoFocus?: boolean;
+    autofocus?: boolean;
 }>;
-declare class __sveltets_Render<TTag extends ElementType = typeof DEFAULT_TEXTAREA_TAG> {
+declare class __sveltets_Render<TTag extends ElementType = typeof DEFAULT_TEXTAREA_TAG, TValue = string> {
     props(): {
         as?: TTag | undefined;
-    } & (Exclude<keyof PropsOf<TTag>, ("as" | "children" | "refName" | "class") | "invalid" | "disabled" | TextareaPropsWeControl | "autoFocus"> extends infer T extends keyof PropsOf<TTag> ? { [P in T]: PropsOf<TTag>[P]; } : never) & {
-        children?: import("../utils/types.js").Children<TextareaRenderPropArg> | undefined;
+        value?: TValue | undefined;
+    } & (Exclude<keyof PropsOf<TTag>, ("slot" | "as" | "children" | "class" | "ref") | "invalid" | "disabled" | "autofocus" | "value" | TextareaPropsWeControl> extends infer T extends keyof PropsOf<TTag> ? { [P in T]: PropsOf<TTag>[P]; } : never) & {
+        children?: import("svelte").Snippet<[{
+            slot: TextareaRenderPropArg;
+            props: Record<string, any>;
+        }]> | undefined;
+        class?: string | ((bag: TextareaRenderPropArg) => string) | null | 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: TextareaRenderPropArg) => string) | undefined;
-    } : {}) & {
+    } & {
+        value?: TValue | undefined;
         disabled?: boolean;
         invalid?: boolean;
-        autoFocus?: boolean;
-    };
-    events(): {} & {
-        [evt: string]: CustomEvent<any>;
+        autofocus?: boolean;
     };
+    events(): {};
     slots(): {};
     bindings(): "ref" | "value";
     exports(): {};
 }
 interface $$IsomorphicComponent {
-    new <TTag extends ElementType = typeof DEFAULT_TEXTAREA_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_TEXTAREA_TAG>(internal: unknown, props: ReturnType<__sveltets_Render<TTag>['props']> & {
-        $$events?: ReturnType<__sveltets_Render<TTag>['events']>;
-    }): ReturnType<__sveltets_Render<TTag>['exports']>;
-    z_$$bindings?: ReturnType<__sveltets_Render<any>['bindings']>;
+    new <TTag extends ElementType = typeof DEFAULT_TEXTAREA_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_TEXTAREA_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 Textarea: $$IsomorphicComponent;
-type Textarea<TTag extends ElementType = typeof DEFAULT_TEXTAREA_TAG> = InstanceType<typeof Textarea<TTag>>;
+type Textarea<TTag extends ElementType = typeof DEFAULT_TEXTAREA_TAG, TValue = string> = InstanceType<typeof Textarea<TTag, TValue>>;
 export default Textarea;

package/dist/transition/InternalTransitionChild.svelte.d.ts

@@ -23,20 +23,20 @@ export declare function shouldForwardRef<TTag extends ElementType = typeof DEFAU
 declare class __sveltets_Render<TTag extends ElementType = typeof DEFAULT_TRANSITION_CHILD_TAG> {
     props(): {
         as?: TTag | undefined;
-    } & (Exclude<keyof import("../utils/types.js").PropsOf<TTag>, ("as" | "children" | "refName" | "class") | "unmount" | "transition" | keyof import("./context.svelte.js").TransitionClasses | keyof import("./context.svelte.js").TransitionEvents | "appear"> 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<HTMLElement> | undefined;
+    } & (Exclude<keyof import("../utils/types.js").PropsOf<TTag>, ("slot" | "as" | "children" | "class" | "ref") | "unmount" | "transition" | keyof import("./context.svelte.js").TransitionClasses | keyof import("./context.svelte.js").TransitionEvents | "appear"> 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: HTMLElement;
+            props: Record<string, any>;
+        }]> | undefined;
+        class?: string | ((bag: HTMLElement) => 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: HTMLElement) => string) | undefined;
-    } : {}) & {
+    } & {
         unmount?: boolean | undefined;
     } & import("./context.svelte.js").TransitionClasses & import("./context.svelte.js").TransitionEvents & {
         transition?: boolean;
         appear?: boolean;
     };
-    events(): {} & {
-        [evt: string]: CustomEvent<any>;
-    };
+    events(): {};
     slots(): {};
     bindings(): "ref";
     exports(): {};
@@ -45,9 +45,7 @@ interface $$IsomorphicComponent {
     new <TTag extends ElementType = typeof DEFAULT_TRANSITION_CHILD_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_TRANSITION_CHILD_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_TRANSITION_CHILD_TAG>(internal: unknown, props: ReturnType<__sveltets_Render<TTag>['props']> & {}): ReturnType<__sveltets_Render<TTag>['exports']>;
     z_$$bindings?: ReturnType<__sveltets_Render<any>['bindings']>;
 }
 declare const InternalTransitionChild: $$IsomorphicComponent;

package/dist/transition/Transition.svelte.d.ts

@@ -7,12 +7,14 @@ export type TransitionRootProps<TTag extends ElementType = typeof DEFAULT_TRANSI
 declare class __sveltets_Render<TTag extends ElementType = typeof DEFAULT_TRANSITION_CHILD_TAG> {
     props(): {
         as?: TTag | undefined;
-    } & (Exclude<keyof import("../utils/types.js").PropsOf<TTag>, ("as" | "children" | "refName" | "class") | "unmount" | "transition" | keyof import("./context.svelte.js").TransitionClasses | keyof import("./context.svelte.js").TransitionEvents | "appear"> 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<HTMLElement> | undefined;
+    } & (Exclude<keyof import("../utils/types.js").PropsOf<TTag>, ("slot" | "as" | "children" | "class" | "ref") | "unmount" | "transition" | keyof import("./context.svelte.js").TransitionClasses | keyof import("./context.svelte.js").TransitionEvents | "appear"> 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: HTMLElement;
+            props: Record<string, any>;
+        }]> | undefined;
+        class?: string | ((bag: HTMLElement) => 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: HTMLElement) => string) | undefined;
-    } : {}) & {
+    } & {
         unmount?: boolean | undefined;
     } & import("./context.svelte.js").TransitionClasses & import("./context.svelte.js").TransitionEvents & {
         transition?: boolean;
@@ -21,9 +23,7 @@ declare class __sveltets_Render<TTag extends ElementType = typeof DEFAULT_TRANSI
         show?: boolean;
         appear?: boolean;
     };
-    events(): {} & {
-        [evt: string]: CustomEvent<any>;
-    };
+    events(): {};
     slots(): {};
     bindings(): "ref";
     exports(): {};
@@ -32,9 +32,7 @@ interface $$IsomorphicComponent {
     new <TTag extends ElementType = typeof DEFAULT_TRANSITION_CHILD_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_TRANSITION_CHILD_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_TRANSITION_CHILD_TAG>(internal: unknown, props: ReturnType<__sveltets_Render<TTag>['props']> & {}): ReturnType<__sveltets_Render<TTag>['exports']>;
     z_$$bindings?: ReturnType<__sveltets_Render<any>['bindings']>;
 }
 declare const Transition: $$IsomorphicComponent;

package/dist/transition/TransitionChild.svelte.d.ts

@@ -12,20 +12,20 @@ export declare const TransitionChildRenderFeatures = RenderFeatures.RenderStrate
 declare class __sveltets_Render<TTag extends ElementType = typeof DEFAULT_TRANSITION_CHILD_TAG> {
     props(): {
         as?: TTag | undefined;
-    } & (Exclude<keyof import("../utils/types.js").PropsOf<TTag>, ("as" | "children" | "refName" | "class") | "unmount" | "transition" | keyof TransitionClasses | keyof TransitionEvents | "appear"> 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<HTMLElement> | undefined;
+    } & (Exclude<keyof import("../utils/types.js").PropsOf<TTag>, ("slot" | "as" | "children" | "class" | "ref") | "unmount" | "transition" | keyof TransitionClasses | keyof TransitionEvents | "appear"> 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: HTMLElement;
+            props: Record<string, any>;
+        }]> | undefined;
+        class?: string | ((bag: HTMLElement) => 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: HTMLElement) => string) | undefined;
-    } : {}) & {
+    } & {
         unmount?: boolean | undefined;
     } & TransitionClasses & TransitionEvents & {
         transition?: boolean;
         appear?: boolean;
     };
-    events(): {} & {
-        [evt: string]: CustomEvent<any>;
-    };
+    events(): {};
     slots(): {};
     bindings(): "ref";
     exports(): {};
@@ -34,9 +34,7 @@ interface $$IsomorphicComponent {
     new <TTag extends ElementType = typeof DEFAULT_TRANSITION_CHILD_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_TRANSITION_CHILD_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_TRANSITION_CHILD_TAG>(internal: unknown, props: ReturnType<__sveltets_Render<TTag>['props']> & {}): ReturnType<__sveltets_Render<TTag>['exports']>;
     z_$$bindings?: ReturnType<__sveltets_Render<any>['bindings']>;
 }
 declare const TransitionChild: $$IsomorphicComponent;

package/dist/transition/context.svelte.js

@@ -10,14 +10,14 @@ export var TreeStates;
 })(TreeStates || (TreeStates = {}));
 export function useTransitionContext() {
     const context = getContext("TransitionContext");
-    if (context === null) {
+    if (!context) {
         throw new Error("A <Transition.Child /> is used but it is missing a parent <Transition /> or <Transition.Root />.");
     }
     return context;
 }
 export function useParentNesting() {
     let context = getContext("NestingContext");
-    if (context === null) {
+    if (!context) {
         throw new Error("A <Transition.Child /> is used but it is missing a parent <Transition /> or <Transition.Root />.");
     }
     return context;

package/dist/utils/DisabledProvider.svelte

@@ -0,0 +1,6 @@
+<script lang="ts">import { provideDisabled } from "../hooks/use-disabled.js";
+const { disabled, children } = $props();
+provideDisabled(() => disabled ?? false);
+</script>
+
+{@render children?.()}

package/dist/utils/DisabledProvider.svelte.d.ts

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

package/dist/utils/ElementOrComponent.svelte

@@ -1,4 +1,4 @@
-<script lang="ts" generics="TFeature extends RenderFeatures, TTag extends ElementType, TSlot, TValue">import { mergePropsAdvanced, RenderFeatures, RenderStrategy } from "./render.js";
+<script lang="ts" generics="TFeature extends RenderFeatures, TTag extends ElementType, TSlot, TValue">import { mergePropsAdvanced, RenderFeatures } from "./render.js";
 import Generic from "./Generic.svelte";
 let {
   ourProps,
@@ -23,4 +23,4 @@ const hiddenProps = $derived(
 );
 </script>
 
-{#if render}<Generic {...rest} {...hiddenProps} {slot} tag={defaultTag} {name} bind:ref bind:value bind:checked />{/if}
+{#if render}<Generic {...rest} {...hiddenProps} {slot} tag={defaultTag} bind:ref bind:value bind:checked />{/if}

package/dist/utils/ElementOrComponent.svelte.d.ts

@@ -6,10 +6,12 @@ declare class __sveltets_Render<TFeature extends RenderFeatures, TTag extends El
             [x: string]: any;
             [x: number]: any;
         } & {
-            children?: import("./types.js").Children<TSlot> | undefined;
+            children?: import("svelte").Snippet<[{
+                slot: TSlot;
+                props: Record<string, any>;
+            }]> | undefined;
+            class?: string | ((bag: TSlot) => string) | null | undefined;
             ref?: HTMLElement;
-        } & {
-            class?: any;
         } & Expand<((TFeature extends RenderFeatures.Static ? {
             static?: boolean;
         } : {}) extends infer T ? T extends (TFeature extends RenderFeatures.Static ? {
@@ -21,9 +23,12 @@ declare class __sveltets_Render<TFeature extends RenderFeatures, TTag extends El
         } : {}) ? T_1 extends any ? (x: T_1) => any : never : never : never) extends (x: infer R) => any ? R : never>> | undefined;
         theirProps: {
             as?: TTag | undefined;
-            children?: import("./types.js").Children<TSlot> | undefined;
+            children?: import("svelte").Snippet<[{
+                slot: TSlot;
+                props: Record<string, any>;
+            }]> | undefined;
+            class?: string | ((bag: TSlot) => string) | null | undefined;
             ref?: HTMLElement | undefined;
-            class?: any;
         };
         slot?: TSlot | undefined;
         slots?: TSlot | undefined;
@@ -35,9 +40,7 @@ declare class __sveltets_Render<TFeature extends RenderFeatures, TTag extends El
         value?: TValue | undefined;
         checked?: boolean;
     };
-    events(): {} & {
-        [evt: string]: CustomEvent<any>;
-    };
+    events(): {};
     slots(): {};
     bindings(): "ref" | "value" | "checked";
     exports(): {};
@@ -46,9 +49,7 @@ interface $$IsomorphicComponent {
     new <TFeature extends RenderFeatures, TTag extends ElementType, TSlot, TValue>(options: import('svelte').ComponentConstructorOptions<ReturnType<__sveltets_Render<TFeature, TTag, TSlot, TValue>['props']>>): import('svelte').SvelteComponent<ReturnType<__sveltets_Render<TFeature, TTag, TSlot, TValue>['props']>, ReturnType<__sveltets_Render<TFeature, TTag, TSlot, TValue>['events']>, ReturnType<__sveltets_Render<TFeature, TTag, TSlot, TValue>['slots']>> & {
         $$bindings?: ReturnType<__sveltets_Render<TFeature, TTag, TSlot, TValue>['bindings']>;
     } & ReturnType<__sveltets_Render<TFeature, TTag, TSlot, TValue>['exports']>;
-    <TFeature extends RenderFeatures, TTag extends ElementType, TSlot, TValue>(internal: unknown, props: ReturnType<__sveltets_Render<TFeature, TTag, TSlot, TValue>['props']> & {
-        $$events?: ReturnType<__sveltets_Render<TFeature, TTag, TSlot, TValue>['events']>;
-    }): ReturnType<__sveltets_Render<TFeature, TTag, TSlot, TValue>['exports']>;
+    <TFeature extends RenderFeatures, TTag extends ElementType, TSlot, TValue>(internal: unknown, props: ReturnType<__sveltets_Render<TFeature, TTag, TSlot, TValue>['props']> & {}): ReturnType<__sveltets_Render<TFeature, TTag, TSlot, TValue>['exports']>;
     z_$$bindings?: ReturnType<__sveltets_Render<any, any, any, any>['bindings']>;
 }
 declare const ElementOrComponent: $$IsomorphicComponent;

package/dist/utils/Generic.svelte

@@ -1,8 +1,7 @@
-<script lang="ts" generics="TTag extends keyof SvelteHTMLProps, TSlot, TValue">import { stateFromSlot } from "./state.js";
+<script lang="ts" generics="TTag extends ElementType, TSlot, TValue">import { stateFromSlot } from "./state.js";
 let {
   slot = {},
   tag,
-  name,
   ref = $bindable(),
   value = $bindable(),
   checked = $bindable(),
@@ -18,19 +17,22 @@ const resolvedClass = $derived(
 </script>
 
 {#if as === "svelte:fragment"}
-  {#if children}{@render children(slot, {
-      ...props,
-      ...(resolvedClass ? { class: resolvedClass } : {}),
-      ...stateFromSlot(slot),
+  {#if children}{@render children({
+      slot,
+      props: {
+        ...props,
+        ...(resolvedClass ? { class: resolvedClass } : {}),
+        ...stateFromSlot(slot),
+      },
     })}{/if}
 {:else if children}
   {#if as === "select"}
     <select bind:this={ref} {...props} class={resolvedClass} {...stateFromSlot(slot)} bind:value>
-      {@render children(slot, {})}
+      {@render children({ slot, props: {} })}
     </select>
   {:else}
     <svelte:element this={as} bind:this={ref} {...props} class={resolvedClass} {...stateFromSlot(slot)}>
-      {@render children(slot, {})}
+      {@render children({ slot, props: {} })}
     </svelte:element>
   {/if}
 {:else if as === "input" && props.type === "checkbox"}

package/dist/utils/Generic.svelte.d.ts

@@ -1,35 +1,32 @@
-import type { ElementType, SvelteHTMLProps } from "./types.js";
-declare class __sveltets_Render<TTag extends keyof SvelteHTMLProps, TSlot, TValue> {
+import type { ElementType } from "./types.js";
+declare class __sveltets_Render<TTag extends ElementType, TSlot, TValue> {
     props(): {
         as?: TTag | undefined;
         slot: TSlot;
         tag: ElementType;
-        name: string;
         ref?: HTMLElement;
         value?: TValue | undefined;
         checked?: boolean;
-    } & (Exclude<keyof import("./types.js").PropsOf<TTag>, "as" | "children" | "refName" | "class"> extends infer T extends keyof import("./types.js").PropsOf<TTag> ? { [P in T]: import("./types.js").PropsOf<TTag>[P]; } : never) & {
-        children?: import("./types.js").Children<TSlot> | undefined;
+    } & (Exclude<keyof import("./types.js").PropsOf<TTag>, "slot" | "as" | "children" | "class" | "ref"> extends infer T extends keyof import("./types.js").PropsOf<TTag> ? { [P in T]: import("./types.js").PropsOf<TTag>[P]; } : never) & {
+        children?: import("svelte").Snippet<[{
+            slot: TSlot;
+            props: Record<string, any>;
+        }]> | undefined;
+        class?: string | ((bag: TSlot) => string) | null | undefined;
         ref?: HTMLElement;
-    } & (true extends (import("./types.js").PropsOf<TTag> extends infer T_1 ? T_1 extends import("./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("./types.js").PropsOf<TTag>["class"] | ((bag: TSlot) => string) | undefined;
-    } : {});
-    events(): {} & {
-        [evt: string]: CustomEvent<any>;
     };
+    events(): {};
     slots(): {};
     bindings(): "ref" | "value" | "checked";
     exports(): {};
 }
 interface $$IsomorphicComponent {
-    new <TTag extends keyof SvelteHTMLProps, TSlot, TValue>(options: import('svelte').ComponentConstructorOptions<ReturnType<__sveltets_Render<TTag, TSlot, TValue>['props']>>): import('svelte').SvelteComponent<ReturnType<__sveltets_Render<TTag, TSlot, TValue>['props']>, ReturnType<__sveltets_Render<TTag, TSlot, TValue>['events']>, ReturnType<__sveltets_Render<TTag, TSlot, TValue>['slots']>> & {
+    new <TTag extends ElementType, TSlot, TValue>(options: import('svelte').ComponentConstructorOptions<ReturnType<__sveltets_Render<TTag, TSlot, TValue>['props']>>): import('svelte').SvelteComponent<ReturnType<__sveltets_Render<TTag, TSlot, TValue>['props']>, ReturnType<__sveltets_Render<TTag, TSlot, TValue>['events']>, ReturnType<__sveltets_Render<TTag, TSlot, TValue>['slots']>> & {
         $$bindings?: ReturnType<__sveltets_Render<TTag, TSlot, TValue>['bindings']>;
     } & ReturnType<__sveltets_Render<TTag, TSlot, TValue>['exports']>;
-    <TTag extends keyof SvelteHTMLProps, TSlot, TValue>(internal: unknown, props: ReturnType<__sveltets_Render<TTag, TSlot, TValue>['props']> & {
-        $$events?: ReturnType<__sveltets_Render<TTag, TSlot, TValue>['events']>;
-    }): ReturnType<__sveltets_Render<TTag, TSlot, TValue>['exports']>;
+    <TTag extends ElementType, TSlot, TValue>(internal: unknown, props: ReturnType<__sveltets_Render<TTag, TSlot, TValue>['props']> & {}): ReturnType<__sveltets_Render<TTag, TSlot, TValue>['exports']>;
     z_$$bindings?: ReturnType<__sveltets_Render<any, any, any>['bindings']>;
 }
 declare const Generic: $$IsomorphicComponent;
-type Generic<TTag extends keyof SvelteHTMLProps, TSlot, TValue> = InstanceType<typeof Generic<TTag, TSlot, TValue>>;
+type Generic<TTag extends ElementType, TSlot, TValue> = InstanceType<typeof Generic<TTag, TSlot, TValue>>;
 export default Generic;

package/dist/utils/StableCollection.svelte.d.ts

@@ -1,22 +1,6 @@
 import { type Snippet } from "svelte";
 export declare function useStableCollectionIndex(group: string): number;
-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 StableCollection: $$__sveltets_2_IsomorphicComponent<{
+declare const StableCollection: import("svelte").Component<{
     children: Snippet;
-}, {
-    [evt: string]: CustomEvent<any>;
-}, {}, {}, "">;
-type StableCollection = InstanceType<typeof StableCollection>;
+}, {}, "">;
 export default StableCollection;

package/dist/utils/alternative-types.d.ts

@@ -7,9 +7,8 @@ export type ElementType = keyof SvelteHTMLProps;
 export type Expand<T> = T extends infer O ? {
     [K in keyof O]: O[K];
 } : never;
-export type Children<TSlot> = Snippet | Snippet<[TSlot, Record<string, any>]>;
 type OurProps<TSlot> = {
-    children?: Children<TSlot>;
+    children?: Snippet<[TSlot, Record<string, any>]>;
     ref?: HTMLElement;
     class?: string | null | ((bag: TSlot) => string);
 };

package/dist/utils/floating-ui/svelte/components/FloatingNode.svelte

@@ -0,0 +1,17 @@
+<script lang="ts" module></script>
+
+<script lang="ts">import { setContext } from "svelte";
+import { useFloatingParentNodeId } from "./FloatingTree.svelte";
+const { children, id } = $props();
+const parentId = useFloatingParentNodeId();
+setContext("FloatingNodeContext", {
+  get id() {
+    return id;
+  },
+  get parentId() {
+    return parentId.value;
+  }
+});
+</script>
+
+{#if children}{@render children()}{/if}

package/dist/utils/floating-ui/svelte/components/FloatingNode.svelte.d.ts

@@ -0,0 +1,7 @@
+import type { Snippet } from "svelte";
+export interface FloatingNodeProps {
+    children?: Snippet;
+    id: string;
+}
+declare const FloatingNode: import("svelte").Component<FloatingNodeProps, {}, "">;
+export default FloatingNode;