SiteLint documentation and guidelines

Verify concurrent input mechanisms

Description

This rule does not automatically validate anything. It simply reminds you to manually verify that web content does not restrict use of input modalities available on the platform, except where the restriction is essential, required to ensure the security of the content, or required to respect user settings. A concurrent input mechanism means that users must be able to switch between any supported input method – keyboard, mouse, touch, stylus, speech, or assistive technology – at any time without losing functionality or being forced into a single input mode.

This rule aligns with WCAG Success Criterion 2.5.6 (Concurrent Input Mechanisms), a Level AAA requirement. It addresses a fundamental principle of inclusive design: that users should never be penalized for their choice of input device. For example, a web application that works perfectly with a mouse but disables keyboard navigation, or a touch interface that blocks right-click functionality, would fail this criterion.

Disabilities impacted

  • Motor disabilities – Users with limited fine motor control often rely on specific input devices such as adaptive keyboards, switch controls, or voice recognition software. When content requires a particular input modality (for example, a precise mouse drag operation or a multi-touch gesture), users who cannot physically perform that action are entirely excluded. The ability to switch between input mechanisms lets users choose the method that works best for their physical capabilities.
  • Vision impairment – Users who are blind or have low vision typically navigate with a keyboard or screen reader and cannot use a mouse or trackpad reliably. When content disables keyboard focus or prevents text selection through assistive technology, these users lose access to core functionality. Conversely, users who rely on screen magnification may need both keyboard and pointer input simultaneously.
  • Cognitive disabilities – Users with attention deficits, memory impairments, or learning disabilities benefit from predictable, consistent input behavior. When a page unexpectedly blocks a familiar input mechanism (such as right-click or keyboard shortcuts), it increases cognitive load and can cause confusion or task abandonment. The freedom to choose the most comfortable input modality reduces mental overhead.
  • Speech input users – Individuals who control their devices through speech recognition software (such as Dragon NaturallySpeaking or voice control features) issue commands that emulate keyboard and mouse events. If content suppresses these events or blocks standard input APIs, voice commands may fail silently, leaving speech-reliant users unable to interact with the page.

Why it matters

Concurrent input mechanisms are foundational to the principle of operability in WCAG. When a website or application dictates which input device the user must use, it shifts the burden of adaptation from the software to the person. This contradicts the core accessibility goal of designing systems that adapt to the user, not the other way around. The ADA and the European Accessibility Act (EAA) both require that digital products be operable through a variety of input methods, and courts have increasingly interpreted this to include concurrent input support.

Beyond legal compliance, supporting multiple input mechanisms improves usability for everyone. A developer testing with a keyboard may catch bugs that mouse-only users never notice. A person with a temporary injury (such as a broken arm) can switch from mouse to keyboard without interruption. A user on a touchscreen tablet may attach an external keyboard and expect both to work simultaneously. Restricting input modalities creates a fragile, exclusionary experience that fails under real-world usage conditions.

Coding problems and solutions

Common pitfalls to manually verify

Since this rule does not perform automated validation, you must manually inspect the page for the following issues:

  • Disabling right-click via the contextmenu event – Calling event.preventDefault() inside a contextmenu event listener prevents users from accessing the browser context menu, which many assistive technologies and power users rely on for navigation and accessibility features.
  • Preventing text selection with CSS – Using user-select: none or vendor-prefixed equivalents blocks the ability to select text, which keyboard and screen reader users depend on for copying, highlighting, and navigating content.
  • Touch-only gesture requirements – Requiring swipe, pinch, long-press, or multi-touch gestures without providing equivalent keyboard or pointer alternatives excludes users on laptops, desktop computers, and those using switch devices.
  • Disabling keyboard focus or tab navigation – Setting negative tabindex values indiscriminately, trapping focus in modals without an escape mechanism, or removing focus outlines with outline: none without a replacement indicator prevents keyboard-only users from navigating.
  • Mouse-only drag and drop – Implementing drag-and-drop interfaces that respond only to mouse events (mousedown, mousemove, mouseup) without keyboard or pointer-event equivalents prevents users who cannot use a mouse from completing the action.
  • Blocking page zoom – Using <meta name="viewport" content="user-scalable=no"> or maximum-scale=1.0 disables pinch-to-zoom on mobile devices and browser zoom on desktop, restricting a core input mechanism for users with low vision.
  • Suppressing keyboard shortcuts – Intercepting and preventing default behavior for common browser keyboard shortcuts (such as Ctrl+F for find or Ctrl++ for zoom) through keydown event listeners removes functionality that users rely on.
  • Requiring speech or microphone access – Building features that accept only voice input without providing a keyboard or pointer alternative excludes users who cannot speak, are in quiet environments, or have privacy concerns about microphone access.

How to fix it

Do not prevent default right-click behavior

Instead of suppressing the contextmenu event entirely, build a custom context menu that is fully keyboard-accessible and coexists with the native browser menu. If you must replace the default menu, ensure it can be opened with the Shift+F10 keyboard shortcut or a dedicated button, and that all menu items are focusable via Tab and activatable via Enter or Space.

const customMenu = document.querySelector('#custom-context-menu');

const openCustomMenu = (event) => {
  event.preventDefault();

  customMenu.style.display = 'block';
  customMenu.style.left = `${event.clientX}px`;
  customMenu.style.top = `${event.clientY}px`;

  const firstItem = customMenu.querySelector('[role="menuitem"]');

  if (firstItem) {
    firstItem.focus();
  }
};

document.addEventListener('contextmenu', openCustomMenu);

document.addEventListener('keydown', (event) => {
  if (event.key === 'Escape') {
    customMenu.style.display = 'none';
  }
});
Correct example
document.addEventListener('contextmenu', (event) => {
  event.preventDefault();
  return false;
});
Incorrect example

Provide keyboard alternatives for touch gestures

When implementing swipe, pinch, or other touch-centric interactions, always provide equivalent keyboard controls. For a carousel or slider with a swipe gesture, add arrow key support and visible previous/next buttons. For an image gallery with pinch-to-zoom, provide zoom-in and zoom-out buttons and keyboard shortcuts.

const handleKeyDown = (event) => {
  if (event.key === 'ArrowLeft') {
    event.preventDefault();
    showPreviousSlide();
  }

  if (event.key === 'ArrowRight') {
    event.preventDefault();
    showNextSlide();
  }
};

carousel.addEventListener('touchstart', handleTouchStart);
carousel.addEventListener('touchend', handleTouchEnd);
carousel.addEventListener('keydown', handleKeyDown);
Correct example
carousel.addEventListener('touchstart', handleTouchStart);
carousel.addEventListener('touchmove', handleTouchMove);
carousel.addEventListener('touchend', handleTouchEnd);

// No keyboard or pointer fallback provided
Incorrect example

Allow text selection and cursor visibility

Do not use CSS to globally disable text selection or hide the cursor. These are core input affordances that users rely on. If you need to prevent accidental text selection during a drag or game interaction, apply the restriction only to the specific interactive element and restore it when the interaction ends.

.draggable-item:active {
  user-select: none;
  cursor: grabbing;
}

.draggable-item {
  user-select: text;
  cursor: grab;
}
Correct example
body {
  user-select: none;
  -webkit-user-select: none;
  cursor: none;
}
Incorrect example

Implement keyboard-accessible drag and drop

Use the HTML Drag and Drop API in combination with ARIA attributes and keyboard event handlers. Every drag-and-drop operation must have a keyboard equivalent: typically by selecting an item with Space, moving it with arrow keys, and dropping it with Enter or Space. Provide clear focus indicators for both the dragged item and the drop target.

<div role="list"
     aria-label="Sortable items">

  <div role="listitem"
       draggable="true"
       aria-grabbed="false"
       tabindex="0"
       data-sort-index="0">
    Item 1
    <button aria-label="Move item 1 up"
            class="move-up-btn">↑</button>
    <button aria-label="Move item 1 down"
            class="move-down-btn">↓</button>
  </div>

  <div role="listitem"
       draggable="true"
       aria-grabbed="false"
       tabindex="0"
       data-sort-index="1">
    Item 2
    <button aria-label="Move item 2 up"
            class="move-up-btn">↑</button>
    <button aria-label="Move item 2 down"
            class="move-down-btn">↓</button>
  </div>

</div>
Correct example
<div id="sortable-list">
  <div class="item" draggable="true">Item 1</div>
  <div class="item" draggable="true">Item 2</div>
</div>

<script>
  const items = document.querySelectorAll('.item');

  items.forEach((item) => {
    item.addEventListener('dragstart', handleDragStart);
    item.addEventListener('dragover', handleDragOver);
    item.addEventListener('drop', handleDrop);
  });

  // No keyboard or ARIA support provided
</script>
Incorrect example

Do not restrict browser zoom or scaling

Allow users to zoom and scale content freely. The viewport <meta> tag should enable user scaling and avoid capping the maximum zoom level. Browsers already handle responsive layouts gracefully; restricting zoom provides no benefit and causes significant accessibility harm.

<meta name="viewport"
      content="width=device-width, initial-scale=1.0">
Correct example
<meta name="viewport"
      content="width=device-width, initial-scale=1.0,
               maximum-scale=1.0, user-scalable=no">
Incorrect example

Known Limitations

  • Manual-only check – Because this rule performs no automated validation, it cannot programmatically detect input modality restrictions. It depends entirely on human judgment: a developer or tester must manually inspect event handlers, CSS rules, and viewport configuration to identify issues. Automated tools cannot discern whether a preventDefault() call on contextmenu is essential (e.g., for a drawing application’s custom tool palette) or purely cosmetic.
  • Single Page Applications (SPAs) – Input-handling code in SPAs is often dynamically registered and deregistered as views change. A manual check at a single point in time may miss event listeners that attach only when a specific route or component is active.
  • Shadow DOM – Event listeners and CSS rules defined inside shadow roots may not be visible during a top-level DOM inspection. The rule must traverse all shadow boundaries to detect input restrictions applied within encapsulated components, but manual inspection of shadow trees is difficult without specialized tooling.
  • Third-party content and iframes – Embedded widgets, advertisements, or content within cross-origin iframes may impose their own input restrictions. These are invisible to parent-page inspection and may not be fixable by the site owner without replacing the third-party integration.
  • Platform-specific and browser-specific behaviors – Some input modality restrictions are introduced by the operating system, browser settings, or device drivers rather than web content itself. For example, certain touch gestures are intercepted by the OS before they reach the browser, and keyboard shortcut conflicts vary across platforms and browsers.
  • Speech recognition variability – The interaction between web content and speech recognition engines (such as Dragon NaturallySpeaking or built-in OS voice control) is complex and poorly documented. A page that works correctly with one speech engine may fail with another due to differences in how each engine emulates keyboard and mouse events.
  • Assistive technology interactions – Screen readers, switch devices, and eye-tracking systems often emulate standard input events. If a web page suppresses or alters these events (e.g., by intercepting keydown and calling preventDefault() without a fallback), the assistive technology may break in ways that are difficult to diagnose without access to the specific AT hardware and software combination.

Resources

Rule

  • Audit: accessibility
  • Standard: WCAG
  • Level: AAA
  • Success Criteria: 2.5.6
  • Rule ID: concurrent-input-mechanisms