expo-invoke 2.6.14 → 2.7.0

package/ios/Widgets/Widget/WidgetsJSRuntime.swift

@@ -0,0 +1,148 @@
+import Foundation
+import JavaScriptCore
+
+struct WidgetJavaScriptError: Error {
+  let message: String
+}
+
+typealias WidgetJavaScriptResult<Value> = Result<Value, WidgetJavaScriptError>
+
+private final class WidgetsJSRuntime {
+  static let shared = WidgetsJSRuntime()
+
+  private let lock = NSRecursiveLock()
+  private var context: JSContext?
+  private var bundleScript: String?
+  private var layoutCache: [String: JSValue] = [:]
+
+  private init() {}
+
+  func render(layout: String, props: [String: Any]?, environment: [String: Any]) -> WidgetJavaScriptResult<[String: Any]> {
+    call(layout: layout, functionName: "__expoWidgetRender") { context in
+      [props.map { $0 } ?? JSValue(undefinedIn: context) as Any, environment]
+    }.flatMap { result in
+      guard let renderedNode = result?.toObject() as? [String: Any] else {
+        return .failure(WidgetJavaScriptError(message: "Expo widget render did not produce any results."))
+      }
+      return .success(renderedNode)
+    }
+  }
+
+  func handlePress(layout: String, props: [String: Any], environment: [String: Any]) -> WidgetJavaScriptResult<[String: Any]?> {
+    call(layout: layout, functionName: "__expoWidgetHandlePress") { _ in [props, environment] }
+      .map { $0?.toObject() as? [String: Any] }
+  }
+
+  private func call(
+    layout: String,
+    functionName: String,
+    arguments: (JSContext) -> [Any]
+  ) -> WidgetJavaScriptResult<JSValue?> {
+    lock.lock()
+    defer { lock.unlock() }
+
+    guard let context = getContext() else {
+      return .failure(WidgetJavaScriptError(message: "Could not create context for layout evaluation."))
+    }
+    guard let layoutValue = getLayoutValue(layout, in: context) else {
+      return .failure(WidgetJavaScriptError(message: contextExceptionMessage(context) ?? "Could not evaluate layout."))
+    }
+
+    context.exception = nil
+    context.setObject(layoutValue, forKeyedSubscript: "__expoWidgetLayout" as NSString)
+
+    let function = context.objectForKeyedSubscript(functionName)
+    guard let function, function.isObject else {
+      return .failure(WidgetJavaScriptError(message: "Expo widget runtime function \(functionName) is unavailable."))
+    }
+
+    let result = function.call(withArguments: arguments(context))
+    if let exceptionMessage = contextExceptionMessage(context) {
+      return .failure(WidgetJavaScriptError(message: exceptionMessage))
+    }
+    return .success(result)
+  }
+
+  private func getContext() -> JSContext? {
+    if let context {
+      return context
+    }
+
+    guard let context = JSContext() else {
+      return nil
+    }
+
+    guard let script = getBundleScript() else {
+      print("[ExpoWidgets] Missing ExpoWidgets.bundle")
+      return nil
+    }
+
+    context.evaluateScript(script)
+    if let exceptionMessage = contextExceptionMessage(context) {
+      print("[ExpoWidgets] Bundle evaluation failed: \(exceptionMessage)")
+      return nil
+    }
+
+    self.context = context
+    return context
+  }
+
+  private func getBundleScript() -> String? {
+    if let bundleScript {
+      return bundleScript
+    }
+
+    guard let bundleURL = Bundle.main.url(forResource: "ExpoWidgets", withExtension: "bundle"),
+          let bundle = Bundle(url: bundleURL),
+          let url = bundle.url(forResource: "ExpoWidgets", withExtension: "bundle"),
+          let script = try? String(contentsOf: url, encoding: .utf8) else {
+      return nil
+    }
+
+    bundleScript = script
+    return script
+  }
+
+  private func getLayoutValue(_ layout: String, in context: JSContext) -> JSValue? {
+    if let layoutValue = layoutCache[layout] {
+      return layoutValue
+    }
+
+    context.exception = nil
+    guard let layoutValue = context.evaluateScript("(\(layout))"),
+          !layoutValue.isUndefined else {
+      return nil
+    }
+    guard context.exception == nil else {
+      return nil
+    }
+
+    layoutCache[layout] = layoutValue
+    return layoutValue
+  }
+
+  private func contextExceptionMessage(_ context: JSContext) -> String? {
+    guard let exception = context.exception else {
+      return nil
+    }
+
+    context.exception = nil
+    return exception.toString() ?? "Unknown JavaScript exception."
+  }
+}
+
+func evaluateWidgetLayout(
+  layout: String,
+  props: [String: Any]?,
+  environment: [String: Any]
+) -> WidgetJavaScriptResult<[String: Any]> {
+  WidgetsJSRuntime.shared.render(layout: layout, props: props, environment: environment)
+}
+
+func evaluateWidgetButtonPress(
+  layout: String,
+  props: [String: Any],
+  environment: [String: Any]
+) -> WidgetJavaScriptResult<[String: Any]?> {
+  WidgetsJSRuntime.shared.handlePress(layout: layout, props: props, environment: environment)
+}

package/ios/Widgets/WidgetObject.swift

@@ -0,0 +1,31 @@
+import ExpoModulesCore
+import WidgetKit
+
+final class WidgetObject: SharedObject {
+  let name: String
+  init(name: String, layout: String) {
+    self.name = name
+    WidgetsStorage.set(layout, forKey: "__expo_widgets_\(name)_layout")
+  }
+
+  func reload() {
+    WidgetCenter.shared.reloadTimelines(ofKind: name)
+  }
+
+  func updateTimeline(entries: [WidgetsJSTimelineEntry]) throws {
+    if WidgetsStorage.getString(forKey: "__expo_widgets_\(name)_layout") == nil {
+      throw UpdatedTimelineWithoutLayout(name)
+    }
+    WidgetsStorage.set(entries.map { $0.toDictionary() }, forKey: "__expo_widgets_\(name)_timeline")
+
+    self.reload()
+  }
+
+  func getTimeline() throws -> [WidgetsJSTimelineEntry] {
+    guard let entries = WidgetsStorage.getArray(forKey: "__expo_widgets_\(name)_timeline") as? [[String: Any]],
+          let appContext else {
+      return []
+    }
+    return try entries.map { try WidgetsJSTimelineEntry(from: $0, appContext: appContext) }
+  }
+}

package/ios/Widgets/WidgetsContext.swift

@@ -0,0 +1,7 @@
+import ExpoModulesCore
+
+// Shared AppContext for widgets
+struct WidgetsContext {
+  static let shared = WidgetsContext()
+  let context: AppContext = AppContext()
+}

package/ios/Widgets/WidgetsEvents.swift

@@ -0,0 +1,16 @@
+public enum WidgetsEventType: String {
+  case userEvent = "ExpoWidgetsUserInteraction"
+}
+
+public class WidgetsEvents {
+  public static let shared = WidgetsEvents()
+
+  private init() {}
+
+  public func sendNotification(type: WidgetsEventType, data: [String: Any]) {
+    var eventData = data
+    eventData["type"] = type.rawValue
+    let userInfo = ["eventData": eventData] as [String: Any]
+    NotificationCenter.default.post(name: onUserInteractionNotification, object: nil, userInfo: userInfo)
+  }
+}

package/ios/Widgets/WidgetsExceptions.swift

@@ -0,0 +1,25 @@
+import ExpoModulesCore
+
+internal final class LiveActivitiesNotSupportedException: Exception, @unchecked Sendable {
+  override var reason: String {
+    "Live Activities are not supported on this device"
+  }
+}
+
+internal final class StartLiveActivityException: GenericException<String>, @unchecked Sendable {
+  override var reason: String {
+    "Failed to start live activity: \(param)"
+  }
+}
+
+internal final class LiveActivityNotFoundException: GenericException<String>, @unchecked Sendable {
+  override var reason: String {
+    "Can't find live activity with id: \(param)"
+  }
+}
+
+internal final class UpdatedTimelineWithoutLayout: GenericException<String>, @unchecked Sendable {
+  override var reason: String {
+    "Cannot update widget timeline without a layout, first register a layout for: \(param)"
+  }
+}

package/ios/Widgets/WidgetsModule.swift

@@ -0,0 +1,149 @@
+import ExpoModulesCore
+import ActivityKit
+import WidgetKit
+
+let pushNotificationsEnabledKey: String = "ExpoWidgets_EnablePushNotifications"
+
+let onUserInteraction = "onExpoWidgetsUserInteraction"
+let onPushToStartTokenReceived = "onExpoWidgetsPushToStartTokenReceived"
+let onTokenReceived = "onExpoWidgetsTokenReceived"
+let onUserInteractionNotification = Notification.Name(onUserInteraction)
+
+public final class WidgetsModule: Module {
+  var pushToStartTokenObserverTask: Task<Void, Never>?
+
+  public func definition() -> ModuleDefinition {
+    Name("ExpoWidgets")
+
+    Events(onPushToStartTokenReceived, onTokenReceived, onUserInteraction)
+
+    OnStartObserving(onUserInteraction) {
+      NotificationCenter.default.addObserver(
+        self,
+        selector: #selector(handleUserInteractionNotification),
+        name: onUserInteractionNotification,
+        object: nil
+      )
+    }
+
+    OnStopObserving(onUserInteraction) {
+      NotificationCenter.default.removeObserver(
+        self,
+        name: onUserInteractionNotification,
+        object: nil
+      )
+    }
+
+    OnStartObserving(onPushToStartTokenReceived) {
+      if pushNotificationsEnabled {
+        observePushToStartToken()
+      }
+    }
+
+    OnStopObserving(onPushToStartTokenReceived) {
+      pushToStartTokenObserverTask?.cancel()
+      pushToStartTokenObserverTask = nil
+    }
+
+    Constant("widgetsDirectory") { () -> String? in
+      guard let appGroupIdentifier = WidgetsStorage.appGroupIdentifier,
+            let containerUrl = FileManager.default.containerURL(forSecurityApplicationGroupIdentifier: appGroupIdentifier) else {
+        return nil
+      }
+      let directoryUrl = containerUrl.appendingPathComponent("ExpoWidgets", isDirectory: true)
+      do {
+        try FileManager.default.createDirectory(at: directoryUrl, withIntermediateDirectories: true)
+        return directoryUrl.absoluteString
+      } catch {
+        return nil
+      }
+    }
+
+    Function("reloadAllWidgets") {
+      WidgetCenter.shared.reloadAllTimelines()
+    }
+
+    Class("Widget", WidgetObject.self) {
+      Constructor { (name: String, layout: String) in
+        WidgetObject(name: name, layout: layout)
+      }
+
+      Function("reload") { (widget: WidgetObject) in
+        widget.reload()
+      }
+
+      Function("updateTimeline") { (widget: WidgetObject, entries: [WidgetsJSTimelineEntry]) in
+        try widget.updateTimeline(entries: entries)
+      }
+
+      Function("getTimeline") { (widget: WidgetObject) in
+        try widget.getTimeline()
+      }
+    }
+
+    Class("LiveActivityFactory", LiveActivityFactory.self) {
+      Constructor { (name: String, layout: String) in
+        LiveActivityFactory(name: name, layout: layout)
+      }
+
+      Function("start") { (liveActivity: LiveActivityFactory, props: String?, url: URL?) in
+        try liveActivity.start(props: props, url: url)
+      }
+
+      Function("getInstances") { (liveActivity: LiveActivityFactory) in
+        try liveActivity.getInstances()
+      }
+    }
+
+    Class("LiveActivity", LiveActivity.self) {
+      AsyncFunction("update") { (instance: LiveActivity, props: String?) in
+        try await instance.update(props: props)
+      }
+
+      AsyncFunction("end") { (instance: LiveActivity, dismissalPolicy: LiveActivityDismissalPolicy?, afterDate: Date?, props: String?, contentDate: Date?) in
+        try await instance.end(dismissalPolicy: dismissalPolicy, afterDate: afterDate, props: props, contentDate: contentDate)
+      }
+
+      AsyncFunction("getPushToken") { (instance: LiveActivity) in
+        try instance.getPushToken()
+      }
+    }
+  }
+
+  @objc func handleUserInteractionNotification(_ notification: Notification) {
+    guard let userInfo = notification.userInfo as? [String: Any],
+          let eventData = userInfo["eventData"] as? [String: Any]
+    else { return }
+    self.sendEvent(onUserInteraction, eventData)
+  }
+
+  private func sendPushToStartToken(activityPushToStartToken: String) {
+    sendEvent(
+      onPushToStartTokenReceived,
+      [
+        "activityPushToStartToken": activityPushToStartToken
+      ]
+    )
+  }
+
+  private func observePushToStartToken() {
+    guard #available(iOS 17.2, *), ActivityAuthorizationInfo().areActivitiesEnabled else { return }
+    pushToStartTokenObserverTask = Task {
+      let initialToken = (Activity<LiveActivityAttributes>.pushToStartToken?.reduce("") { $0 + String(format: "%02x", $1) })
+      if let initialToken {
+        sendPushToStartToken(activityPushToStartToken: initialToken)
+      }
+
+      for await data in Activity<LiveActivityAttributes>.pushToStartTokenUpdates {
+        let token = data.reduce("") { $0 + String(format: "%02x", $1) }
+        if token != initialToken {
+          sendPushToStartToken(activityPushToStartToken: token)
+        }
+      }
+    }
+  }
+
+  private var pushNotificationsEnabled: Bool {
+    Bundle.main.object(forInfoDictionaryKey: pushNotificationsEnabledKey) as? Bool ?? false
+  }
+}

package/ios/Widgets/WidgetsRecords.swift

@@ -0,0 +1,22 @@
+import ExpoModulesCore
+import ActivityKit
+
+struct WidgetsJSTimelineEntry: Record {
+  @Field var timestamp: Int
+  @Field var props: [String: Any] = [:]
+}
+
+internal enum LiveActivityDismissalPolicy: String, Enumerable {
+  case `default`
+  case immediate
+  case after
+
+  @available(iOS 16.1, *)
+  internal func toDismissalPolicy(date: Date?) -> ActivityUIDismissalPolicy {
+    return switch self {
+    case .default: .default
+    case .immediate: .immediate
+    case .after: .after(date ?? Date.now)
+    }
+  }
+}

package/ios/Widgets/WidgetsStorage.swift

@@ -0,0 +1,58 @@
+public enum WidgetsStorage {
+  public static var appGroupIdentifier: String? = Bundle.main.object(forInfoDictionaryKey: "ExpoWidgetsAppGroupIdentifier") as? String
+  static let defaults = UserDefaults(suiteName: appGroupIdentifier)
+
+  static func set(_ value: [String: Any], forKey key: String) {
+    guard let defaults else { return }
+
+    defaults.set(value, forKey: key)
+  }
+
+  static func set(_ value: [[String: Any]], forKey key: String) {
+    guard let defaults else { return }
+
+    defaults.set(value, forKey: key)
+  }
+
+  static func set(_ value: String, forKey key: String) {
+    guard let defaults else { return }
+
+    defaults.set(value, forKey: key)
+  }
+
+  static func set(_ value: Data, forKey key: String) {
+    guard let defaults else { return }
+
+    defaults.set(value, forKey: key)
+  }
+
+  public static func getDictionary(forKey key: String) -> [String: Any]? {
+    guard let defaults else { return nil }
+
+    return defaults.dictionary(forKey: key)
+  }
+
+  public static func getArray(forKey key: String) -> [Any]? {
+    guard let defaults else { return nil }
+
+    return defaults.array(forKey: key)
+  }
+
+  public static func getData(forKey key: String) -> Data? {
+    guard let defaults else { return nil }
+
+    return defaults.data(forKey: key)
+  }
+
+  public static func getString(forKey key: String) -> String? {
+    guard let defaults else { return nil }
+
+    return defaults.string(forKey: key)
+  }
+
+  static func removeObject(forKey key: String) {
+    guard let defaults else { return }
+
+    defaults.removeObject(forKey: key)
+  }
+}

package/metro.widget.config.js

@@ -0,0 +1,76 @@
+const { getDefaultConfig } = require('expo/metro-config');
+const path = require('path');
+const { resolveWorkspaceRoot } = require('resolve-workspace-root');
+
+const projectRoot = process.cwd();
+const config = getDefaultConfig(projectRoot);
+
+const expoStubPath = path.resolve(__dirname, './bundle/expo-stub.ts');
+const expoModulesCoreStubPath = path.resolve(__dirname, './bundle/expo-modules-core-stub.ts');
+const reactStubPath = path.resolve(__dirname, './bundle/react-stub.ts');
+const reactNativeStubPath = path.resolve(__dirname, './bundle/react-native-stub.ts');
+const jsxRuntimeStubPath = path.resolve(__dirname, './bundle/jsx-runtime-stub.ts');
+
+// The `projectRoot` won't be included by default, since we alter it to be `__dirname`
+// to bundle from `expo-widgets` as the main module
+// NOTE: We check the `watchFolders` to start with `projectRoot`, since `expo/metro-config`
+// might add folders if we're in a monorepo
+const watchFolders = config.watchFolders;
+if (!watchFolders.some((entry) => !entry.startsWith(projectRoot))) {
+  watchFolders.push(projectRoot);
+}
+// If expo-widgets is outside the user's project (e.g., symlinked, in a different monorepo,
+// or as an installed dependency), add its workspace root so Metro can resolve its dependencies.
+const rel = path.relative(projectRoot, __dirname);
+if (rel.startsWith('..') || path.isAbsolute(rel)) {
+  const widgetWorkspaceRoot = resolveWorkspaceRoot(__dirname);
+  if (widgetWorkspaceRoot && !watchFolders.includes(widgetWorkspaceRoot)) {
+    watchFolders.push(widgetWorkspaceRoot);
+  }
+}
+
+const buildConfig = {
+  ...config,
+  projectRoot: __dirname, // Override root to be expo-widgets
+  watchFolders,
+  resolver: {
+    ...config.resolver,
+    resolveRequest(context, moduleName, platform) {
+      const fileSpecifierRe = /^[\\/]|^\.\.?(?:$|[\\/])/i;
+      if (fileSpecifierRe.test(moduleName)) {
+        return context.resolveRequest(context, moduleName, platform);
+      }
+      switch (moduleName) {
+        case 'expo':
+          return { type: 'sourceFile', filePath: expoStubPath };
+        case 'expo-modules-core':
+          return { type: 'sourceFile', filePath: expoModulesCoreStubPath };
+        case 'react':
+          return { type: 'sourceFile', filePath: reactStubPath };
+        case 'react/jsx-runtime':
+        case 'react/jsx-dev-runtime':
+          return { type: 'sourceFile', filePath: jsxRuntimeStubPath };
+        case 'react-native':
+          return { type: 'sourceFile', filePath: reactNativeStubPath };
+        case 'react-native-worklets':
+        case 'react-native-reanimated':
+          return { type: 'empty' };
+        default:
+          return context.resolveRequest(context, moduleName, platform);
+      }
+    },
+  },
+  transformer: {
+    ...config.transformer,
+    enableBabelRCLookup: false,
+    getTransformOptions: async () => ({
+      transform: { experimentalImportSupport: false, inlineRequires: false },
+    }),
+  },
+  serializer: {
+    ...config.serializer,
+    getPolyfills: () => [],
+  },
+};
+
+module.exports = buildConfig;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expo-invoke",
-  "version": "2.6.14",
+  "version": "2.7.0",
   "description": "The complete native-surface-to-JS bridge for Expo. One intent config → Siri, Google Assistant, home screen widgets, Dynamic Island, app icon menus, notification actions, NFC, QR, deep links and more — all through a single useInvoke() hook.",
   "main": "build/src/index.js",
   "module": "build/src/index.js",
@@ -24,6 +24,10 @@
     "ios",
     "android/src",
     "android/build.gradle",
+    "bundle",
+    "scripts",
+    "metro.widget.config.js",
+    "spm.config.json",
     "expo-module.config.json",
     "README.md",
     "MIGRATION.md",
@@ -77,6 +81,7 @@
   },
   "peerDependencies": {
     "@expo/config-plugins": ">=7.0.0",
+    "@expo/ui": ">=56.0.0",
     "expo": ">=50.0.0",
     "expo-modules-core": ">=1.12.0",
     "react": ">=18.0.0",
@@ -86,6 +91,9 @@
     "@expo/config-plugins": {
       "optional": false
     },
+    "@expo/ui": {
+      "optional": true
+    },
     "expo-modules-core": {
       "optional": true
     },
@@ -94,6 +102,8 @@
     }
   },
   "devDependencies": {
+    "@expo/plist": "^0.7.0",
+    "@expo/spawn-async": "^1.7.2",
     "@types/jest": "^29.5.14",
     "@types/node": "^20.19.41",
     "@types/react": "^19.2.16",

package/scripts/autolinking.rb

@@ -0,0 +1,34 @@
+require 'json'
+require 'pathname'
+require 'colored2' # dependency of CocoaPods
+
+require File.join(File.dirname(`node --print "require.resolve('expo-modules-autolinking/package.json', { paths: ['#{__dir__}'] })"`), "scripts/ios/autolinking_manager")
+require File.join(File.dirname(`node --print "require.resolve('react-native/package.json')"`), "scripts/react_native_pods")
+
+def use_expo_modules_widgets!(options = {})
+  output = Expo::AutolinkingManager.new(self, @current_target_definition, options).resolve
+
+  all_packages = output["modules"].map { |mod| mod["packageName"] }
+  used_packages = ["expo", "expo-invoke", "@expo/ui"]
+  packages_to_exclude = all_packages - used_packages
+
+  options[:exclude] = packages_to_exclude
+  use_expo_modules!(options)
+end
+
+def use_expo_native_module!(config_command = $default_command)
+  config = list_native_modules!(config_command)
+  config[:ios_packages].select! { |package| package[:name] == "expo" }
+
+  return link_native_modules!(config)
+end
+
+def expo_widgets_post_install(installer)
+  installer.pods_project.targets.each do |target|
+    if target.name == 'ExpoModulesCore' || target.name == 'ExpoUI' || target.name.start_with?('React-')
+      target.build_configurations.each do |config|
+        config.build_settings['APPLICATION_EXTENSION_API_ONLY'] = 'No'
+      end
+    end
+  end
+end

package/scripts/build-bundle.mjs

@@ -0,0 +1,69 @@
+#!/usr/bin/env node
+
+// Build the ExpoWidgets.bundle.
+// Use `yarn build:bundle` to run this script.
+
+import spawn from '@expo/spawn-async';
+import fs from 'node:fs';
+import { createRequire } from 'node:module';
+import path from 'node:path';
+import { argv } from 'node:process';
+import { fileURLToPath } from 'node:url';
+
+// NOTE: Modified from expo-constants/expo-updates entrypoint. We cd into the right folder anyway
+const [, , possibleProjectRoot = process.cwd(), platform = 'ios', bundleOutput] = argv;
+
+// TODO: Verify we can remove projectRoot validation, now that we no longer
+// support React Native <= 62
+let projectRoot;
+if (fs.existsSync(path.join(possibleProjectRoot, 'package.json'))) {
+  projectRoot = possibleProjectRoot;
+} else if (fs.existsSync(path.join(possibleProjectRoot, '..', 'package.json'))) {
+  projectRoot = path.resolve(possibleProjectRoot, '..');
+} else {
+  throw new Error(
+    `Unable to locate project (no package.json found) at path: ${possibleProjectRoot}`
+  );
+}
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const require = createRequire(__dirname);
+
+// NODE_BINARY is set for Xcode builds via the `with-node.sh` script.
+const nodePath = process.env.NODE_BINARY || 'node';
+const outputDir = path.join(__dirname, '../bundle/build');
+const defaultBundleOutput = path.join(outputDir, 'ExpoWidgets.bundle');
+const appBundlePath = path.resolve(projectRoot, bundleOutput ?? defaultBundleOutput);
+
+await fs.promises.rm(appBundlePath, { recursive: true, force: true });
+await fs.promises.mkdir(path.dirname(appBundlePath), { recursive: true });
+
+const result = await spawn(
+  nodePath,
+  [
+    require.resolve('expo/bin/cli'),
+    'export:embed',
+    '--platform',
+    platform,
+    '--bundle-output',
+    appBundlePath,
+    '--entry-file',
+    path.join(__dirname, '../bundle/index.ts'),
+    '--dev',
+    'false',
+    '--skip-server',
+  ],
+  {
+    stdio: 'inherit',
+    cwd: projectRoot,
+    env: {
+      ...process.env,
+      EXPO_OVERRIDE_METRO_CONFIG: path.join(__dirname, '../metro.widget.config.js'),
+    },
+  }
+);
+
+if (result.error) {
+  process.exit(1);
+}