@allxsmith/bestax-bulma 5.16.7 → 5.16.9

package/dist/index.cjs

@@ -1281,6 +1281,22 @@ const avatarSizes = [
     '96x96',
     '128x128',
 ];
+/**
+ * The roles a caller can use to say "this avatar is not a control", and so claim
+ * the non-interactive treatment for a custom `as` target we would otherwise have
+ * to guess about.
+ *
+ * Read by VALUE, not by presence. Any role at all used to count, which let
+ * `role="button"` — a claim of the opposite — route a real control into the
+ * decorative branch and come out `aria-hidden` and nameless. `img` is what the
+ * fallback itself applies; `presentation` and `none` are the standard ways to say
+ * an element carries no semantics, which is what pairs with `alt=""`.
+ */
+const NON_INTERACTIVE_ROLES = [
+    'img',
+    'presentation',
+    'none',
+];
 /**
  * Derives a small set of initials from a name (e.g. "Ada Lovelace" -> "AL").
  */
@@ -1375,17 +1391,63 @@ const Avatar = React.forwardRef(function Avatar(avatarProps, ref) {
     const combinedClasses = classNames(avatarClasses, bulmaHelperClasses, className);
     const initialsClass = usePrefixedClassNames('avatar-initials');
     const Tag = as ?? (href ? 'a' : 'figure');
-    // A custom `as` component given an href is being used as a link — the same
-    // condition under which isLinkLike forwards href/target/rel below — so it
-    // counts as interactive too. Otherwise alt="" would mark a real link
-    // decorative (aria-hidden) and it could render nameless.
+    // A custom component counts as interactive whether or not it was given OUR
+    // href: a router link takes `to`, creates the anchor itself, and cannot be
+    // classified from the props it arrives with (#668). Marking a real link as a
+    // picture is the worse failure — and `alt=""` would go further and mark it
+    // decorative (aria-hidden), leaving it nameless.
+    //
+    // A custom ELEMENT still needs the href. A hyphenated tag renders a real DOM
+    // element of that name, so nothing is hidden from us: without a link to follow
+    // it is still a picture. `Navbar.Link` draws the same line for `role="button"`.
+    //
+    // Where we are guessing, the caller settles it: an explicit `role` or
+    // `aria-hidden` states the semantics, so a custom component that really is a
+    // wrapper gets `role="img"` and its `alt=""` opt-out back. `role` alone would
+    // be a half-override — interactivity also drives the decorative opt-out and the
+    // name fallback, and overriding one of the three is worse than overriding none.
+    //
+    // An `href` ENDS the guess, so it outranks the signal. `as="a"`, `as="button"`
+    // and a target we were handed an href for are known to be interactive, and there
+    // the rule that an interactive element always carries an accessible name is not
+    // the caller's to waive: without this, `as={RouterLink} href="/x" role="img"`
+    // with `alt=""` rendered a real anchor as `aria-hidden` and nameless — the very
+    // failure #668 is about. `Navbar.Link` orders the same two the same way.
+    //
+    // The signal has to MEAN what it is used for, so both halves read a value rather
+    // than a presence — the way `Navbar.Link` reads `role === 'button'`. A role only
+    // claims to be a picture if it says so: `role="button"` or `role="link"` is the
+    // opposite claim, and taking any role as the signal handed an interactive-role
+    // element `aria-hidden` and no name. Likewise `aria-hidden={false}` denies
+    // hiding, so only a truthy one counts.
+    const ariaHidden = rest['aria-hidden'];
+    const statesItIsNotAControl = (rest.role !== undefined && NON_INTERACTIVE_ROLES.includes(rest.role)) ||
+        ariaHidden === true ||
+        ariaHidden === 'true';
+    const customTargetStatesSemantics = typeof Tag !== 'string' && href == null && statesItIsNotAControl;
     const isInteractive = Tag === 'a' ||
         Tag === 'button' ||
-        ((typeof Tag !== 'string' || isCustomElement(Tag)) && href != null);
+        (typeof Tag !== 'string' && !customTargetStatesSemantics) ||
+        (isCustomElement(Tag) && href != null);
     // Only forward link attributes when rendering an anchor or a custom (non-DOM)
     // component; a plain `as="div"` must not receive a stray `href`/`target`/`rel`.
     const isLinkLike = Tag === 'a' || typeof Tag !== 'string' || isCustomElement(Tag);
-    const linkProps = isLinkLike ? { href, target, rel } : {};
+    // Present-only, not `{ href, target, rel }`. An unconditional spread hands the
+    // target these keys whatever the caller passed, and a key existing is not free:
+    // a target that tests for one sees a link where there is none, and one that
+    // spreads its own `{...rest}` onward passes the nothing along. It is NOT about
+    // a destructuring default, which an explicit `undefined` triggers just as an
+    // absent key does. What stops a target that REQUIRES one from being rendered
+    // without it is the type (#665) — this is the smaller half, and the backstop for
+    // the callers a type does not reach: a plain-JavaScript one and a loose spread,
+    // the same pair `Button` and `Menu.Item` keep their own filters for.
+    const linkProps = isLinkLike
+        ? {
+            ...(href !== undefined && { href }),
+            ...(target !== undefined && { target }),
+            ...(rel !== undefined && { rel }),
+        }
+        : {};
     // alt coalesces with ?? (not ||) so an explicit alt="" survives as the
     // standard decorative marker instead of being overridden by name.
     const accessibleName = alt ?? name;
@@ -2886,7 +2948,27 @@ const NavbarLink = React.forwardRef(function NavbarLink(linkProps, ref) {
     });
     const dropdownContext = React.useContext(NavbarDropdownContext);
     const hasHref = rest.href !== undefined;
-    const isNativeInteractive = Component === 'button' || hasHref;
+    // What a custom component renders cannot be read off its input props, and the
+    // prop that ends in an anchor belongs to the router, not to us — `to`, `state`,
+    // `params` and a dozen further spellings all get there. Sniffing for more names
+    // trades one wrong guess for another, so a non-string `as` counts as
+    // interactive: announcing a real anchor as a button, and layering a synthetic
+    // click over its navigation, is the worse of the two failures (#668).
+    //
+    // A custom ELEMENT stays out of it. A hyphenated tag is a real DOM element and
+    // none of those is natively interactive, so `<x-trigger>` keeps the fallback
+    // exactly like `as="span"` — the same line `Avatar` draws for `role="img"`.
+    //
+    // Where we are guessing, the caller settles it: a custom target that declares
+    // `role="button"` is saying it is a button and not a link, so it takes the
+    // whole fallback — including the click, which is the half it could not supply
+    // itself. `Avatar` gives the same escape hatch to the same guess. An `href`
+    // still wins: a target with somewhere to navigate is a link whatever role it
+    // claims.
+    const customTargetIsButton = typeof Component !== 'string' && rest.role === 'button';
+    const isNativeInteractive = Component === 'button' ||
+        (typeof Component !== 'string' && !customTargetIsButton) ||
+        hasHref;
     // Guarded like Button's disabled blocker: these run on whatever `as` renders,
     // and a custom target's callback need not take a DOM event. One declaring
     // `onKeyDown: (k: {key: string}) => void` reaches `e.preventDefault()` and