@pzerelles/headlessui-svelte 2.1.2-next.5 → 2.1.2-next.50

package/dist/radio-group/RadioOption.svelte

@@ -0,0 +1,145 @@
+<script lang="ts" module>
+  import type { Props } from "../utils/types.js"
+
+  const DEFAULT_OPTION_TAG = "div" as const
+
+  export type RadioOptionRenderPropArg = {
+    checked: boolean
+    /** @deprecated use `focus` instead */
+    active: boolean
+    hover: boolean
+    focus: boolean
+    autofocus: boolean
+    disabled: boolean
+  }
+
+  export type RadioOptionOwnProps<TType> = {
+    element?: HTMLElement
+    value: TType
+    disabled?: boolean
+    autofocus?: boolean
+  }
+
+  export type RadioOptionProps<TType> = Props<
+    typeof DEFAULT_OPTION_TAG,
+    RadioOptionRenderPropArg,
+    RadioOptionOwnProps<TType>
+  >
+</script>
+
+<script lang="ts" generics="TType = ComponentProps<typeof RadioGroup>['value']">
+  import { default as RadioGroup } from "./RadioGroup.svelte"
+  import { useActions, useData } from "./contest.svelte.js"
+  import { useId } from "../hooks/use-id.js"
+  import { useLabels } from "../label/context.svelte.js"
+  import { useDescriptions } from "../description/context.svelte.js"
+  import { onMount, type ComponentProps } from "svelte"
+  import ElementOrComponent from "../utils/ElementOrComponent.svelte"
+  import { useFocusRing } from "../hooks/use-focus-ring.svelte.js"
+  import { useHover } from "../hooks/use-hover.svelte.js"
+  import { mergeProps } from "../utils/render.js"
+
+  const data = useData("RadioOption")
+  const actions = useActions<TType>("RadioOption")
+
+  const internalId = useId()
+  let {
+    element = $bindable(),
+    id: theirId,
+    value,
+    disabled: theirDisabled = false,
+    autofocus = false,
+    ...theirProps
+  }: RadioOptionProps<TType> = $props()
+  const id = $derived(theirId || `headlessui-radiogroup-option-${internalId}`)
+  const disabled = $derived(data.disabled || theirDisabled)
+
+  const labelledby = useLabels()
+  const describedby = useDescriptions()
+
+  const propsRef = {
+    get value() {
+      return value
+    },
+    get disabled() {
+      return disabled
+    },
+  }
+
+  onMount(() => {
+    return actions.registerOption({
+      id,
+      get element() {
+        return element
+      },
+      get propsRef() {
+        return propsRef
+      },
+    })
+  })
+
+  const handleClick = (event: MouseEvent) => {
+    //if (isDisabledReactIssue7711(event.currentTarget)) return event.preventDefault()
+    if (!actions.change(value)) return
+    element?.focus()
+  }
+
+  const isFirstOption = $derived(data.firstOption?.id === id)
+
+  const { isFocusVisible: focus, focusProps } = $derived(
+    useFocusRing({
+      get autofocus() {
+        return autofocus
+      },
+    })
+  )
+  const { isHovered: hover, hoverProps } = $derived(
+    useHover({
+      get disabled() {
+        return disabled
+      },
+    })
+  )
+
+  const checked = $derived(data.compare(data.value as TType, value))
+  const ourProps = $derived(
+    mergeProps(
+      {
+        id,
+        role: "radio",
+        "aria-checked": checked ? "true" : "false",
+        "aria-labelledby": labelledby.value,
+        "aria-describedby": describedby.value,
+        "aria-disabled": disabled ? true : undefined,
+        tabIndex: (() => {
+          if (disabled) return -1
+          if (checked) return 0
+          if (!data.containsCheckedOption && isFirstOption) return 0
+          return -1
+        })(),
+        onclick: disabled ? undefined : handleClick,
+        autofocus,
+      },
+      focusProps,
+      hoverProps
+    )
+  )
+
+  const slot = $derived({
+    checked,
+    disabled,
+    active: focus,
+    hover,
+    focus,
+    autofocus,
+  } satisfies RadioOptionRenderPropArg)
+</script>
+
+<ElementOrComponent
+  {ourProps}
+  {theirProps}
+  slots={slot}
+  defaultTag={DEFAULT_OPTION_TAG}
+  bind:element
+  name="RadioOption"
+/>

package/dist/radio-group/RadioOption.svelte.d.ts

@@ -0,0 +1,37 @@
+import type { Props } from "../utils/types.js";
+declare const DEFAULT_OPTION_TAG: "div";
+export type RadioOptionRenderPropArg = {
+    checked: boolean;
+    /** @deprecated use `focus` instead */
+    active: boolean;
+    hover: boolean;
+    focus: boolean;
+    autofocus: boolean;
+    disabled: boolean;
+};
+export type RadioOptionOwnProps<TType> = {
+    element?: HTMLElement;
+    value: TType;
+    disabled?: boolean;
+    autofocus?: boolean;
+};
+export type RadioOptionProps<TType> = Props<typeof DEFAULT_OPTION_TAG, RadioOptionRenderPropArg, RadioOptionOwnProps<TType>>;
+import { default as RadioGroup } from "./RadioGroup.svelte";
+import { type ComponentProps } from "svelte";
+declare class __sveltets_Render<TType = ComponentProps<typeof RadioGroup>['value']> {
+    props(): RadioOptionProps<TType>;
+    events(): {};
+    slots(): {};
+    bindings(): "element";
+    exports(): {};
+}
+interface $$IsomorphicComponent {
+    new <TType = ComponentProps<typeof RadioGroup>['value']>(options: import('svelte').ComponentConstructorOptions<ReturnType<__sveltets_Render<TType>['props']>>): import('svelte').SvelteComponent<ReturnType<__sveltets_Render<TType>['props']>, ReturnType<__sveltets_Render<TType>['events']>, ReturnType<__sveltets_Render<TType>['slots']>> & {
+        $$bindings?: ReturnType<__sveltets_Render<TType>['bindings']>;
+    } & ReturnType<__sveltets_Render<TType>['exports']>;
+    <TType = ComponentProps<typeof RadioGroup>['value']>(internal: unknown, props: ReturnType<__sveltets_Render<TType>['props']> & {}): ReturnType<__sveltets_Render<TType>['exports']>;
+    z_$$bindings?: ReturnType<__sveltets_Render<any>['bindings']>;
+}
+declare const RadioOption: $$IsomorphicComponent;
+type RadioOption<TType = ComponentProps<typeof RadioGroup>['value']> = InstanceType<typeof RadioOption<TType>>;
+export default RadioOption;

package/dist/radio-group/contest.svelte.d.ts

@@ -0,0 +1,30 @@
+interface Option<T = unknown> {
+    id: string;
+    element?: HTMLElement;
+    propsRef: {
+        value: T;
+        disabled: boolean;
+    };
+}
+export interface StateDefinition<T = unknown> {
+    options: Option<T>[];
+}
+export type RadioGroupDataContext = {
+    value: unknown;
+    firstOption?: Option;
+    containsCheckedOption: boolean;
+    disabled: boolean;
+    compare(a: unknown, z: unknown): boolean;
+} & StateDefinition;
+export declare function useData(component: string): RadioGroupDataContext;
+export type RadioGroupActionsContext<T> = {
+    registerOption(option: Option<T>): () => void;
+    change(value: T): boolean;
+};
+export declare function useActions<T>(component: string): RadioGroupActionsContext<T>;
+export declare function createState<T>(): {
+    readonly options: Option<T>[];
+    registerOption(option: Option<T>): void;
+    unregisterOption(id: string): void;
+};
+export {};

package/dist/radio-group/contest.svelte.js

@@ -0,0 +1,40 @@
+import { sortByDomNode } from "../utils/focus-management.js";
+import { getContext } from "svelte";
+export function useData(component) {
+    const context = getContext("RadioGroupDataContext");
+    if (!context) {
+        const err = new Error(`<${component} /> is missing a parent <RadioGroup /> component.`);
+        if (Error.captureStackTrace)
+            Error.captureStackTrace(err, useData);
+        throw err;
+    }
+    return context;
+}
+export function useActions(component) {
+    const context = getContext("RadioGroupActionsContext");
+    if (!context) {
+        const err = new Error(`<${component} /> is missing a parent <RadioGroup /> component.`);
+        if (Error.captureStackTrace)
+            Error.captureStackTrace(err, useActions);
+        throw err;
+    }
+    return context;
+}
+export function createState() {
+    let options = $state([]);
+    return {
+        get options() {
+            return options;
+        },
+        registerOption(option) {
+            const nextOptions = [...options, option];
+            options = sortByDomNode(nextOptions, (option) => option.element ?? null);
+        },
+        unregisterOption(id) {
+            let idx = options.findIndex((radio) => radio.id === id);
+            if (idx === -1)
+                return;
+            options.splice(idx, 1);
+        },
+    };
+}

package/dist/radio-group/index.d.ts

@@ -0,0 +1,3 @@
+export { default as Radio, type RadioProps, type RadioRenderPropArg as RadioSlot, type RadioOwnProps, } from "./Radio.svelte";
+export { default as RadioGroup, type RadioGroupProps, type RadioGroupRenderPropArg as RadioGroupSlot, type RadioGroupOwnProps, } from "./RadioGroup.svelte";
+export { default as RadioOption, type RadioOptionProps, type RadioOptionRenderPropArg as RadioOptionSlot, type RadioOptionOwnProps, } from "./RadioOption.svelte";

package/dist/radio-group/index.js

@@ -0,0 +1,3 @@
+export { default as Radio, } from "./Radio.svelte";
+export { default as RadioGroup, } from "./RadioGroup.svelte";
+export { default as RadioOption, } from "./RadioOption.svelte";

package/dist/select/Select.svelte

@@ -0,0 +1,112 @@
+<script lang="ts" module>
+  import type { Props } from "../utils/types.js"
+
+  let DEFAULT_SELECT_TAG = "select" as const
+
+  export type SelectRenderPropArg = {
+    disabled: boolean
+    hover: boolean
+    focus: boolean
+    active: boolean
+    autofocus: boolean
+    invalid: boolean
+  }
+  type SelectPropsWeControl = "aria-labelledby" | "aria-describedby"
+
+  export type SelectOwnProps = {
+    element?: HTMLElement
+    id?: string
+    disabled?: boolean
+    invalid?: boolean
+    autofocus?: boolean
+  }
+
+  export type SelectProps = Props<typeof DEFAULT_SELECT_TAG, SelectRenderPropArg, SelectOwnProps>
+</script>
+
+<script lang="ts">
+  import { useId } from "../hooks/use-id.js"
+  import { useProvidedId } from "../utils/id.js"
+  import { useDisabled } from "../hooks/use-disabled.js"
+  import { useFocusRing } from "../hooks/use-focus-ring.svelte.js"
+  import { useHover } from "../hooks/use-hover.svelte.js"
+  import { useActivePress } from "../hooks/use-active-press.svelte.js"
+  import { useLabelledBy } from "../label/context.svelte.js"
+  import { useDescribedBy } from "../description/context.svelte.js"
+  import { mergeProps } from "../utils/render.js"
+  import ElementOrComponent from "../utils/ElementOrComponent.svelte"
+
+  const internalId = useId()
+  const providedId = useProvidedId()
+  const providedDisabled = useDisabled()
+  let {
+    element = $bindable(),
+    id = providedId || `headlessui-select-${internalId}`,
+    disabled: theirDisabled = false,
+    invalid = false,
+    autofocus = false,
+    value = $bindable(),
+    ...theirProps
+  }: SelectProps = $props()
+
+  const disabled = $derived(providedDisabled.current ?? theirDisabled)
+  const labelledBy = useLabelledBy()
+  const describedBy = useDescribedBy()
+
+  const { isFocusVisible: focus, focusProps } = $derived(
+    useFocusRing({
+      get autofocus() {
+        return autofocus
+      },
+    })
+  )
+  const { isHovered: hover, hoverProps } = $derived(
+    useHover({
+      get disabled() {
+        return disabled
+      },
+    })
+  )
+  const { pressed: active, pressProps } = $derived(
+    useActivePress({
+      get disabled() {
+        return disabled
+      },
+    })
+  )
+
+  const ourProps = $derived(
+    mergeProps(
+      {
+        id,
+        "aria-labelledby": labelledBy.value,
+        "aria-describedby": describedBy.value,
+        "aria-invalid": invalid ? "" : undefined,
+        disabled: disabled || undefined,
+        autofocus,
+      },
+      focusProps,
+      hoverProps,
+      pressProps
+    )
+  )
+
+  const slot = $derived({
+    disabled,
+    invalid,
+    hover,
+    focus,
+    active,
+    autofocus,
+  } satisfies SelectRenderPropArg)
+</script>
+
+<ElementOrComponent
+  {ourProps}
+  {theirProps}
+  slots={slot}
+  defaultTag={DEFAULT_SELECT_TAG}
+  name="Select"
+  bind:element
+  bind:value
+/>

package/dist/select/Select.svelte.d.ts

@@ -0,0 +1,21 @@
+import type { Props } from "../utils/types.js";
+declare let DEFAULT_SELECT_TAG: "select";
+export type SelectRenderPropArg = {
+    disabled: boolean;
+    hover: boolean;
+    focus: boolean;
+    active: boolean;
+    autofocus: boolean;
+    invalid: boolean;
+};
+export type SelectOwnProps = {
+    element?: HTMLElement;
+    id?: string;
+    disabled?: boolean;
+    invalid?: boolean;
+    autofocus?: boolean;
+};
+export type SelectProps = Props<typeof DEFAULT_SELECT_TAG, SelectRenderPropArg, SelectOwnProps>;
+declare const Select: import("svelte").Component<SelectProps, {}, "element" | "value">;
+type Select = ReturnType<typeof Select>;
+export default Select;

package/dist/select/index.d.ts

@@ -0,0 +1 @@
+export { default as Select, type SelectProps, type SelectRenderPropArg as SelectSlot, type SelectOwnProps, } from "./Select.svelte";

package/dist/select/index.js

@@ -0,0 +1 @@
+export { default as Select, } from "./Select.svelte";

package/dist/switch/Switch.svelte

@@ -1,8 +1,8 @@
 <script lang="ts" module>
-  import type { ElementType, Props, PropsOf } from "../utils/types.js"
+  import type { Props } from "../utils/types.js"
 
   const DEFAULT_SWITCH_TAG = "button" as const
-  type SwitchRenderPropArg = {
+  export type SwitchRenderPropArg = {
     checked: boolean
     hover: boolean
     focus: boolean
@@ -13,28 +13,27 @@
   }
   type SwitchPropsWeControl = "aria-checked" | "aria-describedby" | "aria-labelledby" | "role"
 
-  export type SwitchProps<TTag extends ElementType = typeof DEFAULT_SWITCH_TAG> = Props<
-    TTag,
-    SwitchRenderPropArg,
-    SwitchPropsWeControl,
-    {
-      checked?: boolean
-      defaultChecked?: boolean
-      onchange?(checked: boolean): void
-      name?: string
-      value?: string
-      form?: string
-      autofocus?: boolean
-      disabled?: boolean
-      tabIndex?: number
-    }
-  >
+  export type SwitchOwnProps = {
+    element?: HTMLElement
+    id?: string
+    checked?: boolean
+    defaultChecked?: boolean
+    onchange?(checked: boolean): void
+    name?: string
+    value?: string
+    form?: string
+    autofocus?: boolean
+    disabled?: boolean
+    tabIndex?: number
+  }
+
+  export type SwitchProps = Props<typeof DEFAULT_SWITCH_TAG, SwitchRenderPropArg, SwitchOwnProps>
 </script>
 
-<script lang="ts" generics="TTag extends ElementType = typeof DEFAULT_SWITCH_TAG">
+<script lang="ts">
   import { useId } from "../hooks/use-id.js"
   import { useDisabled } from "../hooks/use-disabled.js"
-  import { useProvidedId } from "../internal/id.js"
+  import { useProvidedId } from "../utils/id.js"
   import { getContext, tick } from "svelte"
   import type { GroupContext } from "./SwitchGroup.svelte"
   import { attemptSubmit } from "../utils/form.js"
@@ -53,8 +52,8 @@
   const providedId = useProvidedId()
   const providedDisabled = useDisabled()
   let {
-    ref = $bindable(),
-    id = (providedId || `headlessui-switch-${internalId}`) as PropsOf<TTag>["id"],
+    element = $bindable(),
+    id = providedId || `headlessui-switch-${internalId}`,
     disabled: theirDisabled = false,
     checked: controlledChecked = $bindable(),
     defaultChecked: _defaultChecked,
@@ -65,11 +64,11 @@
     autofocus = false,
     tabIndex,
     ...theirProps
-  }: { as?: TTag } & SwitchProps<TTag> = $props()
-  const disabled = $derived(providedDisabled?.value ?? theirDisabled)
+  }: SwitchProps = $props()
+  const disabled = $derived(theirDisabled || providedDisabled.current)
   const groupContext = getContext<GroupContext>("GroupContext")
   $effect(() => {
-    if (groupContext) groupContext.switchElement = ref ?? null
+    if (groupContext) groupContext.switchElement = element ?? null
   })
 
   const defaultChecked = _defaultChecked
@@ -152,10 +151,10 @@
 
   const buttonType = useResolveButtonType({
     get props() {
-      return { type: theirProps.type, as: theirProps.as }
+      return { type: theirProps.type ?? undefined, as: element ? element.tagName.toLowerCase() : DEFAULT_SWITCH_TAG }
     },
     get ref() {
-      return { current: ref }
+      return { current: element }
     },
   })
 
@@ -197,4 +196,4 @@
   />
 {/if}
 
-<ElementOrComponent {ourProps} {theirProps} {slot} defaultTag={DEFAULT_SWITCH_TAG} name="Switch" bind:ref />
+<ElementOrComponent {ourProps} {theirProps} slots={slot} defaultTag={DEFAULT_SWITCH_TAG} name="Switch" bind:element />

package/dist/switch/Switch.svelte.d.ts

@@ -1,6 +1,6 @@
-import type { ElementType, Props, PropsOf } from "../utils/types.js";
+import type { Props } from "../utils/types.js";
 declare const DEFAULT_SWITCH_TAG: "button";
-type SwitchRenderPropArg = {
+export type SwitchRenderPropArg = {
     checked: boolean;
     hover: boolean;
     focus: boolean;
@@ -9,8 +9,9 @@ type SwitchRenderPropArg = {
     changing: boolean;
     disabled: boolean;
 };
-type SwitchPropsWeControl = "aria-checked" | "aria-describedby" | "aria-labelledby" | "role";
-export type SwitchProps<TTag extends ElementType = typeof DEFAULT_SWITCH_TAG> = Props<TTag, SwitchRenderPropArg, SwitchPropsWeControl, {
+export type SwitchOwnProps = {
+    element?: HTMLElement;
+    id?: string;
     checked?: boolean;
     defaultChecked?: boolean;
     onchange?(checked: boolean): void;
@@ -20,42 +21,8 @@ export type SwitchProps<TTag extends ElementType = typeof DEFAULT_SWITCH_TAG> =
     autofocus?: boolean;
     disabled?: boolean;
     tabIndex?: number;
-}>;
-declare class __sveltets_Render<TTag extends ElementType = typeof DEFAULT_SWITCH_TAG> {
-    props(): {
-        as?: TTag | undefined;
-    } & (Exclude<keyof PropsOf<TTag>, "form" | ("as" | "children" | "refName" | "class") | "disabled" | "autofocus" | "name" | "value" | "checked" | "onchange" | "tabIndex" | "defaultChecked" | SwitchPropsWeControl> extends infer T extends keyof PropsOf<TTag> ? { [P in T]: PropsOf<TTag>[P]; } : never) & {
-        children?: import("../utils/types.js").Children<SwitchRenderPropArg> | 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: SwitchRenderPropArg) => string) | undefined;
-    } : {}) & {
-        checked?: boolean;
-        defaultChecked?: boolean;
-        onchange?(checked: boolean): void;
-        name?: string;
-        value?: string;
-        form?: string;
-        autofocus?: boolean;
-        disabled?: boolean;
-        tabIndex?: number;
-    };
-    events(): {} & {
-        [evt: string]: CustomEvent<any>;
-    };
-    slots(): {};
-    bindings(): "ref" | "checked";
-    exports(): {};
-}
-interface $$IsomorphicComponent {
-    new <TTag extends ElementType = typeof DEFAULT_SWITCH_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_SWITCH_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']>;
-}
-declare const Switch: $$IsomorphicComponent;
-type Switch<TTag extends ElementType = typeof DEFAULT_SWITCH_TAG> = InstanceType<typeof Switch<TTag>>;
+};
+export type SwitchProps = Props<typeof DEFAULT_SWITCH_TAG, SwitchRenderPropArg, SwitchOwnProps>;
+declare const Switch: import("svelte").Component<SwitchProps, {}, "element" | "checked">;
+type Switch = ReturnType<typeof Switch>;
 export default Switch;

package/dist/switch/SwitchGroup.svelte

@@ -1,16 +1,16 @@
 <script lang="ts" module>
-  import type { ElementType, Props } from "../utils/types.js"
+  import type { PropsAsChild } from "../utils/types.js"
 
   const DEFAULT_GROUP_TAG = "svelte:fragment"
 
-  export type SwitchGroupProps<TTag extends ElementType = typeof DEFAULT_GROUP_TAG> = Props<TTag>
+  export type SwitchGroupProps = PropsAsChild
 
   export type GroupContext = {
     switchElement: HTMLElement | null
   }
 </script>
 
-<script lang="ts" generics="TTag extends ElementType = typeof DEFAULT_GROUP_TAG">
+<script lang="ts">
   import { setContext } from "svelte"
   import { useLabels } from "../label/context.svelte.js"
   import { useDescriptions } from "../description/context.svelte.js"
@@ -44,7 +44,7 @@
     },
   })
 
-  let { ref = $bindable(), ...theirProps }: { as?: TTag } & SwitchGroupProps<TTag> = $props()
+  let { ...theirProps }: SwitchGroupProps = $props()
 </script>
 
-<ElementOrComponent {theirProps} defaultTag={DEFAULT_GROUP_TAG} name="SwitchGroup" bind:ref />
+<ElementOrComponent {theirProps} name="SwitchGroup" />

package/dist/switch/SwitchGroup.svelte.d.ts

@@ -1,34 +1,12 @@
-import type { ElementType, Props } from "../utils/types.js";
-declare const DEFAULT_GROUP_TAG = "svelte:fragment";
-export type SwitchGroupProps<TTag extends ElementType = typeof DEFAULT_GROUP_TAG> = Props<TTag>;
+import type { PropsAsChild } from "../utils/types.js";
+export type SwitchGroupProps = PropsAsChild;
 export type GroupContext = {
     switchElement: HTMLElement | null;
 };
-declare class __sveltets_Render<TTag extends ElementType = typeof DEFAULT_GROUP_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?: import("../utils/types.js").Children<{}> | 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: {}) => string) | undefined;
-    } : {});
-    events(): {} & {
-        [evt: string]: CustomEvent<any>;
-    };
-    slots(): {};
-    bindings(): "ref";
-    exports(): {};
-}
-interface $$IsomorphicComponent {
-    new <TTag extends ElementType = typeof DEFAULT_GROUP_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_GROUP_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']>;
-}
-declare const SwitchGroup: $$IsomorphicComponent;
-type SwitchGroup<TTag extends ElementType = typeof DEFAULT_GROUP_TAG> = InstanceType<typeof SwitchGroup<TTag>>;
+declare const SwitchGroup: import("svelte").Component<{
+    children?: import("svelte").Snippet<[{
+        props?: Record<string, any>;
+    }]> | undefined;
+}, {}, "">;
+type SwitchGroup = ReturnType<typeof SwitchGroup>;
 export default SwitchGroup;

package/dist/switch/index.d.ts

@@ -1,2 +1,2 @@
-export { default as Switch, type SwitchProps } from "./Switch.svelte";
+export { default as Switch, type SwitchProps, type SwitchRenderPropArg as SwitchSlot, type SwitchOwnProps, } from "./Switch.svelte";
 export { default as SwitchGroup, type SwitchGroupProps } from "./SwitchGroup.svelte";

package/dist/switch/index.js

@@ -1,2 +1,2 @@
-export { default as Switch } from "./Switch.svelte";
+export { default as Switch, } from "./Switch.svelte";
 export { default as SwitchGroup } from "./SwitchGroup.svelte";