bestax-migrate 2.3.1 → 2.3.2

package/dist/sources/_shared/specials-utils.js

@@ -8,7 +8,8 @@
  * the modifier vocabulary is the one thing here that differs per source.
  */
 import { addAttrOnce } from './props.js';
-import { addAttr, addTodo, attributesOf, findAttr, literalValueOf, makeAttr, plainElement, removeAttr, } from './jsx-utils.js';
+import { LINK_ATTRS, elementTakesLinkAttr, tagRejectsHref, } from './polymorphic.js';
+import { addAttr, addTodo, attrSource, attributesOf, findAttr, literalValueOf, makeAttr, plainElement, removeAttr, } from './jsx-utils.js';
 /** Pick a target based on a literal align-style prop, removing the prop. */
 export function alignTarget(ctx, path, element, prop, targets, fallback) {
     const attr = findAttr(element, prop);
@@ -206,6 +207,50 @@ export function restrictAsToTargets(ctx, path, element, target, allowed, prop =
         .join(' / ')} does); render the tag directly or restructure`);
     ctx.dirty = true;
 }
+/**
+ * Strip the link attributes a plain element cannot carry.
+ *
+ * Exported because not every source reaches plain markup through
+ * `replaceWithPlain`: react-bulma-components builds six of its replacements
+ * by hand, and they bypassed this entirely -- `<Form.Help href="/x">` became
+ * `<p className="help" href="/x">`, which does not compile.
+ */
+export function dropLinkAttrsForPlainTag(ctx, path, element, tag, where) {
+    // An `href` only belongs on the anchor. The source component put it on
+    // whatever tag it rendered, where the browser ignored it; a plain element
+    // is typed as itself, so carrying it here is a type error for an attribute
+    // that never navigated anywhere.
+    // A plain rewrite can legitimately produce an `<area>` or a `<link>`, and
+    // React types an `href` onto both. The anchor-only rule that applies to
+    // bestax components does not apply here -- there is no component in the way
+    // to disagree about what it forwards.
+    //
+    // The message deliberately does not add "it navigated nowhere in the source
+    // either", the way the polymorphic path does. That holds only where `tag`
+    // came from the source -- bloomer's call sites all pass one -- while rbx and
+    // react-bulma-components hard-code the plain tag and ignore the source's
+    // element prop, so there the element really did change.
+    const href = tagRejectsHref(tag) ? findAttr(element, 'href') : undefined;
+    if (href) {
+        const was = attrSource(ctx.j, href);
+        removeAttr(element, href);
+        addTodo(ctx, path, 'prop:href', `${where} became a plain <${tag}>, which takes no \`href\` — make it an <a>, or put one inside${was ? ` — it read \`${was}\`` : ''}`);
+        ctx.dirty = true;
+    }
+    // Its siblings are judged against the same tag, each on its own, so a
+    // `referrerPolicy` on an `<img>` survives.
+    for (const name of LINK_ATTRS) {
+        if (elementTakesLinkAttr(name, tag))
+            continue;
+        const attr = findAttr(element, name);
+        if (!attr)
+            continue;
+        const was = attrSource(ctx.j, attr);
+        removeAttr(element, attr);
+        addTodo(ctx, path, `prop:${name}`, `${where} became a plain <${tag}>, which takes no \`${name}\`${was ? ` — it read \`${was}\`` : ''}; put it on an <a> inside, or change the element`);
+        ctx.dirty = true;
+    }
+}
 /**
  * The two structural rewrites every source needs, bound to that source's own
  * attribute strip (its modifier vocabulary is the one thing that differs):
@@ -216,6 +261,7 @@ export function makeStructuralHelpers(strip) {
     /** Replace the element with a plain HTML tag carrying `className`. */
     function replaceWithPlain(ctx, path, element, tag, className, where) {
         const merged = mergeClassName(ctx, path, element, className, where);
+        dropLinkAttrsForPlainTag(ctx, path, element, tag, where);
         const kept = new Set(strip(ctx, path, attributesOf(element), where));
         // Spread attributes pass through untouched, in their original places:
         // they are the caller's own props, and a plain element takes them as

package/dist/sources/bloomer/mapping.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mapping.d.ts","sourceRoot":"","sources":["../../../src/sources/bloomer/mapping.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AA2BnE;;;;GAIG;AACH,eAAO,MAAM,WAAW,EAAE,UAEzB,CAAC;AA+CF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CAsBtD,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAG1D,CAAC;AAEF;;;;;GAKG;AACH;;;;;;;GAOG;AACH,eAAO,MAAM,oBAAoB,aAI/B,CAAC;AAEH,eAAO,MAAM,kBAAkB,aAqB7B,CAAC;AAEH,8EAA8E;AAC9E,wBAAgB,eAAe,CAC7B,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,SAAS,GAC3C,MAAM,GAAG,IAAI,CA0Bf;AAED,iFAAiF;AACjF,eAAO,MAAM,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAOlD,CAAC;AAEF,eAAO,MAAM,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAsoBpD,CAAC;AAEF;;;;;;;;;GASG;AACH,eAAO,MAAM,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAiIpD,CAAC;AAEF,sDAAsD;AACtD,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,gBAAgB,GAAG,SAAS,CAM3E"}
+{"version":3,"file":"mapping.d.ts","sourceRoot":"","sources":["../../../src/sources/bloomer/mapping.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AA2BnE;;;;GAIG;AACH,eAAO,MAAM,WAAW,EAAE,UAEzB,CAAC;AA+CF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CAsBtD,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAG1D,CAAC;AAEF;;;;;GAKG;AACH;;;;;;;GAOG;AACH,eAAO,MAAM,oBAAoB,aAI/B,CAAC;AAEH,eAAO,MAAM,kBAAkB,aAqB7B,CAAC;AAEH,8EAA8E;AAC9E,wBAAgB,eAAe,CAC7B,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,SAAS,GAC3C,MAAM,GAAG,IAAI,CA0Bf;AAED,iFAAiF;AACjF,eAAO,MAAM,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAOlD,CAAC;AAEF,eAAO,MAAM,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,gBAAgB,CA0nBpD,CAAC;AAEF;;;;;;;;;GASG;AACH,eAAO,MAAM,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAiIpD,CAAC;AAEF,sDAAsD;AACtD,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,gBAAgB,GAAG,SAAS,CAM3E"}

package/dist/sources/bloomer/mapping.js

@@ -276,9 +276,6 @@ export const MAPPING = {
         props: {
             hasTextColor: TEXT_COLOR_OK,
             isSize: size,
-            href: {
-                todo: 'bestax `Delete` renders a <button> and has no anchor form; wrap it in an <a>, or handle the navigation in `onClick`',
-            },
         },
     },
     Icon: {
@@ -484,9 +481,6 @@ export const MAPPING = {
         target: 'Card.Header.Icon',
         props: {
             hasTextColor: TEXT_COLOR_OK,
-            href: {
-                todo: 'bestax `Card.Header.Icon` renders a <button>; put an <a> inside it, or handle the navigation in `onClick`',
-            },
         },
     },
     CardFooter: {
@@ -499,9 +493,6 @@ export const MAPPING = {
         target: 'Card.FooterItem',
         props: {
             hasTextColor: TEXT_COLOR_OK,
-            href: {
-                todo: 'bestax `Card.FooterItem` renders a <span> with no anchor form; put an <a> inside it',
-            },
         },
     },
     // ---- dropdown -----------------------------------------------------------
@@ -536,9 +527,6 @@ export const MAPPING = {
         props: {
             isActive: active,
             tag: TAG_AS,
-            href: {
-                todo: 'bestax `Dropdown.Item` declares no `href`; navigate in `onClick`, or put an <a> inside the item',
-            },
         },
     },
     DropdownDivider: { status: 'mapped', target: 'Dropdown.Divider' },

package/dist/sources/bloomer/specials.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"specials.d.ts","sourceRoot":"","sources":["../../../src/sources/bloomer/specials.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAE3C,OAAO,EASL,KAAK,gBAAgB,EACtB,MAAM,yBAAyB,CAAC;AAEjC,OAAO,EAQL,KAAK,aAAa,EACnB,MAAM,8BAA8B,CAAC;AAEtC,YAAY,EAAE,aAAa,EAAE,CAAC;AAuiC9B,wBAAgB,UAAU,CACxB,IAAI,EAAE,MAAM,EACZ,GAAG,EAAE,gBAAgB,EACrB,IAAI,EAAE,OAAO,CAAC,GAAG,CAAC,EAClB,OAAO,EAAE,GAAG,GACX,aAAa,CAQf;AAED,eAAO,MAAM,aAAa,UAAwB,CAAC"}
+{"version":3,"file":"specials.d.ts","sourceRoot":"","sources":["../../../src/sources/bloomer/specials.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAE3C,OAAO,EAUL,KAAK,gBAAgB,EACtB,MAAM,yBAAyB,CAAC;AAEjC,OAAO,EAQL,KAAK,aAAa,EACnB,MAAM,8BAA8B,CAAC;AAEtC,YAAY,EAAE,aAAa,EAAE,CAAC;AA0nC9B,wBAAgB,UAAU,CACxB,IAAI,EAAE,MAAM,EACZ,GAAG,EAAE,gBAAgB,EACrB,IAAI,EAAE,OAAO,CAAC,GAAG,CAAC,EAClB,OAAO,EAAE,GAAG,GACX,aAAa,CAQf;AAED,eAAO,MAAM,aAAa,UAAwB,CAAC"}

package/dist/sources/bloomer/specials.js

@@ -11,7 +11,7 @@
  * element `replaced` when it substituted the node itself.
  */
 import { RENDER_TODO, RESPONSIVE_PROPS, UNIVERSAL_PROPS } from './mapping.js';
-import { addAttr, addTodo, attributesOf, findAttr, literalValueOf, makeAttr, removeAttr, resolveBooleanish, } from '../_shared/jsx-utils.js';
+import { addAttr, attrSource, addTodo, attributesOf, findAttr, literalValueOf, makeAttr, removeAttr, resolveBooleanish, } from '../_shared/jsx-utils.js';
 import { applyPropAction } from '../_shared/props.js';
 import { applyIconProps, makeStripModifierProps, makeStructuralHelpers, modifierClass, parseIconClasses, restrictAsToTargets, } from '../_shared/specials-utils.js';
 /* eslint-disable @typescript-eslint/no-explicit-any */
@@ -76,14 +76,56 @@ const join = (...parts) => {
  * (and the Nav family). bestax's defaults differ per component, so this
  * keeps bloomer's markup for those either way:
  *
- * - with a literal `href`, a surviving `tag` (which the mapping turns into
- *   `as`) would undo the anchor on targets that already render one, so it is
- *   dropped; where the target defaults to something else, `as="a"` is set
- *   (`setAs`). A dynamic `href` was a runtime decision bloomer made and
- *   bestax cannot: it is flagged, not guessed;
+ * - with an `href` that has a value, the anchor is the element bloomer
+ *   rendered, so the `tag` beside it (which the mapping would turn into `as`)
+ *   is the branch that did not happen and goes; where the target defaults to
+ *   something other than an <a>, `as="a"` is set (`setAs`);
+ * - a dynamic `href` was a runtime decision bloomer made and bestax's `as` is
+ *   one element or the other. It resolves to the anchor, which is the branch
+ *   the `href` is there for, and the TODO names the element to restore for
+ *   the empty case. Keeping both would emit `href` beside a non-anchor `as`,
+ *   which the library does not type.
+ *
+ *   Settled deliberately, and reviewers have raised it more than once. The
+ *   alternative that keeps bloomer's own choice is a conditional --
+ *   `as={href ? 'a' : 'span'}` -- which does typecheck, on `Button` as well
+ *   as `Level.Item`. It was weighed and declined: it writes a conditional the
+ *   author did not, it only works where the source `tag` is a literal, and it
+ *   leaves a second shape to explain. A single element plus a TODO that names
+ *   the other is the output this package prefers. Do not re-litigate without
+ *   new information;
  * - without `href` or `tag`, a target that defaults to an <a> gets
  *   `as={bareAs}` so bloomer's <div> stays a <div>.
  */
+/**
+ * Did bloomer's `props.href ? 'a' : tag` take the `tag` branch for this value?
+ *
+ * True for `""`, `false` and `0`, and for `null` and `undefined` -- both reach
+ * `literalValueOf` as expressions, because it has no kind for them, but both
+ * are statically falsy and neither ever selected the anchor. `undefined` is
+ * shadowable (a parameter may be named it), so it is resolved by binding
+ * rather than by text, which is the rule this package applies to component
+ * references.
+ *
+ * Shared by `anchorWhenHref` and the `panel-block` handler: they are two
+ * copies of the same decision, and the second one missed these two literals.
+ */
+function isFalsyHref(path, attr) {
+    const expr = attr.value?.type === 'JSXExpressionContainer'
+        ? attr.value.expression
+        : undefined;
+    if (expr) {
+        if (expr.type === 'NullLiteral')
+            return true;
+        if (expr.type === 'Literal' && expr.value === null)
+            return true;
+        if (expr.type === 'Identifier' && expr.name === 'undefined') {
+            return !path.scope?.lookup('undefined');
+        }
+    }
+    const literal = literalValueOf(attr);
+    return literal.kind !== 'expression' && !literal.value;
+}
 function anchorWhenHref(ctx, path, element, options = {}) {
     const handled = [];
     const tagAttr = findAttr(element, 'tag');
@@ -92,31 +134,65 @@ function anchorWhenHref(ctx, path, element, options = {}) {
     // false `href` kept the default element. It selected nothing, and bestax
     // types `href` as a string where it exists at all, so it is dropped.
     const hrefLiteral = hrefAttr ? literalValueOf(hrefAttr) : undefined;
-    const hrefFalsy = hrefLiteral !== undefined &&
-        hrefLiteral.kind !== 'expression' &&
-        !hrefLiteral.value;
+    const hrefFalsy = hrefAttr !== undefined && isFalsyHref(path, hrefAttr);
     if (hrefAttr && hrefFalsy) {
         removeAttr(element, hrefAttr);
         handled.push('href');
         ctx.dirty = true;
     }
     if (hrefAttr && !hrefFalsy) {
-        const literal = hrefLiteral;
-        if (literal.kind === 'expression') {
-            addTodo(ctx, path, 'prop:href', options.setAs
-                ? `bloomer rendered an <a> only when \`href\` had a value, and this one is dynamic; set \`as="a"\` conditionally by hand${tagAttr ? ' (the `tag` beside it becomes `as`, which that conditional has to account for)' : ''}`
-                : `bloomer rendered an <a> only when \`href\` had a value, and this one is dynamic; the bestax target renders an <a> already, so drop the \`href\` where it is empty${tagAttr ? ' — the `tag` beside it is flagged separately' : ''}`);
-            return handled;
-        }
+        // The href wins the element. bloomer read `props.href ? 'a' : tag`, so a
+        // `tag` here is the branch that did not run, and the anchor is what
+        // rendered. That holds for an expression too, so the `tag` still goes --
+        // but it is a live reference, so its removal is announced rather than
+        // silent, which is what the first version of this got wrong.
+        const tagValue = tagAttr ? literalValueOf(tagAttr) : undefined;
+        const dynamicTag = tagAttr !== undefined && tagValue?.kind !== 'string';
+        // The only removal in this pass that deletes an arbitrary expression, so
+        // it owes the same quote every other one gives: the reference may be the
+        // last thing keeping an import alive.
+        const dynamicTagSource = dynamicTag ? attrSource(ctx.j, tagAttr) : '';
         if (tagAttr) {
             removeAttr(element, tagAttr);
             handled.push('tag');
             ctx.dirty = true;
         }
+        if (dynamicTag) {
+            addTodo(ctx, path, 'prop:tag', `bloomer rendered an <a> whenever \`href\` had a value, so the \`tag\` expression beside this one chose nothing and is removed${dynamicTagSource ? ` -- it read \`${dynamicTagSource}\`` : ''}. Restore it by hand if the \`href\` can be empty`);
+        }
+        // An `as` on the element is not bloomer's element choice -- it took no
+        // such prop -- so a literal one that is not the anchor is dropped. An
+        // expression stays: it is the author's own component, it is the element
+        // they meant, and on a target generic over `as` it takes the `href` with
+        // it. Rewriting it to `as="a"` swapped a router link for a plain anchor.
+        const asAttr = findAttr(element, 'as');
+        const asLiteral = asAttr ? literalValueOf(asAttr) : undefined;
+        const literalAs = asLiteral?.kind === 'string' ? asLiteral.value : undefined;
+        if (asAttr && asLiteral?.kind === 'string' && literalAs !== 'a') {
+            removeAttr(element, asAttr);
+            // Say so. bloomer had no `as`, so this one was spread onto the element
+            // as a stray DOM attribute and did nothing -- but in bestax `as` picks
+            // the element, so removing it is a decision about the author's code and
+            // not a no-op the way it was in the source.
+            addTodo(ctx, path, 'prop:as', `bloomer had no \`as\` prop, so \`as="${literalAs}"\` rode onto the element it rendered and did nothing; in bestax it would pick the element, and the \`href\` here needs the <a> -- it is removed rather than left to fight the anchor`);
+            ctx.dirty = true;
+        }
         if (options.setAs && !findAttr(element, 'as')) {
             addAttr(element, makeAttr(ctx.j, 'as', 'a'));
             ctx.dirty = true;
         }
+        if (hrefLiteral.kind === 'expression') {
+            // Name the element that was dropped where the source named it: it is
+            // the half of bloomer's runtime choice this output no longer renders.
+            const other = dynamicTag
+                ? 'the element `tag` named'
+                : tagValue?.kind === 'string'
+                    ? `a <${tagValue.value}>`
+                    : options.bareAs
+                        ? `a <${options.bareAs}>`
+                        : 'its default tag';
+            addTodo(ctx, path, 'prop:href', `bloomer chose the element at runtime — an <a> when \`href\` had a value, ${other} when it did not. bestax's \`as\` is one element or the other, and this is the anchor; render the other by hand where the \`href\` is empty`);
+        }
     }
     else if (options.bareAs && !tagAttr && !findAttr(element, 'as')) {
         addAttr(element, makeAttr(ctx.j, 'as', options.bareAs));
@@ -521,9 +597,7 @@ const SPECIALS = {
         // The same rule as anchorWhenHref: bloomer chose the anchor with
         // `props.href ? 'a' : tag`, so an empty or false href is no anchor.
         const hrefAttr = findAttr(element, 'href');
-        const hrefLiteral = hrefAttr ? literalValueOf(hrefAttr) : undefined;
-        const anchored = hrefAttr !== undefined &&
-            (hrefLiteral.kind === 'expression' || Boolean(hrefLiteral.value));
+        const anchored = hrefAttr !== undefined && !isFalsyHref(path, hrefAttr);
         if (hrefAttr && !anchored) {
             // A falsy href selected nothing in bloomer and cannot sit on a <div>.
             removeAttr(element, hrefAttr);

package/dist/sources/bloomer/transform.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"transform.d.ts","sourceRoot":"","sources":["../../../src/sources/bloomer/transform.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,OAAO,KAAK,EAAE,GAAG,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AACjD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAuDvD,MAAM,CAAC,OAAO,UAAU,SAAS,CAC/B,QAAQ,EAAE,QAAQ,EAClB,GAAG,EAAE,GAAG,EACR,OAAO,GAAE,gBAAqB,GAC7B,MAAM,GAAG,SAAS,CA06BpB"}
+{"version":3,"file":"transform.d.ts","sourceRoot":"","sources":["../../../src/sources/bloomer/transform.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,OAAO,KAAK,EAAE,GAAG,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AACjD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAwDvD,MAAM,CAAC,OAAO,UAAU,SAAS,CAC/B,QAAQ,EAAE,QAAQ,EAClB,GAAG,EAAE,GAAG,EACR,OAAO,GAAE,gBAAqB,GAC7B,MAAM,GAAG,SAAS,CA86BpB"}

package/dist/sources/bloomer/transform.js

@@ -24,6 +24,7 @@
 import { HELPERLESS_TARGETS, MAPPING, NO_CLASSNAME_TARGETS, UNIVERSAL_PROPS, helperClassHint, resolveMapping, } from './mapping.js';
 import { addTodo, attributesOf, jsxNameParts, literalValueOf, removeAttr, renameElement, } from '../_shared/jsx-utils.js';
 import { applyPropAction, applyUniversalProps, mergeClass, } from '../_shared/props.js';
+import { enforcePolymorphicProps } from '../_shared/polymorphic.js';
 import { collectBoundNames, makeReserve, nameOf, prefersTabs, resolvesToBinding, } from '../_shared/imports.js';
 import { flattenResponsiveProps, RESPONSIVE_KINDS } from './responsive.js';
 import { runSpecial } from './specials.js';
@@ -456,6 +457,9 @@ export default function transform(fileInfo, api, options = {}) {
             }
         }
         applyUniversalProps(ctx, path, element, handled, UNIVERSAL_PROPS);
+        // Last: bestax's props follow `as`, so the element decides which of the
+        // props just written it can actually take.
+        enforcePolymorphicProps(ctx, path, element, target);
     });
     // ---- 2b. Value references to bloomer components ---------------------------
     // Components can be referenced as plain values too (`as={Block}`, passed to

package/dist/sources/rbx/mapping.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mapping.d.ts","sourceRoot":"","sources":["../../../src/sources/rbx/mapping.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAuCnE;;;;;;;;;GASG;AACH,eAAO,MAAM,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CAiCtD,CAAC;AAEF,uDAAuD;AACvD,eAAO,MAAM,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAOrD,CAAC;AAEF,2DAA2D;AAC3D,eAAO,MAAM,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAQvD,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,sBAAsB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAShE,CAAC;AAEF,eAAO,MAAM,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAssBpD,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CA2FhD,CAAC;AAEF,sDAAsD;AACtD,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,gBAAgB,GAAG,SAAS,CAM3E"}
+{"version":3,"file":"mapping.d.ts","sourceRoot":"","sources":["../../../src/sources/rbx/mapping.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAuCnE;;;;;;;;;GASG;AACH,eAAO,MAAM,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CAiCtD,CAAC;AAEF,uDAAuD;AACvD,eAAO,MAAM,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAOrD,CAAC;AAEF,2DAA2D;AAC3D,eAAO,MAAM,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAQvD,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,sBAAsB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAShE,CAAC;AAEF,eAAO,MAAM,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAktBpD,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CA2FhD,CAAC;AAEF,sDAAsD;AACtD,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,gBAAgB,GAAG,SAAS,CAM3E"}

package/dist/sources/rbx/mapping.js

@@ -510,7 +510,11 @@ export const MAPPING = {
                 target: 'Dropdown.Item',
                 // `as` lives on DropdownItemProps ('a' | 'div' | 'button'), not on
                 // the Dropdown root.
-                props: { as: AS_OK, active: {}, onClick: {} },
+                props: {
+                    as: AS_OK,
+                    active: {},
+                    onClick: {},
+                },
             },
             Divider: { status: 'mapped', target: 'Dropdown.Divider' },
             Context: {
@@ -680,6 +684,14 @@ export const MAPPING = {
                 },
             },
             Item: {
+                // The `navbar-item` handler names a target only for the `dropdown`
+                // case; without one here the plain item resolved to no target at all,
+                // and `transform.ts` skips every prop pass for an element it cannot
+                // name — so `backgroundColor`/`marginless` on a plain `<Navbar.Item>`
+                // passed through as rbx wrote them while the same props on its
+                // `Navbar.Link` sibling migrated. The rename is a no-op (rbx and
+                // bestax spell it the same), which is why it looked right.
+                target: 'Navbar.Item',
                 status: 'mapped',
                 special: 'navbar-item',
                 props: { active: {}, onClick: {}, as: AS_OK },

package/dist/sources/rbx/transform.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"transform.d.ts","sourceRoot":"","sources":["../../../src/sources/rbx/transform.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,KAAK,EAAE,GAAG,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AACjD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AA2DvD,MAAM,CAAC,OAAO,UAAU,SAAS,CAC/B,QAAQ,EAAE,QAAQ,EAClB,GAAG,EAAE,GAAG,EACR,OAAO,GAAE,gBAAqB,GAC7B,MAAM,GAAG,SAAS,CAmoCpB"}
+{"version":3,"file":"transform.d.ts","sourceRoot":"","sources":["../../../src/sources/rbx/transform.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,KAAK,EAAE,GAAG,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AACjD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AA4DvD,MAAM,CAAC,OAAO,UAAU,SAAS,CAC/B,QAAQ,EAAE,QAAQ,EAClB,GAAG,EAAE,GAAG,EACR,OAAO,GAAE,gBAAqB,GAC7B,MAAM,GAAG,SAAS,CA0oCpB"}

package/dist/sources/rbx/transform.js

@@ -22,6 +22,7 @@
 import { BADGE_PROPS, MAPPING, TOOLTIP_PROPS, UNIVERSAL_PROPS, resolveMapping, } from './mapping.js';
 import { addTodo, attributesOf, findAttr, jsxNameParts, literalValueOf, removeAttr, renameElement, } from '../_shared/jsx-utils.js';
 import { applyPropAction, applyUniversalProps } from '../_shared/props.js';
+import { enforcePolymorphicProps } from '../_shared/polymorphic.js';
 import { collectBoundNames, makeAliasRegistry, makeReserve, nameOf, prefersTabs, resolvesToBinding, } from '../_shared/imports.js';
 import { flattenResponsiveProps, RESPONSIVE_KINDS } from './responsive.js';
 import { runSpecial } from './specials.js';
@@ -560,6 +561,12 @@ export default function transform(fileInfo, api, options = {}) {
             }
         }
         applyUniversalProps(ctx, path, element, handled, UNIVERSAL_PROPS);
+        // After every prop pass: bestax's props follow `as`, so the element
+        // decides which of the props just written it can actually take. The
+        // wrappers below move neither `as` nor `href`, so this reads the final
+        // pair either way.
+        // rbx spells its element prop `as`, so a spread here really can carry one.
+        enforcePolymorphicProps(ctx, path, element, target, true);
         // ---- 2a. badge/tooltip helper props → wrapping components ------------
         // Last, so the inner element is already fully migrated. Both families are
         // read off `element` — the props live there whichever wrapper is built

package/dist/sources/react-bulma-components/mapping.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mapping.d.ts","sourceRoot":"","sources":["../../../src/sources/react-bulma-components/mapping.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAOnE;;;;GAIG;AACH,eAAO,MAAM,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CAgFtD,CAAC;AAEF,gEAAgE;AAChE,eAAO,MAAM,sBAAsB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAUhE,CAAC;AAIF,eAAO,MAAM,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAspBpD,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAsEhD,CAAC;AAEF,6EAA6E;AAC7E,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,gBAAgB,GAAG,SAAS,CAM3E"}
+{"version":3,"file":"mapping.d.ts","sourceRoot":"","sources":["../../../src/sources/react-bulma-components/mapping.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAOnE;;;;GAIG;AACH,eAAO,MAAM,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CAgFtD,CAAC;AAEF,gEAAgE;AAChE,eAAO,MAAM,sBAAsB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAUhE,CAAC;AAIF,eAAO,MAAM,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,gBAAgB,CA6pBpD,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAsEhD,CAAC;AAEF,6EAA6E;AAC7E,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,gBAAgB,GAAG,SAAS,CAM3E"}

package/dist/sources/react-bulma-components/mapping.js

@@ -345,6 +345,8 @@ export const MAPPING = {
                 status: 'mapped',
                 target: 'Control',
                 props: {
+                    // `Control` declares `as` too, narrowed to div/p.
+                    renderAs: { rename: 'as' },
                     fullwidth: { booleanToProp: { name: 'isExpanded' } },
                     loading: { booleanToProp: { name: 'isLoading' } },
                     iconType: {
@@ -470,6 +472,11 @@ export const MAPPING = {
         target: 'Image',
         special: 'image',
         props: {
+            // bestax's `Image` does declare an `as`, narrowed to figure/div/p, so
+            // the universal `renderAs` TODO ("this bestax component has no `as`
+            // prop") was a false claim about the library and left the prop on the
+            // element. Renaming lets the narrowed-union check judge it.
+            renderAs: { rename: 'as' },
             rounded: { booleanToProp: { name: 'isRounded' } },
             fallback: {
                 todo: 'no fallback prop in bestax Image; handle onError yourself',

package/dist/sources/react-bulma-components/specials.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"specials.d.ts","sourceRoot":"","sources":["../../../src/sources/react-bulma-components/specials.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAE3C,OAAO,EAWL,KAAK,gBAAgB,EACtB,MAAM,yBAAyB,CAAC;AACjC,OAAO,EAOL,KAAK,aAAa,EACnB,MAAM,8BAA8B,CAAC;AAEtC,YAAY,EAAE,aAAa,EAAE,CAAC;AAgxB9B,wBAAgB,UAAU,CACxB,IAAI,EAAE,MAAM,EACZ,GAAG,EAAE,gBAAgB,EACrB,IAAI,EAAE,OAAO,CAAC,GAAG,CAAC,EAClB,OAAO,EAAE,GAAG,GACX,aAAa,CAIf;AAED,kEAAkE;AAClE,eAAO,MAAM,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,GAAG,QAAQ,CAGjE,CAAC"}
+{"version":3,"file":"specials.d.ts","sourceRoot":"","sources":["../../../src/sources/react-bulma-components/specials.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAE3C,OAAO,EAWL,KAAK,gBAAgB,EACtB,MAAM,yBAAyB,CAAC;AAEjC,OAAO,EAQL,KAAK,aAAa,EACnB,MAAM,8BAA8B,CAAC;AAEtC,YAAY,EAAE,aAAa,EAAE,CAAC;AA+yB9B,wBAAgB,UAAU,CACxB,IAAI,EAAE,MAAM,EACZ,GAAG,EAAE,gBAAgB,EACrB,IAAI,EAAE,OAAO,CAAC,GAAG,CAAC,EAClB,OAAO,EAAE,GAAG,GACX,aAAa,CAIf;AAED,kEAAkE;AAClE,eAAO,MAAM,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,GAAG,QAAQ,CAGjE,CAAC"}

package/dist/sources/react-bulma-components/specials.js

@@ -9,7 +9,8 @@
  */
 import { RESPONSIVE_BREAKPOINTS, UNIVERSAL_PROPS } from './mapping.js';
 import { addAttr, addTodo, attributesOf, buildJsxName, findAttr, literalValueOf, makeAttr, plainElement, removeAttr, resolveBooleanish, } from '../_shared/jsx-utils.js';
-import { alignTarget, makeStripModifierProps, mergeClassName, applyIconProps, parseIconClasses, } from '../_shared/specials-utils.js';
+import { enforcePolymorphicProps } from '../_shared/polymorphic.js';
+import { alignTarget, dropLinkAttrsForPlainTag, makeStripModifierProps, mergeClassName, applyIconProps, parseIconClasses, } from '../_shared/specials-utils.js';
 /* eslint-disable @typescript-eslint/no-explicit-any */
 /**
  * The attributes a plain-element rewrite keeps: the modifier strip decides
@@ -18,7 +19,12 @@ import { alignTarget, makeStripModifierProps, mergeClassName, applyIconProps, pa
  * takes as readily as the component did. `attributesOf` filters spreads out,
  * so passing its result alone dropped `{...rest}` with no TODO.
  */
-function keptAttrs(ctx, path, element, where) {
+function keptAttrs(ctx, path, element, where, tag) {
+    // These replacements are built by hand rather than through
+    // `replaceWithPlain`, so the link-attribute cleanup has to be invoked here
+    // or it never runs for this source: `<Form.Help href="/x">` was becoming
+    // `<p className="help" href="/x">`.
+    dropLinkAttrsForPlainTag(ctx, path, element, tag, where);
     const kept = new Set(stripModifierProps(ctx, path, attributesOf(element), where));
     return (element.openingElement.attributes ?? []).filter((a) => a.type === 'JSXSpreadAttribute' || kept.has(a));
 }
@@ -135,6 +141,10 @@ const SPECIALS = {
         if (headingTruthy && !subtitleDynamic) {
             removeAttr(element, headingAttr);
             const className = mergeClassName(ctx, path, element, subtitleTruthy ? 'heading subtitle' : 'heading', 'Heading');
+            // The seventh hand-built plain rewrite in this file, and the one that
+            // does not go through `keptAttrs` -- so it needs the cleanup by name or
+            // `<Heading renderAs="a" href="/x">` lands an `href` on the `<p>`.
+            dropLinkAttrsForPlainTag(ctx, path, element, 'p', 'Heading');
             const consumed = new Set(stripModifierProps(ctx, path, attributesOf(element).filter(a => !['size', 'weight', 'spaced', 'subtitle'].includes(a.name.name)), 'Heading'));
             const rest = (element.openingElement.attributes ?? []).filter((a) => a.type === 'JSXSpreadAttribute' || consumed.has(a));
             const replacement = plainElement(ctx.j, 'p', className, rest, element.children ?? []);
@@ -179,14 +189,33 @@ const SPECIALS = {
      * RBC Card.Image takes Image props directly; bestax Card.Image is a plain
      * wrapper — move the props onto a new inner <Image>.
      */
-    'card-image'(ctx, _path, element) {
+    'card-image'(ctx, path, element) {
         const children = (element.children ?? []).filter((c) => !(c.type === 'JSXText' && c.value.trim() === ''));
-        const attrs = element.openingElement.attributes ?? [];
-        const imageAttrs = attrs.filter((a) => a.type === 'JSXAttribute' && a.name.name !== 'className');
-        if (children.length > 0 || imageAttrs.length === 0) {
-            // Already wrapping its own content — nothing to restructure.
+        // These props are about to become an `<Image>`'s, so they are judged
+        // against `Image` and not against the `Card.Image` wrapper they are
+        // written on. The special returns `replaced`, so the shared pass never
+        // sees the child it creates -- `<Card.Image href="/x">` was moving the
+        // `href` onto an `<Image>` that declares none.
+        const imageAttrsOf = () => (element.openingElement.attributes ?? []).filter((a) => a.type === 'JSXAttribute' && a.name.name !== 'className');
+        if (children.length > 0 || imageAttrsOf().length === 0) {
+            // Already wrapping its own content — nothing to restructure, and
+            // nothing here is destined for an `<Image>`. Bail before touching the
+            // props: renaming `renderAs` on this path left an `as` on the
+            // `Card.Image` wrapper, which has none, and put it beyond the reach of
+            // the ordinary `renderAs` mapping that would have flagged it.
             return {};
         }
+        // `renderAs` is renamed first: the mapping does that for a plain `Image`,
+        // but this path never reaches the prop passes, so without it the check
+        // below would look for an `as` that is still spelled the RBC way.
+        const renderAsAttr = findAttr(element, 'renderAs');
+        if (renderAsAttr)
+            renderAsAttr.name = ctx.j.jsxIdentifier('as');
+        enforcePolymorphicProps(ctx, path, element, 'Image');
+        // Read the attributes back AFTER that: it removes the ones `Image` cannot
+        // take, and a list captured beforehand would carry the removed nodes onto
+        // the child regardless.
+        const imageAttrs = imageAttrsOf();
         for (const attr of imageAttrs) {
             if (attr.name.name === 'size') {
                 const literal = literalValueOf(attr);
@@ -199,7 +228,7 @@ const SPECIALS = {
             }
         }
         const inner = ctx.j.jsxElement(ctx.j.jsxOpeningElement(ctx.j.jsxIdentifier(ctx.reserve('Image')), imageAttrs, true), null, []);
-        element.openingElement.attributes = attrs.filter((a) => a.type === 'JSXAttribute' && a.name.name === 'className');
+        element.openingElement.attributes = (element.openingElement.attributes ?? []).filter((a) => a.type === 'JSXAttribute' && a.name.name === 'className');
         element.children = [inner];
         element.openingElement.selfClosing = false;
         // The walker's rename pass rewrites both names to the final (possibly
@@ -319,7 +348,7 @@ const SPECIALS = {
             }
         }
         className = mergeClassName(ctx, path, element, className, 'Form.Label');
-        const rest = keptAttrs(ctx, path, element, 'Form.Label');
+        const rest = keptAttrs(ctx, path, element, 'Form.Label', 'label');
         path.replace(plainElement(ctx.j, 'label', className, rest, element.children ?? []));
         ctx.dirty = true;
         return { replaced: true };
@@ -340,7 +369,7 @@ const SPECIALS = {
             }
         }
         className = mergeClassName(ctx, path, element, className, 'Form.Help');
-        const rest = keptAttrs(ctx, path, element, 'Form.Help');
+        const rest = keptAttrs(ctx, path, element, 'Form.Help', 'p');
         path.replace(plainElement(ctx.j, 'p', className, rest, element.children ?? []));
         ctx.dirty = true;
         return { replaced: true };
@@ -394,7 +423,7 @@ const SPECIALS = {
     /** RBC Loader is a plain <div class="loader"> — keep exactly that. */
     'plain-loader'(ctx, path, element) {
         const className = mergeClassName(ctx, path, element, 'loader', 'Loader');
-        const rest = keptAttrs(ctx, path, element, 'Loader');
+        const rest = keptAttrs(ctx, path, element, 'Loader', 'div');
         path.replace(plainElement(ctx.j, 'div', className, rest, element.children ?? []));
         ctx.dirty = true;
         return { replaced: true };
@@ -441,7 +470,7 @@ const SPECIALS = {
             removeAttr(element, activeAttr);
         }
         className = mergeClassName(ctx, path, element, className, 'Panel.Tabs.Tab');
-        const rest = keptAttrs(ctx, path, element, 'Panel.Tabs.Tab');
+        const rest = keptAttrs(ctx, path, element, 'Panel.Tabs.Tab', 'a');
         path.replace(plainElement(ctx.j, 'a', className, rest, element.children ?? []));
         ctx.dirty = true;
         return { replaced: true };
@@ -461,7 +490,7 @@ const SPECIALS = {
             removeAttr(element, activeAttr);
         }
         liClass = mergeClassName(ctx, path, element, liClass, 'Breadcrumb.Item');
-        const anchorAttrs = keptAttrs(ctx, path, element, 'Breadcrumb.Item');
+        const anchorAttrs = keptAttrs(ctx, path, element, 'Breadcrumb.Item', 'a');
         const children = element.children ?? [];
         const solidChildren = children.filter((c) => !(c.type === 'JSXText' && c.value.trim() === ''));
         // `<Breadcrumb.Item><a href>…</a></Breadcrumb.Item>` already carries its
@@ -497,7 +526,7 @@ const SPECIALS = {
             return { replaced: true };
         }
         const className = mergeClassName(ctx, path, element, 'table-container', 'Table.Container');
-        const rest = keptAttrs(ctx, path, element, 'Table.Container');
+        const rest = keptAttrs(ctx, path, element, 'Table.Container', 'div');
         path.replace(plainElement(ctx.j, 'div', className, rest, element.children ?? []));
         ctx.dirty = true;
         return { replaced: true };

package/dist/sources/react-bulma-components/transform.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"transform.d.ts","sourceRoot":"","sources":["../../../src/sources/react-bulma-components/transform.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,GAAG,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AACjD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AA4CvD,MAAM,CAAC,OAAO,UAAU,SAAS,CAC/B,QAAQ,EAAE,QAAQ,EAClB,GAAG,EAAE,GAAG,EACR,OAAO,GAAE,gBAAqB,GAC7B,MAAM,GAAG,SAAS,CAq8BpB"}
+{"version":3,"file":"transform.d.ts","sourceRoot":"","sources":["../../../src/sources/react-bulma-components/transform.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,GAAG,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AACjD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AA6CvD,MAAM,CAAC,OAAO,UAAU,SAAS,CAC/B,QAAQ,EAAE,QAAQ,EAClB,GAAG,EAAE,GAAG,EACR,OAAO,GAAE,gBAAqB,GAC7B,MAAM,GAAG,SAAS,CAy8BpB"}

package/dist/sources/react-bulma-components/transform.js

@@ -16,6 +16,7 @@
 import { MAPPING, UNIVERSAL_PROPS, resolveMapping } from './mapping.js';
 import { addTodo, attributesOf, jsxNameParts, renameElement, } from '../_shared/jsx-utils.js';
 import { applyPropAction, applyUniversalProps } from '../_shared/props.js';
+import { enforcePolymorphicProps } from '../_shared/polymorphic.js';
 import { collectBoundNames, makeAliasRegistry, makeReserve, nameOf, prefersTabs, resolvesToBinding, } from '../_shared/imports.js';
 import { flattenResponsiveProps } from './responsive.js';
 import { RESPONSIVE_KINDS, runSpecial } from './specials.js';
@@ -451,6 +452,9 @@ export default function transform(fileInfo, api, options = {}) {
             }
         }
         applyUniversalProps(ctx, path, element, handled, UNIVERSAL_PROPS);
+        // Last: bestax's props follow `as`, so the element decides which of the
+        // props just written it can actually take.
+        enforcePolymorphicProps(ctx, path, element, target);
     });
     // ---- 2b. Value references to RBC components ---------------------------
     // Components can be referenced as plain values too (`renderAs={Block}`,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bestax-migrate",
-  "version": "2.3.1",
+  "version": "2.3.2",
   "description": "Codemods for migrating existing React apps from other Bulma libraries to @allxsmith/bestax-bulma",
   "type": "module",
   "bin": {
@@ -38,7 +38,7 @@
     "chalk": "^6.0.0",
     "commander": "^15.0.0",
     "jscodeshift": "^17.3.0",
-    "@allxsmith/bestax-bulma": "^5.15.0"
+    "@allxsmith/bestax-bulma": "^5.15.1"
   },
   "devDependencies": {
     "@jest/globals": "^30.0.0",