expo-harmony-toolkit 1.7.1 → 1.7.3

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;

package/build/core/build/reporting.js

@@ -0,0 +1,67 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderBuildReport = renderBuildReport;
+exports.getBundleOutputPath = getBundleOutputPath;
+exports.getAssetsOutputPath = getAssetsOutputPath;
+exports.createBuildReport = createBuildReport;
+exports.createStepReport = createStepReport;
+const path_1 = __importDefault(require("path"));
+const constants_1 = require("../constants");
+function renderBuildReport(report) {
+    const lines = [
+        'Expo Harmony build report',
+        `Project: ${report.projectRoot}`,
+        `Command: ${report.command}`,
+        `Mode: ${report.mode ?? 'n/a'}`,
+        `Status: ${report.status}`,
+        `Harmony project: ${report.harmonyProjectRoot ?? 'not found'}`,
+        `Entry file: ${report.entryFile ?? 'n/a'}`,
+        `Bundle output: ${report.bundleOutputPath ?? 'n/a'}`,
+        `Artifacts: ${report.artifactPaths.join(', ') || 'none'}`,
+        '',
+        'Steps:',
+        ...report.steps.map((step) => `- [${step.exitCode ?? 'n/a'}] ${step.label}: ${step.command} (cwd ${step.cwd})`),
+    ];
+    if (report.blockingIssues.length > 0) {
+        lines.push('', 'Blocking issues:', ...report.blockingIssues.map((issue) => `- ${issue.code}: ${issue.message}${issue.subject ? ` (${issue.subject})` : ''}`));
+    }
+    if (report.warnings.length > 0) {
+        lines.push('', 'Warnings:', ...report.warnings.map((warning) => `- ${warning}`));
+    }
+    return lines.join('\n');
+}
+function getBundleOutputPath(projectRoot) {
+    return path_1.default.join(projectRoot, 'harmony', 'entry', 'src', 'main', 'resources', 'rawfile', 'bundle.harmony.js');
+}
+function getAssetsOutputPath(projectRoot) {
+    return path_1.default.join(projectRoot, 'harmony', 'entry', 'src', 'main', 'resources', 'rawfile', 'assets');
+}
+function createBuildReport(input) {
+    return {
+        generatedAt: new Date().toISOString(),
+        projectRoot: input.projectRoot,
+        toolkitVersion: constants_1.TOOLKIT_VERSION,
+        command: input.command,
+        mode: input.mode,
+        status: input.status,
+        harmonyProjectRoot: input.harmonyProjectRoot ?? path_1.default.join(input.projectRoot, 'harmony'),
+        entryFile: input.entryFile,
+        bundleOutputPath: input.bundleOutputPath,
+        assetsDestPath: input.assetsDestPath,
+        artifactPaths: input.artifactPaths,
+        blockingIssues: input.blockingIssues,
+        warnings: input.warnings,
+        steps: input.steps,
+    };
+}
+function createStepReport(label, file, args, cwd, exitCode) {
+    return {
+        label,
+        command: [file, ...args].join(' '),
+        cwd,
+        exitCode,
+    };
+}

package/build/core/build/rnohCompatibility.d.ts

@@ -0,0 +1 @@
+export declare function normalizeProjectRnohCliAutolinkingTemplates(projectRoot: string): Promise<() => Promise<void>>;

package/build/core/build/rnohCompatibility.js

@@ -0,0 +1,38 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeProjectRnohCliAutolinkingTemplates = normalizeProjectRnohCliAutolinkingTemplates;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+const RNOH_CLI_AUTOLINKING_TEMPLATE_RELATIVE_PATHS = [
+    path_1.default.join('node_modules', '@react-native-oh', 'react-native-harmony-cli', 'dist', 'autolinking', 'Autolinking.js'),
+    path_1.default.join('node_modules', '@react-native-oh', 'react-native-harmony-cli', 'src', 'autolinking', 'Autolinking.ts'),
+];
+async function normalizeProjectRnohCliAutolinkingTemplates(projectRoot) {
+    const originalContentsByPath = new Map();
+    for (const relativePath of RNOH_CLI_AUTOLINKING_TEMPLATE_RELATIVE_PATHS) {
+        const targetPath = path_1.default.join(projectRoot, relativePath);
+        if (!(await fs_extra_1.default.pathExists(targetPath))) {
+            continue;
+        }
+        const currentContents = await fs_extra_1.default.readFile(targetPath, 'utf8');
+        const normalizedContents = normalizeRnohCliAutolinkingTemplateContents(currentContents);
+        if (normalizedContents === currentContents) {
+            continue;
+        }
+        originalContentsByPath.set(targetPath, currentContents);
+        await fs_extra_1.default.writeFile(targetPath, normalizedContents);
+    }
+    return async () => {
+        for (const [targetPath, originalContents] of originalContentsByPath.entries()) {
+            await fs_extra_1.default.writeFile(targetPath, originalContents);
+        }
+    };
+}
+function normalizeRnohCliAutolinkingTemplateContents(contents) {
+    return contents
+        .replace(/import type \{ RNPackageContext, RNOHPackage \} from '@rnoh\/react-native-openharmony';/g, "import type { RNPackageContext, RNPackage } from '@rnoh/react-native-openharmony';")
+        .replace(/export function createRNOHPackages\(ctx: RNPackageContext\): RNOHPackage\[\] \{/g, 'export function createRNOHPackages(ctx: RNPackageContext): RNPackage[] {');
+}

package/build/core/build.d.ts

@@ -1,13 +1,7 @@
-import { BuildReport } from '../types';
-export interface CommandRunnerResult {
-    exitCode: number;
-    stdout: string;
-    stderr: string;
-}
-export type CommandRunner = (file: string, args: string[], options: {
-    cwd: string;
-    env: NodeJS.ProcessEnv;
-}) => Promise<CommandRunnerResult>;
+import type { BuildReport } from '../types';
+import type { CommandRunner } from './build/commands';
+export type { CommandRunner, CommandRunnerResult } from './build/commands';
+export { renderBuildReport } from './build/reporting';
 interface BundleProjectOptions {
     env?: NodeJS.ProcessEnv;
     runner?: CommandRunner;
@@ -20,6 +14,4 @@ interface BuildHapProjectOptions {
 }
 export declare function bundleProject(projectRoot: string, options?: BundleProjectOptions): Promise<BuildReport>;
 export declare function buildHapProject(projectRoot: string, options: BuildHapProjectOptions): Promise<BuildReport>;
-export declare function renderBuildReport(report: BuildReport): string;
 export declare function getDesiredHarmonyScripts(projectRoot: string): Promise<Record<string, string>>;
-export {};