Counting what prebuild --clean will erase before you upgrade to Expo SDK 57

#!/usr/bin/env node
/**
 * native-drift.mjs — count only the hand edits a regeneration would destroy
 *
 * usage:
 *   node native-drift.mjs <baseline-dir> <current-dir> [--json report.json]
 *
 * baseline : untouched generator output (a clean prebuild)
 * current  : the ios/ or android/ currently in your repo
 */
import { readdirSync, readFileSync, statSync, writeFileSync } from 'node:fs';
import { join, relative, sep } from 'node:path';
 
const EXCLUDE_DIRS = [
  'Pods',                    // pod install output; Podfile holds what matters
  'build', 'DerivedData',
  '.gradle', 'app/build',
  'xcuserdata',              // Xcode UI state, per-person churn
];
const EXCLUDE_FILES = ['.DS_Store', 'UserInterfaceState.xcuserstate'];
 
// Expressions that always change on regeneration but never mean anything
const NORMALIZERS = [
  { name: 'pbxproj-object-id', re: /\b[0-9A-F]{24}\b/g, to: '<OBJID>' },
  { name: 'pod-checksum',      re: /\b[0-9a-f]{40}\b/g, to: '<SHA1>' },
  { name: 'timestamp',         re: /\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?Z?/g, to: '<TIME>' },
  { name: 'abs-path',          re: /\/(Users|home)\/[^\s"']+/g, to: '<PATH>' },
];
 
function normalize(text) {
  let out = text;
  for (const n of NORMALIZERS) out = out.replace(n.re, n.to);
  // Compared as a set of lines, so no sorting is needed here (measured: no difference)
  return out.split('\n').map((l) => l.replace(/\s+$/, '')).filter((l) => l !== '').join('\n');
}
 
function walk(root, base = root, acc = []) {
  let entries;
  try { entries = readdirSync(root, { withFileTypes: true }); } catch { return acc; }
  for (const e of entries) {
    const full = join(root, e.name);
    if (e.isDirectory()) {
      if (EXCLUDE_DIRS.some((d) => d === e.name || full.includes(sep + d + sep))) continue;
      walk(full, base, acc);
    } else if (e.isFile()) {
      if (EXCLUDE_FILES.includes(e.name)) continue;
      acc.push(relative(base, full));
    }
  }
  return acc;
}
 
function readSafe(p) {
  try {
    const st = statSync(p);
    if (st.size > 2 * 1024 * 1024) return null; // skip very large files
    const buf = readFileSync(p);
    if (buf.includes(0)) return null;           // binary
    return buf.toString('utf8');
  } catch { return null; }
}
 
function substantiveHunks(aText, bText) {
  // Normalization destroys line numbers, so compare as sets of lines
  const A = new Set(normalize(aText).split('\n'));
  const B = new Set(normalize(bText).split('\n'));
  return {
    added:   [...B].filter((l) => !A.has(l)),
    removed: [...A].filter((l) => !B.has(l)),
  };
}
 
function main() {
  const [baseDir, curDir] = process.argv.slice(2);
  if (!baseDir || !curDir) {
    console.error('usage: node native-drift.mjs <baseline-dir> <current-dir> [--json out.json]');
    process.exit(2);
  }
  const jsonIdx = process.argv.indexOf('--json');
  const jsonOut = jsonIdx > -1 ? process.argv[jsonIdx + 1] : null;
 
  const baseFiles = new Set(walk(baseDir));
  const curFiles  = new Set(walk(curDir));
  const all = [...new Set([...baseFiles, ...curFiles])].sort();
 
  const report = {
    scanned: all.length, identical: 0, noiseOnly: 0,
    substantive: [], onlyInCurrent: [], onlyInBaseline: [], skippedBinary: 0,
  };
 
  for (const rel of all) {
    if (!baseFiles.has(rel)) { report.onlyInCurrent.push(rel); continue; }
    if (!curFiles.has(rel))  { report.onlyInBaseline.push(rel); continue; }
 
    const a = readSafe(join(baseDir, rel));
    const b = readSafe(join(curDir, rel));
    if (a === null || b === null) { report.skippedBinary++; continue; }
    if (a === b) { report.identical++; continue; }
 
    const { added, removed } = substantiveHunks(a, b);
    if (added.length === 0 && removed.length === 0) { report.noiseOnly++; continue; }
    report.substantive.push({ file: rel, added, removed });
  }
 
  console.log('── native drift report ──────────────────────');
  console.log(`files scanned      : ${report.scanned}`);
  console.log(`identical          : ${report.identical}`);
  console.log(`noise-only diff    : ${report.noiseOnly}   <- prebuild churn`);
  console.log(`substantive edits  : ${report.substantive.length}   <- lost on regeneration`);
  console.log(`only in current    : ${report.onlyInCurrent.length}`);
  console.log(`only in baseline   : ${report.onlyInBaseline.length}`);
  console.log('');
  for (const s of report.substantive) {
    console.log(`> ${s.file}`);
    for (const l of s.removed) console.log(`   - ${l.trim()}`);
    for (const l of s.added)   console.log(`   + ${l.trim()}`);
    console.log('');
  }
  for (const f of report.onlyInCurrent) console.log(`> ${f} (not in generator output = added by hand)`);
 
  if (jsonOut) writeFileSync(jsonOut, JSON.stringify(report, null, 2));
 
  const lost = report.substantive.length + report.onlyInCurrent.length;
  if (lost > 0) {
    console.log(`\nFAIL: ${lost} change(s) would be lost. Move them into a config plugin before running prebuild --clean.`);
    process.exit(1);
  }
  console.log('\nOK: nothing would be lost on regeneration.');
}
main();

/**
 * with-native-edits.js — express ios/ hand edits as a config plugin
 *
 * app.json:
 *   { "expo": { "plugins": [["./with-native-edits", { "cameraUsage": "…" }]] } }
 */
const { withInfoPlist, withAppDelegate, withXcodeProject } = require('@expo/config-plugins');
 
// --- 1. Info.plist: usage string ---
const withCameraUsage = (config, { cameraUsage }) =>
  withInfoPlist(config, (cfg) => {
    // Leave it alone if the value already matches, to avoid needless dirtying
    if (cfg.modResults.NSCameraUsageDescription !== cameraUsage) {
      cfg.modResults.NSCameraUsageDescription = cameraUsage;
    }
    return cfg;
  });
 
// --- 2. AppDelegate: inject one SDK initialization line ---
const ANCHOR = 'self.moduleName = @"main";';
const INJECT = '[FIRApp configure];';
 
const withFirebaseInit = (config) =>
  withAppDelegate(config, (cfg) => {
    const src = cfg.modResults.contents;
 
    if (src.includes(INJECT)) return cfg;              // idempotent: never insert twice
 
    if (!src.includes(ANCHOR)) {
      // Do not skip silently. A warning here means the initialization
      // quietly vanishes after an SDK bump and nobody notices.
      throw new Error(
        `[with-native-edits] Anchor "${ANCHOR}" not found in AppDelegate. ` +
        `The Expo SDK template likely changed — update ANCHOR.`
      );
    }
 
    cfg.modResults.contents = src.replace(ANCHOR, `${INJECT}\n  ${ANCHOR}`);
    return cfg;
  });
 
// --- 3. pbxproj: build setting ---
const withObjCLinkFlag = (config) =>
  withXcodeProject(config, (cfg) => {
    const project = cfg.modResults;
    const configurations = project.pbxXCBuildConfigurationSection();
    for (const key of Object.keys(configurations)) {
      const entry = configurations[key];
      if (typeof entry !== 'object' || !entry.buildSettings) continue;
      if (!('PRODUCT_NAME' in entry.buildSettings)) continue;   // app target only
      const cur = entry.buildSettings.OTHER_LDFLAGS;
      const flags = Array.isArray(cur) ? cur : cur ? [cur] : ['"$(inherited)"'];
      if (!flags.includes('"-ObjC"')) flags.push('"-ObjC"');
      entry.buildSettings.OTHER_LDFLAGS = flags;
    }
    return cfg;
  });
 
module.exports = (config, props = {}) => {
  const opts = { cameraUsage: 'Used to take your profile photo', ...props };
  config = withCameraUsage(config, opts);
  config = withFirebaseInit(config);
  config = withObjCLinkFlag(config);
  return config;
};

if (!src.includes(ANCHOR)) {
  console.warn('anchor not found, skipping');
  return cfg;
}