expo-harmony-toolkit 1.7.2 → 1.7.3

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>;

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[]>;