PBXNativeTarget.ts

import * as json from "../json/types";
import { AbstractTarget } from "./AbstractTarget";

import {
  PBXCopyFilesBuildPhase,
  PBXFrameworksBuildPhase,
  PBXHeadersBuildPhase,
  PBXResourcesBuildPhase,
  PBXSourcesBuildPhase,
  type AnyBuildPhase,
} from "./PBXSourcesBuildPhase";
import { PBXFileReference } from "./PBXFileReference";
import { PBXBuildFile } from "./PBXBuildFile";
import { XCSwiftPackageProductDependency } from "./XCSwiftPackageProductDependency";
import type { PickRequired, SansIsa } from "./utils/util.types";
import type { XcodeProject } from "./XcodeProject";
import type { PBXBuildRule } from "./PBXBuildRule";
import { PBXTargetDependency } from "./PBXTargetDependency";
import type { XCConfigurationList } from "./XCConfigurationList";
import type { PBXFileSystemSynchronizedRootGroup } from "./PBXFileSystemSynchronizedRootGroup";
import { PBXContainerItemProxy } from "./PBXContainerItemProxy";
import type { XCRemoteSwiftPackageReference } from "./XCRemoteSwiftPackageReference";
import type { XCLocalSwiftPackageReference } from "./XCLocalSwiftPackageReference";

export type PBXNativeTargetModel = json.PBXNativeTarget<
  XCConfigurationList,
  PBXTargetDependency,
  AnyBuildPhase,
  PBXBuildRule,
  PBXFileReference,
  XCSwiftPackageProductDependency,
  PBXFileSystemSynchronizedRootGroup
>;

export class PBXNativeTarget extends AbstractTarget<PBXNativeTargetModel> {
  static isa = json.ISA.PBXNativeTarget as const;
  static is(object: any): object is PBXNativeTarget {
    return object.isa === PBXNativeTarget.isa;
  }

  static create(
    project: XcodeProject,
    opts: PickRequired<
      SansIsa<PBXNativeTargetModel>,
      "name" | "productType" | "buildConfigurationList"
    >
  ) {
    return project.createModel<PBXNativeTargetModel>({
      isa: json.ISA.PBXNativeTarget,
      buildPhases: [],
      buildRules: [],
      dependencies: [],
      // TODO: Should we default the product name to the target name?
      ...opts,
    }) as PBXNativeTarget;
  }

  /** @returns the `PBXFrameworksBuildPhase` or creates one if there is none. Only one can exist. */
  getFrameworksBuildPhase() {
    return (
      this.getBuildPhase(PBXFrameworksBuildPhase) ??
      this.createBuildPhase(PBXFrameworksBuildPhase)
    );
  }

  /** @returns the `PBXHeadersBuildPhase` or creates one if there is none. Only one can exist. */
  getHeadersBuildPhase() {
    return (
      this.getBuildPhase(PBXHeadersBuildPhase) ??
      this.createBuildPhase(PBXHeadersBuildPhase)
    );
  }

  /** @returns the `PBXSourcesBuildPhase` or creates one if there is none. Only one can exist. */
  getSourcesBuildPhase() {
    return (
      this.getBuildPhase(PBXSourcesBuildPhase) ??
      this.createBuildPhase(PBXSourcesBuildPhase)
    );
  }

  /** @returns the `PBXResourcesBuildPhase` or creates one if there is none. Only one can exist. */
  getResourcesBuildPhase() {
    return (
      this.getBuildPhase(PBXResourcesBuildPhase) ??
      this.createBuildPhase(PBXResourcesBuildPhase)
    );
  }

  /** Ensures a list of frameworks are linked to the target, given a list like `['SwiftUI.framework', 'WidgetKit.framework']`. Also ensures the file references are added to the Frameworks display folder. */
  ensureFrameworks(frameworks: string[]) {
    const frameworksFolder =
      this.getXcodeProject().rootObject.getFrameworksGroup();

    // TODO: This might need OS-specific checks like https://github.com/CocoaPods/Xcodeproj/blob/ab3dfa504b5a97cae3a653a8924f4616dcaa062e/lib/xcodeproj/project/object/native_target.rb#L322-L328
    const getFrameworkFileReference = (name: string): PBXFileReference => {
      const frameworkName = name.endsWith(".framework")
        ? name
        : name + ".framework";

      for (const [, entry] of this.getXcodeProject().entries()) {
        if (
          PBXFileReference.is(entry) &&
          entry.props.lastKnownFileType === "wrapper.framework" &&
          entry.props.sourceTree === "SDKROOT" &&
          entry.props.name === frameworkName
        ) {
          // This should never happen but if it does then we can repair the state by adding the framework file reference to the Frameworks display group.
          if (
            !frameworksFolder.props.children.find(
              (child) => child.uuid === entry.uuid
            )
          ) {
            frameworksFolder.props.children.push(entry);
          }
          return entry;
        }
      }

      return frameworksFolder.createFile({
        path: "System/Library/Frameworks/" + frameworkName,
      });
    };

    return frameworks.map((framework) => {
      return this.getFrameworksBuildPhase().ensureFile({
        fileRef: getFrameworkFileReference(framework),
      });
    });
  }

  /**
   * Adds a dependency on the given target.
   *
   * @param  [AbstractTarget] target
   *         the target which should be added to the dependencies list of
   *         the receiver. The target may be a target of this target's
   *         project or of a subproject of this project. Note that the
   *         subproject must already be added to this target's project.
   *
   * @return [void]
   */
  addDependency(target: PBXNativeTarget) {
    const isSameProject =
      target.getXcodeProject().filePath === this.getXcodeProject().filePath;
    const existing = this.getDependencyForTarget(target);
    if (existing) {
      if (!isSameProject) {
        // Seems to only be used when the target is a subproject. https://github.com/CocoaPods/Xcodeproj/blob/ab3dfa504b5a97cae3a653a8924f4616dcaa062e/lib/xcodeproj/project/object/target_dependency.rb#L24-L25
        // Update existing props with the existing target.
        existing.props.name = target.props.name;
      }
      return;
    }

    const containerProxy = PBXContainerItemProxy.create(
      this.getXcodeProject(),
      {
        containerPortal: this.getXcodeProject().rootObject,
        proxyType: 1,
        remoteGlobalIDString: target.uuid,
        remoteInfo: target.props.name,
      }
    );

    if (isSameProject) {
      containerProxy.props.containerPortal = this.getXcodeProject().rootObject;
    } else {
      throw new Error(
        "adding dependencies to subprojects is not yet supported. Please open an issue if you need this feature."
      );
    }

    const dependency = PBXTargetDependency.create(this.getXcodeProject(), {
      target,
      targetProxy: containerProxy,
      // name: isSameProject ? undefined : target.props.name,
    });

    this.props.dependencies.push(dependency);
  }

  getCopyBuildPhaseForTarget(target: PBXNativeTarget): PBXCopyFilesBuildPhase {
    const project = this.getXcodeProject();
    if (project.rootObject.getMainAppTarget("ios")!.uuid !== this.uuid) {
      throw new Error(
        `getCopyBuildPhaseForTarget can only be called on the main target`
      );
    }

    const WELL_KNOWN_COPY_EXTENSIONS_NAME = (() => {
      if (
        target.props.productType ===
        "com.apple.product-type.application.on-demand-install-capable"
      ) {
        return "Embed App Clips";
      } else if (target.isWatchOSTarget()) {
        return "Embed Watch Content";
      } else if (
        target.props.productType ===
        "com.apple.product-type.extensionkit-extension"
      ) {
        return "Embed ExtensionKit Extensions";
      }
      return "Embed Foundation Extensions";
    })();

    const existing = this.props.buildPhases.find((phase) => {
      // TODO: maybe there's a safer way to do this? The name is not a good identifier.
      return (
        PBXCopyFilesBuildPhase.is(phase) &&
        phase.props.name === WELL_KNOWN_COPY_EXTENSIONS_NAME
      );
    });
    if (existing) {
      const phase = existing as PBXCopyFilesBuildPhase;
      // Ensure correct settings even for existing phases.
      // This handles cases where an existing phase has incorrect dstPath/dstSubfolderSpec,
      // which can cause App Store validation failures (e.g., watch apps must be in Watch/ subdirectory).
      phase.ensureDefaultsForTarget(target);
      return phase;
    }

    const phase = this.createBuildPhase(PBXCopyFilesBuildPhase, {
      name: WELL_KNOWN_COPY_EXTENSIONS_NAME,
      files: [],
    });

    phase.ensureDefaultsForTarget(target);

    return phase;
  }

  /**
   * Returns true if this target is a watchOS application.
   * This includes both legacy watchOS app types (watchapp, watchapp2) and
   * modern watchOS apps which use the standard application product type
   * with SDKROOT = watchos in build settings.
   */
  isWatchOSTarget(): boolean {
    // Legacy watchOS app product types
    if (
      this.props.productType === "com.apple.product-type.application.watchapp" ||
      this.props.productType === "com.apple.product-type.application.watchapp2" ||
      this.props.productType ===
        "com.apple.product-type.application.watchapp2-container"
    ) {
      return true;
    }

    // Modern watchOS apps use com.apple.product-type.application with
    // SDKROOT = watchos in build settings
    if (this.props.productType === "com.apple.product-type.application") {
      const buildSettings =
        this.props.buildConfigurationList?.props.buildConfigurations?.[0]?.props
          .buildSettings;
      if (buildSettings && buildSettings.SDKROOT === "watchos") {
        return true;
      }
    }

    return false;
  }

  isWatchExtension(): boolean {
    return (
      this.props.productType === "com.apple.product-type.watchkit-extension" ||
      this.props.productType === "com.apple.product-type.watchkit2-extension"
    );
  }

  protected getObjectProps(): Partial<{
    buildRules: any;
    productType: any;
    productReference?: any;
    productInstallPath?: any;
    packageProductDependencies?: any;
    productName?: any;
    buildConfigurationList: any;
    dependencies: any;
    buildPhases: any;
  }> {
    return {
      ...super.getObjectProps(),
      buildRules: [String],
      productReference: [String],
      packageProductDependencies: [String],
      fileSystemSynchronizedGroups: [String],
    };
  }

  /**
   * Removes this target from the project along with all of its exclusively-owned children.
   * Children that are shared with other targets (e.g., shared build phases) are preserved.
   */
  removeFromProject() {
    const project = this.getXcodeProject();

    // Helper to check if an object is only referenced by this target
    const isExclusivelyOwnedByThisTarget = (obj: { getReferrers(): { uuid: string }[] }) => {
      const referrers = obj.getReferrers();
      return referrers.length === 1 && referrers[0].uuid === this.uuid;
    };

    // Remove build phases that are only referenced by this target
    for (const phase of [...this.props.buildPhases]) {
      if (isExclusivelyOwnedByThisTarget(phase)) {
        phase.removeFromProject();
      }
    }

    // Remove build rules that are only referenced by this target
    for (const rule of [...this.props.buildRules]) {
      if (isExclusivelyOwnedByThisTarget(rule)) {
        rule.removeFromProject();
      }
    }

    // Remove the build configuration list (it will cascade to configurations)
    if (isExclusivelyOwnedByThisTarget(this.props.buildConfigurationList)) {
      this.props.buildConfigurationList.removeFromProject();
    }

    // Remove dependencies (PBXTargetDependency objects that this target depends on)
    for (const dep of [...this.props.dependencies]) {
      if (isExclusivelyOwnedByThisTarget(dep)) {
        dep.removeFromProject();
      }
    }

    // Remove file system synchronized groups
    // Check if any OTHER target uses this group (not just any referrer, since groups can be in PBXGroups too)
    if (this.props.fileSystemSynchronizedGroups) {
      for (const group of [...this.props.fileSystemSynchronizedGroups]) {
        const groupUsedByOtherTarget = [...project.values()].some(
          (obj) =>
            PBXNativeTarget.is(obj) &&
            obj.uuid !== this.uuid &&
            obj.props.fileSystemSynchronizedGroups?.some(
              (g) => g.uuid === group.uuid
            )
        );
        if (!groupUsedByOtherTarget) {
          group.removeFromProject();
        }
      }
    }

    // Remove package product dependencies
    if (this.props.packageProductDependencies) {
      for (const dep of [...this.props.packageProductDependencies]) {
        if (isExclusivelyOwnedByThisTarget(dep)) {
          dep.removeFromProject();
        }
      }
    }

    // Remove the product reference (the .app, .framework, etc. file reference)
    // Check if any OTHER target uses this as their productReference
    if (this.props.productReference) {
      const productRefUsedByOtherTarget = [...project.values()].some(
        (obj) =>
          PBXNativeTarget.is(obj) &&
          obj.uuid !== this.uuid &&
          obj.props.productReference?.uuid === this.props.productReference?.uuid
      );
      if (!productRefUsedByOtherTarget) {
        this.props.productReference.removeFromProject();
      }
    }

    // Find and remove any PBXTargetDependency objects from OTHER targets that depend on THIS target
    for (const [, obj] of project.entries()) {
      if (
        PBXTargetDependency.is(obj) &&
        (obj.props.target?.uuid === this.uuid ||
          obj.props.targetProxy?.props.remoteGlobalIDString === this.uuid)
      ) {
        obj.removeFromProject();
      }
    }

    // Call parent which handles removing from PBXProject.targets array
    return super.removeFromProject();
  }

  /**
   * Adds a Swift package product dependency to this target.
   * This handles the full wiring:
   * 1. Creates the XCSwiftPackageProductDependency
   * 2. Adds it to target's packageProductDependencies
   * 3. Creates a PBXBuildFile with productRef
   * 4. Adds the build file to the frameworks build phase
   *
   * Note: The package reference must already be added to the project via
   * `project.addPackageReference()`, `project.addRemoteSwiftPackage()`, or
   * `project.addLocalSwiftPackage()`.
   *
   * @param opts.productName Name of the product from the Swift package
   * @param opts.package The package reference (XCRemoteSwiftPackageReference or XCLocalSwiftPackageReference)
   * @returns The created XCSwiftPackageProductDependency
   */
  addSwiftPackageProduct(opts: {
    productName: string;
    package?: XCRemoteSwiftPackageReference | XCLocalSwiftPackageReference;
  }): XCSwiftPackageProductDependency {
    const xcproj = this.getXcodeProject();

    // Initialize packageProductDependencies if needed
    if (!this.props.packageProductDependencies) {
      this.props.packageProductDependencies = [];
    }

    // Check if this product dependency already exists for this target
    const existing = this.props.packageProductDependencies.find(
      (dep) =>
        dep.props.productName === opts.productName &&
        dep.props.package?.uuid === opts.package?.uuid
    );
    if (existing) {
      return existing;
    }

    // Create the product dependency
    const productDep = XCSwiftPackageProductDependency.create(xcproj, {
      productName: opts.productName,
      package: opts.package,
    });

    // Add to target's packageProductDependencies
    this.props.packageProductDependencies.push(productDep);

    // Create a build file with productRef pointing to the dependency
    const buildFile = PBXBuildFile.createFromProductRef(xcproj, {
      productRef: productDep,
    });

    // Add the build file to the frameworks build phase
    this.getFrameworksBuildPhase().props.files.push(buildFile);

    return productDep;
  }

  /**
   * Gets all Swift package product dependencies for this target.
   *
   * @returns Array of XCSwiftPackageProductDependency objects
   */
  getSwiftPackageProductDependencies(): XCSwiftPackageProductDependency[] {
    return this.props.packageProductDependencies ?? [];
  }

  /**
   * Removes a Swift package product dependency from this target.
   * This handles removing from packageProductDependencies and the build file from the frameworks phase.
   *
   * @param productDep The product dependency to remove
   */
  removeSwiftPackageProduct(productDep: XCSwiftPackageProductDependency): void {
    // Remove from packageProductDependencies
    if (this.props.packageProductDependencies) {
      const index = this.props.packageProductDependencies.findIndex(
        (dep) => dep.uuid === productDep.uuid
      );
      if (index !== -1) {
        this.props.packageProductDependencies.splice(index, 1);
      }
    }

    // Find and remove the build file that references this product dependency
    const frameworksPhase = this.getBuildPhase(PBXFrameworksBuildPhase);
    if (frameworksPhase) {
      const buildFileIndex = frameworksPhase.props.files.findIndex(
        (file) => file.props.productRef?.uuid === productDep.uuid
      );
      if (buildFileIndex !== -1) {
        const buildFile = frameworksPhase.props.files[buildFileIndex];
        frameworksPhase.props.files.splice(buildFileIndex, 1);
        // Remove the build file from the project
        buildFile.removeFromProject();
      }
    }

    // Remove the product dependency from the project
    productDep.removeFromProject();
  }
}