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

package/src/native.ts

@@ -0,0 +1,10 @@
+function isRnohAutolinkingDisabled(source: string): boolean {
+  if (typeof source !== 'string' || !source.trim()) {
+    throw new TypeError('module hvigorfile.ts must start from the canonical Harmony template source.');
+  }
+  return /\bautolinking\s*:\s*null\b/u.test(source.replace(/\r\n?/gu, '\n'));
+}
+
+export {
+  isRnohAutolinkingDisabled,
+};

package/src/packageMetadata.ts

@@ -0,0 +1,8 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+const PackageMetadata = JSON.parse(
+  fs.readFileSync(path.join(__dirname, '../package.json'), 'utf8')
+) as Readonly<{ name: string; version: string }>;
+
+export { PackageMetadata };

package/src/plugin.ts

@@ -0,0 +1,7 @@
+import { createRunOncePlugin } from '@expo/config-plugins';
+
+import { PackageMetadata } from './packageMetadata';
+import { withHarmonyPrebuildConfig } from './withHarmonyPrebuildConfig';
+
+export const HarmonyPrebuildPlugin
+  = createRunOncePlugin(withHarmonyPrebuildConfig, PackageMetadata.name, PackageMetadata.version);

package/src/reconcile.ts

@@ -0,0 +1,70 @@
+import { stableHarmonyJson } from '@expo-harmony/config-plugins';
+
+import { HarmonyPrebuildError } from './errors';
+
+function readRecord(value: unknown): Record<string, unknown> {
+  return value !== null && typeof value === 'object' && !Array.isArray(value) ? value as Record<string, unknown> : {};
+}
+
+function appendUnique(items, values) {
+  return [...new Map([...(items || []), ...values].map(value => [stableHarmonyJson(value), value])).values()];
+}
+
+function upsertNamed(items, name, create) {
+  const values = Array.isArray(items) ? items : [];
+  const existing = values.find(item => item?.name === name);
+  const remaining = values.filter(item => item?.name !== name);
+
+  remaining.push(create(existing && typeof existing === 'object' ? existing : {}));
+
+  return remaining;
+}
+
+function upsertManagedNamed(items, name, previousName, placeholderName, create, field) {
+  const values = Array.isArray(items) ? items : [];
+  const previous = typeof previousName === 'string' && previousName ? previousName : placeholderName;
+  const named = values.filter(item => item?.name === name);
+  const stale = values.filter(item => item?.name === previous);
+
+  if (named.length > 1 || stale.length > 1) {
+    throw new HarmonyPrebuildError(
+      'ERR_HARMONY_IDENTITY_COLLISION',
+      `Harmony ${field} identity is ambiguous because its profile contains duplicate named entries.`,
+      { operation: 'reconcile-identity' }
+    );
+  }
+  if (name !== previous && named.length > 0) {
+    throw new HarmonyPrebuildError(
+      'ERR_HARMONY_IDENTITY_COLLISION',
+      `Cannot rename the managed Harmony ${field} from '${previous}' to '${name}' because '${name}' is already user-owned.`,
+      { operation: 'reconcile-identity' }
+    );
+  }
+
+  const names = new Set([name, previous]);
+  const index = values.findIndex(item => names.has(item?.name));
+  const existing = index === -1 ? undefined : values[index];
+  const next = create(existing && typeof existing === 'object' ? existing : {});
+
+  if (index === -1) return [...values, next];
+
+  return values.map((item, current) => current === index ? next : item);
+}
+
+function replaceManagedString(items, value, previousValue, placeholderValue) {
+  const previous = typeof previousValue === 'string' && previousValue ? previousValue : placeholderValue;
+
+  return [...new Set(
+    (Array.isArray(items) ? items : [])
+      .filter(item => item !== value && item !== previous)
+      .concat(value)
+  )];
+}
+
+export {
+  appendUnique,
+  readRecord,
+  replaceManagedString,
+  upsertManagedNamed,
+  upsertNamed,
+};

package/src/renderers.ts

@@ -0,0 +1,90 @@
+import { isRnohAutolinkingDisabled } from './native';
+import type { HarmonyBuildDescriptor } from './buildDescriptor';
+import { TEMPLATE_PLACEHOLDERS } from './template';
+
+function normalizeSource(source, label) {
+  if (typeof source !== 'string' || !source.trim()) {
+    throw new TypeError(`${label} must start from the canonical Harmony template source.`);
+  }
+  return source.replace(/\r\n?/gu, '\n');
+}
+
+function replacePlaceholder(source, placeholder, value, label) {
+  const count = source.split(placeholder).length - 1;
+
+  if (count !== 1) {
+    throw new TypeError(
+      `Canonical Harmony template has ${count} ${label} placeholders; expected exactly one.`
+    );
+  }
+
+  return source.replace(placeholder, () => value);
+}
+
+function quoteSingle(value) {
+  return `'${String(value)
+    .replace(/\\/gu, '\\\\')
+    .replace(/'/gu, `\\'`)
+    .replace(/\r/gu, '\\r')
+    .replace(/\n/gu, '\\n')}'`;
+}
+
+function renderReactNativeConfig() {
+  return `// Generated by @expo-harmony/prebuild-config. Customize through withReactNativeConfig.
+// React Native CLI loads this generated JavaScript file through CommonJS.
+module.exports = require('@react-native-oh/react-native-harmony-cli/react-native.config.js');
+`;
+}
+
+function renderRootHvigor(source, build: HarmonyBuildDescriptor) {
+  source = normalizeSource(source, build.projectFiles.rootHvigor);
+
+  return replacePlaceholder(
+    source,
+    quoteSingle(TEMPLATE_PLACEHOLDERS.bundlePath),
+    quoteSingle(build.export.bundle),
+    'embedded bundle path'
+  );
+}
+
+function renderEntryAbility(source, harmony) {
+  source = normalizeSource(source, 'EntryAbility.ets');
+
+  return replacePlaceholder(
+    source,
+    TEMPLATE_PLACEHOLDERS.abilityName,
+    harmony.abilityName,
+    'ability class'
+  );
+}
+
+function renderIndexPage(source, harmony) {
+  source = normalizeSource(source, 'Index.ets');
+
+  return replacePlaceholder(
+    source,
+    JSON.stringify(TEMPLATE_PLACEHOLDERS.appLabel),
+    JSON.stringify(harmony.label),
+    'RN instance name'
+  );
+}
+
+function renderCanonical(source, label) {
+  return normalizeSource(source, label);
+}
+
+const renderArktsPackageProvider = source => renderCanonical(source, 'PackageProvider.ets');
+const renderCmakeLists = source => renderCanonical(source, 'CMakeLists.txt');
+const renderCppPackageProvider = source => renderCanonical(source, 'PackageProvider.cpp');
+
+export {
+  isRnohAutolinkingDisabled,
+  renderArktsPackageProvider,
+  renderCanonical,
+  renderCmakeLists,
+  renderCppPackageProvider,
+  renderEntryAbility,
+  renderIndexPage,
+  renderReactNativeConfig,
+  renderRootHvigor,
+};

package/src/signing.ts

@@ -0,0 +1,251 @@
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+
+import JSON5 from 'json5';
+
+import { HarmonyPlatformDirectory } from './buildDescriptor';
+import { HarmonyPrebuildError } from './errors';
+
+const MaterialFields = [
+  'certpath', 'storePassword', 'keyAlias', 'keyPassword',
+  'profile', 'signAlg', 'storeFile',
+] as const;
+type MaterialField = typeof MaterialFields[number];
+type MaterialPathField = Extract<MaterialField, 'certpath' | 'profile' | 'storeFile'>;
+const MaterialPathFields = new Set<MaterialField>(['certpath', 'profile', 'storeFile']);
+
+interface SigningFile {
+  config: {
+    material: Record<MaterialField, string>;
+    name: string;
+    type: 'HarmonyOS';
+    [key: string]: unknown;
+  };
+  file: string;
+  materialFiles: Partial<Record<MaterialPathField, string>>;
+}
+
+interface HarmonySigningConfig {
+  file: string;
+  materialFiles: Partial<Record<'certpath' | 'profile' | 'storeFile', string>>;
+  name: string;
+  type: 'HarmonyOS';
+}
+
+function isInside(root, target) {
+  const relative = path.relative(root, target);
+  return relative === '' || (!relative.startsWith(`..${path.sep}`) && relative !== '..' && !path.isAbsolute(relative));
+}
+
+function mirrorAbsolutePath(temp, source) {
+  const absolute = path.resolve(source);
+  const parsed = path.parse(absolute);
+  const volume = parsed.root.replace(/[^A-Za-z0-9]+/gu, '') || 'root';
+  const segments = absolute.slice(parsed.root.length).split(path.sep).filter(Boolean);
+
+  return path.join(temp, 'filesystem', volume, ...segments);
+}
+
+function resolveSigningPath(base, reference) {
+  const resolved = path.resolve(base, reference);
+  const mirror = process.env.EXPO_HARMONY_CHECK_MIRROR_ROOT;
+
+  return mirror && path.isAbsolute(reference)
+    ? mirrorAbsolutePath(path.resolve(mirror), resolved)
+    : resolved;
+}
+
+function selectSigningConfig(parsed, file) {
+  const source = parsed?.app?.signingConfigs ?? parsed?.signingConfigs ?? parsed;
+  const candidates = Array.isArray(source) ? source : [source];
+  const configs = candidates.filter(item => item && typeof item === 'object' && !Array.isArray(item));
+
+  if (configs.length !== candidates.length || configs.length === 0) {
+    throw new HarmonyPrebuildError(
+      'ERR_HARMONY_SIGNING_INVALID',
+      'Signing config file must contain a signing config object or a non-empty signingConfigs array.',
+      { file, operation: 'validate-signing' }
+    );
+  }
+
+  const config = configs.find(item => item.name === 'default') || (configs.length === 1 ? configs[0] : null);
+
+  if (!config) {
+    throw new HarmonyPrebuildError(
+      'ERR_HARMONY_SIGNING_INVALID',
+      'Signing config file contains multiple entries but none is named default.',
+      { file, operation: 'validate-signing' }
+    );
+  }
+
+  return config;
+}
+
+async function readSigningConfigFile(root: string, reference: string): Promise<SigningFile> {
+  const file = resolveSigningPath(root, reference);
+  const harmony = path.join(root, HarmonyPlatformDirectory);
+
+  if (isInside(harmony, file)) {
+    throw new HarmonyPrebuildError(
+      'ERR_HARMONY_SIGNING_INVALID',
+      'harmony.signingConfigFile must be outside the generated harmony directory so --clean cannot delete it.',
+      { file, operation: 'validate-signing' }
+    );
+  }
+
+  let content;
+
+  try {
+    const stat = await fs.stat(file);
+    if (!stat.isFile()) {
+      throw new HarmonyPrebuildError(
+        'ERR_HARMONY_SIGNING_INVALID',
+        'Harmony signing config reference must be a regular file.',
+        { file, operation: 'validate-signing' }
+      );
+    }
+
+    content = await fs.readFile(file, 'utf8');
+  } catch (cause) {
+    if (cause?.code === 'ERR_HARMONY_SIGNING_INVALID') return Promise.reject(cause);
+
+    throw new HarmonyPrebuildError(
+      'ERR_HARMONY_SIGNING_INVALID',
+      'Cannot read harmony.signingConfigFile.',
+      { cause, file, operation: 'validate-signing' }
+    );
+  }
+
+  let parsed;
+
+  try {
+    parsed = JSON5.parse(content);
+  } catch (cause) {
+    throw new HarmonyPrebuildError(
+      'ERR_HARMONY_SIGNING_INVALID',
+      'Cannot parse harmony.signingConfigFile as JSON5.',
+      { cause, file, operation: 'validate-signing' }
+    );
+  }
+
+  const config = selectSigningConfig(parsed, file);
+
+  if (typeof config.name !== 'string' || !config.name.trim()) {
+    throw new HarmonyPrebuildError(
+      'ERR_HARMONY_SIGNING_INVALID',
+      'Harmony signing config name must be a non-empty string.',
+      { file, operation: 'validate-signing' }
+    );
+  }
+  if (config.type !== undefined && config.type !== 'HarmonyOS') {
+    throw new HarmonyPrebuildError(
+      'ERR_HARMONY_SIGNING_INVALID',
+      'Harmony signing config type must be HarmonyOS.',
+      { file, operation: 'validate-signing' }
+    );
+  }
+  if (!config.material || typeof config.material !== 'object' || Array.isArray(config.material)) {
+    throw new HarmonyPrebuildError(
+      'ERR_HARMONY_SIGNING_INVALID',
+      'Harmony signing config material must be an object.',
+      { file, operation: 'validate-signing' }
+    );
+  }
+
+  const material = { ...config.material };
+  const files: Partial<Record<MaterialPathField, string>> = {};
+
+  for (const field of MaterialFields) {
+    const value = material[field];
+    if (typeof value !== 'string' || !value.trim()) {
+      throw new HarmonyPrebuildError(
+        'ERR_HARMONY_SIGNING_INVALID',
+        `Harmony signing material field ${field} must be a non-empty string.`,
+        { file, operation: 'validate-signing' }
+      );
+    }
+
+    if (MaterialPathFields.has(field)) {
+      const resolved = resolveSigningPath(path.dirname(file), value);
+
+      if (isInside(harmony, resolved)) {
+        throw new HarmonyPrebuildError(
+          'ERR_HARMONY_SIGNING_INVALID',
+          `Harmony signing material field ${field} must be outside the generated harmony directory so --clean cannot delete it.`,
+          { file, operation: 'validate-signing' }
+        );
+      }
+
+      try {
+        const stat = await fs.stat(resolved);
+        if (!stat.isFile()) {
+          throw new HarmonyPrebuildError(
+            'ERR_HARMONY_SIGNING_INVALID',
+            `Harmony signing material field ${field} must reference a regular file.`,
+            { file, operation: 'validate-signing' }
+          );
+        }
+      } catch (cause) {
+        if (cause?.code === 'ERR_HARMONY_SIGNING_INVALID') return Promise.reject(cause);
+
+        throw new HarmonyPrebuildError(
+          'ERR_HARMONY_SIGNING_INVALID',
+          `Cannot read the file referenced by Harmony signing material field ${field}.`,
+          { cause, file, operation: 'validate-signing' }
+        );
+      }
+
+      const relative = path.relative(harmony, resolved);
+
+      if (!relative || path.isAbsolute(relative)) {
+        throw new HarmonyPrebuildError(
+          'ERR_HARMONY_SIGNING_INVALID',
+          `Harmony signing material field ${field} must be on the same filesystem volume as the project.`,
+          { file, operation: 'validate-signing' }
+        );
+      }
+
+      material[field] = relative.split(path.sep).join('/');
+      files[field as MaterialPathField] = resolved;
+    }
+  }
+
+  if (material.signAlg !== 'SHA256withECDSA') {
+    throw new HarmonyPrebuildError(
+      'ERR_HARMONY_SIGNING_INVALID',
+      'Harmony signing material signAlg must be SHA256withECDSA.',
+      { file, operation: 'validate-signing' }
+    );
+  }
+
+  return {
+    config: {
+      ...config,
+      name: config.name.trim(),
+      type: 'HarmonyOS',
+      material,
+    },
+    file,
+    materialFiles: files,
+  };
+}
+
+async function validateHarmonySigningConfigFile(root: string, reference: string): Promise<HarmonySigningConfig> {
+  const signing = await readSigningConfigFile(root, reference);
+
+  return {
+    file: signing.file,
+    materialFiles: signing.materialFiles,
+    name: signing.config.name,
+    type: signing.config.type,
+  };
+}
+
+export {
+  MaterialFields,
+  readSigningConfigFile,
+  validateHarmonySigningConfigFile,
+};
+export type {
+  HarmonySigningConfig,
+};

package/src/stale.ts

@@ -0,0 +1,103 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+import { resolveHarmonyBuildPath } from './buildDescriptor';
+import { HarmonyPrebuildError } from './errors';
+import { CngManifestPath, validateCngManifest } from './manifest';
+
+async function readPreviousCngManifestAsync(root) {
+  const file = resolveHarmonyBuildPath(root, CngManifestPath);
+
+  let parsed;
+
+  try {
+    parsed = JSON.parse(await fs.promises.readFile(file, 'utf8'));
+  } catch (error) {
+    if (error.code === 'ENOENT' || error instanceof SyntaxError) return null;
+    return Promise.reject(error);
+  }
+
+  return validateCngManifest(parsed, { file });
+}
+
+function findStaleConfigPlugins(manifest, plugins) {
+  const owners = new Set(plugins.map(plugin => plugin.owner));
+
+  return (manifest?.configPlugins || []).filter(plugin => !owners.has(plugin.owner));
+}
+
+async function removeStalePluginFilesAsync(root, manifest, plugins) {
+  const owners = new Set(plugins.map(plugin => plugin.owner));
+  const files = (manifest?.managedFiles || []).filter(descriptor => owners.has(descriptor.owner));
+
+  for (const descriptor of files) {
+    const target = path.join(root, ...descriptor.path.split('/'));
+
+    let stat;
+
+    try {
+      stat = await fs.promises.lstat(target);
+    } catch (cause) {
+      if (cause.code === 'ENOENT') continue;
+      return Promise.reject(cause);
+    }
+
+    if (stat.isDirectory()) {
+      throw new HarmonyPrebuildError(
+        'ERR_HARMONY_MANIFEST_INVALID',
+        `A stale config plugin claims a managed directory instead of a file: ${descriptor.path}`,
+        { file: target, operation: 'remove-stale-plugin-output' }
+      );
+    }
+
+    await fs.promises.rm(target, { force: true });
+  }
+
+  // Keep missing files in the result so a retry also removes their declarations.
+  return files.map(descriptor => descriptor.path);
+}
+
+function removeStaleExtensionAbilities(module, moduleJsonPath: string, files: readonly string[]) {
+  if (!Array.isArray(module.extensionAbilities) || files.length === 0) return module;
+
+  const stale = new Set(files);
+  const directory = path.posix.dirname(moduleJsonPath);
+
+  return {
+    ...module,
+    extensionAbilities: module.extensionAbilities.filter(extension => (
+      typeof extension?.srcEntry !== 'string'
+      || !stale.has(path.posix.join(directory, extension.srcEntry))
+    )),
+  };
+}
+
+function removeStaleResources(results, kind, plugins) {
+  for (const plugin of plugins) {
+    for (const [scope, values] of Object.entries(plugin.resources?.[kind] || {})) {
+      const names = values as readonly string[];
+      const resource = results[scope];
+
+      if (!resource || typeof resource !== 'object') continue;
+
+      if (kind === 'media') {
+        for (const name of Object.keys(resource)) {
+          if (names.includes(path.parse(name).name)) delete resource[name];
+        }
+      } else {
+        const field = kind === 'colors' ? 'color' : 'string';
+        resource[field] = (resource[field] || []).filter(item => !names.includes(item?.name));
+      }
+    }
+  }
+
+  return results;
+}
+
+export {
+  findStaleConfigPlugins,
+  readPreviousCngManifestAsync,
+  removeStaleExtensionAbilities,
+  removeStalePluginFilesAsync,
+  removeStaleResources,
+};