react-native-bootsplash 7.0.0-beta.0 → 7.0.0-beta.2

package/src/generate.ts

@@ -1,12 +1,8 @@
 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 ExpoPlist from "@expo/plist";
 import { projectConfig as getAndroidProjectConfig } from "@react-native-community/cli-config-android";
 import { getProjectConfig as getAppleProjectConfig } from "@react-native-community/cli-config-apple";
 import { findProjectRoot } from "@react-native-community/cli-tools";
-import childProcess from "child_process";
 import crypto from "crypto";
 import detectIndent, { type Indent } from "detect-indent";
 import fs from "fs-extra";
@@ -20,22 +16,12 @@ import * as prettier from "prettier/standalone";
 import semver from "semver";
 import sharp, { type Sharp } from "sharp";
 import { dedent } from "ts-dedent";
-import util from "util";
 import formatXml, { type XMLFormatterOptions } from "xml-formatter";
 import type { Manifest } from ".";
 
-const PACKAGE_NAME = "react-native-bootsplash";
+type Platforms = ("android" | "ios" | "web")[];
 
-let isExpo = false;
-
-export const workingPath =
-  process.env.INIT_CWD ?? process.env.PWD ?? process.cwd();
-
-const projectRoot = findProjectRoot(workingPath);
-
-export type Platforms = ("android" | "ios" | "web")[];
-
-export type RGBColor = {
+type RGBColor = {
   R: string;
   G: string;
   B: string;
@@ -46,16 +32,19 @@ type Color = {
   rgb: RGBColor;
 };
 
-const promisifiedExec = util.promisify(childProcess.exec);
+export const packageName = "react-native-bootsplash";
+const workingPath = process.env.INIT_CWD ?? process.env.PWD ?? process.cwd();
+const projectRoot = findProjectRoot(workingPath);
 
-const exec = (cmd: string) =>
-  promisifiedExec(cmd).then(({ stdout, stderr }) => stdout || stderr);
+let isExpo = false;
+
+export const setIsExpo = (value: boolean) => {
+  isExpo = value;
+};
 
 export const log = {
   error: (text: string) => {
-    console.log(
-      pc.red(isExpo ? `❌ [${PACKAGE_NAME}] ${text}` : `❌  ${text}`),
-    );
+    console.log(pc.red(isExpo ? `❌ [${packageName}] ${text}` : `❌  ${text}`));
   },
   title: (emoji: string, text: string) => {
     if (!isExpo) {
@@ -64,7 +53,7 @@ export const log = {
   },
   warn: (text: string) => {
     console.log(
-      pc.yellow(isExpo ? `⚠️  [${PACKAGE_NAME}] ${text}` : `⚠️  ${text}`),
+      pc.yellow(isExpo ? `⚠️  [${packageName}] ${text}` : `⚠️  ${text}`),
     );
   },
   write: (filePath: string, dimensions?: { width: number; height: number }) => {
@@ -101,9 +90,8 @@ const parseColor = (value: string): Color => {
   return { hex: hex.toLowerCase(), rgb };
 };
 
-const getStoryboard = ({ props, extras }: { props: Props; extras: Extras }) => {
-  const { background, logo } = props;
-  const { fileNameSuffix, logoHeight } = extras;
+const getStoryboard = (props: Props) => {
+  const { background, logo, fileNameSuffix } = props;
 
   const { R, G, B } = background.rgb;
   const frameWidth = 375;
@@ -130,7 +118,7 @@ const getStoryboard = ({ props, extras }: { props: Props; extras: Extras }) => {
                         <autoresizingMask key="autoresizingMask" widthSizable="YES" heightSizable="YES"/>
                         <subviews>
                             <imageView autoresizesSubviews="NO" clipsSubviews="YES" userInteractionEnabled="NO" contentMode="scaleAspectFit" image="BootSplashLogo-${fileNameSuffix}" translatesAutoresizingMaskIntoConstraints="NO" id="3lX-Ut-9ad">
-                                <rect key="frame" x="${(frameWidth - logo.width) / 2}" y="${(frameHeight - logoHeight) / 2}" width="${logo.width}" height="${logoHeight}"/>
+                                <rect key="frame" x="${(frameWidth - logo.width) / 2}" y="${(frameHeight - logo.height) / 2}" width="${logo.width}" height="${logo.height}"/>
                                 <accessibility key="accessibilityConfiguration">
                                     <accessibilityTraits key="traits" image="YES" notEnabled="YES"/>
                                 </accessibility>
@@ -150,7 +138,7 @@ const getStoryboard = ({ props, extras }: { props: Props; extras: Extras }) => {
         </scene>
     </scenes>
     <resources>
-        <image name="BootSplashLogo-${fileNameSuffix}" width="${logo.width}" height="${logoHeight}"/>
+        <image name="BootSplashLogo-${fileNameSuffix}" width="${logo.width}" height="${logo.height}"/>
         <namedColor name="BootSplashBackground-${fileNameSuffix}">
             <color red="${R}" green="${G}" blue="${B}" alpha="1" colorSpace="custom" customColorSpace="sRGB"/>
         </namedColor>
@@ -255,37 +243,6 @@ export const writeXmlLike = async (
   }
 };
 
-export type Asset = {
-  path: string;
-  image: Sharp;
-  width: number;
-};
-
-const getAssetBase64 = async (
-  name: string,
-  asset: Asset | undefined,
-): Promise<string> => {
-  if (asset == null) {
-    return "";
-  }
-
-  const { image, width } = asset;
-  const { format } = await image.metadata();
-
-  if (format !== "png" && format !== "svg") {
-    log.error(`${name} image file format (${format}) is not supported`);
-    process.exit(1);
-  }
-
-  const buffer = await image
-    .clone()
-    .resize(width)
-    .png({ quality: 100 })
-    .toBuffer();
-
-  return buffer.toString("base64");
-};
-
 const getAndroidOutputPath = ({
   flavor,
   platforms,
@@ -390,20 +347,51 @@ const getInfoPlistPath = ({
   return path.resolve(iosOutputPath, "Info.plist");
 };
 
-const getAssetHeight = (asset: Asset | undefined): Promise<number> => {
-  if (asset == null) {
-    return Promise.resolve(0);
+export type Asset = {
+  path: string;
+  image: Sharp;
+  hash: string;
+  height: number;
+  width: number;
+};
+
+const toAsset = async (filePath: string, width: number): Promise<Asset> => {
+  const image = sharp(filePath);
+  const { format } = await image.metadata();
+
+  if (format !== "png" && format !== "svg") {
+    log.error(
+      `${path.basename(filePath)} image file format (${format}) is not supported`,
+    );
+    process.exit(1);
   }
 
-  return asset.image
-    .clone()
-    .resize(asset.width)
-    .toBuffer()
-    .then((buffer) => sharp(buffer).metadata())
-    .then(({ height = 0 }) => Math.round(height));
+  const [height, hash] = await Promise.all([
+    image
+      .clone()
+      .resize(width)
+      .toBuffer()
+      .then((buffer) => sharp(buffer).metadata())
+      .then(({ height = 0 }) => Math.round(height)),
+
+    image
+      .clone()
+      .resize(width)
+      .png({ quality: 100 })
+      .toBuffer()
+      .then((buffer) => buffer.toString("base64")),
+  ]);
+
+  return {
+    path: filePath,
+    image,
+    hash,
+    height,
+    width,
+  };
 };
 
-type Config = {
+export type RawProps = {
   logo: string;
   background: string;
   logoWidth: number;
@@ -421,57 +409,46 @@ type Config = {
   };
 };
 
-const getProps = ({ android = {}, licenseKey, ...config }: Config) => {
+export const transformProps = async (
+  rootPath: string,
+  { android = {}, licenseKey, ...rawProps }: RawProps,
+) => {
   if (semver.lt(process.versions.node, "20.0.0")) {
     log.error("Requires Node 20 (or higher)");
     process.exit(1);
   }
 
-  const assetsOutputPath = path.resolve(workingPath, config.assetsOutput);
-  const logoPath = path.resolve(workingPath, config.logo);
+  const assetsOutputPath = path.resolve(rootPath, rawProps.assetsOutput);
+  const logoPath = path.resolve(rootPath, rawProps.logo);
 
   const darkLogoPath =
-    config.darkLogo != null
-      ? path.resolve(workingPath, config.darkLogo)
+    rawProps.darkLogo != null
+      ? path.resolve(rootPath, rawProps.darkLogo)
       : undefined;
 
   const brandPath =
-    config.brand != null ? path.resolve(workingPath, config.brand) : undefined;
+    rawProps.brand != null ? path.resolve(rootPath, rawProps.brand) : undefined;
 
   const darkBrandPath =
-    config.darkBrand != null
-      ? path.resolve(workingPath, config.darkBrand)
-      : undefined;
-
-  const logoWidth = config.logoWidth - (config.logoWidth % 2);
-  const brandWidth = config.brandWidth - (config.brandWidth % 2);
-
-  const logo: Asset = {
-    path: logoPath,
-    image: sharp(logoPath),
-    width: logoWidth,
-  };
-
-  const darkLogo: Asset | undefined =
-    darkLogoPath != null
-      ? { path: darkLogoPath, image: sharp(darkLogoPath), width: logoWidth }
+    rawProps.darkBrand != null
+      ? path.resolve(rootPath, rawProps.darkBrand)
       : undefined;
 
-  const brand: Asset | undefined =
-    brandPath != null
-      ? { path: brandPath, image: sharp(brandPath), width: brandWidth }
-      : undefined;
+  const logoWidth = rawProps.logoWidth - (rawProps.logoWidth % 2);
+  const brandWidth = rawProps.brandWidth - (rawProps.brandWidth % 2);
 
-  const darkBrand: Asset | undefined =
-    darkBrandPath != null
-      ? { path: darkBrandPath, image: sharp(darkBrandPath), width: brandWidth }
-      : undefined;
+  const [logo, darkLogo, brand, darkBrand] = await Promise.all([
+    toAsset(logoPath, logoWidth),
+    darkLogoPath != null ? toAsset(darkLogoPath, logoWidth) : undefined,
+    brandPath != null ? toAsset(brandPath, brandWidth) : undefined,
+    darkBrandPath != null ? toAsset(darkBrandPath, brandWidth) : undefined,
+  ]);
 
-  const background = parseColor(config.background);
+  const background = parseColor(rawProps.background);
 
   const darkBackground =
-    config.darkBackground != null
-      ? parseColor(config.darkBackground)
+    rawProps.darkBackground != null
+      ? parseColor(rawProps.darkBackground)
       : undefined;
 
   const executeAddon =
@@ -515,66 +492,24 @@ const getProps = ({ android = {}, licenseKey, ...config }: Config) => {
     process.exit(1);
   }
 
-  if (logoWidth < config.logoWidth) {
+  if (logoWidth < rawProps.logoWidth) {
     log.warn(
       `Logo width must be a multiple of 2. It has been rounded to ${logoWidth}dp.`,
     );
   }
-  if (brandWidth < config.brandWidth) {
+  if (brandWidth < rawProps.brandWidth) {
     log.warn(
       `Brand width must be a multiple of 2. It has been rounded to ${brandWidth}dp.`,
     );
   }
 
-  return {
-    android,
-    assetsOutputPath,
-    licenseKey,
-    executeAddon,
-    background,
-    darkBackground,
-    logo,
-    darkLogo,
-    brand,
-    darkBrand,
-  };
-};
-
-export type Props = ReturnType<typeof getProps>;
-
-export const getExtras = async ({
-  background,
-  darkBackground,
-  logo,
-  darkLogo,
-  brand,
-  darkBrand,
-}: Props) => {
-  const [
-    logoHash,
-    darkLogoHash,
-    brandHash,
-    darkBrandHash,
-
-    logoHeight,
-    brandHeight,
-  ] = await Promise.all([
-    getAssetBase64("Logo", logo),
-    getAssetBase64("Dark logo", darkLogo),
-    getAssetBase64("Brand", brand),
-    getAssetBase64("Dark brand", darkBrand),
-
-    getAssetHeight(logo),
-    getAssetHeight(brand),
-  ]);
-
   const record: Record<string, string> = {
     background: background.hex,
     darkBackground: darkBackground?.hex ?? "",
-    logo: logoHash,
-    darkLogo: darkLogoHash,
-    brand: brandHash,
-    darkBrand: darkBrandHash,
+    logo: logo.hash,
+    darkLogo: darkLogo?.hash ?? "",
+    brand: brand?.hash ?? "",
+    darkBrand: darkBrand?.hash ?? "",
   };
 
   const stableKey = Object.keys(record)
@@ -589,38 +524,44 @@ export const getExtras = async ({
     .toLowerCase();
 
   return {
+    android,
+    assetsOutputPath,
+    licenseKey,
+    executeAddon,
+    background,
+    darkBackground,
+    logo,
+    darkLogo,
+    brand,
+    darkBrand,
     fileNameSuffix,
-    logoHeight,
-    brandHeight,
   };
 };
 
-export type Extras = Awaited<ReturnType<typeof getExtras>>;
+export type Props = Awaited<ReturnType<typeof transformProps>>;
 
 export const writeAndroidAssets = async ({
   androidOutputPath,
   props,
-  extras,
 }: {
   androidOutputPath: string;
   props: Props;
-  extras: Extras;
 }) => {
   const { logo, brand } = props;
 
-  if (logo.width > 192 || extras.logoHeight > 192) {
+  if (logo.width > 192 || logo.height > 192) {
     return log.warn(
       "Logo size exceeding 192x192dp will be cropped by Android. Skipping Android assets generation…",
     );
   }
 
-  if (brand != null && (brand.width > 200 || extras.brandHeight > 80)) {
+  if (brand != null && (brand.width > 200 || brand.height > 80)) {
     return log.warn(
       "Brand size exceeding 200x80dp will be cropped by Android. Skipping Android assets generation…",
     );
   }
 
-  if (logo.width > 134 || extras.logoHeight > 134) {
+  if (logo.width > 134 || logo.height > 134) {
     log.warn("Logo size exceeds 134x134dp. It might be cropped by Android.");
   }
 
@@ -682,13 +623,11 @@ export const writeAndroidAssets = async ({
 export const writeIOSAssets = async ({
   iosOutputPath,
   props,
-  extras,
 }: {
   iosOutputPath: string;
   props: Props;
-  extras: Extras;
 }) => {
-  const { background, logo } = props;
+  const { background, logo, fileNameSuffix } = props;
 
   log.title("🍏", "iOS");
   hfs.ensureDir(iosOutputPath);
@@ -710,7 +649,7 @@ export const writeIOSAssets = async ({
 
   const storyboardPath = path.resolve(iosOutputPath, "BootSplash.storyboard");
 
-  await writeXmlLike(storyboardPath, getStoryboard({ props, extras }), {
+  await writeXmlLike(storyboardPath, getStoryboard(props), {
     formatter: "xmlFormatter",
     whiteSpaceAtEndOfSelfclosingTag: false,
   });
@@ -718,7 +657,7 @@ export const writeIOSAssets = async ({
   const colorsSetPath = path.resolve(
     iosOutputPath,
     "Colors.xcassets",
-    `BootSplashBackground-${extras.fileNameSuffix}.colorset`,
+    `BootSplashBackground-${fileNameSuffix}.colorset`,
   );
 
   hfs.ensureDir(colorsSetPath);
@@ -744,12 +683,12 @@ export const writeIOSAssets = async ({
     },
   });
 
-  const logoFileName = `logo-${extras.fileNameSuffix}`;
+  const logoFileName = `logo-${fileNameSuffix}`;
 
   const imagesSetPath = path.resolve(
     iosOutputPath,
     "Images.xcassets",
-    `BootSplashLogo-${extras.fileNameSuffix}.imageset`,
+    `BootSplashLogo-${fileNameSuffix}.imageset`,
   );
 
   hfs.ensureDir(imagesSetPath);
@@ -804,11 +743,9 @@ export const writeIOSAssets = async ({
 export const writeWebAssets = async ({
   htmlTemplatePath,
   props,
-  extras,
 }: {
   htmlTemplatePath: string;
   props: Props;
-  extras: Extras;
 }) => {
   const { background, logo } = props;
 
@@ -847,7 +784,7 @@ export const writeWebAssets = async ({
       #bootsplash-logo {
         content: url("${dataURI}");
         width: ${logo.width}px;
-        height: ${extras.logoHeight}px;
+        height: ${logo.height}px;
       }
     </style>
   `);
@@ -879,13 +816,7 @@ export const writeWebAssets = async ({
   });
 };
 
-export const writeGenericAssets = async ({
-  props,
-  extras,
-}: {
-  props: Props;
-  extras: Extras;
-}) => {
+export const writeGenericAssets = async ({ props }: { props: Props }) => {
   const { assetsOutputPath, background, logo } = props;
 
   log.title("📄", "Assets");
@@ -895,7 +826,7 @@ export const writeGenericAssets = async ({
     background: background.hex,
     logo: {
       width: logo.width,
-      height: extras.logoHeight,
+      height: logo.height,
     },
   } satisfies Manifest);
 
@@ -923,28 +854,48 @@ export const writeGenericAssets = async ({
 
 export type AddonConfig = {
   props: Props;
-  extras: Extras;
-
   androidOutputPath: string | void;
   iosOutputPath: string | void;
   htmlTemplatePath: string | void;
 };
 
-const requireAddon = ():
+export const requireAddon = ({
+  executeAddon,
+  licenseKey,
+}: Props):
   | {
       execute: (config: AddonConfig) => Promise<void>;
 
-      withAndroidAssets: Expo.ConfigPlugin<Props>;
-      withAndroidColorsNight: Expo.ConfigPlugin<Props>;
-      withIOSAssets: Expo.ConfigPlugin<Props>;
-      withWebAssets: Expo.ConfigPlugin<Props>;
-      withGenericAssets: Expo.ConfigPlugin<Props>;
+      writeAndroidAssets: (_: {
+        androidOutputPath: string;
+        props: Props;
+      }) => Promise<void>;
+
+      writeIOSAssets: (_: {
+        iosOutputPath: string;
+        props: Props;
+      }) => Promise<void>;
+
+      writeWebAssets: (_: {
+        htmlTemplatePath: string;
+        props: Props;
+      }) => Promise<void>;
+
+      writeGenericAssets: (_: { props: Props }) => Promise<void>;
+
+      withAndroidColorsNight: (_: {
+        config: Expo.ExportedConfigWithProps;
+        props: Props;
+      }) => Promise<Expo.ExportedConfigWithProps>;
     }
   | undefined => {
-  try {
-    return require("./addon");
-  } catch {
-    return;
+  if (licenseKey != null && executeAddon) {
+    try {
+      const addon = require("./dist/commonjs/addon");
+      return "default" in addon ? addon.default : addon;
+    } catch {
+      return;
+    }
   }
 };
 
@@ -953,7 +904,7 @@ export const generate = async ({
   html,
   flavor,
   plist,
-  ...config
+  ...rawProps
 }: {
   platforms: Platforms;
   html: string;
@@ -971,16 +922,17 @@ export const generate = async ({
   darkLogo?: string;
   darkBrand?: string;
 }) => {
-  const props = getProps(config);
-  const { background, brand, licenseKey, executeAddon } = props;
-  const extras = await getExtras(props);
+  const props = await transformProps(workingPath, rawProps);
+  const addon = requireAddon(props);
+
+  const { background, brand } = props;
 
   const androidOutputPath = getAndroidOutputPath({ flavor, platforms });
   const iosOutputPath = getIOSOutputPath({ platforms });
   const htmlTemplatePath = getHtmlTemplatePath({ html, platforms });
 
   if (androidOutputPath != null) {
-    await writeAndroidAssets({ androidOutputPath, props, extras });
+    await writeAndroidAssets({ androidOutputPath, props });
 
     const manifestXmlPath = path.resolve(
       androidOutputPath,
@@ -1103,31 +1055,7 @@ export const generate = async ({
   }
 
   if (iosOutputPath != null) {
-    await writeIOSAssets({ iosOutputPath, props, extras });
-
-    const infoPlistPath = getInfoPlistPath({ iosOutputPath, plist });
-
-    if (infoPlistPath != null) {
-      const infoPlist = ExpoPlist.parse(hfs.text(infoPlistPath)) as Record<
-        string,
-        unknown
-      >;
-
-      infoPlist["UILaunchStoryboardName"] = "BootSplash";
-
-      const formatted = formatXml(ExpoPlist.build(infoPlist), {
-        collapseContent: true,
-        forceSelfClosingEmptyTag: false,
-        indentation: "\t",
-        lineSeparator: "\n",
-        whiteSpaceAtEndOfSelfclosingTag: false,
-      })
-        .replace(/<string\/>/gm, "<string></string>")
-        .replace(/^\t/gm, "");
-
-      hfs.write(infoPlistPath, formatted);
-      log.write(infoPlistPath);
-    }
+    await writeIOSAssets({ iosOutputPath, props });
 
     const pbxprojectPath = Expo.IOSConfig.Paths.getPBXProjectPath(projectRoot);
 
@@ -1154,21 +1082,41 @@ export const generate = async ({
 
     hfs.write(pbxprojectPath, project.writeSync());
     log.write(pbxprojectPath);
+
+    const infoPlistPath = getInfoPlistPath({ iosOutputPath, plist });
+
+    if (infoPlistPath != null) {
+      const infoPlist = ExpoPlist.parse(hfs.text(infoPlistPath)) as Record<
+        string,
+        unknown
+      >;
+
+      infoPlist["UILaunchStoryboardName"] = "BootSplash";
+
+      const formatted = formatXml(ExpoPlist.build(infoPlist), {
+        collapseContent: true,
+        forceSelfClosingEmptyTag: false,
+        indentation: "\t",
+        lineSeparator: "\n",
+        whiteSpaceAtEndOfSelfclosingTag: false,
+      })
+        .replace(/<string\/>/gm, "<string></string>")
+        .replace(/^\t/gm, "");
+
+      hfs.write(infoPlistPath, formatted);
+      log.write(infoPlistPath);
+    }
   }
 
   if (htmlTemplatePath != null) {
-    await writeWebAssets({ htmlTemplatePath, props, extras });
+    await writeWebAssets({ htmlTemplatePath, props });
   }
 
-  await writeGenericAssets({ props, extras });
+  await writeGenericAssets({ props });
 
-  if (licenseKey != null && executeAddon) {
-    const addon = requireAddon();
-
-    await addon?.execute({
+  if (addon != null) {
+    await addon.execute({
       props,
-      extras,
-
       androidOutputPath,
       iosOutputPath,
       htmlTemplatePath,
@@ -1189,342 +1137,3 @@ ${pc.blue("┗━━━━━━━━━━━━━━━━━━━━━━
     `\n💖  Thanks for using ${pc.underline("react-native-bootsplash")}`,
   );
 };
-
-// Expo plugin
-
-const withoutExpoSplashScreen: Expo.ConfigPlugin<Props> =
-  Expo.createRunOncePlugin((config) => config, "expo-splash-screen", "skip");
-
-const withAndroidAssets: Expo.ConfigPlugin<Props> = (config, props) =>
-  Expo.withDangerousMod(config, [
-    "android",
-    async (config) => {
-      const { platformProjectRoot } = config.modRequest;
-      const extras = await getExtras(props);
-
-      const androidOutputPath = path.resolve(
-        platformProjectRoot,
-        "app",
-        "src",
-        "main",
-        "res",
-      );
-
-      await writeAndroidAssets({ androidOutputPath, props, extras });
-      return config;
-    },
-  ]);
-
-const withAndroidManifest: Expo.ConfigPlugin<Props> = (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: Expo.ConfigPlugin<Props> = (config) =>
-  Expo.withMainActivity(config, (config) => {
-    const { modResults } = config;
-
-    const withImports = addImports(
-      modResults.contents.replace(
-        /(\/\/ )?setTheme\(R\.style\.AppTheme\)/,
-        "// setTheme(R.style.AppTheme)",
-      ),
-      ["android.os.Bundle", "com.zoontek.rnbootsplash.RNBootSplash"],
-      false,
-    );
-
-    // 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)",
-    });
-
-    return {
-      ...config,
-      modResults: {
-        ...modResults,
-        contents: withInit.contents,
-      },
-    };
-  });
-
-const withAndroidStyles: Expo.ConfigPlugin<Props> = (config, props) =>
-  Expo.withAndroidStyles(config, (config) => {
-    const { android, brand } = props;
-    const { darkContentBarsStyle } = android;
-
-    const { modResults } = config;
-    const { resources } = modResults;
-    const { style = [] } = resources;
-
-    const item = [
-      {
-        $: { name: "postBootSplashTheme" },
-        _: "@style/AppTheme",
-      },
-      {
-        $: { name: "bootSplashBackground" },
-        _: "@color/bootsplash_background",
-      },
-      {
-        $: { name: "bootSplashLogo" },
-        _: "@drawable/bootsplash_logo",
-      },
-    ];
-
-    if (brand != null) {
-      item.push({
-        $: { name: "bootSplashBrand" },
-        _: "@drawable/bootsplash_brand",
-      });
-    }
-    if (darkContentBarsStyle != null) {
-      item.push({
-        $: { name: "darkContentBarsStyle" },
-        _: String(darkContentBarsStyle),
-      });
-    }
-
-    const withBootTheme = [
-      ...style.filter(({ $ }) => $.name !== "BootTheme"),
-      {
-        $: {
-          name: "BootTheme",
-          parent: "Theme.BootSplash",
-        },
-        item,
-      },
-    ];
-
-    return {
-      ...config,
-      modResults: {
-        ...modResults,
-        resources: {
-          ...resources,
-          style: withBootTheme,
-        },
-      },
-    };
-  });
-
-const withAndroidColors: Expo.ConfigPlugin<Props> = (config, props) =>
-  Expo.withAndroidColors(config, (config) => {
-    const { background } = props;
-
-    config.modResults = assignColorValue(config.modResults, {
-      name: "bootsplash_background",
-      value: background.hex,
-    });
-
-    return config;
-  });
-
-const withIOSAssets: Expo.ConfigPlugin<Props> = (config, props) =>
-  Expo.withDangerousMod(config, [
-    "ios",
-    async (config) => {
-      const { platformProjectRoot, projectName = "" } = config.modRequest;
-      const extras = await getExtras(props);
-      const iosOutputPath = path.resolve(platformProjectRoot, projectName);
-
-      await writeIOSAssets({ iosOutputPath, props, extras });
-      return config;
-    },
-  ]);
-
-const withAppDelegate: Expo.ConfigPlugin<Props> = (config) =>
-  Expo.withAppDelegate(config, (config) => {
-    const { modResults } = config;
-    const { language } = modResults;
-
-    if (language !== "objc" && language !== "objcpp" && language !== "swift") {
-      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 Expo/,
-      newSrc: "import RNBootSplash",
-    });
-
-    const withRootView = mergeContents({
-      src: withHeader.contents,
-      comment: "//",
-      tag: "bootsplash-init",
-      offset: 1,
-      anchor: /class ReactNativeDelegate: ExpoReactNativeFactoryDelegate {/,
-      newSrc: dedent`
-        public override func customize(_ rootView: UIView) {
-          super.customize(rootView)
-          RNBootSplash.initWithStoryboard("BootSplash", rootView: rootView)
-        }
-      `,
-    });
-
-    return {
-      ...config,
-      modResults: {
-        ...modResults,
-        contents: withRootView.contents,
-      },
-    };
-  });
-
-const withInfoPlist: Expo.ConfigPlugin<Props> = (config) =>
-  Expo.withInfoPlist(config, (config) => {
-    config.modResults["UILaunchStoryboardName"] = "BootSplash";
-    return config;
-  });
-
-const withXcodeProject: Expo.ConfigPlugin<Props> = (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;
-  });
-
-const withWebAssets: Expo.ConfigPlugin<Props> = (config, props) =>
-  Expo.withDangerousMod(config, [
-    config.platforms?.includes("ios") ? "ios" : "android",
-    async (config) => {
-      const extras = await getExtras(props);
-      const fileName = "public/index.html";
-      const htmlTemplatePath = path.resolve(workingPath, fileName);
-
-      if (!hfs.exists(htmlTemplatePath)) {
-        await exec(`npx expo customize ${fileName}`);
-      }
-
-      await writeWebAssets({ htmlTemplatePath, props, extras });
-      return config;
-    },
-  ]);
-
-const withGenericAssets: Expo.ConfigPlugin<Props> = (config, props) =>
-  Expo.withDangerousMod(config, [
-    config.platforms?.includes("ios") ? "ios" : "android",
-    async (config) => {
-      const extras = await getExtras(props);
-      await writeGenericAssets({ props, extras });
-      return config;
-    },
-  ]);
-
-export const withBootSplash = Expo.createRunOncePlugin<
-  | {
-      logo: string;
-      background?: string;
-      logoWidth?: number;
-      assetsOutput?: string;
-
-      licenseKey?: string;
-      brand?: string;
-      brandWidth?: number;
-      darkBackground?: string;
-      darkLogo?: string;
-      darkBrand?: string;
-
-      android?: {
-        darkContentBarsStyle?: boolean;
-      };
-    }
-  | undefined
->((config, baseProps) => {
-  const { platforms = [], sdkVersion = "0.1.0" } = config;
-
-  isExpo = true;
-
-  if (semver.lt(sdkVersion, "53.0.0")) {
-    log.error("Requires Expo 53.0.0 (or higher)");
-    process.exit(1);
-  }
-
-  if (!baseProps?.logo) {
-    log.error("Missing required parameter 'logo'");
-    process.exit(1);
-  }
-
-  const props = getProps({
-    assetsOutput: "assets/bootsplash",
-    background: "#fff",
-    brandWidth: 80,
-    logoWidth: 100,
-    ...baseProps,
-  });
-
-  const { executeAddon } = props;
-  const addon = executeAddon ? requireAddon() : undefined;
-
-  const plugins: Expo.ConfigPlugin<Props>[] = [
-    withoutExpoSplashScreen,
-    addon?.withGenericAssets ?? withGenericAssets,
-  ];
-
-  if (platforms.includes("android")) {
-    plugins.push(
-      addon?.withAndroidAssets ?? withAndroidAssets,
-      withAndroidManifest,
-      withMainActivity,
-      withAndroidStyles,
-      withAndroidColors,
-    );
-
-    if (addon != null) {
-      plugins.push(addon.withAndroidColorsNight);
-    }
-  }
-
-  if (platforms.includes("ios")) {
-    plugins.push(
-      addon?.withIOSAssets ?? withIOSAssets,
-      withAppDelegate,
-      withInfoPlist,
-      withXcodeProject,
-    );
-  }
-
-  if (platforms.includes("web")) {
-    plugins.push(addon?.withWebAssets ?? withWebAssets);
-  }
-
-  return Expo.withPlugins(
-    config,
-    plugins.map((plugin) => [plugin, props]),
-  );
-}, PACKAGE_NAME);