react-native-update 10.37.15 → 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

@@ -4,6 +4,70 @@ 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,
 }: {
@@ -35,17 +99,15 @@ async function modifyPackageJson({
 }
 
 async function main(): Promise<void> {
-  const version = (await $`git describe --tags --always`.text())
-    .replace('v', '')
-    .trim();
   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();

package/src/__tests__/core.test.ts

@@ -0,0 +1,103 @@
+import { describe, expect, test, mock } from 'bun:test';
+
+// In Bun, top-level imports are cached.
+// We can use mock.module to change the implementation of a module,
+// but if a module has already been executed (like core.ts),
+// re-importing it might not re-run the top-level code unless we use some tricks
+// or run tests in isolation.
+// Actually, bun test runs each file in its own environment usually,
+// BUT if we run multiple test files in one process, they might share the cache.
+const importFreshCore = (cacheKey: string) => import(`../core?${cacheKey}`);
+
+describe('core info parsing', () => {
+  test('should call error when currentVersionInfo is invalid JSON', async () => {
+    const mockError = mock(() => {});
+
+    mock.module('react-native', () => ({
+      Platform: {
+        OS: 'ios',
+        Version: 13,
+      },
+      NativeModules: {
+        Pushy: {
+          currentVersionInfo: '{invalid}',
+          downloadRootDir: '/tmp',
+          packageVersion: '1.0.0',
+          currentVersion: 'hash1',
+          isFirstTime: false,
+          rolledBackVersion: '',
+          buildTime: '2023-01-01',
+          uuid: 'existing-uuid',
+          setLocalHashInfo: mock(() => {}),
+          getLocalHashInfo: mock(() => Promise.resolve('{}')),
+          setUuid: mock(() => {}),
+        },
+      },
+      NativeEventEmitter: class {
+        addListener = mock(() => ({ remove: mock(() => {}) }));
+      },
+    }));
+
+    mock.module('react-native/Libraries/Core/ReactNativeVersion', () => ({
+      version: { major: 0, minor: 73, patch: 0 },
+    }));
+
+    mock.module('nanoid/non-secure', () => ({
+      nanoid: () => 'mock-uuid',
+    }));
+
+    mock.module('../utils', () => ({
+      error: mockError,
+      log: mock(() => {}),
+      emptyModule: {},
+    }));
+
+    // Use a unique query parameter to bypass cache if supported, or just rely on fresh environment per file.
+    // In Bun, you can sometimes use a cache buster if it's dynamic import.
+    await importFreshCore('error');
+
+    expect(mockError).toHaveBeenCalledWith(
+      expect.stringContaining('error_parse_version_info')
+    );
+  });
+
+  test('should not call error when currentVersionInfo is valid JSON', async () => {
+    const mockError = mock(() => {});
+    const mockSetLocalHashInfo = mock(() => {});
+
+    mock.module('react-native', () => ({
+      Platform: {
+        OS: 'ios',
+        Version: 13,
+      },
+      NativeModules: {
+        Pushy: {
+          currentVersionInfo: JSON.stringify({ name: 'v1', debugChannel: true }),
+          downloadRootDir: '/tmp',
+          packageVersion: '1.0.0',
+          currentVersion: 'hash1',
+          isFirstTime: false,
+          rolledBackVersion: '',
+          buildTime: '2023-01-01',
+          uuid: 'existing-uuid',
+          setLocalHashInfo: mockSetLocalHashInfo,
+          getLocalHashInfo: mock(() => Promise.resolve('{}')),
+          setUuid: mock(() => {}),
+        },
+      },
+      NativeEventEmitter: class {
+        addListener = mock(() => ({ remove: mock(() => {}) }));
+      },
+    }));
+
+    mock.module('../utils', () => ({
+      error: mockError,
+      log: mock(() => {}),
+      emptyModule: {},
+    }));
+
+    await importFreshCore('success');
+
+    expect(mockError).not.toHaveBeenCalled();
+  });
+});

package/src/__tests__/setup.ts

@@ -0,0 +1,37 @@
+import { mock } from 'bun:test';
+
+mock.module('react-native', () => {
+  return {
+    Platform: {
+      OS: 'ios',
+      Version: 13,
+    },
+    NativeModules: {
+      Pushy: {
+        currentVersionInfo: '{}',
+        downloadRootDir: '/tmp',
+        packageVersion: '1.0.0',
+        currentVersion: 'hash',
+        isFirstTime: false,
+        rolledBackVersion: '',
+        buildTime: '2023-01-01',
+        uuid: 'uuid',
+        setLocalHashInfo: () => {},
+        getLocalHashInfo: () => Promise.resolve('{}'),
+        setUuid: () => {},
+      },
+    },
+    NativeEventEmitter: class {
+      addListener = () => ({ remove: () => {} });
+      removeAllListeners = () => {};
+    },
+  };
+});
+
+mock.module('../i18n', () => {
+  return {
+    default: {
+      t: (key: string, params?: any) => `${key}${params ? JSON.stringify(params) : ''}`,
+    },
+  };
+});

package/src/__tests__/utils.test.ts

@@ -0,0 +1,36 @@
+import { describe, expect, test, mock } from 'bun:test';
+
+mock.module('react-native', () => {
+  return {
+    Platform: {
+      OS: 'ios',
+    },
+  };
+});
+
+mock.module('../i18n', () => {
+  return {
+    default: {
+      t: (key: string) => key,
+    },
+  };
+});
+
+import { joinUrls } from '../utils';
+
+describe('joinUrls', () => {
+  test('returns undefined when fileName is not provided', () => {
+    expect(joinUrls(['example.com'])).toBeUndefined();
+  });
+
+  test('returns an empty array when paths is empty', () => {
+    expect(joinUrls([], 'file.txt')).toEqual([]);
+  });
+
+  test('maps over paths and prepends https:// with fileName', () => {
+    expect(joinUrls(['example.com', 'test.org'], 'file.txt')).toEqual([
+      'https://example.com/file.txt',
+      'https://test.org/file.txt',
+    ]);
+  });
+});