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

package/build/mods.js

@@ -0,0 +1,428 @@
+"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.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");
+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', 'prepare', 'patch']);
+const ResourceModNames = ['strings', 'colors', 'media'];
+const AllModNames = Object.freeze([
+    'dangerous',
+    'prepare',
+    'reactNativeConfig',
+    'appJson',
+    'projectBuildProfile',
+    'rootOhPackage',
+    'rootHvigor',
+    'nativeInputsStamp',
+    'hvigorConfig',
+    'entryBuildProfile',
+    'entryOhPackage',
+    'entryHvigor',
+    'moduleJson',
+    'strings',
+    'colors',
+    'media',
+    'profiles',
+    'entryAbility',
+    'indexPage',
+    'worker',
+    'arktsPackageProvider',
+    '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 ??= [];
+    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(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.${name} must return ${kind === 'text' ? 'a string' : 'an object'} modResults.`, { operation: `harmony.${name}.write` });
+    }
+}
+function withFileProvider(config, name) {
+    return (0, config_plugins_1.withBaseMod)(config, {
+        platform: 'harmony',
+        mod: name,
+        isProvider: true,
+        isIntrospective: JsonMods.has(name),
+        saveToInternal: JsonMods.has(name),
+        async action(value) {
+            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'));
+                }
+                else {
+                    await (0, files_1.writeJson5)(file, result.modResults);
+                }
+                recordManagedFile(result, file, name);
+            }
+            return result;
+        },
+    });
+}
+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);
+        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;
+}
+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;
+            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 (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' });
+                }
+                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,
+            });
+        }
+    }
+    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 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 });
+                }
+            }
+        }
+        const file = await (0, paths_1.resolveHarmonyPath)(directory, name);
+        await (0, files_1.atomicWrite)(file, content);
+        recordManagedFile(config, file, 'media');
+    }
+}
+function withResourceProvider(config, name) {
+    const introspective = name !== 'media';
+    return (0, config_plugins_1.withBaseMod)(config, {
+        platform: 'harmony',
+        mod: name,
+        isProvider: true,
+        isIntrospective: introspective,
+        saveToInternal: introspective,
+        async action(value) {
+            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 next({ ...value, modRequest: request, modResults: data });
+            assertModResults(name, result.modResults, 'resource');
+            if (!result.modRequest.introspect) {
+                if (name === 'media') {
+                    await writeMediaMap(root, result.modResults, result, previous);
+                }
+                else {
+                    const paths = paths_1.ResourcePaths[name];
+                    for (const [scope, resource] of Object.entries(result.modResults)) {
+                        if (!(scope in paths))
+                            continue;
+                        if (!resource || typeof resource !== 'object' || Array.isArray(resource)) {
+                            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, name);
+                    }
+                }
+            }
+            return result;
+        },
+    });
+}
+function withVirtualProvider(config, name) {
+    return (0, config_plugins_1.withBaseMod)(config, {
+        platform: 'harmony',
+        mod: name,
+        isProvider: true,
+        isIntrospective: name === 'prepare',
+        async action(value) {
+            const { nextMod: next, ...request } = value.modRequest;
+            return next({ ...value, modRequest: request, modResults: null });
+        },
+    });
+}
+function withProvider(config, name) {
+    const actions = [];
+    config = (0, config_plugins_1.withMod)(config, {
+        platform: 'harmony',
+        mod: name,
+        async action(value) {
+            let result = value;
+            // 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(name) || TextMods.has(name)) {
+        config = withFileProvider(config, name);
+    }
+    else if (ResourceMods.has(name)) {
+        config = withResourceProvider(config, name);
+    }
+    else if (VirtualMods.has(name)) {
+        config = withVirtualProvider(config, name);
+    }
+    else {
+        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?.[name];
+    if (provider?.isProvider)
+        provider.expoHarmonyLateActions = actions;
+    return config;
+}
+function withHarmonyBaseMods(config) {
+    for (const name of AllModNames) {
+        const mods = config.mods;
+        if (!mods?.harmony?.[name]?.isProvider)
+            config = withProvider(config, name);
+    }
+    const mods = config.mods;
+    const table = mods.harmony;
+    mods.harmony = Object.fromEntries([
+        ...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;
+}
+function withHarmonyMod(config, tuple) {
+    if (!Array.isArray(tuple) || tuple.length !== 2) {
+        throw new TypeError('withHarmonyMod expects [modName, action].');
+    }
+    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?.[name];
+    if (provider?.isProvider && provider.expoHarmonyLateActions) {
+        // 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: name,
+        action: 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) => registerMod(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) => 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 name of ResourceModNames) {
+        withHarmonyMod(config, [name, 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, };

package/build/nativeInputs.js

@@ -0,0 +1,81 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HarmonyNativeInputsFingerprintVersion = void 0;
+exports.fingerprintHarmonyNativeInputsSync = fingerprintHarmonyNativeInputsSync;
+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 HarmonyNativeInputsFingerprintVersion = 1;
+exports.HarmonyNativeInputsFingerprintVersion = HarmonyNativeInputsFingerprintVersion;
+function readOptionalFile(file) {
+    try {
+        return Uint8Array.from(node_fs_1.default.readFileSync(file));
+    }
+    catch (cause) {
+        if (cause && typeof cause === 'object' && 'code' in cause && cause.code === 'ENOENT')
+            return null;
+        throw new Error(cause instanceof Error ? cause.message : String(cause), { cause });
+    }
+}
+function resolveLocalHar(root, specifier) {
+    if (typeof specifier !== 'string' || !/^\.\.?[\\/]/u.test(specifier))
+        return null;
+    if (!specifier.toLowerCase().endsWith('.har'))
+        return null;
+    return node_path_1.default.resolve(root, specifier);
+}
+function findLocalHars(root, manifest) {
+    const specifiers = [
+        ...Object.values(manifest.dependencies ?? {}),
+        ...Object.values(manifest.overrides ?? {}),
+    ];
+    return [...new Set(specifiers.map(specifier => resolveLocalHar(root, specifier)))]
+        .filter((value) => value !== null)
+        .sort();
+}
+function hashFile(hash, file) {
+    const handle = node_fs_1.default.openSync(file, 'r');
+    const buffer = new Uint8Array(1024 * 1024);
+    try {
+        while (true) {
+            const size = node_fs_1.default.readSync(handle, buffer, 0, buffer.length, null);
+            if (size === 0)
+                break;
+            hash.update(Uint8Array.from(buffer.subarray(0, size)));
+        }
+    }
+    finally {
+        node_fs_1.default.closeSync(handle);
+    }
+}
+function fingerprintHarmonyNativeInputsSync(options) {
+    const data = node_fs_1.default.readFileSync(options.manifest);
+    const lock = readOptionalFile(options.lockfile);
+    const manifest = json5_1.default.parse(data.toString('utf8'));
+    const root = node_path_1.default.dirname(options.manifest);
+    const files = findLocalHars(root, manifest);
+    const hash = node_crypto_1.default.createHash('sha256');
+    hash.update(`expo-harmony-native-dependencies-v${HarmonyNativeInputsFingerprintVersion}\0`);
+    hash.update(Uint8Array.from(data));
+    if (lock)
+        hash.update(lock);
+    for (const file of files) {
+        if (!node_fs_1.default.statSync(file).isFile()) {
+            throw new Error(`Cannot fingerprint Harmony native artifact: ${file}`);
+        }
+        const relative = node_path_1.default.relative(options.projectRoot, file).split(node_path_1.default.sep).join('/');
+        hash.update('\0artifact\0');
+        hash.update(relative);
+        hash.update('\0');
+        hashFile(hash, file);
+    }
+    return {
+        artifactCount: files.length,
+        fingerprint: hash.digest('hex'),
+        fingerprintVersion: HarmonyNativeInputsFingerprintVersion,
+    };
+}

package/build/normalizeConfig.d.ts

@@ -0,0 +1,35 @@
+import type { ExpoConfigWithHarmony, HarmonyConfig, HarmonyPermission } from './config';
+type HarmonyExpoConfig = ExpoConfigWithHarmony;
+interface NormalizedHarmonyConfig {
+    abiFilters: string[];
+    abilityName: string;
+    backgroundColor: string;
+    bundleName: string;
+    compatibleSdkVersionString: string;
+    deviceTypes: NonNullable<HarmonyConfig['deviceTypes']>;
+    icon?: string;
+    label: string;
+    moduleName: string;
+    nativeOrientation: Exclude<NonNullable<HarmonyConfig['orientation']>, 'default'> | 'unspecified';
+    permissions: NonNullable<HarmonyConfig['permissions']>;
+    productName: string;
+    querySchemes: string[];
+    signingConfigFile?: string;
+    skills: NonNullable<HarmonyConfig['skills']>;
+    targetApiVersion: number;
+    targetSdkVersionString: string;
+    vendor: string;
+    versionCode: number;
+    versionName: string;
+}
+export declare function normalizePermission(permission: HarmonyPermission): {
+    name: string;
+    reason?: string;
+    usedScene?: {
+        abilities?: string[];
+        when: "always" | "inuse";
+    };
+};
+declare function normalizeHarmonyConfig(config: HarmonyExpoConfig): NormalizedHarmonyConfig;
+export { normalizeHarmonyConfig };
+export type { HarmonyExpoConfig, NormalizedHarmonyConfig };