sheer-ui 0.4.2 → 0.5.0

package/dist/components/menubar/menubar.svelte.js

@@ -0,0 +1,312 @@
+import { attachRef } from '../../internal/tools/index.js';
+import { createBitsAttrs, boolToStr, boolToEmptyStrOrUndef, getDataOpenClosed } from '../../internal/attrs.js';
+import { kbd } from '../../internal/kbd.js';
+import { createContext, onMount, tick, untrack } from 'svelte';
+import { getFloatingContentCSSVars } from '../../internal/floating-layer/index.js';
+import { RovingFocusGroup } from '../../internal/roving-focus-group.svelte.js';
+import { RovingFocusItem } from '../../internal/roving-focus-item.svelte.js';
+const menubarAttrs = createBitsAttrs({
+    component: 'menubar',
+    parts: ['root', 'trigger', 'content'],
+});
+const [getMenubarRoot, setMenubarRoot] = createContext();
+const [getMenubarMenu, setMenubarMenu] = createContext();
+export class MenubarRootState {
+    static create(opts) {
+        return setMenubarRoot(new MenubarRootState(opts));
+    }
+    opts;
+    rovingFocusGroup;
+    attachment;
+    wasOpenedByKeyboard = $state(false);
+    triggerIds = $state([]);
+    /** Outgoing menu id when swapping to another top-level menu... skip exit animation wait only then */
+    skipExitAnimationForMenuValue = $state(null);
+    valueToChangeHandler = new Map();
+    constructor(opts) {
+        this.opts = opts;
+        this.attachment = attachRef(this.opts.ref);
+        this.rovingFocusGroup = new RovingFocusGroup({
+            rootNode: () => this.opts.ref.current,
+            candidateAttr: menubarAttrs.trigger,
+            loop: () => this.opts.loop.current,
+            orientation: () => 'horizontal',
+        });
+    }
+    /**
+     * @param id - the id of the trigger to register
+     * @returns - a function to de-register the trigger
+     */
+    registerTrigger = (id) => {
+        this.triggerIds.push(id);
+        return () => {
+            this.triggerIds = this.triggerIds.filter((triggerId) => triggerId !== id);
+        };
+    };
+    /**
+     * @param value - the value of the menu to register
+     * @param contentId - the content id to associate with the value
+     * @returns - a function to de-register the menu
+     */
+    registerMenu = (value, onOpenChange) => {
+        this.valueToChangeHandler.set(value, onOpenChange);
+        return () => {
+            this.valueToChangeHandler.delete(value);
+        };
+    };
+    updateValue = (value) => {
+        const currValue = this.opts.value.current;
+        const switchingMenus = Boolean(currValue && value && currValue !== value);
+        if (switchingMenus) {
+            this.skipExitAnimationForMenuValue = currValue;
+        }
+        const currHandler = this.valueToChangeHandler.get(currValue)?.current;
+        const nextHandler = this.valueToChangeHandler.get(value)?.current;
+        this.opts.value.current = value;
+        if (currHandler && currValue !== value) {
+            currHandler(false);
+        }
+        if (nextHandler) {
+            nextHandler(true);
+        }
+        if (switchingMenus) {
+            tick().then(() => {
+                this.skipExitAnimationForMenuValue = null;
+            });
+        }
+    };
+    getTriggers = () => {
+        const node = this.opts.ref.current;
+        if (!node)
+            return [];
+        return Array.from(node.querySelectorAll(menubarAttrs.selector('trigger')));
+    };
+    onMenuOpen = (id, triggerId) => {
+        this.updateValue(id);
+        this.rovingFocusGroup.setCurrentTabStopId(triggerId);
+    };
+    onMenuClose = () => {
+        this.updateValue('');
+    };
+    onMenuToggle = (id) => {
+        this.updateValue(this.opts.value.current ? '' : id);
+    };
+    props = $derived.by(() => ({
+        id: this.opts.id.current,
+        role: 'menubar',
+        [menubarAttrs.root]: '',
+        ...this.attachment,
+    }));
+}
+export class MenubarMenuState {
+    static create(opts) {
+        return setMenubarMenu(new MenubarMenuState(opts, getMenubarRoot()));
+    }
+    opts;
+    root;
+    open = $derived.by(() => this.root.opts.value.current === this.opts.value.current);
+    wasOpenedByKeyboard = false;
+    triggerNode = $state(null);
+    triggerId = $derived.by(() => this.triggerNode?.id);
+    contentId = $derived.by(() => this.contentNode?.id);
+    contentNode = $state(null);
+    constructor(opts, root) {
+        this.opts = opts;
+        this.root = root;
+        $effect(() => {
+            this.open;
+            untrack(() => {
+                if (!this.open) {
+                    this.wasOpenedByKeyboard = false;
+                }
+            });
+        });
+        onMount(() => {
+            return this.root.registerMenu(this.opts.value.current, opts.onOpenChange);
+        });
+    }
+    getTriggerNode() {
+        return this.triggerNode;
+    }
+    toggleMenu() {
+        this.root.onMenuToggle(this.opts.value.current);
+    }
+    openMenu() {
+        this.root.onMenuOpen(this.opts.value.current, this.triggerNode?.id ?? '');
+    }
+}
+export class MenubarTriggerState {
+    static create(opts) {
+        return new MenubarTriggerState(opts, getMenubarMenu());
+    }
+    opts;
+    menu;
+    root;
+    rovingItem;
+    isFocused = $state(false);
+    constructor(opts, menu) {
+        this.opts = opts;
+        this.menu = menu;
+        this.root = menu.root;
+        this.rovingItem = new RovingFocusItem({
+            group: this.root.rovingFocusGroup,
+            ref: () => this.opts.ref.current,
+            setRef: (v) => (this.opts.ref.current = v),
+            onRefChange: (v) => (this.menu.triggerNode = v),
+        });
+        onMount(() => {
+            return this.root.registerTrigger(opts.id.current);
+        });
+    }
+    onpointerdown = (e) => {
+        // only call if the left button but not when the CTRL key is pressed
+        if (!this.opts.disabled.current && e.button === 0 && e.ctrlKey === false) {
+            // prevent trigger from focusing when opening
+            // which allows the content to focus without competition
+            if (!this.menu.open) {
+                e.preventDefault();
+            }
+            this.menu.toggleMenu();
+        }
+    };
+    onpointerenter = () => {
+        const isMenubarOpen = Boolean(this.root.opts.value.current);
+        if (isMenubarOpen && !this.menu.open) {
+            this.menu.openMenu();
+            this.menu.getTriggerNode()?.focus();
+        }
+    };
+    onkeydown = (e) => {
+        if (this.opts.disabled.current)
+            return;
+        if (e.key === kbd.TAB)
+            return;
+        if (e.key === kbd.ENTER || e.key === kbd.SPACE) {
+            this.root.onMenuToggle(this.menu.opts.value.current);
+        }
+        if (e.key === kbd.ARROW_DOWN) {
+            this.menu.openMenu();
+        }
+        // prevent keydown from scrolling window / first focused item
+        // from inadvertently closing the menu
+        if (e.key === kbd.ENTER || e.key === kbd.SPACE || e.key === kbd.ARROW_DOWN) {
+            this.menu.wasOpenedByKeyboard = true;
+            e.preventDefault();
+        }
+        this.rovingItem.handleKeydown(e);
+    };
+    onfocus = () => {
+        this.isFocused = true;
+    };
+    onblur = () => {
+        this.isFocused = false;
+    };
+    props = $derived.by(() => ({
+        type: 'button',
+        role: 'menuitem',
+        id: this.opts.id.current,
+        'aria-haspopup': 'menu',
+        'aria-expanded': boolToStr(this.menu.open),
+        'aria-controls': this.menu.open ? this.menu.contentId : undefined,
+        'data-highlighted': this.isFocused ? '' : undefined,
+        'data-state': getDataOpenClosed(this.menu.open),
+        'data-disabled': boolToEmptyStrOrUndef(this.opts.disabled.current),
+        'data-menu-value': this.menu.opts.value.current,
+        disabled: this.opts.disabled.current ? true : undefined,
+        [menubarAttrs.trigger]: '',
+        onpointerdown: this.onpointerdown,
+        onpointerenter: this.onpointerenter,
+        onkeydown: this.onkeydown,
+        onfocus: this.onfocus,
+        onblur: this.onblur,
+        ...this.rovingItem.props,
+    }));
+}
+export class MenubarContentState {
+    static create(opts) {
+        return new MenubarContentState(opts, getMenubarMenu());
+    }
+    opts;
+    menu;
+    root;
+    attachment;
+    constructor(opts, menu) {
+        this.opts = opts;
+        this.menu = menu;
+        this.root = menu.root;
+        this.attachment = attachRef(this.opts.ref, (v) => (this.menu.contentNode = v));
+    }
+    onCloseAutoFocus = (e) => {
+        this.opts.onCloseAutoFocus.current?.(e);
+        if (e.defaultPrevented)
+            return;
+    };
+    onFocusOutside = (e) => {
+        const target = e.target;
+        const isMenubarTrigger = this.root.getTriggers().some((trigger) => trigger.contains(target));
+        if (isMenubarTrigger)
+            e.preventDefault();
+        this.opts.onFocusOutside.current(e);
+    };
+    onInteractOutside = (e) => {
+        this.opts.onInteractOutside.current(e);
+    };
+    onOpenAutoFocus = (e) => {
+        this.opts.onOpenAutoFocus.current(e);
+        if (e.defaultPrevented)
+            return;
+        tick().then(() => this.opts.ref.current?.focus());
+    };
+    onkeydown = (e) => {
+        if (e.key !== kbd.ARROW_LEFT && e.key !== kbd.ARROW_RIGHT)
+            return;
+        const target = e.target;
+        const targetIsSubTrigger = target.hasAttribute('data-menu-sub-trigger');
+        const isKeydownInsideSubMenu = target.closest('[data-menu-content]') !== e.currentTarget;
+        const prevMenuKey = this.root.opts.dir.current === 'rtl' ? kbd.ARROW_RIGHT : kbd.ARROW_LEFT;
+        const isPrevKey = prevMenuKey === e.key;
+        const isNextKey = !isPrevKey;
+        // prevent navigation when opening a submenu
+        if (isNextKey && targetIsSubTrigger)
+            return;
+        // or if we're inside a submenu and moving back to close it
+        if (isKeydownInsideSubMenu && isPrevKey)
+            return;
+        const items = this.root.getTriggers().filter((trigger) => !trigger.disabled);
+        const candidates = items.map((item) => ({
+            value: item.getAttribute('data-menu-value'),
+            triggerId: item.id ?? '',
+        }));
+        if (isPrevKey)
+            candidates.reverse();
+        const candidateValues = candidates.map(({ value }) => value);
+        // use the root's open menu id — during rapid switching, stale content can still be
+        // focused while another menu is already open; per-menu value would navigate from the wrong index
+        const openMenuValue = this.root.opts.value.current;
+        if (!openMenuValue)
+            return;
+        const currentIndex = candidateValues.indexOf(openMenuValue);
+        if (currentIndex === -1)
+            return;
+        const nextValue = this.root.opts.loop.current ? candidates[(currentIndex + 1) % candidates.length] : candidates[currentIndex + 1];
+        if (nextValue) {
+            this.menu.root.onMenuOpen(nextValue.value, nextValue.triggerId);
+            e.preventDefault();
+        }
+    };
+    props = $derived.by(() => ({
+        id: this.opts.id.current,
+        'aria-labelledby': this.menu.triggerId,
+        style: getFloatingContentCSSVars('menubar'),
+        onkeydown: this.onkeydown,
+        'data-menu-content': '',
+        [menubarAttrs.content]: '',
+        ...this.attachment,
+    }));
+    popperProps = {
+        onCloseAutoFocus: this.onCloseAutoFocus,
+        onFocusOutside: this.onFocusOutside,
+        onInteractOutside: this.onInteractOutside,
+        onOpenAutoFocus: this.onOpenAutoFocus,
+    };
+}

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

@@ -0,0 +1,49 @@
+import type { FloatingLayerArrowPropsWithoutHTML } from "../../internal/floating-layer/types.js";
+import type { MenuArrowProps } from "../menu/types.js";
+import type { OnChangeFn, WithChild, WithChildren, Without } from "../../internal/types.js";
+import type { BitsPrimitiveButtonAttributes, BitsPrimitiveDivAttributes } from "../../internal/attribute-types.js";
+import type { Direction } from "../../internal/index.js";
+export type MenubarRootPropsWithoutHTML = WithChild<{
+    /**
+     * The reading direction of the menubar.
+     */
+    dir?: Direction;
+    /**
+     * When `true`, the roving focus will loop back to the first menu item when the last
+     * menu item is reached and vice verse.
+     */
+    loop?: boolean;
+    /**
+     * The 'value' assigned to the currently active menu in the menubar.
+     */
+    value?: string;
+    /**
+     * A callback that is called when the active menu changes.
+     */
+    onValueChange?: OnChangeFn<string>;
+}>;
+export type MenubarRootProps = MenubarRootPropsWithoutHTML & Without<BitsPrimitiveDivAttributes, MenubarRootPropsWithoutHTML>;
+export type MenubarMenuPropsWithoutHTML = WithChildren<{
+    /**
+     * The `value` assigned to the menu. Used to programmatically control the menu's open state
+     * within the menubar.
+     */
+    value?: string;
+    /**
+     * A callback that is called when the menu is opened or closed.
+     */
+    onOpenChange?: OnChangeFn<boolean>;
+}>;
+export type MenubarMenuProps = MenubarMenuPropsWithoutHTML;
+export type MenubarTriggerPropsWithoutHTML = WithChild<{
+    /**
+     * Whether the trigger for the menubar item is disabled.
+     *
+     * @defaultValue false
+     */
+    disabled?: boolean | null | undefined;
+}>;
+export type MenubarTriggerProps = MenubarTriggerPropsWithoutHTML & Without<BitsPrimitiveButtonAttributes, MenubarTriggerPropsWithoutHTML>;
+export type { MenuContentPropsWithoutHTML as MenubarContentPropsWithoutHTML, MenuContentProps as MenubarContentProps, MenuContentStaticPropsWithoutHTML as MenubarContentStaticPropsWithoutHTML, MenuContentStaticProps as MenubarContentStaticProps, MenuItemPropsWithoutHTML as MenubarItemPropsWithoutHTML, MenuItemProps as MenubarItemProps, MenuGroupPropsWithoutHTML as MenubarGroupPropsWithoutHTML, MenuGroupProps as MenubarGroupProps, MenuGroupHeadingPropsWithoutHTML as MenubarGroupHeadingPropsWithoutHTML, MenuGroupHeadingProps as MenubarGroupHeadingProps, MenuCheckboxItemPropsWithoutHTML as MenubarCheckboxItemPropsWithoutHTML, MenuCheckboxItemProps as MenubarCheckboxItemProps, MenuRadioGroupPropsWithoutHTML as MenubarRadioGroupPropsWithoutHTML, MenuRadioGroupProps as MenubarRadioGroupProps, MenuRadioItemPropsWithoutHTML as MenubarRadioItemPropsWithoutHTML, MenuRadioItemProps as MenubarRadioItemProps, MenuSeparatorPropsWithoutHTML as MenubarSeparatorPropsWithoutHTML, MenuSeparatorProps as MenubarSeparatorProps, MenuSubContentPropsWithoutHTML as MenubarSubContentPropsWithoutHTML, MenuSubContentProps as MenubarSubContentProps, MenuSubContentStaticPropsWithoutHTML as MenubarSubContentStaticPropsWithoutHTML, MenuSubContentStaticProps as MenubarSubContentStaticProps, MenuSubTriggerPropsWithoutHTML as MenubarSubTriggerPropsWithoutHTML, MenuSubTriggerProps as MenubarSubTriggerProps, MenuSubPropsWithoutHTML as MenubarSubPropsWithoutHTML, MenuPortalPropsWithoutHTML as MenubarPortalPropsWithoutHTML, MenuPortalProps as MenubarPortalProps, MenuCheckboxGroupPropsWithoutHTML as MenubarCheckboxGroupPropsWithoutHTML, MenuCheckboxGroupProps as MenubarCheckboxGroupProps, } from "../menu/types.js";
+export type MenubarArrowPropsWithoutHTML = FloatingLayerArrowPropsWithoutHTML;
+export type MenubarArrowProps = MenuArrowProps;

package/dist/components/menubar/types.js

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

package/dist/components/meter/components/meter.svelte

@@ -0,0 +1,50 @@
+<script lang="ts">
+	import { mergeProps } from '../../../internal/merge-props.js';
+	import type { MeterRootProps } from '../types.js';
+	import { MeterRootState } from '../meter.svelte.js';
+	import { createId } from '../../../internal/create-id.js';
+
+	const uid = $props.id();
+
+	let {
+		child,
+		children,
+		value = 0,
+		max = 100,
+		min = 0,
+		id = createId(uid),
+		ref = $bindable(null),
+		...restProps
+	}: MeterRootProps = $props();
+
+	const rootState = MeterRootState.create({
+		get value() {
+			return value;
+		},
+		get max() {
+			return max;
+		},
+		get min() {
+			return min;
+		},
+		get id() {
+			return id;
+		},
+		get ref() {
+			return ref;
+		},
+		set ref(v) {
+			ref = v;
+		},
+	});
+
+	const mergedProps = $derived(mergeProps(restProps, rootState.props));
+</script>
+
+{#if child}
+	{@render child({ props: mergedProps })}
+{:else}
+	<div {...mergedProps}>
+		{@render children?.()}
+	</div>
+{/if}

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

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

package/dist/components/meter/exports.js

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

package/dist/components/meter/index.js

@@ -0,0 +1,2 @@
+export * as Meter from "./exports.js";
+export * from "./exports.js";

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

@@ -0,0 +1,23 @@
+import type { RefAttachment, RefOpts } from '../../internal/types.js';
+interface MeterRootStateOpts extends RefOpts {
+    readonly value: number;
+    readonly max: number;
+    readonly min: number;
+}
+export declare class MeterRootState {
+    static create(opts: MeterRootStateOpts): MeterRootState;
+    readonly opts: MeterRootStateOpts;
+    readonly attachment: RefAttachment;
+    constructor(opts: MeterRootStateOpts);
+    readonly props: {
+        readonly role: "meter";
+        readonly value: number;
+        readonly 'aria-valuemin': number;
+        readonly 'aria-valuemax': number;
+        readonly 'aria-valuenow': number;
+        readonly 'data-value': number;
+        readonly 'data-max': number;
+        readonly 'data-min': number;
+    };
+}
+export {};

package/dist/components/meter/meter.svelte.js

@@ -0,0 +1,29 @@
+import { attachRef } from '../../internal/tools/index.js';
+import { createBitsAttrs } from '../../internal/attrs.js';
+const meterAttrs = createBitsAttrs({
+    component: 'meter',
+    parts: ['root'],
+});
+export class MeterRootState {
+    static create(opts) {
+        return new MeterRootState(opts);
+    }
+    opts;
+    attachment;
+    constructor(opts) {
+        this.opts = opts;
+        this.attachment = attachRef((v) => (opts.ref = v));
+    }
+    props = $derived.by(() => ({
+        role: 'meter',
+        value: this.opts.value,
+        'aria-valuemin': this.opts.min,
+        'aria-valuemax': this.opts.max,
+        'aria-valuenow': this.opts.value,
+        'data-value': this.opts.value,
+        'data-max': this.opts.max,
+        'data-min': this.opts.min,
+        [meterAttrs.root]: '',
+        ...this.attachment,
+    }));
+}

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

@@ -0,0 +1,23 @@
+import type { WithChild, Without } from "../../internal/types.js";
+import type { BitsPrimitiveDivAttributes } from "../../internal/attribute-types.js";
+export type MeterRootPropsWithoutHTML = WithChild<{
+    /**
+     * The current value of the meter.
+     *
+     * @default 0
+     */
+    value?: number;
+    /**
+     * The maximum value of the meter.
+     *
+     * @default 100
+     */
+    max?: number;
+    /**
+     * The minimum value of the meter.
+     *
+     * @default 0
+     */
+    min?: number;
+}>;
+export type MeterRootProps = MeterRootPropsWithoutHTML & Without<BitsPrimitiveDivAttributes, MeterRootPropsWithoutHTML>;

package/dist/components/meter/types.js

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

package/dist/components/navigation-menu/components/navigation-menu-content-impl.svelte.d.ts

@@ -0,0 +1,14 @@
+import { type Snippet } from 'svelte';
+import type { NavigationMenuContentProps } from '../types.js';
+import { NavigationMenuItemState } from '../navigation-menu.svelte.js';
+type $$ComponentProps = Omit<NavigationMenuContentProps, 'child'> & {
+    itemState?: NavigationMenuItemState;
+    onRefChange?: (ref: HTMLElement | null) => void;
+    child?: Snippet<[{
+        props: Record<string, unknown>;
+        open: boolean;
+    }]>;
+};
+declare const NavigationMenuContentImpl: import("svelte").Component<$$ComponentProps, {}, "ref">;
+type NavigationMenuContentImpl = ReturnType<typeof NavigationMenuContentImpl>;
+export default NavigationMenuContentImpl;

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

@@ -0,0 +1,8 @@
+import type { ClassValue } from 'svelte/elements';
+import type { NavigationMenuContentProps } from '../types.js';
+type $$ComponentProps = NavigationMenuContentProps & {
+    class?: ClassValue;
+};
+declare const NavigationMenuContent: import("svelte").Component<$$ComponentProps, {}, "ref">;
+type NavigationMenuContent = ReturnType<typeof NavigationMenuContent>;
+export default NavigationMenuContent;

package/dist/components/navigation-menu/components/navigation-menu-indicator-impl.svelte.d.ts

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

package/dist/components/navigation-menu/components/navigation-menu-indicator.svelte.d.ts

@@ -0,0 +1,8 @@
+import type { ClassValue } from 'svelte/elements';
+import type { NavigationMenuIndicatorProps } from '../types.js';
+type $$ComponentProps = NavigationMenuIndicatorProps & {
+    class?: ClassValue;
+};
+declare const NavigationMenuIndicator: import("svelte").Component<$$ComponentProps, {}, "ref">;
+type NavigationMenuIndicator = ReturnType<typeof NavigationMenuIndicator>;
+export default NavigationMenuIndicator;

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

@@ -0,0 +1,8 @@
+import type { ClassValue } from 'svelte/elements';
+import type { NavigationMenuItemProps } from '../types.js';
+type $$ComponentProps = NavigationMenuItemProps & {
+    class?: ClassValue;
+};
+declare const NavigationMenuItem: import("svelte").Component<$$ComponentProps, {}, "ref">;
+type NavigationMenuItem = ReturnType<typeof NavigationMenuItem>;
+export default NavigationMenuItem;

package/dist/components/navigation-menu/components/navigation-menu-link.svelte.d.ts

@@ -0,0 +1,8 @@
+import type { ClassValue } from 'svelte/elements';
+import type { NavigationMenuLinkProps } from '../types.js';
+type $$ComponentProps = NavigationMenuLinkProps & {
+    class?: ClassValue;
+};
+declare const NavigationMenuLink: import("svelte").Component<$$ComponentProps, {}, "ref">;
+type NavigationMenuLink = ReturnType<typeof NavigationMenuLink>;
+export default NavigationMenuLink;

package/dist/components/navigation-menu/components/navigation-menu-list.svelte.d.ts

@@ -0,0 +1,8 @@
+import type { ClassValue } from 'svelte/elements';
+import type { NavigationMenuListProps } from '../types.js';
+type $$ComponentProps = NavigationMenuListProps & {
+    class?: ClassValue;
+};
+declare const NavigationMenuList: import("svelte").Component<$$ComponentProps, {}, "ref">;
+type NavigationMenuList = ReturnType<typeof NavigationMenuList>;
+export default NavigationMenuList;

package/dist/components/navigation-menu/components/navigation-menu-sub.svelte.d.ts

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

package/dist/components/navigation-menu/components/navigation-menu-trigger.svelte.d.ts

@@ -0,0 +1,9 @@
+export declare const navigationMenuTriggerStyle: import("overrule").VariantFn<Record<never, never>>;
+import type { ClassValue } from 'svelte/elements';
+import type { NavigationMenuTriggerProps } from '../types.js';
+type $$ComponentProps = NavigationMenuTriggerProps & {
+    class?: ClassValue;
+};
+declare const NavigationMenuTrigger: import("svelte").Component<$$ComponentProps, {}, "ref">;
+type NavigationMenuTrigger = ReturnType<typeof NavigationMenuTrigger>;
+export default NavigationMenuTrigger;

package/dist/components/navigation-menu/components/navigation-menu-viewport.svelte.d.ts

@@ -0,0 +1,8 @@
+import type { ClassValue } from 'svelte/elements';
+import type { NavigationMenuViewportProps } from '../types.js';
+type $$ComponentProps = NavigationMenuViewportProps & {
+    class?: ClassValue;
+};
+declare const NavigationMenuViewport: import("svelte").Component<$$ComponentProps, {}, "ref">;
+type NavigationMenuViewport = ReturnType<typeof NavigationMenuViewport>;
+export default NavigationMenuViewport;

package/dist/components/navigation-menu/components/navigation-menu.svelte.d.ts

@@ -0,0 +1,9 @@
+import type { ClassValue } from 'svelte/elements';
+import type { NavigationMenuRootProps } from '../types.js';
+type $$ComponentProps = NavigationMenuRootProps & {
+    viewport?: boolean;
+    class?: ClassValue;
+};
+declare const NavigationMenu: import("svelte").Component<$$ComponentProps, {}, "ref" | "value">;
+type NavigationMenu = ReturnType<typeof NavigationMenu>;
+export default NavigationMenu;

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

@@ -0,0 +1,9 @@
+import Root from './components/navigation-menu.svelte';
+import Content from './components/navigation-menu-content.svelte';
+import Indicator from './components/navigation-menu-indicator.svelte';
+import Item from './components/navigation-menu-item.svelte';
+import Link from './components/navigation-menu-link.svelte';
+import List from './components/navigation-menu-list.svelte';
+import Trigger from './components/navigation-menu-trigger.svelte';
+import Viewport from './components/navigation-menu-viewport.svelte';
+export { Root, Content, Indicator, Item, Link, List, Trigger, Viewport, Root as NavigationMenuRoot, Content as NavigationMenuContent, Indicator as NavigationMenuIndicator, Item as NavigationMenuItem, Link as NavigationMenuLink, List as NavigationMenuList, Trigger as NavigationMenuTrigger, Viewport as NavigationMenuViewport, };

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

@@ -0,0 +1,11 @@
+import Root from './components/navigation-menu.svelte';
+import Content from './components/navigation-menu-content.svelte';
+import Indicator from './components/navigation-menu-indicator.svelte';
+import Item from './components/navigation-menu-item.svelte';
+import Link from './components/navigation-menu-link.svelte';
+import List from './components/navigation-menu-list.svelte';
+import Trigger from './components/navigation-menu-trigger.svelte';
+import Viewport from './components/navigation-menu-viewport.svelte';
+export { Root, Content, Indicator, Item, Link, List, Trigger, Viewport, 
+//
+Root as NavigationMenuRoot, Content as NavigationMenuContent, Indicator as NavigationMenuIndicator, Item as NavigationMenuItem, Link as NavigationMenuLink, List as NavigationMenuList, Trigger as NavigationMenuTrigger, Viewport as NavigationMenuViewport, };