bestax-migrate 0.0.1

package/dist/sources/react-bulma-components/props.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Prop-level conversion: applies a PropAction to a single attribute, plus the
+ * universal modifier-prop pass shared by every mapped component.
+ */
+import type { ASTPath } from 'jscodeshift';
+import type { PropAction } from '../../types.js';
+import { type TransformContext } from './jsx-utils.js';
+/** Apply one PropAction to `attr` on `element`. */
+export declare function applyPropAction(ctx: TransformContext, path: ASTPath<any>, element: any, attr: any, action: PropAction): void;
+/**
+ * Apply the universal RBC modifier-prop conversions to every attribute that
+ * was not already handled by the component's own prop map.
+ */
+export declare function applyUniversalProps(ctx: TransformContext, path: ASTPath<any>, element: any, handled: Set<string>): void;
+//# sourceMappingURL=props.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"props.d.ts","sourceRoot":"","sources":["../../../src/sources/react-bulma-components/props.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAC3C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAEjD,OAAO,EAQL,KAAK,gBAAgB,EACtB,MAAM,gBAAgB,CAAC;AA6BxB,mDAAmD;AACnD,wBAAgB,eAAe,CAC7B,GAAG,EAAE,gBAAgB,EACrB,IAAI,EAAE,OAAO,CAAC,GAAG,CAAC,EAClB,OAAO,EAAE,GAAG,EACZ,IAAI,EAAE,GAAG,EACT,MAAM,EAAE,UAAU,GACjB,IAAI,CA4HN;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CACjC,GAAG,EAAE,gBAAgB,EACrB,IAAI,EAAE,OAAO,CAAC,GAAG,CAAC,EAClB,OAAO,EAAE,GAAG,EACZ,OAAO,EAAE,GAAG,CAAC,MAAM,CAAC,GACnB,IAAI,CAQN"}

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

@@ -0,0 +1,124 @@
+/**
+ * Prop-level conversion: applies a PropAction to a single attribute, plus the
+ * universal modifier-prop pass shared by every mapped component.
+ */
+import { UNIVERSAL_PROPS } from './mapping.js';
+import { addAttr, addTodo, attributesOf, findAttr, literalValueOf, makeAttr, removeAttr, } from './jsx-utils.js';
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/**
+ * Add a converted attribute unless the target name is already present — two
+ * RBC props can map onto one bestax prop (e.g. `textTransform` + `italic`),
+ * and a silent duplicate would be invalid JSX.
+ */
+function addConverted(ctx, path, element, originalName, name, value) {
+    if (findAttr(element, name)) {
+        addTodo(ctx, path, `prop:${originalName}`, `\`${originalName}\` maps to \`${name}${value === undefined ? '' : `="${value}"`}\`, but \`${name}\` is already set on this element; reconcile by hand`);
+        return;
+    }
+    addAttr(element, makeAttr(ctx.j, name, value));
+}
+/** Apply one PropAction to `attr` on `element`. */
+export function applyPropAction(ctx, path, element, attr, action) {
+    const { j } = ctx;
+    const originalName = attr.name.name;
+    if (action.drop) {
+        removeAttr(element, attr);
+        ctx.dirty = true;
+        return;
+    }
+    if (action.todo) {
+        addTodo(ctx, path, `prop:${originalName}`, `\`${originalName}\` — ${action.todo}`);
+        return;
+    }
+    const literal = literalValueOf(attr);
+    if (action.valueTodo &&
+        literal.kind === 'string' &&
+        action.valueTodo[literal.value]) {
+        addTodo(ctx, path, `prop:${originalName}`, `\`${originalName}="${literal.value}"\` — ${action.valueTodo[literal.value]}`);
+        return;
+    }
+    if (action.valueToProp) {
+        if (literal.kind === 'string') {
+            const mapped = action.valueMap?.[literal.value];
+            if (mapped) {
+                removeAttr(element, attr);
+                for (const name of mapped.split(' ')) {
+                    addConverted(ctx, path, element, originalName, name, undefined);
+                }
+                ctx.dirty = true;
+            }
+            // Unmapped literal values are intentionally left untouched.
+        }
+        else {
+            addTodo(ctx, path, `prop:${originalName}`, `\`${originalName}\` has a dynamic value; map it to the matching bestax boolean prop by hand`);
+        }
+        return;
+    }
+    if (action.booleanToProp) {
+        const { name, value } = action.booleanToProp;
+        if (literal.kind === 'boolean' && literal.value === true) {
+            removeAttr(element, attr);
+            addConverted(ctx, path, element, originalName, name, value);
+            ctx.dirty = true;
+        }
+        else if (literal.kind === 'boolean' && literal.value === false) {
+            removeAttr(element, attr);
+            ctx.dirty = true;
+        }
+        else if (value === undefined) {
+            // Pure boolean rename — a dynamic expression can carry over.
+            attr.name = j.jsxIdentifier(name);
+            ctx.dirty = true;
+        }
+        else {
+            addTodo(ctx, path, `prop:${originalName}`, `\`${originalName}\` has a dynamic value; set \`${name}="${value}"\` conditionally by hand`);
+        }
+        return;
+    }
+    let renamedTo = originalName;
+    if (action.rename) {
+        attr.name = j.jsxIdentifier(action.rename);
+        renamedTo = action.rename;
+        ctx.dirty = true;
+    }
+    if (action.numberToString) {
+        if (literal.kind === 'number') {
+            attr.value = j.stringLiteral(String(literal.value));
+            ctx.dirty = true;
+        }
+        else if (literal.kind === 'expression') {
+            addTodo(ctx, path, `prop:${originalName}`, `\`${renamedTo}\` takes a string in bestax-bulma ('${originalName}={4}' → '${renamedTo}="4"'); convert the dynamic value`);
+        }
+        return;
+    }
+    if (action.valueMap) {
+        if (literal.kind === 'string') {
+            const mapped = action.valueMap[literal.value];
+            if (mapped && mapped !== literal.value) {
+                attr.value = j.stringLiteral(mapped);
+                ctx.dirty = true;
+            }
+        }
+        else if (literal.kind === 'expression') {
+            addTodo(ctx, path, `prop:${originalName}`, `\`${renamedTo}\` values differ in bestax-bulma (${Object.entries(action.valueMap)
+                .filter(([from, to]) => from !== to)
+                .map(([from, to]) => `'${from}'→'${to}'`)
+                .join(', ')}); convert the dynamic value`);
+        }
+    }
+}
+/**
+ * Apply the universal RBC modifier-prop conversions to every attribute that
+ * was not already handled by the component's own prop map.
+ */
+export function applyUniversalProps(ctx, path, element, handled) {
+    for (const attr of [...attributesOf(element)]) {
+        const name = attr.name.name;
+        if (handled.has(name))
+            continue;
+        const action = UNIVERSAL_PROPS[name];
+        if (!action)
+            continue;
+        applyPropAction(ctx, path, element, attr, action);
+    }
+}

package/dist/sources/react-bulma-components/responsive.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Flattens RBC's responsive breakpoint-object props into bestax-bulma's flat
+ * per-viewport props:
+ *
+ *   <Element mobile={{ display: 'flex', textSize: 4 }} />
+ *     → displayMobile="flex" textSizeMobile="4"
+ *   <Columns.Column tablet={{ size: 6, narrow: true }} />
+ *     → sizeTablet={6} isNarrowTablet
+ *
+ * touch / untilWidescreen / untilFullhd have no bestax equivalents and get a
+ * TODO. Non-object or dynamic values get a TODO.
+ */
+import type { ASTPath } from 'jscodeshift';
+import { type TransformContext } from './jsx-utils.js';
+export type ResponsiveKind = 'generic' | 'columns' | 'column';
+export declare function flattenResponsiveProps(ctx: TransformContext, path: ASTPath<any>, element: any, kind: ResponsiveKind): void;
+//# sourceMappingURL=responsive.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"responsive.d.ts","sourceRoot":"","sources":["../../../src/sources/react-bulma-components/responsive.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAE3C,OAAO,EAML,KAAK,gBAAgB,EACtB,MAAM,gBAAgB,CAAC;AAIxB,MAAM,MAAM,cAAc,GAAG,SAAS,GAAG,SAAS,GAAG,QAAQ,CAAC;AAkB9D,wBAAgB,sBAAsB,CACpC,GAAG,EAAE,gBAAgB,EACrB,IAAI,EAAE,OAAO,CAAC,GAAG,CAAC,EAClB,OAAO,EAAE,GAAG,EACZ,IAAI,EAAE,cAAc,GACnB,IAAI,CAkHN"}

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

@@ -0,0 +1,113 @@
+/**
+ * Flattens RBC's responsive breakpoint-object props into bestax-bulma's flat
+ * per-viewport props:
+ *
+ *   <Element mobile={{ display: 'flex', textSize: 4 }} />
+ *     → displayMobile="flex" textSizeMobile="4"
+ *   <Columns.Column tablet={{ size: 6, narrow: true }} />
+ *     → sizeTablet={6} isNarrowTablet
+ *
+ * touch / untilWidescreen / untilFullhd have no bestax equivalents and get a
+ * TODO. Non-object or dynamic values get a TODO.
+ */
+import { RESPONSIVE_BREAKPOINTS } from './mapping.js';
+import { addAttr, addTodo, attributesOf, makeAttr, removeAttr, } from './jsx-utils.js';
+const TEXT_ALIGN_MAP = {
+    center: 'centered',
+    justify: 'justified',
+    left: 'left',
+    right: 'right',
+};
+function literalOf(prop) {
+    const v = prop.value;
+    if (!v)
+        return undefined;
+    if (v.type === 'StringLiteral')
+        return v.value;
+    if (v.type === 'NumericLiteral')
+        return v.value;
+    if (v.type === 'BooleanLiteral')
+        return v.value;
+    return undefined;
+}
+export function flattenResponsiveProps(ctx, path, element, kind) {
+    const { j } = ctx;
+    for (const attr of [...attributesOf(element)]) {
+        const name = attr.name.name;
+        if (!(name in RESPONSIVE_BREAKPOINTS))
+            continue;
+        const suffix = RESPONSIVE_BREAKPOINTS[name];
+        if (suffix === null) {
+            addTodo(ctx, path, 'responsive', `no bestax-bulma helper variants for the \`${name}\` breakpoint; restyle with CSS or drop it`);
+            continue;
+        }
+        const value = attr.value;
+        const objectExpr = value?.type === 'JSXExpressionContainer' &&
+            value.expression?.type === 'ObjectExpression'
+            ? value.expression
+            : null;
+        if (!objectExpr) {
+            addTodo(ctx, path, 'responsive', `\`${name}\` must be an inline object literal to flatten to bestax per-viewport props; convert it by hand`);
+            continue;
+        }
+        const remaining = [];
+        for (const prop of objectExpr.properties) {
+            if (prop.type !== 'ObjectProperty' && prop.type !== 'Property') {
+                remaining.push(prop);
+                continue;
+            }
+            const key = prop.key?.name ?? prop.key?.value;
+            const literal = literalOf(prop);
+            if (key === 'display' && typeof literal === 'string') {
+                if (literal === 'hidden') {
+                    addAttr(element, makeAttr(j, `visibility${suffix}`, 'hidden'));
+                }
+                else if (literal === 'relative') {
+                    remaining.push(prop);
+                    addTodo(ctx, path, 'responsive', `\`${name}.display: 'relative'\` has no bestax per-viewport equivalent`);
+                    continue;
+                }
+                else {
+                    addAttr(element, makeAttr(j, `display${suffix}`, literal));
+                }
+            }
+            else if (key === 'textSize' && literal !== undefined) {
+                addAttr(element, makeAttr(j, `textSize${suffix}`, String(literal)));
+            }
+            else if (key === 'textAlign' && typeof literal === 'string') {
+                addAttr(element, makeAttr(j, `textAlign${suffix}`, TEXT_ALIGN_MAP[literal] ?? literal));
+            }
+            else if (key === 'invisible' && literal === true) {
+                addAttr(element, makeAttr(j, `visibility${suffix}`, 'invisible'));
+            }
+            else if (key === 'only') {
+                remaining.push(prop);
+                addTodo(ctx, path, 'responsive', `\`${name}.only\` (-only helper classes) has no bestax equivalent; use className`);
+                continue;
+            }
+            else if (kind === 'column' && (key === 'size' || key === 'offset')) {
+                // Column sizes accept numbers and named strings alike; reuse the node.
+                const target = `${key}${suffix}`;
+                addAttr(element, j.jsxAttribute(j.jsxIdentifier(target), j.jsxExpressionContainer(prop.value)));
+            }
+            else if (kind === 'column' && key === 'narrow' && literal === true) {
+                addAttr(element, makeAttr(j, `isNarrow${suffix}`));
+            }
+            else if (kind === 'columns' && key === 'gap') {
+                addAttr(element, j.jsxAttribute(j.jsxIdentifier(`gap${suffix}`), j.jsxExpressionContainer(prop.value)));
+            }
+            else {
+                remaining.push(prop);
+                addTodo(ctx, path, 'responsive', `\`${name}.${String(key)}\` could not be flattened to a bestax per-viewport prop`);
+                continue;
+            }
+        }
+        if (remaining.length === 0) {
+            removeAttr(element, attr);
+        }
+        else {
+            objectExpr.properties = remaining;
+        }
+        ctx.dirty = true;
+    }
+}

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

@@ -0,0 +1,23 @@
+/**
+ * Structural handlers for conversions a rename table can't express: targets
+ * chosen by prop values (Level.Side align), child rewrites (Icon <i> parsing,
+ * Tabs list wrapping), element replacement (Form.Help → plain <p>), and
+ * container unwrapping (Table.Container).
+ *
+ * A handler may return a `target` override for the rename step, or mark the
+ * element `replaced` when it substituted the node itself.
+ */
+import type { ASTPath } from 'jscodeshift';
+import { type TransformContext } from './jsx-utils.js';
+export interface SpecialResult {
+    /** Override the mapping's `target` for the rename step. */
+    target?: string;
+    /** The node was replaced outright — skip rename and prop passes. */
+    replaced?: boolean;
+    /** Prop names the handler consumed; skipped by the later prop passes. */
+    handledProps?: string[];
+}
+export declare function runSpecial(name: string, ctx: TransformContext, path: ASTPath<any>, element: any): SpecialResult;
+/** Responsive-flattening kinds keyed by mapping special names. */
+export declare const RESPONSIVE_KINDS: Record<string, 'columns' | 'column'>;
+//# sourceMappingURL=specials.d.ts.map

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

@@ -0,0 +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,EAUL,KAAK,gBAAgB,EACtB,MAAM,gBAAgB,CAAC;AAIxB,MAAM,WAAW,aAAa;IAC5B,2DAA2D;IAC3D,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,oEAAoE;IACpE,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,yEAAyE;IACzE,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;CACzB;AA6wBD,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"}