@expo-harmony/prebuild-config 55.0.0-harmony.1

package/src/mods/withEntryMods.ts

@@ -0,0 +1,332 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+import {
+  getHarmonyConfigPlugins,
+  HarmonyPaths,
+  withColors,
+  withEntryBuildProfile,
+  withEntryHvigor,
+  withEntryOhPackage,
+  withMedia,
+  withModuleJson,
+  withProfiles,
+  withStrings,
+} from '@expo-harmony/config-plugins';
+
+import {
+  createHarmonyBuildDescriptor,
+  HarmonyPlatformDirectory,
+} from '../buildDescriptor';
+import { readTemplateSource, resolveTemplateFile } from '../dependencies';
+import { HarmonyPrebuildError } from '../errors';
+import {
+  appendUnique,
+  readRecord,
+  upsertManagedNamed,
+  upsertNamed,
+} from '../reconcile';
+import * as render from '../renderers';
+import { removeStaleExtensionAbilities, removeStaleResources } from '../stale';
+
+function setResource(items, name, value) {
+  const resources = (Array.isArray(items) ? items : [])
+    .filter(item => item?.name !== name);
+
+  resources.push({ name, value });
+  resources.sort((left, right) => left.name.localeCompare(right.name, 'en'));
+
+  return resources;
+}
+
+function replaceMediaBase(files, base, descriptor?) {
+  for (const name of Object.keys(files)) {
+    if (path.parse(name).name === base) delete files[name];
+  }
+
+  if (descriptor) {
+    files[descriptor.name] = { source: descriptor.source, replaceBase: true };
+  }
+}
+
+function reconcileRuntimeMetadata(items) {
+  const names = new Set([
+    'OPTLazyForEach',
+    'can_preview_text',
+    'halfLeading',
+  ]);
+
+  return (Array.isArray(items) ? items : [])
+    .filter(item => !names.has(item?.name))
+    .concat([
+      { name: 'OPTLazyForEach', value: 'true' },
+      { name: 'can_preview_text', value: 'true' },
+      { name: 'halfLeading', value: 'true' },
+    ]);
+}
+
+function isAbilityValueClaimed(plugins, field, value) {
+  return plugins.some(plugin => plugin.ability?.[field] === value);
+}
+
+function getSourceExtension(value) {
+  const extension = path.extname(value || '').toLowerCase();
+
+  if (!['.png', '.jpg', '.jpeg', '.svg', '.webp'].includes(extension)) {
+    throw new HarmonyPrebuildError(
+      'ERR_HARMONY_CONFIG_INVALID',
+      `Unsupported Harmony icon format: ${extension || '(none)'}`,
+      { file: value, operation: 'render-icons' }
+    );
+  }
+
+  return extension;
+}
+
+function resolveInputFile(root, value) {
+  const file = path.resolve(root, value);
+
+  let stat;
+
+  try {
+    stat = fs.statSync(file);
+  } catch (cause) {
+    throw new HarmonyPrebuildError(
+      'ERR_HARMONY_CONFIG_INVALID',
+      `Harmony input file does not exist: ${file}`,
+      { cause, file, operation: 'render-icons' }
+    );
+  }
+
+  if (!stat.isFile()) {
+    throw new HarmonyPrebuildError(
+      'ERR_HARMONY_CONFIG_INVALID',
+      `Harmony input is not a file: ${file}`,
+      { file, operation: 'render-icons' }
+    );
+  }
+
+  return file;
+}
+
+function withEntryMods(config, harmony) {
+  config = withEntryBuildProfile(config, (mod) => {
+    const build = readRecord(mod.modResults.buildOption);
+    const native = readRecord(build.externalNativeOptions);
+
+    mod.modResults = {
+      ...mod.modResults,
+      apiType: 'stageMode',
+      buildOption: {
+        ...build,
+        externalNativeOptions: {
+          ...native,
+          path: './src/main/cpp/CMakeLists.txt',
+          abiFilters: harmony.abiFilters,
+        },
+      },
+      targets: upsertNamed(
+        upsertNamed(mod.modResults.targets, 'default', existing => ({
+          ...existing,
+          name: 'default',
+          runtimeOS: 'HarmonyOS',
+        })),
+        'ohosTest',
+        existing => ({ ...existing, name: 'ohosTest' })
+      ),
+    };
+
+    return mod;
+  });
+
+  config = withEntryOhPackage(config, (mod) => {
+    mod.modResults = {
+      ...mod.modResults,
+      name: harmony.moduleName,
+      version: harmony.versionName,
+      description: `${harmony.label} Harmony entry module`,
+      license: mod.modResults.license || 'MIT',
+      dependencies: mod.modResults.dependencies || {},
+    };
+
+    return mod;
+  });
+
+  config = withEntryHvigor(config, async (mod) => {
+    const build = createHarmonyBuildDescriptor(harmony, mod._internal?.harmonySigningConfig?.name ?? null);
+    const relative = path.posix.relative(build.harmonyRoot, build.projectFiles.moduleHvigor);
+
+    mod.modResults = render.renderCanonical(
+      await readTemplateSource(relative),
+      build.projectFiles.moduleHvigor
+    );
+
+    return mod;
+  });
+
+  config = withModuleJson(config, (mod) => {
+    const home = {
+      entities: ['entity.system.home'],
+      actions: ['action.system.home'],
+    };
+    const module = removeStaleExtensionAbilities(
+      readRecord(mod.modResults.module),
+      HarmonyPaths.toPosixRelative(
+        mod.modRequest.projectRoot,
+        path.join(mod.modRequest.platformProjectRoot, HarmonyPaths.HARMONY_PATHS.moduleJson)
+      ),
+      mod._internal?.harmonyStalePluginFiles || []
+    );
+    const previous = mod._internal?.harmonyPreviousManagedIdentity;
+    const plugins = getHarmonyConfigPlugins(mod);
+
+    const abilities = upsertManagedNamed(
+      module.abilities,
+      harmony.abilityName,
+      previous?.abilityName,
+      'EntryAbility',
+      existing => ({
+        ...existing,
+        name: harmony.abilityName,
+        srcEntry: './ets/entryability/EntryAbility.ets',
+        description: '$string:expo_harmony_ability_desc',
+        icon: '$media:app_icon',
+        label: '$string:expo_harmony_ability_label',
+        startWindowIcon: isAbilityValueClaimed(
+          plugins,
+          'startWindowIcon',
+          existing.startWindowIcon
+        )
+          ? existing.startWindowIcon
+          : '$media:app_icon',
+        startWindowBackground: isAbilityValueClaimed(
+          plugins,
+          'startWindowBackground',
+          existing.startWindowBackground
+        )
+          ? existing.startWindowBackground
+          : '$color:expo_harmony_start_window_background',
+        exported: true,
+        visible: true,
+        orientation: harmony.nativeOrientation,
+        skills: appendUnique([home], harmony.skills),
+      }),
+      'abilityName'
+    );
+    const metadata = reconcileRuntimeMetadata(module.metadata);
+
+    mod.modResults = {
+      ...mod.modResults,
+      module: {
+        ...module,
+        name: harmony.moduleName,
+        type: 'entry',
+        description: '$string:expo_harmony_module_desc',
+        mainElement: harmony.abilityName,
+        deviceTypes: harmony.deviceTypes,
+        deliveryWithInstall: true,
+        installationFree: false,
+        pages: '$profile:main_pages',
+        requestPermissions: harmony.permissions,
+        querySchemes: harmony.querySchemes,
+        metadata,
+        abilities,
+      },
+    };
+
+    return mod;
+  });
+
+  config = withStrings(config, (mod) => {
+    mod.modResults = removeStaleResources(
+      mod.modResults,
+      'strings',
+      mod._internal?.harmonyStaleConfigPlugins || []
+    );
+    mod.modResults.app ??= {};
+    mod.modResults.entry ??= {};
+
+    mod.modResults.app.string = setResource(
+      mod.modResults.app.string,
+      'app_name',
+      harmony.label
+    );
+
+    let strings = mod.modResults.entry.string || [];
+
+    strings = setResource(
+      strings,
+      'expo_harmony_ability_desc',
+      `${harmony.label} main ability`
+    );
+    strings = setResource(strings, 'expo_harmony_ability_label', harmony.label);
+    strings = setResource(
+      strings,
+      'expo_harmony_module_desc',
+      `${harmony.label} entry module`
+    );
+    mod.modResults.entry.string = strings;
+
+    return mod;
+  });
+
+  config = withColors(config, (mod) => {
+    mod.modResults = removeStaleResources(
+      mod.modResults,
+      'colors',
+      mod._internal?.harmonyStaleConfigPlugins || []
+    );
+    mod.modResults.entry ??= {};
+    mod.modResults.entryDark ??= {};
+
+    mod.modResults.entry.color = setResource(
+      mod.modResults.entry.color,
+      'expo_harmony_start_window_background',
+      harmony.backgroundColor
+    );
+
+    return mod;
+  });
+
+  config = withMedia(config, (mod) => {
+    mod.modResults = removeStaleResources(
+      mod.modResults,
+      'media',
+      mod._internal?.harmonyStaleConfigPlugins || []
+    );
+
+    const icon = harmony.icon
+      ? resolveInputFile(mod.modRequest.projectRoot, harmony.icon)
+      : null;
+    const sources = icon
+      ? { app: icon, entry: icon }
+      : {
+          app: resolveTemplateFile(`${HarmonyPlatformDirectory}/${HarmonyPaths.RESOURCE_PATHS.media.app}/app_icon.svg`),
+          entry: resolveTemplateFile(`${HarmonyPlatformDirectory}/${HarmonyPaths.RESOURCE_PATHS.media.entry}/app_icon.svg`),
+        };
+
+    for (const [scope, source] of Object.entries(sources)) {
+      mod.modResults[scope] ??= {};
+      replaceMediaBase(mod.modResults[scope], 'app_icon', {
+        name: `app_icon${getSourceExtension(source)}`,
+        source,
+      });
+      replaceMediaBase(mod.modResults[scope], 'app_icon_round');
+    }
+
+    return mod;
+  });
+
+  config = withProfiles(config, (mod) => {
+    mod.modResults = {
+      ...mod.modResults,
+      src: appendUnique(mod.modResults.src, ['pages/Index']),
+    };
+
+    return mod;
+  });
+
+  return config;
+}
+
+export { withEntryMods };

package/src/mods/withPreparationMod.ts

@@ -0,0 +1,85 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+import {
+  getHarmonyConfigPlugins,
+  recordManagedFile,
+  withHarmonyDangerousMod,
+} from '@expo-harmony/config-plugins';
+
+import { createHarmonyBuildDescriptor } from '../buildDescriptor';
+import { HarmonyPrebuildError } from '../errors';
+import { ensureGitignoreEntryAsync } from '../generatedFiles';
+import { readSigningConfigFile } from '../signing';
+import {
+  findStaleConfigPlugins,
+  readPreviousCngManifestAsync,
+  removeStalePluginFilesAsync,
+} from '../stale';
+
+function withPreparationMod(config, harmony) {
+  return withHarmonyDangerousMod(config, async (mod) => {
+    const root = mod.modRequest.projectRoot;
+    const platform = mod.modRequest.platformProjectRoot;
+    const manifest = await readPreviousCngManifestAsync(root);
+    const plugins = getHarmonyConfigPlugins(mod);
+    const stale = findStaleConfigPlugins(manifest, plugins);
+
+    mod._internal ??= {};
+    mod._internal.harmonyPreviousSigningConfigName
+      = typeof manifest?.signingConfigName === 'string'
+        ? manifest.signingConfigName
+        : null;
+    mod._internal.harmonyPreviousManagedIdentity
+      = manifest?.managedIdentity && typeof manifest.managedIdentity === 'object'
+        ? manifest.managedIdentity
+        : null;
+    mod._internal.harmonyConfigPlugins = plugins;
+    mod._internal.harmonyStaleConfigPlugins = stale;
+
+    mod._internal.harmonyStalePluginFiles = await removeStalePluginFilesAsync(root, manifest, stale);
+
+    const packed = path.join(platform, 'gitignore');
+    const gitignore = path.join(platform, '.gitignore');
+
+    if (fs.existsSync(packed)) {
+      if (fs.existsSync(gitignore)) {
+        const [source, current] = await Promise.all([
+          fs.promises.readFile(packed),
+          fs.promises.readFile(gitignore),
+        ]);
+
+        if (!source.equals(Uint8Array.from(current))) {
+          throw new HarmonyPrebuildError(
+            'ERR_HARMONY_CONFIG_INVALID',
+            'The packed Harmony gitignore conflicts with an existing harmony/.gitignore.',
+            { file: gitignore, operation: 'restore-gitignore' }
+          );
+        }
+
+        await fs.promises.rm(packed);
+      } else {
+        await fs.promises.rename(packed, gitignore);
+      }
+    }
+
+    const build = createHarmonyBuildDescriptor(harmony, null);
+    const profile = path.posix.relative(build.harmonyRoot, build.projectFiles.projectBuildProfile);
+
+    await ensureGitignoreEntryAsync(gitignore, `/${profile}`);
+    recordManagedFile(mod, gitignore, 'dangerous');
+
+    if (harmony.signingConfigFile) {
+      const signing = await readSigningConfigFile(
+        root,
+        harmony.signingConfigFile
+      );
+
+      mod._internal.harmonySigningConfig = signing.config;
+    }
+
+    return mod;
+  });
+}
+
+export { withPreparationMod };

package/src/mods/withProjectMods.ts

@@ -0,0 +1,258 @@
+import path from 'node:path';
+
+import {
+  withAppJson,
+  withHvigorConfig,
+  withNativeInputsStamp,
+  withProjectBuildProfile,
+  withReactNativeConfig,
+  withRootHvigor,
+  withRootOhPackage,
+} from '@expo-harmony/config-plugins';
+import { loadConfigAsync as loadReactNativeCliConfigAsync } from '@react-native-community/cli-config';
+
+import {
+  createHarmonyBuildDescriptor,
+  harmonyModuleSourcePath,
+  resolveHarmonyBuildPath,
+} from '../buildDescriptor';
+import {
+  readTemplateSource,
+  resolvePackageVersion,
+  resolveRnohHvigorPlugin,
+  toRelativeDependency,
+} from '../dependencies';
+import { HarmonyPrebuildError } from '../errors';
+import { readRecord, replaceManagedString, upsertManagedNamed, upsertNamed } from '../reconcile';
+import * as render from '../renderers';
+
+function hasRnohLinkCommand(config) {
+  const names = new Set((config?.commands || []).map(command => command?.name));
+  return names.has('link-harmony');
+}
+
+async function loadReactNativeConfigAsync(root, file) {
+  try {
+    return await loadReactNativeCliConfigAsync({ projectRoot: root });
+  } catch (cause) {
+    throw new HarmonyPrebuildError(
+      'ERR_HARMONY_CONFIG_INVALID',
+      `Cannot load the existing React Native CLI config: ${file}`,
+      { cause, file, operation: 'react-native-config' }
+    );
+  }
+}
+
+export function withProjectMods(config, harmony) {
+  config = withReactNativeConfig(config, async (mod) => {
+    const root = mod.modRequest.projectRoot;
+    const request = mod.modRequest as typeof mod.modRequest & {
+      modFile: string;
+      modFileExists: boolean;
+    };
+    const file = request.modFile;
+
+    if (request.modFileExists) {
+      if (!hasRnohLinkCommand(await loadReactNativeConfigAsync(root, file))) {
+        throw new HarmonyPrebuildError(
+          'ERR_HARMONY_CONFIG_INVALID',
+          'The React Native CLI config must expose the RNOH link-harmony command.',
+          { file, operation: 'react-native-config' }
+        );
+      }
+
+      return mod;
+    }
+
+    mod.modResults = render.renderReactNativeConfig();
+
+    return mod;
+  });
+
+  config = withAppJson(config, (mod) => {
+    const app = mod.modResults.app && typeof mod.modResults.app === 'object'
+      ? mod.modResults.app
+      : {};
+
+    mod.modResults = {
+      ...mod.modResults,
+      app: {
+        ...app,
+        bundleName: harmony.bundleName,
+        icon: '$media:app_icon',
+        label: '$string:app_name',
+        vendor: harmony.vendor,
+        versionCode: harmony.versionCode,
+        versionName: harmony.versionName,
+      },
+    };
+
+    return mod;
+  });
+
+  config = withProjectBuildProfile(config, (mod) => {
+    const build = createHarmonyBuildDescriptor(
+      harmony,
+      mod._internal?.harmonySigningConfig?.name ?? null
+    );
+    const { moduleName, productName, targetName } = build.identity;
+
+    const profile = mod.modResults;
+    const app = readRecord(profile.app);
+    const signing = mod._internal?.harmonySigningConfig;
+    const previousSigning = mod._internal?.harmonyPreviousSigningConfigName;
+    const previous = mod._internal?.harmonyPreviousManagedIdentity;
+
+    const products = upsertManagedNamed(
+      app.products,
+      productName,
+      previous?.productName,
+      'default',
+      (existing) => {
+        const product = {
+          ...existing,
+          name: productName,
+          compatibleSdkVersion: harmony.compatibleSdkVersionString,
+          targetSdkVersion: harmony.targetSdkVersionString,
+          runtimeOS: 'HarmonyOS',
+          buildOption: { ...(existing.buildOption || {}), nativeCompiler: 'BiSheng' },
+          ...(signing ? { signingConfig: signing.name } : {}),
+        };
+
+        if (!signing && product.signingConfig === previousSigning) {
+          delete product.signingConfig;
+        }
+
+        return product;
+      },
+      'productName'
+    );
+    const modules = upsertManagedNamed(
+      profile.modules,
+      moduleName,
+      previous?.moduleName,
+      'entry',
+      existing => ({
+        ...existing,
+        name: moduleName,
+        srcPath: harmonyModuleSourcePath(build),
+        targets: upsertNamed(existing.targets, targetName, target => ({
+          ...target,
+          name: targetName,
+          applyToProducts: replaceManagedString(
+            target.applyToProducts,
+            productName,
+            previous?.productName,
+            'default'
+          ),
+        })),
+      }),
+      'moduleName'
+    );
+
+    let configs = app.signingConfigs;
+
+    if (signing) {
+      configs = upsertManagedNamed(
+        configs,
+        signing.name,
+        previousSigning,
+        '',
+        () => signing,
+        'signingConfigName'
+      );
+    } else if (previousSigning) {
+      configs = (Array.isArray(configs) ? configs : [])
+        .filter(item => item?.name !== previousSigning);
+    }
+
+    mod.modResults = {
+      ...profile,
+      app: {
+        ...app,
+        products,
+        buildModeSet: upsertNamed(
+          upsertNamed(app.buildModeSet, 'debug', existing => ({ ...existing, name: 'debug' })),
+          'release',
+          existing => ({ ...existing, name: 'release' })
+        ),
+        ...(configs === undefined ? {} : { signingConfigs: configs }),
+      },
+      modules,
+    };
+
+    return mod;
+  });
+
+  config = withRootOhPackage(config, (mod) => {
+    const version = resolvePackageVersion(
+      mod.modRequest.projectRoot,
+      '@react-native-oh/react-native-harmony'
+    );
+    const dependencies = { ...readRecord(mod.modResults.dependencies) };
+    const overrides = { ...readRecord(mod.modResults.overrides) };
+
+    mod.modResults = {
+      ...mod.modResults,
+      name: harmony.bundleName,
+      version: harmony.versionName,
+      license: mod.modResults.license || 'MIT',
+      dependencies: {
+        ...dependencies,
+        '@rnoh/react-native-openharmony': version,
+      },
+      overrides: {
+        ...overrides,
+        '@rnoh/react-native-openharmony': version,
+      },
+    };
+
+    return mod;
+  });
+
+  config = withRootHvigor(config, async (mod) => {
+    const build = createHarmonyBuildDescriptor(
+      harmony,
+      mod._internal?.harmonySigningConfig?.name ?? null
+    );
+    const relative = path.posix.relative(build.harmonyRoot, build.projectFiles.rootHvigor);
+    const source = await readTemplateSource(relative);
+
+    mod.modResults = render.renderRootHvigor(source, build);
+
+    return mod;
+  });
+
+  config = withNativeInputsStamp(config, async (mod) => {
+    const build = createHarmonyBuildDescriptor(harmony, mod._internal?.harmonySigningConfig?.name ?? null);
+    const relative = path.posix.relative(build.harmonyRoot, build.projectFiles.nativeInputsStamp);
+    const source = await readTemplateSource(relative);
+
+    mod.modResults = render.renderCanonical(source, build.projectFiles.nativeInputsStamp);
+
+    return mod;
+  });
+
+  config = withHvigorConfig(config, (mod) => {
+    const root = mod.modRequest.projectRoot;
+    const build = createHarmonyBuildDescriptor(harmony, mod._internal?.harmonySigningConfig?.name ?? null);
+    const directory = path.dirname(resolveHarmonyBuildPath(root, build.projectFiles.hvigorConfig));
+    const plugin = toRelativeDependency(directory, resolveRnohHvigorPlugin(root));
+
+    mod.modResults = {
+      ...mod.modResults,
+      dependencies: {
+        ...readRecord(mod.modResults.dependencies),
+        '@rnoh/hvigor-plugin': plugin,
+      },
+      execution: mod.modResults.execution || {},
+      logging: mod.modResults.logging || {},
+      debugging: mod.modResults.debugging || {},
+      nodeOptions: mod.modResults.nodeOptions || {},
+    };
+
+    return mod;
+  });
+
+  return config;
+}

package/src/mods/withSourceMods.ts

@@ -0,0 +1,32 @@
+import {
+  HarmonyPaths, withArkTSPackageProvider, withCMakeLists, withCppPackageProvider,
+  withEntryAbility, withIndexPage, withWorker,
+} from '@expo-harmony/config-plugins';
+
+import { readTemplateSource } from '../dependencies';
+import * as render from '../renderers';
+
+const SourceMods = [
+  [withEntryAbility, HarmonyPaths.HARMONY_PATHS.entryAbility, render.renderEntryAbility],
+  [withIndexPage, HarmonyPaths.HARMONY_PATHS.indexPage, render.renderIndexPage],
+  [withWorker, HarmonyPaths.HARMONY_PATHS.worker],
+  [withArkTSPackageProvider, HarmonyPaths.HARMONY_PATHS.arktsPackageProvider, render.renderArktsPackageProvider],
+  [withCppPackageProvider, HarmonyPaths.HARMONY_PATHS.cppPackageProvider, render.renderCppPackageProvider],
+  [withCMakeLists, HarmonyPaths.HARMONY_PATHS.cmakeLists, render.renderCmakeLists],
+] as const;
+
+export function withSourceMods(config, harmony) {
+  for (const [plugin, relative, renderer] of SourceMods) {
+    config = plugin(config, async (mod) => {
+      const source = await readTemplateSource(relative);
+
+      mod.modResults = renderer
+        ? renderer(source, harmony)
+        : render.renderCanonical(source, `harmony/${relative}`);
+
+      return mod;
+    });
+  }
+
+  return config;
+}