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

package/build/normalizeConfig.js

@@ -0,0 +1,270 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizePermission = normalizePermission;
+exports.normalizeHarmonyConfig = normalizeHarmonyConfig;
+const errors_1 = require("./errors");
+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 Orientations = new Set([
+    'default',
+    'portrait',
+    'landscape',
+    'portrait_inverted',
+    'landscape_inverted',
+    'auto_rotation',
+]);
+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)'],
+]);
+class HarmonyConfigError extends errors_1.HarmonyConfigPluginError {
+    constructor(message) {
+        super('ERR_HARMONY_CONFIG_INVALID', message, { operation: 'normalize-config' });
+        this.name = 'HarmonyConfigError';
+    }
+}
+function readPositiveInteger(value, field, fallback) {
+    const result = value === undefined ? fallback : value;
+    if (typeof result !== 'number' || !Number.isSafeInteger(result) || result <= 0) {
+        throw new HarmonyConfigError(`harmony.${field} must be a positive integer.`);
+    }
+    return result;
+}
+function readString(value, field, fallback) {
+    const result = value === undefined ? fallback : value;
+    if (typeof result !== 'string' || !result.trim()) {
+        throw new HarmonyConfigError(`${field} must be a non-empty string.`);
+    }
+    if (/\0|[\r\n]/.test(result)) {
+        throw new HarmonyConfigError(`${field} must not contain control characters.`);
+    }
+    return result.trim();
+}
+function normalizeColor(value, field, fallback) {
+    const color = value === undefined ? fallback : value;
+    if (typeof color !== 'string' || !ColorPattern.test(color)) {
+        throw new HarmonyConfigError(`${field} must be #RRGGBB or #RRGGBBAA.`);
+    }
+    return (0, resources_1.toArgb)(color);
+}
+function parseSdkApi(value, field) {
+    if (value === undefined)
+        return null;
+    if (typeof value === 'number' && Number.isSafeInteger(value) && value > 0)
+        return value;
+    if (typeof value !== 'string') {
+        throw new HarmonyConfigError(`harmony.${field} must be a positive API number or an SDK label.`);
+    }
+    const match = /\((\d+)\)$/u.exec(value.trim());
+    const api = Number(match?.[1]);
+    if (!match || !Number.isSafeInteger(api) || api <= 0) {
+        throw new HarmonyConfigError(`harmony.${field} must end with its API level in parentheses, for example "6.0.0(20)".`);
+    }
+    return api;
+}
+function resolveSdkVersion(api, field, value) {
+    if (value !== undefined) {
+        if (typeof value === 'number' && Number.isSafeInteger(value) && value > 0) {
+            if (value !== api) {
+                throw new HarmonyConfigError(`harmony.${field} is API ${value}, but the configured API level is ${api}.`);
+            }
+        }
+        else {
+            const version = readString(value, `harmony.${field}`);
+            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 = 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.`);
+    }
+    return version;
+}
+function normalizeStringArray(value, field, allowed) {
+    if (!Array.isArray(value) || value.length === 0) {
+        throw new HarmonyConfigError(`${field} must be a non-empty array.`);
+    }
+    const result = [];
+    for (const item of value) {
+        if (typeof item !== 'string' || !item || (allowed && !allowed.has(item))) {
+            throw new HarmonyConfigError(`Invalid ${field} entry: ${item}`);
+        }
+        if (!result.includes(item))
+            result.push(item);
+    }
+    return result;
+}
+function normalizePermission(permission) {
+    if (!permission || typeof permission !== 'object') {
+        throw new HarmonyConfigError('harmony.permissions entries must be objects.');
+    }
+    const name = readString(permission.name, 'harmony.permissions[].name');
+    if (!/^ohos\.permission\.[A-Z0-9_]+$/.test(name)) {
+        throw new HarmonyConfigError(`Invalid Harmony permission: ${name}`);
+    }
+    const result = { name };
+    if (permission.reason !== undefined) {
+        result.reason = readString(permission.reason, 'harmony.permissions[].reason');
+    }
+    if (permission.usedScene !== undefined) {
+        if (!permission.usedScene || typeof permission.usedScene !== 'object') {
+            throw new HarmonyConfigError('permission.usedScene must be an object.');
+        }
+        const when = permission.usedScene.when === undefined
+            ? 'inuse'
+            : permission.usedScene.when;
+        if (!['inuse', 'always'].includes(when)) {
+            throw new HarmonyConfigError('permission.usedScene.when must be inuse or always.');
+        }
+        const abilities = permission.usedScene.abilities === undefined
+            ? undefined
+            : normalizeStringArray(permission.usedScene.abilities, 'permission.usedScene.abilities');
+        result.usedScene = { ...(abilities ? { abilities } : {}), when };
+    }
+    return result;
+}
+function normalizeSkill(skill) {
+    if (!skill || typeof skill !== 'object') {
+        throw new HarmonyConfigError('harmony.skills entries must be objects.');
+    }
+    const result = {};
+    for (const field of ['entities', 'actions']) {
+        if (skill[field] !== undefined)
+            result[field] = normalizeStringArray(skill[field], `harmony.skills[].${field}`);
+    }
+    if (skill.uris !== undefined) {
+        if (!Array.isArray(skill.uris)) {
+            throw new HarmonyConfigError('harmony.skills[].uris must be an array.');
+        }
+        result.uris = skill.uris.map((uri) => {
+            if (!uri || typeof uri !== 'object' || Array.isArray(uri)) {
+                throw new HarmonyConfigError('Harmony skill URI must be an object.');
+            }
+            const result = {};
+            for (const [key, value] of Object.entries(uri)) {
+                result[key] = typeof value === 'boolean' || (typeof value === 'number' && Number.isFinite(value))
+                    ? value
+                    : readString(value, `harmony.skills[].uris[].${key}`);
+            }
+            return result;
+        });
+    }
+    if (Object.keys(result).length === 0) {
+        throw new HarmonyConfigError('Harmony skill must contain entities, actions, or uris.');
+    }
+    return result;
+}
+function readExpoSchemes(config) {
+    const values = Array.isArray(config.scheme) ? config.scheme : config.scheme ? [config.scheme] : [];
+    return values.map(value => readString(value, 'scheme'));
+}
+function normalizeHarmonyConfig(config) {
+    const harmony = config.harmony;
+    if (!harmony || typeof harmony !== 'object' || Array.isArray(harmony)) {
+        throw new HarmonyConfigError('Expo config must contain a harmony object.');
+    }
+    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 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(ability)) {
+        throw new HarmonyConfigError('harmony.abilityName must be a valid Harmony identifier.');
+    }
+    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 (compatible > target) {
+        throw new HarmonyConfigError('Harmony compatibleSdkVersion cannot exceed targetApiVersion.');
+    }
+    const orientation = harmony.orientation || config.orientation || 'default';
+    if (!Orientations.has(orientation)) {
+        throw new HarmonyConfigError(`Unsupported Harmony orientation: ${orientation}`);
+    }
+    const background = normalizeColor(harmony.backgroundColor || config.backgroundColor, 'harmony.backgroundColor', '#FFFFFF');
+    const engine = harmony.jsEngine || 'hermes';
+    if (engine !== 'hermes') {
+        throw new HarmonyConfigError('Expo Harmony currently supports only the Hermes JavaScript engine.');
+    }
+    const abis = harmony.abiFilters === undefined
+        ? ['arm64-v8a', 'x86_64']
+        : normalizeStringArray(harmony.abiFilters, 'harmony.abiFilters');
+    for (const abi of abis) {
+        if (!/^[A-Za-z0-9_-]+$/.test(abi)) {
+            throw new HarmonyConfigError(`Invalid Harmony ABI filter: ${abi}`);
+        }
+    }
+    const permissions = (harmony.permissions || []).map(normalizePermission);
+    if (!permissions.some(permission => permission.name === 'ohos.permission.INTERNET')) {
+        permissions.unshift({ name: 'ohos.permission.INTERNET' });
+    }
+    const schemes = readExpoSchemes(config);
+    let skills = (harmony.skills || []).map(normalizeSkill);
+    for (const scheme of schemes) {
+        skills.push({
+            actions: ['ohos.want.action.viewData'],
+            entities: ['entity.system.browsable'],
+            uris: [{ scheme }],
+        });
+    }
+    skills = [...new Map(skills.map(skill => [JSON.stringify(skill), skill])).values()];
+    const queries = [...new Set([
+            'http',
+            'https',
+            'tel',
+            'sms',
+            ...schemes,
+            ...(harmony.querySchemes === undefined
+                ? []
+                : normalizeStringArray(harmony.querySchemes, 'harmony.querySchemes')),
+        ])];
+    const signing = harmony.signingConfigFile === undefined
+        ? undefined
+        : readString(harmony.signingConfigFile, 'harmony.signingConfigFile');
+    const devices = harmony.deviceTypes === undefined
+        ? ['phone', 'tablet']
+        : normalizeStringArray(harmony.deviceTypes, 'harmony.deviceTypes', DeviceTypes);
+    return Object.freeze({
+        abiFilters: abis,
+        abilityName: ability,
+        backgroundColor: background,
+        bundleName: bundle,
+        compatibleSdkVersionString: resolveSdkVersion(compatible, 'compatibleSdkVersion', harmony.compatibleSdkVersion),
+        deviceTypes: devices,
+        icon: harmony.icon || config.icon,
+        label: readString(harmony.label, 'harmony.label', config.name),
+        moduleName: module,
+        nativeOrientation: orientation === 'default' ? 'unspecified' : orientation,
+        permissions,
+        productName: readString(harmony.productName, 'harmony.productName', 'default'),
+        querySchemes: queries,
+        signingConfigFile: signing,
+        skills,
+        targetApiVersion: target,
+        targetSdkVersionString: resolveSdkVersion(target, 'targetSdkVersion', harmony.targetSdkVersion),
+        vendor: readString(harmony.vendor, 'harmony.vendor', 'expo-harmony'),
+        versionCode: code,
+        versionName: version,
+    });
+}

package/build/ownership.d.ts

@@ -0,0 +1,17 @@
+import type { ExpoConfigWithHarmony } from './config';
+export interface HarmonyConfigPluginOwnership {
+    readonly owner: string;
+    readonly files?: readonly string[];
+    readonly ability?: Readonly<Partial<{
+        startWindowBackground: string;
+        startWindowIcon: string;
+    }>>;
+    readonly resources?: Readonly<Partial<{
+        colors: Readonly<Partial<Record<'entry' | 'entryDark', readonly string[]>>>;
+        media: Readonly<Partial<Record<'app' | 'entry' | 'entryDark', readonly string[]>>>;
+        strings: Readonly<Partial<Record<'app' | 'entry', readonly string[]>>>;
+    }>>;
+}
+export declare function normalizeHarmonyConfigPlugins(value: unknown): 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

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeHarmonyConfigPlugins = normalizeHarmonyConfigPlugins;
+exports.registerHarmonyConfigPlugin = registerHarmonyConfigPlugin;
+exports.getHarmonyConfigPlugins = getHarmonyConfigPlugins;
+const ResourceScopes = {
+    colors: new Set(['entry', 'entryDark']),
+    media: new Set(['app', 'entry', 'entryDark']),
+    strings: new Set(['app', 'entry']),
+};
+const AbilityFields = new Set(['startWindowBackground', 'startWindowIcon']);
+const ResourceName = /^[A-Za-z0-9_.-]+$/u;
+function isRecord(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+function normalizeStringList(value, field) {
+    if (!Array.isArray(value)) {
+        throw new TypeError(`Invalid Harmony config-plugin ownership: ${field} must be an array.`);
+    }
+    const items = [];
+    for (const item of value) {
+        if (typeof item !== 'string' || !item || !ResourceName.test(item) || item.includes('..')) {
+            throw new TypeError(`Invalid Harmony config-plugin ownership: ${field} contains an invalid resource name.`);
+        }
+        if (!items.includes(item))
+            items.push(item);
+    }
+    return items.sort((left, right) => left.localeCompare(right, 'en'));
+}
+function normalizeResources(value) {
+    if (value === undefined)
+        return {};
+    if (!isRecord(value)) {
+        throw new TypeError('Invalid Harmony config-plugin ownership: resources must be an object.');
+    }
+    const resources = {};
+    for (const kind of Object.keys(value).sort()) {
+        if (!Object.hasOwn(ResourceScopes, kind)) {
+            throw new TypeError(`Invalid Harmony config-plugin ownership: resources.${kind} is not supported.`);
+        }
+        const scopes = value[kind];
+        if (!isRecord(scopes)) {
+            throw new TypeError(`Invalid Harmony config-plugin ownership: resources.${kind} must be an object.`);
+        }
+        const allowed = ResourceScopes[kind];
+        resources[kind] = {};
+        for (const scope of Object.keys(scopes).sort()) {
+            if (!allowed.has(scope)) {
+                throw new TypeError(`Invalid Harmony config-plugin ownership: resources.${kind}.${scope} is not a supported scope.`);
+            }
+            resources[kind][scope] = normalizeStringList(scopes[scope], `resources.${kind}.${scope}`);
+        }
+    }
+    return resources;
+}
+function normalizeAbility(value) {
+    if (value === undefined)
+        return {};
+    if (!isRecord(value)) {
+        throw new TypeError('Invalid Harmony config-plugin ownership: ability must be an object.');
+    }
+    const ability = {};
+    for (const field of Object.keys(value).sort()) {
+        if (!AbilityFields.has(field)) {
+            throw new TypeError(`Invalid Harmony config-plugin ownership: ability.${field} is not supported.`);
+        }
+        if (typeof value[field] !== 'string' || !value[field]) {
+            throw new TypeError(`Invalid Harmony config-plugin ownership: ability.${field} must be a non-empty string.`);
+        }
+        ability[field] = value[field];
+    }
+    return ability;
+}
+function normalizeHarmonyConfigPlugins(value) {
+    if (value === undefined)
+        return [];
+    if (!Array.isArray(value)) {
+        throw new TypeError('Invalid Harmony config-plugin ownership: the plugin list must be an array.');
+    }
+    const owners = new Set();
+    const plugins = value.map((plugin, index) => {
+        if (!isRecord(plugin)) {
+            throw new TypeError(`Invalid Harmony config-plugin ownership: plugin ${index} must be an object.`);
+        }
+        if (typeof plugin.owner !== 'string' || !plugin.owner.trim()) {
+            throw new TypeError(`Invalid Harmony config-plugin ownership: plugin ${index}.owner must be a non-empty string.`);
+        }
+        if (owners.has(plugin.owner)) {
+            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),
+        };
+    });
+    return plugins.sort((left, right) => left.owner.localeCompare(right.owner, 'en'));
+}
+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,
+    ]);
+    return config;
+}
+function getHarmonyConfigPlugins(config) {
+    return normalizeHarmonyConfigPlugins(config?._internal?.harmonyConfigPlugins);
+}

package/build/paths.d.ts

@@ -0,0 +1,64 @@
+export interface HarmonyManagedPaths {
+    readonly appJson: string;
+    readonly projectBuildProfile: string;
+    readonly rootOhPackage: string;
+    readonly rootHvigor: string;
+    readonly hvigorConfig: string;
+    readonly entryBuildProfile: string;
+    readonly entryOhPackage: string;
+    readonly entryHvigor: string;
+    readonly moduleJson: string;
+    readonly profiles: string;
+    readonly entryAbility: string;
+    readonly indexPage: string;
+    readonly worker: string;
+    readonly arktsPackageProvider: string;
+    readonly cppPackageProvider: string;
+    readonly cmakeLists: string;
+}
+export interface HarmonyProjectPaths {
+    readonly reactNativeConfig: string;
+}
+export interface HarmonyProjectPathCandidates {
+    readonly reactNativeConfig: readonly string[];
+}
+export interface HarmonyResourcePaths {
+    readonly strings: Readonly<{
+        app: string;
+        entry: string;
+    }>;
+    readonly colors: Readonly<{
+        entry: string;
+        entryDark: string;
+    }>;
+    readonly media: Readonly<{
+        app: string;
+        entry: string;
+        entryDark: string;
+    }>;
+}
+export interface HarmonyPathsApi {
+    readonly HARMONY_PATHS: HarmonyManagedPaths;
+    readonly PROJECT_PATH_CANDIDATES: HarmonyProjectPathCandidates;
+    readonly PROJECT_PATHS: HarmonyProjectPaths;
+    readonly RESOURCE_PATHS: HarmonyResourcePaths;
+    assertNoExternalSymlink(root: string, target: string): Promise<void>;
+    isInside(root: string, target: string): boolean;
+    resolveHarmonyPath(directory: string, relative: string): Promise<string>;
+    resolveProjectPath(root: string, name: keyof HarmonyProjectPaths): Promise<string>;
+    toPosixRelative(root: string, target: string): string;
+}
+declare const ManagedPaths: HarmonyManagedPaths & {
+    readonly nativeInputsStamp: string;
+};
+declare const ProjectPaths: HarmonyProjectPaths;
+declare const ProjectPathCandidates: HarmonyProjectPathCandidates;
+declare const ResourcePaths: HarmonyResourcePaths;
+export declare function isInside(root: string, target: string): boolean;
+export declare function assertNoExternalSymlink(root: string, target: string): Promise<void>;
+export declare function resolveHarmonyPath(directory: string, relative: string): Promise<string>;
+export declare function resolveProjectPath(root: string, name: keyof HarmonyProjectPaths): Promise<string>;
+export declare function toPosixRelative(root: string, target: string): string;
+declare const NativeInputsStampPath: string;
+export declare const HarmonyPaths: Readonly<HarmonyPathsApi>;
+export { ManagedPaths, NativeInputsStampPath, ProjectPathCandidates, ProjectPaths, ResourcePaths };

package/build/paths.js

@@ -0,0 +1,129 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResourcePaths = exports.ProjectPaths = exports.ProjectPathCandidates = exports.NativeInputsStampPath = exports.ManagedPaths = exports.HarmonyPaths = void 0;
+exports.isInside = isInside;
+exports.assertNoExternalSymlink = assertNoExternalSymlink;
+exports.resolveHarmonyPath = resolveHarmonyPath;
+exports.resolveProjectPath = resolveProjectPath;
+exports.toPosixRelative = toPosixRelative;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const errors_1 = require("./errors");
+const ManagedPaths = Object.freeze({
+    appJson: 'AppScope/app.json5',
+    projectBuildProfile: 'build-profile.json5',
+    rootOhPackage: 'oh-package.json5',
+    rootHvigor: 'hvigorfile.ts',
+    nativeInputsStamp: 'native-inputs-stamp.ts',
+    hvigorConfig: 'hvigor/hvigor-config.json5',
+    entryBuildProfile: 'entry/build-profile.json5',
+    entryOhPackage: 'entry/oh-package.json5',
+    entryHvigor: 'entry/hvigorfile.ts',
+    moduleJson: 'entry/src/main/module.json5',
+    profiles: 'entry/src/main/resources/base/profile/main_pages.json',
+    entryAbility: 'entry/src/main/ets/entryability/EntryAbility.ets',
+    indexPage: 'entry/src/main/ets/pages/Index.ets',
+    worker: 'entry/src/main/ets/workers/RNOHWorker.ets',
+    arktsPackageProvider: 'entry/src/main/ets/PackageProvider.ets',
+    cppPackageProvider: 'entry/src/main/cpp/PackageProvider.cpp',
+    cmakeLists: 'entry/src/main/cpp/CMakeLists.txt',
+});
+exports.ManagedPaths = ManagedPaths;
+const ProjectPaths = Object.freeze({
+    reactNativeConfig: 'react-native.config.js',
+});
+exports.ProjectPaths = ProjectPaths;
+const ProjectPathCandidates = Object.freeze({
+    // Match React Native CLI lookup precedence; new projects use the first path.
+    reactNativeConfig: Object.freeze([
+        'react-native.config.js',
+        'react-native.config.cjs',
+        'react-native.config.ts',
+        'react-native.config.mjs',
+    ]),
+});
+exports.ProjectPathCandidates = ProjectPathCandidates;
+const ResourcePaths = Object.freeze({
+    strings: Object.freeze({
+        app: 'AppScope/resources/base/element/string.json',
+        entry: 'entry/src/main/resources/base/element/string.json',
+    }),
+    colors: Object.freeze({
+        entry: 'entry/src/main/resources/base/element/color.json',
+        entryDark: 'entry/src/main/resources/dark/element/color.json',
+    }),
+    media: Object.freeze({
+        app: 'AppScope/resources/base/media',
+        entry: 'entry/src/main/resources/base/media',
+        entryDark: 'entry/src/main/resources/dark/media',
+    }),
+});
+exports.ResourcePaths = ResourcePaths;
+function isInside(root, target) {
+    const relative = node_path_1.default.relative(root, target);
+    return relative === ''
+        || (!relative.startsWith(`..${node_path_1.default.sep}`) && relative !== '..' && !node_path_1.default.isAbsolute(relative));
+}
+async function assertNoExternalSymlink(root, target) {
+    const absolute = node_path_1.default.resolve(root);
+    const canonical = await node_fs_1.default.promises.realpath(absolute).catch(() => absolute);
+    const relative = node_path_1.default.relative(absolute, target);
+    let current = absolute;
+    for (const segment of relative.split(node_path_1.default.sep).filter(Boolean)) {
+        current = node_path_1.default.join(current, segment);
+        let stat;
+        try {
+            stat = await node_fs_1.default.promises.lstat(current);
+        }
+        catch (cause) {
+            if (cause.code === 'ENOENT')
+                break;
+            throw new errors_1.HarmonyConfigPluginError('ERR_HARMONY_PATH_INVALID', `Cannot inspect managed Harmony path ${current}: ${cause.message}`, { cause, file: current, operation: 'resolve-path' });
+        }
+        if (stat.isSymbolicLink()) {
+            const real = await node_fs_1.default.promises.realpath(current);
+            if (!isInside(canonical, real)) {
+                throw new errors_1.HarmonyConfigPluginError('ERR_HARMONY_PATH_ESCAPE', `Refusing to follow a symlink outside the Harmony project: ${current}`, { file: current, operation: 'resolve-path' });
+            }
+        }
+    }
+}
+async function resolveHarmonyPath(directory, relative) {
+    if (typeof relative !== 'string' || !relative || node_path_1.default.isAbsolute(relative)) {
+        throw new errors_1.HarmonyConfigPluginError('ERR_HARMONY_PATH_ESCAPE', `Invalid managed path: ${relative}`, { operation: 'resolve-path' });
+    }
+    const root = node_path_1.default.resolve(directory);
+    const target = node_path_1.default.resolve(root, relative);
+    if (!isInside(root, target)) {
+        throw new errors_1.HarmonyConfigPluginError('ERR_HARMONY_PATH_ESCAPE', `Managed path escapes the Harmony project: ${relative}`, { file: target, operation: 'resolve-path' });
+    }
+    await assertNoExternalSymlink(root, target);
+    return target;
+}
+async function resolveProjectPath(root, name) {
+    const candidates = ProjectPathCandidates[name] || [ProjectPaths[name]];
+    for (const candidate of candidates) {
+        if (node_fs_1.default.existsSync(node_path_1.default.join(root, candidate)))
+            return resolveHarmonyPath(root, candidate);
+    }
+    return resolveHarmonyPath(root, candidates[0]);
+}
+function toPosixRelative(root, target) {
+    return node_path_1.default.relative(root, target).split(node_path_1.default.sep).join('/');
+}
+const { nativeInputsStamp: NativeInputsStampPath, ...PublicManagedPaths } = ManagedPaths;
+exports.NativeInputsStampPath = NativeInputsStampPath;
+exports.HarmonyPaths = Object.freeze({
+    HARMONY_PATHS: Object.freeze(PublicManagedPaths),
+    PROJECT_PATH_CANDIDATES: ProjectPathCandidates,
+    PROJECT_PATHS: ProjectPaths,
+    RESOURCE_PATHS: ResourcePaths,
+    assertNoExternalSymlink,
+    isInside,
+    resolveHarmonyPath,
+    resolveProjectPath,
+    toPosixRelative,
+});

package/build/permissions.d.ts

@@ -0,0 +1,12 @@
+import type { HarmonyPermission } from './config';
+import { type HarmonyModuleJson } from './manifest';
+import type { HarmonyConfigPlugin } from './pluginTypes';
+export declare function mergePermissions(current: readonly HarmonyPermission[], additions: readonly HarmonyPermission[]): HarmonyPermission[];
+export declare function ensurePermissions(manifest: HarmonyModuleJson, permissions: readonly HarmonyPermission[]): HarmonyModuleJson;
+export declare function removePermissions(manifest: HarmonyModuleJson, names: readonly string[]): HarmonyModuleJson;
+export declare const withHarmonyPermissions: HarmonyConfigPlugin<readonly HarmonyPermission[]>;
+export declare const HarmonyPermissions: Readonly<{
+    ensurePermissions: typeof ensurePermissions;
+    mergePermissions: typeof mergePermissions;
+    removePermissions: typeof removePermissions;
+}>;