npm - @y14e/tabs - Versions diffs - 1.3.12 → 1.4.0 - Mend

@y14e/tabs 1.3.12 → 1.4.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (5) hide show

package/dist/index.cjs CHANGED Viewed

@@ -50,6 +50,506 @@ function saveAttributes(elements, attributes) {
   });
 }
+// node_modules/@y14e/roving-tabindex/dist/index.js
+var defaultParser2 = (value) => value.split(/\s+/);
+var defaultSerializer2 = (tokens) => tokens.join(" ");
+function addTokenToAttribute2(element, attribute, token, options = {}) {
+  const {
+    caseInsensitive = false,
+    parse = defaultParser2,
+    serialize = defaultSerializer2
+  } = options;
+  const value = element.getAttribute(attribute)?.trim();
+  const tokens = value ? parse(value).filter(Boolean) : [];
+  if (caseInsensitive) {
+    const lower = token.toLowerCase();
+    if (tokens.some((token2) => token2.toLowerCase() === lower)) {
+      return;
+    }
+    tokens.push(token);
+    element.setAttribute(attribute, serialize(tokens));
+    return;
+  }
+  const set = new Set(tokens);
+  set.add(token);
+  element.setAttribute(attribute, serialize([...set]));
+}
+var snapshots2 = /* @__PURE__ */ new WeakMap();
+function restoreAttributes2(elements) {
+  for (const element of elements) {
+    const snapshot = snapshots2.get(element);
+    if (!snapshot) {
+      continue;
+    }
+    for (const [attribute, value] of snapshot.entries()) {
+      value === null ? element.removeAttribute(attribute) : element.setAttribute(attribute, value);
+    }
+    snapshots2.delete(element);
+  }
+}
+function saveAttributes2(elements, attributes) {
+  elements.forEach((element) => {
+    let snapshot = snapshots2.get(element);
+    if (!snapshot) {
+      snapshot = /* @__PURE__ */ new Map();
+      snapshots2.set(element, snapshot);
+    }
+    attributes.forEach((attribute) => {
+      snapshot.set(attribute, element.getAttribute(attribute));
+    });
+  });
+}
+var FOCUSABLE_SELECTOR = `:is(a[href], area[href], button, embed, iframe, input:not([type="hidden" i]), object, select, details > summary:first-of-type, textarea, [contenteditable]:not([contenteditable="false" i]), [controls], [tabindex]):not(:disabled, [hidden], [inert], [tabindex="-1"])`;
+function getFocusables(container = document.body, options = {}) {
+  if (!(container instanceof Element)) {
+    console.warn("Invalid container element. Fallback: <body> element.");
+    container = document.body;
+  }
+  let {
+    composed = false,
+    filter,
+    include,
+    skipVisibilityCheck = false
+  } = options;
+  if (typeof composed !== "boolean") {
+    console.warn("Invalid composed option. Fallback: false.");
+    composed = false;
+  }
+  if (typeof filter !== "undefined" && typeof filter !== "function") {
+    console.warn(
+      "Invalid filter function. Fallback: no filter function (undefined)."
+    );
+    filter = void 0;
+  }
+  if (typeof include !== "undefined" && typeof include !== "function") {
+    console.warn(
+      "Invalid include function. Fallback: no include function (undefined)."
+    );
+    include = void 0;
+  }
+  const elements = [];
+  if (composed || include) {
+    let traverse2 = function(node) {
+      if (node instanceof Element) {
+        if (isFocusable(node, { skipVisibilityCheck }) || include?.(node)) {
+          elements[elements.length] = node;
+        }
+      }
+      const children = getComposedChildren(node);
+      for (let i = 0, l = children.length; i < l; i++) {
+        const child = children[i];
+        if (!child) {
+          continue;
+        }
+        traverse2(child);
+      }
+    };
+    traverse2(container);
+  } else {
+    const candidates = container.querySelectorAll(FOCUSABLE_SELECTOR);
+    for (let i = 0, l = candidates.length; i < l; i++) {
+      const candidate = candidates[i];
+      if (!(candidate instanceof Element)) {
+        continue;
+      }
+      if (isFocusable(candidate, { skipVisibilityCheck })) {
+        elements[elements.length] = candidate;
+      }
+    }
+  }
+  const unfiltered = normalizeRadioGroup(sortByTabIndex(elements));
+  return filter ? unfiltered.filter(filter) : unfiltered;
+}
+function isFocusable(element, options = {}) {
+  if (!(element instanceof Element)) {
+    console.warn("Invalid element");
+    return false;
+  }
+  let { skipVisibilityCheck = false } = options;
+  if (typeof skipVisibilityCheck !== "boolean") {
+    console.warn("Invalid skipVisibilityCheck option. Fallback: false.");
+    skipVisibilityCheck = false;
+  }
+  if (element.hasAttribute("hidden") || isInert(element)) {
+    return false;
+  }
+  if (getTabIndex(element) < 0) {
+    return false;
+  }
+  if (!element.matches(FOCUSABLE_SELECTOR)) {
+    return false;
+  }
+  if (isDisabledDeep(element)) {
+    return false;
+  }
+  if (!skipVisibilityCheck && !element.checkVisibility({
+    contentVisibilityAuto: true,
+    opacityProperty: true,
+    visibilityProperty: true
+  })) {
+    return false;
+  }
+  return true;
+}
+function isDisabledDeep(element) {
+  let current = element;
+  while (current) {
+    if (current instanceof ShadowRoot) {
+      if (current.mode !== "open") {
+        return false;
+      }
+      current = current.host;
+      continue;
+    }
+    if (!(current instanceof Element)) {
+      current = current.parentNode;
+      continue;
+    }
+    if (current === element && isFormControl(current) && isDisabled(current)) {
+      return true;
+    }
+    if (isInert(current)) {
+      return true;
+    }
+    if (isFormControl(element) && current.tagName === "FIELDSET" && isDisabled(current)) {
+      if (!current.querySelector(":scope > legend:first-of-type")?.contains(element)) {
+        return true;
+      }
+    }
+    current = current.parentNode;
+  }
+  return false;
+}
+function normalizeRadioGroup(elements) {
+  let map = null;
+  for (let i = 0, l = elements.length; i < l; i++) {
+    const element = elements[i];
+    if (!(element instanceof HTMLInputElement)) {
+      continue;
+    }
+    if (!isUngroupedRadio(element)) {
+      continue;
+    }
+    if (!map) {
+      map = /* @__PURE__ */ new Map();
+    }
+    const key = `${element.form?.id ?? "no-form"}::${element.name}`;
+    const group = map.get(key) ?? map.set(key, []).get(key);
+    if (group) {
+      group[group.length] = element;
+    }
+  }
+  if (!map) {
+    return elements;
+  }
+  const placeholder = /* @__PURE__ */ new Set();
+  for (const group of map.values()) {
+    placeholder.add(group.find((radio) => radio.checked) ?? group[0]);
+  }
+  return elements.filter((element) => {
+    if (isUngroupedRadio(element)) {
+      return placeholder.has(element);
+    }
+    return true;
+  });
+}
+function sortByTabIndex(elements) {
+  const ordered = [];
+  const natural = [];
+  for (let i = 0, l = elements.length; i < l; i++) {
+    const element = elements[i];
+    if (!element) {
+      continue;
+    }
+    const target = getTabIndex(element) > 0 ? ordered : natural;
+    target[target.length] = element;
+  }
+  ordered.sort((a, b) => getTabIndex(a) - getTabIndex(b));
+  let count = 0;
+  const sorted = new Array(ordered.length + natural.length);
+  for (let i = 0, l = ordered.length; i < l; i++) {
+    sorted[count++] = ordered[i];
+  }
+  for (let i = 0, l = natural.length; i < l; i++) {
+    sorted[count++] = natural[i];
+  }
+  return sorted;
+}
+function getComposedChildren(node) {
+  if (node instanceof ShadowRoot) {
+    return getChildren(node);
+  }
+  if (!(node instanceof Element)) {
+    return [];
+  }
+  if (node instanceof HTMLSlotElement) {
+    const assigned = node.assignedElements({ flatten: true });
+    if (assigned.length) {
+      return assigned;
+    }
+  }
+  if (node instanceof HTMLElement && node.shadowRoot?.mode === "open") {
+    return getChildren(node.shadowRoot);
+  }
+  return getChildren(node);
+}
+function getChildren(node) {
+  const elements = [];
+  for (let child = node.firstElementChild; child; child = child.nextElementSibling) {
+    elements[elements.length] = child;
+  }
+  return elements;
+}
+function getTabIndex(element) {
+  return "tabIndex" in element ? Number(element.tabIndex) : 0;
+}
+function isDisabled(element) {
+  return "disabled" in element && !!element.disabled;
+}
+function isFormControl(element) {
+  const name = element.tagName;
+  return name === "BUTTON" || name === "INPUT" || name === "SELECT" || name === "TEXTAREA";
+}
+function isInert(element) {
+  return "inert" in element && !!element.inert;
+}
+function isUngroupedRadio(element) {
+  return element instanceof HTMLInputElement && element.type === "radio" && !!element.name;
+}
+function createRovingTabIndex(container, options = {}) {
+  if (!(container instanceof Element)) {
+    console.warn("Invalid container element");
+    return () => {
+    };
+  }
+  let {
+    direction,
+    navigationOnly = false,
+    selector,
+    typeahead = false,
+    wrap = false
+  } = options;
+  if (typeof direction !== "undefined" && !["horizontal", "vertical"].includes(direction)) {
+    console.warn("Invalid direction option. Fallback: both (undefined).");
+    direction = void 0;
+  }
+  if (typeof navigationOnly !== "boolean") {
+    console.warn("Invalid navigationOnly option. Fallback: false.");
+    navigationOnly = false;
+  }
+  if (typeof selector !== "undefined" && typeof selector !== "string") {
+    console.warn(
+      "Invalid selector. Fallback: all focusable elements (undefined)."
+    );
+    selector = void 0;
+  }
+  if (typeof typeahead !== "boolean") {
+    console.warn("Invalid typeahead option. Fallback: false.");
+    typeahead = false;
+  }
+  if (typeof wrap !== "boolean") {
+    console.warn("Invalid wrap option. Fallback: false.");
+    wrap = false;
+  }
+  const roving = new RovingTabIndex(container, {
+    direction,
+    navigationOnly,
+    selector,
+    typeahead,
+    wrap
+  });
+  return () => roving.destroy();
+}
+var RovingTabIndex = class {
+  #container;
+  #options;
+  #focusables = /* @__PURE__ */ new Set();
+  #focusablesByFirstChar = /* @__PURE__ */ new Map();
+  #selectorFilter;
+  #controller = null;
+  #isDestroyed = false;
+  constructor(container, options = {}) {
+    this.#container = container;
+    this.#options = options;
+    this.#selectorFilter = this.#createSelectorFilter();
+    this.#initialize();
+  }
+  destroy() {
+    if (this.#isDestroyed) {
+      return;
+    }
+    this.#isDestroyed = true;
+    this.#controller?.abort();
+    this.#controller = null;
+    restoreAttributes2([...this.#focusables]);
+    this.#focusables.clear();
+    this.#focusablesByFirstChar.clear();
+    this.#container.removeAttribute("data-roving-tabindex-initialized");
+  }
+  #initialize() {
+    this.#update(document.activeElement);
+    this.#controller = new AbortController();
+    document.addEventListener("keydown", this.#onKeyDown, {
+      capture: true,
+      signal: this.#controller.signal
+    });
+    this.#container.setAttribute("data-roving-tabindex-initialized", "");
+  }
+  #onKeyDown = (event) => {
+    if (!event.composedPath().includes(this.#container)) {
+      return;
+    }
+    const { key, altKey, ctrlKey, metaKey } = event;
+    if (altKey || ctrlKey || metaKey) {
+      return;
+    }
+    const { direction, typeahead, wrap } = this.#options;
+    const isBoth = !direction;
+    const isHorizontal = direction === "horizontal";
+    if (![
+      "End",
+      "Home",
+      ...isBoth ? ["ArrowLeft", "ArrowUp"] : [`Arrow${isHorizontal ? "Left" : "Up"}`],
+      ...isBoth ? ["ArrowRight", "ArrowDown"] : [`Arrow${isHorizontal ? "Right" : "Down"}`]
+    ].includes(key)) {
+      if (!typeahead || !/^\S$/i.test(key) || !this.#focusablesByFirstChar.has(key.toUpperCase())) {
+        return;
+      }
+    }
+    const active = getActiveElement();
+    if (!(active instanceof HTMLElement)) {
+      return;
+    }
+    const current = this.#getFocusables();
+    if (!current.includes(active)) {
+      return;
+    }
+    event.preventDefault();
+    event.stopPropagation();
+    const currentIndex = current.indexOf(active);
+    let rawIndex;
+    let newIndex = currentIndex;
+    let target = current;
+    switch (key) {
+      case "End":
+        newIndex = -1;
+        break;
+      case "Home":
+        newIndex = 0;
+        break;
+      case "ArrowLeft":
+      case "ArrowUp":
+        rawIndex = currentIndex - 1;
+        newIndex = wrap ? rawIndex : Math.max(rawIndex, 0);
+        break;
+      case "ArrowRight":
+      case "ArrowDown":
+        rawIndex = currentIndex + 1;
+        newIndex = wrap ? rawIndex % current.length : Math.min(rawIndex, current.length - 1);
+        break;
+      default: {
+        target = this.#focusablesByFirstChar.get(key.toUpperCase()) ?? [];
+        const foundIndex = target.findIndex(
+          (focusable2) => current.indexOf(focusable2) > currentIndex
+        );
+        newIndex = foundIndex >= 0 ? foundIndex : 0;
+      }
+    }
+    const focusable = target.at(newIndex);
+    if (!focusable) {
+      return;
+    }
+    this.#update(focusable);
+    focusElement(focusable);
+  };
+  #update(active) {
+    const current = /* @__PURE__ */ new Set([
+      ...this.#getFocusables(),
+      ...getFocusables(this.#container, {
+        composed: true,
+        filter: this.#selectorFilter,
+        skipVisibilityCheck: true
+      })
+    ]);
+    for (const focusable of this.#focusables) {
+      if (current.has(focusable)) {
+        continue;
+      }
+      focusable.isConnected && restoreAttributes2([focusable]);
+      this.#focusables.delete(focusable);
+      this.#focusablesByFirstChar.forEach((focusables) => {
+        const index = focusables.indexOf(focusable);
+        index >= 0 && focusables.splice(index, 1);
+      });
+    }
+    const { navigationOnly } = this.#options;
+    for (const focusable of current) {
+      if (this.#focusables.has(focusable)) {
+        continue;
+      }
+      this.#focusables.add(focusable);
+      if (!navigationOnly) {
+        saveAttributes2([focusable], ["tabindex"]);
+        focusable.setAttribute("tabindex", "-1");
+      }
+      if (!this.#options.typeahead) {
+        continue;
+      }
+      const value = focusable.ariaKeyShortcuts?.trim();
+      const keys = new Set(
+        value ? value.split(/\s+/).filter((key) => /^\S$/i.test(key)).map((key) => key.toUpperCase()) : []
+      );
+      const char = focusable.textContent?.trim()?.at(0)?.toUpperCase();
+      if (char) {
+        keys.add(char);
+        saveAttributes2([focusable], ["aria-keyshortcuts"]);
+        addTokenToAttribute2(focusable, "aria-keyshortcuts", char, {
+          caseInsensitive: true
+        });
+      }
+      keys.forEach((key) => {
+        const focusables = this.#focusablesByFirstChar.get(key) ?? [];
+        focusables.push(focusable);
+        this.#focusablesByFirstChar.set(key, focusables);
+      });
+    }
+    if (navigationOnly) {
+      return;
+    }
+    if (active && this.#focusables.has(active)) {
+      this.#focusables.forEach((focusable) => {
+        focusable.setAttribute("tabindex", focusable === active ? "0" : "-1");
+      });
+      return;
+    }
+    [...this.#focusables].forEach((focusable, i) => {
+      focusable.setAttribute("tabindex", i ? "-1" : "0");
+    });
+  }
+  #createSelectorFilter() {
+    const { selector } = this.#options;
+    return (element) => !selector || [...this.#container.querySelectorAll(selector)].includes(element);
+  }
+  #getFocusables() {
+    return getFocusables(this.#container, {
+      composed: true,
+      filter: this.#selectorFilter,
+      include: (element) => this.#focusables.has(element),
+      skipVisibilityCheck: true
+    });
+  }
+};
+function focusElement(element) {
+  "focus" in element && typeof element.focus === "function" && element.focus();
+}
+function getActiveElement() {
+  let current = document.activeElement;
+  while (current?.shadowRoot?.activeElement) {
+    current = current.shadowRoot.activeElement;
+  }
+  return current;
+}
 // src/index.ts
 var Tabs = class _Tabs {
   static defaults = {};
@@ -87,6 +587,7 @@ var Tabs = class _Tabs {
   #bindings = /* @__PURE__ */ new WeakMap();
   #eventController = null;
   #animationController = null;
+  #cleanupsRovingTabIndex = [];
   #animation = null;
   #indicators = [];
   #isDestroyed = false;
@@ -213,7 +714,7 @@ var Tabs = class _Tabs {
         if (!tab2) {
           return;
         }
-        p.setAttribute("hidden", isFocusable(tab2) ? "until-found" : "");
+        p.setAttribute("hidden", isFocusable2(tab2) ? "until-found" : "");
       }
     });
     this.#animation?.cancel();
@@ -286,6 +787,10 @@ var Tabs = class _Tabs {
     this.#isDestroyed = true;
     this.#eventController?.abort();
     this.#eventController = null;
+    this.#cleanupsRovingTabIndex.forEach((cleanup) => {
+      cleanup();
+    });
+    this.#cleanupsRovingTabIndex.length = 0;
     this.#indicators.forEach((indicator) => {
       indicator.destroy(force);
     });
@@ -367,11 +872,7 @@ var Tabs = class _Tabs {
         tab.id ||= `tabs-tab-${id}`;
       }
       tab.setAttribute("role", "tab");
-      tab.setAttribute(
-        "tabindex",
-        tab.ariaSelected === "true" && !isAvoided ? "0" : "-1"
-      );
-      !isFocusable(tab) && tab.style.setProperty("pointer-events", "none");
+      !isFocusable2(tab) && tab.style.setProperty("pointer-events", "none");
       addTokenToAttribute(panel, "aria-labelledby", tab.id);
       tab.addEventListener("click", this.#onTabClick, { signal });
       tab.addEventListener("focus", this.#onTabFocus, { signal });
@@ -392,6 +893,21 @@ var Tabs = class _Tabs {
         signal
       });
     });
+    this.#listElements.forEach((list) => {
+      this.#cleanupsRovingTabIndex.push(
+        createRovingTabIndex(list, {
+          direction: list.ariaOrientation === "undefined" ? void 0 : this.#settings.vertical ? "vertical" : "horizontal",
+          selector: this.#settings.selector.tab,
+          wrap: true
+        })
+      );
+      list.querySelectorAll(this.#settings.selector.tab).forEach((tab) => {
+        tab.setAttribute(
+          "tabindex",
+          tab.ariaSelected === "true" && !this.#isAvoidedTab(tab) ? "0" : "-1"
+        );
+      });
+    });
     this.#rootElement.setAttribute("data-tabs-initialized", "");
   }
   #onTabClick = (event) => {
@@ -407,6 +923,7 @@ var Tabs = class _Tabs {
     if (!(tab instanceof HTMLElement)) {
       return;
     }
+    !this.#settings.manual && tab.click();
     this.#isAvoidedTab(tab) && tab.blur();
   };
   #onTabKeyDown = (event) => {
@@ -414,62 +931,20 @@ var Tabs = class _Tabs {
     if (altKey || ctrlKey || metaKey || shiftKey) {
       return;
     }
-    const currentTab = event.currentTarget;
-    if (!(currentTab instanceof HTMLElement)) {
-      return;
-    }
-    const list = currentTab.closest(this.#settings.selector.list);
-    if (!list) {
-      return;
-    }
-    const isBoth = list.ariaOrientation === "undefined";
-    const isHorizontal = list.ariaOrientation !== "vertical";
-    if (![
-      "Enter",
-      " ",
-      "End",
-      "Home",
-      ...isBoth ? ["ArrowLeft", "ArrowUp"] : [`Arrow${isHorizontal ? "Left" : "Up"}`],
-      ...isBoth ? ["ArrowRight", "ArrowDown"] : [`Arrow${isHorizontal ? "Right" : "Down"}`]
-    ].includes(key)) {
+    if (!["Enter", " "].includes(key)) {
       return;
     }
-    const focusables = [
-      ...list.querySelectorAll(this.#settings.selector.tab)
-    ].filter(isFocusable);
-    const active = getActiveElement();
+    const active = getActiveElement2();
     if (!(active instanceof HTMLElement)) {
       return;
     }
     event.preventDefault();
-    const currentIndex = focusables.indexOf(active);
-    let newIndex = currentIndex;
     switch (key) {
       case "Enter":
       case " ":
         active.click();
         return;
-      case "End":
-        newIndex = -1;
-        break;
-      case "Home":
-        newIndex = 0;
-        break;
-      case "ArrowLeft":
-      case "ArrowUp":
-        newIndex = currentIndex - 1;
-        break;
-      case "ArrowRight":
-      case "ArrowDown":
-        newIndex = (currentIndex + 1) % focusables.length;
-        break;
     }
-    const newTab = focusables.at(newIndex);
-    if (!newTab) {
-      return;
-    }
-    newTab.focus();
-    !this.#settings.manual && newTab.click();
   };
   #onPanelBeforeMatch = (event) => {
     const panel = event.currentTarget;
@@ -599,7 +1074,7 @@ var TabsIndicator = class {
 function createBinding(tabs, panel) {
   return { tabs, panel, animation: null };
 }
-function getActiveElement() {
+function getActiveElement2() {
   let current = document.activeElement;
   while (current?.shadowRoot?.activeElement) {
     current = current.shadowRoot.activeElement;
@@ -613,14 +1088,14 @@ function hasFocusable(container) {
     )
   ].filter((element) => element.checkVisibility()).length;
 }
-function isFocusable(element) {
+function isFocusable2(element) {
   return !element.hasAttribute("disabled");
 }
 /**
  * Tabs
  * WAI-ARIA compliant tabs pattern implementation in TypeScript.
  *
- * @version 1.3.12
+ * @version 1.4.0
  * @author Yusuke Kamiyamane
  * @license MIT
  * @copyright Copyright (c) Yusuke Kamiyamane
@@ -638,6 +1113,45 @@ function isFocusable(element) {
    * @copyright Copyright (c) Yusuke Kamiyamane
    * @see {@link https://github.com/y14e/attributes-utils}
    *)
+@y14e/roving-tabindex/dist/index.js:
+  (**
+   * Roving Tabindex
+   * Lightweight roving tabindex utility with fully focus management.
+   * Designed for accessible menus, tabs, toolbars, and composite widgets.
+   *
+   * @version 1.3.1
+   * @author Yusuke Kamiyamane
+   * @license MIT
+   * @copyright Copyright (c) Yusuke Kamiyamane
+   * @see {@link https://github.com/y14e/roving-tabindex}
+   *)
+  (*! Bundled license information:
+  @y14e/attributes-utils/dist/index.js:
+    (**
+     * Attributes Utils
+     *
+     * @version 1.0.5
+     * @author Yusuke Kamiyamane
+     * @license MIT
+     * @copyright Copyright (c) Yusuke Kamiyamane
+     * @see {@link https://github.com/y14e/attributes-utils}
+     *)
+  power-focusable/dist/index.js:
+    (**
+     * Power Focusable
+     * High-precision focus management utility with full composed tree support.
+     * Handles complex focus rules including tabindex ordering, radio groups, inert.
+     *
+     * @version 4.2.0
+     * @author Yusuke Kamiyamane
+     * @license MIT
+     * @copyright Copyright (c) Yusuke Kamiyamane
+     * @see {@link https://github.com/y14e/power-focusable}
+     *)
+  *)
 */
 module.exports = Tabs;

package/dist/index.d.cts CHANGED Viewed

@@ -2,7 +2,7 @@
  * Tabs
  * WAI-ARIA compliant tabs pattern implementation in TypeScript.
  *
- * @version 1.3.12
+ * @version 1.4.0
  * @author Yusuke Kamiyamane
  * @license MIT
  * @copyright Copyright (c) Yusuke Kamiyamane