@capacitor-plus/cli 8.0.0-beta.0

package/dist/util/livereload.js

@@ -0,0 +1,148 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CapLiveReloadHelper = void 0;
+const fs_extra_1 = require("fs-extra");
+const os_1 = require("os");
+const path_1 = require("path");
+class CapLiveReload {
+    constructor() {
+        this.configJsonToRevertTo = {
+            json: null,
+            platformPath: null,
+        };
+        // nothing to do
+    }
+    getIpAddress(name, family) {
+        var _a;
+        const interfaces = (_a = (0, os_1.networkInterfaces)()) !== null && _a !== void 0 ? _a : {};
+        const _normalizeFamily = (family) => {
+            if (family === 4) {
+                return 'ipv4';
+            }
+            if (family === 6) {
+                return 'ipv6';
+            }
+            return family ? family.toLowerCase() : 'ipv4';
+        };
+        const isLoopback = (addr) => {
+            return (/^(::f{4}:)?127\.([0-9]{1,3})\.([0-9]{1,3})\.([0-9]{1,3})/.test(addr) ||
+                /^fe80::1$/.test(addr) ||
+                /^::1$/.test(addr) ||
+                /^::$/.test(addr));
+        };
+        const isPrivate = (addr) => {
+            return (/^(::f{4}:)?10\.([0-9]{1,3})\.([0-9]{1,3})\.([0-9]{1,3})$/i.test(addr) ||
+                /^(::f{4}:)?192\.168\.([0-9]{1,3})\.([0-9]{1,3})$/i.test(addr) ||
+                /^(::f{4}:)?172\.(1[6-9]|2\d|30|31)\.([0-9]{1,3})\.([0-9]{1,3})$/i.test(addr) ||
+                /^(::f{4}:)?127\.([0-9]{1,3})\.([0-9]{1,3})\.([0-9]{1,3})$/i.test(addr) ||
+                /^(::f{4}:)?169\.254\.([0-9]{1,3})\.([0-9]{1,3})$/i.test(addr) ||
+                /^f[cd][0-9a-f]{2}:/i.test(addr) ||
+                /^fe80:/i.test(addr) ||
+                /^::1$/.test(addr) ||
+                /^::$/.test(addr));
+        };
+        const isPublic = (addr) => {
+            return !isPrivate(addr);
+        };
+        const loopback = (family) => {
+            //
+            // Default to `ipv4`
+            //
+            family = _normalizeFamily(family);
+            if (family !== 'ipv4' && family !== 'ipv6') {
+                throw new Error('family must be ipv4 or ipv6');
+            }
+            return family === 'ipv4' ? '127.0.0.1' : 'fe80::1';
+        };
+        //
+        // Default to `ipv4`
+        //
+        family = _normalizeFamily(family);
+        //
+        // If a specific network interface has been named,
+        // return the address.
+        //
+        if (name && name !== 'private' && name !== 'public') {
+            const res = interfaces[name].filter((details) => {
+                const itemFamily = _normalizeFamily(details.family);
+                return itemFamily === family;
+            });
+            if (res.length === 0) {
+                return undefined;
+            }
+            return res[0].address;
+        }
+        const all = Object.keys(interfaces)
+            .map((nic) => {
+            //
+            // Note: name will only be `public` or `private`
+            // when this is called.
+            //
+            const addresses = interfaces[nic].filter((details) => {
+                details.family = _normalizeFamily(details.family);
+                if (details.family !== family || isLoopback(details.address)) {
+                    return false;
+                }
+                if (!name) {
+                    return true;
+                }
+                return name === 'public' ? isPrivate(details.address) : isPublic(details.address);
+            });
+            return addresses.length ? addresses[0].address : undefined;
+        })
+            .filter(Boolean);
+        return !all.length ? loopback(family) : all[0];
+    }
+    // TODO remove on next major as it's unused
+    async editExtConfigForLiveReload(config, platformName, options, rootConfigChange = false) {
+        const platformAbsPath = platformName == config.ios.name
+            ? config.ios.nativeTargetDirAbs
+            : platformName == config.android.name
+                ? config.android.assetsDirAbs
+                : null;
+        if (platformAbsPath == null)
+            throw new Error('Platform not found.');
+        const capConfigPath = rootConfigChange
+            ? config.app.extConfigFilePath
+            : (0, path_1.join)(platformAbsPath, 'capacitor.config.json');
+        const configJson = { ...config.app.extConfig };
+        this.configJsonToRevertTo.json = JSON.stringify(configJson, null, 2);
+        this.configJsonToRevertTo.platformPath = capConfigPath;
+        const url = `http://${options.host}:${options.port}`;
+        configJson.server = {
+            url,
+        };
+        return configJson;
+    }
+    // TODO remove rootConfigChange param on next major as it's unused
+    async editCapConfigForLiveReload(config, platformName, options, rootConfigChange = false) {
+        const platformAbsPath = platformName == config.ios.name
+            ? config.ios.nativeTargetDirAbs
+            : platformName == config.android.name
+                ? config.android.assetsDirAbs
+                : null;
+        if (platformAbsPath == null)
+            throw new Error('Platform not found.');
+        const capConfigPath = rootConfigChange
+            ? config.app.extConfigFilePath
+            : (0, path_1.join)(platformAbsPath, 'capacitor.config.json');
+        const configJson = (0, fs_extra_1.readJSONSync)(capConfigPath);
+        this.configJsonToRevertTo.json = JSON.stringify(configJson, null, 2);
+        this.configJsonToRevertTo.platformPath = capConfigPath;
+        const url = `http://${options.host}:${options.port}`;
+        configJson.server = {
+            url,
+        };
+        (0, fs_extra_1.writeJSONSync)(capConfigPath, configJson, { spaces: '\t' });
+    }
+    async revertCapConfigForLiveReload() {
+        if (this.configJsonToRevertTo.json == null || this.configJsonToRevertTo.platformPath == null)
+            return;
+        const capConfigPath = this.configJsonToRevertTo.platformPath;
+        const configJson = this.configJsonToRevertTo.json;
+        (0, fs_extra_1.writeJSONSync)(capConfigPath, JSON.parse(configJson), { spaces: '\t' });
+        this.configJsonToRevertTo.json = null;
+        this.configJsonToRevertTo.platformPath = null;
+    }
+}
+exports.CapLiveReloadHelper = new CapLiveReload();

package/dist/util/monorepotools.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isNXMonorepo = exports.isMonorepo = exports.findPackageRelativePathInMonorepo = exports.findPackagePath = exports.findNXMonorepoRoot = exports.findMonorepoRoot = void 0;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+/**
+ * Finds the monorepo root from the given path.
+ * @param currentPath - The current path to start searching from.
+ * @returns The path to the monorepo root.
+ * @throws An error if the monorepo root is not found.
+ */
+function findMonorepoRoot(currentPath) {
+    const packageJsonPath = (0, node_path_1.join)(currentPath, 'package.json');
+    const pnpmWorkspacePath = (0, node_path_1.join)(currentPath, 'pnpm-workspace.yaml');
+    if ((0, node_fs_1.existsSync)(pnpmWorkspacePath) ||
+        ((0, node_fs_1.existsSync)(packageJsonPath) && JSON.parse((0, node_fs_1.readFileSync)(packageJsonPath, 'utf-8')).workspaces)) {
+        return currentPath;
+    }
+    const parentPath = (0, node_path_1.dirname)(currentPath);
+    if (parentPath === currentPath) {
+        throw new Error('Monorepo root not found');
+    }
+    return findMonorepoRoot(parentPath);
+}
+exports.findMonorepoRoot = findMonorepoRoot;
+/**
+ * Finds the NX monorepo root from the given path.
+ * @param currentPath - The current path to start searching from.
+ * @returns The path to the monorepo root.
+ * @throws An error if the monorepo root is not found.
+ */
+function findNXMonorepoRoot(currentPath) {
+    const nxJsonPath = (0, node_path_1.join)(currentPath, 'nx.json');
+    if ((0, node_fs_1.existsSync)(nxJsonPath)) {
+        return currentPath;
+    }
+    const parentPath = (0, node_path_1.dirname)(currentPath);
+    if (parentPath === currentPath) {
+        throw new Error('Monorepo root not found');
+    }
+    return findNXMonorepoRoot(parentPath);
+}
+exports.findNXMonorepoRoot = findNXMonorepoRoot;
+/**
+ * Finds the path to a package within the node_modules folder,
+ * searching up the directory hierarchy until the last possible directory is reached.
+ * @param packageName - The name of the package to find.
+ * @param currentPath - The current path to start searching from.
+ * @param lastPossibleDirectory - The last possible directory to search for the package.
+ * @returns The path to the package, or null if not found.
+ */
+function findPackagePath(packageName, currentPath, lastPossibleDirectory) {
+    const nodeModulesPath = (0, node_path_1.join)(currentPath, 'node_modules', packageName);
+    if ((0, node_fs_1.existsSync)(nodeModulesPath)) {
+        return nodeModulesPath;
+    }
+    if (currentPath === lastPossibleDirectory) {
+        return null;
+    }
+    const parentPath = (0, node_path_1.dirname)(currentPath);
+    return findPackagePath(packageName, parentPath, lastPossibleDirectory);
+}
+exports.findPackagePath = findPackagePath;
+/**
+ * Finds the relative path to a package from the current directory,
+ * using the monorepo root as the last possible directory.
+ * @param packageName - The name of the package to find.
+ * @param currentPath - The current path to start searching from.
+ * @returns The relative path to the package, or null if not found.
+ */
+function findPackageRelativePathInMonorepo(packageName, currentPath) {
+    const monorepoRoot = findMonorepoRoot(currentPath);
+    const packagePath = findPackagePath(packageName, currentPath, monorepoRoot);
+    if (packagePath) {
+        return (0, node_path_1.relative)(currentPath, packagePath);
+    }
+    return null;
+}
+exports.findPackageRelativePathInMonorepo = findPackageRelativePathInMonorepo;
+/**
+ * Detects if the current directory is part of a monorepo (npm, yarn, pnpm).
+ * @param currentPath - The current path to start searching from.
+ * @returns True if the current directory is part of a monorepo, false otherwise.
+ */
+function isMonorepo(currentPath) {
+    try {
+        findMonorepoRoot(currentPath);
+        return true;
+    }
+    catch (error) {
+        return false;
+    }
+}
+exports.isMonorepo = isMonorepo;
+/**
+ * Detects if the current directory is part of a nx integrated monorepo.
+ * @param currentPath - The current path to start searching from.
+ * @returns True if the current directory is part of a monorepo, false otherwise.
+ */
+function isNXMonorepo(currentPath) {
+    try {
+        findNXMonorepoRoot(currentPath);
+        return true;
+    }
+    catch (error) {
+        return false;
+    }
+}
+exports.isNXMonorepo = isNXMonorepo;

package/dist/util/native-run.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPlatformTargets = exports.runNativeRun = void 0;
+const tslib_1 = require("tslib");
+const path_1 = require("path");
+const colors_1 = tslib_1.__importDefault(require("../colors"));
+const errors_1 = require("../errors");
+const log_1 = require("../log");
+const node_1 = require("./node");
+const subprocess_1 = require("./subprocess");
+async function runNativeRun(args, options = {}) {
+    const p = (0, node_1.resolveNode)(__dirname, (0, path_1.dirname)('native-run/package'), 'bin/native-run');
+    if (!p) {
+        (0, errors_1.fatal)(`${colors_1.default.input('native-run')} not found.`);
+    }
+    if (process.versions.pnp) {
+        return await (0, subprocess_1.runCommand)('yarn', ['node', p, ...args], options);
+    }
+    else {
+        return await (0, subprocess_1.runCommand)(p, args, options);
+    }
+}
+exports.runNativeRun = runNativeRun;
+async function getPlatformTargets(platformName) {
+    const errors = [];
+    try {
+        const output = await runNativeRun([platformName, '--list', '--json']);
+        const parsedOutput = JSON.parse(output);
+        if (parsedOutput.devices.length || parsedOutput.virtualDevices.length) {
+            return [
+                ...parsedOutput.devices.map((t) => ({ ...t, virtual: false })),
+                ...parsedOutput.virtualDevices.map((t) => ({
+                    ...t,
+                    virtual: true,
+                })),
+            ];
+        }
+        else {
+            parsedOutput.errors.map((e) => {
+                errors.push(e);
+            });
+        }
+    }
+    catch (e) {
+        const err = JSON.parse(e);
+        errors.push(err);
+    }
+    if (errors.length === 0) {
+        log_1.logger.info('No devices found.');
+        return [];
+    }
+    const plural = errors.length > 1 ? 's' : '';
+    const errMsg = `${colors_1.default.strong('native-run')} failed with error${plural}\n
+  ${errors
+        .map((e) => {
+        return `\t${colors_1.default.strong(e.code)}: ${e.error}`;
+    })
+        .join('\n')}
+  \n\tMore details for this error${plural} may be available online: ${colors_1.default.strong('https://github.com/ionic-team/native-run/wiki/Android-Errors')}
+  `;
+    throw errMsg;
+}
+exports.getPlatformTargets = getPlatformTargets;

package/dist/util/node.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveNode = exports.requireTS = void 0;
+const fs_1 = require("fs");
+const fs_extra_1 = require("fs-extra");
+const path_1 = require("path");
+/**
+ * @see https://github.com/ionic-team/stencil/blob/HEAD/src/compiler/sys/node-require.ts
+ */
+const requireTS = (ts, p) => {
+    const id = (0, path_1.resolve)(p);
+    delete require.cache[id];
+    require.extensions['.ts'] = (module, fileName) => {
+        var _a;
+        let sourceText = (0, fs_extra_1.readFileSync)(fileName, 'utf8');
+        if (fileName.endsWith('.ts')) {
+            const tsResults = ts.transpileModule(sourceText, {
+                fileName,
+                compilerOptions: {
+                    module: ts.ModuleKind.CommonJS,
+                    moduleResolution: ts.ModuleResolutionKind.NodeJs,
+                    esModuleInterop: true,
+                    strict: true,
+                    target: ts.ScriptTarget.ES2017,
+                },
+                reportDiagnostics: true,
+            });
+            sourceText = tsResults.outputText;
+        }
+        else {
+            // quick hack to turn a modern es module
+            // into and old school commonjs module
+            sourceText = sourceText.replace(/export\s+\w+\s+(\w+)/gm, 'exports.$1');
+        }
+        (_a = module._compile) === null || _a === void 0 ? void 0 : _a.call(module, sourceText, fileName);
+    };
+    const m = require(id); // eslint-disable-line @typescript-eslint/no-var-requires
+    delete require.extensions['.ts'];
+    return m;
+};
+exports.requireTS = requireTS;
+function resolveNode(root, ...pathSegments) {
+    try {
+        return require.resolve(pathSegments.join('/'), { paths: [root] });
+    }
+    catch (e) {
+        const path = [root, 'node_modules', ...pathSegments].join('/');
+        if ((0, fs_1.existsSync)(path)) {
+            return path;
+        }
+        return null;
+    }
+}
+exports.resolveNode = resolveNode;

package/dist/util/promise.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lazy = exports.LazyPromise = exports.allSerial = void 0;
+function allSerial(funcs) {
+    return funcs.reduce((promise, func) => promise.then((result) => func().then((x) => result.concat(x))), Promise.resolve([]));
+}
+exports.allSerial = allSerial;
+class LazyPromise extends Promise {
+    constructor(executor) {
+        super(() => {
+            /* ignore */
+        });
+        this._executor = executor;
+    }
+    then(onfulfilled, onrejected) {
+        this._promise = this._promise || new Promise(this._executor);
+        return this._promise.then(onfulfilled, onrejected);
+    }
+    catch(onrejected) {
+        this._promise = this._promise || new Promise(this._executor);
+        return this._promise.catch(onrejected);
+    }
+}
+exports.LazyPromise = LazyPromise;
+function lazy(fn) {
+    return new LazyPromise(async (resolve, reject) => {
+        try {
+            resolve(await fn());
+        }
+        catch (e) {
+            reject(e);
+        }
+    });
+}
+exports.lazy = lazy;

package/dist/util/spm.js

@@ -0,0 +1,187 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addInfoPlistDebugIfNeeded = exports.runCocoapodsDeintegrate = exports.generatePackageText = exports.removeCocoapodsFiles = exports.extractSPMPackageDirectory = exports.checkPluginsForPackageSwift = exports.generatePackageFile = exports.findPackageSwiftFile = exports.checkPackageManager = void 0;
+const fs_extra_1 = require("fs-extra");
+const os_1 = require("os");
+const path_1 = require("path");
+const plist_1 = require("plist");
+const tar_1 = require("tar");
+const common_1 = require("../common");
+const errors_1 = require("../errors");
+const common_2 = require("../ios/common");
+const log_1 = require("../log");
+const plugin_1 = require("../plugin");
+const subprocess_1 = require("../util/subprocess");
+async function checkPackageManager(config) {
+    const iosDirectory = config.ios.nativeProjectDirAbs;
+    if ((0, fs_extra_1.existsSync)((0, path_1.resolve)(iosDirectory, 'CapApp-SPM'))) {
+        return 'SPM';
+    }
+    return 'Cocoapods';
+}
+exports.checkPackageManager = checkPackageManager;
+async function findPackageSwiftFile(config) {
+    const packageDirectory = (0, path_1.resolve)(config.ios.nativeProjectDirAbs, 'CapApp-SPM');
+    return (0, path_1.resolve)(packageDirectory, 'Package.swift');
+}
+exports.findPackageSwiftFile = findPackageSwiftFile;
+async function generatePackageFile(config, plugins) {
+    const packageSwiftFile = await findPackageSwiftFile(config);
+    try {
+        log_1.logger.info('Writing Package.swift');
+        const textToWrite = await generatePackageText(config, plugins);
+        (0, fs_extra_1.writeFileSync)(packageSwiftFile, textToWrite);
+    }
+    catch (err) {
+        log_1.logger.error(`Unable to write to ${packageSwiftFile}. Verify it is not already open. \n Error: ${err}`);
+    }
+}
+exports.generatePackageFile = generatePackageFile;
+async function checkPluginsForPackageSwift(config, plugins) {
+    const iOSCapacitorPlugins = plugins.filter((p) => (0, plugin_1.getPluginType)(p, 'ios') === 0 /* PluginType.Core */);
+    const packageSwiftPluginList = await pluginsWithPackageSwift(iOSCapacitorPlugins);
+    if (plugins.length == packageSwiftPluginList.length) {
+        log_1.logger.debug(`Found ${plugins.length} iOS plugins, ${packageSwiftPluginList.length} have a Package.swift file`);
+        log_1.logger.info('All plugins have a Package.swift file and will be included in Package.swift');
+    }
+    else {
+        log_1.logger.warn('Some installed packages are not compatable with SPM');
+    }
+    return packageSwiftPluginList;
+}
+exports.checkPluginsForPackageSwift = checkPluginsForPackageSwift;
+async function extractSPMPackageDirectory(config) {
+    const spmDirectory = (0, path_1.join)(config.ios.nativeProjectDirAbs, 'CapApp-SPM');
+    const spmTemplate = (0, path_1.join)(config.cli.assetsDirAbs, 'ios-spm-template.tar.gz');
+    const debugConfig = (0, path_1.join)(config.ios.platformDirAbs, 'debug.xcconfig');
+    log_1.logger.info('Extracting ' + spmTemplate + ' to ' + spmDirectory);
+    try {
+        const tempCapDir = await (0, fs_extra_1.mkdtemp)((0, path_1.join)((0, os_1.tmpdir)(), 'cap-'));
+        const tempCapSPM = (0, path_1.join)(tempCapDir, 'App', 'CapApp-SPM');
+        const tempDebugXCConfig = (0, path_1.join)(tempCapDir, 'debug.xcconfig');
+        await (0, tar_1.extract)({ file: spmTemplate, cwd: tempCapDir });
+        await (0, fs_extra_1.move)(tempCapSPM, spmDirectory);
+        await (0, fs_extra_1.move)(tempDebugXCConfig, debugConfig);
+    }
+    catch (err) {
+        (0, errors_1.fatal)('Failed to create ' + spmDirectory + ' with error: ' + err);
+    }
+}
+exports.extractSPMPackageDirectory = extractSPMPackageDirectory;
+async function removeCocoapodsFiles(config) {
+    const iosDirectory = config.ios.nativeProjectDirAbs;
+    const podFile = (0, path_1.resolve)(iosDirectory, 'Podfile');
+    const podlockFile = (0, path_1.resolve)(iosDirectory, 'Podfile.lock');
+    const xcworkspaceFile = (0, path_1.resolve)(iosDirectory, 'App.xcworkspace');
+    await (0, fs_extra_1.remove)(podFile);
+    await (0, fs_extra_1.remove)(podlockFile);
+    await (0, fs_extra_1.remove)(xcworkspaceFile);
+}
+exports.removeCocoapodsFiles = removeCocoapodsFiles;
+async function generatePackageText(config, plugins) {
+    var _a, _b, _c;
+    const iosPlatformVersion = await (0, common_1.getCapacitorPackageVersion)(config, config.ios.name);
+    const iosVersion = (0, common_2.getMajoriOSVersion)(config);
+    let packageSwiftText = `// swift-tools-version: 5.9
+import PackageDescription
+
+// DO NOT MODIFY THIS FILE - managed by Capacitor CLI commands
+let package = Package(
+    name: "CapApp-SPM",
+    platforms: [.iOS(.v${iosVersion})],
+    products: [
+        .library(
+            name: "CapApp-SPM",
+            targets: ["CapApp-SPM"])
+    ],
+    dependencies: [
+        .package(url: "https://github.com/ionic-team/capacitor-swift-pm.git", exact: "${iosPlatformVersion}")`;
+    for (const plugin of plugins) {
+        if ((0, plugin_1.getPluginType)(plugin, config.ios.name) === 1 /* PluginType.Cordova */) {
+            packageSwiftText += `,\n        .package(name: "${plugin.name}", path: "../../capacitor-cordova-ios-plugins/sources/${plugin.name}")`;
+        }
+        else {
+            const relPath = (0, path_1.relative)(config.ios.nativeXcodeProjDirAbs, plugin.rootPath);
+            packageSwiftText += `,\n        .package(name: "${(_a = plugin.ios) === null || _a === void 0 ? void 0 : _a.name}", path: "${relPath}")`;
+        }
+    }
+    packageSwiftText += `
+    ],
+    targets: [
+        .target(
+            name: "CapApp-SPM",
+            dependencies: [
+                .product(name: "Capacitor", package: "capacitor-swift-pm"),
+                .product(name: "Cordova", package: "capacitor-swift-pm")`;
+    for (const plugin of plugins) {
+        packageSwiftText += `,\n                .product(name: "${(_b = plugin.ios) === null || _b === void 0 ? void 0 : _b.name}", package: "${(_c = plugin.ios) === null || _c === void 0 ? void 0 : _c.name}")`;
+    }
+    packageSwiftText += `
+            ]
+        )
+    ]
+)
+`;
+    return packageSwiftText;
+}
+exports.generatePackageText = generatePackageText;
+async function runCocoapodsDeintegrate(config) {
+    const podPath = await config.ios.podPath;
+    const projectFileName = config.ios.nativeXcodeProjDirAbs;
+    const useBundler = podPath.startsWith('bundle') && (await (0, subprocess_1.isInstalled)('bundle'));
+    const podCommandExists = await (0, subprocess_1.isInstalled)('pod');
+    if (useBundler)
+        log_1.logger.info('Found bundler, using it to run CocoaPods.');
+    log_1.logger.info('Running pod deintegrate on project ' + projectFileName);
+    if (useBundler || podCommandExists) {
+        if (useBundler) {
+            await (0, subprocess_1.runCommand)('bundle', ['exec', 'pod', 'deintegrate', projectFileName], {
+                cwd: config.ios.nativeProjectDirAbs,
+            });
+        }
+        else {
+            await (0, subprocess_1.runCommand)(podPath, ['deintegrate', projectFileName], {
+                cwd: config.ios.nativeProjectDirAbs,
+            });
+        }
+    }
+    else {
+        log_1.logger.warn('Skipping pod deintegrate because CocoaPods is not installed - migration will be incomplete');
+    }
+}
+exports.runCocoapodsDeintegrate = runCocoapodsDeintegrate;
+async function addInfoPlistDebugIfNeeded(config) {
+    const infoPlist = (0, path_1.resolve)(config.ios.nativeTargetDirAbs, 'Info.plist');
+    log_1.logger.info('Checking ' + infoPlist + ' for CAPACITOR_DEBUG');
+    if ((0, fs_extra_1.existsSync)(infoPlist)) {
+        const infoPlistContents = (0, fs_extra_1.readFileSync)(infoPlist, 'utf-8');
+        const plistEntries = (0, plist_1.parse)(infoPlistContents);
+        if (plistEntries['CAPACITOR_DEBUG'] === undefined) {
+            log_1.logger.info('Writing CAPACITOR_DEBUG to ' + infoPlist);
+            plistEntries['CAPACITOR_DEBUG'] = '$(CAPACITOR_DEBUG)';
+            const plistToWrite = (0, plist_1.build)(plistEntries);
+            (0, fs_extra_1.writeFileSync)(infoPlist, plistToWrite);
+        }
+        else {
+            log_1.logger.warn('Found CAPACITOR_DEBUG set to ' + plistEntries['CAPACITOR_DEBUG'] + ', skipping.');
+        }
+    }
+    else {
+        log_1.logger.warn(infoPlist + ' not found.');
+    }
+}
+exports.addInfoPlistDebugIfNeeded = addInfoPlistDebugIfNeeded;
+// Private Functions
+async function pluginsWithPackageSwift(plugins) {
+    const pluginList = [];
+    for (const plugin of plugins) {
+        const packageSwiftFound = await (0, fs_extra_1.pathExists)((0, path_1.join)(plugin.rootPath, 'Package.swift'));
+        if (packageSwiftFound) {
+            pluginList.push(plugin);
+        }
+        else {
+            log_1.logger.warn(plugin.id + ' does not have a Package.swift');
+        }
+    }
+    return pluginList;
+}

package/dist/util/subprocess.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isInstalled = exports.getCommandOutput = exports.runCommand = void 0;
+const utils_subprocess_1 = require("@ionic/utils-subprocess");
+async function runCommand(command, args, options = {}) {
+    const p = new utils_subprocess_1.Subprocess(command, args, options);
+    try {
+        return await p.output();
+    }
+    catch (e) {
+        if (e instanceof utils_subprocess_1.SubprocessError) {
+            // old behavior of just throwing the stdout/stderr strings
+            throw e.output ? e.output : e.cause ? `${e.message} ${e.cause.toString()}` : e.code ? e.code : 'Unknown error';
+        }
+        throw e;
+    }
+}
+exports.runCommand = runCommand;
+async function getCommandOutput(command, args, options = {}) {
+    try {
+        return (await runCommand(command, args, options)).trim();
+    }
+    catch (e) {
+        return null;
+    }
+}
+exports.getCommandOutput = getCommandOutput;
+async function isInstalled(command) {
+    try {
+        await (0, utils_subprocess_1.which)(command);
+    }
+    catch (e) {
+        return false;
+    }
+    return true;
+}
+exports.isInstalled = isInstalled;

package/dist/util/template.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractTemplate = void 0;
+const tslib_1 = require("tslib");
+const fs_extra_1 = require("fs-extra");
+const tar_1 = tslib_1.__importDefault(require("tar"));
+async function extractTemplate(src, dir) {
+    await (0, fs_extra_1.mkdirp)(dir);
+    await tar_1.default.extract({ file: src, cwd: dir });
+}
+exports.extractTemplate = extractTemplate;

package/dist/util/term.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isInteractive = exports.checkInteractive = void 0;
+const tslib_1 = require("tslib");
+const utils_terminal_1 = require("@ionic/utils-terminal");
+const colors_1 = tslib_1.__importDefault(require("../colors"));
+const log_1 = require("../log");
+// Given input variables to a command, make sure all are provided if the terminal
+// is not interactive (because we won't be able to prompt the user)
+const checkInteractive = (...args) => {
+    if ((0, exports.isInteractive)()) {
+        return true;
+    }
+    // Fail if no args are provided, treat this as just a check of whether the term is
+    // interactive or not.
+    if (!args.length) {
+        return false;
+    }
+    // Make sure none of the provided args are empty, otherwise print the interactive
+    // warning and return false
+    if (args.filter((arg) => !arg).length) {
+        log_1.logger.error(`Non-interactive shell detected.\n` +
+            `Run the command with ${colors_1.default.input('--help')} to see a list of arguments that must be provided.`);
+        return false;
+    }
+    return true;
+};
+exports.checkInteractive = checkInteractive;
+const isInteractive = () => utils_terminal_1.TERMINAL_INFO.tty && !utils_terminal_1.TERMINAL_INFO.ci;
+exports.isInteractive = isInteractive;