@allxsmith/bestax-bulma 5.15.2 → 5.15.4

package/dist/index.esm.js

@@ -1779,6 +1779,75 @@ const Card = withSubComponents(CardComponent, {
 /** Internal test-only exports. Not part of the public API. */
 const __test_exports__ = { renderFooter };
 
+/**
+ * The runtime mirror of `AnchorOnlyAttributes`, keyed so the two cannot drift.
+ *
+ * `Record<keyof …, true>` is what links them: the day React adds an anchor
+ * attribute, every component deriving its props from `as` accepts it and this
+ * object stops compiling until it is named here. A plain array beside a derived
+ * type drifts in the one direction that matters — the type accepts the new
+ * attribute and the filter lets it leak onto a `<div>`.
+ */
+const ANCHOR_ONLY_ATTRS = {
+    href: true,
+    target: true,
+    download: true,
+    hrefLang: true,
+    ping: true,
+    referrerPolicy: true,
+    media: true,
+    type: true,
+};
+/**
+ * `props` without the keys named in `strip`.
+ *
+ * The SET is per component and deliberately not shared, because the right
+ * answer differs and the differences are principled: how open the component's
+ * `as` is, and which of these attributes its own tags legitimately take. What
+ * IS shared is the derived source of truth above and this function. Each caller
+ * declares its delta next to the set it passes, which is the only place that
+ * stays true when a component's `as` changes.
+ */
+function omitAttrs(props, strip) {
+    const out = {};
+    // `Reflect.ownKeys`, not `Object.entries`: the latter drops symbol-keyed props.
+    // React enumerates props with `for...in`, which never reports a symbol, so
+    // nothing renders differently either way. It is not the same change for all
+    // three callers: Menu filtered by rest-destructure and kept them already,
+    // while Dropdown and Level filtered through `Object.entries` and did not, so
+    // this restores one and widens two. Symbols are the only shape where those
+    // two disagreed, and keeping them is the side a spread is on.
+    for (const key of Reflect.ownKeys(props)) {
+        // Enumerability, for the same reason in the other direction: `Reflect.ownKeys`
+        // also reports NON-enumerable own props, which every filter this replaced left
+        // behind. Copying one out would both add a prop the old code dropped and make
+        // it enumerable on the way, so widening the key source must not widen this.
+        if (!Object.prototype.propertyIsEnumerable.call(props, key))
+            continue;
+        const value = props[key];
+        // `hasOwnProperty`, not `key in strip`: `in` walks the prototype chain, so a
+        // prop named `toString`, `valueOf`, `constructor` or `hasOwnProperty` was
+        // stripped although no caller named it — and anything written to
+        // `Object.prototype` would start deleting props that share its keys.
+        if (typeof key === 'symbol' ||
+            !Object.prototype.hasOwnProperty.call(strip, key)) {
+            // `defineProperty`, not `out[key] = value`: assignment consults the
+            // prototype chain for a setter, and `__proto__` has one. A prop named
+            // `__proto__` would be swallowed by it — dropped from the result AND
+            // replacing the result's prototype with its value. A spread and a rest
+            // destructure both DEFINE, which is what makes them immune, so this has
+            // to define too.
+            Object.defineProperty(out, key, {
+                value,
+                writable: true,
+                enumerable: true,
+                configurable: true,
+            });
+        }
+    }
+    return out;
+}
+
 /**
  * Checks if code is running in a browser environment.
  * @param win - Window object.
@@ -2001,32 +2070,25 @@ const DropdownComponent = forwardRef(function DropdownComponent({ label, childre
     return (jsxs("div", { className: dropdownClasses, ref: setRefs, id: id, "data-testid": "dropdown-root", ...rest, children: [jsx("div", { className: usePrefixedClassNames('dropdown-trigger'), children: jsxs("button", { ref: triggerRef, className: buttonClass, "aria-haspopup": "true", "aria-controls": id ? `${id}-menu` : undefined, "aria-expanded": active, onClick: handleToggle, onKeyDown: handleTriggerKeyDown, disabled: disabled, type: "button", children: [jsx("span", { children: label }), jsx("span", { className: usePrefixedClassNames('icon', 'is-small'), "aria-hidden": "true", children: jsx("i", { className: "fas fa-angle-down" }) })] }) }), jsx("div", { className: classNames(usePrefixedClassNames('dropdown-menu'), menuClassName), id: id ? `${id}-menu` : undefined, role: "menu", "data-testid": "dropdown-menu", onKeyDown: handleMenuKeyDown, children: jsx("div", { className: usePrefixedClassNames('dropdown-content'), onClick: handleMenuClick, tabIndex: -1, children: children }) })] }));
 });
 /**
- * The anchor-only attributes, withheld from a `<div>` or a `<button>`.
- *
- * Mirrors `LINK_ATTRS` in `bestax-migrate/src/sources/_shared/polymorphic.ts`,
- * which drops the same set when a migration lands one on a non-anchor. `rel` is
- * absent from both on purpose: React declares it on `HTMLAttributes<T>` — every
- * element — so withholding it would diverge from React's own typing, the same
- * call #641 recorded for `Navbar.Link`.
- */
-const LINK_ONLY_ATTRS = [
-    'href',
-    'target',
-    'download',
-    'hrefLang',
-    'ping',
-    'referrerPolicy',
-    'media',
-];
-/** `props` without any attribute only an anchor can carry. */
-function omitLinkAttrs(props) {
-    const out = {};
-    for (const [key, value] of Object.entries(props)) {
-        if (!LINK_ONLY_ATTRS.includes(key))
-            out[key] = value;
-    }
-    return out;
-}
+ * The anchor's attributes, minus the one a `<button>` legitimately takes.
+ *
+ * `type` stays: `as="button"` is a supported form and `type="submit"` is valid
+ * there, so stripping it would remove a working attribute. The exclusion is per
+ * COMPONENT where the reason is per TAG, so it also lets a `type` reach a
+ * `<div>`; selecting the set from the rendered element would close that, and
+ * moves output.
+ *
+ * This set differs from `Level.Item`'s in both directions, not just one. The
+ * `type` above, which Level strips and this component keeps, and `rel`, which
+ * Level adds and this component does not: React declares `rel` on
+ * `HTMLAttributes` for every element, so withholding it would diverge from
+ * React's own typing — the call #641 recorded for `Navbar.Link`. Level
+ * withholds it anyway, because it always has.
+ */
+const STRIP_FROM_NON_ANCHOR$1 = (() => {
+    const { type: _type, ...rest } = ANCHOR_ONLY_ATTRS;
+    return rest;
+})();
 /**
  * Bulma Dropdown item.
  *
@@ -2044,16 +2106,18 @@ const DropdownItem = ((itemProps) => {
     // plain-JS one, a loose `{...props}` spread, and the genericity a wrapping HOC
     // erases.
     //
-    // The whole link set, not `href` alone. Menu strips only `href` because its
-    // props never gained the rest; here they all arrive together under `as="a"`,
-    // and `bestax-migrate` already removes exactly this set (`LINK_ATTRS`) when it
-    // migrates onto a non-anchor — so stripping less would leave the codemod
-    // stricter than the component it migrates to.
+    // The whole link set, not `href` alone: they all arrive together under
+    // `as="a"`. Menu strips `href` only, because its `as` is open and a flat set
+    // would delete attributes legal on the element a caller named.
+    //
+    // `bestax-migrate` tracks the same question from the other side, per attribute
+    // per element (`LINK_ATTR_ELEMENTS`) rather than as one set — so the two lists
+    // are not interchangeable and neither derives from the other.
     //
     // Menu's condition also admits a custom component and a custom element, which
     // own their prop contracts. `as` is closed to three intrinsic tags here, so
     // neither can arrive and the anchor test is the whole rule.
-    const forwarded = Component === 'a' ? rest : omitLinkAttrs(rest);
+    const forwarded = Component === 'a' ? rest : omitAttrs(rest, STRIP_FROM_NON_ANCHOR$1);
     return (jsx(Component, { className: classNames(usePrefixedClassNames('dropdown-item', {
             'is-active': active,
         }), bulmaHelperClasses, className), tabIndex: 0, role: "menuitem", "data-testid": "dropdown-item", ...forwarded, ...(Component === 'button'
@@ -2118,6 +2182,11 @@ const MenuList = ({ className, children, ...props }) => {
     // Increment level for nested MenuLists
     return (jsx(MenuListLevelContext.Provider, { value: level + 1, children: jsx("ul", { className: ulClass, ...rest, children: children }) }));
 };
+/**
+ * `href` alone — annotated so a typo is a compile error rather than a silent
+ * no-op, the way both siblings' sets are.
+ */
+const STRIP_FROM_NON_LINK = { href: true };
 /**
  * MenuItem supports `as` prop for custom link components, e.g., react-router-dom Link.
  *
@@ -2137,8 +2206,20 @@ const MenuItem = forwardRef(function MenuItem(itemProps, ref) {
     const isLinkLike = Component === 'a' ||
         typeof Component !== 'string' ||
         isCustomElement(Component);
-    const { href: _href, ...withoutHref } = forwarded;
-    const linkProps = isLinkLike ? forwarded : withoutHref;
+    // `href` ALONE. `Dropdown.Item` strips every anchor-only attribute except
+    // `type`; `Level.Item` strips all of them, plus `rel`.
+    //
+    // Not because nothing else can arrive: `as` here is an open `React.ElementType`,
+    // and a non-fresh spread skips excess-property checking, so a typed caller
+    // CAN deliver `target` or `download` and they are forwarded. The set stays at
+    // `href` because widening it would be wrong for an open `as` — `referrerPolicy`
+    // on `as="img"`, `target` on `as="form"` and `media` on `as="source"` are all
+    // legal, and a flat strip would delete them. Getting that right needs a
+    // per-attribute-per-element rule, which `bestax-migrate` already models in
+    // `LINK_ATTR_ELEMENTS`.
+    const linkProps = isLinkLike
+        ? forwarded
+        : omitAttrs(forwarded, STRIP_FROM_NON_LINK);
     const itemClass = classNames({ [usePrefixedClassNames('is-active')]: active }, bulmaHelperClasses);
     // Split children into label and nested MenuList(s)
     const labelChildren = [];
@@ -12987,6 +13068,18 @@ const LevelRight = ({ className, children, color, bgColor, textColor, ...props }
     const levelRightClasses = classNames(mainClass, bulmaHelperClasses, className);
     return (jsx("div", { className: levelRightClasses, ...rest, children: children }));
 };
+/**
+ * The derived set plus `rel`.
+ *
+ * `rel` is not an anchor-only attribute — React declares it on every element, so
+ * `AnchorOnlyAttributes` excludes it — but this component has always withheld it
+ * from a non-anchor, so it is named separately rather than folded into the shared
+ * set. That separation is what says which names come from where.
+ *
+ * The annotation is load-bearing: without it a typo adds a key nobody strips, and
+ * widening the key type to `string` also erases `omitAttrs`'s return type.
+ */
+const STRIP_FROM_NON_ANCHOR = { ...ANCHOR_ONLY_ATTRS, rel: true };
 /**
  * Individual item, can be rendered as `div`, `p`, or `a`.
  *
@@ -12994,7 +13087,7 @@ const LevelRight = ({ className, children, color, bgColor, textColor, ...props }
  * @param {LevelItemProps} props - Props for the LevelItem component.
  * @returns {JSX.Element} The rendered level item.
  */
-const LevelItem = ({ as = 'div', hasTextCentered, className, children, href, target, rel, color, bgColor, textColor, ...props }) => {
+const LevelItem = ({ as = 'div', hasTextCentered, className, children, color, bgColor, textColor, ...props }) => {
     const { bulmaHelperClasses, rest } = useBulmaClasses({
         color: textColor ?? color,
         backgroundColor: bgColor,
@@ -13005,11 +13098,16 @@ const LevelItem = ({ as = 'div', hasTextCentered, className, children, href, tar
         'has-text-centered': hasTextCentered,
     });
     const levelItemClasses = classNames(mainClass, bulmaHelperClasses, className);
-    // If rendering as "a", only pass anchor-specific props
+    // The anchor's own attributes reach an `<a>` and nothing else. The type
+    // declares them at every `as` — narrowing that is source-breaking (#672) — so
+    // the runtime is what keeps `<Level.Item as="p" download>` from rendering a
+    // dead attribute.
+    // `STRIP_FROM_NON_ANCHOR` above names the set and why `rel` is in it.
     if (Tag === 'a') {
-        return (jsx("a", { className: levelItemClasses, href: href, target: target, rel: rel, ...rest, children: children }));
+        return (jsx("a", { className: levelItemClasses, ...rest, children: children }));
     }
-    return (jsx(Tag, { className: levelItemClasses, ...rest, children: children }));
+    const withoutAnchorAttrs = omitAttrs(rest, STRIP_FROM_NON_ANCHOR);
+    return (jsx(Tag, { className: levelItemClasses, ...withoutAnchorAttrs, children: children }));
 };
 const Level = withSubComponents(LevelComponent, {
     Left: LevelLeft,