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

package/plugin/build/core/validate.js

@@ -0,0 +1,229 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveConfig = resolveConfig;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const errors_1 = require("./errors");
+const ICON_NAME_RE = /^[a-z][a-z0-9_]*$/;
+const HEX_COLOR_RE = /^#([0-9A-Fa-f]{3}|[0-9A-Fa-f]{6})$/;
+const RESERVED_ANDROID_NAMES = new Set([
+    'round',
+    'foreground',
+    'background',
+    'monochrome',
+]);
+const RESERVED_ANDROID_SUFFIXES = [
+    '_round',
+    '_foreground',
+    '_background',
+    '_monochrome',
+];
+function _isHexColor(value) {
+    return HEX_COLOR_RE.test(value);
+}
+function _normalizeIos(ios) {
+    if (ios === undefined) {
+        return null;
+    }
+    if (typeof ios === 'string') {
+        return { light: ios };
+    }
+    return ios;
+}
+function _normalizeAndroid(android) {
+    if (android === undefined) {
+        return null;
+    }
+    if (typeof android === 'string') {
+        return { legacy: android };
+    }
+    return android;
+}
+function _splitIconSource(source) {
+    if (typeof source === 'string') {
+        return {
+            ios: { light: source },
+            android: { legacy: source },
+        };
+    }
+    return {
+        ios: _normalizeIos(source.ios),
+        android: _normalizeAndroid(source.android),
+    };
+}
+function _resolvedImagePath(projectRoot, rel) {
+    return node_path_1.default.resolve(projectRoot, rel);
+}
+function _imagePathsEqual(projectRoot, a, b) {
+    return (_resolvedImagePath(projectRoot, a) === _resolvedImagePath(projectRoot, b));
+}
+function _comparableDefaultPaths(source) {
+    const { ios, android } = _splitIconSource(source);
+    const out = {};
+    if (ios) {
+        out.ios = ios.light;
+    }
+    if (android) {
+        out.android = 'legacy' in android ? android.legacy : android.foreground;
+    }
+    return out;
+}
+function _validateDefaultMatchesExpo(problems, projectRoot, cfgDefault, expoDefault) {
+    const cfgPaths = _comparableDefaultPaths(cfgDefault);
+    const expoPaths = _comparableDefaultPaths(expoDefault);
+    if (expoPaths.ios !== undefined && cfgPaths.ios !== undefined) {
+        if (!_imagePathsEqual(projectRoot, cfgPaths.ios, expoPaths.ios)) {
+            problems.push(`Default icon iOS path conflicts: icon-switcher config has "${cfgPaths.ios}", Expo \`icon\` has "${expoPaths.ios}" — remove one or point both at the same file`);
+        }
+    }
+    if (expoPaths.android !== undefined && cfgPaths.android !== undefined) {
+        if (!_imagePathsEqual(projectRoot, cfgPaths.android, expoPaths.android)) {
+            problems.push(`Default icon Android path conflicts: icon-switcher config has "${cfgPaths.android}", Expo \`icon\` / \`android.adaptiveIcon\` has "${expoPaths.android}" — remove one or point both at the same file`);
+        }
+    }
+}
+function _validateAndroidResourceName(problems, name) {
+    if (RESERVED_ANDROID_NAMES.has(name)) {
+        problems.push(`Invalid icon name "${name}": reserved for Android mipmap resources (see Android resource naming rules)`);
+        return;
+    }
+    for (const suffix of RESERVED_ANDROID_SUFFIXES) {
+        if (name.endsWith(suffix)) {
+            problems.push(`Invalid icon name "${name}": must not end with "${suffix}" (reserved for Android mipmap resources)`);
+            return;
+        }
+    }
+}
+function _collectPathsFromIos(ios, out) {
+    if (!ios) {
+        return;
+    }
+    out.push(ios.light);
+    if (ios.dark) {
+        out.push(ios.dark);
+    }
+    if (ios.tinted) {
+        out.push(ios.tinted);
+    }
+}
+function _collectPathsFromAndroid(android, out) {
+    if (!android) {
+        return;
+    }
+    if ('legacy' in android) {
+        out.push(android.legacy);
+        return;
+    }
+    out.push(android.foreground);
+    if (typeof android.background === 'string' &&
+        !android.background.startsWith('#')) {
+        out.push(android.background);
+    }
+    if (android.monochrome) {
+        out.push(android.monochrome);
+    }
+}
+function _validateHexField(problems, value, label) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (!_isHexColor(value)) {
+        problems.push(`${label} must be a hex colour (#RGB or #RRGGBB), got "${value}"`);
+        return undefined;
+    }
+    return value;
+}
+function _validateFile(problems, projectRoot, rel) {
+    const abs = node_path_1.default.join(projectRoot, rel);
+    if (!node_fs_1.default.existsSync(abs)) {
+        problems.push(`Missing image file: ${rel}`);
+    }
+}
+function resolveConfig(cfg, ctx) {
+    var _a, _b, _c, _d, _e, _f;
+    const problems = [];
+    if (Object.keys(cfg.icons).length === 0) {
+        problems.push('At least one alternate icon must be declared in `icons`');
+    }
+    for (const name of Object.keys(cfg.icons)) {
+        if (name === 'default') {
+            problems.push('`default` is reserved and cannot be used as an alternate icon name');
+            continue;
+        }
+        if (!ICON_NAME_RE.test(name)) {
+            problems.push(`Invalid icon name "${name}": must match /^[a-z][a-z0-9_]*$/`);
+        }
+        _validateAndroidResourceName(problems, name);
+    }
+    const flattenOn = (_b = _validateHexField(problems, (_a = cfg.ios) === null || _a === void 0 ? void 0 : _a.flattenOn, 'ios.flattenOn')) !== null && _b !== void 0 ? _b : '#FFFFFF';
+    const applyOn = (_d = (_c = cfg.android) === null || _c === void 0 ? void 0 : _c.applyOn) !== null && _d !== void 0 ? _d : 'background';
+    if (applyOn !== 'background' && applyOn !== 'immediate') {
+        problems.push(`android.applyOn must be "background" or "immediate", got "${applyOn}"`);
+    }
+    const skipBrands = ((_f = (_e = cfg.android) === null || _e === void 0 ? void 0 : _e.skipBrands) !== null && _f !== void 0 ? _f : []).map((b) => b.toLowerCase());
+    const expoOwnsDefault = ctx.expoDefault !== undefined;
+    if (cfg.default !== undefined && ctx.expoDefault !== undefined) {
+        _validateDefaultMatchesExpo(problems, ctx.projectRoot, cfg.default, ctx.expoDefault);
+    }
+    const icons = [];
+    const defaultSplit = !expoOwnsDefault && cfg.default !== undefined
+        ? _splitIconSource(cfg.default)
+        : { ios: null, android: null };
+    icons.push({
+        name: 'default',
+        isDefault: true,
+        ios: defaultSplit.ios,
+        android: defaultSplit.android,
+    });
+    for (const name of Object.keys(cfg.icons)) {
+        const source = cfg.icons[name];
+        if (source === undefined) {
+            continue;
+        }
+        const split = _splitIconSource(source);
+        icons.push({
+            name,
+            isDefault: false,
+            ios: split.ios,
+            android: split.android,
+        });
+    }
+    const paths = [];
+    for (const icon of icons) {
+        _collectPathsFromIos(icon.ios, paths);
+        _collectPathsFromAndroid(icon.android, paths);
+    }
+    const uniquePaths = [...new Set(paths)];
+    for (const rel of uniquePaths) {
+        if (rel.startsWith('#')) {
+            continue;
+        }
+        _validateFile(problems, ctx.projectRoot, rel);
+    }
+    for (const icon of icons) {
+        const android = icon.android;
+        if (!android || 'legacy' in android) {
+            continue;
+        }
+        if (typeof android.background === 'string' &&
+            android.background.startsWith('#')) {
+            if (!_isHexColor(android.background)) {
+                problems.push(`icons.${icon.name}.android.background must be a hex colour or image path`);
+            }
+        }
+    }
+    if (problems.length > 0) {
+        throw new errors_1.ConfigError(problems.map((p) => `- ${p}`).join('\n'));
+    }
+    return {
+        icons,
+        ios: { flattenOn },
+        android: {
+            applyOn: applyOn,
+            skipBrands,
+        },
+    };
+}

package/plugin/build/index.d.ts

@@ -0,0 +1,6 @@
+import { ConfigPlugin } from '@expo/config-plugins';
+import type { IconSwitcherConfig } from './types';
+/** @internal Test hook for locating Images.xcassets without a full Expo iOS tree. */
+export declare function __setGetIosSourceRootForTests(resolver: ((projectRoot: string) => string) | undefined): void;
+declare const _default: ConfigPlugin<IconSwitcherConfig>;
+export default _default;

package/plugin/build/index.js

@@ -0,0 +1,134 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.__setGetIosSourceRootForTests = __setGetIosSourceRootForTests;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const config_plugins_1 = require("@expo/config-plugins");
+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");
+let _getIosSourceRootForTests;
+/** @internal Test hook for locating Images.xcassets without a full Expo iOS tree. */
+function __setGetIosSourceRootForTests(resolver) {
+    _getIosSourceRootForTests = resolver;
+}
+function _iosSourceRoot(projectRoot) {
+    if (_getIosSourceRootForTests) {
+        return _getIosSourceRootForTests(projectRoot);
+    }
+    return config_plugins_1.IOSConfig.Paths.getSourceRoot(projectRoot);
+}
+function _buildExpoDefault(config) {
+    var _a;
+    const icon = config.icon;
+    const adaptive = (_a = config.android) === null || _a === void 0 ? void 0 : _a.adaptiveIcon;
+    if (!icon && !adaptive) {
+        return undefined;
+    }
+    const iosPath = typeof icon === 'string' ? icon : undefined;
+    const androidAdaptive = adaptive && typeof adaptive.foregroundImage === 'string'
+        ? {
+            foreground: adaptive.foregroundImage,
+            background: (typeof adaptive.backgroundColor === 'string' &&
+                adaptive.backgroundColor) ||
+                (typeof adaptive.backgroundImage === 'string' &&
+                    adaptive.backgroundImage) ||
+                '#FFFFFF',
+        }
+        : undefined;
+    if (iosPath && !androidAdaptive) {
+        return iosPath;
+    }
+    if (!iosPath && androidAdaptive) {
+        return { android: androidAdaptive };
+    }
+    return {
+        ios: iosPath,
+        android: androidAdaptive,
+    };
+}
+function _resolve(cfg, projectRoot, expoDefault) {
+    return (0, validate_1.resolveConfig)(cfg, { projectRoot, expoDefault });
+}
+function _filterPlan(plan, platform) {
+    const assets = plan.assets.filter((asset) => {
+        const isIos = asset.relativePath.includes('.appiconset');
+        return platform === 'ios' ? isIos : !isIos;
+    });
+    return { ...plan, assets };
+}
+function _findIosAssetCatalog(projectRoot) {
+    const catalog = path_1.default.join(_iosSourceRoot(projectRoot), 'Images.xcassets');
+    if (!fs_1.default.existsSync(catalog)) {
+        throw new Error(`Could not find Images.xcassets at ${catalog}`);
+    }
+    return catalog;
+}
+async function _writeTypesIfChanged(projectRoot, resolved) {
+    const target = path_1.default.join(projectRoot, 'icon-switcher.d.ts');
+    const content = (0, types_1.renderTypes)(resolved);
+    let existing;
+    try {
+        existing = await fs_1.default.promises.readFile(target, 'utf8');
+    }
+    catch {
+        existing = undefined;
+    }
+    if (existing !== content) {
+        await fs_1.default.promises.writeFile(target, content, 'utf8');
+    }
+}
+const withIconSwitcher = (config, props) => {
+    config = (0, config_plugins_1.withAndroidManifest)(config, (config) => {
+        const resolved = _resolve(props, config.modRequest.projectRoot, _buildExpoDefault(config));
+        config.modResults = (0, android_1.applyAndroidManifest)(config.modResults, resolved);
+        return config;
+    });
+    config = (0, config_plugins_1.withInfoPlist)(config, (config) => {
+        const resolved = _resolve(props, config.modRequest.projectRoot, _buildExpoDefault(config));
+        config.modResults = (0, ios_1.applyInfoPlist)(config.modResults, resolved);
+        return config;
+    });
+    config = (0, config_plugins_1.withXcodeProject)(config, (config) => {
+        const resolved = _resolve(props, config.modRequest.projectRoot, _buildExpoDefault(config));
+        config.modResults = (0, ios_1.applyXcodeProject)(config.modResults, resolved);
+        return config;
+    });
+    config = (0, config_plugins_1.withDangerousMod)(config, [
+        'android',
+        async (config) => {
+            const projectRoot = config.modRequest.projectRoot;
+            const resolved = _resolve(props, projectRoot, _buildExpoDefault(config));
+            const plan = _filterPlan((0, assets_1.planAssets)(resolved, projectRoot), 'android');
+            const androidResDir = path_1.default.join(config.modRequest.platformProjectRoot, 'app', 'src', 'main', 'res');
+            await (0, assets_1.writeAssets)(plan, {
+                iosAssetCatalog: path_1.default.join(projectRoot, '.noop-ios'),
+                androidResDir,
+            });
+            await _writeTypesIfChanged(projectRoot, resolved);
+            return config;
+        },
+    ]);
+    config = (0, config_plugins_1.withDangerousMod)(config, [
+        'ios',
+        async (config) => {
+            const projectRoot = config.modRequest.projectRoot;
+            const resolved = _resolve(props, projectRoot, _buildExpoDefault(config));
+            const plan = _filterPlan((0, assets_1.planAssets)(resolved, projectRoot), 'ios');
+            const iosAssetCatalog = _findIosAssetCatalog(projectRoot);
+            await (0, assets_1.writeAssets)(plan, {
+                iosAssetCatalog,
+                androidResDir: path_1.default.join(projectRoot, '.noop-android'),
+            });
+            await _writeTypesIfChanged(projectRoot, resolved);
+            return config;
+        },
+    ]);
+    return config;
+};
+exports.default = (0, config_plugins_1.createRunOncePlugin)(withIconSwitcher, 'react-native-icon-switcher');

package/plugin/build/load-config.d.ts

@@ -0,0 +1,3 @@
+import type { IconSwitcherConfig } from './types';
+export declare function resolveConfigPath(projectRoot: string, explicit?: string): string;
+export declare function loadIconSwitcherConfig(configPath: string): IconSwitcherConfig;

package/plugin/build/load-config.js

@@ -0,0 +1,50 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveConfigPath = resolveConfigPath;
+exports.loadIconSwitcherConfig = loadIconSwitcherConfig;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const jiti_1 = require("jiti");
+const paths_1 = require("./paths");
+const CONFIG_CANDIDATES = [
+    'icon-switcher.config.ts',
+    'icon-switcher.config.js',
+    'icon-switcher.config.mjs',
+    'icon-switcher.config.cjs',
+];
+function resolveConfigPath(projectRoot, explicit) {
+    if (explicit) {
+        const abs = node_path_1.default.isAbsolute(explicit)
+            ? explicit
+            : node_path_1.default.join(projectRoot, explicit);
+        if (!node_fs_1.default.existsSync(abs)) {
+            throw new paths_1.ProjectLayoutError(`Config file not found at ${abs}`);
+        }
+        return abs;
+    }
+    for (const name of CONFIG_CANDIDATES) {
+        const candidate = node_path_1.default.join(projectRoot, name);
+        if (node_fs_1.default.existsSync(candidate)) {
+            return candidate;
+        }
+    }
+    throw new paths_1.ProjectLayoutError(`Could not find icon-switcher.config.{ts,js,mjs,cjs} in ${projectRoot}`);
+}
+function loadIconSwitcherConfig(configPath) {
+    const load = (0, jiti_1.createJiti)(configPath, { interopDefault: true });
+    const loaded = load(configPath);
+    let cfg = loaded &&
+        typeof loaded === 'object' &&
+        loaded !== null &&
+        'default' in loaded &&
+        loaded.default !== undefined
+        ? loaded.default
+        : loaded;
+    if (!cfg || typeof cfg !== 'object') {
+        throw new paths_1.ProjectLayoutError(`Config at ${configPath} must export a default object`);
+    }
+    return cfg;
+}

package/plugin/build/paths.d.ts

@@ -0,0 +1,15 @@
+export interface NativeProjectPaths {
+    projectRoot: string;
+    iosDir: string;
+    xcodeprojPath: string;
+    pbxprojPath: string;
+    infoPlistPath: string;
+    iosAssetCatalog: string;
+    manifestPath: string;
+    androidResDir: string;
+}
+export declare class ProjectLayoutError extends Error {
+    readonly name = "ProjectLayoutError";
+    constructor(message: string);
+}
+export declare function locateNativePaths(projectRoot: string): NativeProjectPaths;

package/plugin/build/paths.js

@@ -0,0 +1,153 @@
+"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.locateNativePaths = locateNativePaths;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const xcode_1 = __importDefault(require("xcode"));
+const APP_PRODUCT_TYPE = 'com.apple.product-type.application';
+const EXCLUDED_PRODUCT_TYPES = new Set([
+    'com.apple.product-type.app-extension',
+    'com.apple.product-type.bundle.unit-test',
+    'com.apple.product-type.bundle.ui-testing',
+]);
+class ProjectLayoutError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'ProjectLayoutError';
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}
+exports.ProjectLayoutError = ProjectLayoutError;
+function _unquote(value) {
+    return value.replace(/^"/, '').replace(/"$/, '');
+}
+function _findAppTarget(project) {
+    var _a;
+    const nativeTargets = project.pbxNativeTargetSection();
+    const targetRefs = project.getFirstProject().firstProject.targets;
+    const matches = [];
+    for (const ref of targetRefs) {
+        const uuid = ref.value;
+        const native = nativeTargets[uuid];
+        if (!native || uuid.endsWith('_comment')) {
+            continue;
+        }
+        const productType = _unquote(String((_a = native.productType) !== null && _a !== void 0 ? _a : ''));
+        if (EXCLUDED_PRODUCT_TYPES.has(productType)) {
+            continue;
+        }
+        if (productType === APP_PRODUCT_TYPE) {
+            matches.push({ uuid, name: String(native.name) });
+        }
+    }
+    if (matches.length === 0) {
+        throw new ProjectLayoutError('Could not find an iOS application target (non-test, non-extension) in the Xcode project');
+    }
+    if (matches.length > 1) {
+        throw new ProjectLayoutError(`Found multiple iOS application targets (${matches.map((m) => m.name).join(', ')}); leave only one app target`);
+    }
+    return matches[0];
+}
+function _infoPlistRelativePath(project, targetUuid) {
+    var _a, _b;
+    const native = project.pbxNativeTargetSection()[targetUuid];
+    if (!native) {
+        throw new ProjectLayoutError('Could not read the iOS app target');
+    }
+    const configListUuid = native.buildConfigurationList;
+    const lists = project.pbxXCConfigurationList();
+    const list = lists[configListUuid];
+    if (!((_a = list === null || list === void 0 ? void 0 : list.buildConfigurations) === null || _a === void 0 ? void 0 : _a.length)) {
+        throw new ProjectLayoutError('Could not read build configurations for the iOS app target');
+    }
+    const firstConfig = list.buildConfigurations[0];
+    if (!firstConfig) {
+        throw new ProjectLayoutError('Could not read build configurations for the iOS app target');
+    }
+    const configUuid = firstConfig.value;
+    const section = project.pbxXCBuildConfigurationSection();
+    const config = section[configUuid];
+    const infoPlist = (_b = config === null || config === void 0 ? void 0 : config.buildSettings) === null || _b === void 0 ? void 0 : _b.INFOPLIST_FILE;
+    if (infoPlist === undefined || infoPlist === '') {
+        throw new ProjectLayoutError('INFOPLIST_FILE is not set on the iOS app target build configuration');
+    }
+    return _unquote(String(infoPlist));
+}
+function _locateXcodeproj(iosDir) {
+    const entries = node_fs_1.default.readdirSync(iosDir);
+    const projects = entries
+        .filter((name) => name.endsWith('.xcodeproj'))
+        .map((name) => node_path_1.default.join(iosDir, name));
+    if (projects.length === 0) {
+        throw new ProjectLayoutError(`Could not find ios/*.xcodeproj under ${iosDir}`);
+    }
+    const withAppTarget = [];
+    for (const xcodeprojPath of projects) {
+        const pbxprojPath = node_path_1.default.join(xcodeprojPath, 'project.pbxproj');
+        if (!node_fs_1.default.existsSync(pbxprojPath)) {
+            continue;
+        }
+        const project = xcode_1.default.project(pbxprojPath);
+        project.parseSync();
+        try {
+            _findAppTarget(project);
+            withAppTarget.push(xcodeprojPath);
+        }
+        catch (err) {
+            if (err instanceof ProjectLayoutError) {
+                continue;
+            }
+            throw err;
+        }
+    }
+    if (withAppTarget.length === 0) {
+        throw new ProjectLayoutError(`Could not find ios/*.xcodeproj with an application target under ${iosDir}`);
+    }
+    if (withAppTarget.length > 1) {
+        throw new ProjectLayoutError(`Found multiple Xcode projects with app targets: ${withAppTarget.map((p) => node_path_1.default.basename(p)).join(', ')}`);
+    }
+    return withAppTarget[0];
+}
+function locateNativePaths(projectRoot) {
+    const iosDir = node_path_1.default.join(projectRoot, 'ios');
+    if (!node_fs_1.default.existsSync(iosDir)) {
+        throw new ProjectLayoutError(`Missing iOS directory at ${iosDir}`);
+    }
+    const xcodeprojPath = _locateXcodeproj(iosDir);
+    const pbxprojPath = node_path_1.default.join(xcodeprojPath, 'project.pbxproj');
+    const project = xcode_1.default.project(pbxprojPath);
+    project.parseSync();
+    const appTarget = _findAppTarget(project);
+    const infoPlistRel = _infoPlistRelativePath(project, appTarget.uuid);
+    const infoPlistPath = node_path_1.default.join(iosDir, infoPlistRel);
+    if (!node_fs_1.default.existsSync(infoPlistPath)) {
+        throw new ProjectLayoutError(`Missing Info.plist at ${infoPlistPath}`);
+    }
+    const appSourceDir = node_path_1.default.dirname(infoPlistPath);
+    const iosAssetCatalog = node_path_1.default.join(appSourceDir, 'Images.xcassets');
+    if (!node_fs_1.default.existsSync(iosAssetCatalog)) {
+        throw new ProjectLayoutError(`Missing Images.xcassets at ${iosAssetCatalog}`);
+    }
+    const manifestPath = node_path_1.default.join(projectRoot, 'android', 'app', 'src', 'main', 'AndroidManifest.xml');
+    if (!node_fs_1.default.existsSync(manifestPath)) {
+        throw new ProjectLayoutError(`Missing AndroidManifest.xml at ${manifestPath}`);
+    }
+    const androidResDir = node_path_1.default.join(projectRoot, 'android', 'app', 'src', 'main', 'res');
+    if (!node_fs_1.default.existsSync(androidResDir)) {
+        throw new ProjectLayoutError(`Missing Android res directory at ${androidResDir}`);
+    }
+    return {
+        projectRoot,
+        iosDir,
+        xcodeprojPath,
+        pbxprojPath,
+        infoPlistPath,
+        iosAssetCatalog,
+        manifestPath,
+        androidResDir,
+    };
+}

package/plugin/build/sync.d.ts

@@ -0,0 +1,12 @@
+export { ProjectLayoutError } from './paths';
+export interface SyncOptions {
+    projectRoot: string;
+    configPath?: string;
+    check: boolean;
+}
+export interface SyncResult {
+    updated: number;
+    unchanged: number;
+    driftedPaths: string[];
+}
+export declare function syncProject(opts: SyncOptions): Promise<SyncResult>;