expo-harmony-toolkit 1.7.2 → 1.8.0

package/build/core/autolinking.js

@@ -0,0 +1,421 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AutolinkingFailureError = exports.AUTOLINKED_FILE_PATHS = void 0;
+exports.buildAutolinkedManagedFiles = buildAutolinkedManagedFiles;
+exports.normalizeKnownHarmonyPackageJsons = normalizeKnownHarmonyPackageJsons;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const json5_1 = __importDefault(require("json5"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const uiStack_1 = require("../data/uiStack");
+exports.AUTOLINKED_FILE_PATHS = [
+    path_1.default.join('harmony', 'oh-package.json5'),
+    path_1.default.join('harmony', 'entry', 'src', 'main', 'ets', 'RNOHPackagesFactory.ets'),
+    path_1.default.join('harmony', 'entry', 'src', 'main', 'cpp', 'RNOHPackagesFactory.h'),
+    path_1.default.join('harmony', 'entry', 'src', 'main', 'cpp', 'autolinking.cmake'),
+];
+const HARMONY_PACKAGE_JSON_NORMALIZERS = {
+    '@react-native-oh-tpl/react-native-gesture-handler': (packageJson) => {
+        const harmony = packageJson.harmony && typeof packageJson.harmony === 'object' && !Array.isArray(packageJson.harmony)
+            ? { ...packageJson.harmony }
+            : null;
+        if (!harmony || !('codegenConfig' in harmony)) {
+            return null;
+        }
+        delete harmony.codegenConfig;
+        return {
+            ...packageJson,
+            harmony,
+        };
+    },
+};
+class AutolinkingFailureError extends Error {
+    constructor(stage, command, options = {}) {
+        const details = [
+            `Harmony autolinking failed during ${stage}.`,
+            `Command: ${command}`,
+        ];
+        if (options.missingFiles && options.missingFiles.length > 0) {
+            details.push(`Missing files: ${options.missingFiles.join(', ')}`);
+        }
+        if (options.cause) {
+            details.push(`Cause: ${options.cause}`);
+        }
+        super(details.join(' '));
+        this.name = 'AutolinkingFailureError';
+    }
+}
+exports.AutolinkingFailureError = AutolinkingFailureError;
+async function buildAutolinkedManagedFiles(projectRoot, harmonyRootPackageContents) {
+    const generated = await generateAutolinkingArtifacts(projectRoot, harmonyRootPackageContents);
+    return [
+        {
+            relativePath: exports.AUTOLINKED_FILE_PATHS[0],
+            contents: generated.ohPackageContents,
+        },
+        {
+            relativePath: exports.AUTOLINKED_FILE_PATHS[1],
+            contents: generated.etsFactoryContents,
+        },
+        {
+            relativePath: exports.AUTOLINKED_FILE_PATHS[2],
+            contents: generated.cppFactoryContents,
+        },
+        {
+            relativePath: exports.AUTOLINKED_FILE_PATHS[3],
+            contents: generated.cmakeContents,
+        },
+    ];
+}
+async function normalizeKnownHarmonyPackageJsons(projectRoot) {
+    const originalContentsByPath = new Map();
+    for (const [packageName, normalizePackageJson] of Object.entries(HARMONY_PACKAGE_JSON_NORMALIZERS)) {
+        const packageJsonPath = resolveProjectPackageJson(projectRoot, packageName);
+        if (!packageJsonPath || originalContentsByPath.has(packageJsonPath)) {
+            continue;
+        }
+        try {
+            const currentContents = await fs_extra_1.default.readFile(packageJsonPath, 'utf8');
+            const packageJson = JSON.parse(currentContents);
+            const normalizedPackageJson = normalizePackageJson(packageJson);
+            if (!normalizedPackageJson) {
+                continue;
+            }
+            originalContentsByPath.set(packageJsonPath, currentContents);
+            await fs_extra_1.default.writeFile(packageJsonPath, JSON.stringify(normalizedPackageJson, null, 2) + '\n');
+        }
+        catch {
+            // Ignore malformed adapter package metadata and let downstream tooling surface the failure.
+        }
+    }
+    return async () => {
+        for (const [packageJsonPath, originalContents] of originalContentsByPath) {
+            await fs_extra_1.default.writeFile(packageJsonPath, originalContents);
+        }
+    };
+}
+async function generateAutolinkingArtifacts(projectRoot, harmonyRootPackageContents) {
+    const rnohCliPackageJsonPath = resolveProjectPackageJson(projectRoot, '@react-native-oh/react-native-harmony-cli');
+    const managedOhPackageContents = await buildManagedHarmonyRootPackageContents(projectRoot, harmonyRootPackageContents);
+    const managedAutolinkingEntries = await resolveManagedAutolinkingEntries(projectRoot);
+    if (!rnohCliPackageJsonPath) {
+        return createEmptyAutolinkingArtifacts(managedOhPackageContents, managedAutolinkingEntries);
+    }
+    const restoreNormalizedHarmonyPackageJsons = await normalizeKnownHarmonyPackageJsons(projectRoot);
+    try {
+        const temporaryRoot = await fs_extra_1.default.mkdtemp(path_1.default.join(os_1.default.tmpdir(), 'expo-harmony-autolinking-'));
+        try {
+            const temporaryHarmonyRoot = path_1.default.join(temporaryRoot, 'harmony');
+            const commandDescription = buildRnohLinkHarmonyCommand(projectRoot, temporaryHarmonyRoot);
+            await fs_extra_1.default.ensureDir(path_1.default.join(temporaryHarmonyRoot, 'entry', 'src', 'main', 'ets'));
+            await fs_extra_1.default.ensureDir(path_1.default.join(temporaryHarmonyRoot, 'entry', 'src', 'main', 'cpp'));
+            await fs_extra_1.default.writeFile(path_1.default.join(temporaryHarmonyRoot, 'oh-package.json5'), harmonyRootPackageContents);
+            await runRnohLinkHarmonyCommand(projectRoot, rnohCliPackageJsonPath, temporaryHarmonyRoot, commandDescription);
+            await assertGeneratedAutolinkingFilesExist(temporaryHarmonyRoot, commandDescription);
+            let normalizedEtsFactoryContents;
+            let normalizedCppFactoryContents;
+            let normalizedCmakeContents;
+            try {
+                normalizedEtsFactoryContents = await normalizeAutolinkingEtsFactoryContents(projectRoot, await fs_extra_1.default.readFile(path_1.default.join(temporaryHarmonyRoot, 'entry', 'src', 'main', 'ets', 'RNOHPackagesFactory.ets'), 'utf8'));
+                normalizedCppFactoryContents = await normalizeAutolinkingCppFactoryContents(projectRoot, await fs_extra_1.default.readFile(path_1.default.join(temporaryHarmonyRoot, 'entry', 'src', 'main', 'cpp', 'RNOHPackagesFactory.h'), 'utf8'));
+                normalizedCmakeContents = await fs_extra_1.default.readFile(path_1.default.join(temporaryHarmonyRoot, 'entry', 'src', 'main', 'cpp', 'autolinking.cmake'), 'utf8');
+            }
+            catch (error) {
+                throw new AutolinkingFailureError('normalize-generated-files', commandDescription, {
+                    cause: getErrorMessage(error),
+                });
+            }
+            return {
+                ohPackageContents: managedOhPackageContents,
+                etsFactoryContents: injectManagedAutolinkingIntoEtsFactory(normalizedEtsFactoryContents, managedAutolinkingEntries),
+                cppFactoryContents: injectManagedAutolinkingIntoCppFactory(normalizedCppFactoryContents, managedAutolinkingEntries),
+                cmakeContents: injectManagedAutolinkingIntoCmake(normalizedCmakeContents, managedAutolinkingEntries),
+            };
+        }
+        finally {
+            await fs_extra_1.default.remove(temporaryRoot);
+        }
+    }
+    finally {
+        await restoreNormalizedHarmonyPackageJsons();
+    }
+}
+async function resolveManagedAutolinkingEntries(projectRoot) {
+    const entries = await Promise.all(uiStack_1.UI_STACK_VALIDATED_ADAPTERS.map(async (adapter) => {
+        if (adapter.supportsAutolinking || !adapter.managedAutolinking) {
+            return null;
+        }
+        const dependencySpecifier = await resolveHarmonyAdapterHarDependency(projectRoot, adapter.adapterPackageName);
+        if (!dependencySpecifier) {
+            return null;
+        }
+        return {
+            adapterPackageName: adapter.adapterPackageName,
+            ...adapter.managedAutolinking,
+        };
+    }));
+    return entries.filter((entry) => entry !== null);
+}
+async function normalizeAutolinkingEtsFactoryContents(projectRoot, contents) {
+    let normalizedContents = contents
+        .replace(/import type \{\s*RNPackageContext\s*,\s*RNOHPackage\s*\} from '@rnoh\/react-native-openharmony';/, "import type { RNPackageContext, RNPackage } from '@rnoh/react-native-openharmony';")
+        .replace(/export function createRNOHPackages\(([^)]*)\):\s*RNOHPackage\[\]/, 'export function createRNOHPackages($1): RNPackage[]');
+    const gestureHandlerPackageJsonPath = resolveProjectPackageJson(projectRoot, '@react-native-oh-tpl/react-native-gesture-handler');
+    if (!gestureHandlerPackageJsonPath) {
+        return normalizedContents;
+    }
+    try {
+        const gestureHandlerPackageJson = (await fs_extra_1.default.readJson(gestureHandlerPackageJsonPath));
+        if (gestureHandlerPackageJson.harmony?.codegenConfig) {
+            return normalizedContents;
+        }
+    }
+    catch {
+        return normalizedContents;
+    }
+    let gestureHandlerPackageImportName = null;
+    normalizedContents = normalizedContents.replace(/import\s+([A-Za-z_$][\w$]*)\s+from ['"]@react-native-oh-tpl\/react-native-gesture-handler['"];?/, (_match, importName) => {
+        gestureHandlerPackageImportName = importName;
+        return "import { GestureHandlerPackage } from '@react-native-oh-tpl/react-native-gesture-handler/ts';";
+    });
+    if (!gestureHandlerPackageImportName) {
+        return normalizedContents;
+    }
+    return normalizedContents.replace(new RegExp(`new\\s+${escapeRegExp(gestureHandlerPackageImportName)}\\(ctx\\)`, 'g'), 'new GestureHandlerPackage(ctx)');
+}
+function injectManagedAutolinkingIntoEtsFactory(contents, entries) {
+    if (entries.length === 0) {
+        return contents;
+    }
+    const missingImports = entries
+        .filter((entry) => !contents.includes(`from '${entry.etsImportPath}'`))
+        .map((entry) => `import { ${entry.etsPackageName} } from '${entry.etsImportPath}';`);
+    if (missingImports.length > 0) {
+        contents = contents.replace("import type { RNPackageContext, RNPackage } from '@rnoh/react-native-openharmony';", `import type { RNPackageContext, RNPackage } from '@rnoh/react-native-openharmony';\n${missingImports.join('\n')}`);
+    }
+    const missingFactoryEntries = entries
+        .filter((entry) => !contents.includes(`new ${entry.etsPackageName}(ctx)`))
+        .map((entry) => `    new ${entry.etsPackageName}(ctx),`);
+    if (missingFactoryEntries.length > 0) {
+        contents = contents.replace(/return \[\n/, `return [\n${missingFactoryEntries.join('\n')}\n`);
+    }
+    return contents;
+}
+async function normalizeAutolinkingCppFactoryContents(projectRoot, contents) {
+    const gestureHandlerPackageJsonPath = resolveProjectPackageJson(projectRoot, '@react-native-oh-tpl/react-native-gesture-handler');
+    if (!gestureHandlerPackageJsonPath) {
+        return contents;
+    }
+    try {
+        const gestureHandlerPackageJson = (await fs_extra_1.default.readJson(gestureHandlerPackageJsonPath));
+        if (gestureHandlerPackageJson.harmony?.codegenConfig) {
+            return contents;
+        }
+    }
+    catch {
+        return contents;
+    }
+    return contents
+        .replace(/#include "ReactNativeOhTplReactNativeGestureHandlerPackage\.h"/, '#include "RnohReactNativeHarmonyGestureHandlerPackage.h"')
+        .replace(/\brnoh::ReactNativeOhTplReactNativeGestureHandlerPackage\b/g, 'rnoh::RnohReactNativeHarmonyGestureHandlerPackage');
+}
+function injectManagedAutolinkingIntoCppFactory(contents, entries) {
+    if (entries.length === 0) {
+        return contents;
+    }
+    const missingIncludes = entries
+        .filter((entry) => !contents.includes(`#include "${entry.cppHeaderName}"`))
+        .map((entry) => `#include "${entry.cppHeaderName}"`);
+    if (missingIncludes.length > 0) {
+        contents = contents.replace('#include "RNOH/Package.h"', `#include "RNOH/Package.h"\n${missingIncludes.join('\n')}`);
+    }
+    const missingFactoryEntries = entries
+        .filter((entry) => !contents.includes(`std::make_shared<rnoh::${entry.cppPackageName}>(ctx)`))
+        .map((entry) => `    std::make_shared<rnoh::${entry.cppPackageName}>(ctx),`);
+    if (missingFactoryEntries.length > 0) {
+        contents = contents.replace(/return \{\n/, `return {\n${missingFactoryEntries.join('\n')}\n`);
+    }
+    return contents;
+}
+function injectManagedAutolinkingIntoCmake(contents, entries) {
+    if (entries.length === 0) {
+        return contents;
+    }
+    const missingSubdirectories = entries
+        .filter((entry) => !contents.includes(`./${entry.cmakeTargetName}`))
+        .map((entry) => `    add_subdirectory("\${OH_MODULES_DIR}/${entry.adapterPackageName}/src/main/cpp" ./${entry.cmakeTargetName})`);
+    if (missingSubdirectories.length > 0) {
+        contents = contents.replace(/function\(autolink_libraries target\)\n/, `function(autolink_libraries target)\n${missingSubdirectories.join('\n')}\n`);
+    }
+    const missingLibraryTargets = entries
+        .filter((entry) => !contents.includes(`        ${entry.cmakeTargetName}`))
+        .map((entry) => `        ${entry.cmakeTargetName}`);
+    if (missingLibraryTargets.length > 0) {
+        contents = contents.replace(/set\(AUTOLINKED_LIBRARIES\n/, `set(AUTOLINKED_LIBRARIES\n${missingLibraryTargets.join('\n')}\n`);
+    }
+    return contents;
+}
+async function runRnohLinkHarmonyCommand(projectRoot, rnohCliPackageJsonPath, harmonyProjectPath, commandDescription) {
+    const rnohCliRoot = path_1.default.dirname(rnohCliPackageJsonPath);
+    let commandLinkHarmony;
+    try {
+        ({ commandLinkHarmony } = require(path_1.default.join(rnohCliRoot, 'dist', 'commands', 'link-harmony.js')));
+    }
+    catch (error) {
+        throw new AutolinkingFailureError('load-link-harmony', commandDescription, {
+            cause: getErrorMessage(error),
+        });
+    }
+    try {
+        await commandLinkHarmony.func([], {}, {
+            harmonyProjectPath,
+            nodeModulesPath: path_1.default.join(projectRoot, 'node_modules'),
+            cmakeAutolinkPathRelativeToHarmony: './entry/src/main/cpp/autolinking.cmake',
+            cppRnohPackagesFactoryPathRelativeToHarmony: './entry/src/main/cpp/RNOHPackagesFactory.h',
+            etsRnohPackagesFactoryPathRelativeToHarmony: './entry/src/main/ets/RNOHPackagesFactory.ets',
+            ohPackagePathRelativeToHarmony: './oh-package.json5',
+            includeNpmPackages: uiStack_1.UI_STACK_ADAPTER_PACKAGE_NAMES,
+        });
+    }
+    catch (error) {
+        throw new AutolinkingFailureError('link-harmony', commandDescription, {
+            cause: getErrorMessage(error),
+        });
+    }
+}
+function buildRnohLinkHarmonyCommand(projectRoot, harmonyProjectPath) {
+    return [
+        'link-harmony',
+        `--harmonyProjectPath ${harmonyProjectPath}`,
+        `--nodeModulesPath ${path_1.default.join(projectRoot, 'node_modules')}`,
+        '--cmakeAutolinkPathRelativeToHarmony ./entry/src/main/cpp/autolinking.cmake',
+        '--cppRnohPackagesFactoryPathRelativeToHarmony ./entry/src/main/cpp/RNOHPackagesFactory.h',
+        '--etsRnohPackagesFactoryPathRelativeToHarmony ./entry/src/main/ets/RNOHPackagesFactory.ets',
+        '--ohPackagePathRelativeToHarmony ./oh-package.json5',
+    ].join(' ');
+}
+async function assertGeneratedAutolinkingFilesExist(harmonyProjectPath, commandDescription) {
+    const requiredFiles = [
+        path_1.default.join(harmonyProjectPath, 'entry', 'src', 'main', 'ets', 'RNOHPackagesFactory.ets'),
+        path_1.default.join(harmonyProjectPath, 'entry', 'src', 'main', 'cpp', 'RNOHPackagesFactory.h'),
+        path_1.default.join(harmonyProjectPath, 'entry', 'src', 'main', 'cpp', 'autolinking.cmake'),
+    ];
+    const missingFiles = requiredFiles.filter((filePath) => !fs_extra_1.default.existsSync(filePath));
+    if (missingFiles.length > 0) {
+        throw new AutolinkingFailureError('validate-generated-files', commandDescription, {
+            missingFiles: missingFiles.map((filePath) => path_1.default.relative(harmonyProjectPath, filePath)),
+        });
+    }
+}
+async function buildManagedHarmonyRootPackageContents(projectRoot, harmonyRootPackageContents) {
+    const parsedPackageJson = json5_1.default.parse(harmonyRootPackageContents);
+    const dependencies = {
+        ...(parsedPackageJson.dependencies ?? {}),
+        ...(await readPreservedHarmonyRootDependencies(projectRoot)),
+    };
+    for (const adapter of uiStack_1.UI_STACK_VALIDATED_ADAPTERS) {
+        const dependencySpecifier = await resolveHarmonyAdapterHarDependency(projectRoot, adapter.adapterPackageName);
+        if (dependencySpecifier) {
+            dependencies[adapter.adapterPackageName] = dependencySpecifier;
+        }
+    }
+    parsedPackageJson.dependencies = sortRecordByKey(dependencies);
+    return json5_1.default.stringify(parsedPackageJson, null, 2) + '\n';
+}
+async function readPreservedHarmonyRootDependencies(projectRoot) {
+    const harmonyRootPackagePath = path_1.default.join(projectRoot, 'harmony', 'oh-package.json5');
+    if (!(await fs_extra_1.default.pathExists(harmonyRootPackagePath))) {
+        return {};
+    }
+    const currentHarmonyRootPackage = json5_1.default.parse(await fs_extra_1.default.readFile(harmonyRootPackagePath, 'utf8'));
+    const preservedDependencies = {};
+    const validatedAdapterPackageNames = new Set(uiStack_1.UI_STACK_ADAPTER_PACKAGE_NAMES);
+    for (const [packageName, specifier] of Object.entries(currentHarmonyRootPackage.dependencies ?? {})) {
+        if (typeof specifier !== 'string') {
+            continue;
+        }
+        if (validatedAdapterPackageNames.has(packageName)) {
+            continue;
+        }
+        preservedDependencies[packageName] = specifier;
+    }
+    return preservedDependencies;
+}
+async function resolveHarmonyAdapterHarDependency(projectRoot, adapterPackageName) {
+    const adapterEntry = uiStack_1.UI_STACK_VALIDATED_ADAPTERS.find((candidate) => candidate.adapterPackageName === adapterPackageName);
+    if (!adapterEntry) {
+        return null;
+    }
+    const adapterRoot = path_1.default.join(projectRoot, 'node_modules', ...adapterPackageName.split('/'));
+    const harPath = path_1.default.join(adapterRoot, 'harmony', adapterEntry.harmonyHarFileName);
+    if (!(await fs_extra_1.default.pathExists(harPath))) {
+        return null;
+    }
+    const relativeHarPath = path_1.default.relative(path_1.default.join(projectRoot, 'harmony'), harPath).replace(/\\/g, '/');
+    return `file:${relativeHarPath}`;
+}
+function createEmptyAutolinkingArtifacts(harmonyRootPackageContents, managedAutolinkingEntries) {
+    return {
+        ohPackageContents: harmonyRootPackageContents,
+        etsFactoryContents: injectManagedAutolinkingIntoEtsFactory(`/*
+ * This file was generated by Expo Harmony Toolkit autolinking.
+ * DO NOT modify it manually, your changes WILL be overwritten.
+ */
+import type { RNPackageContext, RNPackage } from '@rnoh/react-native-openharmony';
+
+export function createRNOHPackages(_ctx: RNPackageContext): RNPackage[] {
+  return [];
+}
+`, managedAutolinkingEntries),
+        cppFactoryContents: injectManagedAutolinkingIntoCppFactory(`/*
+ * This file was generated by Expo Harmony Toolkit autolinking.
+ * DO NOT modify it manually, your changes WILL be overwritten.
+ */
+#pragma once
+#include "RNOH/Package.h"
+
+std::vector<rnoh::Package::Shared> createRNOHPackages(const rnoh::Package::Context &_ctx) {
+  return {};
+}
+`, managedAutolinkingEntries),
+        cmakeContents: injectManagedAutolinkingIntoCmake(`# This file was generated by Expo Harmony Toolkit autolinking.
+# DO NOT modify it manually, your changes WILL be overwritten.
+cmake_minimum_required(VERSION 3.5)
+
+function(autolink_libraries target)
+  set(AUTOLINKED_LIBRARIES
+  )
+
+  foreach(lib \${AUTOLINKED_LIBRARIES})
+    target_link_libraries(\${target} PUBLIC \${lib})
+  endforeach()
+endfunction()
+`, managedAutolinkingEntries),
+    };
+}
+function resolveProjectPackageJson(projectRoot, request) {
+    const directPackageJsonPath = path_1.default.join(projectRoot, 'node_modules', ...request.split('/'), 'package.json');
+    if (fs_extra_1.default.existsSync(directPackageJsonPath)) {
+        return directPackageJsonPath;
+    }
+    try {
+        return require.resolve(path_1.default.join(request, 'package.json'), {
+            paths: [projectRoot],
+        });
+    }
+    catch {
+        return null;
+    }
+}
+function sortRecordByKey(record) {
+    return Object.fromEntries(Object.entries(record).sort(([left], [right]) => left.localeCompare(right)));
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+function getErrorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/build/core/build/commands.d.ts

@@ -0,0 +1,19 @@
+import { buildEnvReport } from '../env';
+export interface CommandRunnerResult {
+    exitCode: number;
+    stdout: string;
+    stderr: string;
+}
+export type CommandRunner = (file: string, args: string[], options: {
+    cwd: string;
+    env: NodeJS.ProcessEnv;
+}) => Promise<CommandRunnerResult>;
+export declare function buildInvocation(file: string, args: string[]): {
+    file: string;
+    args: string[];
+};
+export declare function createHarmonyBuildEnvironment(runtimeEnv: NodeJS.ProcessEnv, envReport: Awaited<ReturnType<typeof buildEnvReport>>): NodeJS.ProcessEnv;
+export declare function defaultCommandRunner(file: string, args: string[], options: {
+    cwd: string;
+    env: NodeJS.ProcessEnv;
+}): Promise<CommandRunnerResult>;

package/build/core/build/commands.js

@@ -0,0 +1,61 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildInvocation = buildInvocation;
+exports.createHarmonyBuildEnvironment = createHarmonyBuildEnvironment;
+exports.defaultCommandRunner = defaultCommandRunner;
+const node_child_process_1 = require("node:child_process");
+const path_1 = __importDefault(require("path"));
+const node_util_1 = require("node:util");
+const execFileAsync = (0, node_util_1.promisify)(node_child_process_1.execFile);
+function buildInvocation(file, args) {
+    if (file.endsWith('.js')) {
+        return {
+            file: process.execPath,
+            args: [file, ...args],
+        };
+    }
+    return {
+        file,
+        args,
+    };
+}
+function createHarmonyBuildEnvironment(runtimeEnv, envReport) {
+    const buildEnvironment = {
+        ...runtimeEnv,
+    };
+    if (envReport.sdkRoot) {
+        buildEnvironment.DEVECO_SDK_HOME = envReport.sdkRoot;
+        buildEnvironment.OHOS_BASE_SDK_HOME = envReport.sdkRoot;
+    }
+    if (envReport.devecoStudioPath) {
+        buildEnvironment.NODE_HOME =
+            buildEnvironment.NODE_HOME ??
+                path_1.default.join(envReport.devecoStudioPath, 'Contents', 'tools', 'node');
+    }
+    return buildEnvironment;
+}
+async function defaultCommandRunner(file, args, options) {
+    try {
+        const result = await execFileAsync(file, args, {
+            cwd: options.cwd,
+            env: options.env,
+            maxBuffer: 20 * 1024 * 1024,
+        });
+        return {
+            exitCode: 0,
+            stdout: result.stdout,
+            stderr: result.stderr,
+        };
+    }
+    catch (error) {
+        const failed = error;
+        return {
+            exitCode: typeof failed.code === 'number' ? failed.code : 1,
+            stdout: failed.stdout ?? '',
+            stderr: failed.stderr ?? failed.message ?? '',
+        };
+    }
+}

package/build/core/build/compatibilityShims.d.ts

@@ -0,0 +1 @@
+export declare function ensureNormalizedLocalHarCompatibilityShims(directoryPath: string, packageName: string): Promise<void>;