@use-voltra/ios-client 1.4.1 → 2.0.0-rc.1

package/expo-plugin/src/ios-widget/files/swift.node.test.ts

@@ -0,0 +1,22 @@
+import { __test__ } from './swift'
+
+describe('generateInitialStatesSwift', () => {
+  it('embeds the locale helper into generated initial states Swift', () => {
+    const swift = __test__.generateInitialStatesSwift(
+      new Map([
+        [
+          'weather',
+          new Map([
+            ['en-US', '{"ok":true}'],
+            ['pl', '{"ok":false}'],
+          ]),
+        ],
+      ])
+    )
+
+    expect(swift).toContain('private enum VoltraGeneratedInitialStateLocale')
+    expect(swift).toContain('VoltraGeneratedInitialStateLocale.preferredLanguageTags()')
+    expect(swift).toContain('VoltraGeneratedInitialStateLocale.pickJson(from: perLocale, preferredLanguages: tags)')
+    expect(swift).not.toContain('VoltraInitialStateLocale.preferredLanguageTags()')
+  })
+})

package/expo-plugin/src/ios-widget/files/swift.ts

@@ -0,0 +1,476 @@
+import dedent from 'dedent'
+import * as fs from 'fs'
+import * as path from 'path'
+
+import {
+  isWidgetLocalizedMap,
+  logger,
+  prerenderWidgetState,
+  widgetLabelEnglish,
+  type PrerenderedWidgetStates,
+  type WidgetLabel,
+} from '@use-voltra/expo-plugin'
+
+import { DEFAULT_WIDGET_FAMILIES, WIDGET_FAMILY_MAP } from '../../constants'
+import type { IOSWidgetConfig } from '../../types'
+import { VOLTRA_WIDGET_STRINGS_BASENAME } from '../../utils/fileDiscovery'
+
+export interface GenerateSwiftFilesOptions {
+  targetPath: string
+  projectRoot: string
+  widgets?: IOSWidgetConfig[]
+}
+
+type RenderWidgetToString = (variants: unknown) => string
+
+// ============================================================================
+// Main Function
+// ============================================================================
+
+/**
+ * Generates all Swift files for the widget extension.
+ *
+ * This creates:
+ * - VoltraWidgetInitialStates.swift (pre-rendered widget states)
+ * - VoltraWidgetBundle.swift (widget bundle definition)
+ */
+export async function generateSwiftFiles(options: GenerateSwiftFilesOptions): Promise<void> {
+  const { targetPath, projectRoot, widgets } = options
+
+  // Dynamic import keeps the plugin CommonJS-compatible while resolving the current package entry.
+  const serverModuleId = '@use-voltra/ios/server'
+  const { renderWidgetToString } = (await import(serverModuleId)) as {
+    renderWidgetToString: RenderWidgetToString
+  }
+
+  // Prerender widget initial states if any widgets have initialStatePath configured
+  const prerenderedStates = await prerenderWidgetState(widgets || [], projectRoot, renderWidgetToString)
+
+  syncVoltraWidgetGalleryStrings(targetPath, widgets)
+
+  // Generate the initial states Swift file
+  const initialStatesContent = generateInitialStatesSwift(prerenderedStates)
+  const initialStatesPath = path.join(targetPath, 'VoltraWidgetInitialStates.swift')
+  fs.writeFileSync(initialStatesPath, initialStatesContent)
+
+  logger.info(
+    `Generated VoltraWidgetInitialStates.swift with ${prerenderedStates.size} widget(s) (localized initial states where configured)`
+  )
+
+  // Generate the widget bundle Swift file
+  const widgetBundleContent =
+    widgets && widgets.length > 0 ? generateWidgetBundleSwift(widgets) : generateDefaultWidgetBundleSwift()
+
+  const widgetBundlePath = path.join(targetPath, 'VoltraWidgetBundle.swift')
+  fs.writeFileSync(widgetBundlePath, widgetBundleContent)
+
+  logger.info(`Generated VoltraWidgetBundle.swift with ${widgets?.length ?? 0} home screen widgets`)
+}
+
+const GENERATED_INITIAL_STATE_LOCALE_HELPER = dedent`
+  private enum VoltraGeneratedInitialStateLocale {
+    static func pickJson(from perLocale: [String: String], preferredLanguages: [String]) -> String? {
+      let entries = perLocale.filter { !$0.value.isEmpty }
+      if entries.isEmpty {
+        return nil
+      }
+
+      func normalize(_ tag: String) -> String {
+        tag.trimmingCharacters(in: .whitespacesAndNewlines)
+          .lowercased()
+          .replacingOccurrences(of: "_", with: "-")
+      }
+
+      var byNorm: [String: String] = [:]
+      for (k, v) in entries {
+        byNorm[normalize(k)] = v
+      }
+
+      for pref in preferredLanguages {
+        let n = normalize(pref)
+        if let direct = byNorm[n] {
+          return direct
+        }
+        let lang = n.split(separator: "-").first.map(String.init) ?? n
+        for (key, val) in entries {
+          let kn = normalize(key)
+          let keyLang = kn.split(separator: "-").first.map(String.init) ?? kn
+          if keyLang == lang {
+            return val
+          }
+        }
+      }
+
+      if let en = byNorm["en"] {
+        return en
+      }
+      if let englishFamily = entries.keys.sorted().first(where: {
+        let normalized = normalize($0)
+        return normalized == "en" || normalized.hasPrefix("en-")
+      }) {
+        return entries[englishFamily]
+      }
+      if let def = byNorm["__default"] {
+        return def
+      }
+
+      let sorted = entries.keys.sorted()
+      guard let firstKey = sorted.first else {
+        return nil
+      }
+      return entries[firstKey]
+    }
+
+    static func preferredLanguageTags() -> [String] {
+      Locale.preferredLanguages
+    }
+  }
+`
+
+// ============================================================================
+// Widget gallery localization: *.lproj/VoltraWidgets.strings + LocalizedStringResource
+//
+// We use classic .strings tables (not .xcstrings): the `xcode` npm library assigns
+// unknown lastKnownFileType to .xcstrings, so Xcode may not treat them as string tables
+// and lookups fall back to English defaultValue.
+//
+// LocalizedStringResource is still appropriate for extensions (deferred resolution).
+// https://developer.apple.com/documentation/foundation/localizedstringresource
+// ============================================================================
+
+function escapeForSwiftStringLiteral(s: string): string {
+  return s.replace(/\\/g, '\\\\').replace(/"/g, '\\"').replace(/\n/g, '\\n').replace(/\r/g, '\\r')
+}
+
+function escapeDotStringsValue(s: string): string {
+  return escapeForSwiftStringLiteral(s)
+}
+
+function collectGalleryStringsByLocale(widgets: IOSWidgetConfig[]): Map<string, Record<string, string>> {
+  const byLocale = new Map<string, Record<string, string>>()
+
+  const add = (locale: string, key: string, value: string) => {
+    let bucket = byLocale.get(locale)
+    if (!bucket) {
+      bucket = {}
+      byLocale.set(locale, bucket)
+    }
+    bucket[key] = value
+  }
+
+  for (const w of widgets) {
+    if (isWidgetLocalizedMap(w.displayName)) {
+      const key = `voltra_widget_${w.id}_displayName`
+      for (const [locale, val] of Object.entries(w.displayName)) {
+        if (typeof val === 'string' && val.trim()) {
+          add(locale, key, val)
+        }
+      }
+    }
+    if (isWidgetLocalizedMap(w.description)) {
+      const key = `voltra_widget_${w.id}_description`
+      for (const [locale, val] of Object.entries(w.description)) {
+        if (typeof val === 'string' && val.trim()) {
+          add(locale, key, val)
+        }
+      }
+    }
+  }
+
+  return byLocale
+}
+
+function formatVoltraWidgetsStringsFile(entries: Record<string, string>): string {
+  const sortedKeys = Object.keys(entries).sort()
+  const lines = sortedKeys.map((k) => `"${k}" = "${escapeDotStringsValue(entries[k]!)}";`)
+  return `/* Voltra widget gallery strings (auto-generated) */\n${lines.join('\n')}\n`
+}
+
+/** Remove generated gallery strings and obsolete string catalog before rewriting. */
+function clearVoltraWidgetGalleryStringArtifacts(targetPath: string): void {
+  const catalogPath = path.join(targetPath, 'VoltraWidgets.xcstrings')
+  if (fs.existsSync(catalogPath)) {
+    fs.unlinkSync(catalogPath)
+  }
+
+  if (!fs.existsSync(targetPath)) {
+    return
+  }
+
+  for (const entry of fs.readdirSync(targetPath)) {
+    if (!entry.endsWith('.lproj')) {
+      continue
+    }
+    const stringsPath = path.join(targetPath, entry, VOLTRA_WIDGET_STRINGS_BASENAME)
+    if (fs.existsSync(stringsPath)) {
+      fs.unlinkSync(stringsPath)
+    }
+    const dirPath = path.join(targetPath, entry)
+    try {
+      if (fs.existsSync(dirPath) && fs.readdirSync(dirPath).length === 0) {
+        fs.rmdirSync(dirPath)
+      }
+    } catch {
+      /* ignore */
+    }
+  }
+}
+
+/**
+ * Writes `<locale>.lproj/VoltraWidgets.strings` for locale-map gallery labels.
+ */
+function syncVoltraWidgetGalleryStrings(targetPath: string, widgets: IOSWidgetConfig[] | undefined): void {
+  const list = widgets ?? []
+  clearVoltraWidgetGalleryStringArtifacts(targetPath)
+
+  if (list.length === 0) {
+    return
+  }
+
+  const byLocale = collectGalleryStringsByLocale(list)
+  if (byLocale.size === 0) {
+    return
+  }
+
+  for (const [locale, kv] of byLocale) {
+    const lproj = path.join(targetPath, `${locale}.lproj`)
+    fs.mkdirSync(lproj, { recursive: true })
+    fs.writeFileSync(path.join(lproj, VOLTRA_WIDGET_STRINGS_BASENAME), formatVoltraWidgetsStringsFile(kv), 'utf8')
+  }
+}
+
+function widgetUsesGalleryLocalization(widget: IOSWidgetConfig): boolean {
+  return isWidgetLocalizedMap(widget.displayName) || isWidgetLocalizedMap(widget.description)
+}
+
+/**
+ * Widget gallery title / description: deferred lookup via LocalizedStringResource when using a locale map
+ * (recommended for extensions); plain Text for single-string config.
+ */
+function iosWidgetGalleryLabelSwiftExpr(
+  widgetId: string,
+  field: 'displayName' | 'description',
+  label: WidgetLabel
+): string {
+  if (!isWidgetLocalizedMap(label)) {
+    return `Text("${escapeForSwiftStringLiteral(label)}")`
+  }
+
+  const key = `voltra_widget_${widgetId}_${field}`
+  const defaultEnglish = escapeForSwiftStringLiteral(widgetLabelEnglish(label))
+
+  return `Text(LocalizedStringResource("${key}", defaultValue: String.LocalizationValue("${defaultEnglish}"), table: "VoltraWidgets"))`
+}
+
+/**
+ * Generates Swift code for a single widget struct
+ */
+function generateWidgetStruct(widget: IOSWidgetConfig): string {
+  const families = widget.supportedFamilies ?? DEFAULT_WIDGET_FAMILIES
+  const familiesSwift = families.map((f) => WIDGET_FAMILY_MAP[f]).join(', ')
+
+  // Sanitize the widget id for use as a Swift identifier
+  const structName = `VoltraWidget_${widget.id}`
+
+  const displayNameExpr = iosWidgetGalleryLabelSwiftExpr(widget.id, 'displayName', widget.displayName)
+  const descriptionExpr = iosWidgetGalleryLabelSwiftExpr(widget.id, 'description', widget.description)
+
+  return dedent`
+    public struct ${structName}: Widget {
+      private let widgetId = "${widget.id}"
+
+      public init() {}
+
+      public var body: some WidgetConfiguration {
+        StaticConfiguration(
+          kind: "Voltra_Widget_${widget.id}",
+          provider: VoltraHomeWidgetProvider(
+            widgetId: widgetId,
+            initialState: VoltraWidgetInitialStates.getInitialState(for: widgetId)
+          )
+        ) { entry in
+          VoltraHomeWidgetView(entry: entry)
+        }
+        .configurationDisplayName(${displayNameExpr})
+        .description(${descriptionExpr})
+        .supportedFamilies([${familiesSwift}])
+        .contentMarginsDisabled()
+      }
+    }
+  `
+}
+
+/**
+ * Generates the VoltraWidgetBundle.swift file content with configured widgets
+ */
+function generateWidgetBundleSwift(widgets: IOSWidgetConfig[]): string {
+  // Generate widget structs
+  const widgetStructs = widgets.map(generateWidgetStruct).join('\n\n')
+
+  // Generate widget bundle body entries
+  const widgetInstances = widgets.map((w) => `VoltraWidget_${w.id}()`).join('\n    ')
+
+  const needsFoundation = widgets.some(widgetUsesGalleryLocalization)
+  const foundationImport = needsFoundation ? 'import Foundation\n' : ''
+
+  return dedent`
+    //
+    //  VoltraWidgetBundle.swift
+    //
+    //  Auto-generated by Voltra config plugin.
+    //  This file defines which Voltra widgets are available in your app.
+    //
+
+    ${foundationImport}import SwiftUI
+    import WidgetKit
+    import VoltraWidget
+
+    @main
+    struct VoltraWidgetBundle: WidgetBundle {
+      var body: some Widget {
+        // Live Activity (with Watch/CarPlay support)
+        VoltraWidget()
+
+        // Home Screen Widgets
+        ${widgetInstances}
+      }
+    }
+
+    // MARK: - Home Screen Widget Definitions
+
+    ${widgetStructs}
+  `
+}
+
+/**
+ * Generates the VoltraWidgetBundle.swift file content when no widgets are configured
+ * (only Live Activities)
+ */
+function generateDefaultWidgetBundleSwift(): string {
+  return dedent`
+    //
+    //  VoltraWidgetBundle.swift
+    //
+    //  This file defines which Voltra widgets are available in your app.
+    //  You can customize which widgets to include by adding or removing them below.
+    //
+
+    import SwiftUI
+    import WidgetKit
+    import VoltraWidget  // Import Voltra widgets
+
+    @main
+    struct VoltraWidgetBundle: WidgetBundle {
+      var body: some Widget {
+        // Live Activity (with Watch/CarPlay support)
+        VoltraWidget()
+      }
+    }
+  `
+}
+
+// ============================================================================
+// Initial States
+// ============================================================================
+
+/**
+ * Generates Swift code that bundles pre-rendered widget initial states (per locale when configured).
+ */
+function generateInitialStatesSwift(prerenderedStates: PrerenderedWidgetStates): string {
+  if (prerenderedStates.size === 0) {
+    return generateEmptyInitialStatesSwift()
+  }
+
+  const widgetEntries = Array.from(prerenderedStates.entries())
+    .map(([widgetId, perLocale]) => {
+      const localeEntries = Array.from(perLocale.entries())
+        .map(([localeKey, json]) => {
+          const delimiter = getSwiftRawStringDelimiter(json)
+          return `"${escapeForSwiftStringLiteral(localeKey)}": ${delimiter}"${json}"${delimiter}`
+        })
+        .join(',\n        ')
+      return `"${widgetId}": [\n        ${localeEntries}\n      ]`
+    })
+    .join(',\n    ')
+
+  return dedent`
+    //
+    //  VoltraWidgetInitialStates.swift
+    //
+    //  Auto-generated by Voltra config plugin.
+    //  Contains pre-rendered initial states for home screen widgets.
+    //
+
+    import Foundation
+
+    ${GENERATED_INITIAL_STATE_LOCALE_HELPER}
+
+    public enum VoltraWidgetInitialStates {
+      private static let bundledLocalizedStates: [String: [String: String]] = [
+        ${widgetEntries}
+      ]
+
+      /// Get the bundled initial state JSON for a widget, matching the device locale when multiple locales were built.
+      /// Returns nil if no initial state was configured for the widget.
+      public static func getInitialState(for widgetId: String) -> Data? {
+        guard let perLocale = bundledLocalizedStates[widgetId] else { return nil }
+        let tags = VoltraGeneratedInitialStateLocale.preferredLanguageTags()
+        guard let jsonString = VoltraGeneratedInitialStateLocale.pickJson(from: perLocale, preferredLanguages: tags) else {
+          return nil
+        }
+        return jsonString.data(using: .utf8)
+      }
+    }
+  `
+}
+
+/**
+ * Generates empty Swift code when no widgets have initial states configured.
+ */
+function generateEmptyInitialStatesSwift(): string {
+  return dedent`
+    //
+    //  VoltraWidgetInitialStates.swift
+    //
+    //  Auto-generated by Voltra config plugin.
+    //  No widget initial states configured.
+    //
+
+    import Foundation
+
+    public enum VoltraWidgetInitialStates {
+      /// Get the bundled initial state JSON for a widget.
+      /// Always returns nil since no initial states are configured.
+      public static func getInitialState(for widgetId: String) -> Data? {
+        return nil
+      }
+    }
+  `
+}
+
+/**
+ * Determines the appropriate Swift raw string delimiter for a given string.
+ * Counts the maximum consecutive '#' characters after a '"' in the content
+ * and returns a delimiter with one more '#' than that maximum.
+ *
+ * For example:
+ * - Content has no '"#' → returns '#'
+ * - Content has '"#' (1 hash) → returns '##'
+ * - Content has '"##' (2 hashes) → returns '###'
+ */
+function getSwiftRawStringDelimiter(str: string): string {
+  // Find all sequences of '#' that follow a '"'
+  const matches = str.match(/"#+/g)
+
+  if (!matches) {
+    return '#'
+  }
+
+  // Find the maximum number of consecutive '#' after a '"'
+  const maxHashes = Math.max(...matches.map((m) => m.length - 1)) // -1 to exclude the '"'
+  return '#'.repeat(maxHashes + 1)
+}
+
+export const __test__ = {
+  generateInitialStatesSwift,
+}

package/expo-plugin/src/ios-widget/fonts.ts

@@ -0,0 +1,132 @@
+/**
+ * Font configuration for Live Activity extension.
+ *
+ * This code is adapted from expo-font to support custom fonts in Live Activities.
+ * @see https://github.com/expo/expo/tree/main/packages/expo-font/plugin
+ *
+ * I would love to reuse the existing expo-font infrastructure, but it's not that easy to do. I'll most likely revisit it later.
+ */
+
+import { type ConfigPlugin, type InfoPlist, IOSConfig, withDangerousMod, withXcodeProject } from '@expo/config-plugins'
+import plist from '@expo/plist'
+import type { ExpoConfig } from 'expo/config'
+import { readFileSync, writeFileSync } from 'fs'
+import * as path from 'path'
+
+import { logger } from '@use-voltra/expo-plugin'
+import { resolveFontPaths } from '@use-voltra/expo-plugin'
+
+/**
+ * Plugin that adds custom fonts to the Live Activity extension.
+ *
+ * @param config - The Expo config
+ * @param fonts - Array of font file paths or directories
+ * @param targetName - Name of the Live Activity extension target
+ * @returns Modified config
+ */
+export const withFonts: ConfigPlugin<{ fonts: string[]; targetName: string }> = (config, { fonts, targetName }) => {
+  if (!fonts || fonts.length === 0) {
+    return config
+  }
+
+  config = addFontsToTarget(config, fonts, targetName)
+  config = addFontsToPlist(config, fonts, targetName)
+  return config
+}
+
+/**
+ * Adds font files to the Live Activity extension target.
+ * This ensures fonts are bundled with the extension and accessible at runtime.
+ */
+function addFontsToTarget(config: ExpoConfig, fonts: string[], targetName: string) {
+  return withXcodeProject(config, async (config) => {
+    if (config.modRequest.introspect) {
+      return config
+    }
+
+    const resolvedFonts = await resolveFontPaths(fonts, config.modRequest.projectRoot)
+    const project = config.modResults
+    const platformProjectRoot = config.modRequest.platformProjectRoot
+    const targetUuid = project.findTargetKey(targetName)
+
+    if (targetUuid == null) {
+      throw new Error(`Target ${targetName} not found in Xcode project. Report this issue to the Voltra team.`)
+    }
+
+    IOSConfig.XcodeUtils.ensureGroupRecursively(project, 'VoltraResources')
+
+    for (const font of resolvedFonts) {
+      const fontPath = path.relative(platformProjectRoot, font)
+
+      IOSConfig.XcodeUtils.addResourceFileToGroup({
+        filepath: fontPath,
+        groupName: 'VoltraResources',
+        project,
+        isBuildFile: true,
+        verbose: true,
+        targetUuid,
+      })
+
+      logger.info(`Added font file: ${path.basename(font)}`)
+    }
+
+    return config
+  })
+}
+
+/**
+ * Adds font filenames to the Live Activity extension's Info.plist UIAppFonts array.
+ * This makes iOS aware of the custom fonts and allows them to be used in SwiftUI.
+ */
+function addFontsToPlist(config: ExpoConfig, fonts: string[], targetName: string) {
+  return withDangerousMod(config, [
+    'ios',
+    async (config) => {
+      if (config.modRequest.introspect) {
+        return config
+      }
+
+      const resolvedFonts = await resolveFontPaths(fonts, config.modRequest.projectRoot)
+      const platformProjectRoot = config.modRequest.platformProjectRoot
+
+      // Read the Live Activity extension's Info.plist directly
+      const targetPath = path.join(platformProjectRoot, targetName)
+      const infoPlistPath = path.join(targetPath, 'Info.plist')
+
+      try {
+        const plistContent = plist.parse(readFileSync(infoPlistPath, 'utf8')) as InfoPlist
+
+        // Get existing fonts or initialize empty array
+        const existingFonts = getUIAppFonts(plistContent)
+
+        // Add new fonts
+        const fontList = resolvedFonts.map((font) => path.basename(font))
+        const allFonts = [...existingFonts, ...fontList]
+        plistContent.UIAppFonts = Array.from(new Set(allFonts))
+
+        // Write back to file
+        writeFileSync(infoPlistPath, plist.build(plistContent))
+
+        logger.info(`Added ${fontList.length} font(s) to ${targetName} Info.plist`)
+      } catch (error) {
+        logger.warn(`Could not update Info.plist for fonts: ${error}`)
+      }
+
+      return config
+    },
+  ])
+}
+
+/**
+ * Retrieves existing UIAppFonts from Info.plist.
+ *
+ * @param infoPlist - Info.plist object
+ * @returns Array of font filenames
+ */
+function getUIAppFonts(infoPlist: InfoPlist): string[] {
+  const fonts = infoPlist['UIAppFonts']
+  if (fonts != null && Array.isArray(fonts) && fonts.every((font) => typeof font === 'string')) {
+    return fonts as string[]
+  }
+  return []
+}

package/expo-plugin/src/ios-widget/index.ts

@@ -0,0 +1,73 @@
+import { ConfigPlugin, withPlugins } from '@expo/config-plugins'
+
+import type { IOSWidgetConfig } from '../types'
+import { configureEasBuild } from './eas'
+import { generateWidgetExtensionFiles } from './files'
+import { withFonts } from './fonts'
+import { configurePodfile } from './podfile'
+import { configureWidgetExtensionPlist } from './widgetPlist'
+import { configureXcodeProject } from './xcode'
+
+export interface WithIOSProps {
+  targetName: string
+  bundleIdentifier: string
+  deploymentTarget: string
+  widgets?: IOSWidgetConfig[]
+  groupIdentifier?: string
+  keychainGroup?: string
+  fonts?: string[]
+  version: string
+  buildNumber: string
+}
+
+/**
+ * Main iOS configuration plugin.
+ *
+ * This orchestrates all iOS-related configuration in the correct order:
+ * 1. Add custom fonts (if provided)
+ * 2. Configure Xcode project (targets, build phases, groups)
+ * 3. Configure Podfile for widget extension
+ * 4. Configure main app Info.plist (URL schemes)
+ * 5. Configure EAS build settings
+ * 6. Generate widget extension files (Swift, assets, plist, entitlements)
+ *
+ * NOTE: Expo mods execute in REVERSE registration order. Plugins that depend
+ * on modifications from other plugins must be registered BEFORE their dependencies.
+ * For example, fonts plugin needs the target created by configureXcodeProject,
+ * so fonts must be registered before configureXcodeProject.
+ */
+export const withIOS: ConfigPlugin<WithIOSProps> = (config, props) => {
+  const {
+    targetName,
+    bundleIdentifier,
+    deploymentTarget,
+    widgets,
+    groupIdentifier,
+    keychainGroup,
+    fonts,
+    version,
+    buildNumber,
+  } = props
+
+  const plugins: [ConfigPlugin<any>, any][] = [
+    // 1. Add custom fonts if provided
+    ...(fonts && fonts.length > 0 ? [[withFonts, { fonts, targetName }] as [ConfigPlugin<any>, any]] : []),
+
+    // 2. Configure Xcode project (creates the target - must run before fonts mod executes)
+    [configureXcodeProject, { targetName, bundleIdentifier, deploymentTarget }],
+
+    // 3. Configure Podfile for widget extension target
+    [configurePodfile, { targetName }],
+
+    // 4. Configure main app Info.plist (URL schemes, widget extension plist)
+    [configureWidgetExtensionPlist, { targetName, groupIdentifier, widgets, keychainGroup }],
+
+    // 5. Configure EAS build settings
+    [configureEasBuild, { targetName, bundleIdentifier, groupIdentifier }],
+
+    // 6. Generate widget extension files (dangerous mod should run before plist patchers)
+    [generateWidgetExtensionFiles, { targetName, widgets, groupIdentifier, keychainGroup, version, buildNumber }],
+  ]
+
+  return withPlugins(config, plugins)
+}