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

package/build/config.d.ts

@@ -0,0 +1,64 @@
+import type { ExpoConfig } from '@expo/config-types';
+export type HarmonyPlatform = 'harmony';
+export type ExpoKnownPlatform = NonNullable<ExpoConfig['platforms']>[number];
+export type ExpoHarmonyPlatform = ExpoKnownPlatform | HarmonyPlatform;
+export type HarmonyDeviceType = 'phone' | 'tablet' | '2in1';
+export type HarmonyOrientation = 'default' | 'portrait' | 'landscape' | 'portrait_inverted' | 'landscape_inverted' | 'auto_rotation';
+export interface HarmonyPermission {
+    name: string;
+    reason?: string;
+    usedScene?: {
+        abilities?: string[];
+        when?: 'inuse' | 'always';
+    };
+}
+export interface HarmonySkill {
+    entities?: string[];
+    actions?: string[];
+    uris?: Array<Record<string, string>>;
+}
+export interface HarmonyFontDefinition {
+    path: string;
+    weight?: number;
+    style?: 'normal' | 'italic';
+}
+export type HarmonyFont = string | {
+    fontFamily: string;
+    fontDefinitions: HarmonyFontDefinition[];
+};
+export interface HarmonyConfig {
+    bundleName: string;
+    moduleName?: string;
+    abilityName?: string;
+    productName?: string;
+    vendor?: string;
+    versionCode?: number;
+    versionName?: string;
+    targetApiVersion?: number;
+    /** Harmony SDK label written to build-profile.json5, e.g. 6.0.0(20). Its API must match targetApiVersion. */
+    targetSdkVersion?: number | string;
+    /** API number, or a full Harmony SDK label ending in the API number. */
+    compatibleSdkVersion?: number | string;
+    deviceTypes?: HarmonyDeviceType[];
+    permissions?: HarmonyPermission[];
+    skills?: HarmonySkill[];
+    /** URL schemes the app may inspect with Linking.canOpenURL. http, https, and expo.scheme are added automatically. */
+    querySchemes?: string[];
+    icon?: string;
+    label?: string;
+    backgroundColor?: string;
+    orientation?: HarmonyOrientation;
+    userInterfaceStyle?: 'light' | 'dark' | 'automatic';
+    jsEngine?: 'hermes';
+    abiFilters?: string[];
+    signingConfigFile?: string;
+    /** Fonts bundled when the `@expo-harmony/expo-font` config plugin is registered. */
+    fonts?: HarmonyFont[];
+}
+export type ExpoConfigWithHarmony = Omit<ExpoConfig, 'platforms'> & {
+    platforms?: ExpoHarmonyPlatform[];
+    harmony?: HarmonyConfig;
+};
+export declare function defineExpoHarmonyConfig<T extends {
+    expo: ExpoConfigWithHarmony;
+} | ExpoConfigWithHarmony>(config: T): T;

package/build/config.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defineExpoHarmonyConfig = defineExpoHarmonyConfig;
+function defineExpoHarmonyConfig(config) {
+    return config;
+}

package/build/errors.d.ts

@@ -0,0 +1,11 @@
+export interface HarmonyConfigPluginErrorOptions {
+    cause?: unknown;
+    file?: string;
+    operation?: string;
+}
+export declare class HarmonyConfigPluginError extends Error {
+    readonly code: string;
+    readonly operation: string;
+    readonly file?: string;
+    constructor(code: string, message: string, options?: HarmonyConfigPluginErrorOptions);
+}

package/build/errors.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HarmonyConfigPluginError = void 0;
+class HarmonyConfigPluginError extends Error {
+    constructor(code, message, options = {}) {
+        super(message, options.cause === undefined ? undefined : { cause: options.cause });
+        this.name = 'HarmonyConfigPluginError';
+        this.code = code;
+        this.operation = options.operation || 'config-plugin';
+        if (options.file)
+            this.file = options.file;
+    }
+}
+exports.HarmonyConfigPluginError = HarmonyConfigPluginError;

package/build/files.d.ts

@@ -0,0 +1,6 @@
+export declare function stableJson(value: unknown): string;
+export declare function readJson5<T>(file: string, fallback: T, modName: string): Promise<T>;
+export declare function readText(file: string, fallback?: string): Promise<string>;
+export declare function atomicWrite(file: string, content: string | Uint8Array): Promise<void>;
+export declare function writeJson5(file: string, value: unknown): Promise<void>;
+export declare function sha256File(file: string): Promise<string>;

package/build/files.js

@@ -0,0 +1,69 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stableJson = stableJson;
+exports.readJson5 = readJson5;
+exports.readText = readText;
+exports.atomicWrite = atomicWrite;
+exports.writeJson5 = writeJson5;
+exports.sha256File = sha256File;
+const node_crypto_1 = __importDefault(require("node:crypto"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const json5_1 = __importDefault(require("json5"));
+const errors_1 = require("./errors");
+function sortValue(value) {
+    if (Array.isArray(value))
+        return value.map(sortValue);
+    if (value && typeof value === 'object' && !Buffer.isBuffer(value)) {
+        const record = value;
+        const entries = Object.keys(record).sort().map(key => [key, sortValue(record[key])]);
+        return Object.fromEntries(entries);
+    }
+    return value;
+}
+function stableJson(value) {
+    return `${JSON.stringify(sortValue(value), null, 2)}\n`;
+}
+async function readJson5(file, fallback, modName) {
+    try {
+        const source = await node_fs_1.default.promises.readFile(file, 'utf8');
+        return json5_1.default.parse(source);
+    }
+    catch (cause) {
+        if (cause.code === 'ENOENT')
+            return structuredClone(fallback);
+        throw new errors_1.HarmonyConfigPluginError('ERR_HARMONY_JSON5_INVALID', `Cannot parse ${file} for harmony.${modName}: ${cause.message}`, { cause, file, operation: `harmony.${modName}.read` });
+    }
+}
+async function readText(file, fallback = '') {
+    try {
+        return await node_fs_1.default.promises.readFile(file, 'utf8');
+    }
+    catch (cause) {
+        if (cause.code === 'ENOENT')
+            return fallback;
+        throw new errors_1.HarmonyConfigPluginError('ERR_HARMONY_TEXT_INVALID', `Cannot read ${file}: ${cause.message}`, { cause, file, operation: 'harmony.mod.read' });
+    }
+}
+async function atomicWrite(file, content) {
+    const directory = node_path_1.default.dirname(file);
+    const temporary = node_path_1.default.join(directory, `.${node_path_1.default.basename(file)}.${process.pid}.${node_crypto_1.default.randomBytes(6).toString('hex')}.tmp`);
+    await node_fs_1.default.promises.mkdir(directory, { recursive: true });
+    try {
+        await node_fs_1.default.promises.writeFile(temporary, content);
+        await node_fs_1.default.promises.rename(temporary, file);
+    }
+    finally {
+        await node_fs_1.default.promises.rm(temporary, { force: true }).catch(() => { });
+    }
+}
+async function writeJson5(file, value) {
+    await atomicWrite(file, stableJson(value));
+}
+async function sha256File(file) {
+    const data = Uint8Array.from(await node_fs_1.default.promises.readFile(file));
+    return node_crypto_1.default.createHash('sha256').update(data).digest('hex');
+}

package/build/index.d.ts

@@ -0,0 +1,12 @@
+export { defineExpoHarmonyConfig } from './config';
+export type { ExpoConfigWithHarmony, ExpoHarmonyPlatform, ExpoKnownPlatform, HarmonyConfig, HarmonyDeviceType, HarmonyFont, HarmonyFontDefinition, HarmonyOrientation, HarmonyPermission, HarmonyPlatform, HarmonySkill, } from './config';
+export { HarmonyConfigPluginError } from './errors';
+export { atomicWrite, stableJson as stableHarmonyJson } from './files';
+export { HarmonySdkVersions, normalizeHarmonyConfig } from './normalizeConfig';
+export type { HarmonyExpoConfig, NormalizedHarmonyConfig } from './normalizeConfig';
+export { HarmonyModNames as HARMONY_MOD_NAMES, recordManagedFile, withAppJson, withArkTSPackageProvider, withCMakeLists, withCngManifest, withColors, withCppPackageProvider, withEntryAbility, withEntryBuildProfile, withEntryHvigor, withEntryOhPackage, withHarmonyAutolinking, withHarmonyBaseMods, withHarmonyDangerousMod, withHarmonyMod, withHarmonyResources, withHvigorConfig, withIndexPage, withMedia, withModuleJson, withNativeInputsStamp, withProfiles, withProjectBuildProfile, withReactNativeConfig, withRootHvigor, withRootOhPackage, withStrings, withWorker, } from './mods';
+export type { HarmonyJson, HarmonyMediaDescriptor, HarmonyMediaMap, HarmonyModAction, HarmonyModName, HarmonyResourceMap, } from './mods';
+export { getHarmonyConfigPlugins, normalizeHarmonyConfigPlugins, registerHarmonyConfigPlugin, } from './ownership';
+export type { HarmonyConfigPluginOwnership } from './ownership';
+export { HarmonyPaths } from './paths';
+export type { HarmonyManagedPaths, HarmonyPathsApi, HarmonyProjectPathCandidates, HarmonyProjectPaths, HarmonyResourcePaths, } from './paths';

package/build/mods.d.ts

@@ -0,0 +1,52 @@
+import { type ConfigPlugin, type ExportedConfigWithProps } from '@expo/config-plugins';
+import type { ExpoConfig } from '@expo/config-types';
+export type HarmonyModName = 'dangerous' | 'reactNativeConfig' | 'appJson' | 'projectBuildProfile' | 'rootOhPackage' | 'rootHvigor' | 'nativeInputsStamp' | 'hvigorConfig' | 'entryBuildProfile' | 'entryOhPackage' | 'entryHvigor' | 'moduleJson' | 'strings' | 'colors' | 'media' | 'profiles' | 'entryAbility' | 'indexPage' | 'worker' | 'arktsPackageProvider' | 'cppPackageProvider' | 'cmakeLists' | 'autolinking' | 'manifest';
+export type HarmonyModAction<T = unknown> = (config: ExportedConfigWithProps<T>) => ExportedConfigWithProps<T> | Promise<ExportedConfigWithProps<T>>;
+export type HarmonyJson = Record<string, unknown>;
+export type HarmonyResourceMap = Record<string, HarmonyJson>;
+export type HarmonyMediaDescriptor = {
+    source: string;
+    content?: never;
+    replaceBase?: boolean;
+} | {
+    source?: never;
+    content: string | Uint8Array;
+    replaceBase?: boolean;
+};
+export type HarmonyMediaMap = Record<string, Record<string, HarmonyMediaDescriptor>>;
+interface ManagedConfig {
+    _internal?: ExpoConfig['_internal'];
+    modRequest: {
+        projectRoot: string;
+    };
+}
+export declare const HarmonyModNames: readonly HarmonyModName[];
+export declare function recordManagedFile(config: ManagedConfig, file: string, owner: string): void;
+export declare function withHarmonyBaseMods(config: ExpoConfig): ExpoConfig;
+export declare function withHarmonyMod<T = unknown>(config: ExpoConfig, tuple: [HarmonyModName, HarmonyModAction<T>]): ExpoConfig;
+export declare const withReactNativeConfig: ConfigPlugin<HarmonyModAction<string>>;
+export declare const withAppJson: ConfigPlugin<HarmonyModAction<HarmonyJson>>;
+export declare const withProjectBuildProfile: ConfigPlugin<HarmonyModAction<HarmonyJson>>;
+export declare const withRootOhPackage: ConfigPlugin<HarmonyModAction<HarmonyJson>>;
+export declare const withRootHvigor: ConfigPlugin<HarmonyModAction<string>>;
+export declare const withNativeInputsStamp: ConfigPlugin<HarmonyModAction<string>>;
+export declare const withHvigorConfig: ConfigPlugin<HarmonyModAction<HarmonyJson>>;
+export declare const withEntryBuildProfile: ConfigPlugin<HarmonyModAction<HarmonyJson>>;
+export declare const withEntryOhPackage: ConfigPlugin<HarmonyModAction<HarmonyJson>>;
+export declare const withEntryHvigor: ConfigPlugin<HarmonyModAction<string>>;
+export declare const withModuleJson: ConfigPlugin<HarmonyModAction<HarmonyJson>>;
+export declare const withStrings: ConfigPlugin<HarmonyModAction<HarmonyResourceMap>>;
+export declare const withColors: ConfigPlugin<HarmonyModAction<HarmonyResourceMap>>;
+export declare const withMedia: ConfigPlugin<HarmonyModAction<HarmonyMediaMap>>;
+export declare const withProfiles: ConfigPlugin<HarmonyModAction<HarmonyJson>>;
+export declare const withEntryAbility: ConfigPlugin<HarmonyModAction<string>>;
+export declare const withIndexPage: ConfigPlugin<HarmonyModAction<string>>;
+export declare const withWorker: ConfigPlugin<HarmonyModAction<string>>;
+export declare const withArkTSPackageProvider: ConfigPlugin<HarmonyModAction<string>>;
+export declare const withCppPackageProvider: ConfigPlugin<HarmonyModAction<string>>;
+export declare const withCMakeLists: ConfigPlugin<HarmonyModAction<string>>;
+export declare const withHarmonyAutolinking: ConfigPlugin<HarmonyModAction<null>>;
+export declare const withCngManifest: ConfigPlugin<HarmonyModAction<null>>;
+export declare const withHarmonyDangerousMod: ConfigPlugin<HarmonyModAction<null>>;
+export declare const withHarmonyResources: ConfigPlugin<HarmonyModAction<unknown>>;
+export {};

package/build/mods.js

@@ -0,0 +1,400 @@
+"use strict";
+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.recordManagedFile = recordManagedFile;
+exports.withHarmonyBaseMods = withHarmonyBaseMods;
+exports.withHarmonyMod = withHarmonyMod;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const config_plugins_1 = require("@expo/config-plugins");
+const errors_1 = require("./errors");
+const files_1 = require("./files");
+const paths_1 = require("./paths");
+const JsonMods = new Set([
+    'appJson',
+    'projectBuildProfile',
+    'rootOhPackage',
+    'hvigorConfig',
+    'entryBuildProfile',
+    'entryOhPackage',
+    'moduleJson',
+    'profiles',
+]);
+const TextMods = new Set([
+    'reactNativeConfig',
+    'rootHvigor',
+    'nativeInputsStamp',
+    'entryHvigor',
+    'entryAbility',
+    'indexPage',
+    'worker',
+    'arktsPackageProvider',
+    'cppPackageProvider',
+    'cmakeLists',
+]);
+const ResourceMods = new Set(['strings', 'colors', 'media']);
+const VirtualMods = new Set(['dangerous', 'autolinking', 'manifest']);
+const ResourceModNames = ['strings', 'colors', 'media'];
+exports.HarmonyModNames = Object.freeze([
+    'dangerous',
+    'reactNativeConfig',
+    'appJson',
+    'projectBuildProfile',
+    'rootOhPackage',
+    'rootHvigor',
+    'nativeInputsStamp',
+    'hvigorConfig',
+    'entryBuildProfile',
+    'entryOhPackage',
+    'entryHvigor',
+    'moduleJson',
+    'strings',
+    'colors',
+    'media',
+    'profiles',
+    'entryAbility',
+    'indexPage',
+    'worker',
+    'arktsPackageProvider',
+    'cppPackageProvider',
+    'cmakeLists',
+    'autolinking',
+    'manifest',
+]);
+function recordManagedFile(config, file, owner) {
+    config._internal ??= {};
+    config._internal.harmonyManagedFiles ??= [];
+    const entry = (0, paths_1.toPosixRelative)(config.modRequest.projectRoot, file);
+    const files = config._internal.harmonyManagedFiles.filter((item) => item.path !== entry);
+    files.push({ path: entry, owner });
+    files.sort((left, right) => left.path.localeCompare(right.path, 'en'));
+    config._internal.harmonyManagedFiles = files;
+}
+function assertModResults(modName, 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` });
+    }
+}
+function withFileProvider(config, modName) {
+    return (0, config_plugins_1.withBaseMod)(config, {
+        platform: 'harmony',
+        mod: modName,
+        isProvider: true,
+        isIntrospective: JsonMods.has(modName),
+        saveToInternal: JsonMods.has(modName),
+        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');
+            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'));
+                }
+                else {
+                    await (0, files_1.writeJson5)(file, result.modResults);
+                }
+                recordManagedFile(result, file, modName);
+            }
+            return result;
+        },
+    });
+}
+async function readResourceMap(root, entries, modName) {
+    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);
+    }
+    return resources;
+}
+async function readMediaMap(root) {
+    const media = {};
+    for (const [scope, relative] of Object.entries(paths_1.ResourcePaths.media)) {
+        const directory = await (0, paths_1.resolveHarmonyPath)(root, relative);
+        media[scope] = {};
+        let names = [];
+        try {
+            names = await node_fs_1.default.promises.readdir(directory);
+        }
+        catch (cause) {
+            if (cause.code !== 'ENOENT') {
+                throw new errors_1.HarmonyConfigPluginError('ERR_HARMONY_RESOURCE_READ', `Cannot read Harmony media directory ${directory}: ${cause.message}`, { cause, file: directory, operation: 'harmony.media.read' });
+            }
+        }
+        for (const name of names.sort()) {
+            const file = node_path_1.default.join(directory, name);
+            if ((await node_fs_1.default.promises.lstat(file)).isFile())
+                media[scope][name] = { source: file };
+        }
+    }
+    return media;
+}
+async function writeMediaMap(root, media, config, previous = {}) {
+    const writes = [];
+    for (const [scope, files] of Object.entries(media || {})) {
+        if (!(scope in paths_1.ResourcePaths.media))
+            continue;
+        if (!files || typeof files !== 'object' || Array.isArray(files)) {
+            throw new errors_1.HarmonyConfigPluginError('ERR_HARMONY_CONFIG_INVALID', `Harmony media scope ${scope} must be an object.`, { operation: 'harmony.media.write' });
+        }
+        const directory = await (0, paths_1.resolveHarmonyPath)(root, paths_1.ResourcePaths.media[scope]);
+        for (const [name, descriptor] of Object.entries(files)) {
+            if (!/^[A-Za-z0-9_.-]+$/.test(name) || name.includes('..')) {
+                throw new errors_1.HarmonyConfigPluginError('ERR_HARMONY_CONFIG_INVALID', `Invalid Harmony media file name: ${name}`, { operation: 'harmony.media.write' });
+            }
+            if (!descriptor || typeof descriptor !== 'object' || Array.isArray(descriptor)) {
+                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) {
+                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 (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' });
+                }
+                content = Uint8Array.from(await node_fs_1.default.promises.readFile(item.source));
+            }
+            else {
+                if (typeof item.content !== 'string' && !(item.content instanceof Uint8Array)) {
+                    throw new errors_1.HarmonyConfigPluginError('ERR_HARMONY_CONFIG_INVALID', `Harmony media ${scope}/${name} content must be a string or Uint8Array.`, { operation: 'harmony.media.write' });
+                }
+                content = item.content;
+            }
+            writes.push({
+                content,
+                directory,
+                name,
+                replaceBase: item.replaceBase === true,
+            });
+        }
+    }
+    // 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;
+        const directory = await (0, paths_1.resolveHarmonyPath)(root, paths_1.ResourcePaths.media[scope]);
+        const next = media?.[scope];
+        for (const name of names) {
+            if (!next || typeof next !== 'object' || !Object.hasOwn(next, name)) {
+                const file = await (0, paths_1.resolveHarmonyPath)(directory, name);
+                await node_fs_1.default.promises.rm(file, { force: true });
+            }
+        }
+    }
+    for (const { content, directory, name, replaceBase } of writes) {
+        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 });
+                }
+            }
+        }
+        const file = await (0, paths_1.resolveHarmonyPath)(directory, name);
+        await (0, files_1.atomicWrite)(file, content);
+        recordManagedFile(config, file, 'media');
+    }
+}
+function withResourceProvider(config, modName) {
+    const isIntrospective = modName !== 'media';
+    return (0, config_plugins_1.withBaseMod)(config, {
+        platform: 'harmony',
+        mod: modName,
+        isProvider: true,
+        isIntrospective,
+        saveToInternal: isIntrospective,
+        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'
+                ? 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');
+            if (!result.modRequest.introspect) {
+                if (modName === 'media') {
+                    await writeMediaMap(root, result.modResults, result, previous);
+                }
+                else {
+                    const paths = paths_1.ResourcePaths[modName];
+                    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` });
+                        }
+                        const file = await (0, paths_1.resolveHarmonyPath)(root, paths[scope]);
+                        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);
+                    }
+                }
+            }
+            return result;
+        },
+    });
+}
+function withVirtualProvider(config, modName) {
+    return (0, config_plugins_1.withBaseMod)(config, {
+        platform: 'harmony',
+        mod: modName,
+        isProvider: true,
+        async action(value) {
+            const { nextMod, ...modRequest } = value.modRequest;
+            return nextMod({ ...value, modRequest, modResults: null });
+        },
+    });
+}
+function withProvider(config, modName) {
+    const actions = [];
+    config = (0, config_plugins_1.withMod)(config, {
+        platform: 'harmony',
+        mod: modName,
+        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.
+            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);
+    }
+    else if (ResourceMods.has(modName)) {
+        config = withResourceProvider(config, modName);
+    }
+    else if (VirtualMods.has(modName)) {
+        config = withVirtualProvider(config, modName);
+    }
+    else {
+        throw new errors_1.HarmonyConfigPluginError('ERR_HARMONY_MOD_NOT_REGISTERED', `Unknown Harmony mod: ${modName}`, { operation: 'register-base-mods' });
+    }
+    const mods = config.mods;
+    const provider = mods?.harmony?.[modName];
+    if (provider?.isProvider)
+        provider.expoHarmonyLateActions = actions;
+    return config;
+}
+function withHarmonyBaseMods(config) {
+    for (const modName of exports.HarmonyModNames) {
+        const mods = config.mods;
+        if (!mods?.harmony?.[modName]?.isProvider)
+            config = withProvider(config, modName);
+    }
+    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)),
+    ]);
+    return config;
+}
+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 mods = config.mods;
+    const provider = mods?.harmony?.[modName];
+    if (provider?.isProvider && provider.expoHarmonyLateActions) {
+        provider.expoHarmonyLateActions.push(action);
+        return config;
+    }
+    return (0, config_plugins_1.withMod)(config, { platform: 'harmony', mod: modName, action });
+}
+const withReactNativeConfig = (config, action) => withHarmonyMod(config, ['reactNativeConfig', action]);
+exports.withReactNativeConfig = withReactNativeConfig;
+const withAppJson = (config, action) => withHarmonyMod(config, ['appJson', action]);
+exports.withAppJson = withAppJson;
+const withProjectBuildProfile = (config, action) => withHarmonyMod(config, ['projectBuildProfile', action]);
+exports.withProjectBuildProfile = withProjectBuildProfile;
+const withRootOhPackage = (config, action) => withHarmonyMod(config, ['rootOhPackage', action]);
+exports.withRootOhPackage = withRootOhPackage;
+const withRootHvigor = (config, action) => withHarmonyMod(config, ['rootHvigor', action]);
+exports.withRootHvigor = withRootHvigor;
+const withNativeInputsStamp = (config, action) => withHarmonyMod(config, ['nativeInputsStamp', action]);
+exports.withNativeInputsStamp = withNativeInputsStamp;
+const withHvigorConfig = (config, action) => withHarmonyMod(config, ['hvigorConfig', action]);
+exports.withHvigorConfig = withHvigorConfig;
+const withEntryBuildProfile = (config, action) => withHarmonyMod(config, ['entryBuildProfile', action]);
+exports.withEntryBuildProfile = withEntryBuildProfile;
+const withEntryOhPackage = (config, action) => withHarmonyMod(config, ['entryOhPackage', action]);
+exports.withEntryOhPackage = withEntryOhPackage;
+const withEntryHvigor = (config, action) => withHarmonyMod(config, ['entryHvigor', action]);
+exports.withEntryHvigor = withEntryHvigor;
+const withModuleJson = (config, action) => withHarmonyMod(config, ['moduleJson', action]);
+exports.withModuleJson = withModuleJson;
+const withStrings = (config, action) => withHarmonyMod(config, ['strings', action]);
+exports.withStrings = withStrings;
+const withColors = (config, action) => withHarmonyMod(config, ['colors', action]);
+exports.withColors = withColors;
+const withMedia = (config, action) => withHarmonyMod(config, ['media', action]);
+exports.withMedia = withMedia;
+const withProfiles = (config, action) => withHarmonyMod(config, ['profiles', action]);
+exports.withProfiles = withProfiles;
+const withEntryAbility = (config, action) => withHarmonyMod(config, ['entryAbility', action]);
+exports.withEntryAbility = withEntryAbility;
+const withIndexPage = (config, action) => withHarmonyMod(config, ['indexPage', action]);
+exports.withIndexPage = withIndexPage;
+const withWorker = (config, action) => withHarmonyMod(config, ['worker', action]);
+exports.withWorker = withWorker;
+const withArkTSPackageProvider = (config, action) => withHarmonyMod(config, ['arktsPackageProvider', action]);
+exports.withArkTSPackageProvider = withArkTSPackageProvider;
+const withCppPackageProvider = (config, action) => withHarmonyMod(config, ['cppPackageProvider', action]);
+exports.withCppPackageProvider = withCppPackageProvider;
+const withCMakeLists = (config, action) => withHarmonyMod(config, ['cmakeLists', action]);
+exports.withCMakeLists = withCMakeLists;
+const withHarmonyAutolinking = (config, action) => withHarmonyMod(config, ['autolinking', action]);
+exports.withHarmonyAutolinking = withHarmonyAutolinking;
+const withCngManifest = (config, action) => withHarmonyMod(config, ['manifest', action]);
+exports.withCngManifest = withCngManifest;
+const withHarmonyDangerousMod = (config, action) => withHarmonyMod(config, ['dangerous', action]);
+exports.withHarmonyDangerousMod = withHarmonyDangerousMod;
+const withHarmonyResources = (config, action) => {
+    for (const modName of ResourceModNames) {
+        withHarmonyMod(config, [modName, action]);
+    }
+    return config;
+};
+exports.withHarmonyResources = withHarmonyResources;

package/build/nativeInputs.d.ts

@@ -0,0 +1,14 @@
+declare const HarmonyNativeInputsFingerprintVersion = 1;
+interface HarmonyNativeInputsFingerprint {
+    artifactCount: number;
+    fingerprint: string;
+    fingerprintVersion: typeof HarmonyNativeInputsFingerprintVersion;
+}
+interface HarmonyNativeInputsFingerprintOptions {
+    lockfile: string;
+    manifest: string;
+    projectRoot: string;
+}
+declare function fingerprintHarmonyNativeInputsSync(options: HarmonyNativeInputsFingerprintOptions): HarmonyNativeInputsFingerprint;
+export { HarmonyNativeInputsFingerprintVersion, fingerprintHarmonyNativeInputsSync, };
+export type { HarmonyNativeInputsFingerprint, HarmonyNativeInputsFingerprintOptions, };