@johly/bits-ui 2.18.1

package/dist/bits/menu/types.d.ts

@@ -0,0 +1,215 @@
+import type { Expand } from "svelte-toolbelt";
+import type { PopperLayerProps, PopperLayerStaticProps } from "../utilities/popper-layer/types.js";
+import type { ArrowProps, ArrowPropsWithoutHTML } from "../utilities/arrow/types.js";
+import type { OnChangeFn, WithChild, WithChildNoChildrenSnippetProps, WithChildren, Without } from "../../internal/types.js";
+import type { BitsPrimitiveButtonAttributes, BitsPrimitiveDivAttributes } from "../../shared/attributes.js";
+import type { Direction } from "../../shared/index.js";
+import type { PortalProps } from "../utilities/portal/types.js";
+import type { FloatingContentSnippetProps, StaticContentSnippetProps } from "../../shared/types.js";
+import type { Align } from "../utilities/floating-layer/use-floating-layer.svelte.js";
+export type MenuRootPropsWithoutHTML = WithChildren<{
+    /**
+     * The open state of the menu.
+     */
+    open?: boolean;
+    /**
+     * A callback that is called when the menu is opened or closed.
+     */
+    onOpenChange?: OnChangeFn<boolean>;
+    /**
+     * A callback that is called when the menu is opened or closed.
+     */
+    onOpenChangeComplete?: OnChangeFn<boolean>;
+    /**
+     * The direction of the site.
+     *
+     * @defaultValue "ltr"
+     */
+    dir?: Direction;
+}>;
+export type MenuRootProps = MenuRootPropsWithoutHTML;
+export type _SharedMenuContentProps = {
+    /**
+     * When `true`, the menu will loop through items when navigating with the keyboard.
+     *
+     * @defaultValue false
+     */
+    loop?: boolean;
+};
+export type MenuContentPropsWithoutHTML = Expand<WithChildNoChildrenSnippetProps<Omit<PopperLayerProps, "content"> & _SharedMenuContentProps, FloatingContentSnippetProps>>;
+export type MenuContentProps = MenuContentPropsWithoutHTML & Without<BitsPrimitiveDivAttributes, MenuContentPropsWithoutHTML>;
+export type MenuContentStaticPropsWithoutHTML = Expand<WithChildNoChildrenSnippetProps<Omit<PopperLayerStaticProps, "content"> & _SharedMenuContentProps, StaticContentSnippetProps>>;
+export type MenuContentStaticProps = MenuContentStaticPropsWithoutHTML & Without<BitsPrimitiveDivAttributes, MenuContentStaticPropsWithoutHTML>;
+export type MenuItemPropsWithoutHTML<U extends Record<PropertyKey, unknown> = {
+    _default: never;
+}> = WithChild<{
+    /**
+     * When `true`, the user will not be able to interact with the menu item.
+     *
+     * @defaultValue false
+     */
+    disabled?: boolean;
+    /**
+     * Optional text to use for typeahead filtering. By default, typeahead will use
+     * the `.textContent` of the menu item. When the content is more complex, you
+     * can provide a string here instead.
+     *
+     * @defaultValue undefined
+     */
+    textValue?: string;
+    /**
+     * A callback fired when the menu item is selected.
+     *
+     * Prevent default behavior of selection with `event.preventDefault()`.
+     */
+    onSelect?: (event: Event) => void;
+    /**
+     * Whether or not the menu item should close when selected.
+     * @defaultValue true
+     */
+    closeOnSelect?: boolean;
+}, U>;
+export type MenuItemProps = MenuItemPropsWithoutHTML & Without<BitsPrimitiveDivAttributes, MenuItemPropsWithoutHTML>;
+export type MenuCheckboxItemSnippetProps = {
+    checked: boolean;
+    indeterminate: boolean;
+};
+export type MenuCheckboxItemPropsWithoutHTML = MenuItemPropsWithoutHTML<MenuCheckboxItemSnippetProps> & {
+    /**
+     * The checked state of the checkbox. It can be one of:
+     * - `true` for checked
+     * - `false` for unchecked
+     *
+     * @defaultValue false
+     */
+    checked?: boolean;
+    /**
+     * A callback that is fired when the checked state changes.
+     */
+    onCheckedChange?: OnChangeFn<boolean>;
+    /**
+     * Whether the checkbox is in an indeterminate state or not.
+     *
+     * @defaultValue false
+     */
+    indeterminate?: boolean;
+    /**
+     * A callback function called when the indeterminate state changes.
+     */
+    onIndeterminateChange?: OnChangeFn<boolean>;
+    /**
+     * Whether or not the menu item should close when selected.
+     *
+     * @defaultValue true
+     */
+    closeOnSelect?: boolean;
+    /**
+     * The value of the checkbox item when used in a checkbox group.
+     */
+    value?: string;
+};
+export type MenuCheckboxItemProps = MenuCheckboxItemPropsWithoutHTML & Without<BitsPrimitiveDivAttributes, MenuCheckboxItemPropsWithoutHTML>;
+export type MenuCheckboxGroupPropsWithoutHTML = WithChild<{
+    /**
+     * The values of the selected checkbox items.
+     *
+     * Supports two-way binding with `bind:value`.
+     */
+    value?: string[];
+    /**
+     * A callback that is fired when the selected checkbox items change.
+     */
+    onValueChange?: OnChangeFn<string[]>;
+}>;
+export type MenuCheckboxGroupProps = MenuCheckboxGroupPropsWithoutHTML & Without<BitsPrimitiveDivAttributes, MenuCheckboxGroupPropsWithoutHTML>;
+export type MenuTriggerPropsWithoutHTML = WithChild<{
+    /**
+     * Whether the trigger is disabled.
+     *
+     * @defaultValue false
+     */
+    disabled?: boolean | null | undefined;
+}>;
+export type MenuTriggerProps = MenuTriggerPropsWithoutHTML & Without<BitsPrimitiveButtonAttributes, MenuTriggerPropsWithoutHTML>;
+export type MenuSubPropsWithoutHTML = WithChildren<{
+    /**
+     * The open state of the menu.
+     */
+    open?: boolean;
+    /**
+     * A callback that is called when the menu is opened or closed.
+     */
+    onOpenChange?: OnChangeFn<boolean>;
+    /**
+     * A callback that is called when the menu finishes opening/closing animations.
+     */
+    onOpenChangeComplete?: OnChangeFn<boolean>;
+}>;
+export type MenuSubProps = MenuSubPropsWithoutHTML;
+export type MenuSubContentPropsWithoutHTML = Expand<WithChildNoChildrenSnippetProps<Omit<PopperLayerProps, "content" | "preventScroll" | "align"> & _SharedMenuContentProps & {
+    /**
+     * Use `"list"` to align a submenu's first navigable row with its trigger row.
+     *
+     * @defaultValue "start"
+     */
+    align?: Align | "list";
+    /**
+     * Called when the floating submenu has been positioned.
+     */
+    onPlaced?: () => void;
+}, FloatingContentSnippetProps>>;
+export type MenuSubContentProps = MenuSubContentPropsWithoutHTML & Without<BitsPrimitiveDivAttributes, MenuSubContentPropsWithoutHTML>;
+export type MenuSubContentStaticPropsWithoutHTML = Expand<WithChildNoChildrenSnippetProps<Omit<PopperLayerStaticProps, "content" | "preventScroll"> & _SharedMenuContentProps, StaticContentSnippetProps>>;
+export type MenuSubContentStaticProps = MenuSubContentStaticPropsWithoutHTML & Without<BitsPrimitiveDivAttributes, MenuSubContentStaticPropsWithoutHTML>;
+export type MenuSubTriggerPropsWithoutHTML = Omit<MenuItemPropsWithoutHTML, "closeOnSelect"> & {
+    /**
+     * The amount of time in ms from when the mouse enters the subtrigger until
+     * the submenu opens. This is useful for preventing the submenu from opening
+     * as a user is moving their mouse through the menu without a true intention to open that
+     * submenu.
+     *
+     * To disable the behavior, set it to `0`.
+     *
+     * @default 100
+     */
+    openDelay?: number;
+};
+export type MenuSubTriggerProps = MenuSubTriggerPropsWithoutHTML & Without<BitsPrimitiveDivAttributes, MenuSubTriggerPropsWithoutHTML>;
+export type MenuSeparatorPropsWithoutHTML = WithChild;
+export type MenuSeparatorProps = MenuSeparatorPropsWithoutHTML & Without<BitsPrimitiveDivAttributes, MenuSeparatorPropsWithoutHTML>;
+export type MenuArrowPropsWithoutHTML = ArrowPropsWithoutHTML;
+export type MenuArrowProps = ArrowProps;
+export type MenuGroupPropsWithoutHTML = WithChild;
+export type MenuGroupProps = MenuGroupPropsWithoutHTML & Without<BitsPrimitiveDivAttributes, MenuGroupPropsWithoutHTML>;
+export type MenuGroupHeadingPropsWithoutHTML = WithChild;
+export type MenuGroupHeadingProps = MenuGroupHeadingPropsWithoutHTML & Without<BitsPrimitiveDivAttributes, MenuGroupHeadingPropsWithoutHTML>;
+export type MenuRadioGroupPropsWithoutHTML = WithChild<{
+    /**
+     * The value of the selected radio item.
+     *
+     * Supports two-way binding with `bind:value`.
+     */
+    value?: string;
+    /**
+     * A callback that is fired when the selected radio item changes.
+     */
+    onValueChange?: OnChangeFn<string>;
+}>;
+export type MenuRadioGroupProps = MenuRadioGroupPropsWithoutHTML & Without<BitsPrimitiveDivAttributes, MenuRadioGroupPropsWithoutHTML>;
+export type MenuRadioItemSnippetProps = {
+    checked: boolean;
+};
+export type MenuRadioItemPropsWithoutHTML = MenuItemPropsWithoutHTML<MenuRadioItemSnippetProps> & {
+    /**
+     * The value of the radio item.
+     */
+    value: string;
+    /**
+     * Whether or not the menu item should close when selected.
+     * @defaultValue true
+     */
+    closeOnSelect?: boolean;
+};
+export type MenuRadioItemProps = MenuRadioItemPropsWithoutHTML & Without<BitsPrimitiveDivAttributes, MenuRadioItemPropsWithoutHTML>;
+export type MenuPortalPropsWithoutHTML = PortalProps;
+export type MenuPortalProps = MenuPortalPropsWithoutHTML;

package/dist/bits/menu/types.js

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

package/dist/bits/menu/utils.d.ts

@@ -0,0 +1,11 @@
+import type { Direction } from "../../shared/index.js";
+export type CheckedState = boolean | "indeterminate";
+export declare const SELECTION_KEYS: string[];
+export declare const FIRST_KEYS: string[];
+export declare const LAST_KEYS: string[];
+export declare const FIRST_LAST_KEYS: string[];
+export declare const SUB_OPEN_KEYS: Record<Direction, string[]>;
+export declare const SUB_CLOSE_KEYS: Record<Direction, string[]>;
+export declare function isIndeterminate(checked?: CheckedState): checked is "indeterminate";
+export declare function getCheckedState(checked: CheckedState): "checked" | "unchecked" | "indeterminate";
+export declare function isMouseEvent(event: PointerEvent): boolean;

package/dist/bits/menu/utils.js

@@ -0,0 +1,22 @@
+import { kbd } from "../../internal/kbd.js";
+export const SELECTION_KEYS = [kbd.ENTER, kbd.SPACE];
+export const FIRST_KEYS = [kbd.ARROW_DOWN, kbd.PAGE_UP, kbd.HOME];
+export const LAST_KEYS = [kbd.ARROW_UP, kbd.PAGE_DOWN, kbd.END];
+export const FIRST_LAST_KEYS = [...FIRST_KEYS, ...LAST_KEYS];
+export const SUB_OPEN_KEYS = {
+    ltr: [...SELECTION_KEYS, kbd.ARROW_RIGHT],
+    rtl: [...SELECTION_KEYS, kbd.ARROW_LEFT],
+};
+export const SUB_CLOSE_KEYS = {
+    ltr: [kbd.ARROW_LEFT],
+    rtl: [kbd.ARROW_RIGHT],
+};
+export function isIndeterminate(checked) {
+    return checked === "indeterminate";
+}
+export function getCheckedState(checked) {
+    return isIndeterminate(checked) ? "indeterminate" : checked ? "checked" : "unchecked";
+}
+export function isMouseEvent(event) {
+    return event.pointerType === "mouse";
+}

package/dist/bits/menu-data/components/data-empty.svelte

@@ -0,0 +1,25 @@
+<script lang="ts">
+	import { mergeProps } from "svelte-toolbelt";
+	import type { DataEmptyProps } from "../types.js";
+	import { dataMenuAttrs, useDataMenuSurfaceContext } from "../menu-data.svelte.js";
+
+	let {
+		children,
+		ref = $bindable(null),
+		...restProps
+	}: DataEmptyProps = $props();
+
+	const surface = useDataMenuSurfaceContext();
+	const isEmpty = $derived(surface.displayNodes.length === 0);
+	const mergedProps = $derived(
+		mergeProps(restProps, {
+			[dataMenuAttrs.empty]: "",
+		})
+	);
+</script>
+
+{#if isEmpty}
+	<div bind:this={ref} {...mergedProps}>
+		{@render children?.()}
+	</div>
+{/if}

package/dist/bits/menu-data/components/data-empty.svelte.d.ts

@@ -0,0 +1,4 @@
+import type { DataEmptyProps } from "../types.js";
+declare const DataEmpty: import("svelte").Component<DataEmptyProps, {}, "ref">;
+type DataEmpty = ReturnType<typeof DataEmpty>;
+export default DataEmpty;

package/dist/bits/menu-data/components/data-input.svelte

@@ -0,0 +1,139 @@
+<script lang="ts">
+	import { mergeProps } from "svelte-toolbelt";
+	import type { DataInputProps } from "../types.js";
+	import { dataMenuAttrs, useDataMenuSurfaceContext } from "../menu-data.svelte.js";
+	import { noop } from "../../../internal/noop.js";
+	import { kbd } from "../../../internal/kbd.js";
+
+	let {
+		value,
+		onValueChange = noop,
+		visibility,
+		hideUntilActive = false,
+		ref = $bindable(null),
+		type = "text",
+		oninput,
+		onkeydown,
+		onfocus,
+		...restProps
+	}: DataInputProps = $props();
+
+	const surface = useDataMenuSurfaceContext();
+	const initialVisibility = visibility ?? (hideUntilActive ? "typing" : "always");
+	surface.setInputVisibility(initialVisibility);
+	const resolvedVisibility = $derived(visibility ?? (hideUntilActive ? "typing" : "always"));
+	const inputValue = $derived(value ?? surface.search);
+	const shouldRender = $derived(surface.shouldRenderInput);
+
+	$effect(() => {
+		surface.setInputVisibility(resolvedVisibility);
+	});
+
+	$effect(() => {
+		surface.inputNode = ref;
+	});
+
+	function updateValue(nextValue: string) {
+		surface.setSearch(nextValue);
+		onValueChange(nextValue);
+	}
+
+	function stopNavigationEvent(event: KeyboardEvent) {
+		event.preventDefault();
+		event.stopPropagation();
+		event.stopImmediatePropagation();
+	}
+
+	function handleInput(event: Event) {
+		oninput?.(event as Event & { currentTarget: EventTarget & HTMLInputElement });
+		if (event.defaultPrevented) return;
+		updateValue((event.currentTarget as HTMLInputElement).value);
+	}
+
+	function handleFocus(event: FocusEvent) {
+		onfocus?.(event as FocusEvent & { currentTarget: EventTarget & HTMLInputElement });
+		if (event.defaultPrevented) return;
+		surface.activate();
+	}
+
+	function handleKeydown(event: KeyboardEvent) {
+		onkeydown?.(event as KeyboardEvent & { currentTarget: EventTarget & HTMLInputElement });
+		if (event.defaultPrevented) return;
+
+		const isModifierKey = event.ctrlKey || event.altKey || event.metaKey;
+		const isPrintableKey = event.key.length === 1;
+		if (!isModifierKey && isPrintableKey && surface.selectShortcut(event.key)) {
+			stopNavigationEvent(event);
+			return;
+		}
+
+		if (event.key === kbd.ARROW_DOWN) {
+			stopNavigationEvent(event);
+			surface.highlightNext();
+			return;
+		}
+
+		if (event.key === kbd.ARROW_UP) {
+			stopNavigationEvent(event);
+			surface.highlightPrevious();
+			return;
+		}
+
+		if (event.key === kbd.HOME) {
+			stopNavigationEvent(event);
+			surface.highlightFirst();
+			return;
+		}
+
+		if (event.key === kbd.END) {
+			stopNavigationEvent(event);
+			surface.highlightLast();
+			return;
+		}
+
+		if (event.key === kbd.ARROW_RIGHT) {
+			if (surface.openHighlightedSubmenu()) {
+				stopNavigationEvent(event);
+			}
+			return;
+		}
+
+		if (event.key === kbd.ARROW_LEFT) {
+			if (surface.closeToParent()) {
+				stopNavigationEvent(event);
+			}
+			return;
+		}
+
+		if (event.key === kbd.ENTER) {
+			stopNavigationEvent(event);
+			surface.selectHighlighted();
+			return;
+		}
+
+		if (isPrintableKey || event.key === kbd.BACKSPACE || event.key === kbd.DELETE) {
+			event.stopPropagation();
+			event.stopImmediatePropagation();
+		}
+	}
+
+	const mergedProps = $derived(
+		mergeProps(restProps, {
+			type,
+			value: inputValue,
+			role: "combobox",
+			"aria-autocomplete": "list",
+			"aria-expanded": true,
+			"aria-controls": surface.listNode?.id,
+			"aria-activedescendant": surface.highlightedId ?? undefined,
+			oninput: handleInput,
+			onkeydown: handleKeydown,
+			onfocus: handleFocus,
+			[dataMenuAttrs.input]: "",
+		})
+	);
+</script>
+
+{#if shouldRender}
+	<input bind:this={ref} {...mergedProps} />
+{/if}

package/dist/bits/menu-data/components/data-input.svelte.d.ts

@@ -0,0 +1,4 @@
+import type { DataInputProps } from "../types.js";
+declare const DataInput: import("svelte").Component<DataInputProps, {}, "ref">;
+type DataInput = ReturnType<typeof DataInput>;
+export default DataInput;

package/dist/bits/menu-data/components/data-list.svelte

@@ -0,0 +1,184 @@
+<script lang="ts" generics="TMeta = any">
+	import { afterTick, mergeProps } from "svelte-toolbelt";
+	import type { DataListProps, DataListChildrenSnippetProps } from "../types.js";
+	import { dataMenuAttrs, useDataMenuSurfaceContext } from "../menu-data.svelte.js";
+	import { createId } from "../../../internal/create-id.js";
+	import { kbd } from "../../../internal/kbd.js";
+
+	const uid = $props.id();
+
+	let {
+		id = createId(uid),
+		children,
+		ref = $bindable(null),
+		onkeydown,
+		onfocus,
+		onpointermove,
+		...restProps
+	}: DataListProps<TMeta> = $props();
+
+	const surface = useDataMenuSurfaceContext<TMeta>();
+	let scrollable = $state(false);
+	let atStart = $state(true);
+	let atEnd = $state(true);
+	const listState = $derived<DataListChildrenSnippetProps<TMeta>>({
+		search: surface.search,
+		nodes: surface.displayNodes,
+		count: surface.displayNodes.length,
+		isDeepSearching: surface.isDeepSearching,
+	});
+
+	$effect(() => {
+		surface.listNode = ref;
+	});
+
+	function updateScrollState() {
+		if (!ref) {
+			scrollable = false;
+			atStart = true;
+			atEnd = true;
+			return;
+		}
+		const maxScrollTop = Math.max(0, ref.scrollHeight - ref.clientHeight);
+		scrollable = maxScrollTop > 1;
+		atStart = ref.scrollTop <= 1;
+		atEnd = ref.scrollTop >= maxScrollTop - 1;
+	}
+
+	$effect(() => {
+		const node = ref;
+		if (!node) return;
+		updateScrollState();
+		const win = node.ownerDocument.defaultView;
+		if (!win) return;
+		const resizeObserver = new win.ResizeObserver(updateScrollState);
+		resizeObserver.observe(node);
+		for (const child of Array.from(node.children)) {
+			resizeObserver.observe(child);
+		}
+		const mutationObserver = new win.MutationObserver(() => {
+			updateScrollState();
+			for (const child of Array.from(node.children)) {
+				resizeObserver.observe(child);
+			}
+		});
+		mutationObserver.observe(node, { childList: true, subtree: true });
+		node.addEventListener("scroll", updateScrollState, { passive: true });
+		return () => {
+			node.removeEventListener("scroll", updateScrollState);
+			mutationObserver.disconnect();
+			resizeObserver.disconnect();
+		};
+	});
+
+	$effect(() => {
+		surface.displayNodes;
+		afterTick(updateScrollState);
+	});
+
+	function stopNavigationEvent(event: KeyboardEvent) {
+		event.preventDefault();
+		event.stopPropagation();
+		event.stopImmediatePropagation();
+	}
+
+	function handleFocus(event: FocusEvent) {
+		onfocus?.(event as FocusEvent & { currentTarget: EventTarget & HTMLDivElement });
+		if (event.defaultPrevented) return;
+		surface.activate();
+	}
+
+	function handlePointerMove(event: PointerEvent) {
+		onpointermove?.(event as PointerEvent & { currentTarget: EventTarget & HTMLDivElement });
+		if (event.defaultPrevented) return;
+		surface.activate();
+	}
+
+	function handleKeydown(event: KeyboardEvent) {
+		onkeydown?.(event as KeyboardEvent & { currentTarget: EventTarget & HTMLDivElement });
+		if (event.defaultPrevented) return;
+
+		if (event.key === kbd.ARROW_DOWN) {
+			stopNavigationEvent(event);
+			surface.highlightNext();
+			return;
+		}
+
+		if (event.key === kbd.ARROW_UP) {
+			stopNavigationEvent(event);
+			surface.highlightPrevious();
+			return;
+		}
+
+		if (event.key === kbd.HOME) {
+			stopNavigationEvent(event);
+			surface.highlightFirst();
+			return;
+		}
+
+		if (event.key === kbd.END) {
+			stopNavigationEvent(event);
+			surface.highlightLast();
+			return;
+		}
+
+		if (event.key === kbd.ARROW_RIGHT) {
+			if (surface.openHighlightedSubmenu()) {
+				stopNavigationEvent(event);
+			}
+			return;
+		}
+
+		if (event.key === kbd.ARROW_LEFT) {
+			if (surface.closeToParent()) {
+				stopNavigationEvent(event);
+			}
+			return;
+		}
+
+		const isModifierKey = event.ctrlKey || event.altKey || event.metaKey;
+		const canRevealInput = !surface.shouldRenderInput && surface.inputVisibility !== "hidden";
+		if (!isModifierKey && event.key.length === 1 && surface.selectShortcut(event.key)) {
+			stopNavigationEvent(event);
+			return;
+		}
+
+		if (event.key === kbd.BACKSPACE && canRevealInput) {
+			stopNavigationEvent(event);
+			surface.revealInput("");
+			return;
+		}
+
+		if (!isModifierKey && event.key.length === 1 && canRevealInput) {
+			stopNavigationEvent(event);
+			surface.revealInput(event.key);
+			return;
+		}
+
+		if (event.key === kbd.ENTER || event.key === kbd.SPACE) {
+			stopNavigationEvent(event);
+			surface.selectHighlighted();
+		}
+	}
+
+	const mergedProps = $derived(
+		mergeProps(restProps, {
+			id,
+			role: "listbox",
+			tabindex: surface.shouldRenderInput ? -1 : 0,
+			"aria-activedescendant": surface.highlightedId ?? undefined,
+			"data-empty": listState.count === 0 && surface.search.trim() === "" ? "" : undefined,
+			"data-scrollable": scrollable ? "" : undefined,
+			"data-scroll-start": atStart ? "" : undefined,
+			"data-scroll-end": atEnd ? "" : undefined,
+			onkeydown: handleKeydown,
+			onfocus: handleFocus,
+			onpointermove: handlePointerMove,
+			[dataMenuAttrs.list]: "",
+		})
+	);
+</script>
+
+<div bind:this={ref} {...mergedProps}>
+	{@render children?.(listState)}
+</div>

package/dist/bits/menu-data/components/data-list.svelte.d.ts

@@ -0,0 +1,18 @@
+import type { DataListProps } from "../types.js";
+declare class __sveltets_Render<TMeta = any> {
+    props(): DataListProps<TMeta>;
+    events(): {};
+    slots(): {};
+    bindings(): "ref";
+    exports(): {};
+}
+interface $$IsomorphicComponent {
+    new <TMeta = any>(options: import('svelte').ComponentConstructorOptions<ReturnType<__sveltets_Render<TMeta>['props']>>): import('svelte').SvelteComponent<ReturnType<__sveltets_Render<TMeta>['props']>, ReturnType<__sveltets_Render<TMeta>['events']>, ReturnType<__sveltets_Render<TMeta>['slots']>> & {
+        $$bindings?: ReturnType<__sveltets_Render<TMeta>['bindings']>;
+    } & ReturnType<__sveltets_Render<TMeta>['exports']>;
+    <TMeta = any>(internal: unknown, props: ReturnType<__sveltets_Render<TMeta>['props']> & {}): ReturnType<__sveltets_Render<TMeta>['exports']>;
+    z_$$bindings?: ReturnType<__sveltets_Render<any>['bindings']>;
+}
+declare const DataList: $$IsomorphicComponent;
+type DataList<TMeta = any> = InstanceType<typeof DataList<TMeta>>;
+export default DataList;