@expo-harmony/config-plugins 55.0.10-harmony.2 → 55.0.10-harmony.3

package/src/generatedFiles.ts

@@ -0,0 +1,85 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+import { HarmonyConfigPluginError } from './errors';
+import { atomicWrite } from './files';
+import { recordManagedFile, withHarmonyDangerousMod } from './mods';
+import { getHarmonyConfigPlugins, registerHarmonyConfigPlugin } from './ownership';
+import { resolveHarmonyPath } from './paths';
+import type { HarmonyConfigPlugin } from './pluginTypes';
+
+export type HarmonyFileDescriptor
+  = | { source: string; content?: never }
+    | { source?: never; content: string | Uint8Array };
+export type HarmonyFileMap = Record<string, HarmonyFileDescriptor>;
+export interface HarmonyGeneratedFilesOptions {
+  owner: string;
+  files: HarmonyFileMap;
+}
+
+export const withHarmonyGeneratedFiles: HarmonyConfigPlugin<HarmonyGeneratedFilesOptions> = (config, options) => {
+  const { owner, files } = options;
+  if (!files || typeof files !== 'object' || Array.isArray(files)) {
+    throw new HarmonyConfigPluginError('ERR_HARMONY_CONFIG_INVALID', 'Generated files must be a path-to-descriptor map.');
+  }
+
+  const claims = getHarmonyConfigPlugins(config).find(plugin => plugin.owner === owner);
+  const paths = [...new Set([...(claims?.files ?? []), ...Object.keys(files)])];
+  config = registerHarmonyConfigPlugin(config, owner, { ...claims, files: paths });
+
+  return withHarmonyDangerousMod(config, async (mod) => {
+    if (mod.modRequest.introspect) return mod;
+
+    const writes: Array<{ file: string; content: string | Uint8Array }> = [];
+    for (const [relative, input] of Object.entries(files)) {
+      if (!input || typeof input !== 'object'
+        || Object.hasOwn(input, 'source') === Object.hasOwn(input, 'content')) {
+        throw new HarmonyConfigPluginError('ERR_HARMONY_CONFIG_INVALID', `${relative} must define exactly one of source or content.`);
+      }
+
+      const file = await resolveHarmonyPath(mod.modRequest.platformProjectRoot, relative);
+      let content: string | Uint8Array;
+      if (Object.hasOwn(input, 'source')) {
+        if (typeof input.source !== 'string' || !input.source) {
+          throw new HarmonyConfigPluginError('ERR_HARMONY_CONFIG_INVALID', `${relative} source must be a non-empty path.`);
+        }
+
+        const source = path.resolve(mod.modRequest.projectRoot, input.source);
+        content = Uint8Array.from(await fs.promises.readFile(source));
+      } else {
+        if (typeof input.content !== 'string' && !(input.content instanceof Uint8Array)) {
+          throw new HarmonyConfigPluginError('ERR_HARMONY_CONFIG_INVALID', `${relative} content must be a string or Uint8Array.`);
+        }
+
+        content = input.content;
+      }
+
+      writes.push({ file, content });
+    }
+
+    for (const { file, content } of writes) {
+      await atomicWrite(file, content);
+      recordManagedFile(mod, file, owner);
+    }
+
+    return mod;
+  });
+};
+
+export const withRawfile: HarmonyConfigPlugin<HarmonyGeneratedFilesOptions> = (config, { owner, files }) => {
+  if (!files || typeof files !== 'object' || Array.isArray(files)) {
+    throw new HarmonyConfigPluginError('ERR_HARMONY_CONFIG_INVALID', 'Rawfiles must be a path-to-descriptor map.');
+  }
+
+  const prefix = 'entry/src/main/resources/rawfile/';
+  const output: HarmonyFileMap = {};
+  for (const [relative, input] of Object.entries(files)) {
+    if (!relative || relative.includes('\\') || relative.split('/').some(part => !part || part === '.' || part === '..')) {
+      throw new HarmonyConfigPluginError('ERR_HARMONY_PATH_ESCAPE', `Invalid rawfile path: ${relative}`);
+    }
+
+    output[prefix + relative] = input;
+  }
+
+  return withHarmonyGeneratedFiles(config, { owner, files: output });
+};

package/src/index.ts

@@ -1,20 +1,26 @@
 export { defineExpoHarmonyConfig } from './config';
+export { createRunOncePlugin, withPlugins, withRunOnce, withStaticPlugin } from './composition';
+export type { HarmonyPluginReference, HarmonyStaticPlugin } from './composition';
+export { compileHarmonyModsAsync } from './compiler';
+export type { HarmonyCompileOptions } from './compiler';
+export { createHarmonyFileMod, withHarmonyJsonFile } from './customFiles';
+export type { HarmonyFileModOptions, HarmonyJsonFileOptions } from './customFiles';
 export type {
   ExpoConfigWithHarmony,
   ExpoHarmonyPlatform,
   ExpoKnownPlatform,
   HarmonyConfig,
   HarmonyDeviceType,
-  HarmonyFont,
-  HarmonyFontDefinition,
   HarmonyOrientation,
   HarmonyPermission,
   HarmonyPlatform,
   HarmonySkill,
+  HarmonySkillUri,
 } from './config';
 export { HarmonyConfigPluginError } from './errors';
+export type { HarmonyConfigPluginErrorOptions } from './errors';
 export { atomicWrite, stableJson as stableHarmonyJson } from './files';
-export { HarmonySdkVersions, normalizeHarmonyConfig } from './normalizeConfig';
+export { normalizeHarmonyConfig } from './normalizeConfig';
 export type { HarmonyExpoConfig, NormalizedHarmonyConfig } from './normalizeConfig';
 export {
   HarmonyModNames as HARMONY_MOD_NAMES,
@@ -22,7 +28,6 @@ export {
   withAppJson,
   withArkTSPackageProvider,
   withCMakeLists,
-  withCngManifest,
   withColors,
   withCppPackageProvider,
   withEntryAbility,
@@ -38,7 +43,6 @@ export {
   withIndexPage,
   withMedia,
   withModuleJson,
-  withNativeInputsStamp,
   withProfiles,
   withProjectBuildProfile,
   withReactNativeConfig,
@@ -51,15 +55,10 @@ export type {
   HarmonyJson,
   HarmonyMediaDescriptor,
   HarmonyMediaMap,
-  HarmonyModAction,
   HarmonyModName,
   HarmonyResourceMap,
 } from './mods';
-export {
-  getHarmonyConfigPlugins,
-  normalizeHarmonyConfigPlugins,
-  registerHarmonyConfigPlugin,
-} from './ownership';
+export { registerHarmonyConfigPlugin } from './ownership';
 export type { HarmonyConfigPluginOwnership } from './ownership';
 export { HarmonyPaths } from './paths';
 export type {
@@ -69,3 +68,12 @@ export type {
   HarmonyProjectPaths,
   HarmonyResourcePaths,
 } from './paths';
+
+export type { HarmonyConfigPlugin, HarmonyModAction, HarmonyModConfig } from './pluginTypes';
+export * as HarmonyManifest from './manifest';
+export * as HarmonyResources from './resources';
+export type { HarmonyAbility, HarmonyExtensionAbility, HarmonyMetadata, HarmonyModule, HarmonyModuleJson } from './manifest';
+export type { HarmonyResourceFile, HarmonyResourceItem } from './resources';
+export { withHarmonyGeneratedFiles, withRawfile } from './generatedFiles';
+export type { HarmonyFileDescriptor, HarmonyFileMap, HarmonyGeneratedFilesOptions } from './generatedFiles';
+export { HarmonyPermissions, withHarmonyPermissions } from './permissions';

package/src/internal.ts

@@ -0,0 +1,3 @@
+export { getHarmonyConfigPlugins, normalizeHarmonyConfigPlugins } from './ownership';
+export { withCngManifest, withNativeInputsStamp, withPreparation, withProjectPatch } from './mods';
+export { NativeInputsStampPath } from './paths';

package/src/manifest.ts

@@ -0,0 +1,151 @@
+import type { HarmonyPermission, HarmonySkill } from './config';
+import { HarmonyConfigPluginError } from './errors';
+import { stableJson } from './files';
+
+export interface HarmonyMetadata extends Record<string, unknown> {
+  name: string;
+  value?: string;
+  resource?: string;
+}
+
+export interface HarmonyAbility extends Record<string, unknown> {
+  name: string;
+  srcEntry?: string;
+  exported?: boolean;
+  skills?: HarmonySkill[];
+  backgroundModes?: string[];
+  metadata?: HarmonyMetadata[];
+}
+
+export interface HarmonyExtensionAbility extends HarmonyAbility {
+  type: string;
+}
+
+export interface HarmonyModule extends Record<string, unknown> {
+  name?: string;
+  mainElement?: string;
+  abilities?: HarmonyAbility[];
+  extensionAbilities?: HarmonyExtensionAbility[];
+  metadata?: HarmonyMetadata[];
+  requestPermissions?: HarmonyPermission[];
+  querySchemes?: string[];
+}
+
+export interface HarmonyModuleJson extends Record<string, unknown> {
+  module?: HarmonyModule;
+}
+
+export function getModuleOrThrow(manifest: HarmonyModuleJson): HarmonyModule {
+  const module = manifest.module;
+  if (!module || typeof module !== 'object' || Array.isArray(module)) {
+    throw new HarmonyConfigPluginError(
+      'ERR_HARMONY_MANIFEST_INVALID',
+      'Harmony module.json5 must contain a module object.',
+      { operation: 'edit-manifest' }
+    );
+  }
+
+  return module;
+}
+
+export function getMainAbilityOrThrow(manifest: HarmonyModuleJson, name?: string): HarmonyAbility {
+  const module = getModuleOrThrow(manifest);
+  const abilities = module.abilities;
+  if (!Array.isArray(abilities)) {
+    throw new HarmonyConfigPluginError(
+      'ERR_HARMONY_MANIFEST_INVALID',
+      'Harmony module.json5 must declare an abilities array.',
+      { operation: 'edit-manifest' }
+    );
+  }
+
+  const selected = name ?? module.mainElement ?? abilities[0]?.name;
+  const matches = abilities.filter(ability => ability && typeof ability.name === 'string' && ability.name === selected);
+  if (matches.length !== 1) {
+    throw new HarmonyConfigPluginError(
+      'ERR_HARMONY_MANIFEST_INVALID',
+      `Expected exactly one Harmony Ability '${selected ?? ''}', found ${matches.length}.`,
+      { operation: 'edit-manifest' }
+    );
+  }
+
+  return matches[0];
+}
+
+export function setMetadata(target: { metadata?: HarmonyMetadata[] }, item: HarmonyMetadata): void {
+  if (!item || typeof item.name !== 'string' || !item.name.trim()) {
+    throw new HarmonyConfigPluginError(
+      'ERR_HARMONY_MANIFEST_INVALID',
+      'Metadata must have a non-empty name.',
+      { operation: 'edit-manifest' }
+    );
+  }
+  if (target.metadata !== undefined && !Array.isArray(target.metadata)) {
+    throw new HarmonyConfigPluginError(
+      'ERR_HARMONY_MANIFEST_INVALID',
+      'metadata must be an array.',
+      { operation: 'edit-manifest' }
+    );
+  }
+
+  const items = target.metadata ?? [];
+  const existing = items.find(value => value?.name === item.name);
+  target.metadata = [...items.filter(value => value?.name !== item.name), { ...existing, ...item }];
+}
+
+export function removeMetadata(target: { metadata?: HarmonyMetadata[] }, name: string): void {
+  if (target.metadata !== undefined && !Array.isArray(target.metadata)) {
+    throw new HarmonyConfigPluginError(
+      'ERR_HARMONY_MANIFEST_INVALID',
+      'metadata must be an array.',
+      { operation: 'edit-manifest' }
+    );
+  }
+
+  if (target.metadata) target.metadata = target.metadata.filter(item => item?.name !== name);
+}
+
+export function ensureExtensionAbility(manifest: HarmonyModuleJson, ability: HarmonyExtensionAbility): void {
+  if (!ability || typeof ability.name !== 'string' || !ability.name.trim()
+    || typeof ability.type !== 'string' || !ability.type.trim()) {
+    throw new HarmonyConfigPluginError(
+      'ERR_HARMONY_MANIFEST_INVALID',
+      'An extension Ability must have a non-empty name and type.',
+      { operation: 'edit-manifest' }
+    );
+  }
+
+  const module = getModuleOrThrow(manifest);
+  if (module.extensionAbilities !== undefined && !Array.isArray(module.extensionAbilities)) {
+    throw new HarmonyConfigPluginError(
+      'ERR_HARMONY_MANIFEST_INVALID',
+      'module.extensionAbilities must be an array.',
+      { operation: 'edit-manifest' }
+    );
+  }
+
+  const abilities = module.extensionAbilities ?? [];
+  const matches = abilities.filter(value => value?.name === ability.name);
+  if (matches.length > 1) {
+    throw new HarmonyConfigPluginError(
+      'ERR_HARMONY_MANIFEST_INVALID',
+      `Harmony module declares ${ability.name} more than once.`,
+      { operation: 'edit-manifest' }
+    );
+  }
+  if (matches.length === 1) {
+    for (const [key, value] of Object.entries(ability)) {
+      if (stableJson(matches[0][key]) !== stableJson(value)) {
+        throw new HarmonyConfigPluginError(
+          'ERR_HARMONY_MANIFEST_INVALID',
+          `Harmony extension Ability '${ability.name}' has an incompatible ${key}.`,
+          { operation: 'edit-manifest' }
+        );
+      }
+    }
+
+    return;
+  }
+
+  module.extensionAbilities = [...abilities, structuredClone(ability)];
+}