@capacitor/cli 9.0.0-alpha.8 → 9.0.0-beta.0

package/dist/tasks/migrate-swiftui.js

@@ -9,22 +9,80 @@ const fs_1 = require("../util/fs");
 const spm_1 = require("../util/spm");
 const template_1 = require("../util/template");
 const xcode_1 = require("../util/xcode");
+const MIGRATION_GUIDE_URL = 'https://capacitorjs.com/docs/next/updating/9-0';
 const OPEN_URL_SIG = /func application\([^)]*\bopen url:/;
 const CONTINUE_SIG = /func application\([^)]*\bcontinue userActivity:/;
 const CONFIGURATION_FOR_CONNECTING_SIG = /func application\([^)]*\bconfigurationForConnecting\b/;
+// Kept byte-identical to the shipped templates; migrate-swiftui-stock-app-delegate.spec.ts
+// fails if the two drift apart.
+const CONFIGURATION_FOR_CONNECTING_METHOD = [
+    '    func application(',
+    '        _ application: UIApplication,',
+    '        configurationForConnecting connectingSceneSession: UISceneSession,',
+    '        options: UIScene.ConnectionOptions',
+    '    ) -> UISceneConfiguration {',
+    '        let configuration = UISceneConfiguration(name: nil, sessionRole: connectingSceneSession.role)',
+    '        configuration.delegateClass = SceneDelegate.self',
+    '        return configuration',
+    '    }',
+].join('\n');
+const SUPPORTED_INTERFACE_ORIENTATIONS_SIG = /func application\([^)]*\bsupportedInterfaceOrientationsFor\b/;
+// Kept byte-identical to the shipped templates, like CONFIGURATION_FOR_CONNECTING_METHOD.
+const SUPPORTED_INTERFACE_ORIENTATIONS_METHOD = [
+    '    func application(',
+    '        _ application: UIApplication,',
+    '        supportedInterfaceOrientationsFor window: UIWindow?',
+    '    ) -> UIInterfaceOrientationMask {',
+    '        ApplicationDelegateProxy.shared.application(application, supportedInterfaceOrientationsFor: window)',
+    '    }',
+].join('\n');
+const SCENE_WILL_CONNECT_SIG = /func scene\([^)]*\bwillConnectTo session:/;
+const SCENE_OPEN_URL_CONTEXTS_SIG = /func scene\([^)]*\bopenURLContexts\b/;
+const SCENE_CONTINUE_SIG = /func scene\([^)]*\bcontinue userActivity:/;
+const SCENE_DELEGATE_PROXY = 'SceneDelegateProxy.shared';
+const STOCK_WILL_CONNECT_BODY = [
+    /^guard let windowScene = scene as\? UIWindowScene else \{ return \}$/,
+    /^window = UIWindow\(windowScene: windowScene\)$/,
+    /^window\?\.rootViewController = CAPBridgeViewController\(\)$/,
+    /^window\?\.makeKeyAndVisible\(\)$/,
+    /^SceneDelegateProxy\.shared\.scene\(/,
+];
+const STOCK_WINDOW_PROPERTY = /^var\s+window\s*:\s*UIWindow\?$/;
+const APP_DELEGATE_CLASS_SIG = /\bclass\s+AppDelegate\s*:\s*(?:UIResponder|NSObject)\s*,\s*UIApplicationDelegate\s*\{/;
+const DID_FINISH_LAUNCHING_SIG = /func application\([^)]*\bdidFinishLaunchingWithOptions\b/;
+const APPLICATION_DELEGATE_PROXY = 'ApplicationDelegateProxy.shared';
+// Every module a stock AppDelegate has ever imported; anything else is the developer's.
+const STOCK_APP_DELEGATE_PREAMBLE = /^(?:import\s+(?:UIKit|Capacitor|Foundation)|@(?:main|UIApplicationMain))$/;
+/**
+ * The members every stock AppDelegate has carried since Capacitor 5, with the body each is
+ * allowed to hold. `configurationForConnecting` takes any body: whatever it names as the
+ * delegate class, the 9.0 template replaces it with one naming SceneDelegate.
+ */
+const STOCK_APP_DELEGATE_METHODS = [
+    { sig: DID_FINISH_LAUNCHING_SIG, bodyIsStock: (lines) => lines.length === 1 && lines[0] === 'return true' },
+    { sig: /func applicationWillResignActive\(/, bodyIsStock: isEmpty },
+    { sig: /func applicationDidEnterBackground\(/, bodyIsStock: isEmpty },
+    { sig: /func applicationWillEnterForeground\(/, bodyIsStock: isEmpty },
+    { sig: /func applicationDidBecomeActive\(/, bodyIsStock: isEmpty },
+    { sig: /func applicationWillTerminate\(/, bodyIsStock: isEmpty },
+    { sig: OPEN_URL_SIG, bodyIsStock: (lines) => lines.every((line) => line.includes(APPLICATION_DELEGATE_PROXY)) },
+    { sig: CONTINUE_SIG, bodyIsStock: (lines) => lines.every((line) => line.includes(APPLICATION_DELEGATE_PROXY)) },
+    { sig: CONFIGURATION_FOR_CONNECTING_SIG, bodyIsStock: () => true },
+    {
+        sig: SUPPORTED_INTERFACE_ORIENTATIONS_SIG,
+        bodyIsStock: (lines) => lines.every((line) => line.includes(APPLICATION_DELEGATE_PROXY)),
+    },
+];
 async function migrateToSwiftUI(config) {
     const signals = readDetectionSignals(config);
-    const state = classify(signals);
-    switch (state) {
-        case 'already-migrated':
-            log_1.logger.info('SwiftUI migration: project already uses the SwiftUI App-struct layout, skipping.');
-            return;
-        case 'partial':
-            log_1.logger.warn(`SwiftUI migration: project is in a partial state (${describeSignals(signals)}). ` +
-                `Skipping automated migration — finish the migration by hand or reset the iOS project to a clean 8.4/8.5 state first.`);
-            return;
-        case 'eligible':
-            break;
+    if (classify(signals) === 'already-migrated') {
+        log_1.logger.info('SwiftUI migration: project already uses the SwiftUI App-struct layout, skipping.');
+        await forwardSupportedInterfaceOrientations(config);
+        return;
+    }
+    if (hasAnySignal(signals)) {
+        log_1.logger.info(`SwiftUI migration: resuming a partially migrated project (${describeSignals(signals)}); ` +
+            `completing the missing steps.`);
     }
     const appDelegatePath = (0, path_1.join)(config.ios.nativeTargetDirAbs, 'AppDelegate.swift');
     const rewrite = planAppDelegateRewrite(appDelegatePath);
@@ -44,7 +102,7 @@ async function migrateToSwiftUI(config) {
             log_1.logger.warn(`Info.plist not updated: ${result.reason}`);
         }
     });
-    await (0, common_1.runTask)('Writing App.swift and CapacitorView.swift.', async () => {
+    await (0, common_1.runTask)('Writing App.swift, CapacitorView.swift and SceneDelegate.swift.', async () => {
         const files = [
             ['App.swift', assets.app],
             ['CapacitorView.swift', assets.capacitorView],
@@ -54,14 +112,27 @@ async function migrateToSwiftUI(config) {
                 log_1.logger.warn(`${name} already exists, skipping.`);
             }
         }
+        const sceneDelegatePath = (0, path_1.join)(config.ios.nativeTargetDirAbs, 'SceneDelegate.swift');
+        if (writeSceneDelegate(sceneDelegatePath, assets.sceneDelegate) === 'kept') {
+            log_1.logger.warn(`${sceneDelegatePath} carries code of your own, so it was kept. It is still the app's scene delegate, but ` +
+                `the SwiftUI App struct now owns the window: move any window setup out of it, and route ` +
+                `scene(_:openURLContexts:) and scene(_:continue:) through SceneDelegateProxy.shared from the SwiftUI ` +
+                `scene body instead. See ${MIGRATION_GUIDE_URL}.`);
+        }
     });
+    const replaceAppDelegate = isStockAppDelegate((0, fs_extra_1.readFileSync)(appDelegatePath, 'utf-8'));
     await (0, common_1.runTask)('Converting AppDelegate.swift into a UIApplicationDelegateAdaptor.', async () => {
-        (0, fs_extra_1.writeFileSync)(appDelegatePath, rewrite.source);
+        (0, fs_extra_1.writeFileSync)(appDelegatePath, replaceAppDelegate ? assets.appDelegate : rewrite.source);
     });
-    await (0, common_1.runTask)('Registering App.swift and CapacitorView.swift with the Xcode App target.', async () => {
+    if (!replaceAppDelegate) {
+        log_1.logger.warn(`${appDelegatePath} carries code of your own, so it was converted in place rather than replaced with the ` +
+            `slimmed-down Capacitor 9 template. Review what it still holds against ${MIGRATION_GUIDE_URL}.`);
+    }
+    let registrationFailed = false;
+    await (0, common_1.runTask)('Registering the SwiftUI entry-point files with the Xcode App target.', async () => {
         var _a;
         const pbxprojPath = (0, path_1.join)(config.ios.nativeXcodeProjDirAbs, 'project.pbxproj');
-        for (const name of ['App.swift', 'CapacitorView.swift']) {
+        for (const name of ['App.swift', 'CapacitorView.swift', 'SceneDelegate.swift']) {
             try {
                 const { added } = (0, xcode_1.addSwiftFileToAppTarget)(pbxprojPath, 'App', name);
                 if (!added) {
@@ -69,15 +140,69 @@ async function migrateToSwiftUI(config) {
                 }
             }
             catch (err) {
+                registrationFailed = true;
                 log_1.logger.warn(`Could not register ${name} automatically: ${(_a = err === null || err === void 0 ? void 0 : err.message) !== null && _a !== void 0 ? _a : err}. ` +
                     `Add ${name} to the App target in Xcode manually.`);
             }
         }
     });
+    if (registrationFailed) {
+        log_1.logger.warn('Leaving Main.storyboard in place because the App target was not fully updated.');
+    }
+    else {
+        await (0, common_1.runTask)('Removing the leftover main storyboard.', async () => {
+            removeLeftoverStoryboard(config);
+        });
+    }
     await scanAndWarn(config);
-    printNextSteps(config);
+    printNextSteps();
 }
 exports.migrateToSwiftUI = migrateToSwiftUI;
+/**
+ * Put the 9.0 scene delegate in place.
+ *
+ * The class stays in the app target rather than moving into the framework because
+ * UISceneConfiguration.delegateClass takes a type and UIKit instantiates it itself, so the
+ * app has to own a concrete class for AppDelegate to name. A stock 8.x file is replaced
+ * outright: its window setup belongs to the SwiftUI App struct now.
+ */
+function writeSceneDelegate(path, contents) {
+    if (!(0, fs_extra_1.existsSync)(path)) {
+        (0, fs_extra_1.writeFileSync)(path, contents);
+        return 'written';
+    }
+    if (!isStockSceneDelegate((0, fs_extra_1.readFileSync)(path, 'utf-8'))) {
+        return 'kept';
+    }
+    (0, fs_extra_1.writeFileSync)(path, contents);
+    return 'replaced';
+}
+/**
+ * Drop the storyboard the SwiftUI App struct replaces.
+ *
+ * Deregisters before unlinking so a pbxproj that cannot be rewritten leaves a working
+ * project behind rather than a dangling reference. LaunchScreen.storyboard stays: Apple
+ * still requires a launch storyboard.
+ */
+function removeLeftoverStoryboard(config) {
+    const pbxprojPath = (0, path_1.join)(config.ios.nativeXcodeProjDirAbs, 'project.pbxproj');
+    const mainStoryboardPath = (0, path_1.join)(config.ios.nativeTargetDirAbs, 'Base.lproj', 'Main.storyboard');
+    if ((0, fs_extra_1.existsSync)(mainStoryboardPath)) {
+        removeFile(pbxprojPath, mainStoryboardPath, () => (0, xcode_1.removeStoryboardFromAppTarget)(pbxprojPath, 'Main.storyboard'));
+    }
+}
+function removeFile(pbxprojPath, path, deregister) {
+    var _a;
+    try {
+        deregister();
+    }
+    catch (err) {
+        log_1.logger.warn(`Could not deregister ${path} from ${pbxprojPath}: ${(_a = err === null || err === void 0 ? void 0 : err.message) !== null && _a !== void 0 ? _a : err}. ` +
+            `Delete it from the App target in Xcode manually.`);
+        return;
+    }
+    (0, fs_extra_1.unlinkSync)(path);
+}
 async function scanAndWarn(config) {
     const findings = [];
     const swiftFiles = await (0, fs_1.readdirp)(config.ios.platformDirAbs, {
@@ -125,24 +250,87 @@ async function scanAndWarn(config) {
         log_1.logger.warn(`  ${finding}`);
     }
 }
-function hasCustomDelegateBody(source, sigRegex) {
+function hasCustomDelegateBody(source, sigRegex, proxyToken = 'ApplicationDelegateProxy.shared') {
+    const body = bracedBody(source, sigRegex);
+    if (body === null)
+        return false;
+    return codeLines(body).some((line) => !line.includes(proxyToken));
+}
+/**
+ * Whether SceneDelegate.swift still holds exactly what the 8.x template shipped, and so
+ * can be deleted without losing anything the developer wrote.
+ */
+function isStockSceneDelegate(source) {
+    const classBody = bracedBody(source, /\bclass\s+SceneDelegate\b/);
+    if (classBody === null)
+        return false;
+    const willConnectBody = bracedBody(classBody, SCENE_WILL_CONNECT_SIG);
+    if (willConnectBody !== null &&
+        !codeLines(willConnectBody).every((line) => STOCK_WILL_CONNECT_BODY.some((stock) => stock.test(line)))) {
+        return false;
+    }
+    if (hasCustomDelegateBody(classBody, SCENE_OPEN_URL_CONTEXTS_SIG, SCENE_DELEGATE_PROXY))
+        return false;
+    if (hasCustomDelegateBody(classBody, SCENE_CONTINUE_SIG, SCENE_DELEGATE_PROXY))
+        return false;
+    let members = classBody;
+    for (const sig of [SCENE_WILL_CONNECT_SIG, SCENE_OPEN_URL_CONTEXTS_SIG, SCENE_CONTINUE_SIG]) {
+        members = removeMethod(members, sig);
+        if (members === null)
+            return false;
+    }
+    return codeLines(members).every((line) => STOCK_WINDOW_PROPERTY.test(line));
+}
+/**
+ * Whether AppDelegate.swift still holds exactly what a Capacitor template shipped, across
+ * every stock shape from 5.x to 8.x, and so can be replaced outright with the 9.0 template
+ * rather than surgically rewritten.
+ *
+ * The 9.0 template keeps only didFinishLaunchingWithOptions: the empty lifecycle stubs are
+ * noise, and URL and universal-link routing moved to the SwiftUI scene body, which
+ * App.swift wires to SceneDelegateProxy in the same run.
+ */
+function isStockAppDelegate(source) {
+    if (!APP_DELEGATE_CLASS_SIG.test(source))
+        return false;
+    const classBody = bracedBody(source, APP_DELEGATE_CLASS_SIG);
+    if (classBody === null)
+        return false;
+    const outsideClass = source.slice(0, source.search(APP_DELEGATE_CLASS_SIG));
+    if (!codeLines(outsideClass).every((line) => STOCK_APP_DELEGATE_PREAMBLE.test(line))) {
+        return false;
+    }
+    let members = classBody;
+    for (const { sig, bodyIsStock } of STOCK_APP_DELEGATE_METHODS) {
+        const body = bracedBody(members, sig);
+        if (body !== null && !bodyIsStock(codeLines(body)))
+            return false;
+        members = removeMethod(members, sig);
+        if (members === null)
+            return false;
+    }
+    return codeLines(members).every((line) => STOCK_WINDOW_PROPERTY.test(line));
+}
+function isEmpty(lines) {
+    return lines.length === 0;
+}
+function bracedBody(source, sigRegex) {
     const match = source.match(sigRegex);
     if (!match || match.index === undefined)
-        return false;
+        return null;
     const openIdx = source.indexOf('{', match.index);
     if (openIdx === -1)
-        return false;
+        return null;
     const closeIdx = findMatchingBrace(source, openIdx);
     if (closeIdx === null)
-        return false;
-    const body = source.slice(openIdx + 1, closeIdx);
-    const codeLines = body
+        return null;
+    return source.slice(openIdx + 1, closeIdx);
+}
+function codeLines(body) {
+    return body
         .split('\n')
-        .map((l) => l.trim())
-        .filter((l) => l.length > 0 && !l.startsWith('//'));
-    if (codeLines.length === 0)
-        return false;
-    return codeLines.some((l) => !l.includes('ApplicationDelegateProxy.shared'));
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0 && !line.startsWith('//'));
 }
 function hasCustomWindowSetup(source) {
     return source.split('\n').some((line) => {
@@ -151,37 +339,34 @@ function hasCustomWindowSetup(source) {
             return false;
         if (trimmed.startsWith('//'))
             return false;
+        // The orientation forward only passes the window UIKit asks about along.
+        if (/\bsupportedInterfaceOrientationsFor\b/.test(trimmed))
+            return false;
         return !/^var\s+window\s*:\s*UIWindow\?$/.test(trimmed);
     });
 }
-function printNextSteps(config) {
+function printNextSteps() {
     log_1.logger.info('');
     log_1.logger.info('SwiftUI migration next steps:');
     log_1.logger.info('  • Review any warnings above for legacy API usage or custom AppDelegate URL/activity handlers.');
     log_1.logger.info('  • App.swift now owns the app entry point; move UIKit root-window customizations into its scene body.');
-    for (const leftover of leftoverUIKitFiles(config)) {
-        log_1.logger.info(`  • ${leftover} is no longer used by the app and can be deleted from the Xcode project.`);
-    }
-    log_1.logger.info('  • Full guide: https://capacitorjs.com/docs/next/updating/9-0');
+    log_1.logger.info(`  • Full guide: ${MIGRATION_GUIDE_URL}`);
 }
 function printManualSteps() {
     log_1.logger.info('');
     log_1.logger.info('Migrate the iOS project to the SwiftUI App-struct layout by hand:');
     log_1.logger.info('  • Add App.swift (an @main struct conforming to App) and CapacitorView.swift to the App target.');
-    log_1.logger.info('  • Drop @main, the UIWindow property, and configurationForConnecting from AppDelegate.');
+    log_1.logger.info('  • Drop @main and the UIWindow property from AppDelegate.');
+    log_1.logger.info('  • Add SceneDelegate.swift (an empty UIWindowSceneDelegate) to the App target, and keep or add');
+    log_1.logger.info('    configurationForConnecting in AppDelegate naming it as the scene delegate class.');
     log_1.logger.info('  • Reference AppDelegate from App.swift with @UIApplicationDelegateAdaptor.');
+    log_1.logger.info('  • Forward application(_:supportedInterfaceOrientationsFor:) in AppDelegate to');
+    log_1.logger.info('    ApplicationDelegateProxy.shared, so the bridge orientations (ScreenOrientation.lock()) apply.');
     log_1.logger.info('  • Reduce UIApplicationSceneManifest to UIApplicationSupportsMultipleScenes only.');
     log_1.logger.info('  • Remove UIMainStoryboardFile from Info.plist.');
     log_1.logger.info('  • Route URLs and universal links from the SwiftUI scene body through');
     log_1.logger.info('    SceneDelegateProxy.shared.handle(openURL:) and .handle(userActivity:).');
-    log_1.logger.info('  • Full guide: https://capacitorjs.com/docs/next/updating/9-0');
-}
-function leftoverUIKitFiles(config) {
-    const candidates = [
-        (0, path_1.join)(config.ios.nativeTargetDirAbs, 'SceneDelegate.swift'),
-        (0, path_1.join)(config.ios.nativeTargetDirAbs, 'Base.lproj', 'Main.storyboard'),
-    ];
-    return candidates.filter((path) => (0, fs_extra_1.existsSync)(path));
+    log_1.logger.info(`  • Full guide: ${MIGRATION_GUIDE_URL}`);
 }
 async function loadTemplateAssets(config) {
     const packageManager = await config.ios.packageManager;
@@ -191,13 +376,18 @@ async function loadTemplateAssets(config) {
     try {
         await (0, template_1.extractTemplate)(archivePath, tempDir);
         const appPath = (0, path_1.join)(tempDir, 'App', 'App', 'App.swift');
+        const appDelegatePath = (0, path_1.join)(tempDir, 'App', 'App', 'AppDelegate.swift');
         const capacitorViewPath = (0, path_1.join)(tempDir, 'App', 'App', 'CapacitorView.swift');
-        if (!(0, fs_extra_1.existsSync)(appPath) || !(0, fs_extra_1.existsSync)(capacitorViewPath)) {
+        const sceneDelegatePath = (0, path_1.join)(tempDir, 'App', 'App', 'SceneDelegate.swift');
+        const paths = [appPath, appDelegatePath, capacitorViewPath, sceneDelegatePath];
+        if (paths.some((path) => !(0, fs_extra_1.existsSync)(path))) {
             return null;
         }
         return {
             app: (0, fs_extra_1.readFileSync)(appPath, 'utf-8'),
+            appDelegate: (0, fs_extra_1.readFileSync)(appDelegatePath, 'utf-8'),
             capacitorView: (0, fs_extra_1.readFileSync)(capacitorViewPath, 'utf-8'),
+            sceneDelegate: (0, fs_extra_1.readFileSync)(sceneDelegatePath, 'utf-8'),
         };
     }
     finally {
@@ -245,11 +435,93 @@ function rewriteAppDelegateForAdaptor(source) {
     let rewritten = stripMainAttribute(source);
     rewritten = rewritten.replace(/(\bclass\s+AppDelegate\s*:\s*)UIResponder\b/, '$1NSObject');
     rewritten = rewritten.replace(/^[ \t]*var\s+window\s*:\s*UIWindow\?[ \t]*\r?\n(?:[ \t]*\r?\n)?/m, '');
-    const withoutSceneConfiguration = removeMethod(rewritten, CONFIGURATION_FOR_CONNECTING_SIG);
-    if (withoutSceneConfiguration === null) {
-        return { status: 'skipped', reason: 'could not parse the configurationForConnecting method in AppDelegate.swift.' };
+    // UIKit stops calling these two once the app is scene-based, so leaving them behind
+    // would plant dead code a developer could mistake for live routing. Both bodies are
+    // known to hold nothing but ApplicationDelegateProxy calls by the guard above; App.swift
+    // re-routes them through SceneDelegateProxy in the same run.
+    const sigs = [OPEN_URL_SIG, CONTINUE_SIG];
+    const names = ['application(_:open:)', 'application(_:continue:)'];
+    let stripped = rewritten;
+    for (const [index, sig] of sigs.entries()) {
+        stripped = removeMethod(stripped, sig);
+        if (stripped === null) {
+            return { status: 'skipped', reason: `could not parse the ${names[index]} method in AppDelegate.swift.` };
+        }
+    }
+    const wired = ensureConfigurationForConnecting(stripped);
+    const forwarded = wired === null ? null : ensureSupportedInterfaceOrientations(wired);
+    if (forwarded === null) {
+        return { status: 'skipped', reason: 'could not find the end of the AppDelegate class in AppDelegate.swift.' };
+    }
+    return { status: 'rewritten', source: forwarded };
+}
+/**
+ * Give the AppDelegate the scene configuration that names SceneDelegate.
+ *
+ * An 8.5 project already has one and keeps it — the class name it points at has not
+ * changed. Anything older gains the 9.0 template's version, because without it UIKit
+ * builds the scene with no delegate of ours and nothing can answer per-scene callbacks.
+ */
+function ensureConfigurationForConnecting(source) {
+    return ensureAppDelegateMethod(source, CONFIGURATION_FOR_CONNECTING_SIG, CONFIGURATION_FOR_CONNECTING_METHOD);
+}
+/**
+ * Forward the window's supported interface orientations to Capacitor.
+ *
+ * In the SwiftUI App-struct layout the bridge is not the window's root view controller, so
+ * UIKit only picks up its orientations, ScreenOrientation.lock() included, through the app
+ * delegate. A developer's own implementation is kept as it is.
+ */
+function ensureSupportedInterfaceOrientations(source) {
+    const forwarded = ensureAppDelegateMethod(source, SUPPORTED_INTERFACE_ORIENTATIONS_SIG, SUPPORTED_INTERFACE_ORIENTATIONS_METHOD);
+    if (forwarded === null || forwarded === source || /^import\s+Capacitor\b/m.test(forwarded)) {
+        return forwarded;
     }
-    return { status: 'rewritten', source: withoutSceneConfiguration };
+    // ApplicationDelegateProxy lives in Capacitor, which a converted AppDelegate may not import yet.
+    const uiKitImport = /^import\s+UIKit\b.*$/m;
+    return uiKitImport.test(forwarded)
+        ? forwarded.replace(uiKitImport, '$&\nimport Capacitor')
+        : `import Capacitor\n${forwarded}`;
+}
+/**
+ * Append `method` at the end of the AppDelegate class, unless a method matching `sig` is
+ * already there. Returns null when the class body cannot be parsed.
+ */
+function ensureAppDelegateMethod(source, sig, method) {
+    // Located even when the method is already there: an unbalanced class body used to be
+    // caught by the strip this replaced, and reporting success on a file we cannot parse
+    // is worse than refusing it.
+    const match = source.match(/\bclass\s+AppDelegate\b/);
+    if (!match || match.index === undefined)
+        return null;
+    const openIdx = source.indexOf('{', match.index);
+    if (openIdx === -1)
+        return null;
+    const closeIdx = findMatchingBrace(source, openIdx);
+    if (closeIdx === null)
+        return null;
+    if (sig.test(source)) {
+        return source;
+    }
+    // Trailing blank lines before the closing brace would otherwise stack up with the separator.
+    const head = source.slice(0, closeIdx).replace(/\s*$/, '');
+    return `${head}\n\n${method}\n${source.slice(closeIdx)}`;
+}
+/**
+ * Projects migrated before the orientation forward existed are already on the SwiftUI layout,
+ * so the rest of this migration skips them; give them the forward on their next run.
+ */
+async function forwardSupportedInterfaceOrientations(config) {
+    const appDelegatePath = (0, path_1.join)(config.ios.nativeTargetDirAbs, 'AppDelegate.swift');
+    if (!(0, fs_extra_1.existsSync)(appDelegatePath))
+        return;
+    const source = (0, fs_extra_1.readFileSync)(appDelegatePath, 'utf-8');
+    const forwarded = ensureSupportedInterfaceOrientations(source);
+    if (forwarded === null || forwarded === source)
+        return;
+    await (0, common_1.runTask)('Forwarding supported interface orientations from AppDelegate.swift to Capacitor.', async () => {
+        (0, fs_extra_1.writeFileSync)(appDelegatePath, forwarded);
+    });
 }
 function stripMainAttribute(source) {
     return source.replace(/@(?:main|UIApplicationMain)[ \t]*(?:\r?\n[ \t]*)?(?=class\s+AppDelegate\b)/, '');
@@ -299,37 +571,55 @@ function readDetectionSignals(config) {
     const appStructPath = (0, path_1.join)(config.ios.nativeTargetDirAbs, 'App.swift');
     const capacitorViewPath = (0, path_1.join)(config.ios.nativeTargetDirAbs, 'CapacitorView.swift');
     const appDelegatePath = (0, path_1.join)(config.ios.nativeTargetDirAbs, 'AppDelegate.swift');
+    const sceneDelegatePath = (0, path_1.join)(config.ios.nativeTargetDirAbs, 'SceneDelegate.swift');
     return {
         hasSwiftUIManifest: (0, spm_1.hasSwiftUISceneManifest)(config),
         hasAppStruct: (0, fs_extra_1.existsSync)(appStructPath) && /struct\s+\w+\s*:\s*App\b/.test((0, fs_extra_1.readFileSync)(appStructPath, 'utf-8')),
         hasCapacitorView: (0, fs_extra_1.existsSync)(capacitorViewPath),
         hasDelegateAdaptorShape: (0, fs_extra_1.existsSync)(appDelegatePath) && !/@(?:main|UIApplicationMain)\b/.test((0, fs_extra_1.readFileSync)(appDelegatePath, 'utf-8')),
+        // A project migrated before the scene delegate landed has every other marker but no
+        // SceneDelegate.swift, so it reads as eligible and the next run completes it.
+        hasSceneDelegate: (0, fs_extra_1.existsSync)(sceneDelegatePath) &&
+            (0, fs_extra_1.existsSync)(appDelegatePath) &&
+            CONFIGURATION_FOR_CONNECTING_SIG.test((0, fs_extra_1.readFileSync)(appDelegatePath, 'utf-8')),
     };
 }
+/**
+ * Anything short of all five signals is eligible, not refused: every step below is
+ * individually idempotent, so a run interrupted part-way is finished by running again.
+ */
 function classify(signals) {
-    const { hasSwiftUIManifest, hasAppStruct, hasCapacitorView, hasDelegateAdaptorShape } = signals;
-    const trueCount = [hasSwiftUIManifest, hasAppStruct, hasCapacitorView, hasDelegateAdaptorShape].filter(Boolean).length;
-    if (trueCount === 0)
-        return 'eligible';
-    if (trueCount === 4)
-        return 'already-migrated';
-    return 'partial';
+    return signalValues(signals).every(Boolean) ? 'already-migrated' : 'eligible';
+}
+function hasAnySignal(signals) {
+    return signalValues(signals).some(Boolean);
+}
+function signalValues({ hasSwiftUIManifest, hasAppStruct, hasCapacitorView, hasDelegateAdaptorShape, hasSceneDelegate, }) {
+    return [hasSwiftUIManifest, hasAppStruct, hasCapacitorView, hasDelegateAdaptorShape, hasSceneDelegate];
 }
-function describeSignals({ hasSwiftUIManifest, hasAppStruct, hasCapacitorView, hasDelegateAdaptorShape, }) {
+function describeSignals({ hasSwiftUIManifest, hasAppStruct, hasCapacitorView, hasDelegateAdaptorShape, hasSceneDelegate, }) {
     const present = [];
     const missing = [];
     (hasSwiftUIManifest ? present : missing).push('SwiftUI UIApplicationSceneManifest');
     (hasAppStruct ? present : missing).push('App.swift');
     (hasCapacitorView ? present : missing).push('CapacitorView.swift');
     (hasDelegateAdaptorShape ? present : missing).push('AppDelegate without @main');
+    (hasSceneDelegate ? present : missing).push('SceneDelegate.swift');
     return `present: [${present.join(', ')}]; missing: [${missing.join(', ')}]`;
 }
 // Exported for tests.
 exports.__testables = {
+    CONFIGURATION_FOR_CONNECTING_METHOD,
+    SUPPORTED_INTERFACE_ORIENTATIONS_METHOD,
     classify,
     describeSignals,
+    ensureSupportedInterfaceOrientations,
     hasCustomDelegateBody,
     hasCustomWindowSetup,
+    isStockAppDelegate,
+    isStockSceneDelegate,
+    removeLeftoverStoryboard,
     rewriteAppDelegateForAdaptor,
     scanAndWarn,
+    writeSceneDelegate,
 };

package/dist/tasks/migrate-to-modern-project.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.migrateToModernProject = void 0;
+const path_1 = require("path");
+const log_1 = require("../log");
+const xcode_1 = require("../util/xcode");
+async function migrateToModernProject(config) {
+    var _a;
+    const pbxprojPath = (0, path_1.join)(config.ios.nativeXcodeProjDirAbs, 'project.pbxproj');
+    const settingsToAdd = {
+        CLANG_WARN_DEPRECATED_OBJC_IMPLEMENTATIONS: 'YES',
+        CLANG_WARN_OBJC_IMPLICIT_RETAIN_SELF: 'YES',
+        CLANG_WARN_QUOTED_INCLUDE_IN_FRAMEWORK_HEADER: 'YES',
+        STRING_CATALOG_GENERATE_SYMBOLS: 'YES',
+    };
+    if ((await config.ios.packageManager) === 'SPM') {
+        settingsToAdd['ENABLE_USER_SCRIPT_SANDBOXING'] = 'YES';
+    }
+    try {
+        (0, xcode_1.addMultipleBuildSettings)(pbxprojPath, settingsToAdd);
+    }
+    catch (err) {
+        log_1.logger.warn(`Could not update the project ${pbxprojPath} to latest apple recomendations: ${(_a = err === null || err === void 0 ? void 0 : err.message) !== null && _a !== void 0 ? _a : err}. ` +
+            `You can manually do so in Xcode`);
+    }
+}
+exports.migrateToModernProject = migrateToModernProject;