expo-invoke 2.6.15 → 2.7.0

package/bundle/__tests__/decorator.test.ts

@@ -0,0 +1,89 @@
+import '../index';
+import { jsx, jsxs } from '../jsx-runtime-stub';
+
+jest.mock('@expo/ui/swift-ui', () => ({}));
+jest.mock('@expo/ui/swift-ui/modifiers', () => ({}));
+
+describe('jsx-runtime-stub', () => {
+  afterEach(() => {
+    delete globalThis.__expoWidgetLayout;
+  });
+
+  it('adds button targets during render', () => {
+    globalThis.__expoWidgetLayout = () =>
+      jsxs('View', {
+        children: [
+          jsx('Button', { label: 'First', onButtonPress: () => ({ id: 'first' }) }),
+          jsx('Button', { label: 'Second', onButtonPress: () => ({ id: 'second' }) }),
+        ],
+      });
+
+    const tree = globalThis.__expoWidgetRender({}, { timestamp: 1 }) as any;
+
+    expect(tree.props.children[0].props.target).toBe('__expo_widgets_target_0');
+    expect(tree.props.children[1].props.target).toBe('__expo_widgets_target_1');
+  });
+
+  it('uses the nearest keyed parent when generating button targets', () => {
+    globalThis.__expoWidgetLayout = () =>
+      jsx(
+        'Row',
+        {
+          children: jsx('Wrapper', {
+            children: jsx('Button', {
+              label: 'Press',
+              onButtonPress: () => ({ id: 'nested' }),
+            }),
+          }),
+        },
+        'row-1'
+      );
+
+    const tree = globalThis.__expoWidgetRender({}, { timestamp: 1 }) as any;
+
+    expect(tree.props.children.props.children.props.target).toBe('__expo_widgets_target_0_row-1');
+  });
+
+  it('preserves explicit button targets', () => {
+    globalThis.__expoWidgetLayout = () =>
+      jsx('Button', {
+        label: 'Custom',
+        target: 'custom-target',
+        onButtonPress: () => ({ id: 'custom' }),
+      });
+
+    const tree = globalThis.__expoWidgetRender({}, { timestamp: 1 }) as any;
+
+    expect(tree.props.target).toBe('custom-target');
+  });
+
+  it('reuses generated button targets when handling presses', () => {
+    const firstPress = jest.fn(() => ({ id: 'first' }));
+    const secondPress = jest.fn(() => ({ id: 'second' }));
+
+    globalThis.__expoWidgetLayout = () =>
+      jsxs('View', {
+        children: [
+          jsx(
+            'Row',
+            { children: jsx('Button', { label: 'First', onButtonPress: firstPress }) },
+            'row-1'
+          ),
+          jsx(
+            'Row',
+            { children: jsx('Button', { label: 'Second', onButtonPress: secondPress }) },
+            'row-2'
+          ),
+        ],
+      });
+
+    const tree = globalThis.__expoWidgetRender({}, { timestamp: 1 }) as any;
+    const secondTarget = tree.props.children[1].props.children.props.target;
+
+    const result = globalThis.__expoWidgetHandlePress({}, { timestamp: 1, target: secondTarget });
+
+    expect(result).toEqual({ id: 'second' });
+    expect(firstPress).not.toHaveBeenCalled();
+    expect(secondPress).toHaveBeenCalledTimes(1);
+  });
+});

package/bundle/decorator.ts

@@ -0,0 +1,61 @@
+import { ReactElementNode } from './jsx-runtime-stub';
+
+export function decorateInteractiveTargets(node: unknown) {
+  return decorateNode(node, {
+    nearestParentKey: null,
+    nextTargetIndex: {
+      current: 0,
+    },
+    typesToDecorate: ['Button'],
+  });
+}
+
+function decorateNode(
+  node: unknown,
+  context: {
+    nearestParentKey: string | null;
+    nextTargetIndex: {
+      current: number;
+    };
+    typesToDecorate: string[];
+  }
+): unknown {
+  if (Array.isArray(node)) {
+    return node.map((child) => decorateNode(child, context));
+  }
+
+  if (!isReactElementNode(node)) {
+    return node;
+  }
+
+  const props = node.props ?? {};
+
+  if (props.target == null && context.typesToDecorate.includes(node.type as string)) {
+    props.target = buildButtonTargetId(context.nextTargetIndex.current, context.nearestParentKey);
+    context.nextTargetIndex.current += 1;
+  }
+
+  if ('children' in props) {
+    props.children = decorateNode(props.children, {
+      nearestParentKey: node.key ?? context.nearestParentKey,
+      nextTargetIndex: context.nextTargetIndex,
+      typesToDecorate: context.typesToDecorate,
+    });
+  }
+
+  return node;
+}
+
+function isReactElementNode(node: unknown): node is ReactElementNode {
+  return Boolean(node) && typeof node === 'object' && 'type' in node && 'props' in node;
+}
+
+function buildButtonTargetId(index: number, parentKey: string | null) {
+  const baseTarget = `__expo_widgets_target_${index}`;
+
+  if (!parentKey) {
+    return baseTarget;
+  }
+
+  return `${baseTarget}_${parentKey}`;
+}

package/bundle/expo-modules-core-stub.ts

@@ -0,0 +1 @@
+export function useReleasingSharedObject() {}

package/bundle/expo-stub.ts

@@ -0,0 +1,15 @@
+export function requireNativeModule(name: string) {
+  return {};
+}
+
+export function requireNativeView(moduleName: string, viewName: string) {
+  const wrapper = {
+    [viewName]: (props?: Record<string, any>) => {
+      return {
+        type: viewName,
+        props: props || {},
+      };
+    },
+  };
+  return wrapper[viewName] as unknown as React.ComponentType<any>;
+}

package/bundle/index.ts

@@ -0,0 +1,69 @@
+/* eslint-disable no-var */
+
+import * as swiftUI from '@expo/ui/swift-ui';
+import * as modifiers from '@expo/ui/swift-ui/modifiers';
+
+import { decorateInteractiveTargets } from './decorator';
+import * as jsxRuntime from './jsx-runtime-stub';
+import * as ReactNative from './react-native-stub';
+import * as React from './react-stub';
+
+type Dictionary = Record<string, unknown>;
+
+declare global {
+  var __expoWidgetLayout: (props: Dictionary, environment: Dictionary) => Dictionary;
+  var __expoWidgetRender: (props: Dictionary, environment: Dictionary) => Dictionary;
+  var __expoWidgetHandlePress: (
+    props: Dictionary,
+    environment: Dictionary & { target?: string }
+  ) => Dictionary | undefined;
+}
+
+const __expoWidgetRender = function (props: Dictionary, environment: Dictionary) {
+  const { timestamp, ...rest } = environment;
+  const decoratedEnvironment: Dictionary = { ...rest };
+  if (timestamp) {
+    decoratedEnvironment.date = new Date(timestamp as number);
+  }
+
+  return decorateInteractiveTargets(globalThis.__expoWidgetLayout(props, decoratedEnvironment));
+};
+
+const __expoWidgetHandlePress = function (
+  props: Dictionary,
+  environment: Dictionary & { target?: string }
+) {
+  const { target, ...renderEnvironment } = environment;
+
+  function findAndCallOnPress(node?: Dictionary): Dictionary | undefined {
+    const props = node?.props as {
+      onButtonPress?: () => Dictionary;
+      target?: string;
+      children?: unknown;
+    };
+    if (props?.onButtonPress && props?.target === target) {
+      return props.onButtonPress();
+    }
+
+    for (const child of React.Children.toArray(props?.children)) {
+      const result = findAndCallOnPress(child as Dictionary);
+      if (result) {
+        return result;
+      }
+    }
+  }
+
+  const node = globalThis.__expoWidgetRender(props, renderEnvironment);
+  return findAndCallOnPress(node as Dictionary);
+};
+
+Object.assign(globalThis, {
+  ...swiftUI,
+  ...modifiers,
+  ...jsxRuntime,
+  ...React,
+  ...ReactNative,
+  React,
+  __expoWidgetRender,
+  __expoWidgetHandlePress,
+});

package/bundle/jsx-runtime-stub.ts

@@ -0,0 +1,71 @@
+import { Fragment } from './react-stub';
+
+export type ReactElementNode = {
+  type: unknown;
+  key: string | null;
+  props: Record<string, any>;
+};
+
+function ReactElement(
+  type: unknown,
+  key: string | null,
+  props: Record<string, any>
+): ReactElementNode {
+  if (typeof type === 'function') {
+    return (type as any)(props);
+  }
+
+  const element = {
+    type,
+    key,
+    props,
+  };
+
+  return element;
+}
+
+function jsxProd(
+  type: unknown,
+  config: any,
+  maybeKey?: string | number | bigint
+): ReactElementNode {
+  let key = null;
+  if (maybeKey !== undefined) {
+    key = '' + maybeKey;
+  }
+  if (hasValidKey(config)) {
+    key = '' + config.key;
+  }
+
+  let props: Record<string, any>;
+  if (!('key' in config)) {
+    props = config;
+  } else {
+    props = {};
+    for (const propName in config) {
+      if (propName !== 'key') {
+        props[propName] = config[propName];
+      }
+    }
+  }
+
+  return ReactElement(type, key, props);
+}
+
+function hasValidKey(config: any) {
+  return config.key !== undefined;
+}
+
+const jsxFileName = 'widget';
+export {
+  Fragment,
+  Fragment as _Fragment,
+  jsxFileName as _jsxFileName,
+  jsxProd,
+  jsxProd as jsx,
+  jsxProd as jsxs,
+  jsxProd as jsxDEV,
+  jsxProd as _jsx,
+  jsxProd as _jsxs,
+  jsxProd as _jsxDEV,
+};

package/bundle/react-native-stub.ts

@@ -0,0 +1,3 @@
+export const PlatformColor = (...names: string[]) => {
+  return { semantic: names };
+};

package/bundle/react-stub.ts

@@ -0,0 +1,13 @@
+export const Fragment = 'react.fragment';
+
+export const Children = {
+  toArray(children: unknown) {
+    if (children === undefined || children === null) {
+      return [];
+    }
+    return Array.isArray(children) ? children : [children];
+  },
+};
+export const isValidElement = (value: unknown) => {
+  return Boolean(value) && typeof value === 'object' && 'type' in (value as object);
+};

package/expo-module.config.json

@@ -1,7 +1,7 @@
 {
   "platforms": ["ios", "android"],
   "ios": {
-    "modules": ["ExpoInvokeModule"]
+    "modules": ["ExpoInvokeModule", "WidgetsModule"]
   },
   "android": {
     "modules": ["expo.modules.invoke.ExpoInvokeModule"]

package/ios/LiveActivity/LiveActivityManager.swift

@@ -23,21 +23,18 @@ import Foundation
       throw LiveActivityError.invalidConfig
     }
 
-    let activityType = config["activityType"] as? String ?? "UnknownActivity"
-    let contentState = config["contentState"] as? [String: Any] ?? [:]
-    let staleDate = config["staleDate"].flatMap { ($0 as? Double).map { Date(timeIntervalSince1970: $0 / 1000) } }
-    let relevance = config["relevanceScore"] as? Double
-
     let activityId = UUID().uuidString
 
-    // Store config for update/end — actual ActivityKit usage requires generated ActivityAttributes
-    // types, which the codegen produces. We store the info for the bridge layer to use.
-    lock.lock()
-    // Store a placeholder; concrete Activity objects are managed in generated code via
-    // LiveActivityRegistry (generated by plugin/codegen/generateSwiftLiveActivities.ts)
-    lock.unlock()
+    // When ActivityKit is available (iOS 16.1+) AND the plugin has run `npx expo prebuild`
+    // with `enableLiveActivities: true`, the generated InvokeLiveActivities.swift provides
+    // a real ActivityKit-backed extension on this class. That extension is called here.
+    // Without prebuild, activityId is returned but the activity is never registered.
+    #if canImport(ActivityKit)
+    if #available(iOS 16.1, *) {
+      try self.createActivity(activityId: activityId, config: config)
+    }
+    #endif
 
-    _ = staleDate; _ = relevance; _ = contentState; _ = activityType
     return activityId
   }
 
@@ -72,8 +69,11 @@ import Foundation
   }
 }
 
-// LiveActivityRegistry is generated by generateSwiftLiveActivities.ts codegen.
-// Provide a stub so the module compiles without codegen having run yet.
+// LiveActivityRegistry is generated by generateSwiftLiveActivities.ts codegen
+// (runs during `npx expo prebuild` when enableLiveActivities: true).
+// This stub compiles only when ActivityKit is unavailable so it doesn't conflict
+// with the real implementation in InvokeLiveActivities.swift.
+#if !canImport(ActivityKit)
 @objc public class LiveActivityRegistry: NSObject {
   @objc public static let shared = LiveActivityRegistry()
   private override init() {}
@@ -81,3 +81,4 @@ import Foundation
   @objc public func end(activityId: String, finalStateJson: String?) {}
   @objc public func listActivities() -> [[String: Any]] { return [] }
 }
+#endif

package/ios/Module/ExpoInvokeModule.swift

@@ -123,6 +123,130 @@ public class ExpoInvokeModule: Module {
       )
     }
 
+    // ── Widget reload ─────────────────────────────────────────────────────────
+    Function("reloadWidget") { (widgetKind: String?) in
+      if #available(iOS 14.0, *) {
+        WidgetManager.reload(kind: widgetKind)
+      }
+    }
+
+    // ── Live Activity lifecycle (iOS 16.1+) ───────────────────────────────────
+    AsyncFunction("startLiveActivity") { (configJson: String) -> String in
+      if #available(iOS 16.1, *) {
+        return try await LiveActivityManager.shared.startActivity(configJson: configJson)
+      }
+      return ""
+    }
+
+    Function("updateLiveActivity") { (activityId: String, stateJson: String) in
+      if #available(iOS 16.1, *) {
+        LiveActivityManager.shared.updateActivity(activityId: activityId, stateJson: stateJson)
+      }
+    }
+
+    Function("endLiveActivity") { (activityId: String, finalStateJson: String?) in
+      if #available(iOS 16.1, *) {
+        LiveActivityManager.shared.endActivity(activityId: activityId, finalStateJson: finalStateJson)
+      }
+    }
+
+    AsyncFunction("getLiveActivities") { () -> String in
+      if #available(iOS 16.1, *) {
+        let activities = await LiveActivityManager.shared.listActivities()
+        if let data = try? JSONSerialization.data(withJSONObject: activities),
+           let json = String(data: data, encoding: .utf8) {
+          return json
+        }
+      }
+      return "[]"
+    }
+
+    // ── Focus filter result (iOS 16+) ─────────────────────────────────────────
+    Function("reportFocusFilterResult") { (filterId: String, success: Bool) in
+      if #available(iOS 16.0, *) {
+        FocusFilterRegistrar.shared.reportResult(filterId: filterId, success: success)
+      }
+    }
+
+    // ── App Entities (iOS 16.4+) ──────────────────────────────────────────────
+    Function("provideEntityResults") { (entityId: String, resultsJson: String) in
+      if #available(iOS 16.4, *) {
+        guard let data = resultsJson.data(using: .utf8),
+              let results = try? JSONSerialization.jsonObject(with: data) as? [[String: Any]] else {
+          return
+        }
+        EntityQueryBridge.shared.receiveResults(entityId: entityId, results: results)
+      }
+    }
+
+    // ── Background intent (iOS 16+) ───────────────────────────────────────────
+    Function("registerBackgroundHandler") { (_: String) in
+      // No-op: the bridge routes events via writePendingIntent; JS registers via addIntentListener.
+    }
+
+    Function("reportBackgroundResult") { (intentId: String, resultJson: String) in
+      if #available(iOS 16.0, *) {
+        guard let data = resultJson.data(using: .utf8),
+              let result = try? JSONSerialization.jsonObject(with: data) as? [String: Any] else {
+          return
+        }
+        let success = result["success"] as? Bool ?? false
+        let spokenResponse = result["spokenResponse"] as? String
+        let error = result["error"] as? String
+        ExpoInvokeBackgroundBridge.shared.reportResult(
+          intentId: intentId,
+          success: success,
+          spokenResponse: spokenResponse,
+          error: error
+        )
+      }
+    }
+
+    // ── Push-to-Talk (iOS 16+) ────────────────────────────────────────────────
+    AsyncFunction("startPTTSession") { (channelId: String, participantName: String?) in
+      if #available(iOS 16.0, *) {
+        try await PTTManager.shared.startSession(channelId: channelId, participantName: participantName)
+      }
+    }
+
+    AsyncFunction("endPTTSession") { (channelId: String) in
+      if #available(iOS 16.0, *) {
+        try await PTTManager.shared.endSession(channelId: channelId)
+      }
+    }
+
+    AsyncFunction("setTransmitting") { (channelId: String, isTransmitting: Bool) in
+      if #available(iOS 16.0, *) {
+        try await PTTManager.shared.setTransmitting(isTransmitting, channelId: channelId)
+      }
+    }
+
+    AsyncFunction("getPTTState") { (channelId: String) -> String in
+      let state: [String: Any]
+      if #available(iOS 16.0, *) {
+        state = PTTManager.shared.getState(channelId: channelId)
+      } else {
+        state = ["isActive": false, "isTransmitting": false]
+      }
+      guard let data = try? JSONSerialization.data(withJSONObject: state),
+            let json = String(data: data, encoding: .utf8) else {
+        return "{\"isActive\":false,\"isTransmitting\":false}"
+      }
+      return json
+    }
+
+    // ── Android Slices — no-op on iOS ─────────────────────────────────────────
+    Function("notifySliceChange") { (_: String) in /* iOS no-op */ }
+
+    // ── Persistent analytics — managed in JS, no native storage needed ────────
+    AsyncFunction("getAnalyticsPersisted") { () -> String in
+      return "{\"fired\":{},\"donated\":{},\"bySource\":{}}"
+    }
+
+    AsyncFunction("clearAnalyticsPersisted") {
+      // No-op: JS layer handles clearing via expo-file-system.
+    }
+
     // ── Focus mode ────────────────────────────────────────────────────────────
     Function("getFocusMode") { () -> String? in
       return FocusFilterManager.currentFocusMode()

package/ios/Widget/WidgetManager.swift

@@ -1,19 +1,36 @@
 import Foundation
 
-/// Triggers a reload of all WidgetKit widget timelines so they display fresh data
-/// after setWidgetData() is called.
+/// Triggers WidgetKit timeline reloads via reflection to avoid hard-linking WidgetKit.
 public struct WidgetManager {
+
   @available(iOS 14.0, *)
   public static func reloadAll() {
-    // WidgetCenter is in WidgetKit — use performSelector to avoid hard linking
-    // the framework in packages that don't need it.
-    if let widgetCenter = NSClassFromString("WidgetKit.WidgetCenter") as? NSObject.Type,
-       let center = widgetCenter.value(forKey: "shared") as? NSObject {
-      center.performSelector(inBackground: #selector(NSObject.reloadAllTimelines), with: nil)
+    guard let center = widgetCenter() else { return }
+    center.performSelector(inBackground: #selector(NSObject._invokeReloadAllTimelines), with: nil)
+  }
+
+  /// Reload a specific widget kind. Falls back to reloading all timelines if kind is nil.
+  @available(iOS 14.0, *)
+  public static func reload(kind: String?) {
+    guard let kind = kind, !kind.isEmpty else {
+      reloadAll()
+      return
     }
+    guard let center = widgetCenter() else { return }
+    let sel = NSSelectorFromString("reloadTimelinesOfKind:")
+    if center.responds(to: sel) {
+      center.perform(sel, with: kind)
+    } else {
+      center.performSelector(inBackground: #selector(NSObject._invokeReloadAllTimelines), with: nil)
+    }
+  }
+
+  private static func widgetCenter() -> NSObject? {
+    guard let cls = NSClassFromString("WidgetKit.WidgetCenter") as? NSObject.Type else { return nil }
+    return cls.value(forKey: "shared") as? NSObject
   }
 }
 
 extension NSObject {
-  @objc func reloadAllTimelines() {}
+  @objc func _invokeReloadAllTimelines() {}
 }

package/ios/Widgets/LiveActivity.swift

@@ -0,0 +1,81 @@
+import ExpoModulesCore
+import ActivityKit
+
+final class LiveActivity: SharedObject {
+  let id: String
+  let name: String
+  private var pushTokenObserverTask: Task<Void, Never>?
+
+  init(id: String, name: String) {
+    self.id = id
+    self.name = name
+    super.init()
+  }
+
+  func update(props: String?) async throws {
+    guard #available(iOS 16.2, *) else { throw LiveActivitiesNotSupportedException() }
+
+    guard let activity = Activity<LiveActivityAttributes>.activities.first(where: { $0.id == id }) else {
+      throw LiveActivityNotFoundException(id)
+    }
+
+    let newState = LiveActivityAttributes.ContentState(name: name, props: props)
+    await activity.update(ActivityContent(state: newState, staleDate: nil))
+  }
+
+  func end(dismissalPolicy: LiveActivityDismissalPolicy?, afterDate: Date?, props: String?, contentDate: Date?) async throws {
+    guard #available(iOS 16.2, *) else { throw LiveActivitiesNotSupportedException() }
+
+    guard let activity = Activity<LiveActivityAttributes>.activities.first(where: { $0.id == id }) else {
+      throw LiveActivityNotFoundException(id)
+    }
+
+    let content: ActivityContent<LiveActivityAttributes.ContentState>?
+    if let props {
+      content = ActivityContent(state: LiveActivityAttributes.ContentState(name: name, props: props), staleDate: nil)
+    } else {
+      content = nil
+    }
+
+    guard let contentDate, #available(iOS 17.2, *) else {
+      return await activity.end(content, dismissalPolicy: dismissalPolicy?.toDismissalPolicy(date: afterDate) ?? .default)
+    }
+
+    await activity.end(content, dismissalPolicy: dismissalPolicy?.toDismissalPolicy(date: afterDate) ?? .default, timestamp: contentDate)
+  }
+
+  func getPushToken() throws -> String? {
+    guard #available(iOS 16.1, *) else { throw LiveActivitiesNotSupportedException() }
+
+    guard let activity = Activity<LiveActivityAttributes>.activities.first(where: { $0.id == id }) else {
+      throw LiveActivityNotFoundException(id)
+    }
+
+    guard let tokenData = activity.pushToken else { return nil }
+
+    return tokenData.reduce("") { $0 + String(format: "%02x", $1) }
+  }
+
+  @available(iOS 16.1, *)
+  func observePushTokenUpdates(for activity: Activity<LiveActivityAttributes>, pushNotificationsEnabled: Bool) {
+    guard pushNotificationsEnabled else {
+      return
+    }
+
+    pushTokenObserverTask?.cancel()
+    pushTokenObserverTask = Task {
+      for await data in activity.pushTokenUpdates {
+        let token = data.reduce("") { $0 + String(format: "%02x", $1) }
+        emit(event: onTokenReceived, payload: [
+          "activityId": activity.id,
+          "pushToken": token
+        ])
+      }
+    }
+  }
+
+  override func sharedObjectWillRelease() {
+    pushTokenObserverTask?.cancel()
+    pushTokenObserverTask = nil
+  }
+}