@scalebun/react-native 1.4.0 → 1.6.0

package/bin/lib/androidCodemod.js

@@ -0,0 +1,370 @@
+'use strict';
+/**
+ * Android MainApplication codemod for `npx scalebun init android`.
+ *
+ * Pure, dependency-free string transforms (no fs / process / RN imports) so they
+ * are unit-testable with plain fixtures and safe to run anywhere. The CLI
+ * (bin/scalebun.js) handles disk IO, flags, and reporting; this module only
+ * decides WHAT the patched source should be.
+ *
+ * It wires OTA bundle resolution into the host app's MainApplication so a
+ * downloaded update actually LOADS instead of the app silently running the
+ * bundle baked into the APK. The required call is the static
+ * `ScaleBunOtaModule.getJSBundleFile(context)`, wired in one of two shapes
+ * depending on the React Native version:
+ *
+ *   - RN < 0.82 (ReactNativeHost still exists): add
+ *       override fun getJSBundleFile(): String? =
+ *         ScaleBunOtaModule.getJSBundleFile(this@MainApplication) ?: super.getJSBundleFile()
+ *     inside the `object : *ReactNativeHost { … }` block.
+ *
+ *   - RN >= 0.82 (ReactNativeHost removed): pass the path to getDefaultReactHost:
+ *       getDefaultReactHost(
+ *         …,
+ *         jsBundleFilePath = ScaleBunOtaModule.getJSBundleFile(applicationContext),
+ *       )
+ *
+ * The version decides the shape — mirroring the check in
+ * @scalebun/cli src/commands/doctor.ts. Every transform is idempotent (running
+ * twice is a no-op). Java MainApplication and unrecognized structures are NOT
+ * auto-patched — they return an exact manual snippet instead of a risky edit.
+ */
+
+const OTA_IMPORT = 'import com.scalebun.rn.ota.ScaleBunOtaModule';
+const BUNDLE_CALL = 'ScaleBunOtaModule.getJSBundleFile';
+const MANAGED_TAG = 'ScaleBun OTA bundle resolution';
+
+// ── MainApplication discovery ────────────────────────────────────────────────
+
+/**
+ * Find the host MainApplication under <androidDir>. Returns { path, kind } where
+ * kind is 'kotlin' (.kt) or 'java' (.java), or null when none is found. Kotlin
+ * is preferred. `fsLike`/`pathLike` are injected for testability.
+ */
+function findMainApplication(androidDir, fsLike, pathLike) {
+    const fs = fsLike;
+    const path = pathLike;
+    const root = path.join(androidDir, 'app', 'src', 'main');
+
+    // Walk src/main/{java,kotlin}/** for MainApplication.kt/.java.
+    const found = { kotlin: null, java: null };
+    const walk = (dir) => {
+        let entries = [];
+        try {
+            entries = fs.readdirSync(dir, { withFileTypes: true });
+        } catch {
+            return;
+        }
+        for (const entry of entries) {
+            const p = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                walk(p);
+            } else if (entry.name === 'MainApplication.kt' && !found.kotlin) {
+                found.kotlin = p;
+            } else if (entry.name === 'MainApplication.java' && !found.java) {
+                found.java = p;
+            }
+        }
+    };
+    walk(root);
+
+    if (found.kotlin) return { path: found.kotlin, kind: 'kotlin' };
+    if (found.java) return { path: found.java, kind: 'java' };
+    return null;
+}
+
+// ── version helper ────────────────────────────────────────────────────────────
+
+/**
+ * True when RN >= 0.82 (ReactNativeHost removed → must pass jsBundleFilePath to
+ * getDefaultReactHost). `minor` is [major, minor] or null when unknown; when
+ * unknown we assume the modern shape.
+ */
+function isReactHostEra(minor) {
+    if (!minor) return true;
+    return minor[0] > 0 || minor[1] >= 82;
+}
+
+// ── analysis ────────────────────────────────────────────────────────────────
+
+/** Report which OTA wiring pieces are already present in a Kotlin MainApplication. */
+function analyzeKotlin(source) {
+    const s = String(source);
+    return {
+        hasImport: s.includes(OTA_IMPORT),
+        hasBundleWiring: s.includes(BUNDLE_CALL),
+        hasReactNativeHostObject: /object\s*:\s*\w*ReactNativeHost\s*\(/.test(s),
+        hasGetDefaultReactHost: s.includes('getDefaultReactHost('),
+        hasJsBundleFilePathArg: s.includes('jsBundleFilePath'),
+    };
+}
+
+/**
+ * True when OTA bundle resolution is fully wired for this RN version (for
+ * --check). On RN >= 0.82 the wiring must go through the jsBundleFilePath arg;
+ * before that any getJSBundleFile call is enough.
+ */
+function isFullyWiredKotlin(source, minor) {
+    const a = analyzeKotlin(source);
+    if (!a.hasImport || !a.hasBundleWiring) return false;
+    if (isReactHostEra(minor)) return a.hasJsBundleFilePathArg;
+    return true;
+}
+
+// ── helpers ─────────────────────────────────────────────────────────────────
+
+/** Insert `lineToAdd` immediately after the last top-of-file Kotlin import. */
+function insertAfterLastImport(source, lineToAdd) {
+    const lines = source.split('\n');
+    let lastImport = -1;
+    for (let i = 0; i < lines.length; i++) {
+        if (/^\s*import\b/.test(lines[i])) lastImport = i;
+        // Stop scanning once the class/object declaration begins.
+        if (/^\s*(class|object)\b/.test(lines[i])) break;
+    }
+    if (lastImport === -1) {
+        // No imports — put it after the package line, else prepend.
+        for (let i = 0; i < lines.length; i++) {
+            if (/^\s*package\b/.test(lines[i])) {
+                lines.splice(i + 1, 0, '', lineToAdd);
+                return lines.join('\n');
+            }
+        }
+        return lineToAdd + '\n' + source;
+    }
+    lines.splice(lastImport + 1, 0, lineToAdd);
+    return lines.join('\n');
+}
+
+/** Leading whitespace of the first non-empty line at/after `fromIdx`. */
+function bodyIndentAfter(source, fromIdx) {
+    const rest = source.slice(fromIdx).split('\n');
+    for (const line of rest) {
+        if (line.trim() === '') continue;
+        return (line.match(/^\s*/) || [''])[0];
+    }
+    return '        ';
+}
+
+/**
+ * Insert the getJSBundleFile() override into the `object : *ReactNativeHost(…) {`
+ * block (RN < 0.82). Returns { source, inserted, reason }.
+ */
+function insertIntoReactNativeHostObject(source, methodText) {
+    const objRe = /object\s*:\s*\w*ReactNativeHost\s*\([^)]*\)\s*\{/;
+    const m = objRe.exec(source);
+    if (!m) return { source, inserted: false, reason: 'no-object' };
+    const insertAt = m.index + m[0].length; // right after the opening `{`
+    const indent = bodyIndentAfter(source, insertAt);
+    const block = '\n' + methodText(indent);
+    return {
+        source: source.slice(0, insertAt) + block + source.slice(insertAt),
+        inserted: true,
+    };
+}
+
+/**
+ * Insert a named argument into a call, respecting single-line vs multi-line
+ * Kotlin argument style. Returns { source, inserted, reason }.
+ */
+function insertArgIntoCall(source, callName, argText) {
+    const callIdx = source.indexOf(callName + '(');
+    if (callIdx === -1) return { source, inserted: false, reason: 'no-call' };
+    const openIdx = source.indexOf('(', callIdx);
+
+    // Find the matching close paren (calls contain nested parens like
+    // PackageList(this).packages, so a naive indexOf(')') is wrong).
+    let depth = 0;
+    let closeIdx = -1;
+    for (let i = openIdx; i < source.length; i++) {
+        const c = source[i];
+        if (c === '(') depth++;
+        else if (c === ')') {
+            depth--;
+            if (depth === 0) {
+                closeIdx = i;
+                break;
+            }
+        }
+    }
+    if (closeIdx === -1) return { source, inserted: false, reason: 'no-close' };
+
+    const inner = source.slice(openIdx + 1, closeIdx);
+    const isMultiline = inner.includes('\n');
+
+    // Last meaningful (non-whitespace) char before the close paren.
+    let j = closeIdx - 1;
+    while (j > openIdx && /\s/.test(source[j])) j--;
+    const lastChar = source[j];
+
+    let insertText;
+    if (inner.trim() === '') {
+        insertText = argText;
+    } else if (isMultiline) {
+        // Align the new argument with the last existing argument line (the line
+        // where `j` sits) so the call reads consistently, not with the closing
+        // paren's indentation.
+        const argLineStart = source.lastIndexOf('\n', j) + 1;
+        const argIndent = (source.slice(argLineStart, j).match(/^\s*/) || [''])[0];
+        insertText =
+            lastChar === ','
+                ? `\n${argIndent}${argText},`
+                : `,\n${argIndent}${argText}`;
+    } else {
+        insertText = lastChar === ',' ? ` ${argText},` : `, ${argText}`;
+    }
+
+    return {
+        source: source.slice(0, j + 1) + insertText + source.slice(j + 1),
+        inserted: true,
+    };
+}
+
+// ── the patch ─────────────────────────────────────────────────────────────────
+
+/**
+ * Patch a Kotlin MainApplication for OTA bundle resolution. `opts.minor` is the
+ * [major, minor] React Native version (or null). Returns:
+ *   { changed, source, summary[], manual[] }
+ */
+function patchKotlin(source, opts = {}) {
+    let out = String(source);
+    const summary = [];
+    const manual = [];
+    const a = analyzeKotlin(out);
+    const reactHostEra = isReactHostEra(opts.minor);
+
+    // Already fully wired for this era → no-op.
+    if (isFullyWiredKotlin(out, opts.minor)) {
+        return { changed: false, source: out, summary, manual };
+    }
+
+    if (reactHostEra) {
+        // RN >= 0.82: pass jsBundleFilePath to getDefaultReactHost(...).
+        if (!a.hasGetDefaultReactHost) {
+            manual.push(reactHostManual());
+            return { changed: false, source: out, summary, manual };
+        }
+        if (!a.hasImport) {
+            out = insertAfterLastImport(out, OTA_IMPORT);
+            summary.push(`Added import: ${OTA_IMPORT}`);
+        }
+        if (!a.hasJsBundleFilePathArg) {
+            const r = insertArgIntoCall(
+                out,
+                'getDefaultReactHost',
+                'jsBundleFilePath = ScaleBunOtaModule.getJSBundleFile(applicationContext)',
+            );
+            if (r.inserted) {
+                out = r.source;
+                summary.push(
+                    'Patched getDefaultReactHost(...) → added jsBundleFilePath = ScaleBunOtaModule.getJSBundleFile(applicationContext)',
+                );
+            } else {
+                manual.push(reactHostManual());
+            }
+        }
+    } else {
+        // RN < 0.82: add getJSBundleFile() override inside the ReactNativeHost object.
+        if (!a.hasReactNativeHostObject) {
+            manual.push(legacyManual());
+            return { changed: false, source: out, summary, manual };
+        }
+        if (!a.hasImport) {
+            out = insertAfterLastImport(out, OTA_IMPORT);
+            summary.push(`Added import: ${OTA_IMPORT}`);
+        }
+        if (!a.hasBundleWiring) {
+            const r = insertIntoReactNativeHostObject(
+                out,
+                (indent) =>
+                    `${indent}// ${MANAGED_TAG} (added by \`npx scalebun init android\`)\n` +
+                    `${indent}override fun getJSBundleFile(): String? =\n` +
+                    `${indent}    ScaleBunOtaModule.getJSBundleFile(this@MainApplication) ?: super.getJSBundleFile()\n`,
+            );
+            if (r.inserted) {
+                out = r.source;
+                summary.push(
+                    'Added getJSBundleFile() override → ScaleBunOtaModule.getJSBundleFile(this@MainApplication)',
+                );
+            } else {
+                manual.push(legacyManual());
+            }
+        }
+    }
+
+    return { changed: out !== String(source), source: out, summary, manual };
+}
+
+// ── manual instructions ─────────────────────────────────────────────────────
+
+/** Manual snippet for RN >= 0.82 when the getDefaultReactHost call can't be found. */
+function reactHostManual() {
+    return [
+        'Could not locate getDefaultReactHost(...) in MainApplication. Wire OTA bundle',
+        'resolution manually (RN >= 0.82):',
+        '',
+        `  ${OTA_IMPORT}`,
+        '',
+        '  override val reactHost: ReactHost by lazy {',
+        '    getDefaultReactHost(',
+        '      context = applicationContext,',
+        '      packageList = PackageList(this).packages,',
+        '      jsBundleFilePath = ScaleBunOtaModule.getJSBundleFile(applicationContext),',
+        '    )',
+        '  }',
+    ].join('\n');
+}
+
+/** Manual snippet for RN < 0.82 when the ReactNativeHost object can't be found. */
+function legacyManual() {
+    return [
+        'Could not locate the ReactNativeHost object in MainApplication. Add the OTA',
+        'bundle-resolution override manually (RN < 0.82), inside your ReactNativeHost:',
+        '',
+        `  ${OTA_IMPORT}`,
+        '',
+        '  override fun getJSBundleFile(): String? =',
+        '    ScaleBunOtaModule.getJSBundleFile(this@MainApplication) ?: super.getJSBundleFile()',
+    ].join('\n');
+}
+
+/** Manual instructions for a Java MainApplication (auto-patch not supported). */
+function javaInstructions(minor) {
+    if (isReactHostEra(minor)) {
+        return [
+            'A Java MainApplication was detected. Automatic patching of Java is not',
+            'supported — wire OTA bundle resolution manually (RN >= 0.82):',
+            '',
+            '  import com.scalebun.rn.ota.ScaleBunOtaModule;',
+            '',
+            '  // where you build the ReactHost via DefaultReactHost.getDefaultReactHost(...),',
+            '  // pass the OTA bundle path:',
+            '  ScaleBunOtaModule.getJSBundleFile(getApplicationContext())',
+        ].join('\n');
+    }
+    return [
+        'A Java MainApplication was detected. Automatic patching of Java is not',
+        'supported — add this override inside your ReactNativeHost (RN < 0.82):',
+        '',
+        '  import com.scalebun.rn.ota.ScaleBunOtaModule;',
+        '',
+        '  @Override',
+        '  protected String getJSBundleFile() {',
+        '    String ota = ScaleBunOtaModule.getJSBundleFile(getApplicationContext());',
+        '    return ota != null ? ota : super.getJSBundleFile();',
+        '  }',
+    ].join('\n');
+}
+
+module.exports = {
+    OTA_IMPORT,
+    BUNDLE_CALL,
+    MANAGED_TAG,
+    findMainApplication,
+    isReactHostEra,
+    analyzeKotlin,
+    isFullyWiredKotlin,
+    patchKotlin,
+    javaInstructions,
+};