@expo-harmony/expo-modules-autolinking 55.0.25-harmony.1

package/build/src/config/options.d.ts

@@ -0,0 +1,13 @@
+declare function assertSafeRnohPackageList(values: any, field: any, stage?: string): void;
+declare function normalizeModuleOverrides(value: any, options?: Record<string, any>): Readonly<{}>;
+declare function normalizeOptionsAsync(rawOptions?: Record<string, any>): Promise<{
+    projectRoot: string;
+    platform: string;
+    searchPaths: string[];
+    nativeModulesDir: string;
+    exclude: string[];
+    include: string[];
+    moduleOverrides: Readonly<{}>;
+    buildType: any;
+}>;
+export { assertSafeRnohPackageList, normalizeOptionsAsync, normalizeModuleOverrides, };

package/build/src/config/options.js

@@ -0,0 +1,202 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertSafeRnohPackageList = assertSafeRnohPackageList;
+exports.normalizeOptionsAsync = normalizeOptionsAsync;
+exports.normalizeModuleOverrides = normalizeModuleOverrides;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const constants_1 = require("./constants");
+const errors_1 = require("../errors");
+const values_1 = require("../utilities/values");
+const ListFields = ['searchPaths', 'exclude', 'include'];
+const NpmPackageNamePattern = /^(?:@[a-z0-9][a-z0-9._-]*\/)?[a-z0-9][a-z0-9._-]*$/u;
+const RnohPackageListDelimiterPattern = /[;\0\r\n]/;
+function selectConfiguredValue(rawOptions, platform, sharedConfig, field, fallback) {
+    if (rawOptions[field] !== undefined)
+        return rawOptions[field];
+    if (platform[field] !== undefined)
+        return platform[field];
+    if (sharedConfig[field] !== undefined)
+        return sharedConfig[field];
+    return fallback;
+}
+function configuredList(platform, sharedConfig, field) {
+    const normalize = (value) => {
+        if (value === undefined)
+            return [];
+        const values = field === 'searchPaths' && typeof value === 'string'
+            ? [value]
+            : Array.isArray(value) ? value : [];
+        return values.filter(item => typeof item === 'string' && item.trim());
+    };
+    if (field === 'include') {
+        return [
+            ...normalize(sharedConfig.include),
+            ...normalize(platform.include),
+        ];
+    }
+    return normalize(platform[field] !== undefined ? platform[field] : sharedConfig[field]);
+}
+function validateConfigObject(value, field) {
+    if (value === undefined)
+        return {};
+    if (!(0, values_1.isObject)(value)) {
+        throw new errors_1.HarmonyAutolinkingError('INVALID_OPTIONS', `${field} must be an object.`, { stage: 'options' });
+    }
+    return value;
+}
+function normalizeBuildType(value) {
+    const buildType = value === undefined ? 'debug' : value;
+    if (buildType !== 'debug' && buildType !== 'release') {
+        throw new errors_1.HarmonyAutolinkingError('INVALID_OPTIONS', 'buildType must be either "debug" or "release".', { stage: 'options' });
+    }
+    return buildType;
+}
+function assertSafeRnohPackageList(values, field, stage = 'options') {
+    if (!Array.isArray(values)
+        || values.some(value => typeof value !== 'string'
+            || !value.trim()
+            || RnohPackageListDelimiterPattern.test(value))) {
+        throw new errors_1.HarmonyAutolinkingError('INVALID_OPTIONS', `${field} entries must not contain semicolons or NUL/CR/LF control characters.`, { stage });
+    }
+}
+function normalizeNativeModulesDirectory(value, projectRoot) {
+    if (value === null)
+        return null;
+    if (typeof value !== 'string' || !value.trim()) {
+        throw new errors_1.HarmonyAutolinkingError('INVALID_OPTIONS', 'nativeModulesDir must be a non-empty string or null.', { stage: 'options' });
+    }
+    return path.resolve(projectRoot, value);
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function normalizeModuleOverrides(value, options = {}) {
+    const code = options.code || 'INVALID_OPTIONS';
+    const field = options.field || 'package.json#expo.autolinking.harmony.modules';
+    const stage = options.stage || 'options';
+    if (value === undefined)
+        return Object.freeze({});
+    if (!(0, values_1.isObject)(value)) {
+        throw new errors_1.HarmonyAutolinkingError(code, `${field} must be an object.`, { stage });
+    }
+    const overrides = {};
+    for (const packageName of Object.keys(value).sort()) {
+        const metadata = value[packageName];
+        if (!NpmPackageNamePattern.test(packageName) || !(0, values_1.isObject)(metadata)) {
+            throw new errors_1.HarmonyAutolinkingError(code, `Invalid Harmony sidecar module registration for ${packageName} in ${field}.`, { stage });
+        }
+        if (metadata.version !== undefined
+            && (typeof metadata.version !== 'string'
+                || !metadata.version
+                || /^[*~^]|^(?:file|link|workspace):/u.test(metadata.version))) {
+            throw new errors_1.HarmonyAutolinkingError(code, `Harmony sidecar module ${packageName} in ${field} must use an exact version.`, { stage });
+        }
+        overrides[packageName] = Object.freeze({ ...metadata });
+    }
+    return Object.freeze(overrides);
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+async function normalizeOptionsAsync(rawOptions = {}) {
+    if (!(0, values_1.isObject)(rawOptions)) {
+        throw new errors_1.HarmonyAutolinkingError('INVALID_OPTIONS', 'Options must be an object.', { stage: 'options' });
+    }
+    if (rawOptions.logger !== undefined) {
+        if (!(0, values_1.isObject)(rawOptions.logger)
+            || ['debug', 'info', 'warn', 'error'].some((level) => {
+                return rawOptions.logger[level] !== undefined && typeof rawOptions.logger[level] !== 'function';
+            })) {
+            throw new errors_1.HarmonyAutolinkingError('INVALID_OPTIONS', 'logger must expose only callable debug/info/warn/error methods.', { stage: 'options' });
+        }
+    }
+    if (rawOptions.platform != null && rawOptions.platform !== constants_1.Platform) {
+        throw new errors_1.HarmonyAutolinkingError('INVALID_OPTIONS', 'Only platform "harmony" is supported.', { stage: 'options' });
+    }
+    const rawRoot = rawOptions.projectRoot === undefined ? process.cwd() : rawOptions.projectRoot;
+    if (typeof rawRoot !== 'string' || !rawRoot) {
+        throw new errors_1.HarmonyAutolinkingError('INVALID_OPTIONS', 'projectRoot must be a non-empty string.', { stage: 'options' });
+    }
+    let projectRoot = await (0, values_1.realpathExistingAsync)(rawRoot, {
+        type: 'directory',
+        field: 'projectRoot',
+        stage: 'options',
+    });
+    let pkgPath = path.join(projectRoot, 'package.json');
+    while (!fs.existsSync(pkgPath) && path.dirname(projectRoot) !== projectRoot) {
+        projectRoot = path.dirname(projectRoot);
+        pkgPath = path.join(projectRoot, 'package.json');
+    }
+    if (!fs.existsSync(pkgPath)) {
+        throw new errors_1.HarmonyAutolinkingError('INVALID_OPTIONS', `No package.json exists at projectRoot: ${projectRoot}`, { stage: 'options' });
+    }
+    const packageJson = await (0, values_1.readJsonAsync)(pkgPath, 'INVALID_OPTIONS', 'options');
+    const expo = packageJson.expo === undefined ? {} : validateConfigObject(packageJson.expo, 'package.json#expo');
+    const shared = expo.autolinking === undefined ? {} : validateConfigObject(expo.autolinking, 'package.json#expo.autolinking');
+    const platform = shared.harmony === undefined ? {} : validateConfigObject(shared.harmony, 'package.json#expo.autolinking.harmony');
+    const configured = Object.fromEntries(ListFields.map(field => [field, configuredList(platform, shared, field)]));
+    const lists = {
+        searchPaths: rawOptions.searchPaths === undefined
+            ? configured.searchPaths
+            : [...(0, values_1.normalizeStringArray)(rawOptions.searchPaths, 'searchPaths'), ...configured.searchPaths],
+        exclude: rawOptions.exclude === undefined
+            ? configured.exclude
+            : [...configured.exclude, ...(0, values_1.normalizeStringArray)(rawOptions.exclude, 'exclude')],
+        include: rawOptions.include === undefined
+            ? configured.include
+            : [...configured.include, ...(0, values_1.normalizeStringArray)(rawOptions.include, 'include')],
+    };
+    assertSafeRnohPackageList(lists.include, 'include');
+    assertSafeRnohPackageList(lists.exclude, 'exclude');
+    const paths = [];
+    for (const value of lists.searchPaths) {
+        const target = path.resolve(projectRoot, value);
+        paths.push(fs.existsSync(target) ? await fs.promises.realpath(target) : target);
+    }
+    const searchPaths = (0, values_1.uniqueStrings)(paths);
+    const rawDir = selectConfiguredValue(rawOptions, platform, shared, 'nativeModulesDir', './modules');
+    let nativeDir = normalizeNativeModulesDirectory(rawDir, projectRoot);
+    if (nativeDir && fs.existsSync(nativeDir)) {
+        nativeDir = await fs.promises.realpath(nativeDir);
+    }
+    return {
+        projectRoot,
+        platform: constants_1.Platform,
+        searchPaths,
+        nativeModulesDir: nativeDir,
+        exclude: (0, values_1.uniqueStrings)(lists.exclude),
+        include: (0, values_1.uniqueStrings)(lists.include),
+        moduleOverrides: normalizeModuleOverrides(platform.modules),
+        buildType: normalizeBuildType(selectConfiguredValue(rawOptions, platform, shared, 'buildType', 'debug')),
+    };
+}

package/build/src/errors.d.ts

@@ -0,0 +1,18 @@
+import type { AutolinkingErrorJson, Diagnostic } from './types';
+interface HarmonyAutolinkingErrorDetails {
+    cause?: unknown;
+    stage?: string;
+    packageName?: string;
+    diagnostics?: ReadonlyArray<Diagnostic>;
+    details?: unknown;
+}
+declare class HarmonyAutolinkingError extends Error {
+    readonly code: string;
+    readonly stage: string;
+    readonly packageName?: string;
+    readonly diagnostics?: ReadonlyArray<Diagnostic>;
+    readonly details?: unknown;
+    constructor(code: string, message: string, details?: HarmonyAutolinkingErrorDetails);
+    toJSON(): AutolinkingErrorJson;
+}
+export { HarmonyAutolinkingError };

package/build/src/errors.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HarmonyAutolinkingError = void 0;
+const ErrorPrefix = 'ERR_EXPO_HARMONY_';
+class HarmonyAutolinkingError extends Error {
+    code;
+    stage;
+    packageName;
+    diagnostics;
+    details;
+    constructor(code, message, details = {}) {
+        const value = code.startsWith(ErrorPrefix) ? code : `${ErrorPrefix}${code}`;
+        super(message, details.cause ? { cause: details.cause } : undefined);
+        this.name = 'HarmonyAutolinkingError';
+        this.code = value;
+        this.stage = details.stage || 'unknown';
+        this.packageName = details.packageName;
+        this.diagnostics = details.diagnostics;
+        this.details = details.details;
+        Error.captureStackTrace?.(this, HarmonyAutolinkingError);
+    }
+    toJSON() {
+        const value = {
+            name: 'HarmonyAutolinkingError',
+            code: this.code,
+            message: this.message,
+            stage: this.stage,
+            ...(this.packageName ? { packageName: this.packageName } : {}),
+            ...(this.diagnostics ? { diagnostics: this.diagnostics } : {}),
+            ...(this.details ? { details: this.details } : {}),
+        };
+        return value;
+    }
+}
+exports.HarmonyAutolinkingError = HarmonyAutolinkingError;

package/build/src/harmony/manifest/generate.d.ts

@@ -0,0 +1,4 @@
+import type { Manifest } from '../../types';
+declare function createManifest(modules: any, options?: Record<string, any>): Manifest;
+declare function serializeManifest(modules: any, options?: Record<string, any>): string;
+export { createManifest, serializeManifest, };

package/build/src/harmony/manifest/generate.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createManifest = createManifest;
+exports.serializeManifest = serializeManifest;
+const constants_1 = require("../../config/constants");
+const values_1 = require("../../utilities/values");
+function cloneOhPackageName(value) {
+    if (Array.isArray(value))
+        return value.map(mapping => ({ ...mapping }));
+    return value;
+}
+function createManifestEntry(descriptor) {
+    return {
+        packageName: descriptor.packageName,
+        packageVersion: descriptor.packageVersion,
+        packageRoot: descriptor.packageRoot,
+        packageLinkPath: descriptor.packageLinkPath,
+        source: descriptor.source,
+        harmony: {
+            modules: [...descriptor.harmony.modules],
+        },
+        ...(descriptor.arkTs ? { arkTs: { ...descriptor.arkTs } } : {}),
+        expo: {
+            rootViewComponents: [...descriptor.expo.rootViewComponents],
+        },
+        rnoh: {
+            ...(descriptor.rnoh.ohPackageName !== undefined
+                ? { ohPackageName: cloneOhPackageName(descriptor.rnoh.ohPackageName) }
+                : {}),
+            ...(descriptor.rnoh.mainHarPath ? { mainHarPath: descriptor.rnoh.mainHarPath } : {}),
+            harPaths: [...descriptor.rnoh.harPaths],
+            ...(descriptor.rnoh.etsPackageClassName ? { etsPackageClassName: descriptor.rnoh.etsPackageClassName } : {}),
+            ...(descriptor.rnoh.etsPackageImport ? { etsPackageImport: descriptor.rnoh.etsPackageImport } : {}),
+            ...(descriptor.rnoh.cppPackageClassName ? { cppPackageClassName: descriptor.rnoh.cppPackageClassName } : {}),
+            ...(descriptor.rnoh.cmakeLibraryTargetName
+                ? { cmakeLibraryTargetName: descriptor.rnoh.cmakeLibraryTargetName }
+                : {}),
+        },
+    };
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function createManifest(modules, options = {}) {
+    const buildType = options.buildType || 'debug';
+    return {
+        schemaVersion: constants_1.ManifestSchemaVersion,
+        platform: constants_1.Platform,
+        buildType,
+        modules: modules.map(descriptor => createManifestEntry(descriptor)),
+        managedArtifacts: [...(options.managedArtifacts || constants_1.ManagedArtifacts)],
+    };
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function serializeManifest(modules, options = {}) {
+    return (0, values_1.stringifyJson)(createManifest(modules, options));
+}

package/build/src/harmony/manifest/index.d.ts

@@ -0,0 +1,7 @@
+import type { Manifest } from '../../types';
+declare function validateManifest(manifest: unknown, options?: Record<string, any>): Manifest;
+declare function ohpmDependenciesFromManifest(manifest: Manifest, options?: {
+    harmonyProjectPath?: string;
+    nodeModulesPath?: string;
+}): Readonly<Record<string, string>>;
+export { ohpmDependenciesFromManifest, validateManifest, };

package/build/src/harmony/manifest/index.js

@@ -0,0 +1,64 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ohpmDependenciesFromManifest = ohpmDependenciesFromManifest;
+exports.validateManifest = validateManifest;
+const node_path_1 = __importDefault(require("node:path"));
+const constants_1 = require("../../config/constants");
+const errors_1 = require("../../errors");
+const dependencies_1 = require("../ohpm/dependencies");
+const schema_1 = require("../../metadata/schema");
+const values_1 = require("../../utilities/values");
+const ModuleSources = new Set(['dependency', 'searchPath', 'nativeModulesDir', 'reactNativeProjectConfig']);
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function validateManifest(manifest, options = {}) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const candidate = (0, values_1.isObject)(manifest) ? manifest : null;
+    if (!candidate
+        || candidate.schemaVersion !== constants_1.ManifestSchemaVersion
+        || candidate.platform !== constants_1.Platform
+        || !['debug', 'release'].includes(candidate.buildType)
+        || !Array.isArray(candidate.modules)
+        || !Array.isArray(candidate.managedArtifacts)) {
+        throw new errors_1.HarmonyAutolinkingError('INVALID_MANIFEST', `Harmony autolinking manifest must use schema ${constants_1.ManifestSchemaVersion}.`, {
+            details: options.file ? { file: options.file } : undefined,
+            stage: 'manifest',
+        });
+    }
+    for (const [index, entry] of candidate.modules.entries()) {
+        if (!(0, values_1.isObject)(entry)
+            || typeof entry.packageName !== 'string'
+            || !entry.packageName
+            || typeof entry.packageVersion !== 'string'
+            || !entry.packageVersion
+            || typeof entry.packageRoot !== 'string'
+            || !node_path_1.default.isAbsolute(entry.packageRoot)
+            || typeof entry.packageLinkPath !== 'string'
+            || !node_path_1.default.isAbsolute(entry.packageLinkPath)
+            || !ModuleSources.has(entry.source)
+            || (entry.harmony !== undefined && (!(0, values_1.isObject)(entry.harmony)
+                || !Array.isArray(entry.harmony.modules)
+                || entry.harmony.modules.some(moduleClass => typeof moduleClass !== 'string' || !moduleClass)))
+            || (entry.arkTs !== undefined && (!(0, values_1.isObject)(entry.arkTs)
+                || entry.arkTs.harPath !== 'harmony/library.har'
+                || !(0, schema_1.isValidOhpmPackageName)(entry.arkTs.ohPackageName)))
+            || (entry.harmony?.modules.length > 0 && !(0, values_1.isObject)(entry.arkTs))
+            || !(0, values_1.isObject)(entry.expo)
+            || !Array.isArray(entry.expo.rootViewComponents)
+            || !(0, values_1.isObject)(entry.rnoh)
+            || !Array.isArray(entry.rnoh.harPaths)) {
+            throw new errors_1.HarmonyAutolinkingError('INVALID_MANIFEST', `Harmony autolinking manifest module ${index} is invalid.`, { details: options.file ? { file: options.file } : undefined, stage: 'manifest' });
+        }
+    }
+    return structuredClone(candidate);
+}
+function ohpmDependenciesFromManifest(manifest, options = {}) {
+    const validated = validateManifest(manifest);
+    return Object.fromEntries((0, dependencies_1.collectOhpmDeps)(validated.modules)
+        .map(({ descriptor, mapping }) => [
+        mapping.ohPackageName,
+        (0, dependencies_1.resolveOhpmSpecifier)(descriptor, mapping, options),
+    ]));
+}

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

@@ -0,0 +1,12 @@
+import type { ArkTsModulePackage, BuildType, MaterializedLocalSource, MaterializeLocalSourceOptions, ModuleArtifactDescriptor, ModuleSource, RnohMetadata } from '../types';
+interface MaterializeModuleArtifactOptions {
+    readonly packageName: string;
+    readonly packageRoot: string;
+    readonly source: ModuleSource;
+    readonly buildType: BuildType;
+    readonly arkTs?: ArkTsModulePackage;
+    readonly rnoh: RnohMetadata;
+}
+declare function materializeModuleArtifactAsync(options: MaterializeModuleArtifactOptions): Promise<ModuleArtifactDescriptor>;
+declare function materializeLocalSourcesAsync(modules: ReadonlyArray<MaterializeLocalSourceOptions['module']>, options: Omit<MaterializeLocalSourceOptions, 'module'>): Promise<ReadonlyArray<MaterializedLocalSource>>;
+export { materializeLocalSourcesAsync, materializeModuleArtifactAsync, };