lithesome 0.7.3 → 0.8.0

package/dist/components/Accordion/Accordion.svelte

@@ -5,7 +5,14 @@ export const { context, contextName } = setupContext();
 
 <script lang="ts">import { useActions, classProp } from "../../internal/index.js";
 import { setContext } from "svelte";
-let { children, use = [], class: klass, self = $bindable(), single = $bindable(false), ...props } = $props();
+let {
+  children,
+  use = [],
+  class: klass,
+  self = $bindable(),
+  single = $bindable(false),
+  ...props
+} = $props();
 const ctx = new AccordionContext({ single });
 const active = $derived(ctx.activeItems.length > 0);
 setContext(contextName, ctx);

package/dist/components/Accordion/Accordion.svelte.d.ts

@@ -1,21 +1,17 @@
 import { SvelteComponent } from "svelte";
 import { AccordionContext } from './context.svelte.js';
 export declare const context: () => AccordionContext, contextName: string;
-import { type BaseProps } from '../../internal/index.js';
+import type { AccordionProps } from './types.js';
 declare const __propDef: {
-    props: BaseProps<HTMLDivElement, {
-        active: boolean;
-    }> & {
-        single?: boolean | undefined;
-    };
+    props: AccordionProps;
     events: {
         [evt: string]: CustomEvent<any>;
     };
     slots: {};
 };
-export type AccordionProps = typeof __propDef.props;
+type AccordionProps_ = typeof __propDef.props;
+export { AccordionProps_ as AccordionProps };
 export type AccordionEvents = typeof __propDef.events;
 export type AccordionSlots = typeof __propDef.slots;
-export default class Accordion extends SvelteComponent<AccordionProps, AccordionEvents, AccordionSlots> {
+export default class Accordion extends SvelteComponent<AccordionProps_, AccordionEvents, AccordionSlots> {
 }
-export {};

package/dist/components/Accordion/AccordionButton.svelte.d.ts

@@ -5,6 +5,11 @@ declare const __propDef: {
         active: boolean;
         disabled: boolean;
     }> & {
+        /**
+         * The onclick event.
+         *
+         * Using the regular `onclick` will overwrite and behaviour the component requires.
+         */
         onClick?: Handler<MouseEvent, HTMLButtonElement> | undefined;
     };
     events: {

package/dist/components/Accordion/AccordionContent.svelte

@@ -5,7 +5,7 @@ let { children, class: klass, use = [], self = $bindable(), transition, ...props
 const ctx = context();
 const itemId = getContext("accordionitem-id");
 const active = $derived(ctx.activeItems.includes(itemId));
-const _transition = getTransition(transition);
+const { inTransition, outTransition } = getTransition(transition);
 const attrs = $derived({
   id: ctx.uid("content"),
   "data-accordioncontent": "",
@@ -14,19 +14,12 @@ const attrs = $derived({
 });
 </script>
 
-{#if _transition}
-	{#if active}
-		<div
-			bind:this={self}
-			use:useActions={use}
-			in:_transition.in.fn={_transition.in.params}
-			out:_transition.out.fn={_transition.out.params}
-			{...attrs}
-			{...props}
-		>
-			{@render children({ active })}
-		</div>
-	{/if}
+{#if inTransition && outTransition && active}
+	{@const { config: inConf, transition: inFn } = inTransition}
+	{@const { config: outConf, transition: outFn } = outTransition}
+	<div bind:this={self} use:useActions={use} in:inFn={inConf} out:outFn={outConf} {...attrs} {...props}>
+		{@render children({ active })}
+	</div>
 {:else if active}
 	<div bind:this={self} use:useActions={use} {...attrs} {...props}>
 		{@render children({ active })}

package/dist/components/Accordion/AccordionContent.svelte.d.ts

@@ -1,24 +1,15 @@
 import { SvelteComponent } from "svelte";
-import { type BaseProps, type Transition } from '../../internal/index.js';
+import type { AccordionContentProps } from './types.js';
 declare const __propDef: {
-    props: BaseProps<HTMLDivElement, {
-        active: boolean;
-    }> & {
-        /**
-         * The `svelte/transtion` you wish to use.
-         *
-         * @see https://lithesome.dev/docs/api#transition-prop
-         */
-        transition?: Transition | undefined;
-    };
+    props: AccordionContentProps;
     events: {
         [evt: string]: CustomEvent<any>;
     };
     slots: {};
 };
-export type AccordionContentProps = typeof __propDef.props;
+type AccordionContentProps_ = typeof __propDef.props;
+export { AccordionContentProps_ as AccordionContentProps };
 export type AccordionContentEvents = typeof __propDef.events;
 export type AccordionContentSlots = typeof __propDef.slots;
-export default class AccordionContent extends SvelteComponent<AccordionContentProps, AccordionContentEvents, AccordionContentSlots> {
+export default class AccordionContent extends SvelteComponent<AccordionContentProps_, AccordionContentEvents, AccordionContentSlots> {
 }
-export {};

package/dist/components/Accordion/AccordionHeading.svelte.d.ts

@@ -1,17 +1,15 @@
 import { SvelteComponent } from "svelte";
-import { type BaseProps } from '../../internal/index.js';
+import type { AccordionHeadingProps } from './types.js';
 declare const __propDef: {
-    props: BaseProps<HTMLDivElement, any> & {
-        level?: 1 | 2 | 3 | 4 | 5 | 6 | undefined;
-    };
+    props: AccordionHeadingProps;
     events: {
         [evt: string]: CustomEvent<any>;
     };
     slots: {};
 };
-export type AccordionHeadingProps = typeof __propDef.props;
+type AccordionHeadingProps_ = typeof __propDef.props;
+export { AccordionHeadingProps_ as AccordionHeadingProps };
 export type AccordionHeadingEvents = typeof __propDef.events;
 export type AccordionHeadingSlots = typeof __propDef.slots;
-export default class AccordionHeading extends SvelteComponent<AccordionHeadingProps, AccordionHeadingEvents, AccordionHeadingSlots> {
+export default class AccordionHeading extends SvelteComponent<AccordionHeadingProps_, AccordionHeadingEvents, AccordionHeadingSlots> {
 }
-export {};

package/dist/components/Accordion/AccordionItem.svelte

@@ -1,7 +1,14 @@
 <script lang="ts">import { context } from "./Accordion.svelte";
 import { log, useActions, createUID, classProp } from "../../internal/index.js";
 import { onMount, setContext } from "svelte";
-let { children, class: klass, use = [], self = $bindable(), disabled = $bindable(false), ...props } = $props();
+let {
+  children,
+  class: klass,
+  use = [],
+  self = $bindable(),
+  disabled = $bindable(false),
+  ...props
+} = $props();
 const ctx = context();
 const { uid } = createUID("item");
 const active = $derived(ctx.activeItems.includes(uid()));

package/dist/components/Accordion/AccordionItem.svelte.d.ts

@@ -1,20 +1,15 @@
 import { SvelteComponent } from "svelte";
-import { type BaseProps } from '../../internal/index.js';
+import type { AccordionItemProps } from './types.js';
 declare const __propDef: {
-    props: BaseProps<HTMLDivElement, {
-        active: boolean;
-        disabled: boolean;
-    }> & {
-        disabled?: boolean | undefined;
-    };
+    props: AccordionItemProps;
     events: {
         [evt: string]: CustomEvent<any>;
     };
     slots: {};
 };
-export type AccordionItemProps = typeof __propDef.props;
+type AccordionItemProps_ = typeof __propDef.props;
+export { AccordionItemProps_ as AccordionItemProps };
 export type AccordionItemEvents = typeof __propDef.events;
 export type AccordionItemSlots = typeof __propDef.slots;
-export default class AccordionItem extends SvelteComponent<AccordionItemProps, AccordionItemEvents, AccordionItemSlots> {
+export default class AccordionItem extends SvelteComponent<AccordionItemProps_, AccordionItemEvents, AccordionItemSlots> {
 }
-export {};

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

@@ -3,3 +3,4 @@ export { default as AccordionHeading } from './AccordionHeading.svelte';
 export { default as AccordionItem } from './AccordionItem.svelte';
 export { default as AccordionButton } from './AccordionButton.svelte';
 export { default as AccordionContent } from './AccordionContent.svelte';
+export type * from './types.js';

package/dist/components/Accordion/types.d.ts

@@ -0,0 +1,45 @@
+import type { BaseProps, Handler, Transition } from '../../internal/index.js';
+interface AccordionState {
+    /** True if any item is opened. */
+    active: boolean;
+}
+export interface AccordionProps extends BaseProps<HTMLDivElement, AccordionState> {
+    /** Allow only a singluar `AccordionItem` to be opened at once. */
+    single?: boolean;
+}
+interface AccordionContentState {
+    /** True if any item is opened. */
+    active: boolean;
+}
+export interface AccordionContentProps extends BaseProps<HTMLDivElement, AccordionContentState> {
+    /**
+     * The `svelte/transtion` you wish to use.
+     *
+     * @see https://lithesome.dev/docs/api#transition-prop
+     */
+    transition?: Transition;
+}
+export interface AccordionHeadingProps extends BaseProps<HTMLDivElement> {
+    /** The `aria-level` to be set. */
+    level?: 1 | 2 | 3 | 4 | 5 | 6;
+}
+interface AccordionButtonState {
+    /** True if the item is opened. */
+    active: boolean;
+    /** True if the item is disabled. */
+    disabled: boolean;
+}
+export interface AccordionButtonProps extends BaseProps<HTMLButtonElement, AccordionButtonState> {
+    onClick?: Handler<MouseEvent, HTMLButtonElement>;
+}
+interface AccordionItemState {
+    /** True if the item is opened. */
+    active: boolean;
+    /** True if the item is disabled. */
+    disabled: boolean;
+}
+export interface AccordionItemProps extends BaseProps<HTMLDivElement, AccordionItemState> {
+    /** Disables the items, disallowing clicking and keyboard navigation. */
+    disabled?: boolean;
+}
+export {};

package/dist/components/Accordion/types.js

@@ -0,0 +1 @@
+export {};

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

@@ -1 +1,2 @@
 export { default as Checkbox } from './Checkbox.svelte';
+export type * from './types.js';

package/dist/components/Checkbox/types.d.ts

@@ -0,0 +1,16 @@
+import type { BaseProps, Handler, Optional } from '../../internal/types.js';
+type Checked = boolean | 'mixed';
+interface CheckboxState {
+    /** If the checkbox is checked or not. */
+    checked: Checked;
+}
+export interface CheckboxProps extends Optional<BaseProps<HTMLButtonElement, CheckboxState>, 'children'> {
+    /** If the checkbox is checked or not. */
+    checked?: Checked;
+    /** Adds aria attributes. */
+    required?: boolean;
+    /** Disabled the checkbox, disallowing the internal events. */
+    disabled?: boolean;
+    onClick?: Handler<MouseEvent, HTMLButtonElement>;
+}
+export {};

package/dist/components/Checkbox/types.js

@@ -0,0 +1 @@
+export {};

package/dist/components/Combobox/Combobox.svelte.d.ts

@@ -1,27 +1,17 @@
 import { SvelteComponent } from "svelte";
 import { ComboboxContext } from './context.svelte.js';
 export declare const context: () => ComboboxContext<any>, contextName: string;
-import { type BaseProps } from '../../internal/index.js';
+import type { ComboboxProps } from './types.js';
 declare class __sveltets_Render<ValueType> {
-    props(): BaseProps<HTMLDivElement, {
-        visible: boolean;
-    }> & {
-        value: ValueType;
-        label?: string | undefined;
-        touched?: boolean | undefined;
-        onChange?: ((payload?: {
-            value?: ValueType | undefined;
-            label?: string | undefined;
-        } | undefined) => void) | undefined;
-    };
+    props(): ComboboxProps<ValueType>;
     events(): {} & {
         [evt: string]: CustomEvent<any>;
     };
     slots(): {};
 }
-export type ComboboxProps<ValueType> = ReturnType<__sveltets_Render<ValueType>['props']>;
+export type ComboboxProps_<ValueType> = ReturnType<__sveltets_Render<ValueType>['props']>;
 export type ComboboxEvents<ValueType> = ReturnType<__sveltets_Render<ValueType>['events']>;
 export type ComboboxSlots<ValueType> = ReturnType<__sveltets_Render<ValueType>['slots']>;
-export default class Combobox<ValueType> extends SvelteComponent<ComboboxProps<ValueType>, ComboboxEvents<ValueType>, ComboboxSlots<ValueType>> {
+export default class Combobox<ValueType> extends SvelteComponent<ComboboxProps_<ValueType>, ComboboxEvents<ValueType>, ComboboxSlots<ValueType>> {
 }
 export {};

package/dist/components/Combobox/ComboboxArrow.svelte.d.ts

@@ -1,17 +1,15 @@
 import { SvelteComponent } from "svelte";
-import { type BasePropsNoChildren } from '../../internal/index.js';
+import type { ComboboxArrowProps } from './types.js';
 declare const __propDef: {
-    props: BasePropsNoChildren<HTMLDivElement, {
-        visible: boolean;
-    }>;
+    props: ComboboxArrowProps;
     events: {
         [evt: string]: CustomEvent<any>;
     };
     slots: {};
 };
-export type ComboboxArrowProps = typeof __propDef.props;
+type ComboboxArrowProps_ = typeof __propDef.props;
+export { ComboboxArrowProps_ as ComboboxArrowProps };
 export type ComboboxArrowEvents = typeof __propDef.events;
 export type ComboboxArrowSlots = typeof __propDef.slots;
-export default class ComboboxArrow extends SvelteComponent<ComboboxArrowProps, ComboboxArrowEvents, ComboboxArrowSlots> {
+export default class ComboboxArrow extends SvelteComponent<ComboboxArrowProps_, ComboboxArrowEvents, ComboboxArrowSlots> {
 }
-export {};

package/dist/components/Combobox/ComboboxContent.svelte

@@ -1,12 +1,5 @@
 <script lang="ts">import { context } from "./Combobox.svelte";
-import {
-  clickOutside,
-  anchorElement,
-  portal,
-  useActions,
-  getTransition,
-  classProp
-} from "../../internal/index.js";
+import { clickOutside, anchorElement, portal, useActions, getTransition, classProp } from "../../internal/index.js";
 import { log } from "../../internal/index.js";
 import { onMount } from "svelte";
 let {
@@ -23,7 +16,7 @@ let {
 } = $props();
 const ctx = context();
 let contentCleanup = $state(void 0);
-const _transition = getTransition(transition);
+const { inTransition, outTransition } = getTransition(transition);
 const attrs = $derived({
   id: ctx.uid("content"),
   "aria-labelledby": ctx.uid("trigger"),
@@ -61,29 +54,29 @@ $effect(() => {
 });
 </script>
 
-{#if _transition}
-	{#if ctx.visible}
-		<div
-			bind:this={self}
-			use:clickOutside={{
-				exclude: [ctx.trigger],
-				callback: () => ctx.close()
-			}}
-			use:portal={portalTarget}
-			use:useActions={use}
-			in:_transition.in.fn={_transition.in.params}
-			out:_transition.out.fn={_transition.out.params}
-			{...attrs}
-			{...props}
-		>
-			{@render children({ visible: ctx.visible })}
-		</div>
-	{/if}
+{#if inTransition && outTransition && ctx.visible}
+	{@const { config: inConf, transition: inFn } = inTransition}
+	{@const { config: outConf, transition: outFn } = outTransition}
+	<div
+		bind:this={self}
+		use:clickOutside={{
+			exclude: ctx.trigger,
+			callback: () => ctx.close()
+		}}
+		use:portal={portalTarget}
+		use:useActions={use}
+		in:inFn={inConf}
+		out:outFn={outConf}
+		{...attrs}
+		{...props}
+	>
+		{@render children({ visible: ctx.visible })}
+	</div>
 {:else if ctx.visible}
 	<div
 		bind:this={self}
 		use:clickOutside={{
-			exclude: [ctx.trigger],
+			exclude: ctx.trigger,
 			callback: () => ctx.close()
 		}}
 		use:portal={portalTarget}

package/dist/components/Combobox/ComboboxContent.svelte.d.ts

@@ -1,17 +1,15 @@
 import { SvelteComponent } from "svelte";
-import { type BaseProps, type ContentProps } from '../../internal/index.js';
+import type { ComboboxContentProps } from './types.js';
 declare const __propDef: {
-    props: BaseProps<HTMLDivElement, {
-        visible: boolean;
-    }> & ContentProps;
+    props: ComboboxContentProps;
     events: {
         [evt: string]: CustomEvent<any>;
     };
     slots: {};
 };
-export type ComboboxContentProps = typeof __propDef.props;
+type ComboboxContentProps_ = typeof __propDef.props;
+export { ComboboxContentProps_ as ComboboxContentProps };
 export type ComboboxContentEvents = typeof __propDef.events;
 export type ComboboxContentSlots = typeof __propDef.slots;
-export default class ComboboxContent extends SvelteComponent<ComboboxContentProps, ComboboxContentEvents, ComboboxContentSlots> {
+export default class ComboboxContent extends SvelteComponent<ComboboxContentProps_, ComboboxContentEvents, ComboboxContentSlots> {
 }
-export {};

package/dist/components/Combobox/ComboboxInput.svelte

@@ -1,10 +1,5 @@
 <script lang="ts">import { context } from "./Combobox.svelte";
-import {
-  useActions,
-  classProp,
-  PREVENT_KEYS,
-  KEYS
-} from "../../internal/index.js";
+import { useActions, classProp, PREVENT_KEYS, KEYS } from "../../internal/index.js";
 import { onMount } from "svelte";
 let {
   class: klass,

package/dist/components/Combobox/ComboboxInput.svelte.d.ts

@@ -1,23 +1,15 @@
 import { SvelteComponent } from "svelte";
-import { type BasePropsNoChildren, type Handler } from '../../internal/index.js';
+import type { ComboboxInputProps } from './types.js';
 declare const __propDef: {
-    props: BasePropsNoChildren<HTMLInputElement, {
-        visible: boolean;
-    }> & {
-        value: string;
-        disabled?: boolean | undefined;
-        onClick?: Handler<MouseEvent, HTMLInputElement> | undefined;
-        onFocus?: Handler<FocusEvent, HTMLInputElement> | undefined;
-        onKeydown?: Handler<KeyboardEvent, HTMLInputElement> | undefined;
-    };
+    props: ComboboxInputProps;
     events: {
         [evt: string]: CustomEvent<any>;
     };
     slots: {};
 };
-export type ComboboxInputProps = typeof __propDef.props;
+type ComboboxInputProps_ = typeof __propDef.props;
+export { ComboboxInputProps_ as ComboboxInputProps };
 export type ComboboxInputEvents = typeof __propDef.events;
 export type ComboboxInputSlots = typeof __propDef.slots;
-export default class ComboboxInput extends SvelteComponent<ComboboxInputProps, ComboboxInputEvents, ComboboxInputSlots> {
+export default class ComboboxInput extends SvelteComponent<ComboboxInputProps_, ComboboxInputEvents, ComboboxInputSlots> {
 }
-export {};

package/dist/components/Combobox/ComboboxOption.svelte

@@ -1,9 +1,5 @@
 <script lang="ts">import { context } from "./Combobox.svelte";
-import {
-  useActions,
-  classProp,
-  isBrowser
-} from "../../internal/index.js";
+import { useActions, classProp, isBrowser } from "../../internal/index.js";
 import { createUID } from "../../internal/index.js";
 import { onMount, tick } from "svelte";
 let {

package/dist/components/Combobox/ComboboxOption.svelte.d.ts

@@ -1,25 +1,15 @@
 import { SvelteComponent } from "svelte";
-import { type BaseProps, type JsonValue, type Handler } from '../../internal/index.js';
+import type { ComboboxOptionProps } from './types.js';
 declare const __propDef: {
-    props: BaseProps<HTMLButtonElement | HTMLAnchorElement, {
-        hovered: boolean;
-        selected: boolean;
-    }> & {
-        value: JsonValue;
-        disabled?: boolean | undefined;
-        label?: string | undefined;
-        onClick?: Handler<MouseEvent, HTMLButtonElement | HTMLAnchorElement> | undefined;
-        onFocus?: Handler<FocusEvent, HTMLButtonElement | HTMLAnchorElement> | undefined;
-        onMouseenter?: Handler<MouseEvent, HTMLButtonElement | HTMLAnchorElement> | undefined;
-    };
+    props: ComboboxOptionProps;
     events: {
         [evt: string]: CustomEvent<any>;
     };
     slots: {};
 };
-export type ComboboxOptionProps = typeof __propDef.props;
+type ComboboxOptionProps_ = typeof __propDef.props;
+export { ComboboxOptionProps_ as ComboboxOptionProps };
 export type ComboboxOptionEvents = typeof __propDef.events;
 export type ComboboxOptionSlots = typeof __propDef.slots;
-export default class ComboboxOption extends SvelteComponent<ComboboxOptionProps, ComboboxOptionEvents, ComboboxOptionSlots> {
+export default class ComboboxOption extends SvelteComponent<ComboboxOptionProps_, ComboboxOptionEvents, ComboboxOptionSlots> {
 }
-export {};

package/dist/components/Combobox/context.svelte.d.ts

@@ -1,4 +1,4 @@
-import { Context, type CalcIndexAction, type JsonValue } from '../../internal/index.js';
+import { FloatingContext, type CalcIndexAction, type JsonValue } from '../../internal/index.js';
 export interface Option {
     value: JsonValue;
     label: string;
@@ -15,7 +15,7 @@ interface Hooks<ValueType> {
         newLabel?: string;
     }) => void;
 }
-export declare class ComboboxContext<ValueType = any> extends Context<Hooks<ValueType>, HTMLInputElement> {
+export declare class ComboboxContext<ValueType = any> extends FloatingContext<Hooks<ValueType>, HTMLInputElement> {
     #private;
     visible: boolean;
     hoveredIndex: number;

package/dist/components/Combobox/context.svelte.js

@@ -1,6 +1,6 @@
-import { calculateIndex, disableScroll, removeDisabledElements, Context, effects } from '../../internal/index.js';
+import { calculateIndex, disableScroll, removeDisabledElements, FloatingContext, effects } from '../../internal/index.js';
 import { tick } from 'svelte';
-export class ComboboxContext extends Context {
+export class ComboboxContext extends FloatingContext {
     visible = $state(true);
     hoveredIndex = $state(-1);
     options = $state([]);

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

@@ -3,3 +3,4 @@ export { default as ComboboxContent } from './ComboboxContent.svelte';
 export { default as ComboboxInput } from './ComboboxInput.svelte';
 export { default as ComboboxOption } from './ComboboxOption.svelte';
 export { default as ComboboxArrow } from './ComboboxArrow.svelte';
+export type * from './types.js';

package/dist/components/Combobox/types.d.ts

@@ -0,0 +1,53 @@
+import type { BaseProps, BasePropsNoChildren, ContentProps, Handler, JsonValue } from '../../internal/types.js';
+export type ComboboxElement = HTMLAnchorElement | HTMLButtonElement;
+interface ComboboxState {
+    /** Whether or not the content is opened or not. */
+    visible: boolean;
+}
+export interface ComboboxProps<T> extends BaseProps<HTMLDivElement, ComboboxState> {
+    /** The value of the combobox. */
+    value: T;
+    /** The label of the selected item. */
+    label?: string;
+    /** If the user has modified the selected value in anyway. */
+    touched?: boolean;
+    onChange?: (payload?: {
+        value?: T;
+        label?: string;
+    }) => void;
+}
+export interface ComboboxArrowProps extends BasePropsNoChildren<HTMLDivElement, ComboboxState> {
+}
+export interface ComboboxContentProps extends BaseProps<HTMLDivElement, ComboboxState>, ContentProps {
+}
+export interface ComboboxInputProps extends BasePropsNoChildren<HTMLInputElement, ComboboxState> {
+    /** Bind the value of the input value. */
+    value: string;
+    /** Disables the input. */
+    disabled?: boolean;
+    onClick?: Handler<MouseEvent, HTMLInputElement>;
+    onFocus?: Handler<FocusEvent, HTMLInputElement>;
+    onKeydown?: Handler<KeyboardEvent, HTMLInputElement>;
+}
+interface ComboboxOptionState {
+    /** If the option is hovered, either via mouse or keyboard. */
+    hovered: boolean;
+    /** If the option is selected. */
+    selected: boolean;
+}
+export interface ComboboxOptionProps extends BaseProps<ComboboxElement, ComboboxOptionState> {
+    /** The value of the option. */
+    value: JsonValue;
+    /** Disables the option. */
+    disabled?: boolean;
+    /**
+     * Label of the option.
+     *
+     * If this prop is not provided, the text content will be used.
+     */
+    label?: string;
+    onClick?: Handler<MouseEvent, ComboboxElement>;
+    onFocus?: Handler<FocusEvent, ComboboxElement>;
+    onMouseenter?: Handler<MouseEvent, ComboboxElement>;
+}
+export {};

package/dist/components/Combobox/types.js

@@ -0,0 +1 @@
+export {};

package/dist/components/Hovercard/Hovercard.svelte.d.ts

@@ -1,26 +1,17 @@
 import { SvelteComponent } from "svelte";
 import { HovercardContext } from './context.svelte.js';
 export declare const context: () => HovercardContext, contextName: string;
-import { type BaseProps } from '../../internal/index.js';
+import type { HovercardProps } from './types.js';
 declare const __propDef: {
-    props: BaseProps<HTMLDivElement, {
-        visible: boolean;
-    }> & {
-        /**
-         * The delay between the the content being visible or not.
-         *
-         * Passing an array will allow you to change the delays for in and out.
-         */
-        delay?: number | [number, number] | undefined;
-    };
+    props: HovercardProps;
     events: {
         [evt: string]: CustomEvent<any>;
     };
     slots: {};
 };
-export type HovercardProps = typeof __propDef.props;
+type HovercardProps_ = typeof __propDef.props;
+export { HovercardProps_ as HovercardProps };
 export type HovercardEvents = typeof __propDef.events;
 export type HovercardSlots = typeof __propDef.slots;
-export default class Hovercard extends SvelteComponent<HovercardProps, HovercardEvents, HovercardSlots> {
+export default class Hovercard extends SvelteComponent<HovercardProps_, HovercardEvents, HovercardSlots> {
 }
-export {};