@svelte-atoms/core 1.0.0-alpha.41 → 1.0.0-alpha.46

package/dist/components/dropdown-menu/bond.svelte.d.ts

@@ -0,0 +1,68 @@
+import { PopoverBond, PopoverState, PopoverContentAtom, PopoverTriggerAtom, type PopoverDomElements, type PopoverStateProps } from '../popover/bond.svelte';
+import { BondAtom } from '../../shared/bond.svelte';
+import type { DropdownMenuItemControllerInterface } from './item/controller.svelte';
+export type DropdownMenuBondProps = PopoverStateProps;
+export type DropdownMenuBondElements = PopoverDomElements;
+export declare class DropdownMenuContentAtom extends PopoverContentAtom {
+    constructor(bond: DropdownMenuBond);
+    protected bond: DropdownMenuBond;
+    get attrs(): {
+        role: "menu";
+        'aria-activedescendant': string | undefined;
+        'aria-orientation': "vertical";
+        'data-active': boolean;
+    };
+    get handlers(): {
+        onkeydown: (ev: KeyboardEvent) => void;
+    };
+}
+export declare class DropdownMenuTriggerAtom extends PopoverTriggerAtom {
+    constructor(bond: DropdownMenuBond);
+    protected bond: DropdownMenuBond;
+    get attrs(): {
+        'aria-haspopup': "menu";
+        role: string;
+        disabled: boolean | undefined;
+        tabindex: number;
+        'aria-expanded': boolean;
+        'aria-disabled': boolean;
+        'aria-controls': string;
+    };
+    get handlers(): {
+        onkeydown: (ev: KeyboardEvent) => void;
+        onclick: (ev: PointerEvent) => void;
+    };
+}
+export declare class DropdownMenuItemAtom<B extends DropdownMenuBond = DropdownMenuBond> extends BondAtom<B> {
+    constructor(bond: B);
+    get attrs(): {
+        role: "menuitem";
+    };
+    get handlers(): {
+        onkeyup: (ev: KeyboardEvent) => void;
+    };
+}
+export declare class DropdownMenuBond<Props extends DropdownMenuBondProps = DropdownMenuBondProps, State extends DropdownMenuBondState<Props> = DropdownMenuBondState<Props>, Elements extends DropdownMenuBondElements = DropdownMenuBondElements> extends PopoverBond<Props, State, Elements> {
+    constructor(state: State);
+    content(): DropdownMenuContentAtom;
+    trigger(): DropdownMenuTriggerAtom;
+    item(): DropdownMenuItemAtom<this>;
+    static get<Props extends DropdownMenuBondProps = DropdownMenuBondProps, State extends DropdownMenuBondState<Props> = DropdownMenuBondState<Props>, Elements extends DropdownMenuBondElements = DropdownMenuBondElements>(): DropdownMenuBond<Props, State, Elements> | undefined;
+    static set<Props extends DropdownMenuBondProps = DropdownMenuBondProps, State extends DropdownMenuBondState<Props> = DropdownMenuBondState<Props>, Elements extends DropdownMenuBondElements = DropdownMenuBondElements>(context: DropdownMenuBond<Props, State, Elements>): DropdownMenuBond<Props, State, Elements>;
+}
+export declare class DropdownMenuBondState<Props extends DropdownMenuBondProps = DropdownMenuBondProps> extends PopoverState<Props> {
+    #private;
+    constructor(props: () => Props);
+    get items(): Map<string, DropdownMenuItemControllerInterface<Record<string, any>> | DropdownMenuItemAtom<DropdownMenuBond<PopoverStateProps, DropdownMenuBondState<PopoverStateProps>, PopoverDomElements>>>;
+    get highlightedId(): string | null;
+    get highlightedItem(): DropdownMenuItemControllerInterface<Record<string, any>> | DropdownMenuItemAtom<DropdownMenuBond<PopoverStateProps, DropdownMenuBondState<PopoverStateProps>, PopoverDomElements>> | null;
+    get navigation(): {
+        next: () => DropdownMenuItemControllerInterface<Record<string, any>> | DropdownMenuItemAtom<DropdownMenuBond<PopoverStateProps, DropdownMenuBondState<PopoverStateProps>, PopoverDomElements>> | null;
+        previous: () => DropdownMenuItemControllerInterface<Record<string, any>> | DropdownMenuItemAtom<DropdownMenuBond<PopoverStateProps, DropdownMenuBondState<PopoverStateProps>, PopoverDomElements>> | null;
+    };
+    mountItem(id: string, item: DropdownMenuItemControllerInterface<Record<string, any>> | DropdownMenuItemAtom): () => void;
+    unmountItem(id: string): void;
+    item(id: string): DropdownMenuItemControllerInterface<Record<string, any>> | DropdownMenuItemAtom<DropdownMenuBond<PopoverStateProps, DropdownMenuBondState<PopoverStateProps>, PopoverDomElements>> | undefined;
+    registerItem(id: string, atom: DropdownMenuItemAtom): void;
+    unregisterItem(id: string): void;
+}

package/dist/components/dropdown-menu/bond.svelte.js

@@ -0,0 +1,173 @@
+import { SvelteMap, SvelteSet } from 'svelte/reactivity';
+import { PopoverBond, PopoverState, PopoverContentAtom, PopoverTriggerAtom } from '../popover/bond.svelte';
+import { BondAtom } from '../../shared/bond.svelte';
+export class DropdownMenuContentAtom extends PopoverContentAtom {
+    constructor(bond) {
+        super(bond);
+    }
+    get attrs() {
+        const highlightedId = this.bond.state.highlightedId;
+        return {
+            ...super.attrs,
+            role: 'menu',
+            'aria-activedescendant': highlightedId ? `item-${highlightedId}` : undefined,
+            'aria-orientation': 'vertical'
+        };
+    }
+    get handlers() {
+        const superHandlers = super.handlers;
+        return {
+            ...superHandlers,
+            onkeydown: (ev) => {
+                superHandlers.onkeydown?.(ev);
+                if (ev.defaultPrevented)
+                    return;
+                if (ev.key === 'ArrowDown') {
+                    this.bond.state.navigation.next();
+                }
+                if (ev.key === 'ArrowUp') {
+                    this.bond.state.navigation.previous();
+                }
+            }
+        };
+    }
+}
+export class DropdownMenuTriggerAtom extends PopoverTriggerAtom {
+    constructor(bond) {
+        super(bond);
+    }
+    get attrs() {
+        return {
+            ...super.attrs,
+            'aria-haspopup': 'menu'
+        };
+    }
+    get handlers() {
+        const superHandlers = super.handlers;
+        return {
+            ...superHandlers,
+            onkeydown: (ev) => {
+                if (ev.key === 'ArrowDown') {
+                    this.bond.state.navigation.next();
+                }
+                if (ev.key === 'ArrowUp') {
+                    this.bond.state.navigation.previous();
+                }
+                if ((ev.key === 'Enter' || ev.key === ' ') &&
+                    this.bond.state.props.open &&
+                    this.bond.state.highlightedItem) {
+                    if (ev.key === ' ') {
+                        ev.preventDefault();
+                    }
+                    this.bond.state.highlightedItem?.element?.click?.();
+                }
+                superHandlers.onkeydown?.(ev);
+            }
+        };
+    }
+}
+export class DropdownMenuItemAtom extends BondAtom {
+    constructor(bond) {
+        super(bond, 'item');
+    }
+    get attrs() {
+        return {
+            ...super.attrs,
+            role: 'menuitem'
+        };
+    }
+    get handlers() {
+        return {
+            onkeyup: (ev) => {
+                const currentTarget = ev.currentTarget;
+                const disabled = currentTarget.getAttribute('disabled') ||
+                    currentTarget.getAttribute('aria-disabled') === 'true';
+                if (disabled)
+                    return;
+                if (ev.key === 'Enter' || ev.key === ' ') {
+                    ev.preventDefault();
+                    this.bond?.state.close();
+                }
+            }
+        };
+    }
+}
+export class DropdownMenuBond extends PopoverBond {
+    constructor(state) {
+        super(state);
+    }
+    content() {
+        return this.atom('content', () => new DropdownMenuContentAtom(this));
+    }
+    trigger() {
+        return this.atom('trigger', () => new DropdownMenuTriggerAtom(this));
+    }
+    item() {
+        return this.atom('item', () => new DropdownMenuItemAtom(this));
+    }
+    static get() {
+        return PopoverBond.get();
+    }
+    static set(context) {
+        return PopoverBond.set(context);
+    }
+}
+export class DropdownMenuBondState extends PopoverState {
+    #keys = new SvelteSet();
+    #items = new SvelteMap();
+    #itemsAsArray = $derived(Array.from(this.#items.values()));
+    #index = $state(-1);
+    #highlightedId = $derived(Array.from(this.#items.keys())[this.#index] ?? null);
+    #highlightedItem = $derived(this.#itemsAsArray[this.#index] ?? null);
+    constructor(props) {
+        super(props);
+    }
+    get items() {
+        return this.#items;
+    }
+    get highlightedId() {
+        return this.#highlightedId;
+    }
+    get highlightedItem() {
+        return this.#highlightedItem;
+    }
+    get navigation() {
+        return {
+            next: () => {
+                if (this.#index < 0) {
+                    this.#index = 0;
+                    return this.#highlightedItem;
+                }
+                const length = this.#items.size;
+                this.#index = Math.min((this.#index + 1) % length, length - 1);
+                return this.#highlightedItem;
+            },
+            previous: () => {
+                if (this.#index <= 0) {
+                    this.#index = this.#items.size - 1;
+                    return this.#highlightedItem;
+                }
+                this.#index = Math.max(this.#index - 1, 0);
+                return this.#highlightedItem;
+            }
+        };
+    }
+    mountItem(id, item) {
+        this.#items.set(id, item);
+        return () => this.unmountItem(id);
+    }
+    unmountItem(id) {
+        if (this.#keys.has(id))
+            return;
+        this.#items.delete(id);
+    }
+    item(id) {
+        return this.#items.get(id);
+    }
+    registerItem(id, atom) {
+        this.#items.set(id, atom);
+    }
+    unregisterItem(id) {
+        this.#items.delete(id);
+    }
+}

package/dist/components/dropdown-menu/dropdown-menu-content.svelte

@@ -0,0 +1,28 @@
+<script lang="ts" generics="T extends keyof HTMLElementTagNameMap = 'div', B extends Base = Base">
+	import { Content } from '../popover/atoms';
+	import type { Base } from '../atom';
+	import { DropdownMenuBond } from './bond.svelte';
+	import { Root } from '../list/atoms';
+
+	const bond = DropdownMenuBond.get();
+
+	let {
+		class: klass = '',
+		as = 'ul' as T,
+		base = Root as B,
+		preset = 'dropdown-menu.content',
+		children = undefined,
+		...restProps
+	} = $props();
+</script>
+
+<Content
+	{as}
+	{base}
+	{bond}
+	{preset}
+	class={['border-border overflow-hidden p-0', '$preset', klass]}
+	{...restProps}
+>
+	{@render children?.()}
+</Content>

package/dist/components/dropdown-menu/dropdown-menu-content.svelte.d.ts

@@ -0,0 +1,31 @@
+import type { Base } from '../atom';
+declare function $$render<T extends keyof HTMLElementTagNameMap = 'div', B extends Base = Base>(): {
+    props: {
+        class?: string;
+        as?: T;
+        base?: B;
+        preset?: string;
+        children?: any;
+    } & Record<string, any>;
+    exports: {};
+    bindings: "";
+    slots: {};
+    events: {};
+};
+declare class __sveltets_Render<T extends keyof HTMLElementTagNameMap = 'div', B extends Base = Base> {
+    props(): ReturnType<typeof $$render<T, B>>['props'];
+    events(): ReturnType<typeof $$render<T, B>>['events'];
+    slots(): ReturnType<typeof $$render<T, B>>['slots'];
+    bindings(): "";
+    exports(): {};
+}
+interface $$IsomorphicComponent {
+    new <T extends keyof HTMLElementTagNameMap = 'div', B extends Base = Base>(options: import('svelte').ComponentConstructorOptions<ReturnType<__sveltets_Render<T, B>['props']>>): import('svelte').SvelteComponent<ReturnType<__sveltets_Render<T, B>['props']>, ReturnType<__sveltets_Render<T, B>['events']>, ReturnType<__sveltets_Render<T, B>['slots']>> & {
+        $$bindings?: ReturnType<__sveltets_Render<T, B>['bindings']>;
+    } & ReturnType<__sveltets_Render<T, B>['exports']>;
+    <T extends keyof HTMLElementTagNameMap = 'div', B extends Base = Base>(internal: unknown, props: ReturnType<__sveltets_Render<T, B>['props']> & {}): ReturnType<__sveltets_Render<T, B>['exports']>;
+    z_$$bindings?: ReturnType<__sveltets_Render<any, any>['bindings']>;
+}
+declare const DropdownMenuContent: $$IsomorphicComponent;
+type DropdownMenuContent<T extends keyof HTMLElementTagNameMap = 'div', B extends Base = Base> = InstanceType<typeof DropdownMenuContent<T, B>>;
+export default DropdownMenuContent;

package/dist/components/dropdown-menu/dropdown-menu-root.svelte

@@ -0,0 +1,14 @@
+<script lang="ts">
+	import { DropdownMenuBond, DropdownMenuBondState, type DropdownMenuBondProps } from './bond.svelte';
+	import { Root } from '../popover/atoms';
+	import type { PopoverRootProps } from '../popover';
+
+	let { open = $bindable(false), factory = _factory, ...restProps }: PopoverRootProps = $props();
+
+	function _factory(props: DropdownMenuBondProps) {
+		const menuBondState = new DropdownMenuBondState(() => props);
+		return new DropdownMenuBond(menuBondState);
+	}
+</script>
+
+<Root bind:open {factory} {...restProps} />

package/dist/components/dropdown-menu/dropdown-menu-root.svelte.d.ts

@@ -0,0 +1,4 @@
+import type { PopoverRootProps } from '../popover';
+declare const DropdownMenuRoot: import("svelte").Component<PopoverRootProps, {}, "open">;
+type DropdownMenuRoot = ReturnType<typeof DropdownMenuRoot>;
+export default DropdownMenuRoot;

package/dist/components/dropdown-menu/index.d.ts

@@ -0,0 +1,7 @@
+export * as DropdownMenu from './atoms';
+export * from './types';
+export { PopoverBond, type PopoverDomElements, type PopoverParams, PopoverState, type PopoverStateProps, type TriggerParams } from '../popover';
+export type { AnimatePopoverContentParams as AnimateDropdownMenuContentParams, animatePopoverContent as animateDropdownMenuContent } from '../popover/motion.svelte';
+export * from './item';
+export { dropdownMenu } from './attachments.svelte';
+export { DropdownMenuBond, DropdownMenuBondState, DropdownMenuContentAtom, DropdownMenuTriggerAtom, DropdownMenuItemAtom, type DropdownMenuBondProps, type DropdownMenuBondElements } from './bond.svelte';

package/dist/components/dropdown-menu/index.js

@@ -0,0 +1,6 @@
+export * as DropdownMenu from './atoms';
+export * from './types';
+export { PopoverBond, PopoverState } from '../popover';
+export * from './item';
+export { dropdownMenu } from './attachments.svelte';
+export { DropdownMenuBond, DropdownMenuBondState, DropdownMenuContentAtom, DropdownMenuTriggerAtom, DropdownMenuItemAtom } from './bond.svelte';

package/dist/components/dropdown-menu/item/bond.svelte.d.ts

@@ -0,0 +1,26 @@
+import { BondAtom } from '../../../shared/bond.svelte';
+import type { DropdownMenuBond } from '../bond.svelte';
+export type DropdownMenuItemAtomProps = {
+    id: string;
+    disabled?: boolean;
+};
+export declare class DropdownMenuItemAtom<B extends DropdownMenuBond = DropdownMenuBond> extends BondAtom<B, HTMLElement> {
+    #private;
+    constructor(props: () => DropdownMenuItemAtomProps, menuBond: B);
+    get id(): string;
+    get createdAt(): Date;
+    get props(): DropdownMenuItemAtomProps;
+    get isHighlighted(): boolean;
+    get attrs(): {
+        id: string;
+        role: string;
+        'data-highlighted': boolean;
+        'aria-disabled': boolean | undefined;
+        tabIndex: number;
+    };
+    get handlers(): {
+        onclick: () => void;
+    };
+    close(): void;
+    onmount(): () => void;
+}

package/dist/components/dropdown-menu/item/bond.svelte.js

@@ -0,0 +1,54 @@
+import { BondAtom } from '../../../shared/bond.svelte';
+import { nanoid } from 'nanoid';
+export class DropdownMenuItemAtom extends BondAtom {
+    #id;
+    #props;
+    #menuBond;
+    // eslint-disable-next-line svelte/prefer-svelte-reactivity
+    #createdAt = new Date();
+    constructor(props, menuBond) {
+        super(menuBond, `item-${props().id}`);
+        this.#props = props;
+        this.#menuBond = menuBond;
+        this.#id = props().id ?? nanoid();
+    }
+    get id() {
+        return this.#id;
+    }
+    get createdAt() {
+        return this.#createdAt;
+    }
+    get props() {
+        return this.#props();
+    }
+    get isHighlighted() {
+        return this.#menuBond.state.highlightedId === this.id;
+    }
+    get attrs() {
+        const itemId = `menu-item-${this.id}`;
+        return {
+            ...super.attrs,
+            id: itemId,
+            role: 'menuitem',
+            'data-highlighted': this.isHighlighted,
+            'aria-disabled': this.#props().disabled ? true : undefined,
+            tabIndex: this.#props().disabled ? -1 : 0
+        };
+    }
+    get handlers() {
+        return {
+            onclick: () => {
+                this.#menuBond?.state.close();
+            }
+        };
+    }
+    close() {
+        this.#menuBond?.state.close();
+    }
+    onmount() {
+        this.#menuBond?.state?.mountItem?.(this.id, this);
+        return () => {
+            this.#menuBond?.state?.unmountItem?.(this.id);
+        };
+    }
+}

package/dist/components/dropdown-menu/item/controller.svelte.d.ts

@@ -0,0 +1,39 @@
+import { DropdownMenuBond, DropdownMenuBondState } from '../bond.svelte';
+export type DropdownMenuItemControllerProps = {
+    readonly id: string;
+};
+export interface DropdownMenuItemControllerInterface<Props extends Record<string, unknown>> {
+    get id(): string;
+    get createdAt(): Date;
+    get props(): Props;
+    get element(): HTMLElement | null;
+    get isHighlighted(): boolean;
+    mount(): () => void;
+    unmount(): void;
+    destroy(): void;
+    share(): DropdownMenuItemControllerInterface<Props>;
+    elementProps(): Record<string, unknown>;
+}
+export declare class DropdownMenuItemController implements DropdownMenuItemControllerInterface<DropdownMenuItemControllerProps> {
+    #private;
+    static CONTEXT_KEY: string;
+    constructor(props: () => DropdownMenuItemControllerProps);
+    get id(): string;
+    get createdAt(): Date;
+    get props(): DropdownMenuItemControllerProps;
+    get element(): HTMLElement | null;
+    get menu(): DropdownMenuBond<import("..").PopoverStateProps, DropdownMenuBondState<import("..").PopoverStateProps>, import("..").PopoverDomElements> | undefined;
+    get isHighlighted(): boolean;
+    mount(): () => void;
+    unmount(): void;
+    destroy(): void;
+    share(): DropdownMenuItemController;
+    elementProps(): {
+        readonly [x: symbol]: (node: HTMLElement) => () => void;
+        readonly id: string;
+        readonly role: "menuitem";
+        readonly 'data-highlighted': boolean;
+    };
+    static get(): DropdownMenuItemController | undefined;
+    static set(item: DropdownMenuItemController): DropdownMenuItemController;
+}

package/dist/components/dropdown-menu/item/controller.svelte.js

@@ -0,0 +1,73 @@
+import { getContext, setContext } from 'svelte';
+import { createAttachmentKey } from 'svelte/attachments';
+import { nanoid } from 'nanoid';
+import { DropdownMenuBond, DropdownMenuBondState } from '../bond.svelte';
+export class DropdownMenuItemController {
+    static CONTEXT_KEY = '@atoms/context/dropdown-menu/item';
+    #id;
+    #props;
+    #element = null;
+    #menu;
+    #unmount;
+    // eslint-disable-next-line svelte/prefer-svelte-reactivity
+    #createdAt = new Date();
+    constructor(props) {
+        this.#props = props;
+        this.#id = this.props.id ?? nanoid();
+        this.#menu = DropdownMenuBond.get();
+        if (!this.#menu) {
+            throw new Error('DropdownMenuItem must be used within a DropdownMenu context');
+        }
+    }
+    get id() {
+        return this.#id;
+    }
+    get createdAt() {
+        return this.#createdAt;
+    }
+    get props() {
+        return this.#props();
+    }
+    get element() {
+        return this.#element;
+    }
+    get menu() {
+        return this.#menu;
+    }
+    get isHighlighted() {
+        return this.#menu?.state.highlightedId === this.#id;
+    }
+    mount() {
+        this.#unmount = this.#menu?.state?.mountItem?.(this.#id, this) ?? undefined;
+        return this.unmount;
+    }
+    unmount() {
+        this.#unmount?.();
+    }
+    destroy() {
+        this.unmount();
+    }
+    share() {
+        return DropdownMenuItemController.set(this);
+    }
+    elementProps() {
+        const itemId = `menu-item-${this.id}`;
+        return {
+            id: itemId,
+            role: 'menuitem',
+            'data-highlighted': this.isHighlighted,
+            [createAttachmentKey()]: (node) => {
+                this.#element = node;
+                return () => {
+                    this.#element = null;
+                };
+            }
+        };
+    }
+    static get() {
+        return getContext(DropdownMenuItemController.CONTEXT_KEY);
+    }
+    static set(item) {
+        return setContext(DropdownMenuItemController.CONTEXT_KEY, item);
+    }
+}

package/dist/components/dropdown-menu/item/dropdown-menu-item.svelte

@@ -0,0 +1,75 @@
+<script
+	lang="ts"
+	generics="E extends keyof HTMLElementTagNameMap = 'div', B extends Base = Base"
+>
+	import type { Base } from '../../atom';
+	import { DropdownMenuItemAtom, type DropdownMenuItemAtomProps } from './bond.svelte';
+	import { DropdownMenuBond } from '../bond.svelte';
+	import type { DropdownMenuItemProps } from './types';
+	import { List } from '../../list';
+
+	const menu = DropdownMenuBond.get();
+
+	if (!menu) {
+		throw new Error('<DropdownMenuItem> must be used within a <DropdownMenu>.');
+	}
+
+	let {
+		class: klass = '',
+		id,
+		preset: presetKey = 'dropdown-menu.item',
+		disabled = undefined,
+		children = undefined,
+		onclick = undefined,
+		...restProps
+	}: DropdownMenuItemProps = $props();
+
+	// Create reactive props object for the atom
+	const itemProps = $derived<DropdownMenuItemAtomProps>({
+		id: id ?? '',
+		disabled
+	});
+
+	// Create the atom instance
+	const atom = new DropdownMenuItemAtom<typeof menu>(() => itemProps, menu);
+
+	// Derived reactive properties
+	const isHighlighted = $derived(atom.isHighlighted);
+
+	// Merge atom attrs with custom props
+	const itemAttrs = $derived({
+		...atom.attrs,
+		...restProps
+	});
+
+	function handleClick(ev: MouseEvent) {
+		onclick?.(ev);
+
+		if (ev.defaultPrevented) {
+			return;
+		}
+
+		ev.preventDefault();
+
+		atom.close();
+	}
+
+	export function getController() {
+		return atom;
+	}
+</script>
+
+<List.Item
+	preset={presetKey}
+	class={[
+		'border-border last:border-b-0 hover:bg-foreground/5 active:bg-foreground/10 outline-primary cursor-pointer border-b',
+		'$preset',
+		klass
+	]
+		.filter(Boolean)
+		.join(' ')}
+	{...itemAttrs}
+	onclick={handleClick}
+>
+	{@render children?.({ menuItem: atom })}
+</List.Item>

package/dist/components/dropdown-menu/item/dropdown-menu-item.svelte.d.ts

@@ -0,0 +1,32 @@
+import type { Base } from '../../atom';
+import { DropdownMenuItemAtom } from './bond.svelte';
+import { DropdownMenuBond } from '../bond.svelte';
+import type { DropdownMenuItemProps } from './types';
+declare function $$render<E extends keyof HTMLElementTagNameMap = 'div', B extends Base = Base>(): {
+    props: DropdownMenuItemProps;
+    exports: {
+        getController: () => DropdownMenuItemAtom<DropdownMenuBond<import("..").PopoverStateProps, import("..").DropdownMenuBondState<import("..").PopoverStateProps>, import("..").PopoverDomElements>>;
+    };
+    bindings: "";
+    slots: {};
+    events: {};
+};
+declare class __sveltets_Render<E extends keyof HTMLElementTagNameMap = 'div', B extends Base = Base> {
+    props(): ReturnType<typeof $$render<E, B>>['props'];
+    events(): ReturnType<typeof $$render<E, B>>['events'];
+    slots(): ReturnType<typeof $$render<E, B>>['slots'];
+    bindings(): "";
+    exports(): {
+        getController: () => DropdownMenuItemAtom<DropdownMenuBond<import("..").PopoverStateProps, import("..").DropdownMenuBondState<import("..").PopoverStateProps>, import("..").PopoverDomElements>>;
+    };
+}
+interface $$IsomorphicComponent {
+    new <E extends keyof HTMLElementTagNameMap = 'div', B extends Base = Base>(options: import('svelte').ComponentConstructorOptions<ReturnType<__sveltets_Render<E, B>['props']>>): import('svelte').SvelteComponent<ReturnType<__sveltets_Render<E, B>['props']>, ReturnType<__sveltets_Render<E, B>['events']>, ReturnType<__sveltets_Render<E, B>['slots']>> & {
+        $$bindings?: ReturnType<__sveltets_Render<E, B>['bindings']>;
+    } & ReturnType<__sveltets_Render<E, B>['exports']>;
+    <E extends keyof HTMLElementTagNameMap = 'div', B extends Base = Base>(internal: unknown, props: ReturnType<__sveltets_Render<E, B>['props']> & {}): ReturnType<__sveltets_Render<E, B>['exports']>;
+    z_$$bindings?: ReturnType<__sveltets_Render<any, any>['bindings']>;
+}
+declare const DropdownMenuItem: $$IsomorphicComponent;
+type DropdownMenuItem<E extends keyof HTMLElementTagNameMap = 'div', B extends Base = Base> = InstanceType<typeof DropdownMenuItem<E, B>>;
+export default DropdownMenuItem;

package/dist/components/dropdown-menu/item/index.d.ts

@@ -0,0 +1,3 @@
+export { DropdownMenuItemController, type DropdownMenuItemControllerProps, type DropdownMenuItemControllerInterface } from './controller.svelte';
+export { DropdownMenuItemAtom, type DropdownMenuItemAtomProps } from './bond.svelte';
+export * from './types';

package/dist/components/dropdown-menu/item/index.js

@@ -0,0 +1,3 @@
+export { DropdownMenuItemController } from './controller.svelte';
+export { DropdownMenuItemAtom } from './bond.svelte';
+export * from './types';