mtrl 0.0.0 → 0.0.2

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

@@ -0,0 +1,179 @@
+// src/components/menu/features/visibility.js
+import { MENU_EVENTS } from '../constants'
+
+/**
+ * Adds visibility management functionality to a menu component
+ * @param {Object} config - Menu configuration
+ * @param {string} config.prefix - CSS class prefix
+ * @returns {Function} Component enhancer
+ */
+export const withVisibility = (config) => (component) => {
+  let isVisible = false
+  let outsideClickHandler = null
+  let keydownHandler = null
+
+  // Create the component interface with hide/show methods first
+  const enhancedComponent = {
+    ...component,
+
+    /**
+     * Shows the menu
+     */
+    show () {
+      if (isVisible) return this
+
+      // First set visibility to true to prevent multiple calls
+      isVisible = true
+
+      // Make sure the element is in the DOM
+      if (!component.element.parentNode) {
+        document.body.appendChild(component.element)
+      }
+
+      // Always clean up previous handlers before adding new ones
+      if (outsideClickHandler) {
+        document.removeEventListener('mousedown', outsideClickHandler)
+      }
+
+      // Setup outside click handler for closing
+      outsideClickHandler = handleOutsideClick
+
+      // Use setTimeout to ensure the handler is not triggered immediately
+      setTimeout(() => {
+        document.addEventListener('mousedown', outsideClickHandler)
+      }, 0)
+
+      // Setup keyboard navigation
+      if (!keydownHandler) {
+        keydownHandler = handleKeydown
+        document.addEventListener('keydown', keydownHandler)
+      }
+
+      // Add display block first for transition to work
+      component.element.style.display = 'block'
+
+      // Force a reflow before adding the visible class for animation
+      component.element.offsetHeight
+      component.element.classList.add(`${config.prefix}-menu--visible`)
+      component.element.setAttribute('aria-hidden', 'false')
+
+      // Emit open event
+      component.emit(MENU_EVENTS.OPEN)
+
+      return this
+    },
+
+    /**
+     * Hides the menu
+     */
+    hide () {
+      // Return early if already hidden
+      if (!isVisible) return this
+
+      // First set the visibility flag to false
+      isVisible = false
+
+      // Close any open submenus first
+      if (component.closeSubmenus) {
+        component.closeSubmenus()
+      }
+
+      // Remove ALL event listeners
+      if (outsideClickHandler) {
+        document.removeEventListener('mousedown', outsideClickHandler)
+        outsideClickHandler = null
+      }
+
+      if (keydownHandler) {
+        document.removeEventListener('keydown', keydownHandler)
+        keydownHandler = null
+      }
+
+      // Hide the menu with visual indication first
+      component.element.classList.remove(`${config.prefix}-menu--visible`)
+      component.element.setAttribute('aria-hidden', 'true')
+
+      // Define a reliable cleanup function
+      const cleanupElement = () => {
+        // Safety check to prevent errors
+        if (component.element) {
+          component.element.style.display = 'none'
+
+          // Remove from DOM if still attached
+          if (component.element.parentNode) {
+            component.element.remove()
+          }
+        }
+      }
+
+      // Try to use transition end for smooth animation
+      const handleTransitionEnd = (e) => {
+        if (e.propertyName === 'opacity' || e.propertyName === 'transform') {
+          component.element.removeEventListener('transitionend', handleTransitionEnd)
+          cleanupElement()
+        }
+      }
+
+      component.element.addEventListener('transitionend', handleTransitionEnd)
+
+      // Fallback timeout in case transition events don't fire
+      // This ensures the menu always gets removed
+      setTimeout(cleanupElement, 300)
+
+      // Emit close event
+      component.emit(MENU_EVENTS.CLOSE)
+
+      return this
+    },
+
+    /**
+     * Returns whether the menu is currently visible
+     * @returns {boolean} Visibility state
+     */
+    isVisible () {
+      return isVisible
+    }
+  }
+
+  /**
+   * Handles clicks outside the menu
+   * @param {MouseEvent} event - Mouse event
+   */
+  const handleOutsideClick = (event) => {
+    if (!isVisible) return
+
+    // Store the opening button if available
+    const openingButton = config.openingButton?.element
+
+    // Check if click is outside the menu but not on the opening button
+    const clickedElement = event.target
+
+    // Don't close if the click is inside the menu
+    if (component.element.contains(clickedElement)) {
+      return
+    }
+
+    // Don't close if the click is on the opening button (it will handle opening/closing)
+    if (openingButton && (openingButton === clickedElement || openingButton.contains(clickedElement))) {
+      return
+    }
+
+    // If we got here, close the menu
+    enhancedComponent.hide()
+  }
+
+  /**
+   * Handles keyboard events
+   * @param {KeyboardEvent} event - Keyboard event
+   */
+  const handleKeydown = (event) => {
+    if (!isVisible) return
+
+    if (event.key === 'Escape') {
+      event.preventDefault()
+      enhancedComponent.hide()
+    }
+  }
+
+  return enhancedComponent
+}

package/src/components/menu/index.js

@@ -0,0 +1,2 @@
+// src/components/menu/index.js
+export { default } from './menu.js'

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

@@ -0,0 +1,41 @@
+// src/components/menu/menu-item.js
+
+/**
+ * Creates a menu item element
+ * @param {Object} itemConfig - Item configuration
+ * @param {string} prefix - CSS class prefix
+ * @returns {HTMLElement} Menu item element
+ */
+export const createMenuItem = (itemConfig, prefix) => {
+  const item = document.createElement('li')
+  item.className = `${prefix}-menu-item`
+
+  if (itemConfig.type === 'divider') {
+    item.className = `${prefix}-menu-divider`
+    return item
+  }
+
+  if (itemConfig.class) {
+    item.className += ` ${itemConfig.class}`
+  }
+
+  if (itemConfig.disabled) {
+    item.setAttribute('aria-disabled', 'true')
+    item.className += ` ${prefix}-menu-item--disabled`
+  }
+
+  if (itemConfig.name) {
+    item.setAttribute('data-name', itemConfig.name)
+  }
+
+  item.textContent = itemConfig.text || ''
+
+  if (itemConfig.items?.length) {
+    item.className += ` ${prefix}-menu-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
+  }
+
+  return item
+}

package/src/components/menu/menu.js

@@ -0,0 +1,54 @@
+// src/components/menu/menu.js
+
+import { PREFIX } from '../../core/config'
+import { pipe } from '../../core/compose'
+import { createBase, withElement } from '../../core/compose/component'
+import { withEvents, withLifecycle } from '../../core/compose/features'
+import { withAPI } from './api'
+import { withVisibility } from './features/visibility'
+import { withItemsManager } from './features/items-manager'
+import { withPositioning } from './features/positioning'
+import { withKeyboardNavigation } from './features/keyboard-navigation'
+
+/**
+ * Creates a new Menu component
+ * @param {Object} config - Menu configuration
+ * @param {Array} [config.items] - Menu items
+ * @param {string} [config.class] - Additional CSS classes
+ * @param {HTMLElement} [config.target] - Target element for positioning
+ * @param {boolean} [config.stayOpenOnSelect] - Whether to keep the menu open after an item is selected
+ * @param {HTMLElement} [config.openingButton] - Button that opens the menu
+ * @returns {Object} Menu component instance
+ */
+const createMenu = (config = {}) => {
+  const baseConfig = {
+    ...config,
+    componentName: 'menu',
+    prefix: PREFIX
+  }
+
+  return pipe(
+    createBase,
+    withEvents(),
+    withElement({
+      tag: 'div',
+      componentName: 'menu',
+      className: config.class,
+      attrs: {
+        role: 'menu',
+        tabindex: '-1',
+        'aria-hidden': 'true'
+      }
+    }),
+    withLifecycle(),
+    withItemsManager(baseConfig),
+    withVisibility(baseConfig),
+    withPositioning,
+    withKeyboardNavigation(baseConfig),
+    comp => withAPI({
+      lifecycle: comp.lifecycle
+    })(comp)
+  )(baseConfig)
+}
+
+export default createMenu

package/src/components/menu/styles.scss

@@ -0,0 +1,150 @@
+// src/components/menu/styles.scss
+@use 'sass:map';
+@use '../../styles/abstract/config' as c;
+@use '../../styles/abstract/mixins' as m;
+@use '../../styles/abstract/variables' as v;
+
+.#{c.$prefix}-menu {
+  // Base styles
+  @include c.typography('body-medium');
+  @include c.shape('small');
+  
+  position: fixed;
+  z-index: map.get(v.$z-index, 'menu');
+  min-width: 112px;
+  max-width: 280px;
+  padding: 8px 0;
+  background-color: var(--mtrl-sys-color-surface-container);
+  color: var(--mtrl-sys-color-on-surface);
+  @include c.elevation(2);
+  
+  display: none;
+  opacity: 0;
+  transform: scale(0.8);
+  transform-origin: top left;
+  pointer-events: none;
+  transition: opacity 150ms cubic-bezier(0.4, 0, 0.2, 1),
+              transform 150ms cubic-bezier(0.4, 0, 0.2, 1);
+  
+  &--visible {
+    display: block;
+    opacity: 1;
+    transform: scale(1);
+    pointer-events: auto;
+  }
+  
+  &--submenu {
+    position: absolute;
+    z-index: map.get(v.$z-index, 'menu') + 1;
+  }
+
+  // List container
+  &-list {
+    margin: 0;
+    padding: 0;
+    list-style: none;
+    overflow-y: auto;
+    max-height: calc(100vh - 96px);
+    @include m.scrollbar;
+  }
+
+  // Menu items
+  &-item {
+    @include c.typography('body-large');
+    @include m.flex-row;
+    
+    position: relative;
+    min-height: 48px;
+    padding: 12px 16px;
+    cursor: pointer;
+    user-select: none;
+    color: var(--mtrl-sys-color-on-surface);
+    transition: background-color 150ms cubic-bezier(0.4, 0, 0.2, 1);
+    
+    &:hover {
+      @include c.state-layer(var(--mtrl-sys-color-on-surface), 'hover');
+    }
+    
+    &:focus {
+      @include c.state-layer(var(--mtrl-sys-color-on-surface), 'focus');
+      outline: none;
+    }
+    
+    &:active {
+      @include c.state-layer(var(--mtrl-sys-color-on-surface), 'pressed');
+    }
+
+    // Submenu indicator
+    &--submenu {
+      padding-right: 48px;
+      
+      &::after {
+        @include m.icon('chevron_right');
+        position: absolute;
+        right: 16px;
+        top: 50%;
+        transform: translateY(-50%);
+        opacity: 0.87;
+      }
+      
+      &[aria-expanded="true"] {
+        @include c.state-layer(var(--mtrl-sys-color-on-surface), 'hover');
+        
+        &::after {
+          opacity: 1;
+        }
+      }
+    }
+
+    // Disabled state
+    &--disabled {
+      pointer-events: none;
+      color: rgba(var(--mtrl-sys-color-on-surface-rgb), 0.38);
+    }
+  }
+
+  // Divider
+  &-divider {
+    height: 1px;
+    margin: 8px 0;
+    background-color: var(--mtrl-sys-color-outline-variant);
+  }
+
+  // Accessibility
+  @include c.focus-ring('.#{c.$prefix}-menu-item:focus-visible');
+  
+  @include c.reduced-motion {
+    transition: none;
+  }
+  
+  @include c.high-contrast {
+    border: 1px solid CurrentColor;
+    
+    .#{c.$prefix}-menu-divider {
+      background-color: CurrentColor;
+    }
+    
+    .#{c.$prefix}-menu-item--disabled {
+      opacity: 1;
+      color: GrayText;
+    }
+  }
+
+  // RTL Support
+  @include c.rtl {
+    transform-origin: top right;
+    
+    .#{c.$prefix}-menu-item {
+      &--submenu {
+        padding-right: 16px;
+        padding-left: 48px;
+        
+        &::after {
+          right: auto;
+          left: 16px;
+          transform: translateY(-50%) rotate(180deg);
+        }
+      }
+    }
+  }
+}

package/src/core/build/ripple.js

@@ -13,7 +13,13 @@ const DEFAULT_CONFIG = RIPPLE_CONFIG
  * @returns {Object} Ripple controller instance
  */
 export const createRipple = (config = {}) => {
-  const options = { ...DEFAULT_CONFIG, ...config }
+  // Make sure we fully merge the config options
+  const options = {
+    ...DEFAULT_CONFIG,
+    ...config,
+    // Handle nested objects like opacity array
+    opacity: config.opacity || DEFAULT_CONFIG.opacity
+  }
 
   const getEndCoordinates = (bounds) => {
     const size = Math.max(bounds.width, bounds.height)
@@ -36,7 +42,29 @@ export const createRipple = (config = {}) => {
     return ripple
   }
 
+  // Store document event listeners for cleanup
+  let documentListeners = []
+
+  // Safe document event handling
+  const addDocumentListener = (event, handler) => {
+    if (typeof document.addEventListener === 'function') {
+      document.addEventListener(event, handler)
+      documentListeners.push({ event, handler })
+    }
+  }
+
+  const removeDocumentListener = (event, handler) => {
+    if (typeof document.removeEventListener === 'function') {
+      document.removeEventListener(event, handler)
+      documentListeners = documentListeners.filter(
+        listener => !(listener.event === event && listener.handler === handler)
+      )
+    }
+  }
+
   const animate = (event, container) => {
+    if (!container) return
+
     const bounds = container.getBoundingClientRect()
     const ripple = createRippleElement()
 
@@ -49,7 +77,10 @@ export const createRipple = (config = {}) => {
     })
 
     container.appendChild(ripple)
-    ripple.offsetHeight // Force reflow
+
+    // Force reflow
+    // eslint-disable-next-line no-unused-expressions
+    ripple.offsetHeight
 
     // Animate to end position
     const end = getEndCoordinates(bounds)
@@ -61,13 +92,20 @@ export const createRipple = (config = {}) => {
 
     const cleanup = () => {
       ripple.style.opacity = '0'
-      setTimeout(() => ripple.remove(), options.duration)
-      document.removeEventListener('mouseup', cleanup)
-      document.removeEventListener('mouseleave', cleanup)
+
+      // Use setTimeout to remove element after animation
+      setTimeout(() => {
+        if (ripple.parentNode) {
+          ripple.parentNode.removeChild(ripple)
+        }
+      }, options.duration)
+
+      removeDocumentListener('mouseup', cleanup)
+      removeDocumentListener('mouseleave', cleanup)
     }
 
-    document.addEventListener('mouseup', cleanup)
-    document.addEventListener('mouseleave', cleanup)
+    addDocumentListener('mouseup', cleanup)
+    addDocumentListener('mouseleave', cleanup)
   }
 
   return {
@@ -81,12 +119,41 @@ export const createRipple = (config = {}) => {
       }
       element.style.overflow = 'hidden'
 
-      element.addEventListener('mousedown', (e) => animate(e, element))
+      // Store the mousedown handler to be able to remove it later
+      const mousedownHandler = (e) => animate(e, element)
+
+      // Store handler reference on the element
+      if (!element.__rippleHandlers) {
+        element.__rippleHandlers = []
+      }
+      element.__rippleHandlers.push(mousedownHandler)
+
+      element.addEventListener('mousedown', mousedownHandler)
     },
 
     unmount: (element) => {
       if (!element) return
-      element.querySelectorAll('.ripple').forEach(ripple => ripple.remove())
+
+      // Clear document event listeners
+      documentListeners.forEach(({ event, handler }) => {
+        removeDocumentListener(event, handler)
+      })
+      documentListeners = []
+
+      // Remove event listeners
+      if (element.__rippleHandlers) {
+        element.__rippleHandlers.forEach(handler => {
+          element.removeEventListener('mousedown', handler)
+        })
+        element.__rippleHandlers = []
+      }
+
+      // Remove all ripple elements
+      const ripples = element.querySelectorAll('.ripple')
+      ripples.forEach(ripple => {
+        // Call remove directly to match the test expectation
+        ripple.remove()
+      })
     }
   }
 }

package/src/core/compose/features/disabled.js

@@ -1,25 +1,44 @@
-// src/core/compose/features/disabled.js
 
-export const withDisabled = (config) => (component) => {
-  if (!component.element) return component
+/**
+ * Adds disabled state management to a component
+ * @param {Object} config - Disabled configuration
+ * @returns {Function} Component enhancer
+ */
+export const withDisabled = (config = {}) => (component) => {
+  // Directly implement disabled functionality
+  const disabled = {
+    enable () {
+      component.element.disabled = false
+      component.element.removeAttribute('disabled')
+      return this
+    },
 
-  return {
-    ...component,
-    disabled: {
-      enable () {
-        console.debug('disabled')
-        component.element.disabled = false
-        const className = `${config.prefix}-${config.componentName}--disable`
-        component.element.classList.remove(className)
-        return this
-      },
-      disable () {
-        console.debug('disabled')
-        component.element.disabled = true
-        const className = `${config.prefix}-${config.componentName}--disable`
-        component.element.classList.add(className)
-        return this
+    disable () {
+      component.element.disabled = true
+      component.element.setAttribute('disabled', 'true')
+      return this
+    },
+
+    toggle () {
+      if (component.element.disabled) {
+        this.enable()
+      } else {
+        this.disable()
       }
+      return this
+    },
+
+    isDisabled () {
+      return component.element.disabled === true
     }
   }
+
+  if (config.disabled) {
+    disabled.disable()
+  }
+
+  return {
+    ...component,
+    disabled
+  }
 }

package/src/core/state/disabled.js

@@ -1,14 +1,51 @@
 // src/core/state/disabled.js
+
+/**
+ * Creates a controller for managing the disabled state of an element
+ * @param {HTMLElement} element - The element to control
+ * @returns {Object} Disabled state controller
+ */
 export const createDisabled = (element) => {
   return {
-    enable() {
+    /**
+     * Enables the element
+     * @returns {Object} The controller instance for chaining
+     */
+    enable () {
       element.disabled = false
+      element.removeAttribute('disabled')
       return this
     },
-    
-    disable() {
+
+    /**
+     * Disables the element
+     * @returns {Object} The controller instance for chaining
+     */
+    disable () {
       element.disabled = true
+      element.setAttribute('disabled', 'true')
       return this
+    },
+
+    /**
+     * Toggles the disabled state
+     * @returns {Object} The controller instance for chaining
+     */
+    toggle () {
+      if (element.disabled) {
+        this.enable()
+      } else {
+        this.disable()
+      }
+      return this
+    },
+
+    /**
+     * Checks if the element is disabled
+     * @returns {boolean} True if the element is disabled
+     */
+    isDisabled () {
+      return element.disabled === true
     }
   }
-}
+}

package/src/index.js

@@ -3,9 +3,10 @@ export { createElement } from './core/dom/create'
 export { default as createLayout } from './core/layout'
 export { default as createButton } from './components/button'
 export { default as createCheckbox } from './components/checkbox'
-export { default as createTextfield } from './components/textfield'
-export { default as createSwitch } from './components/switch'
 export { default as createContainer } from './components/container'
-export { default as createSnackbar } from './components/snackbar'
+export { default as createMenu } from './components/menu'
 export { default as createNavigation } from './components/navigation'
+export { default as createSnackbar } from './components/snackbar'
+export { default as createSwitch } from './components/switch'
+export { default as createTextfield } from './components/textfield'
 export { default as createList } from './components/list'

package/src/styles/abstract/_config.scss

@@ -25,4 +25,4 @@
   rtl,
   touch-target,
   custom-scrollbar,
-  print;
+  print;