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

package/build/src/metadata/descriptor.js

@@ -0,0 +1,306 @@
+"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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDescriptorFromSearchRecordAsync = createDescriptorFromSearchRecordAsync;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const json5_1 = __importDefault(require("json5"));
+const errors_1 = require("../errors");
+const schema_1 = require("./schema");
+const materialize_1 = require("../harmony/materialize");
+const packageMetadata_1 = require("../harmony/rnoh/packageMetadata");
+const values_1 = require("../utilities/values");
+const HarScanIgnoredDirectories = new Set(['.git', 'build', 'node_modules', 'oh_modules']);
+const ArkTsLibraryManifestPath = 'harmony/library/oh-package.json5';
+const ArkTsLibraryHarPath = 'harmony/library.har';
+async function findHarPathsAsync(packageRoot, scanRoot, record) {
+    const harPaths = [];
+    const visited = new Set();
+    async function visit(directory) {
+        let real;
+        let entries;
+        try {
+            real = await fs.promises.realpath(directory);
+            entries = await fs.promises.readdir(directory, { withFileTypes: true });
+        }
+        catch (cause) {
+            throw new errors_1.HarmonyAutolinkingError('INVALID_METADATA', 'Unable to scan harmony.autolinking.mainHarPath.', {
+                cause,
+                packageName: record.packageName,
+                stage: 'metadata',
+            });
+        }
+        if (!(0, values_1.isPathInside)(packageRoot, real)) {
+            throw new errors_1.HarmonyAutolinkingError('PATH_OUTSIDE_PACKAGE', 'harmony.autolinking.mainHarPath resolves outside package root.', { packageName: record.packageName, stage: 'metadata' });
+        }
+        if (visited.has(real))
+            return;
+        visited.add(real);
+        entries.sort((left, right) => (0, values_1.compareText)(left.name, right.name));
+        for (const entry of entries) {
+            const target = path.join(directory, entry.name);
+            let stat;
+            try {
+                stat = await fs.promises.lstat(target);
+            }
+            catch (cause) {
+                throw new errors_1.HarmonyAutolinkingError('INVALID_METADATA', 'A HAR scan entry is missing or unreadable.', {
+                    cause,
+                    packageName: record.packageName,
+                    stage: 'metadata',
+                });
+            }
+            if (stat.isDirectory()) {
+                if (HarScanIgnoredDirectories.has(entry.name))
+                    continue;
+                await visit(target);
+            }
+            else if (path.extname(entry.name) === '.har') {
+                let realTarget;
+                try {
+                    realTarget = await fs.promises.realpath(target);
+                    if (!(await fs.promises.stat(realTarget)).isFile())
+                        continue;
+                }
+                catch (cause) {
+                    throw new errors_1.HarmonyAutolinkingError('INVALID_METADATA', 'A HAR scan entry is missing or unreadable.', {
+                        cause,
+                        packageName: record.packageName,
+                        stage: 'metadata',
+                    });
+                }
+                if (!(0, values_1.isPathInside)(packageRoot, realTarget)) {
+                    throw new errors_1.HarmonyAutolinkingError('PATH_OUTSIDE_PACKAGE', 'A HAR scan path resolves outside package root.', { packageName: record.packageName, stage: 'metadata' });
+                }
+                harPaths.push((0, values_1.normalizeSlashes)(path.relative(packageRoot, target)));
+            }
+        }
+    }
+    await visit(scanRoot);
+    return (0, values_1.sortedUniqueStrings)(harPaths);
+}
+function resolveOhpmPackageName(raw, harPaths, record) {
+    const base = (0, packageMetadata_1.defaultOhPackageNameForNpmPackage)(record.packageName);
+    const fallback = harPath => ({
+        harName: path.basename(harPath),
+        packageName: (0, packageMetadata_1.ohPackageNameForHar)(base, harPath, harPaths.length),
+    });
+    if (raw === undefined) {
+        return harPaths.length === 1 ? base : harPaths.map(fallback);
+    }
+    if (typeof raw === 'string') {
+        return harPaths.length === 1
+            ? raw
+            : harPaths.map(harPath => ({
+                harName: path.basename(harPath),
+                packageName: (0, packageMetadata_1.ohPackageNameForHar)(raw, harPath, harPaths.length),
+            }));
+    }
+    const harNames = new Set(harPaths.map(harPath => path.basename(harPath)));
+    const mappings = raw.map((mapping) => {
+        if (!harNames.has(mapping.harName)) {
+            throw new errors_1.HarmonyAutolinkingError('INVALID_METADATA', `package.json#harmony.autolinking.ohPackageName mapping ${mapping.harName} does not match a discovered HAR.`, {
+                packageName: record.packageName,
+                stage: 'metadata',
+            });
+        }
+        return mapping;
+    });
+    const mapped = new Set(mappings.map(mapping => mapping.harName));
+    for (const harPath of harPaths) {
+        if (!mapped.has(path.basename(harPath)))
+            mappings.push(fallback(harPath));
+    }
+    return mappings;
+}
+async function resolveArkTsModulePackageAsync(record, harmony) {
+    const hasHostExtensions = harmony.rootViewComponents.length > 0;
+    if (harmony.modules.length === 0 && !hasHostExtensions)
+        return undefined;
+    const manifestPath = await (0, values_1.resolveInsideAsync)(record.packageRoot, ArkTsLibraryManifestPath, 'Harmony library OHPM manifest', { packageName: record.packageName, type: 'file' });
+    let manifest;
+    try {
+        manifest = json5_1.default.parse(await fs.promises.readFile(manifestPath, 'utf8'));
+    }
+    catch (cause) {
+        throw new errors_1.HarmonyAutolinkingError('INVALID_METADATA', `${ArkTsLibraryManifestPath} must contain valid JSON5.`, { cause, packageName: record.packageName, stage: 'metadata' });
+    }
+    if (!(0, values_1.isObject)(manifest) || !(0, schema_1.isValidOhpmPackageName)(manifest.name)) {
+        throw new errors_1.HarmonyAutolinkingError('INVALID_METADATA', `${ArkTsLibraryManifestPath} must declare a valid OHPM package name.`, { packageName: record.packageName, stage: 'metadata' });
+    }
+    return {
+        harPath: ArkTsLibraryHarPath,
+        ohPackageName: manifest.name,
+    };
+}
+function normalizeExpoMetadata(record, canonical) {
+    if (!record.supportsHarmony)
+        return {
+            rootViewComponents: [],
+        };
+    return {
+        rootViewComponents: canonical.rootViewComponents,
+    };
+}
+async function normalizeRnohMetadataAsync(record) {
+    if (record.rnohMetadata == null) {
+        return {
+            ohPackageName: undefined,
+            mainHarPath: undefined,
+            harPaths: [],
+            etsPackageClassName: undefined,
+            cppPackageClassName: undefined,
+            cmakeLibraryTargetName: undefined,
+        };
+    }
+    const metadata = (0, schema_1.normalizeRnohPackageMetadata)(record.rnohMetadata, {
+        packageName: record.packageName,
+        packageVersion: record.packageVersion,
+    });
+    let main;
+    if (metadata.mainHarPath !== undefined) {
+        main = metadata.mainHarPath;
+    }
+    else {
+        try {
+            const harmonyStat = await fs.promises.stat(path.join(record.packageRoot, 'harmony'));
+            main = harmonyStat.isDirectory() ? 'harmony' : '.';
+        }
+        catch (_cause) {
+            main = '.';
+        }
+    }
+    const scanRoot = await (0, values_1.resolveInsideAsync)(record.packageRoot, main, 'harmony.autolinking.mainHarPath', { packageName: record.packageName, type: 'directory' });
+    main = (0, values_1.normalizeSlashes)(path.relative(record.packageRoot, scanRoot)) || '.';
+    const harPaths = await findHarPathsAsync(record.packageRoot, scanRoot, record);
+    if (harPaths.length === 0) {
+        throw new errors_1.HarmonyAutolinkingError('INVALID_METADATA', 'harmony.autolinking.mainHarPath does not contain a HAR file.', {
+            packageName: record.packageName,
+            stage: 'metadata',
+        });
+    }
+    const harBasenames = harPaths.map(harPath => path.basename(harPath));
+    if (new Set(harBasenames).size !== harBasenames.length) {
+        throw new errors_1.HarmonyAutolinkingError('INVALID_METADATA', 'harmony.autolinking.mainHarPath contains duplicate HAR filenames.', {
+            packageName: record.packageName,
+            stage: 'metadata',
+        });
+    }
+    const name = resolveOhpmPackageName(metadata.ohPackageName, harPaths, record);
+    if (Array.isArray(name)) {
+        const order = new Map(name.map((mapping, index) => [mapping.harName, index]));
+        harPaths.sort((left, right) => {
+            return order.get(path.basename(left)) - order.get(path.basename(right));
+        });
+    }
+    const rnoh = {
+        ohPackageName: name,
+        mainHarPath: main,
+        harPaths,
+        etsPackageClassName: metadata.etsPackageClassName,
+        etsPackageImport: metadata.etsPackageImport,
+        cppPackageClassName: metadata.cppPackageClassName,
+        cmakeLibraryTargetName: metadata.cmakeLibraryTargetName
+            || (0, packageMetadata_1.defaultCmakeTargetForNpmPackage)(record.packageName),
+    };
+    return rnoh;
+}
+function assertSearchRecord(record) {
+    if (!(0, values_1.isObject)(record)) {
+        throw new errors_1.HarmonyAutolinkingError('INVALID_METADATA', 'Search record must be an object.', {
+            stage: 'metadata',
+        });
+    }
+    for (const field of ['packageName', 'packageVersion', 'packageRoot', 'source']) {
+        (0, values_1.requireNonEmptyString)(record[field], field, { packageName: record.packageName });
+    }
+}
+async function createDescriptorFromSearchRecordAsync(record, buildType = 'debug') {
+    assertSearchRecord(record);
+    let packageRoot;
+    try {
+        packageRoot = await fs.promises.realpath(record.packageRoot);
+        if (!(await fs.promises.stat(packageRoot)).isDirectory())
+            throw new TypeError('not a directory');
+    }
+    catch (cause) {
+        throw new errors_1.HarmonyAutolinkingError('INVALID_METADATA', `${record.packageName} packageRoot is not an existing directory.`, {
+            cause,
+            packageName: record.packageName,
+            stage: 'metadata',
+        });
+    }
+    const base = { ...record, packageRoot };
+    let link = packageRoot;
+    if (typeof record.revision?.originPath === 'string') {
+        const candidate = path.resolve(record.revision.originPath);
+        try {
+            if (await fs.promises.realpath(candidate) === packageRoot)
+                link = candidate;
+        }
+        catch (_cause) {
+            // The canonical package root remains the safe fallback for direct callers.
+        }
+    }
+    const expoConfig = (0, values_1.isObject)(base.expoModuleConfig) ? base.expoModuleConfig : null;
+    const harmony = (0, schema_1.normalizeHarmonyModuleMetadata)(expoConfig?.harmony, { packageName: record.packageName, packageVersion: record.packageVersion });
+    const arkTs = await resolveArkTsModulePackageAsync(base, harmony);
+    const rnoh = await normalizeRnohMetadataAsync(base);
+    const expo = normalizeExpoMetadata(base, harmony);
+    const artifact = await (0, materialize_1.materializeModuleArtifactAsync)({
+        packageName: record.packageName,
+        packageRoot,
+        source: record.source,
+        buildType,
+        arkTs,
+        rnoh,
+    });
+    const descriptor = {
+        packageName: record.packageName,
+        packageVersion: record.packageVersion,
+        packageRoot,
+        packageLinkPath: link,
+        source: record.source,
+        expo,
+        rnoh,
+        harmony,
+        ...(arkTs ? { arkTs } : {}),
+        artifact,
+    };
+    return descriptor;
+}

package/build/src/metadata/host.d.ts

@@ -0,0 +1,5 @@
+declare const HostMetadataFields: readonly string[];
+declare function normalizeHostMetadata(harmony: any, record: any): {
+    [k: string]: string[];
+};
+export { HostMetadataFields, normalizeHostMetadata, };

package/build/src/metadata/host.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HostMetadataFields = void 0;
+exports.normalizeHostMetadata = normalizeHostMetadata;
+const errors_1 = require("../errors");
+const values_1 = require("../utilities/values");
+const ArkTsIdentifierPattern = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+const HostMetadataFields = Object.freeze([
+    'rootViewComponents',
+]);
+exports.HostMetadataFields = HostMetadataFields;
+function normalizeIdentifiers(value, field, packageName) {
+    if (value === undefined)
+        return [];
+    if (!Array.isArray(value)) {
+        throw new errors_1.HarmonyAutolinkingError('INVALID_METADATA', `expo-module.config.json#harmony.${field} must be an array.`, {
+            packageName,
+            stage: 'metadata',
+        });
+    }
+    const values = value.map((item, index) => {
+        if (typeof item !== 'string' || !ArkTsIdentifierPattern.test(item)) {
+            throw new errors_1.HarmonyAutolinkingError('INVALID_METADATA', `harmony.${field}[${index}] must be a valid ArkTS identifier.`, {
+                packageName,
+                stage: 'metadata',
+            });
+        }
+        return item;
+    });
+    return (0, values_1.sortedUniqueStrings)(values);
+}
+function normalizeHostMetadata(harmony, record) {
+    return Object.fromEntries(HostMetadataFields.map(field => [
+        field,
+        normalizeIdentifiers(harmony[field], field, record.packageName),
+    ]));
+}

package/build/src/metadata/schema.d.ts

@@ -0,0 +1,10 @@
+import type { HarmonyModuleMetadata, RnohMetadata } from '../types';
+interface MetadataRecord {
+    readonly packageName: string;
+    readonly packageVersion?: string;
+}
+declare function isValidOhpmPackageName(value: unknown): value is string;
+declare function normalizeHarmonyModuleMetadata(harmonyValue: unknown, record: MetadataRecord): HarmonyModuleMetadata;
+/** Normalizes current RNOH package metadata, independently of Expo module config. */
+declare function normalizeRnohPackageMetadata(value: unknown, record: MetadataRecord): Omit<RnohMetadata, 'harPaths'>;
+export { isValidOhpmPackageName, normalizeHarmonyModuleMetadata, normalizeRnohPackageMetadata, };

package/build/src/metadata/schema.js

@@ -0,0 +1,171 @@
+"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.isValidOhpmPackageName = isValidOhpmPackageName;
+exports.normalizeHarmonyModuleMetadata = normalizeHarmonyModuleMetadata;
+exports.normalizeRnohPackageMetadata = normalizeRnohPackageMetadata;
+const path = __importStar(require("node:path"));
+const errors_1 = require("../errors");
+const host_1 = require("./host");
+const values_1 = require("../utilities/values");
+const ArkTsIdentifierPattern = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+const CppIdentifierPattern = /^[A-Za-z_][A-Za-z0-9_]*$/;
+const CmakeTargetPattern = /^[A-Za-z0-9_.:+-]+$/;
+const OhPackagePartPattern = /^[A-Za-z0-9._~-]+$/;
+function metadataError(message, record) {
+    throw new errors_1.HarmonyAutolinkingError('INVALID_METADATA', message, {
+        packageName: record.packageName,
+        stage: 'metadata-normalize',
+    });
+}
+function requireObject(value, message, record) {
+    if (!(0, values_1.isObject)(value))
+        metadataError(message, record);
+    return value;
+}
+function isValidOhpmPackageName(value) {
+    if (typeof value !== 'string' || !value || /[\0\r\n\\'"`;${}()<>\s]/u.test(value))
+        return false;
+    const scoped = value.startsWith('@');
+    const parts = scoped ? value.slice(1).split('/') : value.split('/');
+    return parts.length === (scoped ? 2 : 1)
+        && parts.every(part => part !== '.' && part !== '..' && OhPackagePartPattern.test(part));
+}
+function normalizeOhPackageName(value, record) {
+    if (value === undefined)
+        return undefined;
+    if (typeof value === 'string') {
+        if (!isValidOhpmPackageName(value)) {
+            metadataError('package.json#harmony.autolinking.ohPackageName must be a safe OHPM package name.', record);
+        }
+        return value;
+    }
+    if (!Array.isArray(value)) {
+        metadataError('package.json#harmony.autolinking.ohPackageName must be a string or HAR mapping array.', record);
+    }
+    const seen = new Set();
+    return value.map((rawMapping, index) => {
+        const field = `package.json#harmony.autolinking.ohPackageName[${index}]`;
+        const mapping = requireObject(rawMapping, `${field} must be an object.`, record);
+        const harName = (0, values_1.requireNonEmptyString)(mapping.harName, `${field}.harName`, {
+            packageName: record.packageName,
+            stage: 'metadata-normalize',
+        });
+        if (path.posix.basename(harName) !== harName
+            || path.win32.basename(harName) !== harName
+            || path.posix.extname(harName).toLowerCase() !== '.har') {
+            metadataError(`${field}.harName must be a HAR filename.`, record);
+        }
+        if (seen.has(harName))
+            metadataError(`${field}.harName is declared more than once.`, record);
+        seen.add(harName);
+        if (!isValidOhpmPackageName(mapping.packageName)) {
+            metadataError(`${field}.packageName must be a safe OHPM package name.`, record);
+        }
+        const version = mapping.version === undefined
+            ? undefined
+            : (0, values_1.requireNonEmptyString)(mapping.version, `${field}.version`, {
+                packageName: record.packageName,
+                stage: 'metadata-normalize',
+            });
+        return { harName, packageName: mapping.packageName, ...(version ? { version } : {}) };
+    });
+}
+function normalizeArkTsModules(value, record) {
+    if (value === undefined)
+        return [];
+    if (!Array.isArray(value)) {
+        metadataError('expo-module.config.json#harmony.modules must be an array.', record);
+    }
+    const seen = new Set();
+    const modules = value.map((item, index) => {
+        const moduleClass = (0, values_1.requireNonEmptyString)(item, `expo-module.config.json#harmony.modules[${index}]`, { packageName: record.packageName, stage: 'metadata-normalize' });
+        if (!ArkTsIdentifierPattern.test(moduleClass)) {
+            metadataError(`expo-module.config.json#harmony.modules[${index}] must be an ArkTS identifier.`, record);
+        }
+        if (seen.has(moduleClass)) {
+            metadataError(`expo-module.config.json#harmony.modules declares ${moduleClass} more than once.`, record);
+        }
+        seen.add(moduleClass);
+        return moduleClass;
+    });
+    return modules.sort((left, right) => left.localeCompare(right, 'en'));
+}
+function normalizeHarmonyModuleMetadata(harmonyValue, record) {
+    const harmony = harmonyValue === undefined
+        ? {}
+        : requireObject(harmonyValue, 'expo-module.config.json#harmony must be an object.', record);
+    const host = (0, host_1.normalizeHostMetadata)(harmony, record);
+    return {
+        ...host,
+        modules: normalizeArkTsModules(harmony.modules, record),
+    };
+}
+function optionalIdentifier(value, field, pattern, record) {
+    if (value === undefined)
+        return undefined;
+    const normalized = (0, values_1.requireNonEmptyString)(value, field, {
+        packageName: record.packageName,
+        stage: 'metadata-normalize',
+    });
+    if (!pattern.test(normalized))
+        metadataError(`${field} is invalid.`, record);
+    return normalized;
+}
+/** Normalizes current RNOH package metadata, independently of Expo module config. */
+function normalizeRnohPackageMetadata(value, record) {
+    if (value == null || value === true)
+        return {};
+    const rnoh = requireObject(value, 'package.json#harmony.autolinking must be an object.', record);
+    const etsPackageImport = rnoh.etsPackageImport;
+    if (etsPackageImport !== undefined && etsPackageImport !== 'default' && etsPackageImport !== 'named') {
+        metadataError('package.json#harmony.autolinking.etsPackageImport must be "default" or "named".', record);
+    }
+    return {
+        ohPackageName: normalizeOhPackageName(rnoh.ohPackageName, record),
+        ...(rnoh.mainHarPath === undefined
+            ? {}
+            : {
+                mainHarPath: (0, values_1.requireNonEmptyString)(rnoh.mainHarPath, 'package.json#harmony.autolinking.mainHarPath', {
+                    packageName: record.packageName,
+                    stage: 'metadata-normalize',
+                }),
+            }),
+        etsPackageClassName: optionalIdentifier(rnoh.etsPackageClassName, 'package.json#harmony.autolinking.etsPackageClassName', ArkTsIdentifierPattern, record),
+        etsPackageImport: etsPackageImport,
+        cppPackageClassName: optionalIdentifier(rnoh.cppPackageClassName, 'package.json#harmony.autolinking.cppPackageClassName', CppIdentifierPattern, record),
+        cmakeLibraryTargetName: optionalIdentifier(rnoh.cmakeLibraryTargetName, 'package.json#harmony.autolinking.cmakeLibraryTargetName', CmakeTargetPattern, record),
+    };
+}