@allxsmith/bestax-bulma 5.15.0 → 5.15.1

package/dist/index.cjs.js

@@ -1189,6 +1189,21 @@ const ColumnsComponent = ({ className, textColor, color: _fieldColor, bgColor, i
 };
 const Columns = withSubComponents(ColumnsComponent, { Column }, 'Columns');
 
+/**
+ * Whether an `as` target is a custom element rather than a built-in tag.
+ *
+ * HTML requires a custom element's name to contain a hyphen, and no built-in
+ * element name has one, so this is exact rather than a heuristic. It matters
+ * because a custom element is an intrinsic STRING — `typeof as === 'string'` is
+ * true — while its props are whatever a consumer declared through
+ * `React.JSX.IntrinsicElements`, the way this package declares `<ion-icon>`.
+ * A runtime backstop that filters built-in attributes must leave those alone,
+ * or it strips props the derived type just promised to forward.
+ */
+function isCustomElement(as) {
+    return typeof as === 'string' && as.includes('-');
+}
+
 const avatarColors = [
     'primary',
     'link',
@@ -1257,6 +1272,7 @@ function DefaultAvatarIcon() {
  *
  * @function
  * @param {AvatarProps} props - Props for the Avatar component.
+ * @param {React.Ref} ref - Forwarded ref to the element `as` renders.
  * @returns {JSX.Element} The rendered avatar element.
  *
  * @example
@@ -1264,7 +1280,8 @@ function DefaultAvatarIcon() {
  * @example
  * <Avatar name="Grace Hopper" />
  */
-const Avatar = ({ className, src, alt, name, initials, icon, size, shape = 'circle', color, as, href, target, rel, imageProps, style, ...props }) => {
+const Avatar = React.forwardRef(function Avatar(avatarProps, ref) {
+    const { className, src, alt, name, initials, icon, size, shape = 'circle', color, as, href, target, rel, imageProps, style, ...props } = avatarProps;
     // Tracks the src that failed to load. A src change clears the latch during
     // render (React's "reset state when props change" pattern) so a previously
     // failed src is retried when switched back to. The img is additionally
@@ -1316,10 +1333,10 @@ const Avatar = ({ className, src, alt, name, initials, icon, size, shape = 'circ
     // decorative (aria-hidden) and it could render nameless.
     const isInteractive = Tag === 'a' ||
         Tag === 'button' ||
-        (typeof Tag !== 'string' && href != null);
+        ((typeof Tag !== 'string' || 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';
+    const isLinkLike = Tag === 'a' || typeof Tag !== 'string' || isCustomElement(Tag);
     const linkProps = isLinkLike ? { href, target, rel } : {};
     // alt coalesces with ?? (not ||) so an explicit alt="" survives as the
     // standard decorative marker instead of being overridden by name.
@@ -1342,11 +1359,11 @@ const Avatar = ({ className, src, alt, name, initials, icon, size, shape = 'circ
     // A clickable avatar inside a form must not submit it; default the native
     // button type (an explicit type passed through rest still wins).
     const buttonTypeProps = Tag === 'button' ? { type: 'button' } : {};
-    return (jsxRuntime.jsxs(Tag, { className: combinedClasses, style: { ...sizeStyle, ...style }, ...buttonTypeProps, ...linkProps, ...a11yProps, ...rest, children: [showImage && (jsxRuntime.jsx("img", { ...imageProps, ref: imgRef, src: src, alt: accessibleName ?? '', onError: e => {
+    return (jsxRuntime.jsxs(Tag, { ref: ref, className: combinedClasses, style: { ...sizeStyle, ...style }, ...buttonTypeProps, ...linkProps, ...a11yProps, ...rest, children: [showImage && (jsxRuntime.jsx("img", { ...imageProps, ref: imgRef, src: src, alt: accessibleName ?? '', onError: e => {
                     imageProps?.onError?.(e);
                     setErroredSrc(src);
                 } }, src)), showInitials && (jsxRuntime.jsx("span", { className: initialsClass, children: resolvedInitials })), showIcon && icon, showDefaultIcon && jsxRuntime.jsx(DefaultAvatarIcon, {})] }));
-};
+});
 Avatar.displayName = 'Avatar';
 
 /**
@@ -2059,13 +2076,23 @@ const MenuList = ({ className, children, ...props }) => {
  *
  * @function
  * @param {MenuItemProps} props - Props for the MenuItem component.
+ * @param {React.Ref} ref - Forwarded ref to the inner element `as` renders.
  * @returns {JSX.Element} The rendered menu item.
  */
-const MenuItem = ({ className, children, active, href, as: Component = 'a', 'data-testid': testId, ...rest }) => {
-    const { bulmaHelperClasses, rest: bulmaRest } = useBulmaClasses(rest);
+const MenuItem = React.forwardRef(function MenuItem(itemProps, ref) {
+    const { className, children, active, as: Component = 'a', 'data-testid': testId, style, id, title, role, tabIndex, ...rest } = itemProps;
+    const { bulmaHelperClasses, rest: forwarded } = useBulmaClasses(rest);
+    // `href` reaches an anchor or a custom component (which owns its own prop
+    // contract), but not another intrinsic tag — `<span href>` is invalid HTML.
+    // The same rule Avatar applies through `isLinkLike` and Button through its
+    // intrinsic-only strip. Before #641 `href` was an own prop re-applied only
+    // for `as="a"`; deriving it from `as` must not quietly widen that.
+    const isLinkLike = Component === 'a' ||
+        typeof Component !== 'string' ||
+        isCustomElement(Component);
+    const { href: _href, ...withoutHref } = forwarded;
+    const linkProps = isLinkLike ? forwarded : withoutHref;
     const itemClass = classNames({ [usePrefixedClassNames('is-active')]: active }, bulmaHelperClasses);
-    // Standard <li> props
-    const { style, id, title, role, tabIndex, ...linkProps } = bulmaRest;
     // Split children into label and nested MenuList(s)
     const labelChildren = [];
     const nestedMenuLists = [];
@@ -2077,15 +2104,9 @@ const MenuItem = ({ className, children, active, href, as: Component = 'a', 'dat
             labelChildren.push(child);
         }
     });
-    // href/to should go to the link component
-    if (Component === 'a' && href) {
-        linkProps.href = href;
-    }
-    if (Object.prototype.hasOwnProperty.call(rest, 'to')) {
-        linkProps.to = rest.to;
-    }
-    return (jsxRuntime.jsxs("li", { className: className, "data-testid": testId, style: style, id: id, title: title, role: role, tabIndex: tabIndex, children: [jsxRuntime.jsx(Component, { className: itemClass, ...linkProps, children: labelChildren }), nestedMenuLists] }));
-};
+    return (jsxRuntime.jsxs("li", { className: className, "data-testid": testId, style: style, id: id, title: title, role: role, tabIndex: tabIndex, children: [jsxRuntime.jsx(Component, { ref: ref, className: itemClass, ...linkProps, children: labelChildren }), nestedMenuLists] }));
+});
+MenuItem.displayName = 'MenuItem';
 // Attach static subcomponents
 const Menu = withSubComponents(MenuComponent, {
     Label: MenuLabel,
@@ -2597,18 +2618,21 @@ const NavbarBrand = ({ className, children, textColor, ...props }) => {
  *
  * @function
  * @param {NavbarItemProps} props - Props for the NavbarItem component.
+ * @param {React.Ref} ref - Forwarded ref to the element `as` renders.
  * @returns {JSX.Element} The rendered item.
  */
-const NavbarItem = ({ className, as: Component = 'a', active, textColor, bgColor, children, ...props }) => {
+const NavbarItem = React.forwardRef(function NavbarItem(itemProps, ref) {
+    const { className, as: Component = 'a', active, textColor, bgColor, children, ...props } = itemProps;
     const { bulmaHelperClasses, rest } = useBulmaClasses({
         color: textColor,
         backgroundColor: bgColor,
         ...props,
     });
-    return (jsxRuntime.jsx(Component, { className: classNames(usePrefixedClassNames('navbar-item', {
+    return (jsxRuntime.jsx(Component, { ref: ref, className: classNames(usePrefixedClassNames('navbar-item', {
             'is-active': active,
         }), bulmaHelperClasses, className), ...rest, children: children }));
-};
+});
+NavbarItem.displayName = 'NavbarItem';
 /**
  * Responsive menu toggle (mobile)
  *
@@ -2672,10 +2696,11 @@ const NavbarEnd = ({ className, children, ...props }) => {
  *
  * @function
  * @param {NavbarLinkProps} props - Props for the NavbarLink component.
- * @param {React.Ref<HTMLAnchorElement | HTMLButtonElement>} ref - Forwarded ref to the rendered link or button element.
+ * @param {React.Ref} ref - Forwarded ref to the element `as` renders.
  * @returns {JSX.Element} The rendered navbar link.
  */
-const NavbarLink = React.forwardRef(function NavbarLink({ className, as: Component = 'a', arrowless, textColor, bgColor, children, ...props }, ref) {
+const NavbarLink = React.forwardRef(function NavbarLink(linkProps, ref) {
+    const { className, as: Component = 'a', arrowless, textColor, bgColor, children, ...props } = linkProps;
     const { bulmaHelperClasses, rest } = useBulmaClasses({
         color: textColor,
         backgroundColor: bgColor,
@@ -2684,8 +2709,16 @@ const NavbarLink = React.forwardRef(function NavbarLink({ className, as: Compone
     const dropdownContext = React.useContext(NavbarDropdownContext);
     const hasHref = rest.href !== undefined;
     const isNativeInteractive = Component === 'button' || 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
+    // throws. Composing the caller's handler is unconditional; acting on the
+    // event is not ours to do when the payload is foreign.
+    const isDomEvent = (e) => typeof e?.preventDefault === 'function';
     const handleKeyDown = (e) => {
         rest.onKeyDown?.(e);
+        if (!isDomEvent(e))
+            return;
         if (!dropdownContext || e.defaultPrevented)
             return;
         if (e.key === 'Enter' || e.key === ' ') {
@@ -2704,6 +2737,8 @@ const NavbarLink = React.forwardRef(function NavbarLink({ className, as: Compone
     // click semantics (navigation / the caller's handler).
     const handleClick = (e) => {
         rest.onClick?.(e);
+        if (!isDomEvent(e))
+            return;
         if (!dropdownContext || isNativeInteractive || e.defaultPrevented)
             return;
         dropdownContext.toggle();
@@ -4693,15 +4728,16 @@ const validButtonColors = [...validColors, 'text', 'ghost'];
  *
  * @function
  * @param {ButtonProps} props - Props for the Button component.
- * @param {React.Ref<HTMLButtonElement | HTMLAnchorElement>} ref - Forwarded ref to the rendered button or anchor element.
- * @returns {JSX.Element} The rendered button or anchor element.
+ * @param {React.Ref} ref - Forwarded ref to the element `as` renders.
+ * @returns {JSX.Element} The rendered button, anchor, or custom element.
  * @see {@link https://bulma.io/documentation/elements/button/ | Bulma Button documentation}
  */
-const Button = React.forwardRef(function Button({ color, size, isLight, isRounded, isLoading, isStatic, isFullwidth, isFullWidth, isOutlined, isInverted, isFocused, isActive, isHovered, isDisabled, className, children, textColor, bgColor, as: Component = 'button', href, onClick, target, rel, ...props }, ref) {
+const Button = React.forwardRef(function Button(props, ref) {
+    const { color, size, isLight, isRounded, isLoading, isStatic, isFullwidth, isFullWidth, isOutlined, isInverted, isFocused, isActive, isHovered, isDisabled, className, children, textColor, bgColor, as: Component = 'button', href, onClick, target, rel, ...bulmaProps } = props;
     const { bulmaHelperClasses, rest } = useBulmaClasses({
         color: textColor,
         backgroundColor: bgColor,
-        ...props,
+        ...bulmaProps,
     });
     // Generate Bulma classes with prefix
     const bulmaClasses = usePrefixedClassNames('button', {
@@ -4723,13 +4759,93 @@ const Button = React.forwardRef(function Button({ color, size, isLight, isRounde
     // Combine prefixed Bulma classes with unprefixed user className and prefixed helper classes
     const buttonClasses = classNames(bulmaClasses, bulmaHelperClasses, className);
     if (Component !== 'button') {
-        // Create anchor-specific props by excluding button-specific ones, so
-        // native/custom link-like elements (an <a>, a router Link, ...) don't
-        // receive button-only HTML attributes.
-        const { type: _type, disabled: _disabled, form: _form, formAction: _formAction, formEncType: _formEncType, formMethod: _formMethod, formNoValidate: _formNoValidate, formTarget: _formTarget, name: _name, value: _value, autoFocus: _autoFocus, ...anchorRest } = rest;
+        // Strip the form-control attributes a link-like element cannot carry, so a
+        // JavaScript consumer or a spread object doesn't put them on the DOM. The
+        // types no longer allow them through; this is the runtime backstop.
+        //
+        // Only for INTRINSIC tags. A custom component (a router Link, ...) owns its
+        // prop contract, and `ComponentPropsWithoutRef<T>` promises the caller that
+        // its props reach it. Stripping names by their spelling alone broke that
+        // promise silently: `<Button as={Custom} name="x" />` type-checked while
+        // `Custom` never received the `name` it requires.
+        //
+        // `autoFocus` and `type` are deliberately NOT stripped: both are valid on
+        // targets this list was filtering them from. `autoFocus` is a global
+        // attribute (React decides per element whether to honour it, which is not
+        // ours to pre-empt), and `type` on an anchor is the MIME hint that
+        // `ButtonProps<'a'>` now types it as.
+        //
+        // The types already answer this for a TypeScript caller: `ButtonProps<T>`
+        // derives from `ComponentPropsWithoutRef<T>`, so only what the target
+        // accepts can be passed. What is left is a runtime backstop for JavaScript
+        // consumers and spread objects.
+        //
+        // Keep it to the two cases where a stray attribute does something. The
+        // submit-overrides belong to a submit control and never make sense on the
+        // anchor path. `disabled` is the one that is VISIBLE: Bulma styles
+        // `.button[disabled]` (background, border, shadow, opacity), so letting it
+        // through to a `<span>` greys the element out — main stripped it, and not
+        // stripping it would be a silent visual change on a types-only release.
+        //
+        // Everything else (`name`, `value`, `form`) is inert where it does not
+        // belong, and enumerating which tags own it is what kept going wrong:
+        // first all nine names on every non-button tag (so `<Button as="input"
+        // name="query" value="Search">` submitted nothing), then a form-control
+        // allowlist that still lost `formAction` on an input and `value` on an
+        // option. Those now ride on the types instead.
+        //
+        // A custom component is exempt entirely — it owns its prop contract, and
+        // `ComponentPropsWithoutRef<T>` promises the caller its props arrive.
+        //
+        // The elements that own `disabled`, per the HTML spec. A closed set, unlike
+        // the open-ended question of which tag owns which attribute.
+        const SUBMIT_OVERRIDES = [
+            'formAction',
+            'formEncType',
+            'formMethod',
+            'formNoValidate',
+            'formTarget',
+        ];
+        const OWNS_DISABLED = [
+            'button',
+            'fieldset',
+            'input',
+            'optgroup',
+            'option',
+            'select',
+            'textarea',
+        ];
+        // Two independent filters. They are not exclusive — an `<a>` owns neither
+        // the submit-overrides nor `disabled`, so it takes both — and deriving them
+        // from one destructure, or from one if/else, is what broke each of them in
+        // turn: first the overrides came off every intrinsic (an `as="input"` lost
+        // `formAction`), then scoping them to the anchor let `disabled` back onto
+        // it.
+        const forwardedRest = { ...rest };
+        if (typeof Component === 'string' && !isCustomElement(Component)) {
+            // Meaningless anywhere but a submit control, and an anchor is not one.
+            if (Component === 'a') {
+                for (const key of SUBMIT_OVERRIDES)
+                    delete forwardedRest[key];
+            }
+            // Visible via Bulma's `.button[disabled]`, so withheld from any element
+            // that does not own it.
+            if (!OWNS_DISABLED.includes(Component))
+                delete forwardedRest.disabled;
+        }
         return (jsxRuntime.jsx(Component, { ref: ref, className: buttonClasses, href: href, target: target, rel: rel, "aria-disabled": isDisabled, tabIndex: isDisabled ? -1 : undefined, onClick: isDisabled
-                ? (e) => e.preventDefault()
-                : onClick, ...anchorRest, children: children }));
+                ? // Guarded, because this handler is installed into whatever `as`
+                    // renders and a custom component's `onClick` need not be a DOM
+                    // event handler at all. One declaring `onClick: (v: string) =>
+                    // void` calls this with a string, and an unguarded
+                    // `e.preventDefault()` throws `is not a function`. Blocking the
+                    // real event is the point; a foreign payload is simply not ours
+                    // to act on.
+                    (e) => {
+                        if (typeof e?.preventDefault === 'function')
+                            e.preventDefault();
+                    }
+                : onClick, ...forwardedRest, children: children }));
     }
     return (jsxRuntime.jsx("button", { ref: ref, className: buttonClasses, disabled: isDisabled, onClick: onClick, ...rest, children: children }));
 });
@@ -5118,7 +5234,8 @@ function usePrefersReducedMotion() {
  *   ))}
  * </Reveal>
  */
-const Reveal = ({ animation = 'fade-up', delay = 0, duration = 600, threshold = 0.15, once = true, as: Component = 'div', cascade = false, cascadeInterval = 80, className, style, children, ...props }) => {
+function RevealImpl(revealProps) {
+    const { animation = 'fade-up', delay = 0, duration = 600, threshold = 0.15, once = true, as: Component = 'div', cascade = false, cascadeInterval = 80, className, style, children, ...props } = revealProps;
     const { bulmaHelperClasses, rest } = useBulmaClasses(props);
     const classPrefix = useClassPrefix();
     const prefersReducedMotion = usePrefersReducedMotion();
@@ -5195,12 +5312,16 @@ const Reveal = ({ animation = 'fade-up', delay = 0, duration = 600, threshold =
             return (jsxRuntime.jsx("span", { className: itemAnimationClasses, style: itemStyle, children: child }, index));
         })
         : children;
-    // Scroll observation needs a real DOM node. Intrinsic tags ('div',
-    // 'section', ...) always accept a ref directly. A custom component passed
-    // via `as` (Section, Card, ...) is rendered by this library as a plain
-    // React.FC with no ref forwarding, so the ref (and the animation classes
-    // that depend on it) go on a plain wrapper `div` instead, with `Component`
-    // rendered inside it.
+    // Scroll observation needs a DOM node this component OWNS — the observer and
+    // the animation classes both key off it. An intrinsic tag is that node, so
+    // the ref goes straight on it. A component passed via `as` is not: whatever
+    // it renders is its own business, and it may render several elements or
+    // none. So it gets wrapped in an observed `div`.
+    //
+    // Not a statement about ref forwarding. Several components in this library
+    // forward refs (#641 added four more), and that changes nothing here — a
+    // forwarded ref would still point at the target's node rather than at one
+    // this component controls.
     if (typeof Component === 'string') {
         // A plain createElement call sidesteps the combinatorial JSX prop types
         // for `ref` across every possible intrinsic tag `as` could be.
@@ -5212,7 +5333,9 @@ const Reveal = ({ animation = 'fade-up', delay = 0, duration = 600, threshold =
         }, content);
     }
     return (jsxRuntime.jsx("div", { ref: setNode, className: combinedClasses, style: wrapperStyle, children: jsxRuntime.jsx(Component, { ...rest, children: content }) }));
-};
+}
+const Reveal = RevealImpl;
+Reveal.displayName = 'Reveal';
 
 /**
  * The `Block` component renders a simple container with Bulma's `.block` class, adding vertical margin between sections of content.
@@ -5265,7 +5388,7 @@ const Box = ({ className, textColor, color, bgColor, hasShadow = true, children,
  *
  * @function
  * @param {LinkButtonProps} props - Props for the LinkButton component.
- * @param {React.Ref<HTMLButtonElement | HTMLAnchorElement>} ref - Forwarded ref to the rendered button or anchor element.
+ * @param {React.Ref} ref - Forwarded ref to the element `as` renders.
  * @returns {JSX.Element} The rendered link-styled button element.
  *
  * @example
@@ -5279,7 +5402,13 @@ const Box = ({ className, textColor, color, bgColor, hasShadow = true, children,
 const LinkButton = React.forwardRef(function LinkButton({ variant = 'text', color, className, ...props }, ref) {
     const buttonColor = variant === 'underline' ? 'text' : variant;
     const prefixedClasses = usePrefixedClassNames('link-button', color && `link-button-${color}`, variant === 'underline' && 'link-button-underline');
-    return (jsxRuntime.jsx(Button, { ref: ref, color: buttonColor, className: classNames(prefixedClasses, className), ...props }));
+    return (jsxRuntime.jsx(Button
+    // LinkButton is polymorphic through to Button, which resolves the element
+    // from `as`. TS cannot infer that through the spread below.
+    , { 
+        // LinkButton is polymorphic through to Button, which resolves the element
+        // from `as`. TS cannot infer that through the spread below.
+        ref: ref, color: buttonColor, className: classNames(prefixedClasses, className), ...props }));
 });
 LinkButton.displayName = 'LinkButton';
 
@@ -5551,10 +5680,12 @@ const Image = ({ as, className, textColor, color, bgColor, size, isRounded, isRe
  *
  * @function
  * @param {LinkProps} props - Props for the Link component.
- * @returns {JSX.Element} The rendered anchor element.
+ * @param {React.Ref} ref - Forwarded ref to the element `as` renders.
+ * @returns {JSX.Element} The rendered anchor, or whatever `as` names.
  * @see {@link https://bulma.io/documentation/elements/content/ | Bulma Content documentation}
  */
-const Link = ({ className, textColor, bgColor, isActive, as: Component = 'a', children, ...props }) => {
+const Link = React.forwardRef(function Link(linkProps, ref) {
+    const { className, textColor, bgColor, isActive, as: Component = 'a', children, ...props } = linkProps;
     /**
      * Generates Bulma helper classes and separates out remaining props.
      */
@@ -5567,8 +5698,9 @@ const Link = ({ className, textColor, bgColor, isActive, as: Component = 'a', ch
         'is-active': isActive,
     });
     const linkClasses = classNames(bulmaClasses, bulmaHelperClasses, className);
-    return (jsxRuntime.jsx(Component, { className: linkClasses || undefined, ...rest, children: children }));
-};
+    return (jsxRuntime.jsx(Component, { ref: ref, className: linkClasses || undefined, ...rest, children: children }));
+});
+Link.displayName = 'Link';
 
 /**
  * The `ListItem` component renders a styled list item (`<li>`) element with Bulma helper class integration.