bestax-migrate 2.8.0 → 2.10.0

package/dist/sources/bulma-classes/class-map.d.ts

@@ -35,8 +35,43 @@ export interface Modifier {
  * - `todo`: bestax has a component, but the markup does not map element by
  *   element yet; the family's outermost class gets a TODO.
  * - `plain`: valid Bulma with nothing to convert to; left alone, no TODO.
+ * - `fold`: a wrapper the `target` renders itself from a prop, so the element
+ *   folds into the one `target` inside it (`.table-container` into
+ *   `Table isResponsive`).
  */
-export type RootStatus = 'mapped' | 'todo' | 'plain';
+export type RootStatus = 'mapped' | 'todo' | 'plain' | 'fold';
+/**
+ * An element whose only child the target renders itself (the `<select>`
+ * inside `.select`), so the two convert together: the target is written
+ * where the child was, and the element goes.
+ */
+export interface Absorbs {
+    /** The child's tag. */
+    readonly tag: string;
+    /**
+     * Where the target puts the attributes it is given. On the child
+     * (`SelectBase`): the child's become the target's, and the element may
+     * carry none but a `key`. On the element (`Breadcrumb`): the element's
+     * stay, and the child may carry none.
+     */
+    readonly attributesOn: 'child' | 'element';
+    /** The child's classes, as the target's props; any other class refuses. */
+    readonly modifiers?: Readonly<Record<string, Modifier>>;
+    /**
+     * A bare child attribute that one of the element's modifiers writes as a
+     * prop (`multiple`, beside `is-multiple`). Each converts only beside the
+     * other, and the attribute goes, since the prop renders it.
+     */
+    readonly pairs?: Readonly<Record<string, string>>;
+    /**
+     * A child attribute the target reads under another name, only beside a
+     * paired attribute (`size` as `multipleSize`, beside `multiple`).
+     */
+    readonly renames?: Readonly<Record<string, {
+        readonly to: string;
+        readonly beside: string;
+    }>>;
+}
 export interface RootEntry {
     readonly status: RootStatus;
     /**
@@ -89,6 +124,13 @@ export interface RootEntry {
      * takes a generated `id` when the element has none of its own.
      */
     readonly adoptsIdFrom?: readonly string[];
+    /**
+     * For a `fold` root: the props that render it on the target inside. Its
+     * modifiers add their props beside these.
+     */
+    readonly folds?: readonly PropWrite[];
+    /** The target renders the element's only child itself. */
+    readonly absorbs?: Absorbs;
     /** The target takes no helper props, so every helper class stays a class. */
     readonly noHelpers?: boolean;
     /**
@@ -97,8 +139,10 @@ export interface RootEntry {
      */
     readonly ownClassOnly?: boolean;
     /**
-     * Attributes the target types as numbers. A numeric string (`value="40"`)
-     * becomes a number, which renders the same; any other string refuses.
+     * Attributes the target types as numbers, among the ones it is given (the
+     * child's, when it `absorbs` the child and puts them there). A numeric
+     * string (`value="40"`) becomes a number, which renders the same; any
+     * other string refuses.
      */
     readonly numberAttrs?: readonly string[];
     /** Attributes the target drops: on these tags, or on all tags except these. */

package/dist/sources/bulma-classes/class-map.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"class-map.d.ts","sourceRoot":"","sources":["../../../src/sources/bulma-classes/class-map.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"class-map.d.ts","sourceRoot":"","sources":["../../../src/sources/bulma-classes/class-map.ts"],"names":[],"mappings":"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"}

package/dist/sources/bulma-classes/class-map.js

@@ -185,10 +185,13 @@ const flag = (prop) => ({ writes: [{ prop }] });
 const set = (prop, value) => ({
     writes: [{ prop, value }],
 });
-/** `prefix + n` → `prop={n}` for `n` from 1 to `max`, for a prop typed as a number. */
-function numbers(prefix, max, prop) {
+/**
+ * `prefix + n + suffix` → `prop={n}` for `n` from 1 to `max`, for a prop
+ * typed as a number.
+ */
+function numbers(prefix, max, prop, suffix = '') {
     return Object.fromEntries(Array.from({ length: max }, (_, i) => String(i + 1)).map(value => [
-        `${prefix}${value}`,
+        `${prefix}${value}${suffix}`,
         { writes: [{ prop, value, numeric: true }] },
     ]));
 }
@@ -771,6 +774,55 @@ export const ROOTS = {
         ],
         passThrough: ['disabled', 'readOnly', 'rows', 'ref'],
     },
+    // `SelectBase` renders `.select` and the `<select>` inside it together, and
+    // gives the `<select>` every attribute it is given.
+    select: {
+        ...BASE,
+        target: 'SelectBase',
+        tag: 'div',
+        textColor: null,
+        bgColor: 'backgroundColor',
+        modifiers: {
+            ...tokens('is-', ['small', 'medium', 'large'], 'size'),
+            ...flags({
+                'is-rounded': 'isRounded',
+                'is-loading': 'isLoading',
+                'is-active': 'isActive',
+                'is-fullwidth': 'isFullwidth',
+                'is-multiple': 'multiple',
+            }),
+        },
+        omits: Object.fromEntries(COMPONENT_COLORS.map(color => [
+            `is-${color}`,
+            '`color` renders `has-text-<color>` on the select as well',
+        ])),
+        absorbs: {
+            tag: 'select',
+            attributesOn: 'child',
+            modifiers: flags({
+                'is-hovered': 'isHovered',
+                'is-focused': 'isFocused',
+            }),
+            pairs: { multiple: 'is-multiple' },
+            renames: { size: { to: 'multipleSize', beside: 'multiple' } },
+        },
+        numberAttrs: ['multipleSize'],
+        adoptsIdFrom: ['Field'],
+        ownProps: [
+            'color',
+            'size',
+            'isRounded',
+            'isLoading',
+            'isActive',
+            'isHovered',
+            'isFocused',
+            'isFullwidth',
+            'isFullWidth',
+            'multiple',
+            'multipleSize',
+        ],
+        passThrough: ['disabled', 'ref'],
+    },
     footer: {
         ...BASE,
         target: 'Footer',
@@ -1085,14 +1137,29 @@ export const ROOTS = {
         },
         ownProps: ['size', 'isSpaced', 'as', 'hasSkeleton', 'textColor', 'bgColor'],
     },
+    // `Breadcrumb` renders the bare `<ul>` inside it, and its `aria-label`
+    // comes before the attributes it is given, which replace it.
+    breadcrumb: {
+        ...BASE,
+        target: 'Breadcrumb',
+        tag: 'nav',
+        // Breadcrumb types no color prop at all.
+        textColor: null,
+        bgColor: null,
+        modifiers: {
+            ...tokens('is-', ['centered', 'right'], 'alignment'),
+            ...tokens('has-', ['arrow', 'bullet', 'dot', 'succeeds'], 'separator', '-separator'),
+            ...tokens('is-', ['small', 'medium', 'large'], 'size'),
+        },
+        defaults: { 'aria-label': 'breadcrumbs' },
+        absorbs: { tag: 'ul', attributesOn: 'element' },
+        ownProps: ['alignment', 'separator', 'size'],
+    },
     // ---- Families bestax has but that do not map element by element yet ------
-    breadcrumb: todo('Breadcrumb', 'bestax `Breadcrumb` renders the `<ul>` itself and adds an `aria-label`'),
-    'fixed-grid': todo('Grid', '`Grid isFixed` renders the `.fixed-grid` wrapper itself, from `fixedCols`; replace the wrapper and its `.grid` with one `Grid`, by hand'),
     checkbox: todo('Checkbox', "bestax `Checkbox` renders its own styled markup, not Bulma's"),
     checkboxes: todo('Checkboxes', 'bestax `Checkboxes` renders its own `.field` and `.control` wrappers'),
     radio: todo('Radio', "bestax `Radio` renders its own styled markup, not Bulma's"),
     radios: todo('Radios', 'bestax `Radios` renders its own `.field` and `.control` wrappers'),
-    select: todo('Select', 'bestax `Select` renders the `.select` wrapper and the `<select>` together'),
     file: todo('File', 'bestax `File` renders the whole `.file-label` tree itself'),
     'file-label': part(),
     'file-input': part(),
@@ -1138,9 +1205,28 @@ export const ROOTS = {
     'panel-icon': part(),
     'panel-list': part(),
     tabs: todo('Tabs', "bestax `Tabs` renders each tab's `<li>` and `<a>` together, with tab roles"),
-    'table-container': todo('Table', 'bestax renders `.table-container` from `Table isResponsive`'),
     'skeleton-block': todo('Skeleton', 'bestax `Skeleton` renders its own markup'),
     'skeleton-lines': todo('Skeleton', 'bestax `Skeleton` renders its own markup'),
+    // ---- Wrappers a component renders from a prop ---------------------------------
+    // Each renders the wrapper with its own class and nothing else, so the
+    // element folds only when it carries no attribute and no other class.
+    'table-container': {
+        status: 'fold',
+        target: 'Table',
+        tag: 'div',
+        folds: [{ prop: 'isResponsive' }],
+    },
+    'fixed-grid': {
+        status: 'fold',
+        target: 'Grid',
+        tag: 'div',
+        folds: [{ prop: 'isFixed' }],
+        modifiers: {
+            ...numbers('has-', 12, 'fixedCols', '-cols'),
+            ...Object.assign({}, ...SIZE_VIEWPORTS.map(viewport => numbers('has-', 12, `fixedCols${viewportSuffix(viewport)}`, `-cols-${viewport}`))),
+            'has-auto-count': set('fixedCols', 'auto'),
+        },
+    },
     // ---- Valid Bulma, nothing to convert to --------------------------------------
     // The other sources emit these on purpose where bestax has no component.
     help: plain('bestax renders `.help` only inside its form controls'),
@@ -1236,6 +1322,7 @@ export const FORWARDS_REF = [
     'Control',
     'InputBase',
     'TextAreaBase',
+    'SelectBase',
 ];
 /**
  * Plain tags bestax wraps, for an element with helper classes and no root
@@ -1387,8 +1474,8 @@ export const PASSTHROUGH = [
         match: /^(?:is-(?:col|row)-.+|is-(?:column|row)-gap-\d+|is-gap-\d+|is-auto-fill)$/,
     },
     {
-        why: 'a `.fixed-grid` column count, which stays with its `.fixed-grid` (a family this source leaves as markup)',
-        match: /^has-\d+-cols(?:-.+)?$/,
+        why: 'a `.fixed-grid` column count, which converts only on its own `.fixed-grid`',
+        match: /^(?:has-\d+-cols(?:-.+)?|has-auto-count)$/,
     },
     {
         why: 'an `.image` modifier; `.image` stays as markup',
@@ -1398,9 +1485,17 @@ export const PASSTHROUGH = [
         why: 'a Bulma helper with no bestax prop',
         match: /^(?:is-display-.+|is-visibility-.+|is-overflow-.+|is-position-.+|is-float-.+|is-clear-.+|has-radius-.+|has-text-weight-extrabold|is-align-content-(?:baseline|start|end)|is-align-items-self-(?:start|end)|is-offset-0(?:-[a-z]+)?)$/,
     },
+    {
+        why: 'a `.breadcrumb` separator, which converts only on its own `.breadcrumb`',
+        match: /^has-[a-z]+-separator$/,
+    },
+    {
+        why: "`.select`'s `is-multiple`, which converts only on its own `.select`, around a `<select multiple>`",
+        match: /^is-multiple$/,
+    },
     {
         why: 'a modifier of markup this source leaves alone, or one bestax has no prop for',
-        match: /^(?:has-addons-.+|has-[a-z]+-separator|has-dropdown(?:-up)?|has-fixed-size|has-icons-(?:left|right)|has-name|has-(?:spaced-)?navbar-fixed-(?:top|bottom)(?:-desktop)?|has-shadow|has-auto-count|is-arrowless|is-boxed|is-center|is-current|is-delete|is-disabled|is-empty|is-expanded|is-fixed-(?:top|bottom)(?:-desktop)?|is-flexible|is-grouped(?:-.+)?|is-halfheight|is-horizontal|is-left|is-(?:lower|upper)-(?:alpha|roman)|is-multiple|is-responsive|is-selected|is-tab|is-toggle(?:-rounded)?|is-transparent|is-underlined|is-up|is-wrapped)$/,
+        match: /^(?:has-addons-.+|has-dropdown(?:-up)?|has-fixed-size|has-icons-(?:left|right)|has-name|has-(?:spaced-)?navbar-fixed-(?:top|bottom)(?:-desktop)?|has-shadow|is-arrowless|is-boxed|is-center|is-current|is-delete|is-disabled|is-empty|is-expanded|is-fixed-(?:top|bottom)(?:-desktop)?|is-flexible|is-grouped(?:-.+)?|is-halfheight|is-horizontal|is-left|is-(?:lower|upper)-(?:alpha|roman)|is-responsive|is-selected|is-tab|is-toggle(?:-rounded)?|is-transparent|is-underlined|is-up|is-wrapped)$/,
     },
 ];
 /**

package/dist/sources/bulma-classes/plan.d.ts

@@ -28,6 +28,16 @@ export interface ElementFacts {
      * counts: one in an expression may not render.
      */
     childTargets?: readonly string[];
+    /**
+     * What the element's only child converts to, when the element holds one
+     * element and nothing else (not even whitespace React would render).
+     */
+    soleChildTarget?: string;
+    /**
+     * That only child as written, when it is a plain HTML element: what an
+     * entry that `absorbs` it reads.
+     */
+    soleChild?: ChildFacts;
     /** The bestax components already in the file inside this element. */
     bestaxInside?: readonly string[];
     /** The bestax components already in the file around this element. */
@@ -44,6 +54,20 @@ export interface ElementFacts {
      */
     onlyChildOf?: string;
 }
+export interface ChildFacts {
+    tag: string;
+    /**
+     * Its static classes, or null when its `className` is computed. Left out
+     * when it has no `className` at all: an empty one still renders `class=""`.
+     */
+    tokens?: readonly string[] | null;
+    /**
+     * Its attributes but `className`, read as `ElementFacts.attributes` is,
+     * except that a number literal (`size={3}`) is that number.
+     */
+    attributes: ReadonlyMap<string, string | number | true | null>;
+    hasSpread: boolean;
+}
 export interface Todo {
     rule: string;
     message: string;
@@ -62,9 +86,31 @@ export interface Conversion {
      * a number (`minCol={4}`), because the target types them as numbers.
      */
     numbers: string[];
+    /**
+     * The element's only child, which the target renders itself: the target is
+     * written in the child's place, with the element's props and attributes
+     * first, then the child's, and the element goes.
+     */
+    absorbs?: {
+        /** What the child's classes become, in place of its `className`. */
+        props: Array<[name: string, value: string | true]>;
+        /** Child attributes the target reads under another name. */
+        renames: Array<[from: string, to: string]>;
+        /** Child attributes a prop above renders instead. */
+        drop: string[];
+    };
 }
 export interface Plan {
     conversion: Conversion | null;
+    /**
+     * The element is a wrapper its only child's component renders from these
+     * props: they join that child's conversion, and the element goes.
+     */
+    fold?: {
+        target: string;
+        props: Array<[name: string, value: string | true]>;
+        numbers: string[];
+    };
     todos: Todo[];
 }
 export declare function plan(facts: ElementFacts): Plan;

package/dist/sources/bulma-classes/plan.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"plan.d.ts","sourceRoot":"","sources":["../../../src/sources/bulma-classes/plan.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAiBH,MAAM,WAAW,YAAY;IAC3B,GAAG,EAAE,MAAM,CAAC;IACZ,2DAA2D;IAC3D,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC;IAC1B;;;OAGG;IACH,UAAU,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI,CAAC,CAAC;IACtD,SAAS,EAAE,OAAO,CAAC;IACnB,MAAM,EAAE,OAAO,CAAC;IAChB,4EAA4E;IAC5E,WAAW,EAAE,OAAO,CAAC;IACrB;;;;OAIG;IACH,YAAY,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACjC,qEAAqE;IACrE,YAAY,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACjC,qEAAqE;IACrE,YAAY,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACjC;;;OAGG;IACH,gBAAgB,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACrC;;;;OAIG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,IAAI;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,UAAU;IACzB,0CAA0C;IAC1C,MAAM,EAAE,MAAM,CAAC;IACf,6DAA6D;IAC7D,KAAK,EAAE,KAAK,CAAC,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC,CAAC,CAAC;IACnD,4DAA4D;IAC5D,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,mEAAmE;IACnE,IAAI,EAAE,MAAM,EAAE,CAAC;IACf;;;OAGG;IACH,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB;AAED,MAAM,WAAW,IAAI;IACnB,UAAU,EAAE,UAAU,GAAG,IAAI,CAAC;IAC9B,KAAK,EAAE,IAAI,EAAE,CAAC;CACf;AA+BD,wBAAgB,IAAI,CAAC,KAAK,EAAE,YAAY,GAAG,IAAI,CA+R9C"}
+{"version":3,"file":"plan.d.ts","sourceRoot":"","sources":["../../../src/sources/bulma-classes/plan.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAiBH,MAAM,WAAW,YAAY;IAC3B,GAAG,EAAE,MAAM,CAAC;IACZ,2DAA2D;IAC3D,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC;IAC1B;;;OAGG;IACH,UAAU,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI,CAAC,CAAC;IACtD,SAAS,EAAE,OAAO,CAAC;IACnB,MAAM,EAAE,OAAO,CAAC;IAChB,4EAA4E;IAC5E,WAAW,EAAE,OAAO,CAAC;IACrB;;;;OAIG;IACH,YAAY,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACjC;;;OAGG;IACH,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB;;;OAGG;IACH,SAAS,CAAC,EAAE,UAAU,CAAC;IACvB,qEAAqE;IACrE,YAAY,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACjC,qEAAqE;IACrE,YAAY,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACjC;;;OAGG;IACH,gBAAgB,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACrC;;;;OAIG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,UAAU;IACzB,GAAG,EAAE,MAAM,CAAC;IACZ;;;OAGG;IACH,MAAM,CAAC,EAAE,SAAS,MAAM,EAAE,GAAG,IAAI,CAAC;IAClC;;;OAGG;IACH,UAAU,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,GAAG,IAAI,CAAC,CAAC;IAC/D,SAAS,EAAE,OAAO,CAAC;CACpB;AAED,MAAM,WAAW,IAAI;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,UAAU;IACzB,0CAA0C;IAC1C,MAAM,EAAE,MAAM,CAAC;IACf,6DAA6D;IAC7D,KAAK,EAAE,KAAK,CAAC,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC,CAAC,CAAC;IACnD,4DAA4D;IAC5D,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,mEAAmE;IACnE,IAAI,EAAE,MAAM,EAAE,CAAC;IACf;;;OAGG;IACH,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB;;;;OAIG;IACH,OAAO,CAAC,EAAE;QACR,oEAAoE;QACpE,KAAK,EAAE,KAAK,CAAC,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC,CAAC,CAAC;QACnD,4DAA4D;QAC5D,OAAO,EAAE,KAAK,CAAC,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,CAAC,CAAC,CAAC;QAC3C,qDAAqD;QACrD,IAAI,EAAE,MAAM,EAAE,CAAC;KAChB,CAAC;CACH;AAED,MAAM,WAAW,IAAI;IACnB,UAAU,EAAE,UAAU,GAAG,IAAI,CAAC;IAC9B;;;OAGG;IACH,IAAI,CAAC,EAAE;QACL,MAAM,EAAE,MAAM,CAAC;QACf,KAAK,EAAE,KAAK,CAAC,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC,CAAC,CAAC;QACnD,OAAO,EAAE,MAAM,EAAE,CAAC;KACnB,CAAC;IACF,KAAK,EAAE,IAAI,EAAE,CAAC;CACf;AA+BD,wBAAgB,IAAI,CAAC,KAAK,EAAE,YAAY,GAAG,IAAI,CA0S9C"}

package/dist/sources/bulma-classes/plan.js

@@ -61,6 +61,9 @@ export function plan(facts) {
         });
         return { conversion: null, todos };
     }
+    const wrapper = tokens.find(token => rootFor(token)?.status === 'fold');
+    if (wrapper)
+        return planFold(facts, wrapper, todos);
     const root = tokens
         .filter(token => rootFor(token)?.status === 'mapped')
         .sort((a, b) => precedence(a) - precedence(b))[0];
@@ -93,21 +96,34 @@ export function plan(facts) {
     if (facts.onlyChildOf) {
         return refuse('only-child', target, `this element is the only child of \`<${facts.onlyChildOf}>\`, which may hand it props or a ref with \`cloneElement\` (next/link's legacy behavior, a tooltip, a Radix \`asChild\` trigger) that bestax \`${target}\` would not take the same way; convert it by hand if \`<${facts.onlyChildOf}>\` only renders its children`);
     }
-    if (facts.attributes.has('dangerouslySetInnerHTML')) {
+    // The attributes the target is given: the element's, or its only child's
+    // when the target renders that child itself and puts them there.
+    let attributes = facts.attributes;
+    let absorbed;
+    if (entry.absorbs) {
+        const outcome = absorb(facts, root, entry, target, refuse);
+        if ('todos' in outcome)
+            return outcome;
+        ({ attributes, absorbed } = outcome);
+    }
+    const renamed = new Set(absorbed?.renames.map(([, to]) => to));
+    if (attributes.has('dangerouslySetInnerHTML')) {
         return refuse('attr', 'dangerouslySetInnerHTML', `\`dangerouslySetInnerHTML\` sets the element's content directly, and some bestax components render content of their own beside \`children\`, which React rejects; keep this element as markup`);
     }
-    for (const name of facts.attributes.keys()) {
+    for (const name of attributes.keys()) {
+        if (renamed.has(name))
+            continue;
         const readAsProp = entry.ownProps?.includes(name) || HELPER_PROPS.has(name);
         if (readAsProp && !entry.passThrough?.includes(name)) {
             return refuse('attr', name, `\`${name}\` is also a bestax \`${target}\` prop, which would read it differently; rename or drop the attribute, then re-run`);
         }
     }
-    const missing = Object.entries(entry.defaults ?? {}).filter(([name]) => !facts.attributes.has(name));
+    const missing = Object.entries(entry.defaults ?? {}).filter(([name]) => !attributes.has(name));
     const drop = [];
     for (const name of entry.untypedAttrs ?? []) {
-        if (!facts.attributes.has(name))
+        if (!attributes.has(name))
             continue;
-        if (entry.defaults?.[name] === facts.attributes.get(name)) {
+        if (entry.defaults?.[name] === attributes.get(name)) {
             drop.push(name);
             continue;
         }
@@ -115,7 +131,7 @@ export function plan(facts) {
     }
     const numbers = [];
     for (const name of entry.numberAttrs ?? []) {
-        const value = facts.attributes.get(name);
+        const value = attributes.get(name);
         if (typeof value !== 'string')
             continue;
         // Only a string that is already the number's own spelling: `040`, `1.50`
@@ -131,7 +147,7 @@ export function plan(facts) {
     if (entry.providesContext && facts.bestaxInside?.length) {
         return refuse('context', target, `bestax \`${target}\` tells the bestax form controls inside it to skip wrappers of their own, and this element already holds \`${facts.bestaxInside[0]}\`, which could render differently inside it; keep this element as markup, or convert it and check that component by hand`);
     }
-    if (entry.adoptsIdFrom && !facts.attributes.has('id')) {
+    if (entry.adoptsIdFrom && !attributes.has('id')) {
         // Context follows the render tree, not the file: a component of the app
         // around the element can render a labelled `Field` around it just as well.
         const around = facts.bestaxAround?.find(name => entry.adoptsIdFrom.includes(name)) ??
@@ -145,18 +161,14 @@ export function plan(facts) {
         (!wraps.when || tokens.includes(wraps.when)) &&
         (facts.hasChildren || wraps.whenEmpty) &&
         !facts.childTargets?.some(child => wraps.unless.includes(child))) {
-        const parts = wraps.unless.map(part => `\`${part}\``);
-        const list = parts.length > 1
-            ? `${parts.slice(0, -1).join(', ')} or ${parts[parts.length - 1]}`
-            : parts[0];
-        return refuse('children', target, `bestax \`${target}\` renders its children inside a \`.${wraps.in}\` of its own unless one of them is a ${list}, so this element stays markup`);
+        return refuse('children', target, `bestax \`${target}\` renders its children inside a \`.${wraps.in}\` of its own unless one of them is a ${orList(wraps.unless)}, so this element stays markup`);
     }
     if (missing.length > 0) {
         const list = missing.map(([name, value]) => `\`${name}="${value}"\``);
         return refuse('defaults', target, `bestax \`${target}\` renders ${list.join(' and ')} when the element does not set ${missing.length === 1 ? 'it' : 'them'}; add ${missing.length === 1 ? 'it' : 'them'} here if that is what you want, then re-run`);
     }
     for (const [name, tags] of Object.entries(entry.dropsAttr ?? {})) {
-        if (facts.attributes.has(name) && inTagSet(tags, tag)) {
+        if (attributes.has(name) && inTagSet(tags, tag)) {
             // Bulma greys out `.button[disabled]` on any tag, so there it is not
             // inert: dropping it changes how the element looks.
             const visible = name === 'disabled';
@@ -253,7 +265,163 @@ export function plan(facts) {
             className: rest.length > 0 ? rest.join(' ') : null,
             drop,
             numbers,
+            ...(absorbed ? { absorbs: absorbed } : {}),
         },
         todos,
     };
 }
+/** `a`, `a or b`, `a, b or c`, each in backticks. */
+function orList(names) {
+    const quoted = names.map(name => `\`${name}\``);
+    return quoted.length > 1
+        ? `${quoted.slice(0, -1).join(', ')} or ${quoted[quoted.length - 1]}`
+        : quoted[0];
+}
+/**
+ * The only child an entry's target renders itself (`.select`'s `<select>`):
+ * what its classes become, and the attributes the target is given. It
+ * converts with the element only when the target would render it exactly
+ * as written.
+ */
+function absorb(facts, root, entry, target, refuse) {
+    const spec = entry.absorbs;
+    const child = facts.soleChild;
+    const itself = `bestax \`${target}\` renders the <${spec.tag}> inside \`.${root}\` itself`;
+    if (child?.tag !== spec.tag) {
+        return refuse('children', target, `${itself}, so this element converts only around a single <${spec.tag}>, with nothing else beside it`);
+    }
+    if (child.hasSpread) {
+        return refuse('spread', target, `the <${spec.tag}> inside spreads props, which bestax \`${target}\` may read differently than the <${spec.tag}> did; convert the two to \`${target}\` by hand`);
+    }
+    if (child.tokens === null) {
+        return refuse('dynamic-class', target, `the <${spec.tag}> inside has a computed \`className\`, and the codemod converts static class strings only; convert the two to bestax \`${target}\` by hand, turning each condition into its prop`);
+    }
+    if (child.tokens?.length === 0) {
+        return refuse('attr', 'className', `the <${spec.tag}> inside has an empty \`className\`, which renders \`class=""\`, and bestax \`${target}\` renders it with no class attribute; drop the empty \`className\`, then re-run`);
+    }
+    const modifiers = spec.modifiers ?? {};
+    const props = [];
+    for (const token of child.tokens ?? []) {
+        const modifier = Object.hasOwn(modifiers, token)
+            ? modifiers[token]
+            : undefined;
+        if (!modifier) {
+            const allowed = Object.keys(modifiers);
+            return refuse('attr', 'className', `${itself}, with no class on it${allowed.length > 0 ? ` but ${orList(allowed)}` : ''}, so its \`${token}\` would be lost; keep this element as markup`);
+        }
+        for (const write of modifier.writes) {
+            props.push([write.prop, write.value ?? true]);
+        }
+    }
+    if (spec.attributesOn === 'element') {
+        const name = [...child.attributes.keys()][0];
+        if (name !== undefined) {
+            return refuse('attr', name, `${itself}, with no attributes, so its \`${name}\` would be lost; keep this element as markup`);
+        }
+        return {
+            attributes: facts.attributes,
+            absorbed: { props, renames: [], drop: [] },
+        };
+    }
+    // The target puts what it is given on the child, so the element can carry
+    // nothing but its `key`, which stays with the component in its place.
+    const own = [...facts.attributes.keys()].find(name => name !== 'key');
+    if (own !== undefined) {
+        return refuse('attr', own, `bestax \`${target}\` puts the attributes it is given on the <${spec.tag}> inside \`.${root}\`, so this element's \`${own}\` would move there; move it onto the <${spec.tag}> if that is what you want, then re-run`);
+    }
+    if (child.attributes.has('key')) {
+        return refuse('attr', 'key', `the <${spec.tag}> inside has a \`key\`, which would move up to bestax \`${target}\` in place of this element's; keep this element as markup`);
+    }
+    const drop = [];
+    for (const [name, token] of Object.entries(spec.pairs ?? {})) {
+        const withClass = facts.tokens.includes(token);
+        if (withClass && child.attributes.get(name) === true) {
+            drop.push(name);
+        }
+        else if (withClass || child.attributes.has(name)) {
+            return refuse('attr', name, `bestax \`${target}\` renders \`${name}\` on the <${spec.tag}> and \`.${token}\` on this element together, from one prop, so the two convert only as a pair, with \`${name}\` written bare; keep this element as markup`);
+        }
+    }
+    // A number literal is carried over as written, like any other expression.
+    const given = (value) => typeof value === 'number' ? null : value;
+    const attributes = new Map();
+    const renames = [];
+    for (const [name, value] of child.attributes) {
+        if (drop.includes(name))
+            continue;
+        const rename = spec.renames && Object.hasOwn(spec.renames, name)
+            ? spec.renames[name]
+            : undefined;
+        if (!rename) {
+            attributes.set(name, given(value));
+            continue;
+        }
+        // `SelectBase` writes `multipleSize` back as `size` only when it holds a
+        // number, and an expression may not: only a literal converts. A string
+        // one is held to a number's spelling below, with the target's numbers.
+        if (!drop.includes(rename.beside) ||
+            (typeof value !== 'number' && typeof value !== 'string')) {
+            return refuse('attr', name, `bestax \`${target}\` writes the <${spec.tag}>'s \`${name}\` only beside \`${rename.beside}\`, and only from a number in \`${rename.to}\`, so it converts only as a number written out (\`${name}={4}\`); keep this element as markup, or convert it by hand if \`${name}\` is always a number`);
+        }
+        if (child.attributes.has(rename.to)) {
+            return refuse('attr', rename.to, `\`${rename.to}\` is also a bestax \`${target}\` prop, which would read it differently; rename or drop the attribute, then re-run`);
+        }
+        renames.push([name, rename.to]);
+        attributes.set(rename.to, given(value));
+    }
+    return { attributes, absorbed: { props, renames, drop } };
+}
+/**
+ * A wrapper the component inside it renders from a prop (`.table-container`
+ * from `Table isResponsive`). It folds into that component only when it is
+ * exactly what the component renders for it: its own tag and class, its own
+ * modifiers, no attribute, and one child that becomes the component.
+ */
+function planFold(facts, wrapper, todos) {
+    const entry = rootFor(wrapper);
+    const target = entry.target;
+    if (!target)
+        return { conversion: null, todos };
+    const folds = entry.folds ?? [];
+    const renders = `\`${target} ${folds.map(write => write.prop).join(' ')}\``;
+    const refuse = (kind, token, message) => ({
+        conversion: null,
+        todos: [...todos, { rule: ruleId(kind, token), message }],
+    });
+    if (facts.tag !== entry.tag) {
+        return refuse('tag', target, `bestax ${renders} renders \`.${wrapper}\` on a <${entry.tag}>, not a <${facts.tag}>; keep the markup, or change the tag and re-run`);
+    }
+    if (facts.hasSpread) {
+        return refuse('spread', target, `this element spreads props, and bestax ${renders} renders \`.${wrapper}\` with none of its own; keep it as markup`);
+    }
+    if (facts.onlyChildOf) {
+        return refuse('only-child', target, `this element is the only child of \`<${facts.onlyChildOf}>\`, which may hand it props or a ref with \`cloneElement\`, and folding it would move those onto the \`${target}\` inside; convert it by hand if \`<${facts.onlyChildOf}>\` only renders its children`);
+    }
+    const attribute = [...facts.attributes.keys()][0];
+    if (attribute) {
+        return refuse('attr', attribute, `bestax ${renders} renders \`.${wrapper}\` with no attributes, so this element's \`${attribute}\` would be lost; keep it as markup`);
+    }
+    const props = folds.map(write => [
+        write.prop,
+        write.value ?? true,
+    ]);
+    const numbers = [];
+    for (const token of facts.tokens) {
+        if (token === wrapper)
+            continue;
+        const modifier = modifierFor(entry, token);
+        const taken = modifier?.writes.some(write => props.some(([prop]) => prop === write.prop));
+        if (!modifier || taken) {
+            return refuse('attr', 'className', `bestax ${renders} renders \`.${wrapper}\` with no class but its own and one of each of its modifiers, so \`${token}\` would be lost; keep this element as markup`);
+        }
+        for (const write of modifier.writes) {
+            props.push([write.prop, write.value ?? true]);
+            if (write.numeric)
+                numbers.push(write.prop);
+        }
+    }
+    if (facts.soleChildTarget !== target) {
+        return refuse('children', target, `bestax ${renders} renders \`.${wrapper}\` itself, so this element converts only around a single element that becomes a \`${target}\`, with nothing else beside it`);
+    }
+    return { conversion: null, fold: { target, props, numbers }, todos };
+}

package/dist/sources/bulma-classes/rules.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rules.d.ts","sourceRoot":"","sources":["../../../src/sources/bulma-classes/rules.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAUH,eAAO,MAAM,KAAK,EAAE,WAAW,CAAC,MAAM,CAapC,CAAC;AAuBH,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAEnD;AAED,wBAAgB,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAK1D"}
+{"version":3,"file":"rules.d.ts","sourceRoot":"","sources":["../../../src/sources/bulma-classes/rules.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAUH,eAAO,MAAM,KAAK,EAAE,WAAW,CAAC,MAAM,CAapC,CAAC;AAyBH,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAEnD;AAED,wBAAgB,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAK1D"}

package/dist/sources/bulma-classes/rules.js

@@ -44,6 +44,8 @@ const VOCABULARY = new Set([
     'dangerouslySetInnerHTML',
     // Refused where the target drops its own class for one it is given.
     'className',
+    // Refused on the child a target renders itself.
+    'key',
 ]);
 export function inVocabulary(token) {
     return VOCABULARY.has(token);

package/dist/sources/bulma-classes/transform.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"transform.d.ts","sourceRoot":"","sources":["../../../src/sources/bulma-classes/transform.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,KAAK,EAAE,GAAG,EAAW,QAAQ,EAAE,MAAM,aAAa,CAAC;AAE1D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAmSvD,MAAM,CAAC,OAAO,UAAU,SAAS,CAC/B,QAAQ,EAAE,QAAQ,EAClB,GAAG,EAAE,GAAG,EACR,OAAO,GAAE,gBAAqB,GAC7B,MAAM,GAAG,SAAS,CA8VpB"}
+{"version":3,"file":"transform.d.ts","sourceRoot":"","sources":["../../../src/sources/bulma-classes/transform.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,KAAK,EAAE,GAAG,EAAW,QAAQ,EAAE,MAAM,aAAa,CAAC;AAE1D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AA8YvD,MAAM,CAAC,OAAO,UAAU,SAAS,CAC/B,QAAQ,EAAE,QAAQ,EAClB,GAAG,EAAE,GAAG,EACR,OAAO,GAAE,gBAAqB,GAC7B,MAAM,GAAG,SAAS,CAwZpB"}

package/dist/sources/bulma-classes/transform.js

@@ -17,7 +17,7 @@
  *   5. write the bestax import, after the file's last import
  */
 import path from 'node:path';
-import { addTodo, findAttr, forgetJsxParens, jsxNameParts, literalValueOf, makeAttr, renameElement, reprintDirectives, } from '../_shared/jsx-utils.js';
+import { addTodo, findAttr, forgetJsxParens, jsxNameParts, literalValueOf, makeAttr, removeAttr, renameElement, reprintDirectives, } from '../_shared/jsx-utils.js';
 import { collectBoundNames, makeReserve, prefersTabs, resolvesToBinding, } from '../_shared/imports.js';
 import { rewriteStylesheetImports } from '../_shared/css-imports.js';
 import { BESTAX, buildBestaxImport, placeBestaxImport, seedBestaxImport, } from '../_shared/bestax-import.js';
@@ -47,6 +47,43 @@ const JSX_FACTORY = /^\s*\*?\s*@jsx\s+(\S+)/m;
 const HEADER_PRAGMA = /^[\s*]*(?:@ts-(?:no)?check|@flow|@noflow|eslint-disable(?!-)|@jsx|@jsxImportSource|@jsxRuntime|@license|@preserve)\b/;
 /** Directives that act on the line after them, so must stay above it. */
 const NEXT_LINE_DIRECTIVE = /^[\s*]*(?:eslint-disable-next-line|@ts-expect-error|@ts-ignore|prettier-ignore)\b/;
+/**
+ * A comment moved to sit after a JSX tag name. It has to be a block comment
+ * there: recast prints a line comment as `<// …`, which TypeScript reads as a
+ * closing tag.
+ */
+function afterTagName(comment) {
+    if (comment.type !== 'CommentLine') {
+        return { ...comment, leading: false, trailing: true };
+    }
+    return {
+        type: 'CommentBlock',
+        value: ` ${comment.value.trim().replace(/\*\//g, '*\\/')} `,
+        leading: false,
+        trailing: true,
+    };
+}
+/**
+ * Put `props`, then what stays in `className`, where an element's
+ * `className` was. A comment on the className goes with whatever takes its
+ * place: the first new attribute, else the next one along, else the tag name.
+ */
+function writeClassName(j, element, props, className) {
+    const attrs = element.openingElement.attributes;
+    const classAttr = findAttr(element, 'className');
+    const replacement = props.map(([name, value]) => makeAttr(j, name, value === true ? undefined : value));
+    if (className)
+        replacement.push(makeAttr(j, 'className', className));
+    if (classAttr.comments?.length) {
+        const name = element.openingElement.name;
+        const carrier = replacement[0] ?? attrs.find((attr) => attr !== classAttr) ?? name;
+        carrier.comments = [
+            ...(carrier.comments ?? []),
+            ...classAttr.comments.map((comment) => carrier === name ? afterTagName(comment) : comment),
+        ];
+    }
+    attrs.splice(attrs.indexOf(classAttr), 1, ...replacement);
+}
 /** A lowercase intrinsic tag: not a component, not a custom element. */
 const INTRINSIC = /^[a-z][a-z0-9]*$/;
 /** Subtrees whose tags are not HTML. */
@@ -126,6 +163,34 @@ function attributeName(attr) {
         ? `${attr.name.namespace.name}:${attr.name.name.name}`
         : attr.name.name;
 }
+/** An element's attributes but `className`, as the planner reads them. */
+function attributesBesides(element, classAttr, read) {
+    const attributes = new Map();
+    for (const attr of element.openingElement.attributes ?? []) {
+        if (attr.type !== 'JSXAttribute' || attr === classAttr)
+            continue;
+        attributes.set(attributeName(attr), read(attr));
+    }
+    return attributes;
+}
+/** A child's attribute as `ChildFacts` reads it: a number literal is that number. */
+function childAttributeValue(attr) {
+    const literal = literalValueOf(attr);
+    return literal.kind === 'number' ? literal.value : attributeValue(attr);
+}
+function hasSpread(element) {
+    return (element.openingElement.attributes ?? []).some((attr) => attr.type === 'JSXSpreadAttribute');
+}
+/** The comments inside an element's tags, on the tags and their names. */
+function tagComments(element) {
+    const { openingElement, closingElement } = element;
+    return [
+        openingElement,
+        openingElement.name,
+        closingElement,
+        closingElement?.name,
+    ].flatMap((node) => node?.comments ?? []);
+}
 /** Every comment in the file (recast hangs them on the nodes). */
 function commentsOf(root, j) {
     const comments = new Set();
@@ -229,6 +294,25 @@ function reachesReact(child) {
         return isContent(child);
     return /[^ \t\r\n]/.test(child.value) || !/[\r\n]/.test(child.value);
 }
+/** A plain HTML child as the planner reads it; nothing for a component. */
+function childFacts(child) {
+    const name = child.openingElement.name;
+    if (name.type !== 'JSXIdentifier' || !INTRINSIC.test(name.name)) {
+        return undefined;
+    }
+    const classAttr = findAttr(child, 'className');
+    const className = classAttr && staticClassName(classAttr);
+    return {
+        tag: name.name,
+        ...(classAttr && {
+            tokens: className === null
+                ? null
+                : [...new Set(className.split(/\s+/).filter(Boolean))],
+        }),
+        attributes: attributesBesides(child, classAttr, childAttributeValue),
+        hasSpread: hasSpread(child),
+    };
+}
 function insideForeignContent(elementPath) {
     let current = elementPath.parent;
     while (current) {
@@ -325,10 +409,21 @@ export default function transform(fileInfo, api, options = {}) {
         if (child.type !== 'JSXElement')
             return [];
         const target = planned.get(child)?.conversion?.target ??
+            planned.get(child)?.fold?.target ??
             // A direct child is looked up in the element's own scope, the child's.
             bestaxTarget(child, elementPath);
         return target ? [target] : [];
     });
+    /**
+     * The one element an element holds, when it holds nothing else: no text
+     * React renders, and no comment, which folding the element would drop.
+     */
+    const soleChild = (element) => {
+        const content = (element.children ?? []).filter((child) => child.type !== 'JSXText' || reachesReact(child));
+        return content.length === 1 && content[0].type === 'JSXElement'
+            ? content[0]
+            : undefined;
+    };
     // For each element, the bestax components already in the file inside it:
     // `Field` and `Control` change how bestax's form controls render.
     const bestaxInside = new Map();
@@ -381,35 +476,34 @@ export default function transform(fileInfo, api, options = {}) {
         const classAttr = findAttr(element, 'className');
         if (!classAttr)
             continue;
-        const attributes = new Map();
-        for (const attr of element.openingElement.attributes ?? []) {
-            if (attr.type !== 'JSXAttribute' || attr === classAttr)
-                continue;
-            attributes.set(attributeName(attr), attributeValue(attr));
-        }
+        const attributes = attributesBesides(element, classAttr, attributeValue);
         const className = staticClassName(classAttr);
         const surrounding = around(elementPath);
+        const sole = soleChild(element);
         const facts = {
             tag: name.name,
             tokens: className === null
                 ? classTokensOf(classAttr.value)
                 : [...new Set(className.split(/\s+/).filter(Boolean))],
             attributes,
-            hasSpread: (element.openingElement.attributes ?? []).some((attr) => attr.type === 'JSXSpreadAttribute'),
+            hasSpread: hasSpread(element),
             hasRef: attributes.has('ref'),
             hasChildren: (element.children ?? []).some(reachesReact),
             childTargets: childTargets(elementPath),
+            soleChildTarget: planned.get(sole)?.conversion?.target,
+            soleChild: sole && childFacts(sole),
             bestaxInside: bestaxInside.get(element) ?? [],
             bestaxAround: surrounding.bestax,
             componentsAround: surrounding.other,
             onlyChildOf: onlyChildOf(elementPath, bestaxLocals),
         };
         let result = plan(facts);
-        const converts = result.conversion !== null;
-        if (className === null && result.conversion) {
+        const converts = result.conversion !== null || result.fold !== undefined;
+        const becomes = result.conversion?.target ?? result.fold?.target;
+        if (className === null && becomes) {
             // The same element with a static className would convert; with a
             // computed one, only a person can turn each condition into its prop.
-            const target = result.conversion.target;
+            const target = becomes;
             result = {
                 conversion: null,
                 todos: [
@@ -421,8 +515,15 @@ export default function transform(fileInfo, api, options = {}) {
                 ],
             };
         }
+        if (result.fold) {
+            // The wrapper's props join its child's conversion, which has not been
+            // applied yet: conversions are applied after every element is planned.
+            const inner = planned.get(soleChild(element)).conversion;
+            inner.props.push(...result.fold.props);
+            inner.numbers.push(...result.fold.numbers);
+        }
         planned.set(element, result);
-        if (result.conversion || result.todos.length > 0) {
+        if (result.conversion || result.fold || result.todos.length > 0) {
             elements.unshift({ path: elementPath, plan: result, converts });
         }
     }
@@ -436,7 +537,7 @@ export default function transform(fileInfo, api, options = {}) {
         if (converting)
             addTodo(ctx, elements[0].path, rule, message);
         for (const element of elements) {
-            element.plan = { ...element.plan, conversion: null };
+            element.plan = { ...element.plan, conversion: null, fold: undefined };
         }
     };
     const runtime = fileJsxRuntime(root, j) ??
@@ -482,50 +583,89 @@ export default function transform(fileInfo, api, options = {}) {
         }
     }
     for (const { path: elementPath, plan: result } of [...elements].reverse()) {
+        if (result.fold) {
+            // The child inside has converted already (innermost first), with the
+            // wrapper's props on it; the wrapper itself goes, its comments with the
+            // child: one on the wrapper moves to the child, and one inside the
+            // wrapper's tags moves inside the child's opening tag.
+            const wrapper = elementPath.node;
+            const inner = soleChild(wrapper);
+            const inTags = [
+                ...tagComments(wrapper),
+                ...(wrapper.openingElement.attributes ?? []).flatMap((attr) => attr.comments ?? []),
+            ];
+            if (inTags.length) {
+                const name = inner.openingElement.name;
+                name.comments = [...(name.comments ?? []), ...inTags.map(afterTagName)];
+            }
+            if (wrapper.comments?.length) {
+                inner.comments = [...wrapper.comments, ...(inner.comments ?? [])];
+            }
+            elementPath.replace(inner);
+            ctx.dirty = true;
+            continue;
+        }
         const conversion = result.conversion;
         if (!conversion)
             continue;
         const element = elementPath.node;
+        // A target that renders the element's only child itself is written in
+        // that child's place, so the child's children stay where they are.
+        const child = conversion.absorbs ? soleChild(element) : undefined;
+        // The element's tags go, and so do the child's tag names: their comments
+        // move to the name that stays. The child's tags themselves stay, and
+        // keep their own.
+        const inTags = child
+            ? [
+                ...tagComments(element),
+                ...[child.openingElement.name, child.closingElement?.name].flatMap((node) => node?.comments ?? []),
+            ]
+            : [];
+        if (child) {
+            // Renamed before the drops below, which name each attribute as the
+            // component is given it.
+            const { renames, drop } = conversion.absorbs;
+            for (const name of drop)
+                removeAttr(child, findAttr(child, name));
+            for (const [from, to] of renames) {
+                findAttr(child, from).name = j.jsxIdentifier(to);
+            }
+        }
         const [head, ...rest] = conversion.target.split('.');
         renameElement(j, element, [ctx.reserve(head), ...rest].join('.'));
-        const attrs = element.openingElement.attributes;
         for (const name of conversion.drop) {
-            attrs.splice(attrs.indexOf(findAttr(element, name)), 1);
-        }
-        const classAttr = findAttr(element, 'className');
-        const replacement = conversion.props.map(([name, value]) => makeAttr(j, name, value === true ? undefined : value));
-        if (conversion.className) {
-            replacement.push(makeAttr(j, 'className', conversion.className));
+            const holder = findAttr(element, name) ? element : child;
+            removeAttr(holder, findAttr(holder, name));
         }
-        // A comment on the className goes with whatever takes its place: the
-        // first new attribute, else the next one along, else the tag name. After
-        // the name it has to be a block comment: recast prints a line comment
-        // there as `<// …`, which TypeScript reads as a closing tag.
-        if (classAttr.comments?.length) {
-            const name = element.openingElement.name;
-            const carrier = replacement[0] ?? attrs.find((attr) => attr !== classAttr) ?? name;
-            carrier.comments = [
-                ...(carrier.comments ?? []),
-                ...classAttr.comments.map((comment) => {
-                    if (carrier !== name)
-                        return comment;
-                    if (comment.type !== 'CommentLine') {
-                        return { ...comment, leading: false, trailing: true };
-                    }
-                    return {
-                        type: 'CommentBlock',
-                        value: ` ${comment.value.trim().replace(/\*\//g, '*\\/')} `,
-                        leading: false,
-                        trailing: true,
-                    };
-                }),
+        writeClassName(j, element, conversion.props, conversion.className);
+        let written = element;
+        if (child) {
+            child.openingElement.name = element.openingElement.name;
+            if (child.closingElement) {
+                child.closingElement.name = element.closingElement.name;
+            }
+            if (findAttr(child, 'className')) {
+                writeClassName(j, child, conversion.absorbs.props, null);
+            }
+            child.openingElement.attributes = [
+                ...(element.openingElement.attributes ?? []),
+                ...(child.openingElement.attributes ?? []),
             ];
+            // A comment on the element moves to the component in its place.
+            if (inTags.length) {
+                const name = child.openingElement.name;
+                name.comments = [...(name.comments ?? []), ...inTags.map(afterTagName)];
+            }
+            if (element.comments?.length) {
+                child.comments = [...element.comments, ...(child.comments ?? [])];
+            }
+            elementPath.replace(child);
+            written = child;
         }
-        attrs.splice(attrs.indexOf(classAttr), 1, ...replacement);
         // After the splice, so a prop the conversion wrote is found as well as
         // an attribute the element already had.
         for (const name of conversion.numbers) {
-            const attr = findAttr(element, name);
+            const attr = findAttr(written, name);
             attr.value = j.jsxExpressionContainer(j.numericLiteral(Number(attributeValue(attr))));
         }
         ctx.dirty = true;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bestax-migrate",
-  "version": "2.8.0",
+  "version": "2.10.0",
   "description": "Codemods for migrating existing React apps from other Bulma libraries to @allxsmith/bestax-bulma",
   "type": "module",
   "bin": {