react-native-debug-toolkit 3.3.3 → 3.3.4

package/scripts/bundle/ios.js

@@ -0,0 +1,179 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const xcode = require('xcode');
+
+const PHASE_NAME = 'Bundle React Native code and images';
+const BEGIN = '# react-native-debug-toolkit: begin debug bundle';
+const END = '# react-native-debug-toolkit: end debug bundle';
+const BLOCK = `${BEGIN}\nexport FORCE_BUNDLING=1\n${END}`;
+
+function stripQuotes(value) {
+  return String(value || '').replace(/^"|"$/g, '');
+}
+
+function findProjects(cwd) {
+  const iosDir = path.join(cwd, 'ios');
+  if (!fs.existsSync(iosDir)) {
+    return [];
+  }
+
+  return fs.readdirSync(iosDir)
+    .filter((entry) => entry.endsWith('.xcodeproj') && entry !== 'Pods.xcodeproj')
+    .map((entry) => path.join(iosDir, entry, 'project.pbxproj'))
+    .filter((file) => fs.existsSync(file));
+}
+
+function decodeScript(value) {
+  if (!value) {
+    return '';
+  }
+
+  try {
+    return JSON.parse(value);
+  } catch {
+    return stripQuotes(value);
+  }
+}
+
+function encodeScript(value) {
+  return JSON.stringify(value);
+}
+
+function phaseName(phase) {
+  return stripQuotes(phase.name || phase.comment);
+}
+
+function isAppTarget(target) {
+  return stripQuotes(target.productType) === 'com.apple.product-type.application';
+}
+
+function targetName(target) {
+  return stripQuotes(target.name || target.productName || target.comment);
+}
+
+function targetBuildPhaseIds(target) {
+  return (target.buildPhases || []).map((phaseRef) => {
+    if (typeof phaseRef === 'string') {
+      return phaseRef;
+    }
+    return phaseRef.value;
+  });
+}
+
+function sectionEntries(objects, sectionName, isaName) {
+  const section = objects[sectionName];
+  if (section) {
+    return Object.entries(section)
+      .filter(([key]) => !key.endsWith('_comment'));
+  }
+
+  return Object.entries(objects)
+    .filter(([key, value]) => !key.endsWith('_comment') && value && value.isa === isaName)
+    .map(([key, value]) => [key, { ...value, comment: objects[`${key}_comment`] }]);
+}
+
+function loadTarget(cwd, iosTarget) {
+  const projects = findProjects(cwd);
+  if (projects.length !== 1) {
+    throw new Error(`Expected one Xcode project, found ${projects.length}. Pass --ios-target after selecting the app project.`);
+  }
+
+  const pbxFile = projects[0];
+  const proj = xcode.project(pbxFile).parseSync();
+  const objects = proj.hash.project.objects;
+  const nativeTargets = sectionEntries(objects, 'PBXNativeTarget', 'PBXNativeTarget');
+  const shellPhases = new Map(sectionEntries(objects, 'PBXShellScriptBuildPhase', 'PBXShellScriptBuildPhase'));
+
+  const appTargets = nativeTargets
+    .filter(([, target]) => isAppTarget(target));
+
+  const matches = iosTarget
+    ? appTargets.filter(([, target]) => targetName(target) === iosTarget)
+    : appTargets;
+
+  if (matches.length !== 1) {
+    throw new Error(`Expected one iOS app target, found ${matches.length}. Pass --ios-target <name>.`);
+  }
+
+  const [, target] = matches[0];
+  for (const phaseId of targetBuildPhaseIds(target)) {
+    const phase = shellPhases.get(phaseId);
+    if (!phase || phaseName(phase) !== PHASE_NAME) {
+      continue;
+    }
+
+    const script = decodeScript(phase.shellScript);
+    if (!script.includes('react-native-xcode.sh') && !script.includes('with-environment.sh')) {
+      throw new Error(`${PHASE_NAME} does not call React Native bundling script.`);
+    }
+
+    return { pbxFile, proj, phase };
+  }
+
+  throw new Error(`${PHASE_NAME} phase not found on iOS app target.`);
+}
+
+function insertBlock(script) {
+  if (script.includes(BEGIN)) {
+    return script;
+  }
+  return `${BLOCK}\n${script}`;
+}
+
+function removeBlock(script) {
+  return script.replace(
+    /# react-native-debug-toolkit: begin debug bundle\r?\nexport FORCE_BUNDLING=1\r?\n# react-native-debug-toolkit: end debug bundle\r?\n?/g,
+    '',
+  );
+}
+
+function writeProject(ctx, script) {
+  ctx.phase.shellScript = encodeScript(script);
+  fs.writeFileSync(ctx.pbxFile, ctx.proj.writeSync());
+}
+
+function setupIosBundle(options) {
+  const ctx = loadTarget(options.cwd, options.iosTarget);
+  const script = decodeScript(ctx.phase.shellScript);
+  const next = insertBlock(script);
+
+  if (next === script) {
+    return { ok: true, changed: false };
+  }
+
+  writeProject(ctx, next);
+  return { ok: true, changed: true };
+}
+
+function undoIosBundle(options) {
+  const ctx = loadTarget(options.cwd, options.iosTarget);
+  const script = decodeScript(ctx.phase.shellScript);
+  const next = removeBlock(script);
+
+  if (next === script) {
+    return { ok: true, changed: false };
+  }
+
+  writeProject(ctx, next);
+  return { ok: true, changed: true };
+}
+
+function checkIosBundle(options) {
+  const ctx = loadTarget(options.cwd, options.iosTarget);
+  const script = decodeScript(ctx.phase.shellScript);
+
+  return {
+    ok: script.includes(BLOCK),
+    changed: false,
+  };
+}
+
+module.exports = {
+  setupIosBundle,
+  undoIosBundle,
+  checkIosBundle,
+  BEGIN,
+  END,
+};

package/scripts/bundle/setup.js

@@ -0,0 +1,39 @@
+'use strict';
+
+const { setupIosBundle, undoIosBundle, checkIosBundle } = require('./ios');
+const { setupAndroidBundle, undoAndroidBundle, checkAndroidBundle } = require('./android');
+
+async function setupBundle(options) {
+  const platforms = options.platform === 'all' ? ['ios', 'android'] : [options.platform];
+  const results = [];
+
+  for (const platform of platforms) {
+    if (platform === 'ios') {
+      if (options.undo) {
+        results.push(undoIosBundle(options));
+      } else if (options.check) {
+        results.push(checkIosBundle(options));
+      } else {
+        results.push(setupIosBundle(options));
+      }
+      continue;
+    }
+
+    if (platform === 'android') {
+      if (options.undo) {
+        results.push(undoAndroidBundle(options));
+      } else if (options.check) {
+        results.push(checkAndroidBundle(options));
+      } else {
+        results.push(setupAndroidBundle(options));
+      }
+      continue;
+    }
+
+    throw new Error(`Unsupported platform: ${platform}`);
+  }
+
+  return results;
+}
+
+module.exports = { setupBundle };

package/scripts/debug-bundle.gradle

@@ -0,0 +1,147 @@
+// react-native-debug-toolkit: persistent debug/development bundle generation
+
+import java.util.Locale
+import javax.inject.Inject
+import org.gradle.api.DefaultTask
+import org.gradle.api.GradleException
+import org.gradle.api.file.DirectoryProperty
+import org.gradle.api.file.RegularFileProperty
+import org.gradle.api.provider.ListProperty
+import org.gradle.api.provider.Property
+import org.gradle.api.tasks.Input
+import org.gradle.api.tasks.InputDirectory
+import org.gradle.api.tasks.InputFile
+import org.gradle.api.tasks.Optional
+import org.gradle.api.tasks.OutputDirectory
+import org.gradle.api.tasks.TaskAction
+import org.gradle.process.ExecOperations
+
+abstract class DebugToolkitBundleTask extends DefaultTask {
+  @Inject
+  abstract ExecOperations getExecOperations()
+
+  @InputDirectory
+  abstract DirectoryProperty getRoot()
+
+  @InputFile
+  abstract RegularFileProperty getCliFile()
+
+  @InputFile
+  @Optional
+  abstract RegularFileProperty getEntryFile()
+
+  @InputFile
+  @Optional
+  abstract RegularFileProperty getBundleConfig()
+
+  @Input
+  abstract ListProperty<String> getNodeExecutableAndArgs()
+
+  @Input
+  abstract Property<String> getBundleCommand()
+
+  @Input
+  abstract Property<String> getBundleAssetName()
+
+  @Input
+  abstract ListProperty<String> getExtraPackagerArgs()
+
+  @OutputDirectory
+  abstract DirectoryProperty getJsBundleDir()
+
+  @OutputDirectory
+  abstract DirectoryProperty getResourcesDir()
+
+  @TaskAction
+  void run() {
+    def rootFile = root.get().asFile
+    def bundleOutput = new File(jsBundleDir.get().asFile, bundleAssetName.get())
+    def entry = resolveEntryFile(rootFile)
+    jsBundleDir.get().asFile.mkdirs()
+    resourcesDir.get().asFile.mkdirs()
+
+    def command = []
+    command.addAll(nodeExecutableAndArgs.get())
+    command.add(cliFile.get().asFile.absolutePath)
+    command.add(bundleCommand.get())
+    command.addAll([
+      "--platform", "android",
+      "--dev", "true",
+      "--entry-file", entry.absolutePath,
+      "--bundle-output", bundleOutput.absolutePath,
+      "--assets-dest", resourcesDir.get().asFile.absolutePath,
+    ])
+
+    if (bundleConfig.isPresent()) {
+      command.add("--config")
+      command.add(bundleConfig.get().asFile.absolutePath)
+    }
+
+    command.addAll(extraPackagerArgs.get())
+
+    execOperations.exec {
+      workingDir(rootFile)
+      commandLine(command)
+    }
+  }
+
+  private File resolveEntryFile(File rootFile) {
+    if (entryFile.isPresent()) {
+      return entryFile.get().asFile
+    }
+
+    def androidEntry = new File(rootFile, "index.android.js")
+    return androidEntry.exists() ? androidEntry : new File(rootFile, "index.js")
+  }
+}
+
+def toolkitCapitalize = { String value ->
+  value.length() == 0 ? value : value.substring(0, 1).toUpperCase(Locale.ROOT) + value.substring(1)
+}
+
+def toolkitReactExt = project.extensions.findByName("react")
+def toolkitAndroidComponents = project.extensions.findByName("androidComponents")
+
+if (toolkitAndroidComponents == null) {
+  throw new GradleException("react-native-debug-toolkit debug-bundle.gradle requires the Android Gradle Plugin.")
+}
+
+def toolkitDefaultRoot = project.rootProject.layout.projectDirectory.dir("../")
+def toolkitDebuggableVariants = toolkitReactExt?.debuggableVariants?.getOrElse(["debug"]) ?: ["debug"]
+
+toolkitAndroidComponents.onVariants(toolkitAndroidComponents.selector().all()) { variant ->
+  def variantName = variant.name
+  def isDebuggable = toolkitDebuggableVariants.any { it.equalsIgnoreCase(variantName) }
+
+  if (!isDebuggable) {
+    return
+  }
+
+  def capName = toolkitCapitalize(variantName)
+  def bundleTask = tasks.register("createDebugToolkit${capName}JsAndAssets", DebugToolkitBundleTask) {
+    group = "react"
+    description = "Generate embedded React Native JS bundle for ${variantName} debug build."
+
+    root.set(toolkitReactExt?.root ?: toolkitDefaultRoot)
+    cliFile.set(toolkitReactExt?.cliFile ?: root.file("node_modules/react-native/cli.js"))
+    if (toolkitReactExt?.entryFile?.isPresent()) {
+      entryFile.set(toolkitReactExt.entryFile)
+    }
+    if (toolkitReactExt?.bundleConfig?.isPresent()) {
+      bundleConfig.set(toolkitReactExt.bundleConfig)
+    }
+    nodeExecutableAndArgs.set(toolkitReactExt?.nodeExecutableAndArgs ?: ["node"])
+    bundleCommand.set(toolkitReactExt?.bundleCommand ?: "bundle")
+    bundleAssetName.set(toolkitReactExt?.bundleAssetName ?: "index.android.bundle")
+    extraPackagerArgs.set(toolkitReactExt?.extraPackagerArgs ?: [])
+    jsBundleDir.set(project.layout.buildDirectory.dir("generated/assets/react-native-debug-toolkit/${variantName}"))
+    resourcesDir.set(project.layout.buildDirectory.dir("generated/res/react-native-debug-toolkit/${variantName}"))
+  }
+
+  variant.sources.assets?.addGeneratedSourceDirectory(bundleTask) { task ->
+    task.jsBundleDir
+  }
+  variant.sources.res?.addGeneratedSourceDirectory(bundleTask) { task ->
+    task.resourcesDir
+  }
+}

package/scripts/android-debug-bundle.gradle

@@ -1,23 +0,0 @@
-// react-native-debug-toolkit: Debug bundle generation for Android
-// Applied via: apply from: "../../node_modules/react-native-debug-toolkit/scripts/android-debug-bundle.gradle"
-
-tasks.register('generateDebugBundle', Exec) {
-    commandLine 'npx', 'react-native', 'bundle',
-        '--platform', 'android',
-        '--dev', 'true',
-        '--entry-file', project.ext.has('debugToolkitEntryFile')
-            ? project.ext.debugToolkitEntryFile : 'index.js',
-        '--bundle-output', "${projectDir}/src/main/assets/index.android.bundle",
-        '--assets-dest', "${projectDir}/src/main/res"
-}
-
-afterEvaluate {
-    // Disable for release variants
-    tasks.matching { it.name.contains('Release') }.configureEach {
-        tasks.named('generateDebugBundle').get().enabled = false
-    }
-    // Wire as preBuild dependency for debug variants
-    android.applicationVariants.matching { it.buildType.name == 'debug' }.configureEach {
-        preBuildProvider.configure { dependsOn 'generateDebugBundle' }
-    }
-}

package/scripts/eas-postinstall.sh

@@ -1,6 +0,0 @@
-#!/usr/bin/env bash
-# react-native-debug-toolkit: EAS Build postInstall hook
-# Usage in eas.json:
-#   "postInstall": "bash node_modules/react-native-debug-toolkit/scripts/eas-postinstall.sh"
-set -e
-npx debug-toolkit embed --yes

package/scripts/embed-android.js

@@ -1,116 +0,0 @@
-'use strict';
-
-const fs = require('fs');
-const path = require('path');
-
-const APPLY_FROM_MARKER =
-  '// react-native-debug-toolkit: debug bundle embed';
-const APPLY_FROM_LINE =
-  APPLY_FROM_MARKER +
-  '\napply from: "../../node_modules/react-native-debug-toolkit/scripts/android-debug-bundle.gradle"';
-
-function findBuildGradle(projectRoot) {
-  const gradlePath = path.join(projectRoot, 'android', 'app', 'build.gradle');
-  const gradleKtsPath = path.join(
-    projectRoot,
-    'android',
-    'app',
-    'build.gradle.kts'
-  );
-
-  if (fs.existsSync(gradleKtsPath)) {
-    return 'android/app/build.gradle.kts';
-  }
-  if (fs.existsSync(gradlePath)) {
-    return 'android/app/build.gradle';
-  }
-  return null;
-}
-
-function ensureAssetsDir(projectRoot) {
-  const assetsDir = path.join(
-    projectRoot,
-    'android',
-    'app',
-    'src',
-    'main',
-    'assets'
-  );
-  if (!fs.existsSync(assetsDir)) {
-    fs.mkdirSync(assetsDir, { recursive: true });
-    console.log('  Created android/app/src/main/assets/');
-  }
-}
-
-function injectGradleApply(projectRoot, buildGradleRelPath, entryFile, options) {
-  const fullPath = path.join(projectRoot, buildGradleRelPath);
-  let content = fs.readFileSync(fullPath, 'utf-8');
-
-  // Idempotent check
-  if (content.includes(APPLY_FROM_MARKER)) {
-    console.log(
-      `  ${buildGradleRelPath}: apply-from already present. Skipping.`
-    );
-    return { buildGradle: buildGradleRelPath, entryFile };
-  }
-
-  // Set entry file as ext property if non-default
-  let entryFileExt = '';
-  if (entryFile && entryFile !== 'index.js') {
-    entryFileExt = `\nproject.ext.debugToolkitEntryFile = '${entryFile}'`;
-  }
-
-  content += '\n\n' + APPLY_FROM_LINE + entryFileExt + '\n';
-  fs.writeFileSync(fullPath, content);
-
-  ensureAssetsDir(projectRoot);
-  console.log(`  ${buildGradleRelPath}: Injected apply-from for debug bundle.`);
-
-  return { buildGradle: buildGradleRelPath, entryFile };
-}
-
-function undoGradleApply(projectRoot, config) {
-  if (!config.android) {
-    console.log('  No Android configuration found. Skipping.');
-    return;
-  }
-
-  const fullPath = path.join(projectRoot, config.android.buildGradle);
-  if (!fs.existsSync(fullPath)) {
-    console.log(`  ${config.android.buildGradle} not found. Skipping.`);
-    return;
-  }
-
-  let content = fs.readFileSync(fullPath, 'utf-8');
-  if (!content.includes(APPLY_FROM_MARKER)) {
-    console.log('  apply-from not found. Skipping.');
-    return;
-  }
-
-  // Remove the marker line, apply-from line, and optional entryFile ext
-  const lines = content.split('\n');
-  const filtered = lines.filter((line) => {
-    if (line === APPLY_FROM_MARKER) return false;
-    if (
-      line.startsWith('apply from:') &&
-      line.includes('react-native-debug-toolkit/scripts/android-debug-bundle.gradle')
-    )
-      return false;
-    if (line.startsWith("project.ext.debugToolkitEntryFile = '")) return false;
-    return true;
-  });
-
-  // Trim trailing empty lines introduced by our injection
-  while (filtered.length > 0 && filtered[filtered.length - 1].trim() === '') {
-    filtered.pop();
-  }
-
-  fs.writeFileSync(fullPath, filtered.join('\n') + '\n');
-  console.log('  Removed apply-from from build.gradle.');
-}
-
-module.exports = {
-  findBuildGradle,
-  injectGradleApply,
-  undoGradleApply,
-};

package/scripts/embed-expo.js

@@ -1,109 +0,0 @@
-'use strict';
-
-const fs = require('fs');
-const path = require('path');
-
-function isExpoProject(projectRoot) {
-  // app.json with expo field
-  const appJsonPath = path.join(projectRoot, 'app.json');
-  if (fs.existsSync(appJsonPath)) {
-    try {
-      const appJson = JSON.parse(fs.readFileSync(appJsonPath, 'utf-8'));
-      if (appJson.expo) return true;
-    } catch (_) {}
-  }
-
-  // app.config.js or app.config.ts
-  if (
-    fs.existsSync(path.join(projectRoot, 'app.config.js')) ||
-    fs.existsSync(path.join(projectRoot, 'app.config.ts'))
-  ) {
-    return true;
-  }
-
-  // expo in package.json dependencies
-  const pkgPath = path.join(projectRoot, 'package.json');
-  if (fs.existsSync(pkgPath)) {
-    try {
-      const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
-      const deps = { ...pkg.dependencies, ...pkg.devDependencies };
-      if (deps.expo) return true;
-    } catch (_) {}
-  }
-
-  return false;
-}
-
-function isExpoGo(projectRoot) {
-  // Expo Go doesn't support embedded bundles
-  // If no ios/ or android/ dirs, likely Expo Go
-  const hasNativeDirs =
-    fs.existsSync(path.join(projectRoot, 'ios')) ||
-    fs.existsSync(path.join(projectRoot, 'android'));
-
-  if (!hasNativeDirs) {
-    return true;
-  }
-  return false;
-}
-
-function isPrebuilt(projectRoot) {
-  // Dev client / bare workflow after prebuild
-  return (
-    fs.existsSync(path.join(projectRoot, 'ios')) &&
-    fs.existsSync(path.join(projectRoot, 'android'))
-  );
-}
-
-function getExpoEntryPoint(projectRoot) {
-  const appJsonPath = path.join(projectRoot, 'app.json');
-  if (fs.existsSync(appJsonPath)) {
-    try {
-      const appJson = JSON.parse(fs.readFileSync(appJsonPath, 'utf-8'));
-      if (appJson.expo && appJson.expo.entryPoint) {
-        return appJson.expo.entryPoint;
-      }
-    } catch (_) {}
-  }
-
-  // Expo default with .expo virtual entry
-  const virtualEntry = path.join(
-    projectRoot,
-    '.expo',
-    '.virtual-metro-entry'
-  );
-  if (fs.existsSync(virtualEntry)) {
-    return '.expo/.virtual-metro-entry';
-  }
-
-  return null;
-}
-
-function checkExpo(projectRoot, options) {
-  const expo = isExpoProject(projectRoot);
-  if (!expo) {
-    return { expo: false, skip: false };
-  }
-
-  if (isExpoGo(projectRoot)) {
-    return {
-      expo: true,
-      skip: true,
-      reason:
-        'Expo Go does not support embedded bundles. Use expo-dev-client or run npx expo prebuild first.',
-    };
-  }
-
-  if (!isPrebuilt(projectRoot)) {
-    return {
-      expo: true,
-      skip: true,
-      reason:
-        'Native directories not found. Run npx expo prebuild first, then retry.',
-    };
-  }
-
-  return { expo: true, skip: false, entryPoint: getExpoEntryPoint(projectRoot) };
-}
-
-module.exports = { isExpoProject, checkExpo, getExpoEntryPoint };