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

package/build/permissions.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HarmonyPermissions = exports.withHarmonyPermissions = void 0;
+exports.mergePermissions = mergePermissions;
+exports.ensurePermissions = ensurePermissions;
+exports.removePermissions = removePermissions;
+const manifest_1 = require("./manifest");
+const mods_1 = require("./mods");
+const normalizeConfig_1 = require("./normalizeConfig");
+function mergePermissions(current, additions) {
+    const result = new Map();
+    for (const input of [...current, ...additions]) {
+        const permission = (0, normalizeConfig_1.normalizePermission)(input);
+        const existing = result.get(permission.name);
+        const scene = existing?.usedScene || permission.usedScene;
+        const abilities = [...new Set([
+                ...(existing?.usedScene?.abilities ?? []),
+                ...(permission.usedScene?.abilities ?? []),
+            ])];
+        result.set(permission.name, {
+            ...existing,
+            ...permission,
+            ...(scene
+                ? {
+                    usedScene: {
+                        ...(abilities.length ? { abilities } : {}),
+                        when: existing?.usedScene?.when === 'always' || permission.usedScene?.when === 'always' ? 'always' : 'inuse',
+                    },
+                }
+                : {}),
+        });
+    }
+    return [...result.values()];
+}
+function ensurePermissions(manifest, permissions) {
+    const module = (0, manifest_1.getModuleOrThrow)(manifest);
+    module.requestPermissions = mergePermissions(module.requestPermissions ?? [], permissions);
+    return manifest;
+}
+function removePermissions(manifest, names) {
+    const module = (0, manifest_1.getModuleOrThrow)(manifest);
+    if (module.requestPermissions) {
+        module.requestPermissions = module.requestPermissions.filter(permission => !names.includes(permission.name));
+    }
+    return manifest;
+}
+const withHarmonyPermissions = (config, permissions) => {
+    const additions = mergePermissions([], permissions);
+    if (config.harmony) {
+        config.harmony = { ...config.harmony, permissions: mergePermissions(config.harmony.permissions ?? [], additions) };
+    }
+    return (0, mods_1.withModuleJson)(config, (mod) => {
+        if (mod.modResults.module === undefined)
+            mod.modResults.module = {};
+        ensurePermissions(mod.modResults, additions);
+        return mod;
+    });
+};
+exports.withHarmonyPermissions = withHarmonyPermissions;
+exports.HarmonyPermissions = Object.freeze({ ensurePermissions, mergePermissions, removePermissions });

package/build/pluginTypes.d.ts

@@ -0,0 +1,15 @@
+import type { ExportedConfigWithProps } from '@expo/config-plugins';
+import type { ExpoConfigWithHarmony, ExpoHarmonyPlatform, HarmonyConfig } from './config';
+export type HarmonyConfigPlugin<Props = void> = <Config extends ExpoConfigWithHarmony>(config: Config, props: Props) => Config;
+export type HarmonyModConfig<T> = Omit<ExportedConfigWithProps<T>, 'platforms' | 'modRawConfig' | 'modRequest'> & {
+    platforms?: ExpoHarmonyPlatform[];
+    harmony?: HarmonyConfig;
+    modRawConfig: ExpoConfigWithHarmony;
+    modRequest: Omit<ExportedConfigWithProps<T>['modRequest'], 'platform' | 'nextMod'> & {
+        platform: 'harmony';
+        nextMod?: HarmonyModAction<T>;
+        modFile?: string;
+        modFileExists?: boolean;
+    };
+};
+export type HarmonyModAction<T = unknown> = (config: HarmonyModConfig<T>) => HarmonyModConfig<T> | Promise<HarmonyModConfig<T>>;

package/build/pluginTypes.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/resources.d.ts

@@ -0,0 +1,13 @@
+export interface HarmonyResourceItem extends Record<string, unknown> {
+    name: string;
+    value: string;
+}
+export interface HarmonyResourceFile extends Record<string, unknown> {
+    string?: HarmonyResourceItem[];
+    color?: HarmonyResourceItem[];
+}
+export declare function setString(file: HarmonyResourceFile, item: HarmonyResourceItem): HarmonyResourceFile;
+export declare function removeString(file: HarmonyResourceFile, name: string): HarmonyResourceFile;
+export declare function setColor(file: HarmonyResourceFile, item: HarmonyResourceItem): HarmonyResourceFile;
+export declare function removeColor(file: HarmonyResourceFile, name: string): HarmonyResourceFile;
+export declare function toArgb(value: string | number): string;

package/build/resources.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setString = setString;
+exports.removeString = removeString;
+exports.setColor = setColor;
+exports.removeColor = removeColor;
+exports.toArgb = toArgb;
+const errors_1 = require("./errors");
+function setItem(file, kind, item) {
+    if (!item || typeof item.name !== 'string' || !/^[A-Za-z0-9_.-]+$/.test(item.name)
+        || item.name.includes('..') || typeof item.value !== 'string') {
+        throw new errors_1.HarmonyConfigPluginError('ERR_HARMONY_RESOURCE_INVALID', `Invalid Harmony ${kind} resource.`, { operation: 'edit-resource' });
+    }
+    const items = readItems(file, kind);
+    const existing = items.find(value => value?.name === item.name);
+    file[kind] = [...items.filter(value => value?.name !== item.name), { ...existing, ...item }];
+    return file;
+}
+function readItems(file, kind) {
+    if (file[kind] !== undefined && !Array.isArray(file[kind])) {
+        throw new errors_1.HarmonyConfigPluginError('ERR_HARMONY_RESOURCE_INVALID', `Harmony ${kind} resources must be an array.`, { operation: 'edit-resource' });
+    }
+    return file[kind] ?? [];
+}
+function setString(file, item) {
+    return setItem(file, 'string', item);
+}
+function removeString(file, name) {
+    const items = readItems(file, 'string');
+    if (file.string)
+        file.string = items.filter(item => item?.name !== name);
+    return file;
+}
+function setColor(file, item) {
+    return setItem(file, 'color', item);
+}
+function removeColor(file, name) {
+    const items = readItems(file, 'color');
+    if (file.color)
+        file.color = items.filter(item => item?.name !== name);
+    return file;
+}
+function toArgb(value) {
+    let hex;
+    if (typeof value === 'number' && Number.isInteger(value) && value >= 0 && value <= 0xffffffff) {
+        hex = value.toString(16).padStart(8, '0');
+    }
+    else if (typeof value === 'string' && /^#[0-9a-f]{6}(?:[0-9a-f]{2})?$/i.test(value)) {
+        hex = value.slice(1);
+    }
+    else {
+        throw new errors_1.HarmonyConfigPluginError('ERR_HARMONY_CONFIG_INVALID', 'Color must be #RRGGBB, #RRGGBBAA or an unsigned RGBA integer.', { operation: 'convert-color' });
+    }
+    return `#${hex.length === 8 ? hex.slice(6, 8) + hex.slice(0, 6) : hex}`.toUpperCase();
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@expo-harmony/config-plugins",
-  "version": "55.0.10-harmony.1",
+  "version": "55.0.10-harmony.3",
   "keywords": [
     "react-native",
     "expo",
@@ -29,12 +29,17 @@
       "require": "./build/index.js",
       "default": "./build/index.js"
     },
-    "./native-inputs": {
+    "./package.json": "./package.json",
+    "./internal": {
+      "types": "./build/internal.d.ts",
+      "require": "./build/internal.js",
+      "default": "./build/internal.js"
+    },
+    "./internal/native-inputs": {
       "types": "./build/nativeInputs.d.ts",
       "require": "./build/nativeInputs.js",
       "default": "./build/nativeInputs.js"
-    },
-    "./package.json": "./package.json"
+    }
   },
   "dependencies": {
     "@expo/config-plugins": "55.0.10",
@@ -44,11 +49,6 @@
   "peerDependencies": {
     "@expo/config": "55.0.17"
   },
-  "peerDependenciesMeta": {
-    "@expo/config": {
-      "optional": true
-    }
-  },
   "devDependencies": {
     "@types/node": "18.19.0",
     "typescript": "^6.0.3"

package/src/compiler.ts

@@ -0,0 +1,21 @@
+import { compileModsAsync, type ExportedConfig, type ModPlatform } from '@expo/config-plugins';
+
+import type { ExpoConfigWithHarmony } from './config';
+import { withHarmonyBaseMods } from './mods';
+
+export interface HarmonyCompileOptions {
+  projectRoot: string;
+  introspect?: boolean;
+  ignoreExistingNativeFiles?: boolean;
+}
+
+export async function compileHarmonyModsAsync<Config extends ExpoConfigWithHarmony>(
+  config: Config,
+  options: HarmonyCompileOptions
+): Promise<Config> {
+  return await compileModsAsync(withHarmonyBaseMods(config) as ExportedConfig, {
+    ...options,
+    platforms: ['harmony' as ModPlatform],
+    assertMissingModProviders: true,
+  }) as Config;
+}

package/src/composition.ts

@@ -0,0 +1,45 @@
+import {
+  createRunOncePlugin as expoCreateRunOncePlugin,
+  withPlugins as expoWithPlugins,
+  withRunOnce as expoWithRunOnce,
+  withStaticPlugin as expoWithStaticPlugin,
+  type ConfigPlugin,
+} from '@expo/config-plugins';
+
+import type { HarmonyConfigPlugin } from './pluginTypes';
+import type { ExpoConfigWithHarmony } from './config';
+
+// Expo plugins accept the narrower platform union. Method variance allows them
+// alongside Harmony plugins without losing contextual types for inline callbacks.
+type CompatiblePlugin<Props = void> = {
+  apply(config: ExpoConfigWithHarmony, props: Props): ExpoConfigWithHarmony;
+}['apply'];
+
+export type HarmonyPluginReference = string | CompatiblePlugin<never>;
+export type HarmonyStaticPlugin = HarmonyPluginReference | [HarmonyPluginReference, unknown];
+
+export const withPlugins = expoWithPlugins as unknown as HarmonyConfigPlugin<HarmonyStaticPlugin[]>;
+export const withRunOnce = expoWithRunOnce as unknown as HarmonyConfigPlugin<{
+  plugin: CompatiblePlugin;
+  name: string;
+  version?: string;
+}>;
+export const withStaticPlugin = expoWithStaticPlugin as unknown as HarmonyConfigPlugin<{
+  plugin: HarmonyStaticPlugin;
+  projectRoot?: string;
+  fallback?: CompatiblePlugin<{ _resolverError: Error } & Record<string, unknown>>;
+}>;
+
+export function createRunOncePlugin<Props>(
+  plugin: HarmonyConfigPlugin<Props>, name: string, version?: string
+): HarmonyConfigPlugin<Props>;
+export function createRunOncePlugin<Props>(
+  plugin: ConfigPlugin<Props>, name: string, version?: string
+): HarmonyConfigPlugin<Props>;
+export function createRunOncePlugin(
+  plugin: ConfigPlugin<never> | HarmonyConfigPlugin<never>,
+  name: string,
+  version?: string
+): HarmonyConfigPlugin<never> {
+  return expoCreateRunOncePlugin(plugin as ConfigPlugin<never>, name, version) as HarmonyConfigPlugin<never>;
+}

package/src/config.ts

@@ -18,25 +18,14 @@ export interface HarmonyPermission {
   usedScene?: { abilities?: string[]; when?: 'inuse' | 'always' };
 }
 
+export type HarmonySkillUri = Record<string, string | number | boolean>;
+
 export interface HarmonySkill {
   entities?: string[];
   actions?: string[];
-  uris?: Array<Record<string, string>>;
-}
-
-export interface HarmonyFontDefinition {
-  path: string;
-  weight?: number;
-  style?: 'normal' | 'italic';
+  uris?: HarmonySkillUri[];
 }
 
-export type HarmonyFont
-  = | string
-    | {
-      fontFamily: string;
-      fontDefinitions: HarmonyFontDefinition[];
-    };
-
 export interface HarmonyConfig {
   bundleName: string;
   moduleName?: string;
@@ -46,14 +35,11 @@ export interface HarmonyConfig {
   versionCode?: number;
   versionName?: string;
   targetApiVersion?: number;
-  /** Harmony SDK label written to build-profile.json5, e.g. 6.0.0(20). Its API must match targetApiVersion. */
   targetSdkVersion?: number | string;
-  /** API number, or a full Harmony SDK label ending in the API number. */
   compatibleSdkVersion?: number | string;
   deviceTypes?: HarmonyDeviceType[];
   permissions?: HarmonyPermission[];
   skills?: HarmonySkill[];
-  /** URL schemes the app may inspect with Linking.canOpenURL. http, https, and expo.scheme are added automatically. */
   querySchemes?: string[];
   icon?: string;
   label?: string;
@@ -63,8 +49,6 @@ export interface HarmonyConfig {
   jsEngine?: 'hermes';
   abiFilters?: string[];
   signingConfigFile?: string;
-  /** Fonts bundled when the `@expo-harmony/expo-font` config plugin is registered. */
-  fonts?: HarmonyFont[];
 }
 
 export type ExpoConfigWithHarmony = Omit<ExpoConfig, 'platforms'> & {

package/src/customFiles.ts

@@ -0,0 +1,142 @@
+import fs from 'node:fs/promises';
+
+import { withBaseMod, type ExportedConfig, type ModPlatform } from '@expo/config-plugins';
+import JSON5 from 'json5';
+
+import { HarmonyConfigPluginError } from './errors';
+import { atomicWrite, stableJson } from './files';
+import { recordManagedFile, registerMod } from './mods';
+import { getHarmonyConfigPlugins, normalizeHarmonyConfigPlugins, registerHarmonyConfigPlugin } from './ownership';
+import { ManagedPaths, ResourcePaths, resolveHarmonyPath } from './paths';
+import type { HarmonyConfigPlugin, HarmonyModAction, HarmonyModConfig } from './pluginTypes';
+
+export interface HarmonyFileModOptions<T> {
+  path: string;
+  owner: string;
+  parse: (source: string | null) => T;
+  serialize: (value: T) => string;
+  isIntrospective?: boolean;
+}
+
+type Definition = Omit<HarmonyFileModOptions<unknown>, 'parse' | 'serialize'> & { parse: unknown; serialize: unknown };
+interface CustomProvider { expoHarmonyLateActions?: unknown }
+const providers = new WeakMap<object, Definition>();
+
+export function createHarmonyFileMod<T>(options: HarmonyFileModOptions<T>): HarmonyConfigPlugin<HarmonyModAction<T>> {
+  const definition = Object.freeze({ ...options });
+  const { path: relative, owner, parse, serialize, isIntrospective = false } = definition;
+
+  normalizeHarmonyConfigPlugins([{ owner, files: [relative] }]);
+
+  const reserved = Object.values(ManagedPaths).includes(relative)
+    || Object.values(ResourcePaths).some(scopes => Object.values(scopes).some(file => relative === file))
+    || Object.values(ResourcePaths.media).some(directory => relative.startsWith(`${directory}/`));
+  if (reserved || relative.split('/').some(part => part === '.git') || relative.startsWith('.expo/')) {
+    throw new HarmonyConfigPluginError('ERR_HARMONY_PATH_INVALID', `Use the built-in mod for reserved path ${relative}.`);
+  }
+  if (typeof parse !== 'function' || typeof serialize !== 'function') {
+    throw new TypeError('A file mod requires parse and serialize functions.');
+  }
+
+  const name = `file:${relative}`;
+
+  return (config, action) => {
+    const mods = (config as ExportedConfig).mods as Record<string, Record<string, CustomProvider>> | undefined;
+    const provider = mods?.harmony?.[name];
+    if (provider) {
+      const stored = providers.get(provider);
+      if (!stored || stored.owner !== owner || stored.parse !== parse
+        || stored.serialize !== serialize || !!stored.isIntrospective !== isIntrospective) {
+        throw new HarmonyConfigPluginError('ERR_HARMONY_CONFIG_INVALID', `Conflicting providers for ${relative}. Reuse the same file mod definition.`);
+      }
+    }
+
+    const claims = getHarmonyConfigPlugins(config).find(plugin => plugin.owner === owner);
+    registerHarmonyConfigPlugin(config, owner, {
+      ...claims, files: [...new Set([...(claims?.files ?? []), relative])],
+    });
+
+    if (!provider) {
+      const actions: HarmonyModAction<T>[] = [];
+      withBaseMod<T>(config as ExportedConfig, {
+        platform: 'harmony' as ModPlatform,
+        mod: name,
+        isProvider: true,
+        isIntrospective,
+        saveToInternal: isIntrospective,
+        async action(value) {
+          const { nextMod: _next, ...request } = value.modRequest;
+          const file = await resolveHarmonyPath(request.platformProjectRoot, relative);
+          let source: string | null = null;
+
+          if (!request.ignoreExistingNativeFiles) {
+            try {
+              source = await fs.readFile(file, 'utf8');
+            } catch (cause) {
+              if ((cause as NodeJS.ErrnoException).code !== 'ENOENT') {
+                throw new HarmonyConfigPluginError(
+                  'ERR_HARMONY_TEXT_INVALID',
+                  `Cannot read ${file}: ${(cause as Error).message}`,
+                  { cause, file, operation: `harmony.${name}.read` }
+                );
+              }
+            }
+          }
+
+          let result = {
+            ...value,
+            modRequest: { ...request, modFile: file, modFileExists: source !== null },
+            modResults: parse(source),
+          } as unknown as HarmonyModConfig<T>;
+          for (let index = actions.length - 1; index >= 0; index--) {
+            result = await actions[index](result) as HarmonyModConfig<T>;
+          }
+
+          const output = serialize(result.modResults);
+          if (typeof output !== 'string') throw new TypeError(`Serializer for ${relative} must return a string.`);
+
+          if (!request.introspect) {
+            await atomicWrite(file, output);
+            recordManagedFile(result, file, owner);
+          }
+
+          return result as unknown as typeof value;
+        },
+      });
+
+      const table = ((config as ExportedConfig).mods as Record<string, Record<string, CustomProvider>>).harmony;
+      table[name].expoHarmonyLateActions = actions;
+      providers.set(table[name], definition);
+
+      // CNG must fingerprint custom outputs after they have been written.
+      for (const stage of ['patch', 'manifest']) {
+        if (table[stage]) {
+          const provider = table[stage];
+          delete table[stage];
+          table[stage] = provider;
+        }
+      }
+    }
+
+    return registerMod(config, name, action);
+  };
+}
+
+function parseJson(source: string | null): Record<string, unknown> {
+  const value = source === null ? {} : JSON5.parse(source);
+  if (!value || typeof value !== 'object' || Array.isArray(value)) {
+    throw new TypeError('A Harmony JSON file must contain an object.');
+  }
+
+  return value;
+}
+
+export interface HarmonyJsonFileOptions {
+  path: string;
+  owner: string;
+  action: HarmonyModAction<Record<string, unknown>>;
+}
+
+export const withHarmonyJsonFile: HarmonyConfigPlugin<HarmonyJsonFileOptions> = (config, { path, owner, action }) => (
+  createHarmonyFileMod({ path, owner, parse: parseJson, serialize: stableJson, isIntrospective: true })(config, action)
+);

package/src/files.ts

@@ -21,7 +21,7 @@ export function stableJson(value: unknown): string {
   return `${JSON.stringify(sortValue(value), null, 2)}\n`;
 }
 
-export async function readJson5<T>(file: string, fallback: T, modName: string): Promise<T> {
+export async function readJson5<T>(file: string, fallback: T, name: string): Promise<T> {
   try {
     const source = await fs.promises.readFile(file, 'utf8');
 
@@ -31,8 +31,8 @@ export async function readJson5<T>(file: string, fallback: T, modName: string):
 
     throw new HarmonyConfigPluginError(
       'ERR_HARMONY_JSON5_INVALID',
-      `Cannot parse ${file} for harmony.${modName}: ${(cause as Error).message}`,
-      { cause, file, operation: `harmony.${modName}.read` }
+      `Cannot parse ${file} for harmony.${name}: ${(cause as Error).message}`,
+      { cause, file, operation: `harmony.${name}.read` }
     );
   }
 }
@@ -74,6 +74,5 @@ export async function writeJson5(file: string, value: unknown): Promise<void> {
 
 export async function sha256File(file: string): Promise<string> {
   const data = Uint8Array.from(await fs.promises.readFile(file));
-
   return crypto.createHash('sha256').update(data).digest('hex');
 }

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';