expo-harmony-toolkit 1.7.2 → 1.8.0

package/build/core/build/compatibilityShims.js

@@ -0,0 +1,272 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureNormalizedLocalHarCompatibilityShims = ensureNormalizedLocalHarCompatibilityShims;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+async function ensureNormalizedLocalHarCompatibilityShims(directoryPath, packageName) {
+    if (packageName === '@react-native-oh-tpl/react-native-gesture-handler') {
+        const gestureHandlerPackageHeaderPath = path_1.default.join(directoryPath, 'src', 'main', 'cpp', 'RnohReactNativeHarmonyGestureHandlerPackage.h');
+        const gestureHandlerPackagePath = path_1.default.join(directoryPath, 'src', 'main', 'cpp', 'RnohReactNativeHarmonyGestureHandlerPackage.cpp');
+        const gestureHandlerTurboModulePath = path_1.default.join(directoryPath, 'src', 'main', 'ets', 'rnoh', 'RNGestureHandlerModule.ts');
+        if (await fs_extra_1.default.pathExists(gestureHandlerTurboModulePath)) {
+            const gestureHandlerTurboModuleContents = await fs_extra_1.default.readFile(gestureHandlerTurboModulePath, 'utf8');
+            let nextGestureHandlerTurboModuleContents = gestureHandlerTurboModuleContents;
+            nextGestureHandlerTurboModuleContents = nextGestureHandlerTurboModuleContents.replace(/^import \{ TM \} from ["']@rnoh\/react-native-openharmony\/generated\/ts["'];?\r?\n/m, '');
+            nextGestureHandlerTurboModuleContents = nextGestureHandlerTurboModuleContents.replace(/\s+implements TM\.RNGestureHandlerModule\.Spec/, '');
+            if (nextGestureHandlerTurboModuleContents !== gestureHandlerTurboModuleContents) {
+                await fs_extra_1.default.writeFile(gestureHandlerTurboModulePath, nextGestureHandlerTurboModuleContents);
+            }
+        }
+        const gestureHandlerGeneratedDirectoryPath = path_1.default.join(directoryPath, 'src', 'main', 'cpp', 'generated');
+        await fs_extra_1.default.ensureDir(gestureHandlerGeneratedDirectoryPath);
+        await fs_extra_1.default.writeFile(path_1.default.join(gestureHandlerGeneratedDirectoryPath, 'RNGestureHandlerButtonComponentDescriptor.h'), createGestureHandlerCompatibilityDescriptorHeader('RNGestureHandlerButton'));
+        await fs_extra_1.default.writeFile(path_1.default.join(gestureHandlerGeneratedDirectoryPath, 'RNGestureHandlerRootViewComponentDescriptor.h'), createGestureHandlerCompatibilityDescriptorHeader('RNGestureHandlerRootView'));
+        if (await fs_extra_1.default.pathExists(gestureHandlerPackageHeaderPath)) {
+            const gestureHandlerPackageHeaderContents = await fs_extra_1.default.readFile(gestureHandlerPackageHeaderPath, 'utf8');
+            const nextGestureHandlerPackageHeaderContents = patchGestureHandlerCompatibilityPackageHeader(gestureHandlerPackageHeaderContents);
+            if (nextGestureHandlerPackageHeaderContents !== gestureHandlerPackageHeaderContents) {
+                await fs_extra_1.default.writeFile(gestureHandlerPackageHeaderPath, nextGestureHandlerPackageHeaderContents);
+            }
+        }
+        if (!(await fs_extra_1.default.pathExists(gestureHandlerPackagePath))) {
+            return;
+        }
+        const gestureHandlerPackageContents = await fs_extra_1.default.readFile(gestureHandlerPackagePath, 'utf8');
+        const nextGestureHandlerPackageContents = patchGestureHandlerCompatibilityPackageSource(gestureHandlerPackageContents);
+        if (nextGestureHandlerPackageContents !== gestureHandlerPackageContents) {
+            await fs_extra_1.default.writeFile(gestureHandlerPackagePath, nextGestureHandlerPackageContents);
+        }
+        if (!nextGestureHandlerPackageContents.includes('<react/renderer/debug/SystraceSection.h>')) {
+            return;
+        }
+        const systraceCompatibilityShimPath = path_1.default.join(directoryPath, 'src', 'main', 'cpp', 'react', 'renderer', 'debug', 'SystraceSection.h');
+        await fs_extra_1.default.ensureDir(path_1.default.dirname(systraceCompatibilityShimPath));
+        await fs_extra_1.default.writeFile(systraceCompatibilityShimPath, '#pragma once\n#include <cxxreact/SystraceSection.h>\n');
+        return;
+    }
+    if (packageName === '@react-native-oh-tpl/react-native-reanimated') {
+        const reanimatedCmakeListsPath = path_1.default.join(directoryPath, 'src', 'main', 'cpp', 'CMakeLists.txt');
+        const reanimatedMountHookHeaderPath = path_1.default.join(directoryPath, 'src', 'main', 'cpp', 'Common', 'cpp', 'Fabric', 'ReanimatedMountHook.h');
+        const reanimatedMountHookSourcePath = path_1.default.join(directoryPath, 'src', 'main', 'cpp', 'Common', 'cpp', 'Fabric', 'ReanimatedMountHook.cpp');
+        const nativeReanimatedModuleSourcePath = path_1.default.join(directoryPath, 'src', 'main', 'cpp', 'Common', 'cpp', 'NativeModules', 'NativeReanimatedModule.cpp');
+        if (await fs_extra_1.default.pathExists(reanimatedCmakeListsPath)) {
+            const reanimatedCmakeListsContents = await fs_extra_1.default.readFile(reanimatedCmakeListsPath, 'utf8');
+            if (reanimatedCmakeListsContents.includes('REACT_NATIVE_MINOR_VERSION=72')) {
+                await fs_extra_1.default.writeFile(reanimatedCmakeListsPath, reanimatedCmakeListsContents.replace('REACT_NATIVE_MINOR_VERSION=72', 'REACT_NATIVE_MINOR_VERSION=82'));
+            }
+        }
+        if (await fs_extra_1.default.pathExists(reanimatedMountHookHeaderPath)) {
+            const reanimatedMountHookHeaderContents = await fs_extra_1.default.readFile(reanimatedMountHookHeaderPath, 'utf8');
+            if (reanimatedMountHookHeaderContents.includes('double mountTime) noexcept override;')) {
+                await fs_extra_1.default.writeFile(reanimatedMountHookHeaderPath, reanimatedMountHookHeaderContents.replace('double mountTime) noexcept override;', 'HighResTimeStamp mountTime) noexcept override;'));
+            }
+        }
+        if (await fs_extra_1.default.pathExists(reanimatedMountHookSourcePath)) {
+            const reanimatedMountHookSourceContents = await fs_extra_1.default.readFile(reanimatedMountHookSourcePath, 'utf8');
+            if (reanimatedMountHookSourceContents.includes('double) noexcept {')) {
+                await fs_extra_1.default.writeFile(reanimatedMountHookSourcePath, reanimatedMountHookSourceContents.replace('double) noexcept {', 'HighResTimeStamp) noexcept {'));
+            }
+        }
+        if (await fs_extra_1.default.pathExists(nativeReanimatedModuleSourcePath)) {
+            const nativeReanimatedModuleSourceContents = await fs_extra_1.default.readFile(nativeReanimatedModuleSourcePath, 'utf8');
+            let nextNativeReanimatedModuleSourceContents = nativeReanimatedModuleSourceContents;
+            if (nextNativeReanimatedModuleSourceContents.includes('<react/renderer/core/TraitCast.h>')) {
+                nextNativeReanimatedModuleSourceContents = nextNativeReanimatedModuleSourceContents.replace('<react/renderer/core/TraitCast.h>', '<react/renderer/core/LayoutableShadowNode.h>');
+            }
+            if (nextNativeReanimatedModuleSourceContents.includes('#include <react/utils/CoreFeatures.h>')) {
+                nextNativeReanimatedModuleSourceContents = nextNativeReanimatedModuleSourceContents.replace('#include <react/utils/CoreFeatures.h>\n', '');
+                nextNativeReanimatedModuleSourceContents = nextNativeReanimatedModuleSourceContents.replace('#include <react/utils/CoreFeatures.h>\r\n', '');
+            }
+            if (nextNativeReanimatedModuleSourceContents.includes('traitCast<LayoutableShadowNode const *>(newestCloneOfShadowNode.get())')) {
+                nextNativeReanimatedModuleSourceContents = nextNativeReanimatedModuleSourceContents.replace('traitCast<LayoutableShadowNode const *>(newestCloneOfShadowNode.get())', 'dynamic_cast<LayoutableShadowNode const *>(newestCloneOfShadowNode.get())');
+            }
+            if (nextNativeReanimatedModuleSourceContents.includes('shadowNodeFromValue(rt, shadowNodeWrapper)')) {
+                nextNativeReanimatedModuleSourceContents =
+                    nextNativeReanimatedModuleSourceContents.replace(/auto (\w+) = shadowNodeFromValue\(rt, shadowNodeWrapper\);/g, 'auto $1 = Bridging<std::shared_ptr<const ShadowNode>>::fromJs(rt, shadowNodeWrapper);');
+            }
+            if (nextNativeReanimatedModuleSourceContents.includes('shadowNodeFromValue(rt, shadowNodeValue)')) {
+                nextNativeReanimatedModuleSourceContents =
+                    nextNativeReanimatedModuleSourceContents.replace(/(ShadowNode::Shared|auto) (\w+) = shadowNodeFromValue\(rt, shadowNodeValue\);/g, 'auto $2 = Bridging<std::shared_ptr<const ShadowNode>>::fromJs(rt, shadowNodeValue);');
+            }
+            if (nextNativeReanimatedModuleSourceContents.includes('bool CoreFeatures::useNativeState;')) {
+                nextNativeReanimatedModuleSourceContents = nextNativeReanimatedModuleSourceContents.replace(/#if REACT_NATIVE_MINOR_VERSION >= 73 && defined\(RCT_NEW_ARCH_ENABLED\)\r?\n\/\/ Android can't find the definition of this static field\r?\nbool CoreFeatures::useNativeState;\r?\n#endif\r?\n/m, '');
+            }
+            if (nextNativeReanimatedModuleSourceContents.includes('/* .shouldYield = */ [this]() {')) {
+                nextNativeReanimatedModuleSourceContents =
+                    nextNativeReanimatedModuleSourceContents.replace(/#if REACT_NATIVE_MINOR_VERSION >= 72\r?\n\s*\/\* \.mountSynchronously = \*\/ true,\r?\n#endif\r?\n\s*\/\* \.shouldYield = \*\/ \[this\]\(\) \{\r?\n\s*return propsRegistry_->shouldReanimatedSkipCommit\(\);\r?\n\s*\}/m, '#if REACT_NATIVE_MINOR_VERSION >= 72\n'
+                        + '              /* .mountSynchronously = */ true,\n'
+                        + '#endif\n'
+                        + '              /* .source = */ ShadowTree::CommitSource::Unknown');
+            }
+            if (nextNativeReanimatedModuleSourceContents !== nativeReanimatedModuleSourceContents) {
+                await fs_extra_1.default.writeFile(nativeReanimatedModuleSourcePath, nextNativeReanimatedModuleSourceContents);
+            }
+        }
+        return;
+    }
+    if (packageName !== '@react-native-oh-tpl/react-native-svg') {
+        return;
+    }
+    const svgGeneratedPropsPath = path_1.default.join(directoryPath, 'src', 'main', 'cpp', 'generated', 'react', 'renderer', 'components', 'react_native_svg', 'Props.h');
+    const svgPathComponentInstancePath = path_1.default.join(directoryPath, 'src', 'main', 'cpp', 'componentInstances', 'RNSVGPathComponentInstance.h');
+    const svgImageComponentDescriptorPath = path_1.default.join(directoryPath, 'src', 'main', 'cpp', 'svgImage', 'RNSVGImageComponentDescriptor.h');
+    const svgImageShadowNodePath = path_1.default.join(directoryPath, 'src', 'main', 'cpp', 'svgImage', 'RNSVGImageShadowNode.h');
+    if (await fs_extra_1.default.pathExists(svgGeneratedPropsPath)) {
+        const svgGeneratedPropsContents = await fs_extra_1.default.readFile(svgGeneratedPropsPath, 'utf8');
+        if (svgGeneratedPropsContents.includes('butter::map<std::string, RawValue>')) {
+            await fs_extra_1.default.writeFile(svgGeneratedPropsPath, svgGeneratedPropsContents.replace(/butter::map<std::string, RawValue>/g, 'std::unordered_map<std::string, RawValue>'));
+        }
+    }
+    if (await fs_extra_1.default.pathExists(svgImageComponentDescriptorPath)) {
+        const svgImageComponentDescriptorContents = await fs_extra_1.default.readFile(svgImageComponentDescriptorPath, 'utf8');
+        let nextSvgImageComponentDescriptorContents = svgImageComponentDescriptorContents;
+        if (nextSvgImageComponentDescriptorContents.includes('void adopt(ShadowNode::Unshared const &shadowNode) const override {')) {
+            nextSvgImageComponentDescriptorContents =
+                nextSvgImageComponentDescriptorContents.replace('void adopt(ShadowNode::Unshared const &shadowNode) const override {', 'void adopt(ShadowNode& shadowNode) const override {');
+        }
+        if (nextSvgImageComponentDescriptorContents.includes('auto imageShadowNode = std::static_pointer_cast<RNSVGImageShadowNode>(shadowNode);')) {
+            nextSvgImageComponentDescriptorContents =
+                nextSvgImageComponentDescriptorContents.replace('auto imageShadowNode = std::static_pointer_cast<RNSVGImageShadowNode>(shadowNode);', 'auto& imageShadowNode = static_cast<RNSVGImageShadowNode&>(shadowNode);');
+        }
+        if (nextSvgImageComponentDescriptorContents.includes('imageShadowNode->setImageManager(imageManager_);')) {
+            nextSvgImageComponentDescriptorContents =
+                nextSvgImageComponentDescriptorContents.replace('imageShadowNode->setImageManager(imageManager_);', 'imageShadowNode.setImageManager(imageManager_);');
+        }
+        if (nextSvgImageComponentDescriptorContents !== svgImageComponentDescriptorContents) {
+            await fs_extra_1.default.writeFile(svgImageComponentDescriptorPath, nextSvgImageComponentDescriptorContents);
+        }
+    }
+    if (await fs_extra_1.default.pathExists(svgImageShadowNodePath)) {
+        const svgImageShadowNodeContents = await fs_extra_1.default.readFile(svgImageShadowNodePath, 'utf8');
+        let nextSvgImageShadowNodeContents = svgImageShadowNodeContents;
+        const svgImageShadowNodeNewline = svgImageShadowNodeContents.includes('\r\n') ? '\r\n' : '\n';
+        if (!nextSvgImageShadowNodeContents.includes('#include <react/renderer/core/ShadowNodeFamily.h>')
+            && nextSvgImageShadowNodeContents.includes('#include <react/renderer/components/view/ConcreteViewShadowNode.h>')) {
+            nextSvgImageShadowNodeContents = nextSvgImageShadowNodeContents.replace('#include <react/renderer/components/view/ConcreteViewShadowNode.h>', '#include <react/renderer/components/view/ConcreteViewShadowNode.h>'
+                + `${svgImageShadowNodeNewline}#include <react/renderer/core/ShadowNodeFamily.h>`);
+        }
+        const svgImageInitialStateSignaturePattern = /static RNSVGImageState initialStateData\(ShadowNodeFragment const &fragment,\r?\n\s*ShadowNodeFamilyFragment const &familyFragment,\r?\n\s*ComponentDescriptor const &componentDescriptor\) \{/m;
+        if (svgImageInitialStateSignaturePattern.test(nextSvgImageShadowNodeContents)) {
+            nextSvgImageShadowNodeContents = nextSvgImageShadowNodeContents.replace(svgImageInitialStateSignaturePattern, 'static RNSVGImageState initialStateData(const Props::Shared& /*props*/,'
+                + `${svgImageShadowNodeNewline}`
+                + '                                            const ShadowNodeFamily::Shared& /*family*/,'
+                + `${svgImageShadowNodeNewline}`
+                + '                                            const ComponentDescriptor& /*componentDescriptor*/) {');
+        }
+        if (nextSvgImageShadowNodeContents !== svgImageShadowNodeContents) {
+            await fs_extra_1.default.writeFile(svgImageShadowNodePath, nextSvgImageShadowNodeContents);
+        }
+    }
+    if (!(await fs_extra_1.default.pathExists(svgPathComponentInstancePath))) {
+        return;
+    }
+    const svgPathComponentInstanceContents = await fs_extra_1.default.readFile(svgPathComponentInstancePath, 'utf8');
+    if (!svgPathComponentInstanceContents.includes('Float m_cacheScale;')) {
+        return;
+    }
+    await fs_extra_1.default.writeFile(svgPathComponentInstancePath, svgPathComponentInstanceContents.replace('Float m_cacheScale;', 'facebook::react::Float m_cacheScale;'));
+}
+function createGestureHandlerCompatibilityDescriptorHeader(componentName) {
+    return [
+        '#pragma once',
+        '',
+        '#include <react/renderer/components/view/ConcreteViewShadowNode.h>',
+        '#include <react/renderer/core/ConcreteComponentDescriptor.h>',
+        '',
+        'namespace facebook::react {',
+        '',
+        `inline constexpr char ${componentName}ComponentName[] = "${componentName}";`,
+        '',
+        `using ${componentName}ShadowNode = ConcreteViewShadowNode<${componentName}ComponentName>;`,
+        `using ${componentName}ComponentDescriptor = ConcreteComponentDescriptor<${componentName}ShadowNode>;`,
+        '',
+        '} // namespace facebook::react',
+        '',
+    ].join('\n');
+}
+function patchGestureHandlerCompatibilityPackageHeader(contents) {
+    if (contents.includes('createComponentDescriptorProviders() override;')) {
+        return contents;
+    }
+    return contents.replace('    std::vector<ArkTSMessageHandler::Shared> createArkTSMessageHandlers() override;\n', [
+        '    std::vector<facebook::react::ComponentDescriptorProvider> createComponentDescriptorProviders() override;',
+        '',
+        '    ComponentJSIBinderByString createComponentJSIBinderByName() override;',
+        '',
+        '    std::vector<ArkTSMessageHandler::Shared> createArkTSMessageHandlers() override;',
+    ].join('\n'));
+}
+function patchGestureHandlerCompatibilityPackageSource(contents) {
+    let nextContents = contents;
+    if (!nextContents.includes('#include "RNOHCorePackage/ComponentBinders/ViewComponentJSIBinder.h"')) {
+        nextContents = nextContents.replace('#include "RNOH/RNInstanceCAPI.h"\n', '#include "RNOH/RNInstanceCAPI.h"\n#include "RNOHCorePackage/ComponentBinders/ViewComponentJSIBinder.h"\n');
+    }
+    if (!nextContents.includes('#include "generated/RNGestureHandlerButtonComponentDescriptor.h"')) {
+        nextContents = nextContents.replace('#include "componentInstances/RNGestureHandlerRootViewComponentInstance.h"\n', '#include "componentInstances/RNGestureHandlerRootViewComponentInstance.h"\n#include "generated/RNGestureHandlerButtonComponentDescriptor.h"\n#include "generated/RNGestureHandlerRootViewComponentDescriptor.h"\n');
+    }
+    if (!nextContents.includes('class RNGestureHandlerComponentJSIBinder')) {
+        nextContents = nextContents.replace('using namespace rnoh;\nusing namespace facebook;\n\n', [
+            'using namespace rnoh;',
+            'using namespace facebook;',
+            '',
+            'class RNGestureHandlerComponentJSIBinder : public ViewComponentJSIBinder {',
+            'protected:',
+            '    facebook::jsi::Object createNativeProps(facebook::jsi::Runtime &rt) override {',
+            '        auto nativeProps = ViewComponentJSIBinder::createNativeProps(rt);',
+            '        nativeProps.setProperty(rt, "exclusive", "boolean");',
+            '        nativeProps.setProperty(rt, "foreground", "boolean");',
+            '        nativeProps.setProperty(rt, "borderless", "boolean");',
+            '        nativeProps.setProperty(rt, "enabled", "boolean");',
+            '        nativeProps.setProperty(rt, "rippleColor", "Color");',
+            '        nativeProps.setProperty(rt, "rippleRadius", "number");',
+            '        nativeProps.setProperty(rt, "touchSoundDisabled", "boolean");',
+            '        return nativeProps;',
+            '    }',
+            '',
+            '    facebook::jsi::Object createDirectEventTypes(facebook::jsi::Runtime &rt) override {',
+            '        auto events = ViewComponentJSIBinder::createDirectEventTypes(rt);',
+            '        events.setProperty(rt, "onGestureHandlerEvent", createDirectEvent(rt, "onGestureHandlerEvent"));',
+            '        events.setProperty(',
+            '            rt,',
+            '            "onGestureHandlerStateChange",',
+            '            createDirectEvent(rt, "onGestureHandlerStateChange"));',
+            '        events.setProperty(rt, "topOnGestureHandlerEvent", createDirectEvent(rt, "onGestureHandlerEvent"));',
+            '        events.setProperty(',
+            '            rt,',
+            '            "topOnGestureHandlerStateChange",',
+            '            createDirectEvent(rt, "onGestureHandlerStateChange"));',
+            '        return events;',
+            '    }',
+            '};',
+            '',
+        ].join('\n'));
+    }
+    if (!nextContents.includes('RnohReactNativeHarmonyGestureHandlerPackage::createComponentDescriptorProviders()')) {
+        nextContents = nextContents.replace('EventEmitRequestHandlers RnohReactNativeHarmonyGestureHandlerPackage::createEventEmitRequestHandlers() {\n', [
+            'std::vector<facebook::react::ComponentDescriptorProvider>',
+            'RnohReactNativeHarmonyGestureHandlerPackage::createComponentDescriptorProviders() {',
+            '    return {',
+            '        facebook::react::concreteComponentDescriptorProvider<',
+            '            facebook::react::RNGestureHandlerButtonComponentDescriptor>(),',
+            '        facebook::react::concreteComponentDescriptorProvider<',
+            '            facebook::react::RNGestureHandlerRootViewComponentDescriptor>(),',
+            '    };',
+            '}',
+            '',
+            'ComponentJSIBinderByString',
+            'RnohReactNativeHarmonyGestureHandlerPackage::createComponentJSIBinderByName() {',
+            '    auto componentJSIBinder = std::make_shared<RNGestureHandlerComponentJSIBinder>();',
+            '    return {',
+            '        {"RNGestureHandlerButton", componentJSIBinder},',
+            '        {"RNGestureHandlerRootView", componentJSIBinder},',
+            '    };',
+            '}',
+            '',
+            'EventEmitRequestHandlers RnohReactNativeHarmonyGestureHandlerPackage::createEventEmitRequestHandlers() {',
+        ].join('\n'));
+    }
+    return nextContents;
+}

package/build/core/build/localHar.d.ts

@@ -0,0 +1,13 @@
+export interface NormalizedLocalHarPackage {
+    packageName: string;
+    moduleName: string;
+    directoryPath: string;
+}
+export declare function normalizeLocalHarDependencies(harmonyProjectRoot: string): Promise<{
+    restore: () => Promise<void>;
+    packages: NormalizedLocalHarPackage[];
+}>;
+export declare function ensureHarmonyBuildProfileSupportsNormalizedLocalDeps(harmonyProjectRoot: string, localHarPackages: NormalizedLocalHarPackage[]): Promise<() => Promise<void>>;
+export declare function ensureRnohGeneratedTsShim(harmonyProjectRoot: string): Promise<void>;
+export declare function alignRnohCodegenWithNormalizedLocalPackage(harmonyProjectRoot: string, localHarPackages: NormalizedLocalHarPackage[]): Promise<() => Promise<void>>;
+export declare function findHarmonyArtifacts(harmonyProjectRoot: string): Promise<string[]>;

package/build/core/build/localHar.js

@@ -0,0 +1,337 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeLocalHarDependencies = normalizeLocalHarDependencies;
+exports.ensureHarmonyBuildProfileSupportsNormalizedLocalDeps = ensureHarmonyBuildProfileSupportsNormalizedLocalDeps;
+exports.ensureRnohGeneratedTsShim = ensureRnohGeneratedTsShim;
+exports.alignRnohCodegenWithNormalizedLocalPackage = alignRnohCodegenWithNormalizedLocalPackage;
+exports.findHarmonyArtifacts = findHarmonyArtifacts;
+const node_child_process_1 = require("node:child_process");
+const json5_1 = __importDefault(require("json5"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const node_util_1 = require("node:util");
+const compatibilityShims_1 = require("./compatibilityShims");
+const execFileAsync = (0, node_util_1.promisify)(node_child_process_1.execFile);
+const RNOH_GENERATED_TS_SHIM_RELATIVE_PATH = path_1.default.join('oh_modules', '@rnoh', 'react-native-openharmony', 'ts.ts');
+const RNOH_GENERATED_MODULE_ROOT_RELATIVE_PATH = path_1.default.join('oh_modules', '@rnoh', 'react-native-openharmony');
+const RNOH_NORMALIZED_TS_TARGET_RELATIVE_PATH = path_1.default.join('expo-harmony-local-deps', 'rnoh-react-native-openharmony-react_native_openharmony', 'ts.ts');
+async function normalizeLocalHarDependencies(harmonyProjectRoot) {
+    const packagePaths = [
+        path_1.default.join(harmonyProjectRoot, 'oh-package.json5'),
+        path_1.default.join(harmonyProjectRoot, 'entry', 'oh-package.json5'),
+    ];
+    const extractionRoot = path_1.default.join(harmonyProjectRoot, 'expo-harmony-local-deps');
+    const archiveCache = new Map();
+    const originalContents = new Map();
+    const packagesByDirectoryPath = new Map();
+    await fs_extra_1.default.ensureDir(extractionRoot);
+    for (const packagePath of packagePaths) {
+        if (!(await fs_extra_1.default.pathExists(packagePath))) {
+            continue;
+        }
+        const rawContents = await fs_extra_1.default.readFile(packagePath, 'utf8');
+        const parsed = json5_1.default.parse(rawContents);
+        let didChange = false;
+        for (const sectionName of ['dependencies', 'devDependencies', 'overrides']) {
+            const section = parsed[sectionName];
+            if (!section || typeof section !== 'object' || Array.isArray(section)) {
+                continue;
+            }
+            for (const [packageName, specifier] of Object.entries(section)) {
+                if (typeof specifier !== 'string' || !specifier.startsWith('file:') || !specifier.endsWith('.har')) {
+                    continue;
+                }
+                const archivePath = path_1.default.resolve(harmonyProjectRoot, specifier.slice('file:'.length));
+                const normalizedDirectory = archiveCache.get(archivePath) ??
+                    (await extractHarArchiveToDirectory(archivePath, extractionRoot, packageName));
+                archiveCache.set(archivePath, normalizedDirectory);
+                if (!packagesByDirectoryPath.has(normalizedDirectory)) {
+                    packagesByDirectoryPath.set(normalizedDirectory, await readNormalizedLocalHarPackageMetadata(normalizedDirectory, packageName));
+                }
+                let relativeDirectory = path_1.default.relative(harmonyProjectRoot, normalizedDirectory);
+                if (!relativeDirectory.startsWith('.')) {
+                    relativeDirectory = `./${relativeDirectory}`;
+                }
+                const nextSpecifier = `file:${relativeDirectory.split(path_1.default.sep).join('/')}`;
+                if (nextSpecifier !== specifier) {
+                    section[packageName] = nextSpecifier;
+                    didChange = true;
+                }
+            }
+        }
+        if (didChange) {
+            originalContents.set(packagePath, rawContents);
+            await fs_extra_1.default.writeFile(packagePath, JSON.stringify(parsed, null, 2) + '\n');
+        }
+    }
+    return {
+        packages: [...packagesByDirectoryPath.values()],
+        restore: async () => {
+            for (const [packagePath, rawContents] of originalContents) {
+                await fs_extra_1.default.writeFile(packagePath, rawContents);
+            }
+        },
+    };
+}
+async function extractHarArchiveToDirectory(archivePath, extractionRoot, packageName) {
+    if (!(await fs_extra_1.default.pathExists(archivePath))) {
+        throw new Error(`Local Harmony archive not found: ${archivePath}`);
+    }
+    const destinationPath = path_1.default.join(extractionRoot, `${sanitizePackageName(packageName)}-${path_1.default.basename(archivePath, path_1.default.extname(archivePath))}`);
+    const stagingRoot = await fs_extra_1.default.mkdtemp(path_1.default.join(os_1.default.tmpdir(), 'expo-harmony-har-'));
+    try {
+        await execFileAsync('tar', ['-xzf', archivePath, '-C', stagingRoot], {
+            maxBuffer: 20 * 1024 * 1024,
+        });
+        const packagedRoot = path_1.default.join(stagingRoot, 'package');
+        const sourceRoot = (await fs_extra_1.default.pathExists(path_1.default.join(packagedRoot, 'oh-package.json5')))
+            ? packagedRoot
+            : stagingRoot;
+        if (!(await fs_extra_1.default.pathExists(path_1.default.join(sourceRoot, 'oh-package.json5')))) {
+            throw new Error(`oh-package.json5 not found after extracting ${archivePath}`);
+        }
+        await fs_extra_1.default.remove(destinationPath);
+        await fs_extra_1.default.ensureDir(destinationPath);
+        for (const entryName of await fs_extra_1.default.readdir(sourceRoot)) {
+            await fs_extra_1.default.move(path_1.default.join(sourceRoot, entryName), path_1.default.join(destinationPath, entryName), {
+                overwrite: true,
+            });
+        }
+        await (0, compatibilityShims_1.ensureNormalizedLocalHarCompatibilityShims)(destinationPath, packageName);
+        return destinationPath;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Failed to normalize local Harmony archive ${archivePath}: ${message}`);
+    }
+    finally {
+        await fs_extra_1.default.remove(stagingRoot);
+    }
+}
+function sanitizePackageName(packageName) {
+    return packageName.replace(/[^a-zA-Z0-9._-]+/g, '-').replace(/^-+|-+$/g, '');
+}
+async function readNormalizedLocalHarPackageMetadata(directoryPath, packageName) {
+    await ensureNormalizedLocalHarModuleJson5(directoryPath);
+    const moduleJsonPaths = [
+        path_1.default.join(directoryPath, 'src', 'main', 'module.json5'),
+        path_1.default.join(directoryPath, 'src', 'main', 'module.json'),
+    ];
+    let moduleName = sanitizePackageName(packageName);
+    for (const moduleJsonPath of moduleJsonPaths) {
+        if (!(await fs_extra_1.default.pathExists(moduleJsonPath))) {
+            continue;
+        }
+        try {
+            const parsed = json5_1.default.parse(await fs_extra_1.default.readFile(moduleJsonPath, 'utf8'));
+            if (typeof parsed?.module?.name === 'string' && parsed.module.name.trim().length > 0) {
+                moduleName = parsed.module.name.trim();
+                break;
+            }
+        }
+        catch {
+            // Ignore malformed module metadata and fall back to a sanitized package name.
+        }
+    }
+    return {
+        packageName,
+        moduleName,
+        directoryPath,
+    };
+}
+async function ensureNormalizedLocalHarModuleJson5(directoryPath) {
+    const moduleJson5Path = path_1.default.join(directoryPath, 'src', 'main', 'module.json5');
+    const moduleJsonPath = path_1.default.join(directoryPath, 'src', 'main', 'module.json');
+    const sourcePath = (await fs_extra_1.default.pathExists(moduleJsonPath))
+        ? moduleJsonPath
+        : ((await fs_extra_1.default.pathExists(moduleJson5Path)) ? moduleJson5Path : null);
+    if (!sourcePath) {
+        return;
+    }
+    const parsed = json5_1.default.parse(await fs_extra_1.default.readFile(sourcePath, 'utf8'));
+    const legacyModule = parsed.module && typeof parsed.module === 'object' && !Array.isArray(parsed.module)
+        ? parsed.module
+        : {};
+    const normalizedModule = {
+        name: typeof legacyModule.name === 'string' && legacyModule.name.trim().length > 0
+            ? legacyModule.name.trim()
+            : path_1.default.basename(directoryPath).replace(/[^a-zA-Z0-9]+/g, '_'),
+        type: typeof legacyModule.type === 'string' ? legacyModule.type : 'har',
+        deviceTypes: Array.isArray(legacyModule.deviceTypes) && legacyModule.deviceTypes.length > 0
+            ? legacyModule.deviceTypes
+            : ['default'],
+        installationFree: typeof legacyModule.installationFree === 'boolean' ? legacyModule.installationFree : false,
+    };
+    const passthroughKeys = [
+        'srcEntrance',
+        'srcEntry',
+        'description',
+        'process',
+        'mainElement',
+        'uiSyntax',
+        'metadata',
+        'abilities',
+        'extensionAbilities',
+        'requestPermissions',
+        'definePermissions',
+        'testRunner',
+        'dependencies',
+        'libIsolation',
+        'routerMap',
+        'appStartup',
+        'crossAppSharedConfig',
+    ];
+    for (const key of passthroughKeys) {
+        const value = legacyModule[key];
+        if (value !== undefined) {
+            normalizedModule[key] = value;
+        }
+    }
+    if (typeof legacyModule.virtualMachine === 'string') {
+        normalizedModule.virtualMachine = legacyModule.virtualMachine.includes('ark') ? 'ark' : 'default';
+    }
+    await fs_extra_1.default.writeFile(moduleJson5Path, JSON.stringify({
+        module: normalizedModule,
+    }, null, 2) + '\n');
+}
+async function ensureHarmonyBuildProfileSupportsNormalizedLocalDeps(harmonyProjectRoot, localHarPackages) {
+    if (localHarPackages.length === 0) {
+        return async () => { };
+    }
+    const buildProfilePath = path_1.default.join(harmonyProjectRoot, 'build-profile.json5');
+    if (!(await fs_extra_1.default.pathExists(buildProfilePath))) {
+        return async () => { };
+    }
+    const rawContents = await fs_extra_1.default.readFile(buildProfilePath, 'utf8');
+    const parsed = json5_1.default.parse(rawContents);
+    let didChange = false;
+    const products = Array.isArray(parsed.app?.products) ? parsed.app.products : [];
+    for (const product of products) {
+        let buildOption = product.buildOption;
+        if (!buildOption || typeof buildOption !== 'object' || Array.isArray(buildOption)) {
+            buildOption = {};
+            product.buildOption = buildOption;
+            didChange = true;
+        }
+        let strictMode = buildOption.strictMode;
+        if (!strictMode || typeof strictMode !== 'object' || Array.isArray(strictMode)) {
+            strictMode = {};
+            buildOption.strictMode = strictMode;
+            didChange = true;
+        }
+        if (strictMode.useNormalizedOHMUrl !== true) {
+            strictMode.useNormalizedOHMUrl = true;
+            didChange = true;
+        }
+    }
+    if (!Array.isArray(parsed.modules)) {
+        parsed.modules = [];
+        didChange = true;
+    }
+    for (const localHarPackage of localHarPackages) {
+        let relativeDirectory = path_1.default.relative(harmonyProjectRoot, localHarPackage.directoryPath);
+        relativeDirectory = relativeDirectory.split(path_1.default.sep).join('/');
+        if (!relativeDirectory.startsWith('.')) {
+            relativeDirectory = `./${relativeDirectory}`;
+        }
+        const existingModule = parsed.modules.find((moduleEntry) => {
+            return (moduleEntry?.srcPath === relativeDirectory ||
+                moduleEntry?.name === localHarPackage.moduleName);
+        });
+        if (existingModule) {
+            if (existingModule.srcPath !== relativeDirectory) {
+                existingModule.srcPath = relativeDirectory;
+                didChange = true;
+            }
+            continue;
+        }
+        parsed.modules.push({
+            name: localHarPackage.moduleName,
+            srcPath: relativeDirectory,
+        });
+        didChange = true;
+    }
+    if (!didChange) {
+        return async () => { };
+    }
+    await fs_extra_1.default.writeFile(buildProfilePath, JSON.stringify(parsed, null, 2) + '\n');
+    return async () => {
+        await fs_extra_1.default.writeFile(buildProfilePath, rawContents);
+    };
+}
+async function ensureRnohGeneratedTsShim(harmonyProjectRoot) {
+    const shimPath = path_1.default.join(harmonyProjectRoot, RNOH_GENERATED_TS_SHIM_RELATIVE_PATH);
+    let relativeTarget = path_1.default.relative(path_1.default.dirname(shimPath), path_1.default.join(harmonyProjectRoot, RNOH_NORMALIZED_TS_TARGET_RELATIVE_PATH));
+    relativeTarget = relativeTarget.replace(/\\/g, '/').replace(/\.ts$/, '');
+    if (!relativeTarget.startsWith('.')) {
+        relativeTarget = `./${relativeTarget}`;
+    }
+    await fs_extra_1.default.ensureDir(path_1.default.dirname(shimPath));
+    await fs_extra_1.default.writeFile(shimPath, `export * from '${relativeTarget}';\n`);
+}
+async function alignRnohCodegenWithNormalizedLocalPackage(harmonyProjectRoot, localHarPackages) {
+    const rnohPackage = localHarPackages.find((localPackage) => localPackage.packageName === '@rnoh/react-native-openharmony');
+    if (!rnohPackage) {
+        return async () => { };
+    }
+    const hvigorFilePath = path_1.default.join(harmonyProjectRoot, 'entry', 'hvigorfile.ts');
+    if (!(await fs_extra_1.default.pathExists(hvigorFilePath))) {
+        return async () => { };
+    }
+    const originalHvigorFile = await fs_extra_1.default.readFile(hvigorFilePath, 'utf8');
+    let relativeRnohModulePath = path_1.default.relative(harmonyProjectRoot, rnohPackage.directoryPath);
+    relativeRnohModulePath = relativeRnohModulePath.split(path_1.default.sep).join('/');
+    if (!relativeRnohModulePath.startsWith('.')) {
+        relativeRnohModulePath = `./${relativeRnohModulePath}`;
+    }
+    const updatedHvigorFile = originalHvigorFile.replace(/rnohModulePath:\s*['"][^'"]+['"]/, `rnohModulePath: '${relativeRnohModulePath}'`);
+    if (updatedHvigorFile !== originalHvigorFile) {
+        await fs_extra_1.default.writeFile(hvigorFilePath, updatedHvigorFile);
+    }
+    const generatedModuleRootPath = path_1.default.join(harmonyProjectRoot, RNOH_GENERATED_MODULE_ROOT_RELATIVE_PATH);
+    const backupRootPath = await fs_extra_1.default.mkdtemp(path_1.default.join(os_1.default.tmpdir(), 'expo-harmony-rnoh-module-'));
+    const backupModuleRootPath = path_1.default.join(backupRootPath, 'react-native-openharmony');
+    let movedGeneratedModuleRoot = false;
+    if (await fs_extra_1.default.pathExists(generatedModuleRootPath)) {
+        await fs_extra_1.default.move(generatedModuleRootPath, backupModuleRootPath, { overwrite: true });
+        movedGeneratedModuleRoot = true;
+    }
+    return async () => {
+        if (updatedHvigorFile !== originalHvigorFile) {
+            await fs_extra_1.default.writeFile(hvigorFilePath, originalHvigorFile);
+        }
+        if (movedGeneratedModuleRoot) {
+            await fs_extra_1.default.remove(generatedModuleRootPath);
+            await fs_extra_1.default.ensureDir(path_1.default.dirname(generatedModuleRootPath));
+            await fs_extra_1.default.move(backupModuleRootPath, generatedModuleRootPath, { overwrite: true });
+        }
+        await fs_extra_1.default.remove(backupRootPath);
+    };
+}
+async function findHarmonyArtifacts(harmonyProjectRoot) {
+    const discoveredPaths = [];
+    await walkDirectory(harmonyProjectRoot, async (entryPath) => {
+        if (entryPath.endsWith('.hap') || entryPath.endsWith('.app') || entryPath.endsWith('.hsp')) {
+            discoveredPaths.push(entryPath);
+        }
+    });
+    return discoveredPaths.sort((left, right) => left.localeCompare(right));
+}
+async function walkDirectory(currentPath, visitor) {
+    if (!(await fs_extra_1.default.pathExists(currentPath))) {
+        return;
+    }
+    const entries = await fs_extra_1.default.readdir(currentPath, { withFileTypes: true });
+    for (const entry of entries) {
+        const nextPath = path_1.default.join(currentPath, entry.name);
+        if (entry.isDirectory()) {
+            await walkDirectory(nextPath, visitor);
+            continue;
+        }
+        await visitor(nextPath);
+    }
+}

package/build/core/build/reporting.d.ts

@@ -0,0 +1,19 @@
+import { BlockingIssue, BuildReport, BuildStepReport } from '../../types';
+export declare function renderBuildReport(report: BuildReport): string;
+export declare function getBundleOutputPath(projectRoot: string): string;
+export declare function getAssetsOutputPath(projectRoot: string): string;
+export declare function createBuildReport(input: {
+    projectRoot: string;
+    command: BuildReport['command'];
+    mode: BuildReport['mode'];
+    status: BuildReport['status'];
+    harmonyProjectRoot?: string | null;
+    entryFile: string | null;
+    bundleOutputPath: string | null;
+    assetsDestPath: string | null;
+    artifactPaths: string[];
+    blockingIssues: BlockingIssue[];
+    warnings: string[];
+    steps: BuildStepReport[];
+}): BuildReport;
+export declare function createStepReport(label: string, file: string, args: string[], cwd: string, exitCode: number | null): BuildStepReport;