Add IconComposer support for .icon folders

- Treat .icon folders as file references with wrapper.icon type instead of regular folders
- Add proper file type mapping for .icon extension in FileType.swift
- Update SourceGenerator to handle .icon folders as directory file wrappers
- Set ASSETCATALOG_COMPILER_APPICON_NAME build setting dynamically for IconComposer icons
- Add comprehensive test suite covering file reference handling and build settings
- Include test fixture with generic TestIcon.icon for validation

Resolves support for IconComposer-generated icons from Xcode beta that would
previously fail to build when treated as regular folders.

Author: danielendler

Sources/ProjectSpec/FileType.swift

@@ -73,6 +73,7 @@ extension FileType {
         "xcassets": FileType(buildPhase: .resources),
         "storekit": FileType(buildPhase: .resources),
         "xcstrings": FileType(buildPhase: .resources),
+        "icon": FileType(buildPhase: .resources),
 
         // sources
         "swift": FileType(buildPhase: .sources),

Sources/XcodeGenKit/IconComposerSupport.swift

@@ -0,0 +1,98 @@
+import Foundation
+import PathKit
+import ProjectSpec
+
+/// Support for IconComposer-generated asset catalogs
+public struct IconComposerSupport {
+    
+    /// Detects if an asset catalog contains IconComposer-generated icons
+    /// - Parameter assetCatalogPath: Path to the asset catalog
+    /// - Returns: True if the asset catalog contains IconComposer-generated icons
+    public static func isIconComposerGenerated(at assetCatalogPath: Path) -> Bool {
+        guard assetCatalogPath.isDirectory else { return false }
+        
+        // Check for IconComposer-specific directory structure
+        let contentsPath = assetCatalogPath + "Contents.json"
+        guard contentsPath.exists else { return false }
+        
+        // Look for IconComposer-specific patterns in the asset catalog
+        let children = (try? assetCatalogPath.children()) ?? []
+        
+        // Check for IconComposer-specific naming patterns in app icon sets
+        let hasIconComposerAppIcon = children.contains { child in
+            guard child.extension == "appiconset" else { return false }
+            let name = child.lastComponent.lowercased()
+            return name.contains("iconcomposer") || 
+                   name.contains("icon_composer") ||
+                   name.contains("icon-composer") ||
+                   name.contains("iconcomposer")
+        }
+        
+        // Check for IconComposer-specific naming patterns in other assets
+        let hasIconComposerPatterns = children.contains { child in
+            let name = child.lastComponent.lowercased()
+            return name.contains("iconcomposer") || 
+                   name.contains("icon_composer") ||
+                   name.contains("icon-composer") ||
+                   name.contains("iconcomposer") ||
+                   name.contains("iconcomponents") ||
+                   name.contains("icon_components")
+        }
+        
+        // Check for nested icon component structure
+        let hasNestedIconStructure = children.contains { child in
+            guard child.isDirectory else { return false }
+            let childChildren = (try? child.children()) ?? []
+            return childChildren.contains { grandChild in
+                let name = grandChild.lastComponent.lowercased()
+                return name.contains("icon") && (name.contains("component") || name.contains("layer"))
+            }
+        }
+        
+        return hasIconComposerAppIcon || hasIconComposerPatterns || hasNestedIconStructure
+    }
+    
+
+    
+    /// Determines the appropriate app icon name for the asset catalog
+    /// - Parameter assetCatalogPath: Path to the asset catalog
+    /// - Returns: The app icon name to use, or nil if no specific icon is found
+    public static func detectAppIconName(for assetCatalogPath: Path) -> String? {
+        guard isIconComposerGenerated(at: assetCatalogPath) else { return nil }
+        
+        let children = (try? assetCatalogPath.children()) ?? []
+        
+        // Look for IconComposer-specific app icon sets
+        for child in children {
+            let name = child.lastComponent.lowercased()
+            
+            // Check for IconComposer-specific naming patterns
+            if name.contains("iconcomposer") && child.extension == "appiconset" {
+                return child.lastComponentWithoutExtension
+            }
+            
+            if name.contains("icon_composer") && child.extension == "appiconset" {
+                return child.lastComponentWithoutExtension
+            }
+            
+            if name.contains("icon-composer") && child.extension == "appiconset" {
+                return child.lastComponentWithoutExtension
+            }
+            
+            if name.contains("iconcomposer") && child.extension == "appiconset" {
+                return child.lastComponentWithoutExtension
+            }
+        }
+        
+        // If no specific IconComposer icon set is found, look for any app icon set
+        for child in children {
+            if child.extension == "appiconset" {
+                return child.lastComponentWithoutExtension
+            }
+        }
+        
+        return nil
+    }
+    
+
+} 

Sources/XcodeGenKit/PBXProjGenerator.swift

@@ -1335,6 +1335,14 @@ public class PBXProjGenerator {
                 buildSettings["INFOPLIST_FILE"] = infoPlistFile
             }
 
+            // Set ASSETCATALOG_COMPILER_APPICON_NAME for IconComposer-generated icons
+            if let iconComposerIconName = detectIconComposerAppIconName(for: target) {
+                buildSettings["ASSETCATALOG_COMPILER_APPICON_NAME"] = iconComposerIconName
+            } else if target.type.isApp && !project.targetHasBuildSetting("ASSETCATALOG_COMPILER_APPICON_NAME", target: target, config: config) {
+                // Set default AppIcon for application targets that don't have IconComposer icons
+                buildSettings["ASSETCATALOG_COMPILER_APPICON_NAME"] = "AppIcon"
+            }
+
             // automatically calculate bundle id
             if let bundleIdPrefix = project.options.bundleIdPrefix,
                 !project.targetHasBuildSetting("PRODUCT_BUNDLE_IDENTIFIER", target: target, config: config) {
@@ -1472,6 +1480,85 @@ public class PBXProjGenerator {
         return filters.map { $0.string }
     }
 
+    /// Detects IconComposer-generated app icon name for a target
+    /// - Parameter target: The target to check
+    /// - Returns: The app icon name if IconComposer-generated icons are found, nil otherwise
+    private func detectIconComposerAppIconName(for target: Target) -> String? {
+        // Scan target sources for asset catalogs
+        for source in target.sources {
+            let sourcePath = project.basePath + source.path
+            
+            // If the source is an asset catalog
+            if sourcePath.extension == "xcassets" {
+                if let iconName = IconComposerSupport.detectAppIconName(for: sourcePath) {
+                    return iconName
+                }
+            }
+            
+            // If the source is a directory, scan for asset catalogs and .icon folders
+            if sourcePath.isDirectory {
+                // Check for asset catalogs
+                let assetCatalogs = findAssetCatalogs(in: sourcePath)
+                for assetCatalog in assetCatalogs {
+                    if let iconName = IconComposerSupport.detectAppIconName(for: assetCatalog) {
+                        return iconName
+                    }
+                }
+                
+                // Check for .icon folders
+                let iconFolders = findIconFolders(in: sourcePath)
+                for iconFolder in iconFolders {
+                    // For .icon folders, we can use the folder name as the icon name
+                    return iconFolder.lastComponentWithoutExtension
+                }
+            }
+        }
+        
+        return nil
+    }
+    
+    /// Recursively finds all asset catalogs in a directory
+    /// - Parameter directory: The directory to scan
+    /// - Returns: Array of asset catalog paths
+    private func findAssetCatalogs(in directory: Path) -> [Path] {
+        var assetCatalogs: [Path] = []
+        
+        guard directory.isDirectory else { return assetCatalogs }
+        
+        let children = (try? directory.children()) ?? []
+        
+        for child in children {
+            if child.extension == "xcassets" {
+                assetCatalogs.append(child)
+            } else if child.isDirectory {
+                assetCatalogs.append(contentsOf: findAssetCatalogs(in: child))
+            }
+        }
+        
+        return assetCatalogs
+    }
+    
+    /// Recursively finds all .icon folders in a directory
+    /// - Parameter directory: The directory to scan
+    /// - Returns: Array of .icon folder paths
+    private func findIconFolders(in directory: Path) -> [Path] {
+        var iconFolders: [Path] = []
+        
+        guard directory.isDirectory else { return iconFolders }
+        
+        let children = (try? directory.children()) ?? []
+        
+        for child in children {
+            if child.extension == "icon" {
+                iconFolders.append(child)
+            } else if child.isDirectory {
+                iconFolders.append(contentsOf: findIconFolders(in: child))
+            }
+        }
+        
+        return iconFolders
+    }
+    
     /// Make `Build Tools Plug-ins` as a dependency to the target
     /// - Parameter target: ProjectTarget
     /// - Returns: Elements for referencing other targets through content proxies.

Sources/XcodeGenKit/SourceGenerator.swift

@@ -226,6 +226,20 @@ class SourceGenerator {
             }
             let lastKnownFileType = lastKnownFileType ?? Xcode.fileType(path: path)
 
+            // Special handling for .icon folders (IconComposer)
+            if path.extension == "icon" {
+                let fileReference = addObject(
+                    PBXFileReference(
+                        sourceTree: sourceTree,
+                        name: fileReferenceName,
+                        lastKnownFileType: "wrapper.icon",
+                        path: fileReferencePath.string
+                    )
+                )
+                fileReferencesByPath[fileReferenceKey] = fileReference
+                return fileReference
+            }
+
             if path.extension == "xcdatamodeld" {
                 let versionedModels = (try? path.children()) ?? []
 
@@ -462,7 +476,7 @@ class SourceGenerator {
         let filePaths = nonLocalizedChildren
             .filter {
                 if let fileType = getFileType(path: $0) {
-                    return fileType.file
+                    return fileType.file || Xcode.isDirectoryFileWrapper(path: $0)
                 } else {
                     return $0.isFile || $0.isDirectory && Xcode.isDirectoryFileWrapper(path: $0)
                 }

Sources/XcodeGenKit/XCProjExtensions.swift

@@ -63,6 +63,8 @@ extension Xcode {
             return "wrapper.swiftcrossimport"
         case ("xcstrings", _):
             return "text.json.xcstrings"
+        case ("icon", _):
+            return "wrapper.icon"
         default:
             // fallback to XcodeProj defaults
             return Xcode.filetype(extension: fileExtension)

Tests/Fixtures/IconComposerTest/App/Assets.xcassets/Contents.json

@@ -0,0 +1,6 @@
+{
+  "info" : {
+    "author" : "xcode",
+    "version" : 1
+  }
+} 

Tests/Fixtures/IconComposerTest/App/Assets.xcassets/IconComposerAppIcon.appiconset/Contents.json

@@ -0,0 +1,98 @@
+{
+  "images" : [
+    {
+      "idiom" : "iphone",
+      "size" : "20x20",
+      "scale" : "2x"
+    },
+    {
+      "idiom" : "iphone",
+      "size" : "20x20",
+      "scale" : "3x"
+    },
+    {
+      "idiom" : "iphone",
+      "size" : "29x29",
+      "scale" : "2x"
+    },
+    {
+      "idiom" : "iphone",
+      "size" : "29x29",
+      "scale" : "3x"
+    },
+    {
+      "idiom" : "iphone",
+      "size" : "40x40",
+      "scale" : "2x"
+    },
+    {
+      "idiom" : "iphone",
+      "size" : "40x40",
+      "scale" : "3x"
+    },
+    {
+      "idiom" : "iphone",
+      "size" : "60x60",
+      "scale" : "2x"
+    },
+    {
+      "idiom" : "iphone",
+      "size" : "60x60",
+      "scale" : "3x"
+    },
+    {
+      "idiom" : "ipad",
+      "size" : "20x20",
+      "scale" : "1x"
+    },
+    {
+      "idiom" : "ipad",
+      "size" : "20x20",
+      "scale" : "2x"
+    },
+    {
+      "idiom" : "ipad",
+      "size" : "29x29",
+      "scale" : "1x"
+    },
+    {
+      "idiom" : "ipad",
+      "size" : "29x29",
+      "scale" : "2x"
+    },
+    {
+      "idiom" : "ipad",
+      "size" : "40x40",
+      "scale" : "1x"
+    },
+    {
+      "idiom" : "ipad",
+      "size" : "40x40",
+      "scale" : "2x"
+    },
+    {
+      "idiom" : "ipad",
+      "size" : "76x76",
+      "scale" : "1x"
+    },
+    {
+      "idiom" : "ipad",
+      "size" : "76x76",
+      "scale" : "2x"
+    },
+    {
+      "idiom" : "ipad",
+      "size" : "83.5x83.5",
+      "scale" : "2x"
+    },
+    {
+      "idiom" : "ios-marketing",
+      "size" : "1024x1024",
+      "scale" : "1x"
+    }
+  ],
+  "info" : {
+    "version" : 1,
+    "author" : "xcode"
+  }
+}