@urbicon-ui/blocks 6.1.4

package/dist/primitives/Menu/MenuDivider.svelte

@@ -0,0 +1,15 @@
+<script lang="ts">
+  import { getMenuContext } from './menu.context';
+
+  const ctx = getMenuContext();
+  if (!ctx) {
+    throw new Error('MenuDivider must be used inside Menu');
+  }
+</script>
+
+<div
+  class={ctx.unstyled
+    ? (ctx.slotClasses?.divider ?? '')
+    : ctx.styles.divider({ class: ctx.slotClasses?.divider })}
+  role="separator"
+></div>

package/dist/primitives/Menu/MenuDivider.svelte.d.ts

@@ -0,0 +1,18 @@
+interface $$__sveltets_2_IsomorphicComponent<Props extends Record<string, any> = any, Events extends Record<string, any> = any, Slots extends Record<string, any> = any, Exports = {}, Bindings = string> {
+    new (options: import('svelte').ComponentConstructorOptions<Props>): import('svelte').SvelteComponent<Props, Events, Slots> & {
+        $$bindings?: Bindings;
+    } & Exports;
+    (internal: unknown, props: {
+        $$events?: Events;
+        $$slots?: Slots;
+    }): Exports & {
+        $set?: any;
+        $on?: any;
+    };
+    z_$$bindings?: Bindings;
+}
+declare const MenuDivider: $$__sveltets_2_IsomorphicComponent<Record<string, never>, {
+    [evt: string]: CustomEvent<any>;
+}, {}, {}, string>;
+type MenuDivider = InstanceType<typeof MenuDivider>;
+export default MenuDivider;

package/dist/primitives/Menu/MenuItem.svelte

@@ -0,0 +1,132 @@
+<script lang="ts">
+  import type { Snippet } from 'svelte';
+  import { getMenuContext, getMenuParentId } from './menu.context';
+
+  let {
+    id: idProp,
+    label,
+    disabled = false,
+    icon,
+    onSelect,
+    keepOpen = false,
+    children,
+    class: className = ''
+  }: {
+    /** Stable id for sub-menu bookkeeping. Auto-generated when omitted. */
+    id?: string;
+    /** Display label. Falls back to the slot's text content. */
+    label?: string;
+    /** @default false */
+    disabled?: boolean;
+    /** Optional leading icon component. */
+    icon?: unknown;
+    /** Invoked when the item is activated (click / Enter / Space). */
+    onSelect?: () => void;
+    /**
+     * Keep the menu open after activation. Useful for repeated actions like
+     * "Add tag" where the user picks several entries in a row.
+     * @default false
+     */
+    keepOpen?: boolean;
+    children?: Snippet;
+    class?: string;
+  } = $props();
+
+  const ctx = getMenuContext();
+  const parentId = getMenuParentId();
+
+  if (!ctx) {
+    throw new Error('MenuItem must be used inside Menu');
+  }
+
+  const propsId = $props.id();
+  const itemId = $derived(idProp ?? `item-${propsId}`);
+
+  let labelSpanRef = $state<HTMLSpanElement>();
+  let buttonRef = $state<HTMLButtonElement>();
+
+  $effect(() => {
+    const textLabel = labelSpanRef?.textContent?.trim();
+    const effectiveLabel = label ?? textLabel ?? itemId;
+    ctx.registerItem({
+      id: itemId,
+      label: effectiveLabel,
+      disabled,
+      parentId: parentId ?? null
+    });
+    return () => ctx.unregisterItem(itemId);
+  });
+
+  /**
+   * Activate the item: fire the consumer's `onSelect` exactly once and then
+   * let the Menu close (or keep open) via `ctx.onItemActivated`. This is the
+   * single dispatch path — the wrapping Menu does *not* fire `onSelect`
+   * separately, so a consumer's `onSelect` always runs exactly once per
+   * activation regardless of whether the item came from `items[]` or from
+   * a declarative `<MenuItem>`.
+   */
+  function activate(e?: MouseEvent | KeyboardEvent) {
+    if (disabled) return;
+    e?.stopPropagation();
+    onSelect?.();
+    ctx.onItemActivated(keepOpen);
+  }
+
+  function onKeydown(e: KeyboardEvent) {
+    switch (e.key) {
+      case 'Enter':
+      case ' ':
+        e.preventDefault();
+        activate(e);
+        break;
+      case 'ArrowDown':
+        e.preventDefault();
+        if (buttonRef) ctx.focusNextItem(buttonRef);
+        break;
+      case 'ArrowUp':
+        e.preventDefault();
+        if (buttonRef) ctx.focusPrevItem(buttonRef);
+        break;
+    }
+  }
+
+  const itemSizeVariant = $derived<'sm' | 'md' | 'lg'>(ctx.itemSizeForDepth(parentId ? 1 : 0));
+</script>
+
+<button
+  bind:this={buttonRef}
+  id={`${ctx.rootId}-item-${itemId}`}
+  type="button"
+  {disabled}
+  onclick={activate}
+  onkeydown={onKeydown}
+  role="menuitem"
+  tabindex={-1}
+  aria-disabled={disabled || undefined}
+  class={ctx.unstyled
+    ? [ctx.slotClasses?.item, className].filter(Boolean).join(' ')
+    : ctx.styles.item({
+        itemSize: itemSizeVariant,
+        disabled,
+        class: [ctx.slotClasses?.item, className]
+      })}
+  data-mint={ctx.mint}
+>
+  {#if icon}
+    {@const Icon = icon as import('svelte').Component<{ class?: string }>}
+    <span
+      class={ctx.unstyled
+        ? (ctx.slotClasses?.indicator ?? '')
+        : ctx.styles.indicator({ class: ctx.slotClasses?.indicator })}
+    >
+      <Icon class="h-4 w-4" />
+    </span>
+  {/if}
+  <span bind:this={labelSpanRef} class="flex-1 truncate text-left">
+    {#if children}
+      {@render children()}
+    {:else if label != null}
+      {label}
+    {/if}
+  </span>
+</button>

package/dist/primitives/Menu/MenuItem.svelte.d.ts

@@ -0,0 +1,24 @@
+import type { Snippet } from 'svelte';
+type $$ComponentProps = {
+    /** Stable id for sub-menu bookkeeping. Auto-generated when omitted. */
+    id?: string;
+    /** Display label. Falls back to the slot's text content. */
+    label?: string;
+    /** @default false */
+    disabled?: boolean;
+    /** Optional leading icon component. */
+    icon?: unknown;
+    /** Invoked when the item is activated (click / Enter / Space). */
+    onSelect?: () => void;
+    /**
+     * Keep the menu open after activation. Useful for repeated actions like
+     * "Add tag" where the user picks several entries in a row.
+     * @default false
+     */
+    keepOpen?: boolean;
+    children?: Snippet;
+    class?: string;
+};
+declare const MenuItem: import("svelte").Component<$$ComponentProps, {}, "">;
+type MenuItem = ReturnType<typeof MenuItem>;
+export default MenuItem;

package/dist/primitives/Menu/MenuSection.svelte

@@ -0,0 +1,18 @@
+<script lang="ts">
+  import type { Snippet } from 'svelte';
+  import { getMenuContext } from './menu.context';
+
+  let { label, children }: { label?: string; children?: Snippet } = $props();
+  const ctx = getMenuContext();
+  if (!ctx) {
+    throw new Error('MenuSection must be used inside Menu');
+  }
+</script>
+
+<div class={ctx.styles.section()} role="separator">
+  {#if children}
+    {@render children()}
+  {:else}
+    {label}
+  {/if}
+</div>

package/dist/primitives/Menu/MenuSection.svelte.d.ts

@@ -0,0 +1,8 @@
+import type { Snippet } from 'svelte';
+type $$ComponentProps = {
+    label?: string;
+    children?: Snippet;
+};
+declare const MenuSection: import("svelte").Component<$$ComponentProps, {}, "">;
+type MenuSection = ReturnType<typeof MenuSection>;
+export default MenuSection;

package/dist/primitives/Menu/MenuSubmenu.svelte

@@ -0,0 +1,137 @@
+<script lang="ts">
+  import type { Snippet } from 'svelte';
+  import { resolveIcon } from '../../icons';
+  import ChevronRightIconDefault from '../../icons/ChevronRightIcon.svelte';
+  import { getMenuContext, setMenuParentId } from './menu.context';
+  import MenuItemComp from './MenuItem.svelte';
+  import type { MenuItemType, MenuObjectOption, MenuSectionHeader } from './index';
+
+  const ChevronRightIcon = resolveIcon('chevronRight', ChevronRightIconDefault);
+
+  let {
+    id,
+    label,
+    disabled = false,
+    icon,
+    items,
+    children
+  }: {
+    /** Stable id for sub-menu bookkeeping. */
+    id: string;
+    /** Visible label on the parent menu row. */
+    label?: string;
+    /** @default false */
+    disabled?: boolean;
+    /** Optional leading icon component. */
+    icon?: unknown;
+    /**
+     * Array-shape children — used when Menu's parent `items` array contains a
+     * `MenuObjectOption` with `children: MenuItemType[]`. Mutually exclusive
+     * with the `children` snippet.
+     */
+    items?: MenuItemType[];
+    /**
+     * Declarative-shape children — used inside `<MenuSubmenu><MenuItem …/></MenuSubmenu>`.
+     */
+    children?: Snippet;
+  } = $props();
+
+  const ctx = getMenuContext();
+  if (!ctx) throw new Error('MenuSubmenu must be used inside Menu');
+
+  const isOpen = $derived(ctx.isSubMenuOpen(id));
+
+  // Provide parent id to descendants exactly once per component instance
+  // so that nested MenuItem components can register with correct parent.
+  setMenuParentId(id);
+
+  function toggleOpen() {
+    if (disabled) return;
+    ctx.toggleSubMenu(id);
+  }
+
+  function onKeydown(e: KeyboardEvent) {
+    if (e.key === 'Enter' || e.key === ' ' || e.key === 'ArrowRight') {
+      e.preventDefault();
+      toggleOpen();
+    } else if (e.key === 'ArrowLeft' && isOpen) {
+      e.preventDefault();
+      toggleOpen();
+    }
+  }
+
+  function isSectionItem(it: MenuItemType): it is MenuSectionHeader {
+    return typeof it === 'object' && it !== null && (it as MenuSectionHeader).type === 'section';
+  }
+
+  function resolveLabel(item: MenuItemType): string {
+    if (typeof item === 'string') return item;
+    if (isSectionItem(item)) return item.label;
+    return ((item as MenuObjectOption).label as string | undefined) ?? '';
+  }
+
+  function resolveId(item: MenuItemType, fallbackIndex: number): string {
+    if (typeof item === 'string') return item;
+    if (isSectionItem(item)) return `section-${fallbackIndex}`;
+    return ((item as MenuObjectOption).id as string | undefined) ?? `item-${fallbackIndex}`;
+  }
+</script>
+
+<button
+  id={`${ctx.rootId}-submenu-${id}`}
+  type="button"
+  {disabled}
+  onclick={toggleOpen}
+  onkeydown={onKeydown}
+  role="menuitem"
+  tabindex={-1}
+  aria-haspopup="menu"
+  aria-expanded={isOpen}
+  aria-disabled={disabled || undefined}
+  class={ctx.styles.item({ itemSize: ctx.itemSizeForDepth(0), disabled })}
+  data-mint={ctx.mint}
+>
+  {#if icon}
+    {@const Icon = icon as import('svelte').Component<{ class?: string }>}
+    <span
+      class={ctx.unstyled
+        ? (ctx.slotClasses?.indicator ?? '')
+        : ctx.styles.indicator({ class: ctx.slotClasses?.indicator })}
+    >
+      <Icon class="h-4 w-4" />
+    </span>
+  {/if}
+  <span class="flex-1 truncate text-left">{label}</span>
+  <ChevronRightIcon class="h-4 w-4 opacity-70" />
+</button>
+
+{#if isOpen}
+  <div role="menu" class={ctx.styles.submenu()}>
+    {#if items && items.length > 0}
+      {#each items as child, i (resolveId(child, i))}
+        {#if isSectionItem(child)}
+          <div
+            role="presentation"
+            class={ctx.unstyled
+              ? (ctx.slotClasses?.section ?? '')
+              : ctx.styles.section({ class: ctx.slotClasses?.section })}
+          >
+            {child.label}
+          </div>
+        {:else}
+          {@const childOpt = typeof child === 'object' ? (child as MenuObjectOption) : null}
+          <MenuItemComp
+            id={resolveId(child, i)}
+            label={resolveLabel(child)}
+            disabled={Boolean(childOpt?.disabled)}
+            icon={childOpt?.icon}
+            onSelect={childOpt?.onSelect}
+            keepOpen={childOpt?.keepOpen}
+          />
+        {/if}
+      {/each}
+    {:else if children}
+      {@render children()}
+    {/if}
+  </div>
+{/if}

package/dist/primitives/Menu/MenuSubmenu.svelte.d.ts

@@ -0,0 +1,25 @@
+import type { Snippet } from 'svelte';
+import type { MenuItemType } from './index';
+type $$ComponentProps = {
+    /** Stable id for sub-menu bookkeeping. */
+    id: string;
+    /** Visible label on the parent menu row. */
+    label?: string;
+    /** @default false */
+    disabled?: boolean;
+    /** Optional leading icon component. */
+    icon?: unknown;
+    /**
+     * Array-shape children — used when Menu's parent `items` array contains a
+     * `MenuObjectOption` with `children: MenuItemType[]`. Mutually exclusive
+     * with the `children` snippet.
+     */
+    items?: MenuItemType[];
+    /**
+     * Declarative-shape children — used inside `<MenuSubmenu><MenuItem …/></MenuSubmenu>`.
+     */
+    children?: Snippet;
+};
+declare const MenuSubmenu: import("svelte").Component<$$ComponentProps, {}, "">;
+type MenuSubmenu = ReturnType<typeof MenuSubmenu>;
+export default MenuSubmenu;

package/dist/primitives/Menu/index.d.ts

@@ -0,0 +1,279 @@
+import type { Snippet } from 'svelte';
+import type { HTMLAttributes } from 'svelte/elements';
+import type { MintProp } from '../../mint';
+import type { ButtonVariants, MenuVariants } from '..';
+import type { AnimationProps } from '../../utils';
+import type { Placement } from '../../utils/floating';
+import type { InteractiveTier } from '../../utils/tier-context';
+/**
+ * @description Action menu (`role="menu"`) triggered by a button. Items are
+ * verbs the user can invoke — Edit, Delete, Share, Export — and dispatch an
+ * `onSelect` callback when activated. For picking a value from a list use
+ * `Select` (or `Combobox` for searchable). Menu and Select are deliberately
+ * disjoint: Menu's ARIA semantics, keyboard model (Tab through items, Enter
+ * triggers), and visual chrome match the Action surface family; Select's
+ * `role="listbox"` + arrow-navigation match the Form surface family.
+ *
+ * @tag action
+ * @related Select
+ * @related Combobox
+ * @related Popover
+ *
+ * @example Items array with `onSelect` callbacks
+ * ```svelte
+ * <Menu placeholder="Actions" items={[
+ *   { label: 'Edit', onSelect: () => edit() },
+ *   { label: 'Duplicate', onSelect: () => duplicate() },
+ *   { type: 'section', label: 'Danger' },
+ *   { label: 'Delete', onSelect: () => confirmDelete() }
+ * ]} />
+ * ```
+ *
+ * @example Declarative children with MenuItem
+ * ```svelte
+ * <Menu placeholder="More">
+ *   <MenuSection label="Edit" />
+ *   <MenuItem onSelect={() => rename()}>Rename</MenuItem>
+ *   <MenuItem onSelect={() => duplicate()}>Duplicate</MenuItem>
+ *   <MenuDivider />
+ *   <MenuItem onSelect={() => confirmDelete()}>Delete</MenuItem>
+ * </Menu>
+ * ```
+ *
+ * @example Icon-only trigger via customTrigger
+ * ```svelte
+ * <Menu items={actionItems}>
+ *   {#snippet customTrigger(toggle, open)}
+ *     <Button
+ *       variant="ghost"
+ *       aria-label="Actions"
+ *       aria-haspopup="menu"
+ *       aria-expanded={open}
+ *       onclick={toggle}
+ *     >
+ *       <MoreHorizontalIcon />
+ *     </Button>
+ *   {/snippet}
+ * </Menu>
+ * ```
+ */
+export interface MenuSpecificProps<TItem extends MenuItemType = MenuItemType> {
+    /** Array of menu items. Each item's `onSelect` runs when activated. */
+    items?: TItem[];
+    /** Declarative children mode — use `<MenuItem>` / `<MenuDivider>` / `<MenuSection>`. */
+    children?: Snippet;
+    /**
+     * Remove default tailwind-variants classes. Only user-supplied classes apply.
+     * @default false
+     */
+    unstyled?: boolean;
+    /**
+     * Per-slot class overrides merged with tailwind-variants styles.
+     */
+    slotClasses?: Partial<Record<'base' | 'trigger' | 'triggerText' | 'chevron' | 'content' | 'header' | 'section' | 'divider' | 'items' | 'item' | 'indicator' | 'submenu' | 'footer', string>>;
+    /**
+     * Apply a named preset registered via `<BlocksProvider presets={{ Menu: {...} }}>`.
+     * Prefer this over `class` overrides when the requested look falls outside the
+     * semantic intent palette — presets keep hover/active/dark-mode logic coherent
+     * and make the custom look reusable across the project.
+     */
+    preset?: string;
+    /**
+     * Placeholder text shown on the default trigger. Acts as the trigger's
+     * accessible name unless `aria-label` is supplied. Typical values: "Actions",
+     * "More", "Options". Ignored when `customTrigger` is provided.
+     */
+    placeholder?: string;
+    /** Optional mapping functions for custom item shapes. */
+    getItemLabel?: (item: TItem) => string;
+    getItemId?: (item: TItem) => string;
+    getItemDisabled?: (item: TItem) => boolean;
+    getItemChildren?: (item: TItem) => TItem[] | undefined;
+    /** Optional icon resolver for items in array mode. */
+    getItemIcon?: (item: TItem) => unknown;
+    /** Section detection override. Applies to full union, not just TItem. */
+    isSection?: (item: MenuItemType) => boolean;
+    /** Section label override. Accepts concrete section header type. */
+    getSectionLabel?: (item: MenuSectionHeader) => string;
+    /**
+     * Where the menu panel appears relative to the trigger. Uses floating-ui
+     * placement. @default 'bottom-start'
+     */
+    placement?: Placement;
+    /**
+     * Syncs the width of the menu panel with the trigger element.
+     * @default true
+     */
+    syncWidth?: boolean;
+    /**
+     * Render menu content in a portal for better positioning.
+     * Prevents menu from being clipped by overflow containers.
+     * @default true
+     */
+    usePortal?: boolean;
+    /**
+     * Controls the open state of the menu. Supports `bind:open`.
+     * @default false
+     */
+    open?: boolean;
+    /**
+     * Button variant applied to the default trigger button.
+     * @default 'outlined'
+     */
+    variant?: ButtonVariants['variant'];
+    /**
+     * Button size applied to the default trigger button.
+     * @default 'md'
+     */
+    size?: ButtonVariants['size'];
+    /**
+     * Size of the menu list items, independent from the trigger size.
+     * When not set, item size is derived from the trigger `size` prop.
+     * @default undefined
+     */
+    itemSize?: 'sm' | 'md' | 'lg';
+    /**
+     * Button intent applied to the default trigger button.
+     * @default 'neutral'
+     */
+    intent?: ButtonVariants['intent'];
+    /**
+     * Semantic radius tier applied to the default trigger button. Menu is an
+     * Action surface, so the default is `commit` (pill) to match the Action
+     * family — consistent with `<Button>`. Set to `'modify'` when the trigger
+     * lives inside a Toolbar/ButtonGroup that propagates a different tier.
+     * @default 'commit'
+     */
+    tier?: InteractiveTier;
+    /**
+     * Whether the default trigger button is in loading state.
+     * @default false
+     */
+    loading?: boolean;
+    /**
+     * Whether the menu is disabled.
+     * @default false
+     */
+    disabled?: boolean;
+    /**
+     * Micro-interaction patterns for enhanced user feedback. Defaults to
+     * `'none'` — Action menus benefit from a clean, predictable feel.
+     * @default 'none'
+     */
+    mint?: MintProp;
+}
+/**
+ * @description Action menu triggered by a button with nested items, icons, separators, and keyboard navigation.
+ *
+ * @tag action
+ * @related Select
+ * @related Combobox
+ * @related Popover
+ */
+export interface MenuProps<TItem extends MenuItemType = MenuItemType> extends MenuVariants, Omit<MenuSpecificProps<TItem>, keyof MenuVariants>, MenuCustomSlots<TItem>, AnimationProps, Omit<HTMLAttributes<HTMLDivElement>, 'children' | 'class' | 'placeholder'> {
+    class?: string;
+    id?: string;
+}
+/**
+ * Shorthand item form: the string is the label and serves as the item's
+ * stable id (for sub-menu bookkeeping). Use `MenuObjectOption` to attach
+ * an `onSelect` callback or other rich item state.
+ */
+export type MenuOption = string;
+/**
+ * Section header item for grouping related menu options.
+ */
+export interface MenuSectionHeader {
+    type: 'section';
+    label: string;
+    disabled?: true;
+}
+/**
+ * Menu item with explicit label, action callback, and optional nested
+ * children. Menu items are *verbs* — the `id` is only an internal stable
+ * identifier for sub-menu bookkeeping and DOM `id` derivation, not a
+ * selectable value. (Menu has no selection state — for value-picking use
+ * `Select`.)
+ */
+export interface MenuObjectOption {
+    /** Display text for the action. */
+    label: string;
+    /**
+     * Stable identifier for sub-menu nesting and DOM id derivation. Optional:
+     * when omitted, the rendered position is used as a fallback key. Provide
+     * a stable id when items can reorder or when you need to address an item
+     * from tests / e2e selectors.
+     */
+    id?: string;
+    /**
+     * Whether the action is disabled.
+     * @default false
+     */
+    disabled?: boolean;
+    /** Optional leading icon component. */
+    icon?: unknown;
+    /**
+     * Action invoked when the user activates this item (click or Enter / Space).
+     * The Menu closes after `onSelect` runs unless `keepOpen` is set.
+     */
+    onSelect?: () => void;
+    /**
+     * Keep the menu open after this item is activated. Useful for repeated
+     * actions (e.g. "Add tag") where the user typically picks several in a row.
+     * @default false
+     */
+    keepOpen?: boolean;
+    /** Nested child options for hierarchical menus. */
+    children?: MenuItemType[];
+}
+/**
+ * Union of all supported menu item shapes.
+ *
+ * - string: simple item label (value equals label)
+ * - MenuObjectOption: rich item with label/onSelect and optional children
+ * - MenuSectionHeader: non-selectable header grouping the following items
+ */
+export type MenuItemType = MenuOption | MenuObjectOption | MenuSectionHeader;
+export interface MenuCustomSlots<TItem extends MenuItemType = MenuItemType> {
+    /**
+     * Replace the default trigger button (chevron + label) with a custom element.
+     * Positional args: `(toggle, open, dismiss)`.
+     *
+     * - `toggle`: flips the open state — wire this to your custom trigger's
+     *   click handler so the menu can be opened from the consumer's element.
+     * - `open`: current open state — useful for `aria-expanded`.
+     * - `dismiss`: closes the menu without changing toggle history; rarely
+     *   needed but provided for symmetry.
+     *
+     * The consumer's element should bind its `onclick` to `toggle` and set
+     * `aria-expanded={open}` + `aria-haspopup="menu"` for ARIA correctness.
+     */
+    customTrigger?: Snippet<[() => void, boolean, () => void]>;
+    /**
+     * Custom per-item content. **Render visible content only** — the outer
+     * `role="menuitem"` button is provided by Menu and handles the click /
+     * keyboard activation. Putting an interactive element (`<button>`, `<a>`)
+     * inside the snippet creates nested-interactive HTML and triggers the
+     * item's action twice via event bubbling.
+     *
+     * Positional arg: `(item)`. To dispatch from outside the normal click
+     * (e.g. a "Recent" entry that needs to activate from a parent shortcut),
+     * call the item's own `onSelect` directly.
+     */
+    customItem?: Snippet<[TItem]>;
+    /**
+     * Optional custom header rendered above the items list.
+     */
+    customHeader?: Snippet;
+    /**
+     * Optional custom footer rendered below the items list.
+     */
+    customFooter?: Snippet;
+}
+export { default as Menu } from './Menu.svelte';
+export { default as MenuDivider } from './MenuDivider.svelte';
+export { default as MenuItem } from './MenuItem.svelte';
+export { default as MenuSection } from './MenuSection.svelte';
+export { default as MenuSubmenu } from './MenuSubmenu.svelte';
+export type { MenuContext, MenuRegistryItem } from './menu.context';
+export { type MenuIconVariants, type MenuVariants, menuIconVariants, menuVariants } from './menu.variants';

package/dist/primitives/Menu/index.js

@@ -0,0 +1,6 @@
+export { default as Menu } from './Menu.svelte';
+export { default as MenuDivider } from './MenuDivider.svelte';
+export { default as MenuItem } from './MenuItem.svelte';
+export { default as MenuSection } from './MenuSection.svelte';
+export { default as MenuSubmenu } from './MenuSubmenu.svelte';
+export { menuIconVariants, menuVariants } from './menu.variants';