react-native-update 10.37.13 → 10.37.16

package/scripts/build-harmony-har.js

@@ -0,0 +1,427 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+const projectRoot = path.resolve(__dirname, '..');
+const androidJniDir = path.join(projectRoot, 'android', 'jni');
+const harmonyModuleDir = path.join(projectRoot, 'harmony', 'pushy');
+const harmonyBuildDir = path.join(harmonyModuleDir, 'build');
+const harmonyNativeStageDir = path.join(
+  harmonyModuleDir,
+  'src',
+  'main',
+  'cpp',
+  'android-generated',
+);
+const harmonyNativeStageJniDir = path.join(harmonyNativeStageDir, 'jni');
+const wrapperProjectDir = path.join(projectRoot, 'harmony', 'har-wrapper');
+const defaultOutputPath = path.join(projectRoot, 'harmony', 'pushy.har');
+const wrapperProjectFiles = [
+  'hvigorfile.ts',
+  path.join('hvigor', 'hvigor-config.json5'),
+  'oh-package.json5',
+  path.join('AppScope', 'app.json5'),
+  'build-profile.json5',
+];
+
+const args = parseArgs(process.argv.slice(2));
+const buildMode = normalizeBuildMode(
+  args['build-mode'] || process.env.HARMONY_BUILD_MODE || 'debug',
+);
+const skipInstall =
+  args['skip-install'] || process.env.HARMONY_SKIP_INSTALL === '1';
+const outputDir = args['out-dir']
+  ? path.resolve(projectRoot, args['out-dir'])
+  : process.env.HARMONY_HAR_OUTPUT_DIR
+    ? path.resolve(projectRoot, process.env.HARMONY_HAR_OUTPUT_DIR)
+    : null;
+const outputPath = args['out-file']
+  ? path.resolve(projectRoot, args['out-file'])
+  : process.env.HARMONY_HAR_OUTPUT_PATH
+    ? path.resolve(projectRoot, process.env.HARMONY_HAR_OUTPUT_PATH)
+    : outputDir
+      ? null
+      : defaultOutputPath;
+
+try {
+  main();
+} catch (error) {
+  console.error(error instanceof Error ? error.message : String(error));
+  process.exit(1);
+}
+
+function main() {
+  syncHarmonyNativeSources();
+  let buildError = null;
+
+  try {
+    buildHar();
+  } catch (error) {
+    buildError = error;
+  }
+
+  try {
+    cleanupHarmonyNativeSources();
+  } catch (error) {
+    if (!buildError) {
+      buildError = error;
+    } else {
+      console.warn(
+        `Warning: failed to clean staged Harmony native sources: ${
+          error instanceof Error ? error.message : String(error)
+        }`,
+      );
+    }
+  }
+
+  if (buildError) {
+    throw buildError;
+  }
+}
+
+function buildHar() {
+  ensureWrapperProject();
+
+  const devecoRoots = getDevEcoRoots();
+  const hvigorwPath = resolveBinary('hvigorw', [
+    process.env.HVIGORW_PATH,
+    ...devecoRoots.map((root) =>
+      path.join(root, 'tools', 'hvigor', 'bin', 'hvigorw'),
+    ),
+  ]);
+  const ohpmPath = resolveBinary('ohpm', [
+    process.env.OHPM_PATH,
+    ...devecoRoots.map((root) =>
+      path.join(root, 'tools', 'ohpm', 'bin', 'ohpm'),
+    ),
+  ]);
+
+  if (!hvigorwPath) {
+    fail(
+      'Cannot find hvigorw. Set HVIGORW_PATH or install DevEco Studio.',
+    );
+  }
+
+  if (!ohpmPath) {
+    fail('Cannot find ohpm. Set OHPM_PATH or install DevEco Studio.');
+  }
+
+  const env = {
+    ...process.env,
+  };
+
+  if (!env.DEVECO_SDK_HOME) {
+    const devecoSdkHome = findExistingPath(
+      devecoRoots.map((root) => path.join(root, 'sdk')),
+    );
+    if (devecoSdkHome) {
+      env.DEVECO_SDK_HOME = devecoSdkHome;
+    }
+  }
+
+  if (!env.DEVECO_STUDIO_HOME) {
+    const devecoStudioHome = findExistingPath(devecoRoots);
+    if (devecoStudioHome) {
+      env.DEVECO_STUDIO_HOME = devecoStudioHome;
+    }
+  }
+
+  if (!skipInstall) {
+    runCommand(ohpmPath, ['install'], {
+      cwd: harmonyModuleDir,
+      env,
+      label: 'Install Harmony dependencies',
+    });
+
+    runCommand(ohpmPath, ['install'], {
+      cwd: wrapperProjectDir,
+      env,
+      label: 'Install wrapper project dependencies',
+    });
+  }
+
+  const hvigorArgs = ['assembleHar'];
+  if (buildMode !== 'debug') {
+    hvigorArgs.push('-p', `buildMode=${buildMode}`);
+  }
+
+  runCommand(hvigorwPath, hvigorArgs, {
+    cwd: wrapperProjectDir,
+    env,
+    label: `Build Harmony HAR (${buildMode})`,
+  });
+
+  const harPath = findNewestHar(harmonyBuildDir);
+  if (!harPath) {
+    fail(
+      `Build finished but no .har artifact was found under ${relativeToProject(
+        harmonyBuildDir,
+      )}`,
+    );
+  }
+
+  let finalPath = harPath;
+  if (outputDir || outputPath) {
+    finalPath = outputPath || path.join(outputDir, path.basename(harPath));
+    fs.mkdirSync(path.dirname(finalPath), { recursive: true });
+    fs.copyFileSync(harPath, finalPath);
+  }
+
+  console.log(`HAR package ready: ${finalPath}`);
+}
+
+function syncHarmonyNativeSources() {
+  ensureFileExists(
+    path.join(androidJniDir, 'hpatch.c'),
+    `Missing Android native source: ${relativeToProject(
+      path.join(androidJniDir, 'hpatch.c'),
+    )}`,
+  );
+  ensureFileExists(
+    path.join(androidJniDir, 'hpatch.h'),
+    `Missing Android native source: ${relativeToProject(
+      path.join(androidJniDir, 'hpatch.h'),
+    )}`,
+  );
+  ensureFileExists(
+    path.join(androidJniDir, 'HDiffPatch'),
+    `Missing Android native source directory: ${relativeToProject(
+      path.join(androidJniDir, 'HDiffPatch'),
+    )}`,
+  );
+  ensureFileExists(
+    path.join(androidJniDir, 'lzma', 'C'),
+    `Missing Android native source directory: ${relativeToProject(
+      path.join(androidJniDir, 'lzma', 'C'),
+    )}`,
+  );
+
+  fs.rmSync(harmonyNativeStageDir, { recursive: true, force: true });
+  fs.mkdirSync(path.join(harmonyNativeStageJniDir, 'lzma'), {
+    recursive: true,
+  });
+
+  copyPath(
+    path.join(androidJniDir, 'hpatch.c'),
+    path.join(harmonyNativeStageJniDir, 'hpatch.c'),
+  );
+  copyPath(
+    path.join(androidJniDir, 'hpatch.h'),
+    path.join(harmonyNativeStageJniDir, 'hpatch.h'),
+  );
+  copyPath(
+    path.join(androidJniDir, 'HDiffPatch'),
+    path.join(harmonyNativeStageJniDir, 'HDiffPatch'),
+  );
+  copyPath(
+    path.join(androidJniDir, 'lzma', 'C'),
+    path.join(harmonyNativeStageJniDir, 'lzma', 'C'),
+  );
+}
+
+function cleanupHarmonyNativeSources() {
+  fs.rmSync(harmonyNativeStageDir, { recursive: true, force: true });
+}
+
+function copyPath(sourcePath, targetPath) {
+  const stats = fs.statSync(sourcePath);
+  if (stats.isDirectory()) {
+    fs.cpSync(sourcePath, targetPath, {
+      recursive: true,
+      force: true,
+      filter: (entry) => path.basename(entry) !== '.git',
+    });
+    return;
+  }
+
+  fs.mkdirSync(path.dirname(targetPath), { recursive: true });
+  fs.copyFileSync(sourcePath, targetPath);
+}
+
+function ensureWrapperProject() {
+  wrapperProjectFiles.forEach((relativePath) => {
+    const fullPath = path.join(wrapperProjectDir, relativePath);
+    ensureFileExists(
+      fullPath,
+      `Missing Harmony wrapper file: ${relativeToProject(fullPath)}`,
+    );
+  });
+}
+
+function parseArgs(argv) {
+  const parsed = {};
+
+  for (let index = 0; index < argv.length; index += 1) {
+    const token = argv[index];
+    if (!token.startsWith('--')) {
+      fail(`Unsupported argument: ${token}`);
+    }
+
+    const keyValue = token.slice(2).split('=');
+    const key = keyValue[0];
+    const inlineValue = keyValue.length > 1 ? keyValue.slice(1).join('=') : '';
+
+    if (key === 'skip-install') {
+      parsed[key] = true;
+      continue;
+    }
+
+    const value = inlineValue || argv[index + 1];
+    if (!value || value.startsWith('--')) {
+      fail(`Missing value for --${key}`);
+    }
+
+    parsed[key] = value;
+    if (!inlineValue) {
+      index += 1;
+    }
+  }
+
+  return parsed;
+}
+
+function normalizeBuildMode(value) {
+  const mode = String(value).toLowerCase();
+  if (mode === 'debug' || mode === 'release') {
+    return mode;
+  }
+
+  fail(`Unsupported build mode: ${value}. Use debug or release.`);
+}
+
+function getDevEcoRoots() {
+  const roots = new Set();
+  const envCandidates = [
+    process.env.DEVECO_STUDIO_HOME,
+    process.env.DEVECO_SDK_HOME,
+  ].filter(Boolean);
+
+  envCandidates.forEach((candidate) => {
+    const normalized = normalizeDevEcoRoot(candidate);
+    if (normalized) {
+      roots.add(normalized);
+    }
+  });
+
+  roots.add('/Applications/DevEco-Studio.app/Contents');
+  return Array.from(roots);
+}
+
+function normalizeDevEcoRoot(value) {
+  const resolved = path.resolve(value);
+  const basename = path.basename(resolved);
+
+  if (basename === 'sdk') {
+    return path.dirname(resolved);
+  }
+
+  if (basename === 'Contents') {
+    return resolved;
+  }
+
+  if (resolved.endsWith('.app')) {
+    return path.join(resolved, 'Contents');
+  }
+
+  if (fs.existsSync(path.join(resolved, 'Contents', 'tools'))) {
+    return path.join(resolved, 'Contents');
+  }
+
+  return resolved;
+}
+
+function resolveBinary(name, candidates) {
+  const explicitPath = findExistingPath(candidates);
+  if (explicitPath) {
+    return explicitPath;
+  }
+
+  const whichResult = spawnSync('bash', ['-lc', `command -v ${name}`], {
+    encoding: 'utf8',
+  });
+  if (whichResult.status === 0) {
+    const resolved = whichResult.stdout.trim();
+    if (resolved) {
+      return resolved;
+    }
+  }
+
+  return null;
+}
+
+function findExistingPath(candidates) {
+  for (const candidate of candidates) {
+    if (candidate && fs.existsSync(candidate)) {
+      return candidate;
+    }
+  }
+
+  return null;
+}
+
+function runCommand(command, commandArgs, options) {
+  const { cwd, env, label } = options;
+  console.log(`> ${label}`);
+  console.log(`  ${[command, ...commandArgs].join(' ')}`);
+
+  const result = spawnSync(command, commandArgs, {
+    cwd,
+    env,
+    stdio: 'inherit',
+  });
+
+  if (result.status !== 0) {
+    fail(`${label} failed with exit code ${result.status || 1}.`);
+  }
+}
+
+function findNewestHar(rootDir) {
+  if (!fs.existsSync(rootDir)) {
+    return null;
+  }
+
+  let latestFile = null;
+  let latestMtime = 0;
+  const queue = [rootDir];
+
+  while (queue.length > 0) {
+    const currentDir = queue.pop();
+    const entries = fs.readdirSync(currentDir, { withFileTypes: true });
+
+    for (const entry of entries) {
+      const fullPath = path.join(currentDir, entry.name);
+      if (entry.isDirectory()) {
+        queue.push(fullPath);
+        continue;
+      }
+
+      if (!entry.isFile() || !entry.name.endsWith('.har')) {
+        continue;
+      }
+
+      const stat = fs.statSync(fullPath);
+      if (!latestFile || stat.mtimeMs > latestMtime) {
+        latestFile = fullPath;
+        latestMtime = stat.mtimeMs;
+      }
+    }
+  }
+
+  return latestFile;
+}
+
+function ensureFileExists(filePath, message) {
+  if (!fs.existsSync(filePath)) {
+    fail(message);
+  }
+}
+
+function relativeToProject(filePath) {
+  return path.relative(projectRoot, filePath) || '.';
+}
+
+function fail(message) {
+  throw new Error(message);
+}

package/scripts/prepublish.ts

@@ -0,0 +1,113 @@
+#!/usr/bin/env bun
+
+import { access, readFile, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { $ } from 'bun';
+
+function normalizeVersion(version: string): string {
+  return version.trim().replace(/^refs\/tags\//, '').replace(/^v/, '');
+}
+
+function getVersionFromEnvironment(): string | null {
+  const candidates = [
+    process.env.RELEASE_VERSION,
+    process.env.CI_COMMIT_TAG,
+    process.env.GITHUB_REF_TYPE === 'tag' ? process.env.GITHUB_REF_NAME : null,
+    process.env.GITHUB_REF?.startsWith('refs/tags/')
+      ? process.env.GITHUB_REF
+      : null,
+  ];
+
+  for (const candidate of candidates) {
+    if (candidate?.trim()) {
+      return normalizeVersion(candidate);
+    }
+  }
+
+  return null;
+}
+
+function getShellErrorMessage(error: unknown): string {
+  if (
+    typeof error === 'object' &&
+    error !== null &&
+    'stderr' in error &&
+    typeof error.stderr === 'string' &&
+    error.stderr.trim()
+  ) {
+    return error.stderr.trim();
+  }
+
+  if (error instanceof Error && error.message.trim()) {
+    return error.message.trim();
+  }
+
+  return 'Unknown git error';
+}
+
+async function getVersionFromGit(): Promise<string> {
+  try {
+    return normalizeVersion(await $`git describe --tags --always`.text());
+  } catch (error) {
+    const message = getShellErrorMessage(error);
+
+    if (message.includes('detected dubious ownership')) {
+      throw new Error(
+        'Git refused to read repository metadata because this checkout is not marked as safe. Configure safe.directory in CI or provide RELEASE_VERSION/GITHUB_REF_NAME.',
+        { cause: error },
+      );
+    }
+
+    throw new Error(`Unable to resolve publish version from git: ${message}`, {
+      cause: error,
+    });
+  }
+}
+
+async function resolveVersion(): Promise<string> {
+  return getVersionFromEnvironment() ?? (await getVersionFromGit());
+}
+
+async function modifyPackageJson({
+  version,
+}: {
+  version: string;
+}): Promise<void> {
+  const packageJsonPath = path.join(__dirname, '..', 'package.json');
+
+  try {
+    await access(packageJsonPath);
+  } catch {
+    throw new Error(`package.json not found at ${packageJsonPath}`);
+  }
+
+  console.log('Reading package.json...');
+  const packageJsonContent = await readFile(packageJsonPath, 'utf-8');
+  const packageJson = JSON.parse(packageJsonContent);
+
+  packageJson.version = version;
+
+  console.log('Writing modified package.json...');
+
+  await writeFile(
+    packageJsonPath,
+    JSON.stringify(packageJson, null, 2),
+    'utf-8',
+  );
+
+  console.log('package.json has been modified for publishing');
+}
+
+async function main(): Promise<void> {
+  try {
+    const version = await resolveVersion();
+    console.log(`Using publish version ${version}`);
+    await modifyPackageJson({ version });
+    console.log('✅ Prepublish script completed successfully');
+  } catch (error) {
+    console.error('❌ Prepublish script failed:', error);
+    process.exit(1);
+  }
+}
+
+main();