hotcodepush 0.0.0 → 0.1.0

package/dist/utils/frameworks/cordova.js

@@ -0,0 +1,110 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { XMLParser } from 'fast-xml-parser';
+import { CORDOVA_PACKAGE_NAME, CORDOVA_PACKAGE_SPEC, } from '../../config/consts.js';
+import { resolveCommandLineText, runCommandLineVisibly, } from '../package-manager.js';
+import { NATIVE_GLUE_PATHS } from './native-glue.js';
+import { checkSdkPackage, isSdkPackageDeclared } from './sdk-package.js';
+const CONFIG_FILE_NAME = 'config.xml';
+const INSECURE_FILE_MODE_PREFERENCE_NAME = 'AndroidInsecureFileModeEnabled';
+const LIST_TAG_NAMES = new Set(['platform', 'preference']);
+const PLUGIN_ADD_COMMAND_LINE = {
+    args: ['cordova', 'plugin', 'add', CORDOVA_PACKAGE_SPEC],
+    command: 'npx',
+};
+const WEB_DIRECTORY = 'www';
+export const cordovaFramework = {
+    nativeGluePaths: NATIVE_GLUE_PATHS,
+    packageName: CORDOVA_PACKAGE_NAME,
+    versionedPackageNames: [
+        'cordova',
+        'cordova-android',
+        'cordova-ios',
+        CORDOVA_PACKAGE_NAME,
+    ],
+    checkWiring: project => [
+        checkSdkPackage(project, CORDOVA_PACKAGE_NAME),
+        checkHook(project),
+        checkInsecureFileMode(project),
+    ],
+    // The start page in `config.xml` is a page inside `www`, which the app serves as its root.
+    readBuildDirectory: () => ({ path: WEB_DIRECTORY }),
+    resolveWiring: project => Promise.resolve(resolveWiring(project)),
+};
+// The plugin wires the build steps itself into each platform once `package.json` lists it among Cordova's plugins.
+function checkHook({ packageJson }) {
+    return isPluginListed(packageJson)
+        ? {
+            check: 'hook',
+            message: "The plugin's Xcode phase and Gradle task run the build step.",
+            status: 'ok',
+        }
+        : {
+            check: 'hook',
+            code: 'wiring_missing',
+            manualStep: `Run "${resolveCommandLineText(PLUGIN_ADD_COMMAND_LINE)}".`,
+            message: `The plugin ${CORDOVA_PACKAGE_NAME} is not among package.json's cordova plugins.`,
+            status: 'failed',
+        };
+}
+function checkInsecureFileMode({ directoryPath, }) {
+    return isInsecureFileModeEnabled(readWidget(directoryPath))
+        ? {
+            check: 'android_file_mode',
+            code: 'insecure_file_mode',
+            manualStep: 'The plugin serves no update from file:// and stays off. Remove the preference.',
+            message: `The file ${CONFIG_FILE_NAME} sets ${INSECURE_FILE_MODE_PREFERENCE_NAME}, which loads the Android app from file://.`,
+            status: 'failed',
+        }
+        : {
+            check: 'android_file_mode',
+            message: `The file ${CONFIG_FILE_NAME} leaves ${INSECURE_FILE_MODE_PREFERENCE_NAME} off.`,
+            status: 'ok',
+        };
+}
+// Matches how Cordova reads Android preferences: names and values ignore case, and the last one wins.
+// The Android section comes after the widget's, so it wins too.
+function isInsecureFileModeEnabled(widget) {
+    const preferences = [
+        ...(widget?.preference ?? []),
+        ...(widget?.platform ?? [])
+            .filter(({ name }) => name === 'android')
+            .flatMap(({ preference }) => preference ?? []),
+    ];
+    const value = preferences.findLast(({ name }) => name?.toLowerCase() === INSECURE_FILE_MODE_PREFERENCE_NAME.toLowerCase())?.value;
+    return value?.toLowerCase() === 'true';
+}
+function isPluginListed(packageJson) {
+    return packageJson?.cordova?.plugins?.[CORDOVA_PACKAGE_NAME] !== undefined;
+}
+function readWidget(projectDirectoryPath) {
+    const configFilePath = join(projectDirectoryPath, CONFIG_FILE_NAME);
+    if (!existsSync(configFilePath)) {
+        return undefined;
+    }
+    const document = new XMLParser({
+        attributeNamePrefix: '',
+        ignoreAttributes: false,
+        isArray: (tagName, _jPath, _isLeafNode, isAttribute) => !isAttribute && LIST_TAG_NAMES.has(tagName),
+        parseAttributeValue: false,
+    }).parse(readFileSync(configFilePath, 'utf8'));
+    return document.widget;
+}
+function resolveWiring({ directoryPath, packageJson, }) {
+    const isPackageInstalled = isSdkPackageDeclared(packageJson, CORDOVA_PACKAGE_NAME) &&
+        isPluginListed(packageJson);
+    return {
+        isPackageInstalled,
+        nativeFilePaths: [],
+        packageFilePaths: isPackageInstalled ? [] : ['package.json'],
+        installPackage: () => {
+            runCommandLineVisibly(PLUGIN_ADD_COMMAND_LINE, directoryPath);
+            return `Installed ${CORDOVA_PACKAGE_NAME} from ${CORDOVA_PACKAGE_SPEC} through "cordova plugin add".`;
+        },
+        wireBinaryCreateStep: () => Promise.resolve({
+            message: 'The plugin wires its Xcode phase and Gradle task itself, so there is nothing to wire.',
+            status: 'skipped',
+            value: undefined,
+        }),
+    };
+}

package/dist/utils/frameworks/expo.js

@@ -0,0 +1,152 @@
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { EXPO_PACKAGE_NAME, EXPO_PACKAGE_SPEC, INIT_MANUAL_STEP, REACT_NATIVE_PACKAGE_NAME, } from '../../config/consts.js';
+import { NativeProjectError } from '../errors.js';
+import { stringifyLikeSource } from '../json-file.js';
+import { collectEmbeddedFiles, packageReactNativeBundles, readBuildDirectory, } from './react-native-build.js';
+import { checkSdkPackage, installSdkPackage, isSdkPackageDeclared, } from './sdk-package.js';
+const APP_JSON_FILE_NAME = 'app.json';
+// Expo's native release builds run this bundler, and it resolves the entry file itself.
+const BUNDLER_ARGS = ['expo', 'export:embed'];
+// Both lists are in the order Expo prefers.
+const CODE_APP_CONFIG_FILE_NAMES = [
+    'app.config.ts',
+    'app.config.mts',
+    'app.config.cts',
+    'app.config.mjs',
+    'app.config.cjs',
+    'app.config.js',
+];
+const JSON_APP_CONFIG_FILE_NAMES = ['app.config.json', APP_JSON_FILE_NAME];
+// The config plugin wires the native projects at prebuild, so `init` only adds one entry to the app config.
+export const expoFramework = {
+    packageName: EXPO_PACKAGE_NAME,
+    versionedPackageNames: ['expo', 'react-native', EXPO_PACKAGE_NAME],
+    versionedSdkDependencyNames: [REACT_NATIVE_PACKAGE_NAME],
+    checkWiring: project => [
+        checkSdkPackage(project, EXPO_PACKAGE_NAME),
+        checkPluginEntry(project),
+    ],
+    collectEmbeddedFiles,
+    packageBundles: request => packageReactNativeBundles(request, () => BUNDLER_ARGS),
+    readBuildDirectory,
+    resolveWiring: project => Promise.resolve(resolveWiring(project)),
+};
+function addPluginEntry(filePath) {
+    // A project without an app config gets one, as Expo's own install writes it.
+    const appJsonText = existsSync(filePath)
+        ? readFileSync(filePath, 'utf8')
+        : '{}';
+    const appJson = JSON.parse(appJsonText);
+    const appConfig = appJson.expo ?? appJson;
+    appConfig.plugins = [...(appConfig.plugins ?? []), EXPO_PACKAGE_NAME];
+    writeFileSync(filePath, stringifyLikeSource(appJson, appJsonText));
+}
+function checkPluginEntry({ directoryPath }) {
+    const appConfigFileNames = findAppConfigFileNames(directoryPath);
+    const pluginEntryFileName = findPluginEntryFileName(directoryPath, appConfigFileNames);
+    if (pluginEntryFileName !== undefined) {
+        return {
+            check: 'hook',
+            message: `The app config ${pluginEntryFileName} lists the config plugin, which wires the build step at prebuild.`,
+            status: 'ok',
+        };
+    }
+    const { codeFileName, jsonFileName } = appConfigFileNames;
+    const appConfigFileName = codeFileName ?? jsonFileName;
+    return {
+        check: 'hook',
+        code: 'wiring_missing',
+        manualStep: isPluginEntryEditable(directoryPath, appConfigFileNames)
+            ? INIT_MANUAL_STEP
+            : resolvePluginEntryStep(appConfigFileName),
+        message: `The app config ${appConfigFileName} does not list the config plugin ${EXPO_PACKAGE_NAME}.`,
+        status: 'failed',
+    };
+}
+function findAppConfigFileNames(projectDirectoryPath) {
+    const isPresent = (fileName) => existsSync(join(projectDirectoryPath, fileName));
+    return {
+        codeFileName: CODE_APP_CONFIG_FILE_NAMES.find(isPresent),
+        jsonFileName: JSON_APP_CONFIG_FILE_NAMES.find(isPresent) ?? APP_JSON_FILE_NAME,
+    };
+}
+// An entry in the JSON config counts beside a code config too, since Expo hands its config to the code.
+function findPluginEntryFileName(projectDirectoryPath, { codeFileName, jsonFileName }) {
+    return [codeFileName, jsonFileName].find(fileName => fileName !== undefined && hasPluginEntry(projectDirectoryPath, fileName));
+}
+// A code or JSON5 config is never evaluated, so the package name is matched in its text.
+function hasPluginEntry(projectDirectoryPath, appConfigFileName) {
+    const filePath = join(projectDirectoryPath, appConfigFileName);
+    if (!existsSync(filePath)) {
+        return false;
+    }
+    const appConfigText = readFileSync(filePath, 'utf8');
+    const appJson = JSON_APP_CONFIG_FILE_NAMES.includes(appConfigFileName)
+        ? parseAppJson(appConfigText)
+        : undefined;
+    if (appJson === undefined) {
+        return appConfigText.includes(EXPO_PACKAGE_NAME);
+    }
+    return ((appJson.expo ?? appJson).plugins ?? []).some(plugin => (Array.isArray(plugin) ? plugin[0] : plugin) === EXPO_PACKAGE_NAME);
+}
+// Expo also reads JSON5, which does not parse as JSON. The person adds the entry there and beside a code config.
+function isPluginEntryEditable(projectDirectoryPath, { codeFileName, jsonFileName }) {
+    const jsonFilePath = join(projectDirectoryPath, jsonFileName);
+    return (codeFileName === undefined &&
+        (!existsSync(jsonFilePath) ||
+            parseAppJson(readFileSync(jsonFilePath, 'utf8')) !== undefined));
+}
+function parseAppJson(appJsonText) {
+    try {
+        return JSON.parse(appJsonText);
+    }
+    catch {
+        return undefined;
+    }
+}
+function resolvePluginEntryStep(appConfigFileName) {
+    return `Add "${EXPO_PACKAGE_NAME}" to the plugins in ${appConfigFileName}.`;
+}
+function resolveWiring({ directoryPath, packageJson, }) {
+    const isPackageInstalled = isSdkPackageDeclared(packageJson, EXPO_PACKAGE_NAME);
+    const appConfigFileNames = findAppConfigFileNames(directoryPath);
+    const isAppJsonToEdit = isPluginEntryEditable(directoryPath, appConfigFileNames) &&
+        findPluginEntryFileName(directoryPath, appConfigFileNames) === undefined;
+    return {
+        isPackageInstalled,
+        nativeFilePaths: [],
+        packageFilePaths: [
+            ...(isPackageInstalled ? [] : ['package.json']),
+            ...(isAppJsonToEdit ? [appConfigFileNames.jsonFileName] : []),
+        ],
+        installPackage: () => installSdkPackage(directoryPath, EXPO_PACKAGE_NAME, EXPO_PACKAGE_SPEC),
+        wireBinaryCreateStep: editBlocker => wirePluginEntry(directoryPath, appConfigFileNames, editBlocker),
+    };
+}
+async function wirePluginEntry(projectDirectoryPath, appConfigFileNames, editBlocker) {
+    const pluginEntryFileName = findPluginEntryFileName(projectDirectoryPath, appConfigFileNames);
+    if (pluginEntryFileName !== undefined) {
+        return {
+            message: `The app config ${pluginEntryFileName} already lists the config plugin.`,
+            status: 'skipped',
+            value: undefined,
+        };
+    }
+    const { codeFileName, jsonFileName } = appConfigFileNames;
+    if (codeFileName !== undefined) {
+        throw new NativeProjectError(`The app config ${codeFileName} is code, which the CLI does not edit.`, resolvePluginEntryStep(codeFileName));
+    }
+    if (!isPluginEntryEditable(projectDirectoryPath, appConfigFileNames)) {
+        throw new NativeProjectError(`The app config ${jsonFileName} is not JSON the CLI can parse.`, resolvePluginEntryStep(jsonFileName));
+    }
+    if (editBlocker !== undefined) {
+        throw editBlocker;
+    }
+    addPluginEntry(join(projectDirectoryPath, jsonFileName));
+    return {
+        message: `Added the config plugin ${EXPO_PACKAGE_NAME} to ${jsonFileName}.`,
+        status: 'done',
+        value: undefined,
+    };
+}

package/dist/utils/frameworks/index.js

@@ -0,0 +1,13 @@
+import { capacitorFramework } from './capacitor.js';
+import { cordovaFramework } from './cordova.js';
+import { expoFramework } from './expo.js';
+import { reactNativeFramework } from './react-native.js';
+const FRAMEWORK_MODULES = {
+    capacitor: capacitorFramework,
+    cordova: cordovaFramework,
+    expo: expoFramework,
+    react_native: reactNativeFramework,
+};
+export function resolveFrameworkModule(framework) {
+    return FRAMEWORK_MODULES[framework];
+}

package/dist/utils/frameworks/native-glue.js

@@ -0,0 +1,10 @@
+// Cordova's bridge and plugin scripts, which Capacitor copies too. The binary serves them under every bundle.
+// A path ending in `/` names everything under it.
+export const NATIVE_GLUE_PATHS = [
+    'cordova.js',
+    'cordova_plugins.js',
+    'plugins/',
+];
+export function omitNativeGlue(files, nativeGluePaths) {
+    return files.filter(({ path }) => !nativeGluePaths.some(gluePath => gluePath.endsWith('/') ? path.startsWith(gluePath) : path === gluePath));
+}

package/dist/utils/frameworks/native-projects.js

@@ -0,0 +1,27 @@
+import { existsSync } from 'node:fs';
+import { relative, resolve } from 'node:path';
+import { isInteractive } from '../environment.js';
+import { MissingParameterError } from '../errors.js';
+import { promptText } from '../prompts.js';
+// Non-interactively, missing projects stop the hook step later instead of failing here.
+export async function resolveNativeProjects(projectDirectoryPath, defaultPaths, options, missingProjectsStep) {
+    const android = options.androidPath === undefined
+        ? defaultPaths.android
+        : resolve(options.androidPath);
+    const ios = options.iosPath === undefined ? defaultPaths.ios : resolve(options.iosPath);
+    if (existsSync(android) || existsSync(ios)) {
+        return { android, ios, missingError: undefined };
+    }
+    if (!isInteractive(options)) {
+        return {
+            android,
+            ios,
+            missingError: new MissingParameterError('--ios-path', `Neither ${relative(projectDirectoryPath, ios)} nor ${relative(projectDirectoryPath, android)} exists. ${missingProjectsStep}`),
+        };
+    }
+    return {
+        android: resolve(await promptText('--android-path', 'Where is the Android project?', options)),
+        ios: resolve(await promptText('--ios-path', 'Where is the iOS project?', options)),
+        missingError: undefined,
+    };
+}

package/dist/utils/frameworks/react-native-build.js

@@ -0,0 +1,182 @@
+import { existsSync, mkdirSync, readFileSync, renameSync, statSync, } from 'node:fs';
+import { createRequire } from 'node:module';
+import { dirname, join, resolve } from 'node:path';
+import { collectBundleFiles, computeFileSha256 } from '../bundle-files.js';
+import { InvalidParameterError } from '../errors.js';
+import { runCommandLineVisibly } from '../package-manager.js';
+// The names React Native's own builds give the JavaScript, in the app and in an uploaded bundle alike.
+const BUNDLE_FILE_NAMES = {
+    android: 'index.android.bundle',
+    ios: 'main.jsbundle',
+};
+// React Native's release build defaults: the Gradle plugin's `hermesFlags`, and react-native-xcode.sh without `SOURCEMAP_FILE`.
+// On Android the source map takes the debug information out of the bytecode, on iOS it stays inline.
+const HERMES_FLAGS = {
+    android: ['-O', '-output-source-map'],
+    ios: ['-O'],
+};
+const HERMESC_DIRECTORY_NAMES = {
+    darwin: 'osx-bin',
+    linux: 'linux64-bin',
+    win32: 'win64-bin',
+};
+const PLATFORMS = ['android', 'ios'];
+// The iOS app holds far more than the bundle, so only the JavaScript and `assets/` are taken.
+// A debug build that Metro serves has no bundle and gives the build step nothing to hash.
+export async function collectEmbeddedFiles(platform, inputDirectoryPath) {
+    const bundleFileName = BUNDLE_FILE_NAMES[platform];
+    const bundleFilePath = join(inputDirectoryPath, bundleFileName);
+    if (!existsSync(bundleFilePath)) {
+        return undefined;
+    }
+    if (platform === 'android') {
+        return collectBundleFiles(inputDirectoryPath);
+    }
+    const assetsDirectoryPath = join(inputDirectoryPath, 'assets');
+    const assetFiles = existsSync(assetsDirectoryPath)
+        ? await collectBundleFiles(assetsDirectoryPath)
+        : [];
+    return [
+        ...assetFiles.map(file => ({ ...file, path: `assets/${file.path}` })),
+        {
+            filePath: bundleFilePath,
+            path: bundleFileName,
+            sha256: await computeFileSha256(bundleFilePath),
+            sizeBytes: statSync(bundleFilePath).size,
+        },
+    ];
+}
+export function packageReactNativeBundles({ packagingDirectoryPath, path, platforms = PLATFORMS, projectDirectoryPath, }, resolveBundlerArgs) {
+    if (path !== undefined) {
+        const [platform] = platforms;
+        if (platform === undefined || platforms.length > 1) {
+            throw new InvalidParameterError('A prepared bundle from --path serves one platform.', 'Name it with --platform ios or --platform android.');
+        }
+        const directoryPath = resolve(path);
+        const bundleFileName = BUNDLE_FILE_NAMES[platform];
+        if (!existsSync(join(directoryPath, bundleFileName))) {
+            throw new InvalidParameterError(`The directory ${directoryPath} from --path holds no ${bundleFileName}, the JavaScript the ${platform} app loads.`, `Pass the ${platform} bundle's directory, with ${bundleFileName} in it, or leave out --path to bundle the project.`);
+        }
+        return Promise.resolve([{ directoryPath, platforms }]);
+    }
+    return Promise.resolve(platforms.map(platform => {
+        const directoryPath = join(packagingDirectoryPath, platform);
+        packageBundle(projectDirectoryPath, platform, directoryPath, resolveBundlerArgs(projectDirectoryPath, platform));
+        return { directoryPath, platforms: [platform] };
+    }));
+}
+export function readBuildDirectory() {
+    return {
+        missingReason: 'the embedded bundle lies in the app the native build makes',
+    };
+}
+export function resolveNativeProjectPaths(projectDirectoryPath) {
+    return {
+        android: join(projectDirectoryPath, 'android'),
+        ios: join(projectDirectoryPath, 'ios'),
+    };
+}
+function isHermesEnabled(platform, nativeProjectPaths) {
+    const [filePath, disabledPattern] = platform === 'android'
+        ? [
+            join(nativeProjectPaths.android, 'gradle.properties'),
+            /^\s*hermesEnabled\s*=\s*false\s*$/m,
+        ]
+        : [
+            join(nativeProjectPaths.ios, 'Podfile'),
+            /:hermes_enabled\s*=>\s*false/,
+        ];
+    return (!existsSync(filePath) ||
+        !disabledPattern.test(readFileSync(filePath, 'utf8')));
+}
+// Mirrors the release build. Intermediate files go beside the bundle's directory, never into it.
+function packageBundle(projectDirectoryPath, platform, outputDirectoryPath, bundlerArgs) {
+    const intermediateDirectoryPath = `${outputDirectoryPath}-intermediate`;
+    mkdirSync(outputDirectoryPath, { recursive: true });
+    mkdirSync(intermediateDirectoryPath, { recursive: true });
+    const bundleFileName = BUNDLE_FILE_NAMES[platform];
+    const bundleFilePath = join(outputDirectoryPath, bundleFileName);
+    const hermescFilePath = resolveHermescFilePath(projectDirectoryPath, platform);
+    const javaScriptFilePath = hermescFilePath === undefined
+        ? bundleFilePath
+        : join(intermediateDirectoryPath, bundleFileName);
+    const sourceMapFileName = resolvePackagerSourceMapFileName(platform, hermescFilePath !== undefined);
+    runCommandLineVisibly({
+        args: [
+            ...bundlerArgs,
+            '--platform',
+            platform,
+            '--dev',
+            'false',
+            '--bundle-output',
+            javaScriptFilePath,
+            '--assets-dest',
+            outputDirectoryPath,
+            '--reset-cache',
+            ...(sourceMapFileName === undefined
+                ? []
+                : [
+                    '--sourcemap-output',
+                    join(intermediateDirectoryPath, sourceMapFileName),
+                ]),
+            // Hermes compiles the JavaScript itself and needs no minification before it.
+            ...(hermescFilePath === undefined ? [] : ['--minify', 'false']),
+        ],
+        command: 'npx',
+    }, projectDirectoryPath);
+    if (hermescFilePath !== undefined) {
+        const bytecodeFilePath = `${javaScriptFilePath}.hbc`;
+        runCommandLineVisibly({
+            args: [
+                '-emit-binary',
+                '-max-diagnostic-width=80',
+                ...HERMES_FLAGS[platform],
+                '-out',
+                bytecodeFilePath,
+                javaScriptFilePath,
+            ],
+            command: hermescFilePath,
+        }, projectDirectoryPath);
+        renameSync(bytecodeFilePath, bundleFilePath);
+    }
+}
+function resolveHermescFilePath(projectDirectoryPath, platform) {
+    if (!isHermesEnabled(platform, resolveNativeProjectPaths(projectDirectoryPath))) {
+        return undefined;
+    }
+    const directoryName = HERMESC_DIRECTORY_NAMES[process.platform];
+    const fileName = process.platform === 'win32' ? 'hermesc.exe' : 'hermesc';
+    const hermescFilePath = [
+        ['react-native', 'sdks', 'hermesc'],
+        ['hermes-compiler', 'hermesc'],
+    ]
+        .map(([packageName = '', ...segments]) => resolvePackageDirectoryPath(projectDirectoryPath, packageName, segments))
+        .map(directoryPath => directoryPath === undefined || directoryName === undefined
+        ? undefined
+        : join(directoryPath, directoryName, fileName))
+        .find(filePath => filePath !== undefined && existsSync(filePath));
+    if (hermescFilePath === undefined) {
+        throw new InvalidParameterError("Hermes' compiler was not found in the project's react-native.", 'Install the dependencies, or pass --path with a bundle directory prepared for one --platform.');
+    }
+    return hermescFilePath;
+}
+function resolvePackageDirectoryPath(projectDirectoryPath, packageName, segments) {
+    try {
+        const packageJsonPath = createRequire(join(projectDirectoryPath, 'package.json')).resolve(`${packageName}/package.json`);
+        return join(dirname(packageJsonPath), ...segments);
+    }
+    catch {
+        return undefined;
+    }
+}
+// The JavaScript ends with a comment naming its source map, so the name must match React Native's release build.
+// Gradle always writes one, and Xcode none by default.
+function resolvePackagerSourceMapFileName(platform, isHermesEnabledForPlatform) {
+    if (platform === 'ios') {
+        return undefined;
+    }
+    const bundleFileName = BUNDLE_FILE_NAMES[platform];
+    return isHermesEnabledForPlatform
+        ? `${bundleFileName}.packager.map`
+        : `${bundleFileName}.map`;
+}

package/dist/utils/frameworks/react-native.js

@@ -0,0 +1,127 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { join, relative } from 'node:path';
+import { REACT_NATIVE_PACKAGE_NAME, REACT_NATIVE_PACKAGE_SPEC, } from '../../config/consts.js';
+import { resolveGradleEdit } from '../native-project-edit.js';
+import { runCommandLineVisibly } from '../package-manager.js';
+import { resolveBundleUrlEdit, resolveReactHostEdit, } from '../react-native-project.js';
+import { buildPbxprojShellScript, hasBinaryCreatePhase, resolveXcodeProjectFilePath, } from '../xcode-project.js';
+import { applyNativeProjectEdits, checkBinaryCreateStep, checkEdits, } from './binary-create-step.js';
+import { resolveNativeProjects } from './native-projects.js';
+import { collectEmbeddedFiles, packageReactNativeBundles, readBuildDirectory, resolveNativeProjectPaths, } from './react-native-build.js';
+import { checkSdkPackage, installSdkPackage, isSdkPackageDeclared, } from './sdk-package.js';
+// React Native's `with-environment.sh` finds Node for the script.
+const BINARY_CREATE_PHASE = {
+    anchorPhaseName: 'Bundle React Native code and images',
+    fix: `Add a Run Script phase after "Bundle React Native code and images" that runs node_modules/${REACT_NATIVE_PACKAGE_NAME}/scripts/binary-create-xcode.sh through React Native's with-environment.sh.`,
+    shellScript: buildPbxprojShellScript([
+        'set -e',
+        '',
+        '# hotcodepush: writes hotcodepush.json into the app and, in a store build, creates the binary',
+        'WITH_ENVIRONMENT="$REACT_NATIVE_PATH/scripts/xcode/with-environment.sh"',
+        `HOTCODEPUSH_BINARY_CREATE="$REACT_NATIVE_PATH/../${REACT_NATIVE_PACKAGE_NAME}/scripts/binary-create-xcode.sh"`,
+        '',
+        '/bin/sh -c "$WITH_ENVIRONMENT $HOTCODEPUSH_BINARY_CREATE"',
+        '',
+    ]),
+};
+const POD_NAME = 'HotcodepushReactNativeCodePush';
+// The project has no build output: the native build and the upload each bundle the JavaScript when needed.
+export const reactNativeFramework = {
+    packageName: REACT_NATIVE_PACKAGE_NAME,
+    versionedPackageNames: ['react-native', REACT_NATIVE_PACKAGE_NAME],
+    checkWiring: project => [
+        checkSdkPackage(project, REACT_NATIVE_PACKAGE_NAME),
+        checkBinaryCreateStep(project.directoryPath, resolveNativeProjectPaths(project.directoryPath), REACT_NATIVE_PACKAGE_NAME),
+        checkBundleWiring(project),
+    ],
+    collectEmbeddedFiles,
+    packageBundles: request => packageReactNativeBundles(request, resolveBundlerArgs),
+    readBuildDirectory,
+    resolveWiring,
+};
+function checkBundleWiring({ directoryPath, }) {
+    return checkEdits('host', 'React Native runs the bundle the SDK serves.', resolveBundleWiringEdits(resolveNativeProjectPaths(directoryPath)), directoryPath);
+}
+function isPodInstalled(iosProjectPath) {
+    if (!existsSync(join(iosProjectPath, 'Podfile'))) {
+        return true;
+    }
+    const lockFilePath = join(iosProjectPath, 'Podfile.lock');
+    return (existsSync(lockFilePath) &&
+        readFileSync(lockFilePath, 'utf8').includes(POD_NAME));
+}
+function resolveBundleWiringEdits(nativeProjectPaths) {
+    return [
+        resolveBundleUrlEdit(nativeProjectPaths.ios),
+        resolveReactHostEdit(nativeProjectPaths.android),
+    ].filter(edit => edit !== undefined);
+}
+// React Native's own builds prefer `index.<platform>.js` over `index.js`.
+function resolveBundlerArgs(projectDirectoryPath, platform) {
+    const platformEntryFileName = `index.${platform}.js`;
+    return [
+        'react-native',
+        'bundle',
+        '--entry-file',
+        existsSync(join(projectDirectoryPath, platformEntryFileName))
+            ? platformEntryFileName
+            : 'index.js',
+    ];
+}
+function resolveEdits(nativeProjectPaths) {
+    return [
+        resolveGradleEdit(nativeProjectPaths.android, REACT_NATIVE_PACKAGE_NAME),
+        ...resolveBundleWiringEdits(nativeProjectPaths),
+    ].filter(edit => edit !== undefined);
+}
+async function resolveWiring({ directoryPath, packageJson }, options) {
+    const nativeProjects = await resolveNativeProjects(directoryPath, resolveNativeProjectPaths(directoryPath), options, 'Pass --ios-path and --android-path.');
+    const isPackageInstalled = isSdkPackageDeclared(packageJson, REACT_NATIVE_PACKAGE_NAME);
+    const xcodeProjectFilePath = resolveXcodeProjectFilePath(nativeProjects.ios);
+    return {
+        isPackageInstalled,
+        nativeFilePaths: [
+            ...(xcodeProjectFilePath === undefined ||
+                hasBinaryCreatePhase(xcodeProjectFilePath)
+                ? []
+                : [xcodeProjectFilePath]),
+            ...resolveEdits(nativeProjects)
+                .filter(edit => !edit.isRefused && !edit.isApplied())
+                .map(({ filePath }) => filePath),
+        ].map(filePath => relative(directoryPath, filePath)),
+        packageFilePaths: isPackageInstalled ? [] : ['package.json'],
+        installPackage: () => installSdkPackage(directoryPath, REACT_NATIVE_PACKAGE_NAME, REACT_NATIVE_PACKAGE_SPEC),
+        wireBinaryCreateStep: editBlocker => wireBinaryCreateStep(nativeProjects, xcodeProjectFilePath, editBlocker, options),
+    };
+}
+async function wireBinaryCreateStep(nativeProjects, xcodeProjectFilePath, editBlocker, options) {
+    if (nativeProjects.missingError !== undefined) {
+        throw nativeProjects.missingError;
+    }
+    const isPhaseWired = xcodeProjectFilePath === undefined ||
+        hasBinaryCreatePhase(xcodeProjectFilePath);
+    const pendingEdits = resolveEdits(nativeProjects).filter(edit => !edit.isApplied());
+    const arePodsInstalled = isPodInstalled(nativeProjects.ios);
+    if (isPhaseWired && pendingEdits.length === 0 && arePodsInstalled) {
+        return {
+            message: 'The build step and the bundle wiring are already wired.',
+            status: 'skipped',
+            value: undefined,
+        };
+    }
+    if (editBlocker !== undefined && (!isPhaseWired || pendingEdits.length > 0)) {
+        throw editBlocker;
+    }
+    const wired = await applyNativeProjectEdits(xcodeProjectFilePath === undefined
+        ? undefined
+        : { phase: BINARY_CREATE_PHASE, projectFilePath: xcodeProjectFilePath }, pendingEdits, options);
+    if (!arePodsInstalled) {
+        runCommandLineVisibly({ args: ['install'], command: 'pod' }, nativeProjects.ios);
+        wired.push('the pods through "pod install"');
+    }
+    return {
+        message: `Wired ${wired.join(', ')}.`,
+        status: 'done',
+        value: undefined,
+    };
+}