voltra 2.0.0-rc.4 → 2.1.0

package/src/platforms/android/gradle.ts

@@ -0,0 +1,155 @@
+import path from 'node:path'
+
+import { normalizeRelativePath, toRelativePath } from '../../fs/path'
+import { readTextFile, writeTextFile } from '../../fs/readWrite'
+
+import type { AndroidProjectDiscovery } from '../../discovery/android'
+import type { ReportedChange } from '../../reporting/summary'
+
+const MARKER = '// @voltra-widget-bundling'
+const END_MARKER = '// @voltra-widget-bundling-end'
+
+export interface EnsureAndroidGradleWidgetBundlingOptions {
+  projectRoot: string
+  discovery: AndroidProjectDiscovery
+  hasDynamicWidgets: boolean
+}
+
+export interface EnsureAndroidGradleWidgetBundlingResult {
+  change?: ReportedChange
+  warnings?: string[]
+}
+
+export async function ensureAndroidGradleWidgetBundling(
+  options: EnsureAndroidGradleWidgetBundlingOptions
+): Promise<EnsureAndroidGradleWidgetBundlingResult> {
+  const { projectRoot, discovery, hasDynamicWidgets } = options
+  const isKotlinDsl = discovery.buildGradlePath.endsWith('.kts')
+  const projectRootRelativeToAppModule =
+    normalizeRelativePath(path.relative(discovery.appModuleRoot, projectRoot)) || '.'
+
+  if (isKotlinDsl) {
+    if (!hasDynamicWidgets) {
+      return {}
+    }
+
+    return {
+      warnings: ['Voltra: app/build.gradle is not Groovy - skipping Dynamic Widget release bundling wiring.'],
+    }
+  }
+
+  const previousContent = await readTextFile(discovery.buildGradlePath)
+  const removal = removeDynamicWidgetBundlingSnippet(previousContent, projectRootRelativeToAppModule)
+  const nextContent = hasDynamicWidgets
+    ? addDynamicWidgetBundlingSnippet(removal.contents, projectRootRelativeToAppModule)
+    : removal.contents
+
+  if (nextContent === previousContent) {
+    return removal.warning ? { warnings: [removal.warning] } : {}
+  }
+
+  await writeTextFile(discovery.buildGradlePath, nextContent)
+
+  return {
+    change: {
+      kind: 'updated',
+      path: toRelativePath(projectRoot, discovery.buildGradlePath),
+    },
+    warnings: removal.warning ? [removal.warning] : undefined,
+  }
+}
+
+export function addDynamicWidgetBundlingSnippet(contents: string, projectRootRelativeToAppModule: string): string {
+  if (contents.includes(MARKER)) {
+    return contents
+  }
+
+  return `${contents.trimEnd()}\n\n${createDynamicWidgetBundlingSnippet(projectRootRelativeToAppModule)}\n`
+}
+
+export function removeDynamicWidgetBundlingSnippet(
+  contents: string,
+  projectRootRelativeToAppModule: string
+): { contents: string; warning?: string } {
+  const range = findManagedSnippetRange(contents)
+
+  if (range) {
+    return {
+      contents: collapseRemovedRange(contents, range.start, range.end),
+    }
+  }
+
+  const legacySnippet = createLegacyDynamicWidgetBundlingSnippet(projectRootRelativeToAppModule)
+  const legacyIndex = contents.indexOf(legacySnippet)
+
+  if (legacyIndex >= 0) {
+    return {
+      contents: collapseRemovedRange(contents, legacyIndex, legacyIndex + legacySnippet.length),
+    }
+  }
+
+  if (!contents.includes(MARKER)) {
+    return { contents }
+  }
+
+  return {
+    contents,
+    warning:
+      'Voltra: found legacy Dynamic Widget Gradle marker without managed end marker. Preserved trailing Gradle content; remove old @voltra-widget-bundling block manually if no longer needed.',
+  }
+}
+
+function createDynamicWidgetBundlingSnippet(projectRootRelativeToAppModule: string): string {
+  return `
+${MARKER}
+def voltraProjectRoot = file("${projectRootRelativeToAppModule}")
+def voltraWidgetAssetsDir = file("\${buildDir}/generated/voltra/assets")
+android.sourceSets.getByName("main").assets.srcDir(voltraWidgetAssetsDir)
+
+def voltraBundleWidgets = tasks.register("voltraBundleWidgets", Exec) {
+    description = "Bake Dynamic Widget Voltra bundles into assets (release)."
+    workingDir voltraProjectRoot
+    environment "VOLTRA_PROJECT_ROOT", voltraProjectRoot.absolutePath
+    environment "VOLTRA_OUT_DIR", new File(voltraWidgetAssetsDir, "voltra").absolutePath
+    environment "VOLTRA_BUNDLER_RESOLVER", "const m=require('module'),p=require('path');process.stdout.write(m.createRequire(p.join(process.argv[1],'package.json')).resolve('@use-voltra/metro/bundle-widgets'))"
+    commandLine "bash", "-c", 'BUNDLER="$(node -e "$VOLTRA_BUNDLER_RESOLVER" "$VOLTRA_PROJECT_ROOT")"; if [ -z "$BUNDLER" ]; then echo "error: Voltra could not resolve @use-voltra/metro/bundle-widgets from $VOLTRA_PROJECT_ROOT - install @use-voltra/metro so release widgets can be baked." >&2; exit 1; fi; node "$BUNDLER" --platform android --out-dir "$VOLTRA_OUT_DIR" --project-root "$VOLTRA_PROJECT_ROOT"'
+    outputs.upToDateWhen { false }
+}
+
+android.applicationVariants.all { variant ->
+    if (variant.buildType.name == "release") {
+        tasks.named("merge\${variant.name.capitalize()}Assets").configure { dependsOn voltraBundleWidgets }
+    }
+}
+${END_MARKER}
+`.trim()
+}
+
+function createLegacyDynamicWidgetBundlingSnippet(projectRootRelativeToAppModule: string): string {
+  return createDynamicWidgetBundlingSnippet(projectRootRelativeToAppModule).replace(`\n${END_MARKER}`, '')
+}
+
+function findManagedSnippetRange(contents: string): { start: number; end: number } | null {
+  const markerIndex = contents.indexOf(MARKER)
+  if (markerIndex < 0) {
+    return null
+  }
+
+  const endMarkerIndex = contents.indexOf(END_MARKER, markerIndex)
+  if (endMarkerIndex < 0) {
+    return null
+  }
+
+  const lineEndIndex = contents.indexOf('\n', endMarkerIndex)
+  return {
+    start: markerIndex,
+    end: lineEndIndex >= 0 ? lineEndIndex + 1 : contents.length,
+  }
+}
+
+function collapseRemovedRange(contents: string, start: number, end: number): string {
+  const before = contents.slice(0, start).trimEnd()
+  const after = contents.slice(end).replace(/^\s+/, '')
+  const merged = [before, after].filter(Boolean).join('\n\n')
+  return merged ? `${merged}\n` : ''
+}

package/src/platforms/android/manifest.ts

@@ -0,0 +1,379 @@
+import { Builder, parseStringPromise } from 'xml2js'
+
+import { readTextFile, writeTextFile } from '../../fs/readWrite'
+import { toRelativePath } from '../../fs/path'
+import { VoltraCliError } from '../../reporting/summary'
+
+import type { NormalizedVoltraAndroidConfig } from '../../config/types'
+import type { AndroidProjectDiscovery } from '../../discovery/android'
+import type { ReportedChange } from '../../reporting/summary'
+
+const XML_BUILDER = new Builder({
+  headless: false,
+  renderOpts: {
+    pretty: true,
+    indent: '  ',
+    newline: '\n',
+  },
+})
+
+const APPWIDGET_UPDATE_ACTION = 'android.appwidget.action.APPWIDGET_UPDATE'
+const APPWIDGET_PROVIDER_METADATA = 'android.appwidget.provider'
+const ONGOING_NOTIFICATION_RECEIVER = 'voltra.VoltraOngoingNotificationDismissedReceiver'
+const POST_NOTIFICATIONS_PERMISSION = 'android.permission.POST_NOTIFICATIONS'
+const POST_PROMOTED_NOTIFICATIONS_PERMISSION = 'android.permission.POST_PROMOTED_NOTIFICATIONS'
+const WIDGET_RECEIVER_NAME_PREFIX = '.widget.VoltraWidget_'
+const WIDGET_RECEIVER_NAME_SUFFIX = 'Receiver'
+const WIDGET_INFO_RESOURCE_PREFIX = '@xml/voltra_widget_'
+const WIDGET_INFO_RESOURCE_SUFFIX = '_info'
+
+export interface EnsureAndroidManifestOptions {
+  projectRoot: string
+  android: NormalizedVoltraAndroidConfig
+  discovery: AndroidProjectDiscovery
+}
+
+export interface EnsureAndroidManifestResult {
+  change?: ReportedChange
+}
+
+interface AndroidManifestDocument {
+  manifest?: AndroidManifestRoot
+}
+
+interface AndroidManifestRoot {
+  $?: Record<string, string>
+  application?: AndroidManifestApplication[]
+  'uses-permission'?: AndroidManifestPermission[]
+}
+
+interface AndroidManifestPermission {
+  $?: Record<string, string>
+}
+
+interface AndroidManifestApplication {
+  $?: Record<string, string>
+  receiver?: AndroidManifestReceiver[]
+}
+
+interface AndroidManifestReceiver {
+  $?: Record<string, string>
+  'intent-filter'?: AndroidManifestIntentFilter[]
+  'meta-data'?: AndroidManifestMetaData[]
+}
+
+interface AndroidManifestIntentFilter {
+  action?: AndroidManifestAction[]
+}
+
+interface AndroidManifestAction {
+  $?: Record<string, string>
+}
+
+interface AndroidManifestMetaData {
+  $?: Record<string, string>
+}
+
+export class AndroidManifestMutationError extends VoltraCliError {
+  constructor(message: string) {
+    super(message, 'VOLTRA_ANDROID_MANIFEST_MUTATION_FAILED')
+    this.name = 'AndroidManifestMutationError'
+  }
+}
+
+export async function ensureAndroidManifest(
+  options: EnsureAndroidManifestOptions
+): Promise<EnsureAndroidManifestResult> {
+  const { projectRoot, android, discovery } = options
+  const manifestPath = discovery.manifestPath
+  const previousContent = await readTextFile(manifestPath)
+  const manifestDocument = await parseAndroidManifest(previousContent, manifestPath)
+  const manifest = manifestDocument.manifest
+
+  if (!manifest) {
+    throw new AndroidManifestMutationError(`Android manifest root is missing in ${manifestPath}`)
+  }
+
+  const application = getMainApplication(manifest, manifestPath)
+  const permissions = manifest['uses-permission'] ?? []
+  manifest['uses-permission'] = permissions
+
+  reconcileNotificationPermissions(permissions, android.enableNotifications)
+
+  const receivers = application.receiver ?? []
+  application.receiver = receivers
+
+  reconcileNotificationReceiver(receivers, android.enableNotifications)
+  removeStaleWidgetReceivers(
+    receivers,
+    android.widgets.map((widget) => widget.id)
+  )
+
+  if (android.enableNotifications) {
+    ensureNotificationReceiver(receivers)
+  }
+
+  for (const widget of android.widgets) {
+    ensureWidgetReceiver(receivers, widget.id)
+  }
+
+  const nextContent = `${XML_BUILDER.buildObject(manifestDocument)}\n`
+
+  if (nextContent === previousContent) {
+    return {}
+  }
+
+  await writeTextFile(manifestPath, nextContent)
+
+  return {
+    change: {
+      kind: 'updated',
+      path: toRelativePath(projectRoot, manifestPath),
+    },
+  }
+}
+
+async function parseAndroidManifest(content: string, manifestPath: string): Promise<AndroidManifestDocument> {
+  try {
+    return (await parseStringPromise(content)) as AndroidManifestDocument
+  } catch (error: unknown) {
+    throw new AndroidManifestMutationError(
+      `Failed to parse AndroidManifest.xml at ${manifestPath}: ${
+        error instanceof Error ? error.message : String(error)
+      }`
+    )
+  }
+}
+
+function getMainApplication(manifest: AndroidManifestRoot, manifestPath: string): AndroidManifestApplication {
+  const applications = manifest.application ?? []
+
+  if (applications.length === 0) {
+    throw new AndroidManifestMutationError(
+      `Android manifest does not contain an <application> element: ${manifestPath}`
+    )
+  }
+
+  if (applications.length > 1) {
+    throw new AndroidManifestMutationError(`Android manifest contains multiple <application> elements: ${manifestPath}`)
+  }
+
+  return applications[0]
+}
+
+function ensurePermission(permissions: AndroidManifestPermission[], permissionName: string): void {
+  const matchingPermissions = permissions.filter((permission) => permission.$?.['android:name'] === permissionName)
+
+  if (matchingPermissions.length === 0) {
+    permissions.push(createPermission(permissionName))
+    return
+  }
+
+  const primaryPermission = matchingPermissions[0]
+  primaryPermission.$ = {
+    ...primaryPermission.$,
+    'android:name': permissionName,
+  }
+
+  removeDuplicateEntries(permissions, (permission) => permission.$?.['android:name'] === permissionName)
+}
+
+function reconcileNotificationPermissions(permissions: AndroidManifestPermission[], enabled: boolean): void {
+  if (enabled) {
+    ensurePermission(permissions, POST_NOTIFICATIONS_PERMISSION)
+    ensurePermission(permissions, POST_PROMOTED_NOTIFICATIONS_PERMISSION)
+  }
+}
+
+function ensureNotificationReceiver(receivers: AndroidManifestReceiver[]): void {
+  const receiver = findReceiverByName(receivers, ONGOING_NOTIFICATION_RECEIVER)
+
+  if (receiver) {
+    receiver.$ = {
+      ...receiver.$,
+      'android:name': ONGOING_NOTIFICATION_RECEIVER,
+      'android:exported': 'false',
+    }
+    removeDuplicateEntries(receivers, (candidate) => candidate.$?.['android:name'] === ONGOING_NOTIFICATION_RECEIVER)
+    return
+  }
+
+  receivers.push(createReceiver(ONGOING_NOTIFICATION_RECEIVER, 'false'))
+}
+
+function reconcileNotificationReceiver(receivers: AndroidManifestReceiver[], enabled: boolean): void {
+  if (enabled) {
+    ensureNotificationReceiver(receivers)
+    return
+  }
+
+  removeEntries(receivers, (receiver) => receiver.$?.['android:name'] === ONGOING_NOTIFICATION_RECEIVER)
+}
+
+function ensureWidgetReceiver(receivers: AndroidManifestReceiver[], widgetId: string): void {
+  const receiverName = `.widget.VoltraWidget_${widgetId}Receiver`
+  const metadataResource = `@xml/voltra_widget_${widgetId}_info`
+  const labelResource = `@string/voltra_widget_${widgetId}_label`
+  const receiver = findReceiverByName(receivers, receiverName)
+
+  if (receiver) {
+    receiver.$ = {
+      ...receiver.$,
+      'android:name': receiverName,
+      'android:exported': 'true',
+      'android:label': labelResource,
+    }
+    ensureAppWidgetUpdateIntentFilter(receiver)
+    ensureReceiverMetadata(receiver, metadataResource)
+    removeDuplicateEntries(receivers, (candidate) => candidate.$?.['android:name'] === receiverName)
+    return
+  }
+
+  const nextReceiver = createReceiver(receiverName, 'true', labelResource)
+  ensureAppWidgetUpdateIntentFilter(nextReceiver)
+  ensureReceiverMetadata(nextReceiver, metadataResource)
+  receivers.push(nextReceiver)
+}
+
+function removeStaleWidgetReceivers(receivers: AndroidManifestReceiver[], widgetIds: string[]): void {
+  const nextWidgetIds = new Set(widgetIds)
+
+  removeEntries(receivers, (receiver) => {
+    const receiverName = receiver.$?.['android:name']
+
+    if (
+      !receiverName ||
+      !receiverName.startsWith(WIDGET_RECEIVER_NAME_PREFIX) ||
+      !receiverName.endsWith(WIDGET_RECEIVER_NAME_SUFFIX)
+    ) {
+      return false
+    }
+
+    const widgetId = receiverName.slice(WIDGET_RECEIVER_NAME_PREFIX.length, -WIDGET_RECEIVER_NAME_SUFFIX.length)
+
+    if (!widgetId || nextWidgetIds.has(widgetId)) {
+      return false
+    }
+
+    const metadataResource = getReceiverMetadataResource(receiver)
+    return metadataResource === undefined || isWidgetMetadataResource(metadataResource)
+  })
+}
+
+function ensureAppWidgetUpdateIntentFilter(receiver: AndroidManifestReceiver): void {
+  const intentFilters = receiver['intent-filter'] ?? []
+  receiver['intent-filter'] = intentFilters
+
+  const existingFilter = intentFilters.find((intentFilter) =>
+    (intentFilter.action ?? []).some((action) => action.$?.['android:name'] === APPWIDGET_UPDATE_ACTION)
+  )
+
+  if (existingFilter) {
+    existingFilter.action = [{ $: { 'android:name': APPWIDGET_UPDATE_ACTION } }]
+    removeDuplicateEntries(intentFilters, (intentFilter) =>
+      (intentFilter.action ?? []).some((action) => action.$?.['android:name'] === APPWIDGET_UPDATE_ACTION)
+    )
+    return
+  }
+
+  intentFilters.push({
+    action: [
+      {
+        $: {
+          'android:name': APPWIDGET_UPDATE_ACTION,
+        },
+      },
+    ],
+  })
+}
+
+function ensureReceiverMetadata(receiver: AndroidManifestReceiver, metadataResource: string): void {
+  const metadataEntries = receiver['meta-data'] ?? []
+  receiver['meta-data'] = metadataEntries
+
+  const providerMetadata = metadataEntries.find(
+    (metadata) => metadata.$?.['android:name'] === APPWIDGET_PROVIDER_METADATA
+  )
+
+  if (providerMetadata) {
+    providerMetadata.$ = {
+      ...providerMetadata.$,
+      'android:name': APPWIDGET_PROVIDER_METADATA,
+      'android:resource': metadataResource,
+    }
+    removeDuplicateEntries(metadataEntries, (metadata) => metadata.$?.['android:name'] === APPWIDGET_PROVIDER_METADATA)
+    return
+  }
+
+  metadataEntries.push({
+    $: {
+      'android:name': APPWIDGET_PROVIDER_METADATA,
+      'android:resource': metadataResource,
+    },
+  })
+}
+
+function findReceiverByName(
+  receivers: AndroidManifestReceiver[],
+  receiverName: string
+): AndroidManifestReceiver | undefined {
+  return receivers.find((receiver) => receiver.$?.['android:name'] === receiverName)
+}
+
+function getReceiverMetadataResource(receiver: AndroidManifestReceiver): string | undefined {
+  return receiver['meta-data']?.find((metadata) => metadata.$?.['android:name'] === APPWIDGET_PROVIDER_METADATA)?.$?.[
+    'android:resource'
+  ]
+}
+
+function isWidgetMetadataResource(resource: string): boolean {
+  return resource.startsWith(WIDGET_INFO_RESOURCE_PREFIX) && resource.endsWith(WIDGET_INFO_RESOURCE_SUFFIX)
+}
+
+function createPermission(permissionName: string): AndroidManifestPermission {
+  return {
+    $: {
+      'android:name': permissionName,
+    },
+  }
+}
+
+function createReceiver(receiverName: string, exported: 'true' | 'false', label?: string): AndroidManifestReceiver {
+  return {
+    $: {
+      'android:name': receiverName,
+      'android:exported': exported,
+      ...(label ? { 'android:label': label } : {}),
+    },
+  }
+}
+
+function removeDuplicateEntries<TEntry>(entries: TEntry[], isDuplicate: (entry: TEntry) => boolean): void {
+  let foundPrimary = false
+
+  for (let index = 0; index < entries.length; ) {
+    if (!isDuplicate(entries[index])) {
+      index += 1
+      continue
+    }
+
+    if (!foundPrimary) {
+      foundPrimary = true
+      index += 1
+      continue
+    }
+
+    entries.splice(index, 1)
+  }
+}
+
+function removeEntries<TEntry>(entries: TEntry[], shouldRemove: (entry: TEntry) => boolean): void {
+  for (let index = 0; index < entries.length; ) {
+    if (!shouldRemove(entries[index])) {
+      index += 1
+      continue
+    }
+
+    entries.splice(index, 1)
+  }
+}

package/src/platforms/ios/apply.ts

@@ -0,0 +1,139 @@
+import { discoverIOSProject } from '../../discovery/ios'
+import { getMissingPlatformPackageMessage, getMissingPlatformPackages } from '../../dependencies/platformPackages'
+import { VoltraCliError } from '../../reporting/summary'
+
+import { ensureEntitlements } from './entitlements'
+import { generateIOSFiles } from './generated'
+import { ensureInfoPlist } from './plist'
+import { ensurePodfileBlock } from './podfile'
+import { ensureIOSWidgetTarget } from './xcodeTarget'
+
+import type { NormalizedVoltraConfig } from '../../config/types'
+import type { IOSProjectDiscovery } from '../../discovery/ios'
+import type { PlatformApplyContext, PlatformApplyResult } from '../../apply'
+import type { ApplyPreflightContext, PlatformPreflightResult, PlatformPreflightRunner } from '../../apply/preflight'
+
+export function createIOSPreflightRunner(config: NormalizedVoltraConfig): PlatformPreflightRunner<IOSProjectDiscovery> {
+  return async (_context: ApplyPreflightContext): Promise<PlatformPreflightResult<IOSProjectDiscovery>> => {
+    const iosConfig = config.ios
+
+    if (!iosConfig) {
+      return {
+        platform: 'ios',
+        issues: [{ message: 'iOS config is missing.' }],
+      }
+    }
+
+    const missingPackages = getMissingPlatformPackages(config.projectRoot, 'ios')
+
+    if (missingPackages.length > 0) {
+      return {
+        platform: 'ios',
+        issues: [{ message: getMissingPlatformPackageMessage('ios', missingPackages) }],
+      }
+    }
+
+    return {
+      platform: 'ios',
+      context: await discoverIOSProject(config.projectRoot, iosConfig.project),
+    }
+  }
+}
+
+export async function applyIOSPlatform(context: PlatformApplyContext): Promise<PlatformApplyResult> {
+  if (context.platform !== 'ios') {
+    throw new VoltraCliError(`iOS apply runner received unexpected platform: ${context.platform}.`)
+  }
+
+  const iosConfig = context.config.ios
+
+  if (!iosConfig) {
+    throw new VoltraCliError('iOS config is missing.')
+  }
+
+  const discovery = getIOSDiscovery(context.preflight)
+  const generatedResult = await generateIOSFiles({
+    projectRoot: context.config.projectRoot,
+    ios: iosConfig,
+    discovery,
+  })
+  const entitlementsResult = await ensureEntitlements({
+    projectRoot: context.config.projectRoot,
+    ios: iosConfig,
+    discovery,
+  })
+  const infoPlistResult = await ensureInfoPlist({
+    projectRoot: context.config.projectRoot,
+    ios: iosConfig,
+    discovery,
+  })
+  const podfileResult = await ensurePodfileBlock({
+    projectRoot: context.config.projectRoot,
+    ios: iosConfig,
+    discovery,
+  })
+  const xcodeTargetResult = await ensureIOSWidgetTarget({
+    projectRoot: context.config.projectRoot,
+    ios: iosConfig,
+    discovery,
+    generatedFiles: generatedResult.files,
+    previousGeneratedFiles: context.previousState?.files,
+  })
+
+  if (generatedResult.targetName !== xcodeTargetResult.targetName) {
+    throw new VoltraCliError(
+      `iOS generated files and Xcode target mutation resolved different widget target names: ${generatedResult.targetName} vs ${xcodeTargetResult.targetName}.`
+    )
+  }
+
+  if (generatedResult.targetName !== podfileResult.targetName) {
+    throw new VoltraCliError(
+      `iOS generated files and Podfile block resolved different widget target names: ${generatedResult.targetName} vs ${podfileResult.targetName}.`
+    )
+  }
+
+  const changes = [
+    infoPlistResult.change,
+    entitlementsResult.change,
+    podfileResult.change,
+    xcodeTargetResult.change,
+  ].filter(isDefined)
+
+  return {
+    platform: 'ios',
+    changes: [...changes, ...generatedResult.changes],
+    generatedFiles: generatedResult.files,
+    warnings: [...(generatedResult.warnings ?? []), ...(podfileResult.warnings ?? [])],
+  }
+}
+
+function getIOSDiscovery(value: unknown): IOSProjectDiscovery {
+  if (!isIOSProjectDiscovery(value)) {
+    throw new VoltraCliError('iOS preflight did not provide a valid discovery result.')
+  }
+
+  return value
+}
+
+function isIOSProjectDiscovery(value: unknown): value is IOSProjectDiscovery {
+  if (!value || typeof value !== 'object') {
+    return false
+  }
+
+  const candidate = value as Partial<IOSProjectDiscovery>
+
+  return (
+    [
+      candidate.iosRoot,
+      candidate.xcodeprojPath,
+      candidate.pbxprojPath,
+      candidate.podfilePath,
+      candidate.mainTargetName,
+      candidate.infoPlistPath,
+    ].every((entry) => typeof entry === 'string' && entry.length > 0) && Array.isArray(candidate.mainTargetCandidates)
+  )
+}
+
+function isDefined<TValue>(value: TValue | undefined): value is TValue {
+  return value !== undefined
+}