expo-app-icon 1.0.0

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "expo-app-icon",
+  "version": "1.0.0",
+  "description": "Programmatically change the app icon at runtime in Expo, with Android adaptive-icon support.",
+  "main": "build/index.js",
+  "types": "build/index.d.ts",
+  "files": [
+    "build",
+    "android",
+    "ios",
+    "plugin/build",
+    "app.plugin.js",
+    "expo-module.config.json"
+  ],
+  "scripts": {
+    "build": "expo-module build",
+    "build:plugin": "tsc --build ./plugin",
+    "clean": "expo-module clean",
+    "lint": "expo-module lint",
+    "typecheck": "tsgo --noEmit -p tsconfig.json && tsgo --noEmit -p plugin/tsconfig.json",
+    "test": "vp test run",
+    "test:watch": "vp test",
+    "prepublishOnly": "expo-module prepublishOnly",
+    "expo-module": "expo-module"
+  },
+  "keywords": [
+    "react-native",
+    "expo",
+    "app-icon",
+    "adaptive-icon"
+  ],
+  "repository": "https://github.com/Daniel-Griffiths/expo-app-icon",
+  "bugs": {
+    "url": "https://github.com/Daniel-Griffiths/expo-app-icon/issues"
+  },
+  "author": "Daniel Griffiths",
+  "license": "MIT",
+  "homepage": "https://github.com/Daniel-Griffiths/expo-app-icon#readme",
+  "dependencies": {
+    "@expo/image-utils": "^0.8.7",
+    "jimp-compact": "^0.16.1",
+    "xcode": "^3.0.1"
+  },
+  "devDependencies": {
+    "@types/node": "^25.9.2",
+    "@types/react": "~19.2.17",
+    "@typescript/native-preview": "^7.0.0-dev.20260618.1",
+    "expo": "~56.0.8",
+    "expo-module-scripts": "~56.0.3",
+    "typescript": "~6.0.3",
+    "vite-plus": "^0.1.22",
+    "vitest": "4.1.8"
+  },
+  "peerDependencies": {
+    "expo": "^52 || ^53 || ^54 || ^55 || ^56",
+    "react": "*",
+    "react-native": "*"
+  }
+}

package/plugin/build/android-resources.d.ts

@@ -0,0 +1,89 @@
+/**
+ * Pure helpers describing how Android launcher icons are laid out on disk.
+ * Kept free of `expo`/`fs` imports so the logic can be unit-tested directly.
+ */
+/**
+ * Density bucket directory → foreground pixel size (108dp at each scale).
+ */
+export declare const ANDROID_DENSITY_SIZES: {
+    readonly "mipmap-mdpi": 108;
+    readonly "mipmap-hdpi": 162;
+    readonly "mipmap-xhdpi": 216;
+    readonly "mipmap-xxhdpi": 324;
+    readonly "mipmap-xxxhdpi": 432;
+};
+export type AndroidDensityDir = keyof typeof ANDROID_DENSITY_SIZES;
+export declare const ANDROID_DENSITY_DIRS: AndroidDensityDir[];
+/**
+ * Directory holding version-26+ adaptive-icon XML.
+ */
+export declare const ADAPTIVE_ICON_DIR = "mipmap-anydpi-v26";
+/**
+ * Adaptive icons require this API level; below it legacy bitmaps are needed.
+ */
+export declare const ADAPTIVE_ICON_MIN_SDK = 26;
+/**
+ * Fraction of the 108dp adaptive canvas the artwork occupies. Android reserves
+ * the outer 18dp on every side (visible viewport ≈ inner 72dp, guaranteed-safe
+ * inner 66dp), so full-bleed art (1.0) is cropped by the launcher mask and
+ * looks zoomed in. Scaling to this fraction and centering keeps the logo safe.
+ */
+export declare const FOREGROUND_SAFE_ZONE_SCALE = 0.72;
+/**
+ * Reserved icon name for the project's primary (`ic_launcher`) icon. A dedicated
+ * alias under this name owns the launcher role so the real `MainActivity` can
+ * stay enabled — otherwise disabling it to swap icons breaks tools (e.g. the
+ * Expo dev client) that launch `MainActivity` by explicit component.
+ */
+export declare const DEFAULT_ICON_NAME = "DEFAULT";
+/**
+ * Fully-qualified activity-alias name for an icon. Must match the name the
+ * native module toggles at runtime (`<package>.MainActivity<iconName>`).
+ */
+export declare function activityAliasName(packageName: string, iconName: string): string;
+/**
+ * Turn an arbitrary icon key into a valid Android resource name.
+ */
+export declare function toResourceName(iconKey: string): string;
+/**
+ * XML body for an adaptive icon whose foreground points at `<foregroundResource>`.
+ */
+export declare function adaptiveIconXml(foregroundResource: string): string;
+/**
+ * Centered content size + inset for placing artwork inside the safe zone.
+ */
+export declare function foregroundLayout(canvasSize: number, scale?: number): {
+    contentSize: number;
+    inset: number;
+};
+/**
+ * Whether the project still needs pre-26 legacy square/round bitmaps.
+ */
+export declare function needsLegacyBitmaps(minSdkVersion: number | null): boolean;
+/**
+ * Resolve the Android `minSdkVersion`. Prefers the declared
+ * `expo-build-properties` plugin config (order-independent — `gradle.properties`
+ * may not be written yet when our dangerous mod runs), then falls back to a
+ * `gradle.properties` snapshot. Returns null when undeterminable.
+ */
+export declare function resolveMinSdkVersion(plugins: unknown, gradlePropertiesContent?: string | null): number | null;
+/**
+ * Legacy bitmap basenames this plugin owns for an icon key (square + round).
+ */
+export declare function legacyBitmapNames(iconKey: string): [string, string];
+/**
+ * Adaptive foreground bitmap basename for an icon key.
+ */
+export declare function foregroundBitmapName(iconKey: string): string;
+/**
+ * Adaptive-icon XML basenames this plugin owns for an icon key.
+ */
+export declare function adaptiveXmlNames(iconKey: string): [string, string];
+/**
+ * True when `fileName` is a mipmap resource this plugin generated for `iconKey`.
+ */
+export declare function isOwnedMipmapFile(fileName: string, iconKey: string): boolean;
+/**
+ * True when `fileName` is an adaptive XML this plugin generated for `iconKey`.
+ */
+export declare function isOwnedAdaptiveXml(fileName: string, iconKey: string): boolean;

package/plugin/build/android-resources.js

@@ -0,0 +1,151 @@
+"use strict";
+/**
+ * Pure helpers describing how Android launcher icons are laid out on disk.
+ * Kept free of `expo`/`fs` imports so the logic can be unit-tested directly.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_ICON_NAME = exports.FOREGROUND_SAFE_ZONE_SCALE = exports.ADAPTIVE_ICON_MIN_SDK = exports.ADAPTIVE_ICON_DIR = exports.ANDROID_DENSITY_DIRS = exports.ANDROID_DENSITY_SIZES = void 0;
+exports.activityAliasName = activityAliasName;
+exports.toResourceName = toResourceName;
+exports.adaptiveIconXml = adaptiveIconXml;
+exports.foregroundLayout = foregroundLayout;
+exports.needsLegacyBitmaps = needsLegacyBitmaps;
+exports.resolveMinSdkVersion = resolveMinSdkVersion;
+exports.legacyBitmapNames = legacyBitmapNames;
+exports.foregroundBitmapName = foregroundBitmapName;
+exports.adaptiveXmlNames = adaptiveXmlNames;
+exports.isOwnedMipmapFile = isOwnedMipmapFile;
+exports.isOwnedAdaptiveXml = isOwnedAdaptiveXml;
+/**
+ * Density bucket directory → foreground pixel size (108dp at each scale).
+ */
+exports.ANDROID_DENSITY_SIZES = {
+    "mipmap-mdpi": 108,
+    "mipmap-hdpi": 162,
+    "mipmap-xhdpi": 216,
+    "mipmap-xxhdpi": 324,
+    "mipmap-xxxhdpi": 432,
+};
+exports.ANDROID_DENSITY_DIRS = Object.keys(exports.ANDROID_DENSITY_SIZES);
+/**
+ * Directory holding version-26+ adaptive-icon XML.
+ */
+exports.ADAPTIVE_ICON_DIR = "mipmap-anydpi-v26";
+/**
+ * Adaptive icons require this API level; below it legacy bitmaps are needed.
+ */
+exports.ADAPTIVE_ICON_MIN_SDK = 26;
+/**
+ * Fraction of the 108dp adaptive canvas the artwork occupies. Android reserves
+ * the outer 18dp on every side (visible viewport ≈ inner 72dp, guaranteed-safe
+ * inner 66dp), so full-bleed art (1.0) is cropped by the launcher mask and
+ * looks zoomed in. Scaling to this fraction and centering keeps the logo safe.
+ */
+exports.FOREGROUND_SAFE_ZONE_SCALE = 0.72;
+/**
+ * Reserved icon name for the project's primary (`ic_launcher`) icon. A dedicated
+ * alias under this name owns the launcher role so the real `MainActivity` can
+ * stay enabled — otherwise disabling it to swap icons breaks tools (e.g. the
+ * Expo dev client) that launch `MainActivity` by explicit component.
+ */
+exports.DEFAULT_ICON_NAME = "DEFAULT";
+/**
+ * Fully-qualified activity-alias name for an icon. Must match the name the
+ * native module toggles at runtime (`<package>.MainActivity<iconName>`).
+ */
+function activityAliasName(packageName, iconName) {
+    return `${packageName}.MainActivity${iconName}`;
+}
+const NON_RESOURCE_CHARS = /[^a-zA-Z0-9_]/g;
+/**
+ * Turn an arbitrary icon key into a valid Android resource name.
+ */
+function toResourceName(iconKey) {
+    return iconKey.replace(NON_RESOURCE_CHARS, "_").toLowerCase();
+}
+/**
+ * XML body for an adaptive icon whose foreground points at `<foregroundResource>`.
+ */
+function adaptiveIconXml(foregroundResource) {
+    return [
+        `<?xml version="1.0" encoding="utf-8"?>`,
+        `<adaptive-icon xmlns:android="http://schemas.android.com/apk/res/android">`,
+        `    <background android:drawable="@color/iconBackground"/>`,
+        `    <foreground android:drawable="@mipmap/${foregroundResource}"/>`,
+        `</adaptive-icon>`,
+        ``,
+    ].join("\n");
+}
+/**
+ * Centered content size + inset for placing artwork inside the safe zone.
+ */
+function foregroundLayout(canvasSize, scale = exports.FOREGROUND_SAFE_ZONE_SCALE) {
+    const contentSize = Math.round(canvasSize * scale);
+    const inset = Math.round((canvasSize - contentSize) / 2);
+    return { contentSize, inset };
+}
+/**
+ * Whether the project still needs pre-26 legacy square/round bitmaps.
+ */
+function needsLegacyBitmaps(minSdkVersion) {
+    return minSdkVersion == null || minSdkVersion < exports.ADAPTIVE_ICON_MIN_SDK;
+}
+/**
+ * Resolve the Android `minSdkVersion`. Prefers the declared
+ * `expo-build-properties` plugin config (order-independent — `gradle.properties`
+ * may not be written yet when our dangerous mod runs), then falls back to a
+ * `gradle.properties` snapshot. Returns null when undeterminable.
+ */
+function resolveMinSdkVersion(plugins, gradlePropertiesContent) {
+    if (Array.isArray(plugins)) {
+        for (const entry of plugins) {
+            if (Array.isArray(entry) && entry[0] === "expo-build-properties") {
+                const declared = entry[1]?.android?.minSdkVersion;
+                if (typeof declared === "number")
+                    return declared;
+            }
+        }
+    }
+    if (gradlePropertiesContent) {
+        const captured = gradlePropertiesContent.match(/android\.minSdkVersion\s*=\s*(\d+)/)?.[1];
+        if (captured)
+            return Number.parseInt(captured, 10);
+    }
+    return null;
+}
+/**
+ * Legacy bitmap basenames this plugin owns for an icon key (square + round).
+ */
+function legacyBitmapNames(iconKey) {
+    const safe = toResourceName(iconKey);
+    return [`${safe}.png`, `${safe}_round.png`];
+}
+/**
+ * Adaptive foreground bitmap basename for an icon key.
+ */
+function foregroundBitmapName(iconKey) {
+    return `${toResourceName(iconKey)}_foreground.png`;
+}
+/**
+ * Adaptive-icon XML basenames this plugin owns for an icon key.
+ */
+function adaptiveXmlNames(iconKey) {
+    const safe = toResourceName(iconKey);
+    return [`${safe}.xml`, `${safe}_round.xml`];
+}
+/**
+ * True when `fileName` is a mipmap resource this plugin generated for `iconKey`.
+ */
+function isOwnedMipmapFile(fileName, iconKey) {
+    const [square, round] = legacyBitmapNames(iconKey);
+    return (fileName === square ||
+        fileName === round ||
+        fileName === foregroundBitmapName(iconKey));
+}
+/**
+ * True when `fileName` is an adaptive XML this plugin generated for `iconKey`.
+ */
+function isOwnedAdaptiveXml(fileName, iconKey) {
+    const [square, round] = adaptiveXmlNames(iconKey);
+    return fileName === square || fileName === round;
+}

package/plugin/build/android.d.ts

@@ -0,0 +1,18 @@
+import { ConfigPlugin } from "expo/config-plugins";
+import type { IconSet } from "./types";
+/**
+ * Set up the launcher entries for icon switching.
+ *
+ * `MainActivity` keeps every non-launcher filter (deep links, etc.) and stays
+ * enabled so tools that launch it by explicit component (e.g. the Expo dev
+ * client) keep working — but its MAIN/LAUNCHER filter is removed so it isn't a
+ * second home-screen icon. A dedicated `DEFAULT` alias owns the launcher role
+ * for the project's primary icon, and one disabled alias is added per
+ * configured icon. The native module enables exactly one alias at a time.
+ */
+export declare const withAndroidIconAliases: ConfigPlugin<IconSet>;
+/**
+ * Generate Android launcher icons as adaptive icons (so the launcher mask never
+ * shrinks them) plus, when the project's minSdk is below 26, legacy bitmaps.
+ */
+export declare const withAndroidIconResources: ConfigPlugin<IconSet>;

package/plugin/build/android.js

@@ -0,0 +1,203 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withAndroidIconResources = exports.withAndroidIconAliases = void 0;
+const config_plugins_1 = require("expo/config-plugins");
+const image_utils_1 = require("@expo/image-utils");
+// @ts-ignore - no types; ships with @expo/image-utils. Used to pad the adaptive
+// foreground onto a transparent canvas without requiring `sharp`.
+const jimp_compact_1 = __importDefault(require("jimp-compact"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const android_resources_1 = require("./android-resources");
+const { getMainApplicationOrThrow, getMainActivityOrThrow } = config_plugins_1.AndroidConfig.Manifest;
+const ANDROID_RES_PATH = ["app", "src", "main", "res"];
+const LAUNCHER_CATEGORY = "android.intent.category.LAUNCHER";
+/** A standalone MAIN/LAUNCHER intent-filter for an alias. */
+const launcherIntentFilter = () => ({
+    action: [{ $: { "android:name": "android.intent.action.MAIN" } }],
+    category: [{ $: { "android:name": LAUNCHER_CATEGORY } }],
+});
+/** Whether an intent-filter is the home-screen launcher entry. */
+function isLauncherIntentFilter(filter) {
+    return (Array.isArray(filter?.category) &&
+        filter.category.some((entry) => entry?.$?.["android:name"] === LAUNCHER_CATEGORY));
+}
+/**
+ * Set up the launcher entries for icon switching.
+ *
+ * `MainActivity` keeps every non-launcher filter (deep links, etc.) and stays
+ * enabled so tools that launch it by explicit component (e.g. the Expo dev
+ * client) keep working — but its MAIN/LAUNCHER filter is removed so it isn't a
+ * second home-screen icon. A dedicated `DEFAULT` alias owns the launcher role
+ * for the project's primary icon, and one disabled alias is added per
+ * configured icon. The native module enables exactly one alias at a time.
+ */
+const withAndroidIconAliases = (config, icons) => {
+    return (0, config_plugins_1.withAndroidManifest)(config, (config) => {
+        const mainApplication = getMainApplicationOrThrow(config.modResults);
+        const mainActivity = getMainActivityOrThrow(config.modResults);
+        const packageName = config.android.package;
+        const aliasPrefix = `${packageName}.MainActivity`;
+        if (Array.isArray(mainActivity["intent-filter"])) {
+            mainActivity["intent-filter"] = mainActivity["intent-filter"].filter((filter) => !isLauncherIntentFilter(filter));
+        }
+        const defaultAlias = {
+            $: {
+                "android:name": (0, android_resources_1.activityAliasName)(packageName, android_resources_1.DEFAULT_ICON_NAME),
+                "android:enabled": "true",
+                "android:exported": "true",
+                "android:icon": "@mipmap/ic_launcher",
+                "android:roundIcon": "@mipmap/ic_launcher_round",
+                "android:targetActivity": ".MainActivity",
+            },
+            "intent-filter": [launcherIntentFilter()],
+        };
+        const iconAliases = Object.keys(icons).map((iconKey) => {
+            const resource = (0, android_resources_1.toResourceName)(iconKey);
+            return {
+                $: {
+                    "android:name": (0, android_resources_1.activityAliasName)(packageName, iconKey),
+                    "android:enabled": "false",
+                    "android:exported": "true",
+                    "android:icon": `@mipmap/${resource}`,
+                    "android:roundIcon": `@mipmap/${resource}_round`,
+                    "android:targetActivity": ".MainActivity",
+                },
+                "intent-filter": [launcherIntentFilter()],
+            };
+        });
+        const preserved = (mainApplication["activity-alias"] || []).filter((alias) => !String(alias.$["android:name"]).startsWith(aliasPrefix));
+        mainApplication["activity-alias"] = [
+            ...preserved,
+            defaultAlias,
+            ...iconAliases,
+        ];
+        return config;
+    });
+};
+exports.withAndroidIconAliases = withAndroidIconAliases;
+/**
+ * Read `gradle.properties` if it already exists (used as a minSdk fallback).
+ */
+function readGradleProperties(platformProjectRoot) {
+    try {
+        return fs_1.default.readFileSync(path_1.default.join(platformProjectRoot, "gradle.properties"), "utf8");
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Generate, then write, a single density's foreground bitmap (padded + centered).
+ */
+async function writeForegroundBitmap(projectRoot, outputDir, iconKey, source, canvasSize) {
+    const fileName = (0, android_resources_1.foregroundBitmapName)(iconKey);
+    const { contentSize, inset } = (0, android_resources_1.foregroundLayout)(canvasSize);
+    const { source: scaledArt } = await (0, image_utils_1.generateImageAsync)({
+        projectRoot,
+        cacheType: `expo-app-icon-fg-${(0, android_resources_1.toResourceName)(iconKey)}-${canvasSize}`,
+    }, {
+        name: fileName,
+        src: source,
+        removeTransparency: false,
+        resizeMode: "cover",
+        width: contentSize,
+        height: contentSize,
+    });
+    const canvas = new jimp_compact_1.default(canvasSize, canvasSize, 0x00000000);
+    canvas.composite(await jimp_compact_1.default.read(scaledArt), inset, inset);
+    await fs_1.default.promises.writeFile(path_1.default.join(outputDir, fileName), await canvas.getBufferAsync(jimp_compact_1.default.MIME_PNG));
+}
+/**
+ * Generate, then write, the legacy square + round bitmaps for one density.
+ */
+async function writeLegacyBitmaps(projectRoot, outputDir, iconKey, source, canvasSize) {
+    const [squareName, roundName] = (0, android_resources_1.legacyBitmapNames)(iconKey);
+    const resource = (0, android_resources_1.toResourceName)(iconKey);
+    const { source: square } = await (0, image_utils_1.generateImageAsync)({ projectRoot, cacheType: `expo-app-icon-${resource}-${canvasSize}` }, {
+        name: squareName,
+        src: source,
+        removeTransparency: true,
+        backgroundColor: "#ffffff",
+        resizeMode: "cover",
+        width: canvasSize,
+        height: canvasSize,
+    });
+    await fs_1.default.promises.writeFile(path_1.default.join(outputDir, squareName), square);
+    const { source: round } = await (0, image_utils_1.generateImageAsync)({ projectRoot, cacheType: `expo-app-icon-round-${resource}-${canvasSize}` }, {
+        name: roundName,
+        src: source,
+        removeTransparency: false,
+        resizeMode: "cover",
+        width: canvasSize,
+        height: canvasSize,
+        borderRadius: canvasSize / 2,
+    });
+    await fs_1.default.promises.writeFile(path_1.default.join(outputDir, roundName), round);
+}
+/**
+ * Remove every mipmap/adaptive resource a previous run of this plugin emitted.
+ */
+async function cleanGeneratedResources(resPath, iconKeys) {
+    for (const densityDir of android_resources_1.ANDROID_DENSITY_DIRS) {
+        const dir = path_1.default.join(resPath, densityDir);
+        const files = await fs_1.default.promises.readdir(dir).catch(() => []);
+        for (const file of files) {
+            if (file.startsWith("ic_launcher.") || file.startsWith("ic_launcher_round.")) {
+                continue;
+            }
+            if (iconKeys.some((iconKey) => (0, android_resources_1.isOwnedMipmapFile)(file, iconKey))) {
+                await fs_1.default.promises.rm(path_1.default.join(dir, file), { force: true }).catch(() => null);
+            }
+        }
+    }
+    const adaptiveDir = path_1.default.join(resPath, android_resources_1.ADAPTIVE_ICON_DIR);
+    const adaptiveFiles = await fs_1.default.promises.readdir(adaptiveDir).catch(() => []);
+    for (const file of adaptiveFiles) {
+        if (iconKeys.some((iconKey) => (0, android_resources_1.isOwnedAdaptiveXml)(file, iconKey))) {
+            await fs_1.default.promises
+                .rm(path_1.default.join(adaptiveDir, file), { force: true })
+                .catch(() => null);
+        }
+    }
+}
+/**
+ * Generate Android launcher icons as adaptive icons (so the launcher mask never
+ * shrinks them) plus, when the project's minSdk is below 26, legacy bitmaps.
+ */
+const withAndroidIconResources = (config, icons) => {
+    return (0, config_plugins_1.withDangerousMod)(config, [
+        "android",
+        async (config) => {
+            const { platformProjectRoot, projectRoot } = config.modRequest;
+            const resPath = path_1.default.join(platformProjectRoot, ...ANDROID_RES_PATH);
+            const adaptiveDir = path_1.default.join(resPath, android_resources_1.ADAPTIVE_ICON_DIR);
+            await fs_1.default.promises.mkdir(adaptiveDir, { recursive: true });
+            const minSdkVersion = (0, android_resources_1.resolveMinSdkVersion)(config.plugins, readGradleProperties(platformProjectRoot));
+            const emitLegacy = (0, android_resources_1.needsLegacyBitmaps)(minSdkVersion);
+            const iconKeys = Object.keys(icons);
+            await cleanGeneratedResources(resPath, iconKeys);
+            for (const [iconKey, { android }] of Object.entries(icons)) {
+                if (!android)
+                    continue;
+                for (const densityDir of android_resources_1.ANDROID_DENSITY_DIRS) {
+                    const canvasSize = android_resources_1.ANDROID_DENSITY_SIZES[densityDir];
+                    const outputDir = path_1.default.join(resPath, densityDir);
+                    if (emitLegacy) {
+                        await writeLegacyBitmaps(projectRoot, outputDir, iconKey, android, canvasSize);
+                    }
+                    await writeForegroundBitmap(projectRoot, outputDir, iconKey, android, canvasSize);
+                }
+                const xml = (0, android_resources_1.adaptiveIconXml)((0, android_resources_1.foregroundBitmapName)(iconKey).replace(/\.png$/, ""));
+                const [squareXml, roundXml] = (0, android_resources_1.adaptiveXmlNames)(iconKey);
+                await fs_1.default.promises.writeFile(path_1.default.join(adaptiveDir, squareXml), xml);
+                await fs_1.default.promises.writeFile(path_1.default.join(adaptiveDir, roundXml), xml);
+            }
+            return config;
+        },
+    ]);
+};
+exports.withAndroidIconResources = withAndroidIconResources;

package/plugin/build/apple.d.ts

@@ -0,0 +1,14 @@
+import { ConfigPlugin } from "expo/config-plugins";
+import type { ResolvedIconProps } from "./types";
+/**
+ * Add the generated icon files to the Xcode project (removing stale ones).
+ */
+export declare const withAppleIconAssets: ConfigPlugin<ResolvedIconProps>;
+/**
+ * Register the alternate icons in Info.plist (per device family).
+ */
+export declare const withAppleAlternateIcons: ConfigPlugin<ResolvedIconProps>;
+/**
+ * Render and write the actual icon PNGs into the iOS project.
+ */
+export declare const withAppleIconImages: ConfigPlugin<ResolvedIconProps>;

package/plugin/build/apple.js

@@ -0,0 +1,143 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withAppleIconImages = exports.withAppleAlternateIcons = exports.withAppleIconAssets = void 0;
+const config_plugins_1 = require("expo/config-plugins");
+const image_utils_1 = require("@expo/image-utils");
+// @ts-ignore - no types
+const pbxFile_1 = __importDefault(require("xcode/lib/pbxFile"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const icons_1 = require("./icons");
+/**
+ * Xcode group / on-disk folder the generated icon assets live in.
+ */
+const APPLE_ASSET_GROUP = "AppIconVariants";
+/**
+ * Add the generated icon files to the Xcode project (removing stale ones).
+ */
+const withAppleIconAssets = (config, props) => {
+    return (0, config_plugins_1.withXcodeProject)(config, async (config) => {
+        const groupPath = `${config.modRequest.projectName}/${APPLE_ASSET_GROUP}`;
+        const group = config_plugins_1.IOSConfig.XcodeUtils.ensureGroupRecursively(config.modResults, groupPath);
+        const project = config.modResults;
+        const options = {};
+        const findGroupId = (section) => Object.keys(project.hash.project.objects[section] ?? {}).find((id) => project.hash.project.objects[section][id].name === group.name);
+        const groupId = findGroupId("PBXGroup");
+        if (!project.hash.project.objects["PBXVariantGroup"]) {
+            project.hash.project.objects["PBXVariantGroup"] = {};
+        }
+        const variantGroupId = findGroupId("PBXVariantGroup");
+        // Unlink any previously generated assets.
+        for (const child of [...(group.children || [])]) {
+            const file = new pbxFile_1.default(path_1.default.join(group.name, child.comment), options);
+            file.target = options ? options.target : undefined;
+            project.removeFromPbxBuildFileSection(file);
+            project.removeFromPbxFileReferenceSection(file);
+            if (groupId) {
+                project.removeFromPbxGroup(file, groupId);
+            }
+            else if (variantGroupId) {
+                project.removeFromPbxVariantGroup(file, variantGroupId);
+            }
+            project.removeFromPbxResourcesBuildPhase(file);
+        }
+        // Link the freshly generated assets.
+        await (0, icons_1.forEachAppleIcon)(props, async (iconKey, _icon, variant) => {
+            const fileName = (0, icons_1.appleIconFileName)(iconKey, variant);
+            const alreadyLinked = group?.children.some(({ comment }) => comment === fileName);
+            if (alreadyLinked)
+                return;
+            config.modResults = config_plugins_1.IOSConfig.XcodeUtils.addResourceFileToGroup({
+                filepath: path_1.default.join(groupPath, fileName),
+                groupName: groupPath,
+                project: config.modResults,
+                isBuildFile: true,
+                verbose: true,
+            });
+        });
+        return config;
+    });
+};
+exports.withAppleIconAssets = withAppleIconAssets;
+/**
+ * Register the alternate icons in Info.plist (per device family).
+ */
+const withAppleAlternateIcons = (config, props) => {
+    return (0, config_plugins_1.withInfoPlist)(config, async (config) => {
+        const phoneIcons = {};
+        const iconsByTarget = {};
+        await (0, icons_1.forEachAppleIcon)(props, async (iconKey, icon, variant) => {
+            if (!icon.ios)
+                return;
+            const entry = {
+                CFBundleIconFiles: [(0, icons_1.appleIconBaseName)(iconKey, variant)],
+                UIPrerenderedIcon: !!icon.prerendered,
+            };
+            if (variant.target) {
+                (iconsByTarget[variant.target] ??= {})[iconKey] = entry;
+            }
+            else {
+                phoneIcons[iconKey] = entry;
+            }
+        });
+        const writeIconsBlock = (key, icons) => {
+            const block = config.modResults[key];
+            if (typeof block !== "object" || Array.isArray(block) || !block) {
+                config.modResults[key] = {};
+            }
+            // @ts-ignore - plist values are loosely typed
+            config.modResults[key].CFBundleAlternateIcons = icons;
+            // @ts-ignore
+            config.modResults[key].CFBundlePrimaryIcon = {
+                CFBundleIconFiles: ["AppIcon"],
+            };
+        };
+        writeIconsBlock("CFBundleIcons", phoneIcons);
+        for (const [target, icons] of Object.entries(iconsByTarget)) {
+            if (Object.keys(icons).length > 0) {
+                writeIconsBlock(`CFBundleIcons~${target}`, icons);
+            }
+        }
+        return config;
+    });
+};
+exports.withAppleAlternateIcons = withAppleAlternateIcons;
+/**
+ * Render and write the actual icon PNGs into the iOS project.
+ */
+const withAppleIconImages = (config, props) => {
+    return (0, config_plugins_1.withDangerousMod)(config, [
+        "ios",
+        async (config) => {
+            const iosRoot = path_1.default.join(config.modRequest.platformProjectRoot, config.modRequest.projectName);
+            const assetDir = path_1.default.join(iosRoot, APPLE_ASSET_GROUP);
+            await fs_1.default.promises
+                .rm(assetDir, { recursive: true, force: true })
+                .catch(() => null);
+            await fs_1.default.promises.mkdir(assetDir, { recursive: true });
+            await (0, icons_1.forEachAppleIcon)(props, async (iconKey, icon, variant) => {
+                if (!icon.ios)
+                    return;
+                const fileName = (0, icons_1.appleIconFileName)(iconKey, variant);
+                const { source } = await (0, image_utils_1.generateImageAsync)({
+                    projectRoot: config.modRequest.projectRoot,
+                    cacheType: `expo-app-icon-${variant.width}-${variant.height}`,
+                }, {
+                    name: fileName,
+                    src: icon.ios,
+                    removeTransparency: true,
+                    backgroundColor: "#ffffff",
+                    resizeMode: "cover",
+                    width: variant.width,
+                    height: variant.height,
+                });
+                await fs_1.default.promises.writeFile(path_1.default.join(assetDir, fileName), source);
+            });
+            return config;
+        },
+    ]);
+};
+exports.withAppleIconImages = withAppleIconImages;