@expo-harmony/expo-modules-autolinking 55.0.25-harmony.4 → 55.0.27-harmony.2

package/build/index.d.ts

@@ -1,10 +1,11 @@
-import { linkModulesAsync } from './src/autolinking/link';
+import { linkModulesAsync, linkPreparedModulesAsync } from './src/autolinking/link';
+import { prepareModulesAsync } from './src/autolinking/prepare';
 import { canonicalizeAutolinkingArtifacts } from './src/harmony/persistence/canonicalize';
 import { resolveModulesAsync } from './src/autolinking/resolve';
 import { searchModulesAsync } from './src/autolinking/search';
 import { verifyModulesAsync } from './src/autolinking/verify';
 import { normalizeHarmonyModuleMetadata } from './src/metadata/schema';
-export { canonicalizeAutolinkingArtifacts, linkModulesAsync, normalizeHarmonyModuleMetadata, resolveModulesAsync, searchModulesAsync, verifyModulesAsync, };
+export { canonicalizeAutolinkingArtifacts, linkModulesAsync, linkPreparedModulesAsync, prepareModulesAsync, normalizeHarmonyModuleMetadata, resolveModulesAsync, searchModulesAsync, verifyModulesAsync, };
 export type { BuildType, CanonicalizeAutolinkingArtifactsOptions, CanonicalizedAutolinkingArtifacts, Diagnostic, DiagnosticSource, ExpoMetadata, HostMetadata, HarmonyModuleMetadata, LinkOptions, LinkResult, Logger, Manifest, ModuleDescriptor, ModuleArtifactDescriptor, ModuleSource, Platform, ResolveOptions, RnohMetadata, SearchOptions, SearchRecord, SearchResult, VerificationResult, VerifyOptions, } from './src/types';
 export { createNativeModuleContracts } from './src/harmony/manifest/runtime';
 export { ohpmDependenciesFromManifest } from './src/harmony/manifest';

package/build/index.js

@@ -1,8 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ohpmDependenciesFromManifest = exports.createNativeModuleContracts = exports.verifyModulesAsync = exports.searchModulesAsync = exports.resolveModulesAsync = exports.normalizeHarmonyModuleMetadata = exports.linkModulesAsync = exports.canonicalizeAutolinkingArtifacts = void 0;
+exports.ohpmDependenciesFromManifest = exports.createNativeModuleContracts = exports.verifyModulesAsync = exports.searchModulesAsync = exports.resolveModulesAsync = exports.normalizeHarmonyModuleMetadata = exports.prepareModulesAsync = exports.linkPreparedModulesAsync = exports.linkModulesAsync = exports.canonicalizeAutolinkingArtifacts = void 0;
 const link_1 = require("./src/autolinking/link");
 Object.defineProperty(exports, "linkModulesAsync", { enumerable: true, get: function () { return link_1.linkModulesAsync; } });
+Object.defineProperty(exports, "linkPreparedModulesAsync", { enumerable: true, get: function () { return link_1.linkPreparedModulesAsync; } });
+const prepare_1 = require("./src/autolinking/prepare");
+Object.defineProperty(exports, "prepareModulesAsync", { enumerable: true, get: function () { return prepare_1.prepareModulesAsync; } });
 const canonicalize_1 = require("./src/harmony/persistence/canonicalize");
 Object.defineProperty(exports, "canonicalizeAutolinkingArtifacts", { enumerable: true, get: function () { return canonicalize_1.canonicalizeAutolinkingArtifacts; } });
 const resolve_1 = require("./src/autolinking/resolve");

package/build/runtime.d.ts

@@ -7,7 +7,7 @@ export interface HarmonyNativeModule {
     artifacts: string[];
 }
 export interface HarmonyRuntimeContract {
-    schemaVersion: 1;
+    schemaVersion: 1 | 2;
     platform: 'harmony';
     runtimeVersion: string;
     development: boolean;
@@ -22,8 +22,9 @@ export interface HarmonyRuntimeContract {
     modules: HarmonyNativeModule[];
     config: {
         nativeCompiler: string;
-        targetApiVersion: number;
-        compatibleApiVersion: number;
+        targetApiVersion: number | string;
+        compatibleApiVersion: number | string;
+        nativeLibFilterHash?: string;
         permissions: string[];
         querySchemes: string[];
         backgroundModes: string[];
@@ -40,6 +41,7 @@ export declare class HarmonyCompatibilityError extends Error {
     readonly code = "ERR_HARMONY_INCOMPATIBLE";
     constructor(issues: HarmonyCompatibilityIssue[]);
 }
+export declare function harmonyRuntimeSchemaVersion(config: HarmonyRuntimeContract['config']): 1 | 2;
 export declare function validateHarmonyRuntime(value: unknown): HarmonyCompatibilityIssue[];
 export declare function checkHarmonyCompatibility(client: unknown, requirements: unknown): HarmonyCompatibilityIssue[];
 export declare function assertHarmonyCompatibility(client: unknown, requirements: unknown): asserts requirements is HarmonyRuntimeContract;

package/build/runtime.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HarmonyCompatibilityError = void 0;
+exports.harmonyRuntimeSchemaVersion = harmonyRuntimeSchemaVersion;
 exports.validateHarmonyRuntime = validateHarmonyRuntime;
 exports.checkHarmonyCompatibility = checkHarmonyCompatibility;
 exports.assertHarmonyCompatibility = assertHarmonyCompatibility;
@@ -27,11 +28,37 @@ function strings(value) {
 }
 const Versions = ['runtimeVersion', 'expo', 'expoModulesCore', 'rnoh', 'react', 'hermes'];
 const Settings = ['permissions', 'querySchemes', 'backgroundModes', 'abiFilters'];
+function apiVersion(value, schema) {
+    if (typeof value === 'number' && Number.isSafeInteger(value) && value >= 13 && value < 26)
+        return [value, 0, 0];
+    if (schema === 2 && typeof value === 'string' && /^(?:[1-9]\d{1,2})\.(?:0|[1-9]\d{0,2})\.(?:0|[1-9]\d{0,2})$/.test(value)) {
+        const parts = value.split('.').map(Number);
+        if (parts[0] >= 26)
+            return parts;
+    }
+    return undefined;
+}
+function compareApiVersions(left, right) {
+    for (let index = 0; index < 3; index++) {
+        if (left[index] !== right[index])
+            return left[index] - right[index];
+    }
+    return 0;
+}
+function harmonyRuntimeSchemaVersion(config) {
+    return typeof config.targetApiVersion === 'string' || typeof config.compatibleApiVersion === 'string'
+        || config.nativeLibFilterHash !== undefined
+        ? 2
+        : 1;
+}
 function validateHarmonyRuntime(value) {
     if (!record(value))
         return [{ code: 'INVALID_CONTRACT', field: '', message: 'Runtime contract must be an object.' }];
     const issues = [];
-    for (const [field, expected] of Object.entries({ schemaVersion: 1, platform: 'harmony', engine: 'hermes-v1', bundleFormat: 'js-source', renderer: 'rnoh' })) {
+    if (value.schemaVersion !== 1 && value.schemaVersion !== 2) {
+        issues.push({ code: 'INVALID_CONTRACT', field: 'schemaVersion', message: 'schemaVersion must be 1 or 2.' });
+    }
+    for (const [field, expected] of Object.entries({ platform: 'harmony', engine: 'hermes-v1', bundleFormat: 'js-source', renderer: 'rnoh' })) {
         if (value[field] !== expected) {
             issues.push({ code: field === 'platform' ? 'PLATFORM_MISMATCH' : 'INVALID_CONTRACT', field, message: `${field} must be ${expected}.` });
         }
@@ -62,10 +89,12 @@ function validateHarmonyRuntime(value) {
         }
     }
     const config = value.config;
+    const target = record(config) ? apiVersion(config.targetApiVersion, value.schemaVersion) : undefined;
+    const compatible = record(config) ? apiVersion(config.compatibleApiVersion, value.schemaVersion) : undefined;
     if (!record(config) || !token(config.nativeCompiler) || !Settings.every(field => strings(config[field]))
-        || !Number.isInteger(config.targetApiVersion) || Number(config.targetApiVersion) < 13
-        || !Number.isInteger(config.compatibleApiVersion) || Number(config.compatibleApiVersion) < 13
-        || Number(config.compatibleApiVersion) > Number(config.targetApiVersion)
+        || !target || !compatible || compareApiVersions(compatible, target) > 0
+        || (config.nativeLibFilterHash !== undefined && (value.schemaVersion !== 2
+            || typeof config.nativeLibFilterHash !== 'string' || !/^[a-f0-9]{64}$/.test(config.nativeLibFilterHash)))
         || (Array.isArray(config.abiFilters) && config.abiFilters.length === 0)) {
         issues.push({ code: 'INVALID_CONTRACT', field: 'config', message: 'Invalid native build configuration.' });
     }
@@ -103,7 +132,7 @@ function checkHarmonyCompatibility(client, requirements) {
             issues.push({ code: 'NATIVE_MODULE_MISMATCH', field: module.packageName, message: `Native contract differs for ${module.packageName}. Rebuild or select a matching client.` });
         }
     }
-    for (const field of ['nativeCompiler', 'targetApiVersion', 'compatibleApiVersion']) {
+    for (const field of ['nativeCompiler', 'targetApiVersion', 'compatibleApiVersion', 'nativeLibFilterHash']) {
         if (available.config[field] !== required.config[field]) {
             issues.push({ code: 'CONFIG_MISMATCH', field, message: `${field}: project requires ${required.config[field]}, client provides ${available.config[field]}.` });
         }

package/build/src/autolinking/link.d.ts

@@ -1,3 +1,5 @@
 import type { LinkOptions, LinkResult } from '../types';
-declare function linkModulesAsync(rawOptions: LinkOptions): Promise<LinkResult>;
-export { linkModulesAsync };
+import { prepareModulesAsync } from './prepare';
+declare function linkPreparedModulesAsync(raw: LinkOptions, prepared: Awaited<ReturnType<typeof prepareModulesAsync>>): Promise<LinkResult>;
+declare function linkModulesAsync(raw: LinkOptions): Promise<LinkResult>;
+export { linkModulesAsync, linkPreparedModulesAsync };

package/build/src/autolinking/link.js

@@ -4,20 +4,19 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.linkModulesAsync = linkModulesAsync;
+exports.linkPreparedModulesAsync = linkPreparedModulesAsync;
 const node_path_1 = __importDefault(require("node:path"));
 const constants_1 = require("../config/constants");
 const host_1 = require("../harmony/providers/host");
 const generate_1 = require("../harmony/manifest/generate");
 const runtime_1 = require("../harmony/manifest/runtime");
 const errors_1 = require("../errors");
-const options_1 = require("../config/options");
 const link_1 = require("../harmony/rnoh/link");
 const stageProject_1 = require("../harmony/transaction/stageProject");
 const publish_1 = require("../harmony/transaction/publish");
 const previousState_1 = require("../harmony/transaction/previousState");
-const verify_1 = require("./verify");
 const values_1 = require("../utilities/values");
-const materialize_1 = require("../harmony/materialize");
+const prepare_1 = require("./prepare");
 function buildPublishEntries(staging, hostProviderSource, manifest) {
     return [
         ...Object.entries(constants_1.RnohArtifacts).map(([name, relative]) => ({
@@ -34,30 +33,9 @@ function buildPublishEntries(staging, hostProviderSource, manifest) {
         },
     ];
 }
-async function linkModulesAsync(rawOptions) {
-    const options = await (0, options_1.normalizeOptionsAsync)(rawOptions);
-    if (typeof rawOptions.harmonyProjectPath !== 'string' || !rawOptions.harmonyProjectPath) {
-        throw new errors_1.HarmonyAutolinkingError('INVALID_OPTIONS', 'link requires harmonyProjectPath.', { stage: 'link' });
-    }
-    const verify = await (0, verify_1.verifyModulesAsync)((rawOptions.modules !== undefined
-        ? { modules: rawOptions.modules }
-        : { ...options, searchResult: rawOptions.searchResult }));
-    (0, verify_1.assertVerificationSucceeded)(verify, 'link');
-    const modules = verify.modules;
-    const pendingSource = modules.filter(module => module.artifact.kind === 'local-source');
-    if (pendingSource.length > 0) {
-        if (pendingSource.some(module => module.source !== 'nativeModulesDir')) {
-            throw new errors_1.HarmonyAutolinkingError('SOURCE_ARTIFACT_MATERIALIZATION_REQUIRED', 'Only nativeModulesDir modules may build a local Harmony HAR.', { stage: 'link', details: pendingSource.map(module => module.packageName).sort() });
-        }
-        await (0, materialize_1.materializeLocalSourcesAsync)(pendingSource, {
-            dependencies: modules,
-            projectRoot: options.projectRoot,
-            timeoutMs: rawOptions.timeoutMs,
-            outputLimit: rawOptions.outputLimit,
-            env: rawOptions.env,
-        });
-    }
-    const hostProviderSource = (0, host_1.renderArkTsHostProviderSource)(modules);
+async function linkPreparedModulesAsync(raw, prepared) {
+    const { options, modules, diagnostics } = prepared;
+    const provider = (0, host_1.renderArkTsHostProviderSource)(modules);
     let staging;
     let failure;
     let cleanupWarning;
@@ -66,16 +44,16 @@ async function linkModulesAsync(rawOptions) {
         const previous = await (0, previousState_1.readPreviousAutolinkingStateAsync)(options.projectRoot);
         if (previous.warning) {
             warnings.push(previous.warning);
-            (0, values_1.emitLog)(rawOptions.logger, 'warn', previous.warning.message, previous.warning);
+            (0, values_1.emitLog)(raw.logger, 'warn', previous.warning.message, previous.warning);
         }
         staging = await (0, stageProject_1.stageProjectAsync)({
             projectRoot: options.projectRoot,
-            harmonyProjectPath: rawOptions.harmonyProjectPath,
-            nodeModulesPath: rawOptions.nodeModulesPath,
+            harmonyProjectPath: raw.harmonyProjectPath,
+            nodeModulesPath: raw.nodeModulesPath,
             modules,
             buildType: options.buildType,
             previousManagedOhpmPackageNames: previous.managedOhpmPackageNames,
-            rnohCliPackageJsonPath: rawOptions.rnohCliPackageJsonPath,
+            rnohCliPackageJsonPath: raw.rnohCliPackageJsonPath,
         });
         staging.rnohArtifacts = await (0, link_1.linkRnohAsync)({
             ...staging,
@@ -83,11 +61,11 @@ async function linkModulesAsync(rawOptions) {
             buildType: options.buildType,
             exclude: staging.rnohRuntimePackages,
             commandNodeModulesPath: staging.sourceNodeModulesPath,
-            reactNativeExecutable: rawOptions.reactNativeExecutable,
-            rnohCliPackageJsonPath: rawOptions.rnohCliPackageJsonPath,
-            timeoutMs: rawOptions.timeoutMs,
-            outputLimit: rawOptions.outputLimit,
-            env: rawOptions.env,
+            reactNativeExecutable: raw.reactNativeExecutable,
+            rnohCliPackageJsonPath: raw.rnohCliPackageJsonPath,
+            timeoutMs: raw.timeoutMs,
+            outputLimit: raw.outputLimit,
+            env: raw.env,
         });
         const harmonyRoot = node_path_1.default.relative(staging.projectRoot, staging.harmonyProjectPath)
             .split(node_path_1.default.sep).join('/');
@@ -100,7 +78,19 @@ async function linkModulesAsync(rawOptions) {
         const published = await (0, publish_1.publishArtifactsAsync)({
             allowedRoot: staging.projectRoot,
             lockPath: node_path_1.default.join(staging.projectRoot, '.expo/harmony/autolinking.lock'),
-            files: buildPublishEntries(staging, hostProviderSource, manifest),
+            files: [
+                ...buildPublishEntries(staging, provider, manifest),
+                ...(raw.moduleBuilds !== undefined
+                    ? [{
+                            target: node_path_1.default.join(staging.projectRoot, '.expo/harmony/module-build-options.json'),
+                            content: JSON.stringify({
+                                schemaVersion: 1,
+                                moduleBuilds: raw.moduleBuilds,
+                                moduleBuildSettings: raw.moduleBuildSettings,
+                            }, null, 2) + '\n',
+                        }]
+                    : []),
+            ],
             stale: previous.artifacts.filter(artifact => !managed.some((relative) => {
                 return artifact === node_path_1.default.join(staging.projectRoot, ...relative.split('/'));
             })),
@@ -112,10 +102,10 @@ async function linkModulesAsync(rawOptions) {
             managedArtifacts: [...managed],
             changedArtifacts: published.changed.map(target => node_path_1.default.relative(staging.projectRoot, target).split(node_path_1.default.sep).join('/')),
             unchangedArtifacts: published.unchanged.map(target => node_path_1.default.relative(staging.projectRoot, target).split(node_path_1.default.sep).join('/')),
-            diagnostics: verify.diagnostics,
+            diagnostics,
             warnings,
         };
-        (0, values_1.emitLog)(rawOptions.logger, 'info', 'Harmony autolinking completed.', {
+        (0, values_1.emitLog)(raw.logger, 'info', 'Harmony autolinking completed.', {
             moduleCount: result.modules.length,
             changedArtifactCount: result.changedArtifacts.length,
         });
@@ -123,7 +113,7 @@ async function linkModulesAsync(rawOptions) {
     }
     catch (error) {
         failure = error;
-        (0, values_1.emitLog)(rawOptions.logger, 'error', 'Harmony autolinking failed.', {
+        (0, values_1.emitLog)(raw.logger, 'error', 'Harmony autolinking failed.', {
             code: error.code || 'ERR_EXPO_HARMONY_UNKNOWN',
             stage: error.stage || 'link',
         });
@@ -135,7 +125,7 @@ async function linkModulesAsync(rawOptions) {
                 const warning = { ...cleanup };
                 delete warning.cause;
                 warnings.push(warning);
-                (0, values_1.emitLog)(rawOptions.logger, 'warn', warning.message, warning);
+                (0, values_1.emitLog)(raw.logger, 'warn', warning.message, warning);
                 if (failure)
                     cleanupWarning = warning;
             }
@@ -151,3 +141,6 @@ async function linkModulesAsync(rawOptions) {
             : failure.details,
     });
 }
+async function linkModulesAsync(raw) {
+    return linkPreparedModulesAsync(raw, await (0, prepare_1.prepareModulesAsync)(raw));
+}

package/build/src/autolinking/prepare.d.ts

@@ -0,0 +1,15 @@
+import type { LinkOptions } from '../types';
+export declare function prepareModulesAsync(raw: LinkOptions): Promise<{
+    options: {
+        projectRoot: string;
+        platform: string;
+        searchPaths: string[];
+        nativeModulesDir: string;
+        exclude: string[];
+        include: string[];
+        moduleOverrides: Readonly<{}>;
+        buildType: any;
+    };
+    diagnostics: readonly import("../types").Diagnostic[];
+    modules: readonly import("../types").ModuleDescriptor[];
+}>;

package/build/src/autolinking/prepare.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prepareModulesAsync = prepareModulesAsync;
+const errors_1 = require("../errors");
+const options_1 = require("../config/options");
+const materialize_1 = require("../harmony/materialize");
+const configuredBuild_1 = require("../harmony/configuredBuild");
+const verify_1 = require("./verify");
+async function prepareModulesAsync(raw) {
+    const options = await (0, options_1.normalizeOptionsAsync)(raw);
+    if (typeof raw.harmonyProjectPath !== 'string' || !raw.harmonyProjectPath) {
+        throw new errors_1.HarmonyAutolinkingError('INVALID_OPTIONS', 'link requires harmonyProjectPath.', { stage: 'link' });
+    }
+    const verify = await (0, verify_1.verifyModulesAsync)((raw.modules !== undefined
+        ? { modules: raw.modules }
+        : { ...options, searchResult: raw.searchResult }));
+    (0, verify_1.assertVerificationSucceeded)(verify, 'link');
+    const modules = verify.modules;
+    const pending = modules.filter(module => module.artifact.kind === 'local-source');
+    if (pending.length > 0) {
+        if (pending.some(module => module.source !== 'nativeModulesDir')) {
+            throw new errors_1.HarmonyAutolinkingError('SOURCE_ARTIFACT_MATERIALIZATION_REQUIRED', 'Only nativeModulesDir modules may build a local Harmony HAR.', { stage: 'link', details: pending.map(module => module.packageName).sort() });
+        }
+        await (0, materialize_1.materializeLocalSourcesAsync)(pending, {
+            dependencies: modules,
+            projectRoot: options.projectRoot,
+            timeoutMs: raw.timeoutMs,
+            outputLimit: raw.outputLimit,
+            env: raw.env,
+        });
+    }
+    return {
+        options,
+        diagnostics: verify.diagnostics,
+        modules: await (0, configuredBuild_1.buildConfiguredModulesAsync)(modules, {
+            ...raw, projectRoot: options.projectRoot, buildType: options.buildType,
+        }),
+    };
+}

package/build/src/autolinking/verify.js

@@ -224,6 +224,7 @@ function searchRecordFromDescriptor(descriptor, declared) {
             ? {
                 platforms: ['harmony'],
                 harmony: {
+                    ...(descriptor.harmony.buildOptionsFile ? { buildOptionsFile: descriptor.harmony.buildOptionsFile } : {}),
                     modules,
                     services,
                     ...Object.fromEntries(host_1.HostMetadataFields.map(field => [

package/build/src/commands/link.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.registerLinkCommand = registerLinkCommand;
 const link_1 = require("../autolinking/link");
+const prepare_1 = require("../autolinking/prepare");
 const autolinkingOptions_1 = require("./autolinkingOptions");
 const output_1 = require("./output");
 function registerLinkCommand(program, io) {
@@ -14,7 +15,7 @@ function registerLinkCommand(program, io) {
         .option('--output-limit <bytes>', 'per-stream output capture limit', autolinkingOptions_1.parsePositiveInt)
         .option('-j, --json', 'output results in the plain JSON format', false)
         .action(async (searchPaths, options) => {
-        (0, output_1.writeResult)(io, await (0, link_1.linkModulesAsync)({
+        const input = {
             ...(0, autolinkingOptions_1.toApiOptions)(options, searchPaths),
             harmonyProjectPath: options.harmonyProjectPath,
             nodeModulesPath: options.nodeModulesPath,
@@ -22,6 +23,8 @@ function registerLinkCommand(program, io) {
             rnohCliPackageJsonPath: options.rnohCliPackageJson,
             timeoutMs: options.timeoutMs,
             outputLimit: options.outputLimit,
-        }), options);
+        };
+        const prepared = await (0, prepare_1.prepareModulesAsync)(input);
+        (0, output_1.writeResult)(io, await (0, link_1.linkPreparedModulesAsync)(input, prepared), options);
     });
 }

package/build/src/harmony/configuredBuild.d.ts

@@ -0,0 +1,2 @@
+import type { LinkOptions, ModuleDescriptor } from '../types';
+export declare function buildConfiguredModulesAsync(modules: ReadonlyArray<ModuleDescriptor>, raw: LinkOptions): Promise<ReadonlyArray<ModuleDescriptor>>;