react-native-icon-switcher 0.0.0-stage → 0.1.0

package/plugin/build/sync.js

@@ -0,0 +1,162 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProjectLayoutError = void 0;
+exports.syncProject = syncProject;
+const promises_1 = __importDefault(require("node:fs/promises"));
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const config_plugins_1 = require("@expo/config-plugins");
+const plist_1 = __importDefault(require("@expo/plist"));
+const xcode_1 = __importDefault(require("xcode"));
+const assets_1 = require("./core/assets");
+const validate_1 = require("./core/validate");
+const android_1 = require("./transforms/android");
+const ios_1 = require("./transforms/ios");
+const types_1 = require("./transforms/types");
+const load_config_1 = require("./load-config");
+const paths_1 = require("./paths");
+var paths_2 = require("./paths");
+Object.defineProperty(exports, "ProjectLayoutError", { enumerable: true, get: function () { return paths_2.ProjectLayoutError; } });
+async function _readFileIfExists(abs) {
+    try {
+        return await promises_1.default.readFile(abs);
+    }
+    catch {
+        return null;
+    }
+}
+function _rel(projectRoot, abs) {
+    return node_path_1.default.relative(projectRoot, abs).split(node_path_1.default.sep).join('/');
+}
+async function _applyFileChange(_projectRoot, abs, next, check) {
+    const nextBuf = typeof next === 'string' ? Buffer.from(next, 'utf8') : next;
+    const existing = await _readFileIfExists(abs);
+    if (existing !== null && existing.equals(nextBuf)) {
+        return 'unchanged';
+    }
+    if (check) {
+        return 'updated';
+    }
+    await promises_1.default.mkdir(node_path_1.default.dirname(abs), { recursive: true });
+    await promises_1.default.writeFile(abs, nextBuf);
+    return 'updated';
+}
+function _recordOutcome(projectRoot, abs, outcome, driftedPaths) {
+    if (outcome === 'updated') {
+        driftedPaths.push(_rel(projectRoot, abs));
+        return 'updated';
+    }
+    return 'unchanged';
+}
+async function _syncAssets(resolved, projectRoot, iosAssetCatalog, androidResDir, check, driftedPaths) {
+    const plan = (0, assets_1.planAssets)(resolved, projectRoot);
+    const tmpRoot = await promises_1.default.mkdtemp(node_path_1.default.join(node_os_1.default.tmpdir(), 'icon-switcher-sync-'));
+    const tmpIos = node_path_1.default.join(tmpRoot, 'ios');
+    const tmpAndroid = node_path_1.default.join(tmpRoot, 'android');
+    let updated = 0;
+    let unchanged = 0;
+    try {
+        await (0, assets_1.writeAssets)(plan, {
+            iosAssetCatalog: tmpIos,
+            androidResDir: tmpAndroid,
+        });
+        for (const asset of plan.assets) {
+            const isIos = asset.relativePath.includes('.appiconset');
+            const targetAbs = node_path_1.default.join(isIos ? iosAssetCatalog : androidResDir, asset.relativePath);
+            const stagedAbs = node_path_1.default.join(isIos ? tmpIos : tmpAndroid, asset.relativePath);
+            const staged = await promises_1.default.readFile(stagedAbs);
+            const outcome = await _applyFileChange(projectRoot, targetAbs, staged, check);
+            if (_recordOutcome(projectRoot, targetAbs, outcome, driftedPaths) ===
+                'updated') {
+                updated += 1;
+            }
+            else {
+                unchanged += 1;
+            }
+        }
+    }
+    finally {
+        await promises_1.default.rm(tmpRoot, { recursive: true, force: true });
+    }
+    return { updated, unchanged };
+}
+async function _syncAndroidManifest(resolved, manifestPath, projectRoot, check, driftedPaths) {
+    const xml = await promises_1.default.readFile(manifestPath, 'utf8');
+    const parsed = (await config_plugins_1.XML.parseXMLAsync(xml));
+    const next = (0, android_1.applyAndroidManifest)(parsed, resolved);
+    const nextXml = config_plugins_1.XML.format(next);
+    const nextBuf = Buffer.from(nextXml, 'utf8');
+    const existing = await _readFileIfExists(manifestPath);
+    if (existing !== null && existing.equals(nextBuf)) {
+        return _recordOutcome(projectRoot, manifestPath, 'unchanged', driftedPaths);
+    }
+    if (!check) {
+        await config_plugins_1.AndroidConfig.Manifest.writeAndroidManifestAsync(manifestPath, next);
+    }
+    return _recordOutcome(projectRoot, manifestPath, 'updated', driftedPaths);
+}
+async function _syncInfoPlist(resolved, infoPlistPath, projectRoot, check, driftedPaths) {
+    const raw = await promises_1.default.readFile(infoPlistPath, 'utf8');
+    const parsed = plist_1.default.parse(raw);
+    const next = (0, ios_1.applyInfoPlist)(parsed, resolved);
+    const nextXml = plist_1.default.build(next);
+    const outcome = await _applyFileChange(projectRoot, infoPlistPath, nextXml, check);
+    return _recordOutcome(projectRoot, infoPlistPath, outcome, driftedPaths);
+}
+async function _syncXcodeProject(resolved, pbxprojPath, projectRoot, check, driftedPaths) {
+    const project = xcode_1.default.project(pbxprojPath);
+    project.parseSync();
+    (0, ios_1.applyXcodeProject)(project, resolved);
+    const nextContent = project.writeSync();
+    const outcome = await _applyFileChange(projectRoot, pbxprojPath, nextContent, check);
+    return _recordOutcome(projectRoot, pbxprojPath, outcome, driftedPaths);
+}
+async function _syncTypes(resolved, projectRoot, check, driftedPaths) {
+    const typesPath = node_path_1.default.join(projectRoot, 'icon-switcher.d.ts');
+    const content = (0, types_1.renderTypes)(resolved);
+    const outcome = await _applyFileChange(projectRoot, typesPath, content, check);
+    return _recordOutcome(projectRoot, typesPath, outcome, driftedPaths);
+}
+async function syncProject(opts) {
+    const projectRoot = node_path_1.default.resolve(opts.projectRoot);
+    const configPath = (0, load_config_1.resolveConfigPath)(projectRoot, opts.configPath);
+    const rawConfig = (0, load_config_1.loadIconSwitcherConfig)(configPath);
+    const resolved = (0, validate_1.resolveConfig)(rawConfig, { projectRoot });
+    const paths = (0, paths_1.locateNativePaths)(projectRoot);
+    const driftedPaths = [];
+    let updated = 0;
+    let unchanged = 0;
+    const assets = await _syncAssets(resolved, projectRoot, paths.iosAssetCatalog, paths.androidResDir, opts.check, driftedPaths);
+    updated += assets.updated;
+    unchanged += assets.unchanged;
+    const nativeFiles = [
+        {
+            abs: paths.manifestPath,
+            outcome: await _syncAndroidManifest(resolved, paths.manifestPath, projectRoot, opts.check, driftedPaths),
+        },
+        {
+            abs: paths.infoPlistPath,
+            outcome: await _syncInfoPlist(resolved, paths.infoPlistPath, projectRoot, opts.check, driftedPaths),
+        },
+        {
+            abs: paths.pbxprojPath,
+            outcome: await _syncXcodeProject(resolved, paths.pbxprojPath, projectRoot, opts.check, driftedPaths),
+        },
+        {
+            abs: node_path_1.default.join(projectRoot, 'icon-switcher.d.ts'),
+            outcome: await _syncTypes(resolved, projectRoot, opts.check, driftedPaths),
+        },
+    ];
+    for (const file of nativeFiles) {
+        if (file.outcome === 'updated') {
+            updated += 1;
+        }
+        else {
+            unchanged += 1;
+        }
+    }
+    return { updated, unchanged, driftedPaths: [...new Set(driftedPaths)] };
+}

package/plugin/build/transforms/android.d.ts

@@ -0,0 +1,5 @@
+import { AndroidConfig } from '@expo/config-plugins';
+import type { ResolvedConfig } from '../types';
+type AndroidManifest = AndroidConfig.Manifest.AndroidManifest;
+export declare function applyAndroidManifest(manifest: AndroidManifest, cfg: ResolvedConfig): AndroidManifest;
+export {};

package/plugin/build/transforms/android.js

@@ -0,0 +1,212 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyAndroidManifest = applyAndroidManifest;
+const errors_1 = require("./errors");
+const MAIN_ACTION = 'android.intent.action.MAIN';
+const LAUNCHER_CATEGORY = 'android.intent.category.LAUNCHER';
+const ICONKIT_ICON_META = 'com.iconswitcher.icon';
+const ICONKIT_ICONS_META = 'com.iconswitcher.icons';
+const ICONKIT_APPLY_ON_META = 'com.iconswitcher.applyOn';
+const ICONKIT_SKIP_BRANDS_META = 'com.iconswitcher.skipBrands';
+const DEFAULT_ALIAS = '.IconSwitcher_default';
+const RECOGNIZED_ACTIONS = new Set([MAIN_ACTION]);
+const RECOGNIZED_CATEGORIES = new Set([LAUNCHER_CATEGORY]);
+function applyAndroidManifest(manifest, cfg) {
+    const next = JSON.parse(JSON.stringify(manifest));
+    const application = _getApplication(next);
+    const launcherActivityName = _resolveLauncherActivityName(application);
+    _stripLauncherFilters(application, launcherActivityName);
+    _syncActivityAliases(application, cfg, launcherActivityName);
+    _syncApplicationMetaData(application, cfg);
+    return next;
+}
+function _getApplication(manifest) {
+    var _a;
+    const application = (_a = manifest.manifest.application) === null || _a === void 0 ? void 0 : _a[0];
+    if (!application) {
+        throw new errors_1.TransformError('AndroidManifest has no <application> element');
+    }
+    return application;
+}
+function _resolveLauncherActivityName(application) {
+    var _a, _b, _c, _d, _e, _f;
+    const withLauncher = ((_a = application.activity) !== null && _a !== void 0 ? _a : []).find((activity) => { var _a; return ((_a = activity['intent-filter']) !== null && _a !== void 0 ? _a : []).some(_isLauncherIntentFilter); });
+    if ((_b = withLauncher === null || withLauncher === void 0 ? void 0 : withLauncher.$) === null || _b === void 0 ? void 0 : _b['android:name']) {
+        return withLauncher.$['android:name'];
+    }
+    const mainActivity = ((_c = application.activity) !== null && _c !== void 0 ? _c : []).find((activity) => { var _a; return ((_a = activity.$) === null || _a === void 0 ? void 0 : _a['android:name']) === '.MainActivity'; });
+    if ((_d = mainActivity === null || mainActivity === void 0 ? void 0 : mainActivity.$) === null || _d === void 0 ? void 0 : _d['android:name']) {
+        return mainActivity.$['android:name'];
+    }
+    const defaultAlias = ((_e = application['activity-alias']) !== null && _e !== void 0 ? _e : []).find((alias) => { var _a; return ((_a = alias.$) === null || _a === void 0 ? void 0 : _a['android:name']) === DEFAULT_ALIAS; });
+    const target = (_f = defaultAlias === null || defaultAlias === void 0 ? void 0 : defaultAlias.$) === null || _f === void 0 ? void 0 : _f['android:targetActivity'];
+    if (target) {
+        return target;
+    }
+    throw new errors_1.TransformError('Could not find launcher activity (no MAIN/LAUNCHER filter, .MainActivity, or default activity-alias)');
+}
+function _stripLauncherFilters(application, activityName) {
+    var _a, _b;
+    const activities = (_a = application.activity) !== null && _a !== void 0 ? _a : [];
+    const activity = activities.find((item) => { var _a; return ((_a = item.$) === null || _a === void 0 ? void 0 : _a['android:name']) === activityName; });
+    if (!activity) {
+        throw new errors_1.TransformError(`Launcher activity ${activityName} not found in manifest`);
+    }
+    const filters = (_b = activity['intent-filter']) !== null && _b !== void 0 ? _b : [];
+    activity['intent-filter'] = filters.filter((filter) => {
+        if (!_isLauncherIntentFilter(filter)) {
+            return true;
+        }
+        _assertRecognizedLauncherFilter(filter);
+        return false;
+    });
+}
+function _isLauncherIntentFilter(filter) {
+    const actions = _actionNames(filter);
+    const categories = _categoryNames(filter);
+    return (actions.includes(MAIN_ACTION) && categories.includes(LAUNCHER_CATEGORY));
+}
+function _assertRecognizedLauncherFilter(filter) {
+    const actions = _actionNames(filter);
+    const categories = _categoryNames(filter);
+    for (const action of actions) {
+        if (!RECOGNIZED_ACTIONS.has(action)) {
+            throw new errors_1.TransformError(`Unrecognized action in launcher intent-filter: ${action}`);
+        }
+    }
+    for (const category of categories) {
+        if (!RECOGNIZED_CATEGORIES.has(category)) {
+            throw new errors_1.TransformError(`Unrecognized category in launcher intent-filter: ${category}`);
+        }
+    }
+}
+function _actionNames(filter) {
+    var _a;
+    return ((_a = filter.action) !== null && _a !== void 0 ? _a : [])
+        .map((item) => { var _a; return (_a = item.$) === null || _a === void 0 ? void 0 : _a['android:name']; })
+        .filter(Boolean);
+}
+function _categoryNames(filter) {
+    var _a;
+    return ((_a = filter.category) !== null && _a !== void 0 ? _a : [])
+        .map((item) => { var _a; return (_a = item.$) === null || _a === void 0 ? void 0 : _a['android:name']; })
+        .filter(Boolean);
+}
+function _syncActivityAliases(application, cfg, launcherActivityName) {
+    var _a;
+    const configuredNames = new Set(cfg.icons
+        .filter((icon) => icon.isDefault || icon.android !== null)
+        .map((icon) => icon.name));
+    const existing = (_a = application['activity-alias']) !== null && _a !== void 0 ? _a : [];
+    const kept = [];
+    for (const alias of existing) {
+        const marker = _readIconKitMarker(alias);
+        if (marker === null) {
+            kept.push(alias);
+            continue;
+        }
+        if (!configuredNames.has(marker)) {
+            continue;
+        }
+        kept.push(_buildActivityAlias(marker, cfg, launcherActivityName, alias));
+    }
+    for (const icon of cfg.icons) {
+        if (!icon.isDefault && icon.android === null) {
+            continue;
+        }
+        const aliasName = `.IconSwitcher_${icon.name}`;
+        const already = kept.some((alias) => { var _a; return ((_a = alias.$) === null || _a === void 0 ? void 0 : _a['android:name']) === aliasName; });
+        if (!already) {
+            kept.push(_buildActivityAlias(icon.name, cfg, launcherActivityName));
+        }
+    }
+    application['activity-alias'] = kept;
+}
+function _buildActivityAlias(iconName, cfg, launcherActivityName, previous) {
+    var _a, _b;
+    const icon = cfg.icons.find((item) => item.name === iconName);
+    const isDefault = (_a = icon === null || icon === void 0 ? void 0 : icon.isDefault) !== null && _a !== void 0 ? _a : iconName === 'default';
+    const { icon: iconRef, roundIcon } = _mipmapRefs(iconName, isDefault);
+    const aliasAttrs = {
+        ...((_b = previous === null || previous === void 0 ? void 0 : previous.$) !== null && _b !== void 0 ? _b : {}),
+        'android:name': `.IconSwitcher_${iconName}`,
+        'android:targetActivity': launcherActivityName,
+        'android:exported': 'true',
+        'android:enabled': isDefault ? 'true' : 'false',
+        'android:icon': iconRef,
+        'android:roundIcon': roundIcon,
+    };
+    return {
+        '$': aliasAttrs,
+        'intent-filter': [_launcherIntentFilter()],
+        'meta-data': [_iconKitMarkerMeta(iconName)],
+    };
+}
+function _mipmapRefs(iconName, isDefault) {
+    if (isDefault) {
+        return {
+            icon: '@mipmap/ic_launcher',
+            roundIcon: '@mipmap/ic_launcher_round',
+        };
+    }
+    return {
+        icon: `@mipmap/ic_launcher_${iconName}`,
+        roundIcon: `@mipmap/ic_launcher_${iconName}_round`,
+    };
+}
+function _launcherIntentFilter() {
+    return {
+        action: [{ $: { 'android:name': MAIN_ACTION } }],
+        category: [{ $: { 'android:name': LAUNCHER_CATEGORY } }],
+    };
+}
+function _iconKitMarkerMeta(iconName) {
+    return {
+        $: {
+            'android:name': ICONKIT_ICON_META,
+            'android:value': iconName,
+        },
+    };
+}
+function _readIconKitMarker(alias) {
+    var _a, _b, _c;
+    const meta = (_a = alias['meta-data']) !== null && _a !== void 0 ? _a : [];
+    for (const item of meta) {
+        if (((_b = item.$) === null || _b === void 0 ? void 0 : _b['android:name']) === ICONKIT_ICON_META) {
+            return (_c = item.$['android:value']) !== null && _c !== void 0 ? _c : null;
+        }
+    }
+    return null;
+}
+function _syncApplicationMetaData(application, cfg) {
+    var _a;
+    const meta = (_a = application['meta-data']) !== null && _a !== void 0 ? _a : [];
+    const withoutIconKit = meta.filter((item) => {
+        var _a, _b, _c;
+        return ((_a = item.$) === null || _a === void 0 ? void 0 : _a['android:name']) !== ICONKIT_ICONS_META &&
+            ((_b = item.$) === null || _b === void 0 ? void 0 : _b['android:name']) !== ICONKIT_APPLY_ON_META &&
+            ((_c = item.$) === null || _c === void 0 ? void 0 : _c['android:name']) !== ICONKIT_SKIP_BRANDS_META;
+    });
+    withoutIconKit.push({
+        $: {
+            'android:name': ICONKIT_ICONS_META,
+            'android:value': _configuredAndroidIconNames(cfg).join(','),
+        },
+    }, {
+        $: {
+            'android:name': ICONKIT_APPLY_ON_META,
+            'android:value': cfg.android.applyOn,
+        },
+    }, {
+        $: {
+            'android:name': ICONKIT_SKIP_BRANDS_META,
+            'android:value': cfg.android.skipBrands.join(','),
+        },
+    });
+    application['meta-data'] = withoutIconKit;
+}
+function _configuredAndroidIconNames(cfg) {
+    return cfg.icons
+        .filter((icon) => icon.isDefault || icon.android !== null)
+        .map((icon) => icon.name);
+}

package/plugin/build/transforms/errors.d.ts

@@ -0,0 +1,4 @@
+export declare class TransformError extends Error {
+    readonly name = "TransformError";
+    constructor(message: string);
+}

package/plugin/build/transforms/errors.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransformError = void 0;
+class TransformError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'TransformError';
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}
+exports.TransformError = TransformError;

package/plugin/build/transforms/index.d.ts

@@ -0,0 +1,4 @@
+export { applyAndroidManifest } from './android';
+export { TransformError } from './errors';
+export { applyInfoPlist, applyXcodeProject } from './ios';
+export { renderTypes } from './types';

package/plugin/build/transforms/index.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderTypes = exports.applyXcodeProject = exports.applyInfoPlist = exports.TransformError = exports.applyAndroidManifest = void 0;
+var android_1 = require("./android");
+Object.defineProperty(exports, "applyAndroidManifest", { enumerable: true, get: function () { return android_1.applyAndroidManifest; } });
+var errors_1 = require("./errors");
+Object.defineProperty(exports, "TransformError", { enumerable: true, get: function () { return errors_1.TransformError; } });
+var ios_1 = require("./ios");
+Object.defineProperty(exports, "applyInfoPlist", { enumerable: true, get: function () { return ios_1.applyInfoPlist; } });
+Object.defineProperty(exports, "applyXcodeProject", { enumerable: true, get: function () { return ios_1.applyXcodeProject; } });
+var types_1 = require("./types");
+Object.defineProperty(exports, "renderTypes", { enumerable: true, get: function () { return types_1.renderTypes; } });

package/plugin/build/transforms/ios.d.ts

@@ -0,0 +1,4 @@
+import type { XcodeProject } from 'xcode';
+import type { ResolvedConfig } from '../types';
+export declare function applyInfoPlist(plist: Record<string, unknown>, cfg: ResolvedConfig): Record<string, unknown>;
+export declare function applyXcodeProject(project: XcodeProject, cfg: ResolvedConfig): XcodeProject;

package/plugin/build/transforms/ios.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyInfoPlist = applyInfoPlist;
+exports.applyXcodeProject = applyXcodeProject;
+const PRIMARY_ICON_NAME = 'AppIcon';
+function applyInfoPlist(plist, cfg) {
+    const next = { ...plist };
+    next.IconSwitcherIcons = cfg.icons
+        .filter((icon) => icon.isDefault || icon.ios !== null)
+        .map((icon) => icon.name);
+    next.CFBundleIcons = _ensurePrimaryIconBundle(next.CFBundleIcons, 'CFBundleIcons');
+    if (_supportsIpad(next)) {
+        next['CFBundleIcons~ipad'] = _mirrorIpadIcons(next.CFBundleIcons, next['CFBundleIcons~ipad']);
+    }
+    return next;
+}
+function _ensurePrimaryIconBundle(existing, label) {
+    const bundle = existing && typeof existing === 'object' && !Array.isArray(existing)
+        ? { ...existing }
+        : {};
+    const primary = bundle.CFBundlePrimaryIcon && typeof bundle.CFBundlePrimaryIcon === 'object'
+        ? { ...bundle.CFBundlePrimaryIcon }
+        : {};
+    const currentName = primary.CFBundleIconName;
+    if (currentName !== undefined && currentName !== PRIMARY_ICON_NAME) {
+        console.warn(`[react-native-icon-switcher] ${label}.CFBundlePrimaryIcon.CFBundleIconName is "${String(currentName)}"; expected "${PRIMARY_ICON_NAME}" — leaving unchanged`);
+    }
+    else {
+        primary.CFBundleIconName = PRIMARY_ICON_NAME;
+    }
+    bundle.CFBundlePrimaryIcon = primary;
+    return bundle;
+}
+function _supportsIpad(plist) {
+    const families = plist.UIDeviceFamily;
+    if (Array.isArray(families) &&
+        families.some((value) => value === 2 || value === '2')) {
+        return true;
+    }
+    return plist['UISupportedInterfaceOrientations~ipad'] !== undefined;
+}
+function _mirrorIpadIcons(phoneIcons, existingIpad) {
+    const phone = phoneIcons && typeof phoneIcons === 'object' && !Array.isArray(phoneIcons)
+        ? phoneIcons
+        : {};
+    const ipad = existingIpad &&
+        typeof existingIpad === 'object' &&
+        !Array.isArray(existingIpad)
+        ? { ...existingIpad }
+        : {};
+    ipad.CFBundlePrimaryIcon = phone.CFBundlePrimaryIcon;
+    return ipad;
+}
+function applyXcodeProject(project, cfg) {
+    const alternateNames = cfg.icons
+        .filter((icon) => !icon.isDefault && icon.ios !== null)
+        .map((icon) => `AppIcon-${icon.name}`)
+        .join(' ');
+    const [, nativeTarget] = _findFirstApplicationTarget(project);
+    const buildConfigurations = _getBuildConfigurationsForListId(project, nativeTarget.buildConfigurationList);
+    for (const [, configuration] of buildConfigurations) {
+        configuration.buildSettings.ASSETCATALOG_COMPILER_ALTERNATE_APPICON_NAMES =
+            _formatAlternateAppIconNamesSetting(alternateNames);
+        configuration.buildSettings.ASSETCATALOG_COMPILER_INCLUDE_ALL_APPICON_ASSETS =
+            'NO';
+    }
+    return project;
+}
+function _formatAlternateAppIconNamesSetting(raw) {
+    if (!raw) {
+        return '';
+    }
+    if (!raw.includes(' ')) {
+        return raw;
+    }
+    return `"${raw}"`;
+}
+function _findFirstApplicationTarget(project) {
+    var _a;
+    const section = project.pbxNativeTargetSection();
+    for (const [key, value] of Object.entries(section)) {
+        if (key.endsWith('_comment')) {
+            continue;
+        }
+        const target = value;
+        const productType = _unquote(String((_a = target.productType) !== null && _a !== void 0 ? _a : ''));
+        if (productType === 'com.apple.product-type.application') {
+            return [key, target];
+        }
+    }
+    throw new Error('Could not find application target in Xcode project');
+}
+function _getBuildConfigurationsForListId(project, configurationListId) {
+    var _a;
+    const lists = project.pbxXCConfigurationList();
+    const list = lists[configurationListId];
+    const ids = ((_a = list === null || list === void 0 ? void 0 : list.buildConfigurations) !== null && _a !== void 0 ? _a : []).map((entry) => entry.value);
+    const section = project.pbxXCBuildConfigurationSection();
+    return Object.entries(section).filter(([key, value]) => {
+        if (key.endsWith('_comment')) {
+            return false;
+        }
+        const item = value;
+        return item.isa === 'XCBuildConfiguration' && ids.includes(key);
+    });
+}
+function _unquote(value) {
+    var _a;
+    const match = value.match(/^"(.*)"$/);
+    return (_a = match === null || match === void 0 ? void 0 : match[1]) !== null && _a !== void 0 ? _a : value;
+}

package/plugin/build/transforms/sampleConfigs.d.ts

@@ -0,0 +1,3 @@
+import type { ResolvedConfig } from '../types';
+export declare const sampleConfig: ResolvedConfig;
+export declare const halloweenOnlyConfig: ResolvedConfig;

package/plugin/build/transforms/sampleConfigs.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.halloweenOnlyConfig = exports.sampleConfig = void 0;
+exports.sampleConfig = {
+    icons: [
+        {
+            name: 'default',
+            isDefault: true,
+            ios: { light: 'icons/default.png' },
+            android: { legacy: 'icons/default.png' },
+        },
+        {
+            name: 'halloween',
+            isDefault: false,
+            ios: { light: 'icons/halloween.png' },
+            android: { legacy: 'icons/halloween.png' },
+        },
+    ],
+    ios: { flattenOn: '#FFFFFF' },
+    android: { applyOn: 'background', skipBrands: ['samsung'] },
+};
+exports.halloweenOnlyConfig = {
+    icons: [
+        {
+            name: 'default',
+            isDefault: true,
+            ios: { light: 'icons/default.png' },
+            android: { legacy: 'icons/default.png' },
+        },
+    ],
+    ios: { flattenOn: '#FFFFFF' },
+    android: { applyOn: 'immediate', skipBrands: [] },
+};

package/plugin/build/transforms/types.d.ts

@@ -0,0 +1,2 @@
+import type { ResolvedConfig } from '../types';
+export declare function renderTypes(cfg: ResolvedConfig): string;

package/plugin/build/transforms/types.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderTypes = renderTypes;
+function renderTypes(cfg) {
+    const iconUnion = cfg.icons.map((icon) => `'${icon.name}'`).join(' | ');
+    return `import 'react-native-icon-switcher';
+
+declare module 'react-native-icon-switcher' {
+  interface Register {
+    icons: ${iconUnion};
+  }
+}
+`;
+}

package/plugin/build/types.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Mirror of `src/types.ts` (P2). Keep identical so plugin build-time code matches the package contract.
+ */
+/** A path to a square PNG master, ideally 1024 px. Relative to the project root. */
+export type ImagePath = string;
+/** Hex colour, `#RGB` or `#RRGGBB`. */
+export type HexColor = string;
+export interface IosIconVariants {
+    light: ImagePath;
+    /** Phase 2. */
+    dark?: ImagePath;
+    /** Phase 2. */
+    tinted?: ImagePath;
+}
+export interface AndroidAdaptiveIcon {
+    foreground: ImagePath;
+    background: ImagePath | HexColor;
+    /** Phase 2. Android 13+ themed icons. */
+    monochrome?: ImagePath;
+}
+export interface IconSpec {
+    ios?: ImagePath | IosIconVariants;
+    android?: ImagePath | AndroidAdaptiveIcon;
+}
+/** A bare path means "same master for both platforms". */
+export type IconSource = ImagePath | IconSpec;
+export interface IconSwitcherConfig {
+    /** Primary icon. Omit on Expo to reuse `icon` / `android.adaptiveIcon`. */
+    default?: IconSource;
+    icons: Record<string, IconSource>;
+    ios?: {
+        /** Background colour that transparent pixels are flattened onto. Default `#FFFFFF`. */
+        flattenOn?: HexColor;
+    };
+    android?: {
+        /** Default `'background'`. */
+        applyOn?: 'background' | 'immediate';
+        /** Lower-cased `Build.BRAND` values where switching is disabled. Default `[]`. */
+        skipBrands?: string[];
+    };
+}
+/** Config after validation and defaults; every icon normalised to per-platform specs. */
+export interface ResolvedIcon {
+    name: string;
+    isDefault: boolean;
+    ios: IosIconVariants | null;
+    android: AndroidAdaptiveIcon | {
+        legacy: ImagePath;
+    } | null;
+}
+export interface ResolvedConfig {
+    /** `default` first, then alternates in declaration order. */
+    icons: ResolvedIcon[];
+    ios: {
+        flattenOn: HexColor;
+    };
+    android: {
+        applyOn: 'background' | 'immediate';
+        skipBrands: string[];
+    };
+}

package/plugin/build/types.js

@@ -0,0 +1,5 @@
+"use strict";
+/**
+ * Mirror of `src/types.ts` (P2). Keep identical so plugin build-time code matches the package contract.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });