expo-harmony-toolkit 1.7.2 → 1.7.3

package/build/core/template/expoModulesCoreShim.js

@@ -0,0 +1,279 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderExpoModulesCoreHarmonyShim = renderExpoModulesCoreHarmonyShim;
+function renderExpoModulesCoreHarmonyShim(expoConfig, identifiers) {
+    const embeddedExpoConfig = buildExpoConfigForShim(expoConfig, identifiers);
+    const serializedExpoConfig = JSON.stringify(embeddedExpoConfig, null, 2);
+    const primaryScheme = getPrimarySchemeForShim(embeddedExpoConfig, identifiers);
+    const linkingUri = primaryScheme ? `${primaryScheme}://` : null;
+    const serializedLinkingUri = JSON.stringify(linkingUri);
+    return `'use strict';
+
+const { Linking, Platform } = require('react-native');
+
+const embeddedExpoConfig = ${serializedExpoConfig};
+const nativeModules = Object.create(null);
+
+class EventSubscription {
+  constructor(remove) {
+    this._remove = remove;
+  }
+
+  remove() {
+    if (!this._remove) {
+      return;
+    }
+
+    const remove = this._remove;
+    this._remove = null;
+    remove();
+  }
+}
+
+class EventEmitter {
+  constructor() {
+    this._listeners = new Map();
+  }
+
+  addListener(eventName, listener) {
+    const listeners = this._listeners.get(eventName) ?? new Set();
+    listeners.add(listener);
+    this._listeners.set(eventName, listeners);
+
+    return new EventSubscription(() => {
+      listeners.delete(listener);
+
+      if (listeners.size === 0) {
+        this._listeners.delete(eventName);
+      }
+    });
+  }
+
+  removeAllListeners(eventName) {
+    if (typeof eventName === 'string') {
+      this._listeners.delete(eventName);
+      return;
+    }
+
+    this._listeners.clear();
+  }
+
+  emit(eventName, payload) {
+    const listeners = this._listeners.get(eventName);
+
+    if (!listeners) {
+      return;
+    }
+
+    for (const listener of listeners) {
+      listener(payload);
+    }
+  }
+}
+
+class LegacyEventEmitter extends EventEmitter {}
+
+class NativeModule extends EventEmitter {}
+
+class SharedObject {}
+
+class SharedRef extends SharedObject {}
+
+class CodedError extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = 'CodedError';
+  }
+}
+
+class UnavailabilityError extends CodedError {
+  constructor(moduleName, propertyName) {
+    super(
+      'ERR_UNAVAILABLE',
+      propertyName
+        ? moduleName + '.' + propertyName + ' is not available on Harmony.'
+        : moduleName + ' is not available on Harmony.',
+    );
+    this.name = 'UnavailabilityError';
+  }
+}
+
+class ExpoLinkingModule extends NativeModule {
+  constructor(initialUrl) {
+    super();
+    this._currentUrl = initialUrl;
+  }
+
+  getLinkingURL() {
+    return this._currentUrl;
+  }
+
+  _setCurrentUrl(url) {
+    this._currentUrl = url;
+    this.emit('onURLReceived', {
+      url,
+    });
+  }
+}
+
+const expoLinkingModule = new ExpoLinkingModule(${serializedLinkingUri});
+
+if (Linking?.addEventListener) {
+  Linking.addEventListener('url', (event) => {
+    expoLinkingModule._setCurrentUrl(event?.url ?? null);
+  });
+}
+
+nativeModules.ExpoLinking = expoLinkingModule;
+nativeModules.ExponentConstants = {
+  manifest: embeddedExpoConfig,
+  appOwnership: null,
+  executionEnvironment: 'standalone',
+  experienceUrl: ${serializedLinkingUri},
+  linkingUri: ${serializedLinkingUri},
+  statusBarHeight: 0,
+  systemVersion: 'HarmonyOS',
+  platform: {
+    android: embeddedExpoConfig.android ?? null,
+    ios: embeddedExpoConfig.ios ?? null,
+    web: null,
+  },
+};
+nativeModules.ExpoAsset = {
+  async downloadAsync(url) {
+    return url;
+  },
+};
+nativeModules.ExpoFetchModule = {
+  NativeRequest: class NativeRequest {
+    constructor(_response) {
+      this._response = _response;
+    }
+
+    async start() {
+      throw new UnavailabilityError('ExpoFetchModule', 'NativeRequest.start');
+    }
+
+    cancel() {}
+  },
+};
+
+function requireOptionalNativeModule(name) {
+  return nativeModules[name] ?? null;
+}
+
+function requireNativeModule(name) {
+  const nativeModule = requireOptionalNativeModule(name);
+
+  if (nativeModule) {
+    return nativeModule;
+  }
+
+  throw new UnavailabilityError(name);
+}
+
+function requireNativeViewManager(name) {
+  throw new UnavailabilityError(name, 'viewManager');
+}
+
+function registerWebModule() {}
+
+async function reloadAppAsync() {}
+
+function installOnUIRuntime() {}
+
+globalThis.expo = {
+  ...(globalThis.expo ?? {}),
+  EventEmitter,
+  LegacyEventEmitter,
+  NativeModule,
+  SharedObject,
+  SharedRef,
+  modules: {
+    ...(globalThis.expo?.modules ?? {}),
+    ...nativeModules,
+  },
+};
+
+module.exports = {
+  Platform,
+  CodedError,
+  UnavailabilityError,
+  EventEmitter,
+  LegacyEventEmitter,
+  NativeModule,
+  SharedObject,
+  SharedRef,
+  requireNativeModule,
+  requireOptionalNativeModule,
+  requireNativeViewManager,
+  registerWebModule,
+  reloadAppAsync,
+  installOnUIRuntime,
+};
+`;
+}
+function buildExpoConfigForShim(expoConfig, identifiers) {
+    const normalized = toSerializableValue(expoConfig);
+    const config = normalized && typeof normalized === 'object' && !Array.isArray(normalized)
+        ? { ...normalized }
+        : {};
+    config.name = config.name ?? identifiers.appName;
+    config.slug = config.slug ?? identifiers.slug;
+    config.version = config.version ?? '1.0.0';
+    if (!config.scheme) {
+        config.scheme = getPrimarySchemeForShim(config, identifiers);
+    }
+    const android = config.android && typeof config.android === 'object' && !Array.isArray(config.android)
+        ? { ...config.android }
+        : {};
+    const ios = config.ios && typeof config.ios === 'object' && !Array.isArray(config.ios)
+        ? { ...config.ios }
+        : {};
+    android.package = android.package ?? identifiers.androidPackage ?? identifiers.bundleName;
+    ios.bundleIdentifier =
+        ios.bundleIdentifier ?? identifiers.iosBundleIdentifier ?? identifiers.bundleName;
+    config.android = android;
+    config.ios = ios;
+    return config;
+}
+function getPrimarySchemeForShim(expoConfig, identifiers) {
+    const scheme = expoConfig.scheme;
+    if (typeof scheme === 'string' && scheme.trim().length > 0) {
+        return scheme.trim();
+    }
+    if (Array.isArray(scheme)) {
+        const firstScheme = scheme.find((value) => typeof value === 'string' && value.trim().length > 0);
+        if (firstScheme) {
+            return firstScheme.trim();
+        }
+    }
+    return (identifiers.androidPackage ??
+        identifiers.iosBundleIdentifier ??
+        identifiers.bundleName);
+}
+function toSerializableValue(value) {
+    if (value === null ||
+        typeof value === 'string' ||
+        typeof value === 'number' ||
+        typeof value === 'boolean') {
+        return value;
+    }
+    if (Array.isArray(value)) {
+        return value
+            .map((entry) => toSerializableValue(entry))
+            .filter((entry) => entry !== undefined);
+    }
+    if (typeof value === 'object') {
+        const result = {};
+        for (const [key, entry] of Object.entries(value)) {
+            const serializedEntry = toSerializableValue(entry);
+            if (serializedEntry !== undefined) {
+                result[key] = serializedEntry;
+            }
+        }
+        return result;
+    }
+    return undefined;
+}

package/build/core/template/metro.d.ts

@@ -0,0 +1,2 @@
+import { CapabilityDefinition } from '../../types';
+export declare function renderMetroConfig(enabledCapabilities: readonly CapabilityDefinition[]): string;

package/build/core/template/metro.js

@@ -0,0 +1,213 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderMetroConfig = renderMetroConfig;
+function renderMetroConfig(enabledCapabilities) {
+    const previewCapabilityAliases = enabledCapabilities
+        .filter((capability) => capability.supportTier === 'preview' ||
+        capability.supportTier === 'experimental')
+        .map((capability) => `  '${capability.packageName}': path.resolve(__dirname, '.expo-harmony/shims/${capability.packageName}'),`)
+        .join('\n');
+    return `const fs = require('fs');
+const path = require('path');
+
+process.env.EXPO_ROUTER_APP_ROOT = process.env.EXPO_ROUTER_APP_ROOT ?? 'app';
+
+const { getDefaultConfig } = require('expo/metro-config');
+const { createHarmonyMetroConfig } = require('@react-native-oh/react-native-harmony/metro.config');
+
+const defaultConfig = getDefaultConfig(__dirname);
+const harmonyConfig = createHarmonyMetroConfig({
+  reactNativeHarmonyPackageName: '@react-native-oh/react-native-harmony',
+});
+const expoHarmonyShims = {
+  'expo-modules-core': path.resolve(__dirname, '.expo-harmony/shims/expo-modules-core'),
+  'react-native-safe-area-context': path.resolve(
+    __dirname,
+    '.expo-harmony/shims/react-native-safe-area-context',
+  ),
+${previewCapabilityAliases ? `${previewCapabilityAliases}\n` : ''}};
+const uiStackRootModuleAliases = {
+  'react-native-gesture-handler': path.resolve(__dirname, 'node_modules/react-native-gesture-handler'),
+  'react-native-reanimated': path.resolve(__dirname, 'node_modules/react-native-reanimated'),
+  'react-native-svg': path.resolve(__dirname, 'node_modules/react-native-svg'),
+};
+const resolvePackageAlias = (context, moduleName, platform, aliases) => {
+  for (const [aliasedModuleName, aliasedModulePath] of Object.entries(aliases)) {
+    if (moduleName === aliasedModuleName) {
+      return context.resolveRequest(context, aliasedModulePath, platform);
+    }
+
+    if (moduleName.startsWith(\`\${aliasedModuleName}/\`)) {
+      return context.resolveRequest(
+        context,
+        path.join(aliasedModulePath, moduleName.slice(aliasedModuleName.length + 1)),
+        platform,
+      );
+    }
+  }
+
+  return null;
+};
+const resolveUiStackModuleAlias = (context, moduleName, platform) =>
+  resolvePackageAlias(context, moduleName, platform, uiStackRootModuleAliases);
+const resolveExpoHarmonyModuleAlias = (context, moduleName, platform) =>
+  resolvePackageAlias(context, moduleName, platform, expoHarmonyShims);
+const reactNativeCompatibilitySourceExts = ['js', 'jsx', 'ts', 'tsx', 'mjs', 'cjs', 'json'];
+const reactNativeCompatibilityPackageMarkers = [
+  path.sep + '@react-native-oh' + path.sep + 'react-native-harmony' + path.sep,
+  path.sep + 'react-native' + path.sep,
+];
+const findFirstExistingCompatibilityModule = (candidateBasePath, platforms) => {
+  for (const candidatePlatform of platforms) {
+    for (const candidateExtension of reactNativeCompatibilitySourceExts) {
+      const candidatePath = candidatePlatform
+        ? \`\${candidateBasePath}.\${candidatePlatform}.\${candidateExtension}\`
+        : \`\${candidateBasePath}.\${candidateExtension}\`;
+
+      if (fs.existsSync(candidatePath)) {
+        return { candidatePath, candidatePlatform };
+      }
+    }
+  }
+
+  return null;
+};
+const resolveReactNativeCompatibilityWrapper = (context, moduleName, platform) => {
+  if (platform !== 'harmony' || !context.originModulePath || !moduleName.startsWith('.')) {
+    return null;
+  }
+
+  const originModulePath = context.originModulePath;
+  const isReactNativeCompatibilityWrapper = reactNativeCompatibilityPackageMarkers.some((marker) =>
+    originModulePath.includes(marker),
+  );
+
+  if (!isReactNativeCompatibilityWrapper) {
+    return null;
+  }
+
+  const originExtension = path.extname(originModulePath);
+  const originBasename = path.basename(originModulePath, originExtension);
+  const candidateModulePath = path.resolve(path.dirname(originModulePath), moduleName);
+  const candidateModuleExtension = path.extname(candidateModulePath);
+  const candidateBasename = path.basename(candidateModulePath, candidateModuleExtension);
+
+  const candidateBasePath = candidateModuleExtension
+    ? candidateModulePath.slice(0, -candidateModuleExtension.length)
+    : candidateModulePath;
+
+  if (candidateBasename === originBasename) {
+    const compatibilityWrapperCandidate = findFirstExistingCompatibilityModule(candidateBasePath, [
+      'harmony',
+      'native',
+      'android',
+      'ios',
+    ]);
+
+    if (compatibilityWrapperCandidate) {
+      return context.resolveRequest(
+        context,
+        compatibilityWrapperCandidate.candidatePath,
+        compatibilityWrapperCandidate.candidatePlatform || platform,
+      );
+    }
+
+    return null;
+  }
+
+  const standardResolutionCandidate = findFirstExistingCompatibilityModule(candidateBasePath, [
+    'harmony',
+    'native',
+    '',
+  ]);
+
+  if (standardResolutionCandidate) {
+    return null;
+  }
+
+  const compatibilityFallbackCandidate = findFirstExistingCompatibilityModule(candidateBasePath, [
+    'android',
+    'ios',
+  ]);
+
+  if (compatibilityFallbackCandidate) {
+    return context.resolveRequest(
+      context,
+      compatibilityFallbackCandidate.candidatePath,
+      compatibilityFallbackCandidate.candidatePlatform || platform,
+    );
+  }
+
+  return null;
+};
+const resolveExpoHarmonyShim = (context, moduleName, platform) => {
+  const uiStackModuleAliasResolution = resolveUiStackModuleAlias(context, moduleName, platform);
+
+  if (uiStackModuleAliasResolution) {
+    return uiStackModuleAliasResolution;
+  }
+
+  const expoHarmonyModuleAliasResolution = resolveExpoHarmonyModuleAlias(context, moduleName, platform);
+
+  if (expoHarmonyModuleAliasResolution) {
+    return expoHarmonyModuleAliasResolution;
+  }
+
+  const compatibilityWrapperResolution = resolveReactNativeCompatibilityWrapper(
+    context,
+    moduleName,
+    platform,
+  );
+
+  if (compatibilityWrapperResolution) {
+    return compatibilityWrapperResolution;
+  }
+
+  const harmonyResolveRequest = harmonyConfig.resolver?.resolveRequest;
+
+  if (typeof harmonyResolveRequest === 'function') {
+    return harmonyResolveRequest(context, moduleName, platform);
+  }
+
+  return context.resolveRequest(context, moduleName, platform);
+};
+
+module.exports = {
+  ...defaultConfig,
+  ...harmonyConfig,
+  projectRoot: __dirname,
+  server: {
+    ...(defaultConfig.server ?? {}),
+    ...(harmonyConfig.server ?? {}),
+    unstable_serverRoot: __dirname,
+  },
+  transformer: {
+    ...(defaultConfig.transformer ?? {}),
+    ...(harmonyConfig.transformer ?? {}),
+  },
+  serializer: {
+    ...(defaultConfig.serializer ?? {}),
+    ...(harmonyConfig.serializer ?? {}),
+  },
+  resolver: {
+    ...(defaultConfig.resolver ?? {}),
+    ...(harmonyConfig.resolver ?? {}),
+    extraNodeModules: {
+      ...((defaultConfig.resolver?.extraNodeModules ?? {})),
+      ...((harmonyConfig.resolver?.extraNodeModules ?? {})),
+      ...uiStackRootModuleAliases,
+      ...expoHarmonyShims,
+    },
+    resolveRequest: resolveExpoHarmonyShim,
+    sourceExts: [
+      'harmony.ts',
+      'harmony.tsx',
+      'harmony.js',
+      'harmony.jsx',
+      ...((harmonyConfig.resolver?.sourceExts ??
+        defaultConfig.resolver?.sourceExts ?? ['ts', 'tsx', 'js', 'jsx', 'json'])),
+    ],
+  },
+};
+`;
+}

package/build/core/template/nativeFiles.d.ts

@@ -0,0 +1,8 @@
+export declare function renderPackageProvider(options: {
+    hasManagedExpoHarmonyPackage: boolean;
+}): string;
+export declare function renderPackageProviderCpp(options: {
+    hasManagedExpoHarmonyPackage: boolean;
+}): string;
+export declare function renderExpoHarmonyCppPackage(): string;
+export declare function renderExpoHarmonyPackage(): string;