mtrl 0.2.7 → 0.2.8

package/src/components/menu/features/items-manager.ts

@@ -1,6 +1,6 @@
 // src/components/menu/features/items-manager.ts
 import { createMenuItem } from '../menu-item';
-import { MENU_EVENTS } from '../constants';
+import { MENU_EVENT } from '../utils';
 import { BaseComponent, MenuConfig, MenuItemConfig, MenuItemData } from '../types';
 
 interface SubmenuMap {
@@ -63,8 +63,8 @@ export const withItemsManager = (config: MenuConfig) => (component: BaseComponen
     });
 
     // Handle submenu selection
-    submenu.on?.(MENU_EVENTS.SELECT, (detail: any) => {
-      component.emit?.(MENU_EVENTS.SELECT, {
+    submenu.on?.(MENU_EVENT.SELECT, (detail: any) => {
+      component.emit?.(MENU_EVENT.SELECT, {
         name: `${name}:${detail.name}`,
         text: detail.text,
         path: [name, detail.name]
@@ -116,7 +116,7 @@ export const withItemsManager = (config: MenuConfig) => (component: BaseComponen
       });
 
       // Emit submenu open event
-      component.emit?.(MENU_EVENTS.SUBMENU_OPEN, { name });
+      component.emit?.(MENU_EVENT.SUBMENU_OPEN, { name });
     }
   };
 
@@ -143,7 +143,7 @@ export const withItemsManager = (config: MenuConfig) => (component: BaseComponen
     activeSubmenu = null;
 
     // Emit submenu close event
-    component.emit?.(MENU_EVENTS.SUBMENU_CLOSE, { name });
+    component.emit?.(MENU_EVENT.SUBMENU_CLOSE, { name });
   };
 
   /**
@@ -160,7 +160,7 @@ export const withItemsManager = (config: MenuConfig) => (component: BaseComponen
     
     // Cancel any pending close timer for this item
     if (closeTimers.has(name)) {
-      window.clearTimeout(closeTimers.get(name));
+      window.clearTimeout(closeTimers.get(name)!);
       closeTimers.delete(name);
     }
     
@@ -194,7 +194,7 @@ export const withItemsManager = (config: MenuConfig) => (component: BaseComponen
     if (submenu && submenu.element) {
       // Cancel any existing close timer for this item
       if (closeTimers.has(name)) {
-        window.clearTimeout(closeTimers.get(name));
+        window.clearTimeout(closeTimers.get(name)!);
       }
 
       // Set a new close timer
@@ -254,7 +254,7 @@ export const withItemsManager = (config: MenuConfig) => (component: BaseComponen
     // For regular items, emit select event
     const name = item.getAttribute('data-name');
     if (name) {
-      component.emit?.(MENU_EVENTS.SELECT, { name, text: item.textContent });
+      component.emit?.(MENU_EVENT.SELECT, { name, text: item.textContent });
       // Hide menu after selection unless configured otherwise
       if (!config.stayOpenOnSelect) {
         component.hide?.();
@@ -430,7 +430,7 @@ export const withItemsManager = (config: MenuConfig) => (component: BaseComponen
 
     /**
      * Gets all registered items
-     * @returns {Map<string, MenuItemConfig>} Map of item names to configurations
+     * @returns {Map<string, MenuItemData>} Map of item names to data
      */
     getItems(): Map<string, MenuItemData> {
       const result = new Map<string, MenuItemData>();

package/src/components/menu/features/positioning.ts

@@ -1,6 +1,6 @@
 // src/components/menu/features/positioning.ts
 import { BaseComponent, MenuPositionConfig, MenuPosition } from '../types';
-import { MENU_ALIGN, MENU_VERTICAL_ALIGN } from '../constants';
+import { MENU_ALIGNMENT, MENU_VERTICAL_ALIGNMENT } from '../utils';
 
 /**
  * Positions a menu element relative to a target element
@@ -34,8 +34,8 @@ export const positionMenu = (
   menuElement.style.opacity = originalOpacity;
 
   const {
-    align = MENU_ALIGN.LEFT,
-    vAlign = MENU_VERTICAL_ALIGN.BOTTOM,
+    align = MENU_ALIGNMENT.LEFT,
+    vAlign = MENU_VERTICAL_ALIGNMENT.BOTTOM,
     offsetX = 0,
     offsetY = 0
   } = options;
@@ -44,16 +44,16 @@ export const positionMenu = (
   let top = targetRect.bottom + offsetY;
 
   // Handle horizontal alignment
-  if (align === MENU_ALIGN.RIGHT) {
+  if (align === MENU_ALIGNMENT.RIGHT) {
     left = targetRect.right - menuRect.width + offsetX;
-  } else if (align === MENU_ALIGN.CENTER) {
+  } else if (align === MENU_ALIGNMENT.CENTER) {
     left = targetRect.left + (targetRect.width - menuRect.width) / 2 + offsetX;
   }
 
   // Handle vertical alignment
-  if (vAlign === MENU_VERTICAL_ALIGN.TOP) {
+  if (vAlign === MENU_VERTICAL_ALIGNMENT.TOP) {
     top = targetRect.top - menuRect.height + offsetY;
-  } else if (vAlign === MENU_VERTICAL_ALIGN.MIDDLE) {
+  } else if (vAlign === MENU_VERTICAL_ALIGNMENT.MIDDLE) {
     top = targetRect.top + (targetRect.height - menuRect.height) / 2 + offsetY;
   }
 

package/src/components/menu/features/visibility.ts

@@ -1,6 +1,6 @@
 // src/components/menu/features/visibility.ts
 import { BaseComponent, MenuConfig } from '../types';
-import { MENU_EVENTS } from '../constants';
+import { MENU_EVENT, MENU_CLASSES } from '../utils';
 
 /**
  * Adds visibility management functionality to a menu component
@@ -56,11 +56,11 @@ export const withVisibility = (config: MenuConfig) => (component: BaseComponent)
       // Force a reflow before adding the visible class for animation
       // eslint-disable-next-line no-void
       void component.element.offsetHeight;
-      component.element.classList.add(`${prefix}-menu--visible`);
+      component.element.classList.add(`${prefix}-${MENU_CLASSES.VISIBLE}`);
       component.element.setAttribute('aria-hidden', 'false');
 
       // Emit open event
-      component.emit?.(MENU_EVENTS.OPEN, {});
+      component.emit?.(MENU_EVENT.OPEN, {});
 
       return this;
     },
@@ -92,7 +92,7 @@ export const withVisibility = (config: MenuConfig) => (component: BaseComponent)
       }
 
       // Hide the menu with visual indication first
-      component.element.classList.remove(`${prefix}-menu--visible`);
+      component.element.classList.remove(`${prefix}-${MENU_CLASSES.VISIBLE}`);
       component.element.setAttribute('aria-hidden', 'true');
 
       // Define a reliable cleanup function
@@ -123,7 +123,7 @@ export const withVisibility = (config: MenuConfig) => (component: BaseComponent)
       setTimeout(cleanupElement, 300);
 
       // Emit close event
-      component.emit?.(MENU_EVENTS.CLOSE, {});
+      component.emit?.(MENU_EVENT.CLOSE, {});
 
       return this;
     },
@@ -145,7 +145,7 @@ export const withVisibility = (config: MenuConfig) => (component: BaseComponent)
     if (!isVisible) return;
 
     // Store the opening button if available
-    const openingButton = config.openingButton?.element;
+    const origin = config.origin?.element;
 
     // Check if click is outside the menu but not on the opening button
     const clickedElement = event.target as Node;
@@ -156,7 +156,7 @@ export const withVisibility = (config: MenuConfig) => (component: BaseComponent)
     }
 
     // Don't close if the click is on the opening button (it will handle opening/closing)
-    if (openingButton && (openingButton === clickedElement || openingButton.contains(clickedElement))) {
+    if (origin && (origin === clickedElement || origin.contains(clickedElement))) {
       return;
     }
 

package/src/components/menu/index.ts

@@ -1,14 +1,12 @@
 // src/components/menu/index.ts
-export { default } from './menu'
-export {
-  MENU_ALIGN,
-  MENU_VERTICAL_ALIGN,
-  MENU_ITEM_TYPES,
-  MENU_EVENTS
-} from './constants'
+export { default } from './menu';
 export {
   MenuConfig,
   MenuComponent,
   MenuItemConfig,
-  MenuPositionConfig
-} from './types'
+  MenuPositionConfig,
+  MenuAlign,
+  MenuVerticalAlign,
+  MenuItemType,
+  MenuEvent
+} from './types';

package/src/components/menu/menu-item.ts

@@ -1,6 +1,6 @@
 // src/components/menu/menu-item.ts
 import { MenuItemConfig } from './types';
-import { MENU_ITEM_TYPES } from './constants';
+import { MENU_ITEM_TYPE, getMenuClass } from './utils';
 
 /**
  * Creates a menu item element
@@ -10,10 +10,10 @@ import { MENU_ITEM_TYPES } from './constants';
  */
 export const createMenuItem = (itemConfig: MenuItemConfig, prefix: string): HTMLElement => {
   const item = document.createElement('li');
-  item.className = `${prefix}-menu-item`;
+  item.className = `${prefix}-${getMenuClass('ITEM')}`;
 
-  if (itemConfig.type === MENU_ITEM_TYPES.DIVIDER) {
-    item.className = `${prefix}-menu-divider`;
+  if (itemConfig.type === MENU_ITEM_TYPE.DIVIDER) {
+    item.className = `${prefix}-${getMenuClass('DIVIDER')}`;
     return item;
   }
 
@@ -23,7 +23,7 @@ export const createMenuItem = (itemConfig: MenuItemConfig, prefix: string): HTML
 
   if (itemConfig.disabled) {
     item.setAttribute('aria-disabled', 'true');
-    item.className += ` ${prefix}-menu-item--disabled`;
+    item.className += ` ${prefix}-${getMenuClass('ITEM')}--disabled`;
   }
 
   if (itemConfig.name) {
@@ -33,7 +33,7 @@ export const createMenuItem = (itemConfig: MenuItemConfig, prefix: string): HTML
   item.textContent = itemConfig.text || '';
 
   if (itemConfig.items?.length) {
-    item.className += ` ${prefix}-menu-item--submenu`;
+    item.className += ` ${prefix}-${getMenuClass('ITEM')}--submenu`;
     item.setAttribute('aria-haspopup', 'true');
     item.setAttribute('aria-expanded', 'false');
     // We don't need to add a submenu indicator as it's handled by CSS ::after

package/src/components/menu/menu.ts

@@ -18,6 +18,28 @@ import {
  * Creates a new Menu component
  * @param {MenuConfig} config - Menu configuration
  * @returns {MenuComponent} Menu component instance
+ * 
+ * @example
+ * ```typescript
+ * // Create a basic menu with items
+ * const menu = createMenu({
+ *   items: [
+ *     { name: 'item1', text: 'Option 1' },
+ *     { name: 'item2', text: 'Option 2' },
+ *     { type: 'divider' },
+ *     { name: 'item3', text: 'Option 3' }
+ *   ]
+ * });
+ * 
+ * // Show the menu positioned relative to a button
+ * const button = document.getElementById('menuButton');
+ * menu.position(button).show();
+ * 
+ * // Listen for item selection
+ * menu.on('select', (event) => {
+ *   console.log(`Selected: ${event.name}`);
+ * });
+ * ```
  */
 const createMenu = (config: MenuConfig = {}): MenuComponent => {
   const baseConfig = createBaseConfig(config);

package/src/components/menu/types.ts

@@ -1,9 +1,28 @@
 // src/components/menu/types.ts
-import { 
-  MENU_ALIGN, 
-  MENU_VERTICAL_ALIGN, 
-  MENU_ITEM_TYPES 
-} from './constants';
+
+/**
+ * Menu alignment options
+ * @category Components
+ */
+export type MenuAlign = 'left' | 'right' | 'center';
+
+/**
+ * Menu vertical alignment options
+ * @category Components
+ */
+export type MenuVerticalAlign = 'top' | 'bottom' | 'middle';
+
+/**
+ * Menu item types
+ * @category Components
+ */
+export type MenuItemType = 'item' | 'divider';
+
+/**
+ * Menu events
+ * @category Components
+ */
+export type MenuEvent = 'select' | 'open' | 'close' | 'submenuOpen' | 'submenuClose';
 
 /**
  * Menu item configuration
@@ -16,7 +35,7 @@ export interface MenuItemConfig {
   text: string;
   
   /** Type of menu item */
-  type?: keyof typeof MENU_ITEM_TYPES | string;
+  type?: MenuItemType | string;
   
   /** Whether the item is disabled */
   disabled?: boolean;
@@ -33,10 +52,10 @@ export interface MenuItemConfig {
  */
 export interface MenuPositionConfig {
   /** Horizontal alignment */
-  align?: keyof typeof MENU_ALIGN | string;
+  align?: MenuAlign | string;
   
   /** Vertical alignment */
-  vAlign?: keyof typeof MENU_VERTICAL_ALIGN | string;
+  vAlign?: MenuVerticalAlign | string;
   
   /** Horizontal offset in pixels */
   offsetX?: number;
@@ -94,8 +113,8 @@ export interface MenuConfig {
   /** Whether to keep menu open after selection */
   stayOpenOnSelect?: boolean;
   
-  /** Button element that opens the menu */
-  openingButton?: HTMLElement | { element: HTMLElement };
+  /** Orgin element that opens the menu */
+  origin?: HTMLElement | { element: HTMLElement };
   
   /** Parent item element (for submenus) */
   parentItem?: HTMLElement;

package/src/components/menu/utils.ts

@@ -0,0 +1,67 @@
+// src/components/menu/utils.ts
+
+/**
+ * Menu alignment constants for internal use
+ * @internal
+ */
+export const MENU_ALIGNMENT = {
+  LEFT: 'left',
+  RIGHT: 'right',
+  CENTER: 'center'
+};
+
+/**
+ * Menu vertical alignment constants for internal use
+ * @internal
+ */
+export const MENU_VERTICAL_ALIGNMENT = {
+  TOP: 'top',
+  BOTTOM: 'bottom',
+  MIDDLE: 'middle'
+};
+
+/**
+ * Menu item types for internal use
+ * @internal
+ */
+export const MENU_ITEM_TYPE = {
+  ITEM: 'item',
+  DIVIDER: 'divider'
+};
+
+/**
+ * Menu events for internal use
+ * @internal
+ */
+export const MENU_EVENT = {
+  SELECT: 'select',
+  OPEN: 'open',
+  CLOSE: 'close',
+  SUBMENU_OPEN: 'submenuOpen',
+  SUBMENU_CLOSE: 'submenuClose'
+};
+
+/**
+ * Menu CSS classes for internal use
+ * @internal
+ */
+export const MENU_CLASSES = {
+  ROOT: 'menu',
+  ITEM: 'menu-item',
+  ITEM_CONTAINER: 'menu-item-container',
+  LIST: 'menu-list',
+  DIVIDER: 'menu-divider',
+  SUBMENU: 'menu--submenu',
+  VISIBLE: 'menu--visible',
+  DISABLED: 'menu--disabled'
+};
+
+/**
+ * Gets a class name for menu elements
+ * @param {string} element - Element name from MENU_CLASSES
+ * @returns {string} The class name
+ * @internal
+ */
+export const getMenuClass = (element: keyof typeof MENU_CLASSES): string => {
+  return MENU_CLASSES[element];
+};

package/src/components/navigation/config.ts

@@ -5,15 +5,14 @@ import {
   BaseComponentConfig 
 } from '../../core/config/component-config';
 import { NavigationConfig, BaseComponent, ApiOptions } from './types';
-import { NAV_VARIANTS, NAV_POSITIONS, NAV_BEHAVIORS } from './constants';
 
 /**
  * Default configuration for the Navigation component
  */
 export const defaultConfig: NavigationConfig = {
-  variant: NAV_VARIANTS.RAIL,
-  position: NAV_POSITIONS.LEFT,
-  behavior: NAV_BEHAVIORS.FIXED,
+  variant: 'rail',
+  position: 'left',
+  behavior: 'fixed',
   items: [],
   showLabels: true,
   scrimEnabled: false
@@ -32,16 +31,29 @@ export const createBaseConfig = (config: NavigationConfig = {}): NavigationConfi
  * @param {NavigationConfig} config - Navigation configuration
  * @returns {Object} Element configuration object for withElement
  */
-export const getElementConfig = (config: NavigationConfig) => 
-  createElementConfig(config, {
+export const getElementConfig = (config: NavigationConfig) => {
+  // Build class list - start with the variant class
+  const variantClass = config.variant ? `${config.prefix}-nav--${config.variant}` : '';
+  
+  // Add position class if specified
+  const positionClass = config.position ? `${config.prefix}-nav--${config.position}` : '';
+  
+  // Add user-provided classes
+  const userClass = config.class || '';
+  
+  // Combine all classes
+  const classNames = [variantClass, positionClass, userClass].filter(Boolean);
+  
+  return createElementConfig(config, {
     tag: 'nav',
     componentName: 'nav',
     attrs: {
       role: 'navigation',
       'aria-label': config.ariaLabel || 'Main Navigation'
     },
-    className: config.class
+    className: classNames
   });
+};
 
 /**
  * Creates API configuration for the Navigation component
@@ -50,11 +62,11 @@ export const getElementConfig = (config: NavigationConfig) =>
  */
 export const getApiConfig = (comp: BaseComponent): ApiOptions => ({
   disabled: {
-    enable: comp.disabled?.enable,
-    disable: comp.disabled?.disable
+    enable: comp.disabled?.enable || (() => {}),
+    disable: comp.disabled?.disable || (() => {})
   },
   lifecycle: {
-    destroy: comp.lifecycle?.destroy
+    destroy: comp.lifecycle?.destroy || (() => {})
   }
 });
 

package/src/components/navigation/features/items.ts

@@ -1,18 +1,12 @@
 // src/components/navigation/features/items.ts
 import { createNavItem, getAllNestedItems } from '../nav-item';
-import { NavItemConfig, NavItemData } from '../types';
-
-// Type definitions to help with TypeScript conversion
-interface Component {
-  element: HTMLElement;
-  emit?: (event: string, data: any) => void;
-  lifecycle?: {
-    destroy: () => void;
-  };
-  [key: string]: any;
-}
+import { NavItemConfig, NavItemData, BaseComponent, NavClass } from '../types';
 
-interface ItemsComponent extends Component {
+/**
+ * Interface for a component with items management capabilities
+ * @internal
+ */
+interface ItemsComponent extends BaseComponent {
   items: Map<string, NavItemData>;
   addItem: (config: NavItemConfig) => ItemsComponent;
   removeItem: (id: string) => ItemsComponent;
@@ -23,15 +17,25 @@ interface ItemsComponent extends Component {
   setActive: (id: string) => ItemsComponent;
 }
 
+/**
+ * Interface for navigation configuration
+ * @internal
+ */
 interface NavigationConfig {
   prefix?: string;
   items?: NavItemConfig[];
   [key: string]: any;
 }
 
-export const withNavItems = (config: NavigationConfig) => (component: Component): ItemsComponent => {
+/**
+ * Adds navigation items management to a component
+ * @param {NavigationConfig} config - Navigation configuration
+ * @returns {Function} Component enhancer function
+ */
+export const withNavItems = (config: NavigationConfig) => (component: BaseComponent): ItemsComponent => {
   const items = new Map<string, NavItemData>();
   let activeItem: NavItemData | null = null;
+  const prefix = config.prefix || 'mtrl';
 
   /**
    * Recursively stores items in the items Map
@@ -43,9 +47,9 @@ export const withNavItems = (config: NavigationConfig) => (component: Component)
 
     if (itemConfig.items?.length) {
       itemConfig.items.forEach(nestedConfig => {
-        const container = item.closest(`.${config.prefix}-nav-item-container`);
+        const container = item.closest(`.${prefix}-${NavClass.ITEM_CONTAINER}`);
         if (container) {
-          const nestedContainer = container.querySelector(`.${config.prefix}-nav-nested-container`);
+          const nestedContainer = container.querySelector(`.${prefix}-${NavClass.NESTED_CONTAINER}`);
           if (nestedContainer) {
             const nestedItem = nestedContainer.querySelector(`[data-id="${nestedConfig.id}"]`) as HTMLElement;
             if (nestedItem) {
@@ -68,7 +72,7 @@ export const withNavItems = (config: NavigationConfig) => (component: Component)
     const role = item.getAttribute('role');
     
     if (active) {
-      item.classList.add(`${config.prefix}-nav-item--active`);
+      item.classList.add(`${prefix}-${NavClass.ITEM}--active`);
       
       // Set appropriate attribute based on role
       if (role === 'tab') {
@@ -79,7 +83,7 @@ export const withNavItems = (config: NavigationConfig) => (component: Component)
         item.setAttribute('aria-current', 'page');
       }
     } else {
-      item.classList.remove(`${config.prefix}-nav-item--active`);
+      item.classList.remove(`${prefix}-${NavClass.ITEM}--active`);
       
       // Remove appropriate attribute based on role
       if (role === 'tab') {
@@ -94,7 +98,7 @@ export const withNavItems = (config: NavigationConfig) => (component: Component)
   // Create initial items
   if (config.items) {
     config.items.forEach(itemConfig => {
-      const item = createNavItem(itemConfig, component.element, config.prefix || 'mtrl');
+      const item = createNavItem(itemConfig, component.element, prefix);
       storeItem(itemConfig, item);
 
       if (itemConfig.active) {
@@ -106,7 +110,7 @@ export const withNavItems = (config: NavigationConfig) => (component: Component)
 
   // Handle item clicks
   component.element.addEventListener('click', (event: Event) => {
-    const item = (event.target as HTMLElement).closest(`.${config.prefix}-nav-item`) as HTMLElement;
+    const item = (event.target as HTMLElement).closest(`.${prefix}-${NavClass.ITEM}`) as HTMLElement;
     if (!item || (item as any).disabled || item.getAttribute('aria-haspopup') === 'menu') return;
 
     const id = item.dataset.id;
@@ -151,12 +155,12 @@ export const withNavItems = (config: NavigationConfig) => (component: Component)
 
     if (!currentItem) return path;
 
-    let parentContainer = currentItem.element.closest(`.${config.prefix}-nav-nested-container`);
+    let parentContainer = currentItem.element.closest(`.${prefix}-${NavClass.NESTED_CONTAINER}`);
     while (parentContainer) {
       const parentItemContainer = parentContainer.parentElement;
       if (!parentItemContainer) break;
 
-      const parentItem = parentItemContainer.querySelector(`.${config.prefix}-nav-item`);
+      const parentItem = parentItemContainer.querySelector(`.${prefix}-${NavClass.ITEM}`);
       if (!parentItem) break;
 
       const parentId = parentItem.getAttribute('data-id');
@@ -165,7 +169,7 @@ export const withNavItems = (config: NavigationConfig) => (component: Component)
       path.unshift(parentId);
       
       // Move up to next level
-      parentContainer = parentItemContainer.closest(`.${config.prefix}-nav-nested-container`);
+      parentContainer = parentItemContainer.closest(`.${prefix}-${NavClass.NESTED_CONTAINER}`);
     }
 
     return path;
@@ -189,7 +193,7 @@ export const withNavItems = (config: NavigationConfig) => (component: Component)
     addItem(itemConfig: NavItemConfig) {
       if (items.has(itemConfig.id)) return this;
 
-      const item = createNavItem(itemConfig, component.element, config.prefix || 'mtrl');
+      const item = createNavItem(itemConfig, component.element, prefix);
       storeItem(itemConfig, item);
 
       if (itemConfig.active) {
@@ -210,7 +214,7 @@ export const withNavItems = (config: NavigationConfig) => (component: Component)
       if (!item) return this;
 
       // Remove all nested items first
-      const nestedItems = getAllNestedItems(item.element, config.prefix || 'mtrl');
+      const nestedItems = getAllNestedItems(item.element, prefix);
       nestedItems.forEach(nestedItem => {
         const nestedId = nestedItem.dataset.id;
         if (nestedId) items.delete(nestedId);
@@ -221,7 +225,7 @@ export const withNavItems = (config: NavigationConfig) => (component: Component)
       }
 
       // Remove the entire item container
-      const container = item.element.closest(`.${config.prefix}-nav-item-container`);
+      const container = item.element.closest(`.${prefix}-${NavClass.ITEM_CONTAINER}`);
       if (container) {
         container.remove();
       }
@@ -255,9 +259,9 @@ export const withNavItems = (config: NavigationConfig) => (component: Component)
         const parentItem = items.get(parentId);
         if (parentItem) {
           const parentButton = parentItem.element;
-          const container = parentButton.closest(`.${config.prefix}-nav-item-container`);
+          const container = parentButton.closest(`.${prefix}-${NavClass.ITEM_CONTAINER}`);
           if (container) {
-            const nestedContainer = container.querySelector(`.${config.prefix}-nav-nested-container`);
+            const nestedContainer = container.querySelector(`.${prefix}-${NavClass.NESTED_CONTAINER}`);
             if (nestedContainer) {
               parentButton.setAttribute('aria-expanded', 'true');
               nestedContainer.hidden = false;

package/src/components/navigation/index.ts

@@ -1,11 +1,5 @@
 // src/components/navigation/index.ts
 export { default } from './navigation'
-export {
-  NAV_VARIANTS,
-  NAV_POSITIONS,
-  NAV_BEHAVIORS,
-  NAV_STATES
-} from './constants'
 export {
   NavigationConfig,
   NavigationComponent,