@expo-harmony/config-plugins 55.0.10-harmony.2 → 55.0.10-harmony.3

package/build/mods.js

@@ -3,10 +3,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.withHarmonyResources = exports.withHarmonyDangerousMod = exports.withCngManifest = exports.withHarmonyAutolinking = exports.withCMakeLists = exports.withCppPackageProvider = exports.withArkTSPackageProvider = exports.withWorker = exports.withIndexPage = exports.withEntryAbility = exports.withProfiles = exports.withMedia = exports.withColors = exports.withStrings = exports.withModuleJson = exports.withEntryHvigor = exports.withEntryOhPackage = exports.withEntryBuildProfile = exports.withHvigorConfig = exports.withNativeInputsStamp = exports.withRootHvigor = exports.withRootOhPackage = exports.withProjectBuildProfile = exports.withAppJson = exports.withReactNativeConfig = exports.HarmonyModNames = void 0;
+exports.withHarmonyResources = exports.withHarmonyDangerousMod = exports.withProjectPatch = exports.withPreparation = exports.withCngManifest = exports.withHarmonyAutolinking = exports.withCMakeLists = exports.withCppPackageProvider = exports.withArkTSPackageProvider = exports.withWorker = exports.withIndexPage = exports.withEntryAbility = exports.withProfiles = exports.withMedia = exports.withColors = exports.withStrings = exports.withModuleJson = exports.withEntryHvigor = exports.withEntryOhPackage = exports.withEntryBuildProfile = exports.withHvigorConfig = exports.withNativeInputsStamp = exports.withRootHvigor = exports.withRootOhPackage = exports.withProjectBuildProfile = exports.withAppJson = exports.withReactNativeConfig = exports.HarmonyModNames = void 0;
 exports.recordManagedFile = recordManagedFile;
 exports.withHarmonyBaseMods = withHarmonyBaseMods;
 exports.withHarmonyMod = withHarmonyMod;
+exports.registerMod = registerMod;
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
 const config_plugins_1 = require("@expo/config-plugins");
@@ -36,10 +37,11 @@ const TextMods = new Set([
     'cmakeLists',
 ]);
 const ResourceMods = new Set(['strings', 'colors', 'media']);
-const VirtualMods = new Set(['dangerous', 'autolinking', 'manifest']);
+const VirtualMods = new Set(['dangerous', 'autolinking', 'manifest', 'prepare', 'patch']);
 const ResourceModNames = ['strings', 'colors', 'media'];
-exports.HarmonyModNames = Object.freeze([
+const AllModNames = Object.freeze([
     'dangerous',
+    'prepare',
     'reactNativeConfig',
     'appJson',
     'projectBuildProfile',
@@ -62,8 +64,10 @@ exports.HarmonyModNames = Object.freeze([
     'cppPackageProvider',
     'cmakeLists',
     'autolinking',
+    'patch',
     'manifest',
 ]);
+exports.HarmonyModNames = Object.freeze(AllModNames.filter((name) => name !== 'manifest' && name !== 'nativeInputsStamp' && name !== 'prepare' && name !== 'patch'));
 function recordManagedFile(config, file, owner) {
     config._internal ??= {};
     config._internal.harmonyManagedFiles ??= [];
@@ -73,35 +77,41 @@ function recordManagedFile(config, file, owner) {
     files.sort((left, right) => left.path.localeCompare(right.path, 'en'));
     config._internal.harmonyManagedFiles = files;
 }
-function assertModResults(modName, value, kind) {
+function assertModResults(name, value, kind) {
     const valid = kind === 'text'
         ? typeof value === 'string'
         : value !== null && typeof value === 'object' && !Array.isArray(value);
     if (!valid) {
-        throw new errors_1.HarmonyConfigPluginError('ERR_HARMONY_MOD_RESULTS_INVALID', `harmony.${modName} must return ${kind === 'text' ? 'a string' : 'an object'} modResults.`, { operation: `harmony.${modName}.write` });
+        throw new errors_1.HarmonyConfigPluginError('ERR_HARMONY_MOD_RESULTS_INVALID', `harmony.${name} must return ${kind === 'text' ? 'a string' : 'an object'} modResults.`, { operation: `harmony.${name}.write` });
     }
 }
-function withFileProvider(config, modName) {
+function withFileProvider(config, name) {
     return (0, config_plugins_1.withBaseMod)(config, {
         platform: 'harmony',
-        mod: modName,
+        mod: name,
         isProvider: true,
-        isIntrospective: JsonMods.has(modName),
-        saveToInternal: JsonMods.has(modName),
+        isIntrospective: JsonMods.has(name),
+        saveToInternal: JsonMods.has(name),
         async action(value) {
-            const { nextMod, ...modRequest } = value.modRequest;
-            const isProjectFile = modName in paths_1.ProjectPaths;
-            const root = isProjectFile ? modRequest.projectRoot : modRequest.platformProjectRoot;
-            const file = isProjectFile
-                ? await (0, paths_1.resolveProjectPath)(root, modName)
-                : await (0, paths_1.resolveHarmonyPath)(root, paths_1.ManagedPaths[modName]);
-            const exists = node_fs_1.default.existsSync(file);
-            const data = JsonMods.has(modName)
-                ? await (0, files_1.readJson5)(file, {}, modName)
-                : await (0, files_1.readText)(file);
-            const request = { ...modRequest, modFile: file, modFileExists: exists };
-            const result = await nextMod({ ...value, modRequest: request, modResults: data });
-            assertModResults(modName, result.modResults, JsonMods.has(modName) ? 'json' : 'text');
+            const { nextMod: next, ...request } = value.modRequest;
+            const project = name in paths_1.ProjectPaths;
+            const root = project ? request.projectRoot : request.platformProjectRoot;
+            const file = project
+                ? await (0, paths_1.resolveProjectPath)(root, name)
+                : await (0, paths_1.resolveHarmonyPath)(root, paths_1.ManagedPaths[name]);
+            const exists = !request.ignoreExistingNativeFiles && node_fs_1.default.existsSync(file);
+            const template = value._internal?.harmonyTemplateDirectory;
+            const input = !exists && !project && typeof template === 'string'
+                ? await (0, paths_1.resolveHarmonyPath)(template, paths_1.ManagedPaths[name])
+                : file;
+            const data = request.ignoreExistingNativeFiles && input === file
+                ? (JsonMods.has(name) ? {} : '')
+                : JsonMods.has(name)
+                    ? await (0, files_1.readJson5)(input, {}, name)
+                    : await (0, files_1.readText)(file);
+            const context = { ...request, modFile: file, modFileExists: exists };
+            const result = await next({ ...value, modRequest: context, modResults: data });
+            assertModResults(name, result.modResults, JsonMods.has(name) ? 'json' : 'text');
             if (!result.modRequest.introspect) {
                 if (typeof result.modResults === 'string') {
                     await (0, files_1.atomicWrite)(file, result.modResults.replace(/\r\n?/g, '\n').replace(/\n?$/, '\n'));
@@ -109,17 +119,19 @@ function withFileProvider(config, modName) {
                 else {
                     await (0, files_1.writeJson5)(file, result.modResults);
                 }
-                recordManagedFile(result, file, modName);
+                recordManagedFile(result, file, name);
             }
             return result;
         },
     });
 }
-async function readResourceMap(root, entries, modName) {
+async function readResourceMap(root, entries, name, template, ignore = false) {
     const resources = {};
     for (const [scope, relative] of Object.entries(entries)) {
         const file = await (0, paths_1.resolveHarmonyPath)(root, relative);
-        resources[scope] = await (0, files_1.readJson5)(file, {}, modName);
+        const fallback = ignore || !node_fs_1.default.existsSync(file);
+        const input = fallback && template ? await (0, paths_1.resolveHarmonyPath)(template, relative) : file;
+        resources[scope] = ignore && input === file ? {} : await (0, files_1.readJson5)(input, {}, name);
     }
     return resources;
 }
@@ -162,16 +174,14 @@ async function writeMediaMap(root, media, config, previous = {}) {
                 throw new errors_1.HarmonyConfigPluginError('ERR_HARMONY_CONFIG_INVALID', `Harmony media ${scope}/${name} must use a descriptor object.`, { operation: 'harmony.media.write' });
             }
             const item = descriptor;
-            const hasSource = Object.hasOwn(item, 'source');
-            const hasContent = Object.hasOwn(item, 'content');
-            if (hasSource === hasContent) {
+            if (Object.hasOwn(item, 'source') === Object.hasOwn(item, 'content')) {
                 throw new errors_1.HarmonyConfigPluginError('ERR_HARMONY_CONFIG_INVALID', `Harmony media ${scope}/${name} must define exactly one of source or content.`, { operation: 'harmony.media.write' });
             }
             if (item.replaceBase !== undefined && typeof item.replaceBase !== 'boolean') {
                 throw new errors_1.HarmonyConfigPluginError('ERR_HARMONY_CONFIG_INVALID', `Harmony media ${scope}/${name} replaceBase must be a boolean.`, { operation: 'harmony.media.write' });
             }
             let content;
-            if (hasSource) {
+            if (Object.hasOwn(item, 'source')) {
                 if (typeof item.source !== 'string' || item.source.length === 0) {
                     throw new errors_1.HarmonyConfigPluginError('ERR_HARMONY_CONFIG_INVALID', `Harmony media ${scope}/${name} source must be a non-empty path.`, { operation: 'harmony.media.write' });
                 }
@@ -191,9 +201,6 @@ async function writeMediaMap(root, media, config, previous = {}) {
             });
         }
     }
-    // Resolve and read every desired input before removing stale resources. A
-    // malformed descriptor or missing source therefore cannot partially mutate
-    // an otherwise valid generated project.
     for (const [scope, names] of Object.entries(previous)) {
         if (!(scope in paths_1.ResourcePaths.media))
             continue;
@@ -210,9 +217,9 @@ async function writeMediaMap(root, media, config, previous = {}) {
         await node_fs_1.default.promises.mkdir(directory, { recursive: true });
         if (replaceBase) {
             const base = node_path_1.default.parse(name).name;
-            for (const oldName of await node_fs_1.default.promises.readdir(directory)) {
-                if (node_path_1.default.parse(oldName).name === base && oldName !== name) {
-                    await node_fs_1.default.promises.rm(node_path_1.default.join(directory, oldName), { force: true });
+            for (const entry of await node_fs_1.default.promises.readdir(directory)) {
+                if (node_path_1.default.parse(entry).name === base && entry !== name) {
+                    await node_fs_1.default.promises.rm(node_path_1.default.join(directory, entry), { force: true });
                 }
             }
         }
@@ -221,47 +228,47 @@ async function writeMediaMap(root, media, config, previous = {}) {
         recordManagedFile(config, file, 'media');
     }
 }
-function withResourceProvider(config, modName) {
-    const isIntrospective = modName !== 'media';
+function withResourceProvider(config, name) {
+    const introspective = name !== 'media';
     return (0, config_plugins_1.withBaseMod)(config, {
         platform: 'harmony',
-        mod: modName,
+        mod: name,
         isProvider: true,
-        isIntrospective,
-        saveToInternal: isIntrospective,
+        isIntrospective: introspective,
+        saveToInternal: introspective,
         async action(value) {
-            const { nextMod, ...modRequest } = value.modRequest;
-            const root = modRequest.platformProjectRoot;
-            const data = modName === 'media'
-                ? await readMediaMap(root)
-                : await readResourceMap(root, paths_1.ResourcePaths[modName], modName);
-            const previous = modName === 'media'
+            const { nextMod: next, ...request } = value.modRequest;
+            const root = request.platformProjectRoot;
+            const data = name === 'media'
+                ? (request.ignoreExistingNativeFiles
+                    ? Object.fromEntries(Object.keys(paths_1.ResourcePaths.media).map(scope => [scope, {}]))
+                    : await readMediaMap(root))
+                : await readResourceMap(root, paths_1.ResourcePaths[name], name, value._internal?.harmonyTemplateDirectory, request.ignoreExistingNativeFiles);
+            const previous = name === 'media'
                 ? Object.fromEntries(Object.entries(data).map(([scope, files]) => [scope, Object.keys(files)]))
                 : {};
-            const result = await nextMod({ ...value, modRequest, modResults: data });
-            assertModResults(modName, result.modResults, 'resource');
+            const result = await next({ ...value, modRequest: request, modResults: data });
+            assertModResults(name, result.modResults, 'resource');
             if (!result.modRequest.introspect) {
-                if (modName === 'media') {
+                if (name === 'media') {
                     await writeMediaMap(root, result.modResults, result, previous);
                 }
                 else {
-                    const paths = paths_1.ResourcePaths[modName];
+                    const paths = paths_1.ResourcePaths[name];
                     for (const [scope, resource] of Object.entries(result.modResults)) {
                         if (!(scope in paths))
                             continue;
-                        // Harmony's resource compiler requires the JSON root to contain
-                        // exactly one resource-kind member. An empty scope serialized as
-                        // `{}` is invalid, so omit it until a plugin contributes content.
                         if (!resource || typeof resource !== 'object' || Array.isArray(resource)) {
-                            throw new errors_1.HarmonyConfigPluginError('ERR_HARMONY_CONFIG_INVALID', `Harmony ${modName} scope ${scope} must be an object.`, { operation: `harmony.${modName}.write` });
+                            throw new errors_1.HarmonyConfigPluginError('ERR_HARMONY_CONFIG_INVALID', `Harmony ${name} scope ${scope} must be an object.`, { operation: `harmony.${name}.write` });
                         }
                         const file = await (0, paths_1.resolveHarmonyPath)(root, paths[scope]);
+                        // Harmony's resource compiler rejects an empty JSON root.
                         if (Object.keys(resource).length === 0) {
                             await node_fs_1.default.promises.rm(file, { force: true });
                             continue;
                         }
                         await (0, files_1.writeJson5)(file, resource);
-                        recordManagedFile(result, file, modName);
+                        recordManagedFile(result, file, name);
                     }
                 }
             }
@@ -269,61 +276,63 @@ function withResourceProvider(config, modName) {
         },
     });
 }
-function withVirtualProvider(config, modName) {
+function withVirtualProvider(config, name) {
     return (0, config_plugins_1.withBaseMod)(config, {
         platform: 'harmony',
-        mod: modName,
+        mod: name,
         isProvider: true,
+        isIntrospective: name === 'prepare',
         async action(value) {
-            const { nextMod, ...modRequest } = value.modRequest;
-            return nextMod({ ...value, modRequest, modResults: null });
+            const { nextMod: next, ...request } = value.modRequest;
+            return next({ ...value, modRequest: request, modResults: null });
         },
     });
 }
-function withProvider(config, modName) {
+function withProvider(config, name) {
     const actions = [];
     config = (0, config_plugins_1.withMod)(config, {
         platform: 'harmony',
-        mod: modName,
+        mod: name,
         async action(value) {
             let result = value;
-            // withMod is a stack: the last registered plugin runs first. Preserve
-            // that ordering for Harmony plugins registered after the provider.
+            // Late mods must follow Expo's last-registered-first order.
             for (let index = actions.length - 1; index >= 0; index -= 1) {
                 result = await actions[index](result);
             }
             return result;
         },
     });
-    if (JsonMods.has(modName) || TextMods.has(modName)) {
-        config = withFileProvider(config, modName);
+    if (JsonMods.has(name) || TextMods.has(name)) {
+        config = withFileProvider(config, name);
     }
-    else if (ResourceMods.has(modName)) {
-        config = withResourceProvider(config, modName);
+    else if (ResourceMods.has(name)) {
+        config = withResourceProvider(config, name);
     }
-    else if (VirtualMods.has(modName)) {
-        config = withVirtualProvider(config, modName);
+    else if (VirtualMods.has(name)) {
+        config = withVirtualProvider(config, name);
     }
     else {
-        throw new errors_1.HarmonyConfigPluginError('ERR_HARMONY_MOD_NOT_REGISTERED', `Unknown Harmony mod: ${modName}`, { operation: 'register-base-mods' });
+        throw new errors_1.HarmonyConfigPluginError('ERR_HARMONY_MOD_NOT_REGISTERED', `Unknown Harmony mod: ${name}`, { operation: 'register-base-mods' });
     }
     const mods = config.mods;
-    const provider = mods?.harmony?.[modName];
+    const provider = mods?.harmony?.[name];
     if (provider?.isProvider)
         provider.expoHarmonyLateActions = actions;
     return config;
 }
 function withHarmonyBaseMods(config) {
-    for (const modName of exports.HarmonyModNames) {
+    for (const name of AllModNames) {
         const mods = config.mods;
-        if (!mods?.harmony?.[modName]?.isProvider)
-            config = withProvider(config, modName);
+        if (!mods?.harmony?.[name]?.isProvider)
+            config = withProvider(config, name);
     }
     const mods = config.mods;
     const table = mods.harmony;
     mods.harmony = Object.fromEntries([
-        ...exports.HarmonyModNames.filter(name => table[name]).map(name => [name, table[name]]),
-        ...Object.entries(table).filter(([name]) => !exports.HarmonyModNames.includes(name)),
+        ...AllModNames.filter(name => table[name] && name !== 'manifest' && name !== 'patch').map(name => [name, table[name]]),
+        ...Object.entries(table).filter(([name]) => !AllModNames.includes(name)),
+        ['patch', table.patch],
+        ['manifest', table.manifest],
     ]);
     return config;
 }
@@ -331,17 +340,32 @@ function withHarmonyMod(config, tuple) {
     if (!Array.isArray(tuple) || tuple.length !== 2) {
         throw new TypeError('withHarmonyMod expects [modName, action].');
     }
-    const [modName, action] = tuple;
-    if (!exports.HarmonyModNames.includes(modName) || typeof action !== 'function') {
-        throw new errors_1.HarmonyConfigPluginError('ERR_HARMONY_MOD_NOT_REGISTERED', `Cannot register Harmony mod: ${modName}`, { operation: 'register-mod' });
+    const [name, action] = tuple;
+    if (!exports.HarmonyModNames.includes(name) || typeof action !== 'function') {
+        throw new errors_1.HarmonyConfigPluginError('ERR_HARMONY_MOD_NOT_REGISTERED', `Cannot register Harmony mod: ${name}`, { operation: 'register-mod' });
     }
+    return registerMod(config, name, action);
+}
+function registerMod(config, name, action) {
     const mods = config.mods;
-    const provider = mods?.harmony?.[modName];
+    const provider = mods?.harmony?.[name];
     if (provider?.isProvider && provider.expoHarmonyLateActions) {
-        provider.expoHarmonyLateActions.push(action);
+        // Build an ordinary Expo interceptor on an isolated mod table, preserving
+        // its registration stack, error behavior and execution trace for late mods.
+        const carrier = (0, config_plugins_1.withMod)({ ...config, mods: {} }, {
+            platform: 'harmony',
+            mod: name,
+            action: action,
+        });
+        const interceptor = carrier.mods.harmony[name];
+        provider.expoHarmonyLateActions.push(interceptor);
         return config;
     }
-    return (0, config_plugins_1.withMod)(config, { platform: 'harmony', mod: modName, action });
+    return (0, config_plugins_1.withMod)(config, {
+        platform: 'harmony',
+        mod: name,
+        action: action,
+    });
 }
 const withReactNativeConfig = (config, action) => withHarmonyMod(config, ['reactNativeConfig', action]);
 exports.withReactNativeConfig = withReactNativeConfig;
@@ -353,7 +377,7 @@ const withRootOhPackage = (config, action) => withHarmonyMod(config, ['rootOhPac
 exports.withRootOhPackage = withRootOhPackage;
 const withRootHvigor = (config, action) => withHarmonyMod(config, ['rootHvigor', action]);
 exports.withRootHvigor = withRootHvigor;
-const withNativeInputsStamp = (config, action) => withHarmonyMod(config, ['nativeInputsStamp', action]);
+const withNativeInputsStamp = (config, action) => registerMod(config, 'nativeInputsStamp', action);
 exports.withNativeInputsStamp = withNativeInputsStamp;
 const withHvigorConfig = (config, action) => withHarmonyMod(config, ['hvigorConfig', action]);
 exports.withHvigorConfig = withHvigorConfig;
@@ -387,13 +411,17 @@ const withCMakeLists = (config, action) => withHarmonyMod(config, ['cmakeLists',
 exports.withCMakeLists = withCMakeLists;
 const withHarmonyAutolinking = (config, action) => withHarmonyMod(config, ['autolinking', action]);
 exports.withHarmonyAutolinking = withHarmonyAutolinking;
-const withCngManifest = (config, action) => withHarmonyMod(config, ['manifest', action]);
+const withCngManifest = (config, action) => registerMod(config, 'manifest', action);
 exports.withCngManifest = withCngManifest;
+const withPreparation = (config, action) => registerMod(config, 'prepare', action);
+exports.withPreparation = withPreparation;
+const withProjectPatch = (config, action) => registerMod(config, 'patch', action);
+exports.withProjectPatch = withProjectPatch;
 const withHarmonyDangerousMod = (config, action) => withHarmonyMod(config, ['dangerous', action]);
 exports.withHarmonyDangerousMod = withHarmonyDangerousMod;
 const withHarmonyResources = (config, action) => {
-    for (const modName of ResourceModNames) {
-        withHarmonyMod(config, [modName, action]);
+    for (const name of ResourceModNames) {
+        withHarmonyMod(config, [name, action]);
     }
     return config;
 };

package/build/normalizeConfig.d.ts

@@ -1,4 +1,4 @@
-import type { ExpoConfigWithHarmony, HarmonyConfig } from './config';
+import type { ExpoConfigWithHarmony, HarmonyConfig, HarmonyPermission } from './config';
 type HarmonyExpoConfig = ExpoConfigWithHarmony;
 interface NormalizedHarmonyConfig {
     abiFilters: string[];
@@ -22,7 +22,14 @@ interface NormalizedHarmonyConfig {
     versionCode: number;
     versionName: string;
 }
-declare const HarmonySdkVersions: Map<number, string>;
+export declare function normalizePermission(permission: HarmonyPermission): {
+    name: string;
+    reason?: string;
+    usedScene?: {
+        abilities?: string[];
+        when: "always" | "inuse";
+    };
+};
 declare function normalizeHarmonyConfig(config: HarmonyExpoConfig): NormalizedHarmonyConfig;
-export { HarmonySdkVersions, normalizeHarmonyConfig };
+export { normalizeHarmonyConfig };
 export type { HarmonyExpoConfig, NormalizedHarmonyConfig };

package/build/normalizeConfig.js

@@ -1,12 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.HarmonySdkVersions = void 0;
+exports.normalizePermission = normalizePermission;
 exports.normalizeHarmonyConfig = normalizeHarmonyConfig;
 const errors_1 = require("./errors");
-const BundleNamePattern = /^[A-Za-z][A-Za-z0-9_]*(\.[A-Za-z][A-Za-z0-9_]*){2,}$/;
+const resources_1 = require("./resources");
+const BundlePattern = /^[A-Za-z][A-Za-z0-9_]*(\.[A-Za-z][A-Za-z0-9_]*){2,}$/;
 const IdentifierPattern = /^[A-Za-z][A-Za-z0-9_]*$/;
 const ColorPattern = /^(#[0-9A-Fa-f]{6}|#[0-9A-Fa-f]{8})$/;
-const ValidOrientations = new Set([
+const Orientations = new Set([
     'default',
     'portrait',
     'landscape',
@@ -14,17 +15,17 @@ const ValidOrientations = new Set([
     'landscape_inverted',
     'auto_rotation',
 ]);
-const ValidDeviceTypes = new Set(['phone', 'tablet', '2in1']);
-const SupportedMinimumHarmonyApi = 13;
-const DefaultHarmonyCompatibleApi = 23;
-const DefaultHarmonyTargetApi = 24;
-const HarmonySdkVersions = new Map([
+const DeviceTypes = new Set(['phone', 'tablet', '2in1']);
+const MinimumApi = 13;
+const TargetApi = 24;
+const SdkVersions = new Map([
     [13, '5.0.1(13)'],
+    [14, '5.0.2(14)'],
     [20, '6.0.0(20)'],
+    [21, '6.0.1(21)'],
     [23, '6.1.0(23)'],
     [24, '6.1.1(24)'],
 ]);
-exports.HarmonySdkVersions = HarmonySdkVersions;
 class HarmonyConfigError extends errors_1.HarmonyConfigPluginError {
     constructor(message) {
         super('ERR_HARMONY_CONFIG_INVALID', message, { operation: 'normalize-config' });
@@ -53,10 +54,7 @@ function normalizeColor(value, field, fallback) {
     if (typeof color !== 'string' || !ColorPattern.test(color)) {
         throw new HarmonyConfigError(`${field} must be #RRGGBB or #RRGGBBAA.`);
     }
-    const result = color.toUpperCase();
-    return result.length === 9
-        ? `#${result.slice(7, 9)}${result.slice(1, 7)}`
-        : result;
+    return (0, resources_1.toArgb)(color);
 }
 function parseSdkApi(value, field) {
     if (value === undefined)
@@ -82,14 +80,14 @@ function resolveSdkVersion(api, field, value) {
         }
         else {
             const version = readString(value, `harmony.${field}`);
-            const versionApi = parseSdkApi(version, field);
-            if (versionApi !== api) {
-                throw new HarmonyConfigError(`harmony.${field} describes API ${versionApi}, but the configured API level is ${api}.`);
+            const parsed = parseSdkApi(version, field);
+            if (parsed !== api) {
+                throw new HarmonyConfigError(`harmony.${field} describes API ${parsed}, but the configured API level is ${api}.`);
             }
             return version;
         }
     }
-    const version = HarmonySdkVersions.get(api);
+    const version = SdkVersions.get(api);
     if (!version) {
         throw new HarmonyConfigError(`Harmony API ${api} has no built-in SDK label. Set harmony.${field} explicitly so new SDK releases do not require a package update.`);
     }
@@ -157,7 +155,9 @@ function normalizeSkill(skill) {
             }
             const result = {};
             for (const [key, value] of Object.entries(uri)) {
-                result[key] = readString(value, `harmony.skills[].uris[].${key}`);
+                result[key] = typeof value === 'boolean' || (typeof value === 'number' && Number.isFinite(value))
+                    ? value
+                    : readString(value, `harmony.skills[].uris[].${key}`);
             }
             return result;
         });
@@ -176,38 +176,32 @@ function normalizeHarmonyConfig(config) {
     if (!harmony || typeof harmony !== 'object' || Array.isArray(harmony)) {
         throw new HarmonyConfigError('Expo config must contain a harmony object.');
     }
-    const bundleName = readString(harmony.bundleName, 'harmony.bundleName');
-    if (!BundleNamePattern.test(bundleName)) {
+    const bundle = readString(harmony.bundleName, 'harmony.bundleName');
+    if (!BundlePattern.test(bundle)) {
         throw new HarmonyConfigError('harmony.bundleName must contain at least three valid dot-separated segments.');
     }
-    const moduleName = readString(harmony.moduleName, 'harmony.moduleName', 'entry');
-    const abilityName = readString(harmony.abilityName, 'harmony.abilityName', 'EntryAbility');
-    if (!IdentifierPattern.test(moduleName)) {
+    const module = readString(harmony.moduleName, 'harmony.moduleName', 'entry');
+    const ability = readString(harmony.abilityName, 'harmony.abilityName', 'EntryAbility');
+    if (!IdentifierPattern.test(module)) {
         throw new HarmonyConfigError('harmony.moduleName must be a valid Harmony identifier.');
     }
-    if (!IdentifierPattern.test(abilityName)) {
+    if (!IdentifierPattern.test(ability)) {
         throw new HarmonyConfigError('harmony.abilityName must be a valid Harmony identifier.');
     }
-    const versionName = readString(harmony.versionName, 'harmony.versionName', config.version || '1.0.0');
-    const versionCode = readPositiveInteger(harmony.versionCode, 'versionCode', 1);
-    const targetSdkApi = parseSdkApi(harmony.targetSdkVersion, 'targetSdkVersion');
-    const targetApi = readPositiveInteger(harmony.targetApiVersion, 'targetApiVersion', targetSdkApi ?? DefaultHarmonyTargetApi);
-    const compatibleSdkApi = parseSdkApi(harmony.compatibleSdkVersion, 'compatibleSdkVersion');
-    const compatibleApi = readPositiveInteger(compatibleSdkApi ?? undefined, 'compatibleSdkVersion', DefaultHarmonyCompatibleApi);
-    if (compatibleApi < SupportedMinimumHarmonyApi) {
-        throw new HarmonyConfigError(`Harmony compatible API must be ${SupportedMinimumHarmonyApi} or newer.`);
+    const version = readString(harmony.versionName, 'harmony.versionName', config.version || '1.0.0');
+    const code = readPositiveInteger(harmony.versionCode, 'versionCode', 1);
+    const target = readPositiveInteger(harmony.targetApiVersion, 'targetApiVersion', parseSdkApi(harmony.targetSdkVersion, 'targetSdkVersion') ?? TargetApi);
+    const compatible = readPositiveInteger(parseSdkApi(harmony.compatibleSdkVersion, 'compatibleSdkVersion') ?? undefined, 'compatibleSdkVersion', MinimumApi);
+    if (compatible < MinimumApi) {
+        throw new HarmonyConfigError(`Harmony compatible API must be ${MinimumApi} or newer.`);
     }
-    if (compatibleApi > targetApi) {
+    if (compatible > target) {
         throw new HarmonyConfigError('Harmony compatibleSdkVersion cannot exceed targetApiVersion.');
     }
     const orientation = harmony.orientation || config.orientation || 'default';
-    if (!ValidOrientations.has(orientation)) {
+    if (!Orientations.has(orientation)) {
         throw new HarmonyConfigError(`Unsupported Harmony orientation: ${orientation}`);
     }
-    const style = harmony.userInterfaceStyle || config.userInterfaceStyle || 'light';
-    if (!['light', 'dark', 'automatic'].includes(style)) {
-        throw new HarmonyConfigError(`Unsupported Harmony UI style: ${style}`);
-    }
     const background = normalizeColor(harmony.backgroundColor || config.backgroundColor, 'harmony.backgroundColor', '#FFFFFF');
     const engine = harmony.jsEngine || 'hermes';
     if (engine !== 'hermes') {
@@ -250,27 +244,27 @@ function normalizeHarmonyConfig(config) {
         : readString(harmony.signingConfigFile, 'harmony.signingConfigFile');
     const devices = harmony.deviceTypes === undefined
         ? ['phone', 'tablet']
-        : normalizeStringArray(harmony.deviceTypes, 'harmony.deviceTypes', ValidDeviceTypes);
+        : normalizeStringArray(harmony.deviceTypes, 'harmony.deviceTypes', DeviceTypes);
     return Object.freeze({
         abiFilters: abis,
-        abilityName,
+        abilityName: ability,
         backgroundColor: background,
-        bundleName,
-        compatibleSdkVersionString: resolveSdkVersion(compatibleApi, 'compatibleSdkVersion', harmony.compatibleSdkVersion),
+        bundleName: bundle,
+        compatibleSdkVersionString: resolveSdkVersion(compatible, 'compatibleSdkVersion', harmony.compatibleSdkVersion),
         deviceTypes: devices,
         icon: harmony.icon || config.icon,
         label: readString(harmony.label, 'harmony.label', config.name),
-        moduleName,
+        moduleName: module,
         nativeOrientation: orientation === 'default' ? 'unspecified' : orientation,
         permissions,
         productName: readString(harmony.productName, 'harmony.productName', 'default'),
         querySchemes: queries,
         signingConfigFile: signing,
         skills,
-        targetApiVersion: targetApi,
-        targetSdkVersionString: resolveSdkVersion(targetApi, 'targetSdkVersion', harmony.targetSdkVersion),
+        targetApiVersion: target,
+        targetSdkVersionString: resolveSdkVersion(target, 'targetSdkVersion', harmony.targetSdkVersion),
         vendor: readString(harmony.vendor, 'harmony.vendor', 'expo-harmony'),
-        versionCode,
-        versionName,
+        versionCode: code,
+        versionName: version,
     });
 }

package/build/ownership.d.ts

@@ -1,6 +1,7 @@
-import type { ExpoConfig } from '@expo/config-types';
+import type { ExpoConfigWithHarmony } from './config';
 export interface HarmonyConfigPluginOwnership {
     readonly owner: string;
+    readonly files?: readonly string[];
     readonly ability?: Readonly<Partial<{
         startWindowBackground: string;
         startWindowIcon: string;
@@ -12,5 +13,5 @@ export interface HarmonyConfigPluginOwnership {
     }>>;
 }
 export declare function normalizeHarmonyConfigPlugins(value: unknown): readonly HarmonyConfigPluginOwnership[];
-export declare function registerHarmonyConfigPlugin(config: ExpoConfig, owner: string, claims?: Omit<HarmonyConfigPluginOwnership, 'owner'>): ExpoConfig;
-export declare function getHarmonyConfigPlugins(config: ExpoConfig): readonly HarmonyConfigPluginOwnership[];
+export declare function registerHarmonyConfigPlugin<Config extends ExpoConfigWithHarmony>(config: Config, owner: string, claims?: Omit<HarmonyConfigPluginOwnership, 'owner'>): Config;
+export declare function getHarmonyConfigPlugins(config: ExpoConfigWithHarmony): readonly HarmonyConfigPluginOwnership[];

package/build/ownership.js

@@ -89,7 +89,17 @@ function normalizeHarmonyConfigPlugins(value) {
             throw new TypeError(`Invalid Harmony config-plugin ownership: owner ${plugin.owner} is duplicated.`);
         }
         owners.add(plugin.owner);
+        let files;
+        if (plugin.files !== undefined) {
+            if (!Array.isArray(plugin.files) || plugin.files.some(file => typeof file !== 'string'
+                || !file || file.includes('\\') || file.includes('\0') || /^[A-Za-z]:/.test(file)
+                || file.split('/').some(part => !part || part === '.' || part === '..'))) {
+                throw new TypeError(`Invalid Harmony config-plugin ownership: ${plugin.owner}.files must contain relative file paths.`);
+            }
+            files = [...new Set(plugin.files)].sort();
+        }
         return {
+            ...(files === undefined ? {} : { files }),
             ability: normalizeAbility(plugin.ability),
             owner: plugin.owner,
             resources: normalizeResources(plugin.resources),
@@ -101,6 +111,13 @@ function registerHarmonyConfigPlugin(config, owner, claims = {}) {
     const plugin = normalizeHarmonyConfigPlugins([{ ...claims, owner }])[0];
     config._internal ??= {};
     const plugins = normalizeHarmonyConfigPlugins(config._internal.harmonyConfigPlugins);
+    for (const other of plugins) {
+        if (other.owner === owner)
+            continue;
+        const duplicate = plugin.files?.find(file => other.files?.includes(file));
+        if (duplicate)
+            throw new TypeError(`Harmony file ${duplicate} is claimed by both ${other.owner} and ${owner}.`);
+    }
     config._internal.harmonyConfigPlugins = normalizeHarmonyConfigPlugins([
         ...plugins.filter(item => item.owner !== owner),
         plugin,