react-native-bootsplash 6.0.0-beta.0 → 6.0.0-beta.10

package/src/generate.ts

@@ -1,33 +1,32 @@
-import murmurhash from "@emotion/hash";
-import { getConfig as getExpoConfig } from "@expo/config";
 import * as Expo from "@expo/config-plugins";
-import { assignColorValue } from "@expo/config-plugins/build/android/Colors";
-import { addImports } from "@expo/config-plugins/build/android/codeMod";
-import { mergeContents } from "@expo/config-plugins/build/utils/generateCode";
 import plist from "@expo/plist";
 import { findProjectRoot } from "@react-native-community/cli-tools";
 import {
   AndroidProjectConfig,
   IOSProjectConfig,
 } from "@react-native-community/cli-types";
+import childProcess from "child_process";
+import crypto from "crypto";
 import detectIndent from "detect-indent";
 import fs from "fs-extra";
-import { parse as parseHtml } from "node-html-parser";
+import { HTMLElement, parse as parseHtml } from "node-html-parser";
 import path from "path";
 import pc from "picocolors";
 import { Options as PrettierOptions } from "prettier";
 import * as htmlPlugin from "prettier/plugins/html";
 import * as cssPlugin from "prettier/plugins/postcss";
 import * as prettier from "prettier/standalone";
+import semver from "semver";
 import sharp, { Sharp } from "sharp";
 import { dedent } from "ts-dedent";
+import util from "util";
 import formatXml, { XMLFormatterOptions } from "xml-formatter";
 import { Manifest } from ".";
 
 const workingPath = process.env.INIT_CWD ?? process.env.PWD ?? process.cwd();
 const projectRoot = findProjectRoot(workingPath);
 
-export type Platforms = ("android" | "ios" | "web")[];
+type Platforms = ("android" | "ios" | "web")[];
 
 export type RGBColor = {
   R: string;
@@ -35,11 +34,16 @@ export type RGBColor = {
   B: string;
 };
 
-export type Color = {
+type Color = {
   hex: string;
   rgb: RGBColor;
 };
 
+const promisifiedExec = util.promisify(childProcess.exec);
+
+const exec = (cmd: string) =>
+  promisifiedExec(cmd).then(({ stdout, stderr }) => stdout || stderr);
+
 export const log = {
   error: (text: string) => {
     console.log(pc.red(`❌  ${text}`));
@@ -60,7 +64,7 @@ export const log = {
   },
 };
 
-export const parseColor = (value: string): Color => {
+const parseColor = (value: string): Color => {
   const up = value.toUpperCase().replace(/[^0-9A-F]/g, "");
 
   if (up.length !== 3 && up.length !== 6) {
@@ -180,70 +184,102 @@ export const hfs = {
   },
 };
 
-export const writeJson = (filePath: string, content: object) => {
-  hfs.write(filePath, JSON.stringify(content, null, 2));
-  log.write(filePath);
-};
+export const getExpoConfig = (projectRoot: string): { isExpo: boolean } => {
+  try {
+    const pkg = hfs.json(
+      path.resolve(projectRoot, "node_modules", "expo", "package.json"),
+    ) as { version?: string };
 
-export const readXml = (filePath: string) => {
-  const xml = hfs.text(filePath);
-  const { indent } = detectIndent(xml);
+    const version = pkg.version;
 
-  const formatOptions: XMLFormatterOptions = {
-    indentation: indent || "    ",
-  };
+    if (version == null || semver.lt(version, "51.0.20")) {
+      log.error("Requires Expo 51.0.20 (or higher)");
+      process.exit(1);
+    }
 
-  return { root: parseHtml(xml), formatOptions };
+    return { isExpo: true };
+  } catch {
+    return { isExpo: false };
+  }
 };
 
-export const writeXml = (
-  filePath: string,
-  content: string,
-  options?: XMLFormatterOptions,
-) => {
-  const formatted = formatXml(content, {
-    collapseContent: true,
-    forceSelfClosingEmptyTag: true,
-    indentation: "    ",
-    lineSeparator: "\n",
-    whiteSpaceAtEndOfSelfclosingTag: true,
-    ...options,
-  });
-
-  hfs.write(filePath, formatted);
+export const writeJson = (filePath: string, content: object) => {
+  hfs.write(filePath, JSON.stringify(content, null, 2));
   log.write(filePath);
 };
 
-export const readHtml = (filePath: string) => {
-  const html = hfs.text(filePath);
-  const { type, amount } = detectIndent(html);
+type FormatOptions = { indent?: detectIndent.Indent } & (
+  | {
+      formatter: "prettier";
+      selfClosingTags?: boolean;
+      useCssPlugin?: boolean;
+      htmlWhitespaceSensitivity?: PrettierOptions["htmlWhitespaceSensitivity"];
+      singleAttributePerLine?: PrettierOptions["singleAttributePerLine"];
+    }
+  | {
+      formatter: "xmlFormatter";
+      whiteSpaceAtEndOfSelfclosingTag?: XMLFormatterOptions["whiteSpaceAtEndOfSelfclosingTag"];
+    }
+);
 
-  const formatOptions: PrettierOptions = {
-    useTabs: type === "tab",
-    tabWidth: amount || 2,
-  };
+export const readXmlLike = (filePath: string) => {
+  const content = hfs.text(filePath);
 
-  return { root: parseHtml(html), formatOptions };
+  return {
+    root: parseHtml(content),
+    formatOptions: { indent: detectIndent(content) },
+  };
 };
 
-export const writeHtml = async (
+export const writeXmlLike = async (
   filePath: string,
   content: string,
-  options?: Omit<PrettierOptions, "parser" | "plugins">,
+  { indent, ...formatOptions }: FormatOptions,
 ) => {
-  const formatted = await prettier.format(content, {
-    parser: "html",
-    plugins: [htmlPlugin, cssPlugin],
-    tabWidth: 2,
-    useTabs: false,
-    ...options,
-  });
+  if (formatOptions.formatter === "prettier") {
+    const {
+      formatter,
+      useCssPlugin = false,
+      selfClosingTags = false,
+      ...options
+    } = formatOptions;
+
+    const formatted = await prettier.format(content, {
+      parser: "html",
+      bracketSameLine: true,
+      printWidth: 10000,
+      plugins: [htmlPlugin, ...(useCssPlugin ? [cssPlugin] : [])],
+      useTabs: indent?.type === "tab",
+      tabWidth: (indent?.amount ?? 0) || 2,
+      ...options,
+    });
 
-  hfs.write(filePath, formatted);
-  log.write(filePath);
+    hfs.write(
+      filePath,
+      selfClosingTags
+        ? formatted.replace(/><\/[a-z-0-9]+>/gi, " />")
+        : formatted,
+    );
+
+    log.write(filePath);
+  } else {
+    const { formatter, ...options } = formatOptions;
+
+    const formatted = formatXml(content, {
+      collapseContent: true,
+      forceSelfClosingEmptyTag: true,
+      lineSeparator: "\n",
+      whiteSpaceAtEndOfSelfclosingTag: true,
+      indentation: (indent?.indent ?? "") || "    ",
+      ...options,
+    });
+
+    hfs.write(filePath, formatted);
+    log.write(filePath);
+  }
 };
 
-const cleanIOS = (dir: string) => {
+export const cleanIOSAssets = (dir: string) => {
   hfs
     .readDir(dir)
     .filter((file) => file === "Colors.xcassets" || file === "Images.xcassets")
@@ -316,7 +352,11 @@ const getFileNameSuffix = async ({
     .map((key) => record[key])
     .join();
 
-  return murmurhash(stableKey);
+  return crypto
+    .createHash("shake256", { outputLength: 3 })
+    .update(stableKey)
+    .digest("hex")
+    .toLowerCase();
 };
 
 const ensureSupportedFormat = async (
@@ -402,8 +442,8 @@ const getAndroidOutputPath = ({
 };
 
 const getIOSOutputPath = ({
-  assetsOutputPath,
   ios,
+  assetsOutputPath,
   isExpo,
   platforms,
 }: {
@@ -441,10 +481,12 @@ const getIOSOutputPath = ({
   return iosOutputPath;
 };
 
-const getHtmlTemplatePath = ({
+const getHtmlTemplatePath = async ({
+  isExpo,
   html,
   platforms,
 }: {
+  isExpo: boolean;
   html: string;
   platforms: Platforms;
 }) => {
@@ -452,6 +494,24 @@ const getHtmlTemplatePath = ({
     return;
   }
 
+  if (isExpo) {
+    const htmlTemplatePath = path.resolve(workingPath, html);
+
+    const htmlTemplateRelativePath = path.relative(
+      workingPath,
+      htmlTemplatePath,
+    );
+
+    if (
+      htmlTemplateRelativePath === "public/index.html" &&
+      !hfs.exists(htmlTemplatePath)
+    ) {
+      const cmd = `npx expo customize ${htmlTemplateRelativePath}`;
+      console.log(pc.dim(`Running ${cmd}`));
+      await exec(cmd);
+    }
+  }
+
   const htmlTemplatePath = path.resolve(workingPath, html);
 
   if (!hfs.exists(htmlTemplatePath)) {
@@ -466,7 +526,7 @@ const getHtmlTemplatePath = ({
   return htmlTemplatePath;
 };
 
-export const getImageHeight = (
+const getImageHeight = (
   image: Sharp | undefined,
   width: number,
 ): Promise<number> => {
@@ -548,14 +608,9 @@ export const generate = async ({
   darkLogo?: string;
   darkBrand?: string;
 }) => {
-  const isExpo =
-    getExpoConfig(projectRoot, { skipSDKVersionRequirement: true }).exp
-      .sdkVersion != null;
-
-  const [nodeStringVersion = ""] = process.versions.node.split(".");
-  const nodeVersion = Number.parseInt(nodeStringVersion, 10);
+  const { isExpo } = getExpoConfig(workingPath);
 
-  if (!Number.isNaN(nodeVersion) && nodeVersion < 18) {
+  if (semver.lt(process.versions.node, "18.0.0")) {
     log.error("Requires Node 18 (or higher)");
     process.exit(1);
   }
@@ -670,7 +725,8 @@ export const generate = async ({
     platforms,
   });
 
-  const htmlTemplatePath = getHtmlTemplatePath({
+  const htmlTemplatePath = await getHtmlTemplatePath({
+    isExpo,
     html,
     platforms,
   });
@@ -735,6 +791,29 @@ export const generate = async ({
     );
 
     if (!isExpo) {
+      const manifestXmlPath = path.resolve(
+        androidOutputPath,
+        "..",
+        "AndroidManifest.xml",
+      );
+
+      const manifestXml = readXmlLike(manifestXmlPath);
+      const activities = manifestXml.root.querySelectorAll("activity");
+
+      for (const activity of activities) {
+        if (activity.getAttribute("android:name") === ".MainActivity") {
+          activity.setAttribute("android:theme", "@style/BootTheme");
+        }
+      }
+
+      await writeXmlLike(manifestXmlPath, manifestXml.root.toString(), {
+        ...manifestXml.formatOptions,
+        formatter: "prettier",
+        htmlWhitespaceSensitivity: "ignore",
+        selfClosingTags: true,
+        singleAttributePerLine: true,
+      });
+
       const valuesPath = path.resolve(androidOutputPath, "values");
       hfs.ensureDir(valuesPath);
 
@@ -742,23 +821,86 @@ export const generate = async ({
       const colorsXmlEntry = `<color name="bootsplash_background">${background.hex}</color>`;
 
       if (hfs.exists(colorsXmlPath)) {
-        const { root, formatOptions } = readXml(colorsXmlPath);
+        const colorsXml = readXmlLike(colorsXmlPath);
         const nextColor = parseHtml(colorsXmlEntry);
 
-        const prevColor = root.querySelector(
+        const prevColor = colorsXml.root.querySelector(
           'color[name="bootsplash_background"]',
         );
 
         if (prevColor != null) {
           prevColor.replaceWith(nextColor);
         } else {
-          root.querySelector("resources")?.appendChild(nextColor);
+          colorsXml.root.querySelector("resources")?.appendChild(nextColor);
         }
 
-        writeXml(colorsXmlPath, root.toString(), formatOptions);
+        await writeXmlLike(colorsXmlPath, colorsXml.root.toString(), {
+          ...colorsXml.formatOptions,
+          formatter: "xmlFormatter",
+        });
       } else {
-        writeXml(colorsXmlPath, `<resources>${colorsXmlEntry}</resources>`);
+        await writeXmlLike(
+          colorsXmlPath,
+          `<resources>${colorsXmlEntry}</resources>`,
+          { formatter: "xmlFormatter" },
+        );
       }
+
+      const stylesXmlPath = path.resolve(valuesPath, "styles.xml");
+      const stylesXml = readXmlLike(stylesXmlPath);
+
+      const prevStyle = stylesXml.root.querySelector('style[name="BootTheme"]');
+      const parent = prevStyle?.getAttribute("parent") ?? "Theme.BootSplash";
+
+      const extraItems = parseHtml(
+        prevStyle?.text
+          .split("\n")
+          .map((line) => line.trim())
+          .join("") ?? "",
+      )
+        .childNodes.filter((node) => {
+          if (!(node instanceof HTMLElement)) {
+            return true;
+          }
+
+          const name = node.getAttribute("name");
+
+          return (
+            name !== "bootSplashBackground" &&
+            name !== "bootSplashLogo" &&
+            name !== "bootSplashBrand" &&
+            name !== "postBootSplashTheme"
+          );
+        })
+        .map((node) => node.toString());
+
+      const styleItems: string[] = [
+        ...(extraItems.length > 0 ? [...extraItems, ""] : []),
+
+        '<item name="bootSplashBackground">@color/bootsplash_background</item>',
+        '<item name="bootSplashLogo">@drawable/bootsplash_logo</item>',
+
+        ...(brand != null && brandPath != null
+          ? ['<item name="bootSplashBrand">@drawable/bootsplash_brand</item>']
+          : []),
+
+        '<item name="postBootSplashTheme">@style/AppTheme</item>',
+      ];
+
+      const nextStyle = parseHtml(dedent`
+        <style name="BootTheme" parent="${parent}">
+          ${styleItems.join("\n")}
+        </style>
+      `);
+
+      prevStyle?.remove(); // remove the existing style
+      stylesXml.root.querySelector("resources")?.appendChild(nextStyle);
+
+      await writeXmlLike(stylesXmlPath, stylesXml.root.toString(), {
+        ...stylesXml.formatOptions,
+        formatter: "prettier",
+        htmlWhitespaceSensitivity: "ignore",
+      });
     }
   }
 
@@ -766,7 +908,7 @@ export const generate = async ({
     log.title("🍏", "iOS");
 
     hfs.ensureDir(iosOutputPath);
-    cleanIOS(iosOutputPath);
+    cleanIOSAssets(iosOutputPath);
 
     const storyboardPath = path.resolve(iosOutputPath, "BootSplash.storyboard");
 
@@ -785,7 +927,7 @@ export const generate = async ({
     hfs.ensureDir(colorsSetPath);
     hfs.ensureDir(imageSetPath);
 
-    writeXml(
+    await writeXmlLike(
       storyboardPath,
       getStoryboard({
         logoHeight,
@@ -793,7 +935,10 @@ export const generate = async ({
         background: background.rgb,
         fileNameSuffix,
       }),
-      { whiteSpaceAtEndOfSelfclosingTag: false },
+      {
+        formatter: "xmlFormatter",
+        whiteSpaceAtEndOfSelfclosingTag: false,
+      },
     );
 
     writeJson(path.resolve(colorsSetPath, "Contents.json"), {
@@ -896,18 +1041,19 @@ export const generate = async ({
 
       const project = Expo.IOSConfig.XcodeUtils.getPbxproj(projectRoot);
       const projectName = path.basename(iosOutputPath);
+      const groupName = path.parse(xcodeProjectPath).name;
 
       Expo.IOSConfig.XcodeUtils.addResourceFileToGroup({
-        filepath: path.join(projectName, "BootSplash.storyboard"),
-        groupName: path.parse(xcodeProjectPath).name,
         project,
+        filepath: path.join(projectName, "BootSplash.storyboard"),
+        groupName,
         isBuildFile: true,
       });
 
       Expo.IOSConfig.XcodeUtils.addResourceFileToGroup({
-        filepath: path.join(projectName, "Colors.xcassets"),
-        groupName: path.parse(xcodeProjectPath).name,
         project,
+        filepath: path.join(projectName, "Colors.xcassets"),
+        groupName,
         isBuildFile: true,
       });
 
@@ -919,9 +1065,9 @@ export const generate = async ({
   if (htmlTemplatePath != null) {
     log.title("🌐", "Web");
 
-    const { root, formatOptions } = readHtml(htmlTemplatePath);
+    const htmlTemplate = readXmlLike(htmlTemplatePath);
     const { format } = await logo.metadata();
-    const prevStyle = root.querySelector("#bootsplash-style");
+    const prevStyle = htmlTemplate.root.querySelector("#bootsplash-style");
 
     const base64 = (
       format === "svg"
@@ -960,10 +1106,10 @@ export const generate = async ({
     if (prevStyle != null) {
       prevStyle.replaceWith(nextStyle);
     } else {
-      root.querySelector("head")?.appendChild(nextStyle);
+      htmlTemplate.root.querySelector("head")?.appendChild(nextStyle);
     }
 
-    const prevDiv = root.querySelector("#bootsplash");
+    const prevDiv = htmlTemplate.root.querySelector("#bootsplash");
 
     const nextDiv = parseHtml(dedent`
       <div id="bootsplash">
@@ -974,10 +1120,14 @@ export const generate = async ({
     if (prevDiv != null) {
       prevDiv.replaceWith(nextDiv);
     } else {
-      root.querySelector("body")?.appendChild(nextDiv);
+      htmlTemplate.root.querySelector("body")?.appendChild(nextDiv);
     }
 
-    await writeHtml(htmlTemplatePath, root.toString(), formatOptions);
+    await writeXmlLike(htmlTemplatePath, htmlTemplate.root.toString(), {
+      ...htmlTemplate.formatOptions,
+      formatter: "prettier",
+      useCssPlugin: true,
+    });
   }
 
   log.title("📄", "Assets");
@@ -1060,321 +1210,3 @@ ${pc.blue("┗━━━━━━━━━━━━━━━━━━━━━━
     `\n💖  Thanks for using ${pc.underline("react-native-bootsplash")}`,
   );
 };
-
-export type ExpoProps = {
-  assetsDir?: string;
-  edgeToEdge?: boolean;
-};
-
-export type ExpoPlugin = Expo.ConfigPlugin<ExpoProps>;
-
-const withAndroidAssets: ExpoPlugin = (config, props) =>
-  Expo.withDangerousMod(config, [
-    "android",
-    (config) => {
-      const { assetsDir = "assets/bootsplash" } = props;
-      const { platformProjectRoot } = config.modRequest;
-
-      const srcDir = path.resolve(workingPath, assetsDir, "android");
-
-      const destDir = path.resolve(
-        platformProjectRoot,
-        "app",
-        "src",
-        "main",
-        "res",
-      );
-
-      for (const drawableDir of hfs.readDir(srcDir)) {
-        const srcDrawableDir = path.join(srcDir, drawableDir);
-        const destDrawableDir = path.join(destDir, drawableDir);
-
-        hfs.ensureDir(destDrawableDir);
-
-        for (const file of hfs.readDir(srcDrawableDir)) {
-          hfs.copy(
-            path.join(srcDrawableDir, file),
-            path.join(destDrawableDir, file),
-          );
-        }
-      }
-
-      return config;
-    },
-  ]);
-
-const withAndroidManifest: ExpoPlugin = (config) =>
-  Expo.withAndroidManifest(config, (config) => {
-    config.modResults.manifest.application?.forEach((application) => {
-      if (application.$["android:name"] === ".MainApplication") {
-        const { activity } = application;
-
-        activity?.forEach((activity) => {
-          if (activity.$["android:name"] === ".MainActivity") {
-            activity.$["android:theme"] = "@style/BootTheme";
-          }
-        });
-      }
-    });
-
-    return config;
-  });
-
-const withMainActivity: ExpoPlugin = (config) =>
-  Expo.withMainActivity(config, (config) => {
-    const { modResults } = config;
-    const { language } = modResults;
-
-    const withImports = addImports(
-      modResults.contents.replace(
-        /(\/\/ )?setTheme\(R\.style\.AppTheme\)/,
-        "// setTheme(R.style.AppTheme)",
-      ),
-      ["android.os.Bundle", "com.zoontek.rnbootsplash.RNBootSplash"],
-      language === "java",
-    );
-
-    // indented with 4 spaces
-    const withInit = mergeContents({
-      src: withImports,
-      comment: "    //",
-      tag: "bootsplash-init",
-      offset: 0,
-      anchor: /super\.onCreate\(null\)/,
-      newSrc:
-        "    RNBootSplash.init(this, R.style.BootTheme)" +
-        (language === "java" ? ";" : ""),
-    });
-
-    return {
-      ...config,
-      modResults: {
-        ...modResults,
-        contents: withInit.contents,
-      },
-    };
-  });
-
-const withAndroidStyles: ExpoPlugin = (config, props) =>
-  Expo.withAndroidStyles(config, async (config) => {
-    const { assetsDir = "assets/bootsplash", edgeToEdge = false } = props;
-
-    const manifest = (await hfs.json(
-      path.resolve(workingPath, assetsDir, "manifest.json"),
-    )) as Manifest;
-
-    const item = [
-      {
-        $: { name: "postBootSplashTheme" },
-        _: "@style/AppTheme",
-      },
-      {
-        $: { name: "bootSplashBackground" },
-        _: "@color/bootsplash_background",
-      },
-      {
-        $: { name: "bootSplashLogo" },
-        _: "@drawable/bootsplash_logo",
-      },
-    ];
-
-    if (manifest.brand != null) {
-      item.push({
-        $: { name: "bootSplashBrand" },
-        _: "@drawable/bootsplash_brand",
-      });
-    }
-
-    config.modResults.resources.style
-      ?.filter(({ $ }) => $.name !== "BootTheme")
-      .push({
-        item,
-        $: {
-          name: "BootTheme",
-          parent: edgeToEdge
-            ? "Theme.BootSplash"
-            : "Theme.BootSplash.EdgeToEdge",
-        },
-      });
-
-    return config;
-  });
-
-const withAndroidColors: ExpoPlugin = (config, props) =>
-  Expo.withAndroidColors(config, async (config) => {
-    const { assetsDir = "assets/bootsplash" } = props;
-
-    const manifest = (await hfs.json(
-      path.resolve(workingPath, assetsDir, "manifest.json"),
-    )) as Manifest;
-
-    config.modResults = assignColorValue(config.modResults, {
-      name: "bootsplash_background",
-      value: manifest.background,
-    });
-
-    return config;
-  });
-
-const withAndroidColorsNight: ExpoPlugin = (config, props) =>
-  Expo.withAndroidColorsNight(config, async (config) => {
-    const { assetsDir = "assets/bootsplash" } = props;
-
-    const manifest = (await hfs.json(
-      path.resolve(workingPath, assetsDir, "manifest.json"),
-    )) as Manifest;
-
-    if (manifest.darkBackground != null) {
-      config.modResults = assignColorValue(config.modResults, {
-        name: "bootsplash_background",
-        value: manifest.darkBackground,
-      });
-    }
-
-    return config;
-  });
-
-const withIOSAssets: ExpoPlugin = (config, props) =>
-  Expo.withDangerousMod(config, [
-    "ios",
-    (config) => {
-      const { assetsDir = "assets/bootsplash" } = props;
-      const { platformProjectRoot, projectName = "" } = config.modRequest;
-
-      const srcDir = path.resolve(workingPath, assetsDir, "ios");
-      const destDir = path.resolve(platformProjectRoot, projectName);
-
-      cleanIOS(destDir);
-
-      hfs.copy(
-        path.join(srcDir, "BootSplash.storyboard"),
-        path.join(destDir, "BootSplash.storyboard"),
-      );
-
-      for (const xcassetsDir of ["Colors.xcassets", "Images.xcassets"]) {
-        const srcXcassetsDir = path.join(srcDir, xcassetsDir);
-        const destXcassetsDir = path.join(destDir, xcassetsDir);
-
-        hfs.ensureDir(destXcassetsDir);
-
-        for (const file of hfs.readDir(srcXcassetsDir)) {
-          hfs.copy(
-            path.join(srcXcassetsDir, file),
-            path.join(destXcassetsDir, file),
-          );
-        }
-      }
-
-      return config;
-    },
-  ]);
-
-const withAppDelegate: ExpoPlugin = (config) =>
-  Expo.withAppDelegate(config, (config) => {
-    const [sdkStringVersion = ""] = config.sdkVersion?.split(".") ?? "";
-    const isAtLeastExpo51 = Number.parseInt(sdkStringVersion, 10) >= 51;
-
-    const { modResults } = config;
-    const { language } = modResults;
-
-    if (language !== "objc" && language !== "objcpp") {
-      throw new Error(
-        `Cannot modify the project AppDelegate as it's not in a supported language: ${language}`,
-      );
-    }
-
-    const withHeader = mergeContents({
-      src: modResults.contents,
-      comment: "//",
-      tag: "bootsplash-header",
-      offset: 1,
-      anchor: /#import "AppDelegate\.h"/,
-      newSrc: '#import "RNBootSplash.h"',
-    });
-
-    const withRootView = mergeContents({
-      src: withHeader.contents,
-      comment: "//",
-      tag: "bootsplash-init",
-      offset: 0,
-      anchor: /@end/,
-      newSrc: isAtLeastExpo51
-        ? dedent`
-          - (void)customizeRootView:(RCTRootView *)rootView {
-            [RNBootSplash initWithStoryboard:@"BootSplash" rootView:rootView];
-          }
-        `
-        : dedent`
-          - (UIView *)createRootViewWithBridge:(RCTBridge *)bridge moduleName:(NSString *)moduleName initProps:(NSDictionary *)initProps {
-            UIView *rootView = [super createRootViewWithBridge:bridge moduleName:moduleName initProps:initProps];
-            [RNBootSplash initWithStoryboard:@"BootSplash" rootView:rootView];
-            return rootView;
-          }
-        `,
-    });
-
-    return {
-      ...config,
-      modResults: {
-        ...modResults,
-        contents: withRootView.contents,
-      },
-    };
-  });
-
-const withInfoPlist: ExpoPlugin = (config) =>
-  Expo.withInfoPlist(config, (config) => {
-    config.modResults["UILaunchStoryboardName"] = "BootSplash";
-    return config;
-  });
-
-const withXcodeProject: ExpoPlugin = (config) =>
-  Expo.withXcodeProject(config, (config) => {
-    const { projectName = "" } = config.modRequest;
-
-    Expo.IOSConfig.XcodeUtils.addResourceFileToGroup({
-      filepath: path.join(projectName, "BootSplash.storyboard"),
-      groupName: projectName,
-      project: config.modResults,
-      isBuildFile: true,
-    });
-
-    Expo.IOSConfig.XcodeUtils.addResourceFileToGroup({
-      filepath: path.join(projectName, "Colors.xcassets"),
-      groupName: projectName,
-      project: config.modResults,
-      isBuildFile: true,
-    });
-
-    return config;
-  });
-
-export const withGenerate: ExpoPlugin = (config, props = {}) => {
-  const plugins: ExpoPlugin[] = [];
-  const { platforms = [] } = config;
-
-  if (platforms.includes("android")) {
-    plugins.push(
-      withAndroidAssets,
-      withAndroidManifest,
-      withMainActivity,
-      withAndroidStyles,
-      withAndroidColors,
-      withAndroidColorsNight,
-    );
-  }
-
-  if (platforms.includes("ios")) {
-    plugins.push(
-      withIOSAssets,
-      withAppDelegate,
-      withInfoPlist,
-      withXcodeProject,
-    );
-  }
-
-  return Expo.withPlugins(
-    config,
-    plugins.map((plugin) => [plugin, props]),
-  );
-};