nn-widgets 0.1.0

package/plugin/build/withIosWidget.js

@@ -0,0 +1,1589 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withIosWidget = void 0;
+exports.resolveIosProps = resolveIosProps;
+const config_plugins_1 = require("@expo/config-plugins");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+// ──────────────────────────────────────────────
+//  Swift code generation helpers
+// ──────────────────────────────────────────────
+function generateDataProviderCode(props, bundleId) {
+    const useAppGroups = props.ios.useAppGroups;
+    const appGroupId = props.ios.appGroupIdentifier || `group.${bundleId}`;
+    const hasListWidget = props.widgets.some((w) => w.type === "list");
+    const hasSingleWidget = props.widgets.some((w) => w.type === "single");
+    const storageCode = useAppGroups
+        ? `
+struct WidgetDataProvider {
+    static let appGroupIdentifier = "${appGroupId}"
+    
+    static var userDefaults: UserDefaults? {
+        return UserDefaults(suiteName: appGroupIdentifier)
+    }
+    
+    static func getValue<T>(forKey key: String) -> T? {
+        return userDefaults?.object(forKey: "widget_\\(key)") as? T
+    }
+    
+    static func getString(forKey key: String, default defaultValue: String = "") -> String {
+        return getValue(forKey: key) ?? defaultValue
+    }
+    
+    static func getInt(forKey key: String, default defaultValue: Int = 0) -> Int {
+        return getValue(forKey: key) ?? defaultValue
+    }
+    
+    static func getBool(forKey key: String, default defaultValue: Bool = false) -> Bool {
+        return getValue(forKey: key) ?? defaultValue
+    }
+    
+    static func getJSON(forKey key: String) -> Any? {
+        guard let jsonString: String = getValue(forKey: key),
+              let data = jsonString.data(using: .utf8) else { return nil }
+        return try? JSONSerialization.jsonObject(with: data)
+    }
+}`
+        : `
+// Note: App Groups is disabled. Widget cannot share data with main app.
+// To enable data sharing, set ios.useAppGroups: true and configure App Groups in Apple Developer Portal.
+struct WidgetDataProvider {
+    static var userDefaults: UserDefaults {
+        return UserDefaults.standard
+    }
+    
+    static func getValue<T>(forKey key: String) -> T? {
+        return userDefaults.object(forKey: "widget_\\(key)") as? T
+    }
+    
+    static func getString(forKey key: String, default defaultValue: String = "") -> String {
+        return getValue(forKey: key) ?? defaultValue
+    }
+    
+    static func getInt(forKey key: String, default defaultValue: Int = 0) -> Int {
+        return getValue(forKey: key) ?? defaultValue
+    }
+    
+    static func getBool(forKey key: String, default defaultValue: Bool = false) -> Bool {
+        return getValue(forKey: key) ?? defaultValue
+    }
+    
+    static func getJSON(forKey key: String) -> Any? {
+        guard let jsonString: String = getValue(forKey: key),
+              let data = jsonString.data(using: .utf8) else { return nil }
+        return try? JSONSerialization.jsonObject(with: data)
+    }
+}`;
+    // ── List item model (shared across list-type widgets) ──
+    const listItemModel = hasListWidget || hasSingleWidget
+        ? `
+
+// MARK: - Widget Item Models
+
+struct WidgetIconConfig {
+    let url: String
+    let size: CGFloat
+    let radius: CGFloat
+    let backgroundColor: String?
+    
+    init(from dict: [String: Any]) {
+        self.url = dict["url"] as? String ?? ""
+        self.size = CGFloat(dict["size"] as? Double ?? 32)
+        self.radius = CGFloat(dict["radius"] as? Double ?? 0)
+        self.backgroundColor = dict["backgroundColor"] as? String
+    }
+    
+    init(url: String) {
+        self.url = url
+        self.size = 32
+        self.radius = 0
+        self.backgroundColor = nil
+    }
+}
+
+struct WidgetTextConfig {
+    let text: String
+    let color: String?
+    let fontSize: String?
+    let fontWeight: String?
+    
+    init(from dict: [String: Any]) {
+        self.text = dict["text"] as? String ?? ""
+        self.color = dict["color"] as? String
+        self.fontSize = dict["fontSize"] as? String
+        self.fontWeight = dict["fontWeight"] as? String
+    }
+    
+    init(text: String) {
+        self.text = text
+        self.color = nil
+        self.fontSize = nil
+        self.fontWeight = nil
+    }
+    
+    func resolvedFont(default defaultSize: Font = .body) -> Font {
+        guard let fs = fontSize else { return defaultSize }
+        switch fs {
+        case "caption2": return .caption2
+        case "caption": return .caption
+        case "footnote": return .footnote
+        case "subheadline": return .subheadline
+        case "body": return .body
+        case "headline": return .headline
+        case "title3": return .title3
+        case "title2": return .title2
+        case "title": return .title
+        default: return defaultSize
+        }
+    }
+    
+    func resolvedWeight(default defaultWeight: Font.Weight = .regular) -> Font.Weight {
+        guard let fw = fontWeight else { return defaultWeight }
+        switch fw {
+        case "regular": return .regular
+        case "medium": return .medium
+        case "semibold": return .semibold
+        case "bold": return .bold
+        default: return defaultWeight
+        }
+    }
+}
+
+struct WidgetListItem: Identifiable {
+    let id: String
+    let icon: WidgetIconConfig?
+    let rightIcon: WidgetIconConfig?
+    let title: WidgetTextConfig
+    let description: WidgetTextConfig?
+    let deepLink: String?
+    
+    init(from dict: [String: Any], index: Int) {
+        self.id = "item_\\(index)"
+        
+        // Parse icon
+        if let iconDict = dict["icon"] as? [String: Any] {
+            self.icon = WidgetIconConfig(from: iconDict)
+        } else if let iconStr = dict["icon"] as? String {
+            self.icon = WidgetIconConfig(url: iconStr)
+        } else {
+            self.icon = nil
+        }
+        
+        // Parse rightIcon
+        if let iconDict = dict["rightIcon"] as? [String: Any] {
+            self.rightIcon = WidgetIconConfig(from: iconDict)
+        } else if let iconStr = dict["rightIcon"] as? String {
+            self.rightIcon = WidgetIconConfig(url: iconStr)
+        } else {
+            self.rightIcon = nil
+        }
+        
+        // Parse title
+        if let titleDict = dict["title"] as? [String: Any] {
+            self.title = WidgetTextConfig(from: titleDict)
+        } else if let titleStr = dict["title"] as? String {
+            self.title = WidgetTextConfig(text: titleStr)
+        } else {
+            self.title = WidgetTextConfig(text: "")
+        }
+        
+        // Parse description
+        if let descDict = dict["description"] as? [String: Any] {
+            self.description = WidgetTextConfig(from: descDict)
+        } else if let descStr = dict["description"] as? String {
+            self.description = WidgetTextConfig(text: descStr)
+        } else {
+            self.description = nil
+        }
+        
+        self.deepLink = dict["deepLink"] as? String
+    }
+}
+
+// MARK: - Icon View Helper
+
+struct WidgetIconView: View {
+    let config: WidgetIconConfig
+    let accentColor: Color
+    
+    var body: some View {
+        ZStack {
+            if let bg = config.backgroundColor {
+                RoundedRectangle(cornerRadius: config.radius)
+                    .fill(Color(hex: bg))
+            }
+            
+            if UIImage(named: config.url) != nil {
+                Image(config.url)
+                    .resizable()
+                    .aspectRatio(contentMode: .fit)
+                    .padding(config.size * 0.15)
+            } else {
+                Image(systemName: config.url)
+                    .font(.system(size: config.size * 0.5))
+                    .foregroundColor(
+                        config.backgroundColor != nil ? .white : accentColor
+                    )
+            }
+        }
+        .frame(width: config.size, height: config.size)
+        .clipShape(RoundedRectangle(cornerRadius: config.radius))
+    }
+}`
+        : "";
+    return `${storageCode}
+${listItemModel}`;
+}
+/** Generate the TimelineEntry, TimelineProvider, Views, and Widget struct for one widget */
+function generateSingleWidgetCode(w) {
+    const deepLinkLine = w.deepLinkUrl
+        ? `private let deepLinkUrl = URL(string: "${w.deepLinkUrl}")`
+        : `private let deepLinkUrl: URL? = nil`;
+    // ── Image-only mode ──
+    if (w.type === "image") {
+        return generateImageWidgetCode(w, deepLinkLine);
+    }
+    // ── List mode ──
+    if (w.type === "list") {
+        return generateListWidgetCode(w, deepLinkLine);
+    }
+    // ── Grid mode ──
+    if (w.type === "grid") {
+        return generateGridWidgetCode(w, deepLinkLine);
+    }
+    // ── Single mode (default) ──
+    return generateSingleTypeWidgetCode(w, deepLinkLine);
+}
+function generateImageWidgetCode(w, deepLinkLine) {
+    const hasImage = w.image && (w.image.small || w.image.medium || w.image.large);
+    const smallImage = w.image?.small
+        ? `"${w.name}_small"`
+        : w.image?.medium
+            ? `"${w.name}_medium"`
+            : `"${w.name}_large"`;
+    const mediumImage = w.image?.medium
+        ? `"${w.name}_medium"`
+        : w.image?.large
+            ? `"${w.name}_large"`
+            : smallImage;
+    const largeImage = w.image?.large ? `"${w.name}_large"` : mediumImage;
+    return `
+// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+// MARK: - ${w.name} (Image)
+// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+struct ${w.name}Entry: TimelineEntry {
+    let date: Date
+    static var placeholder: ${w.name}Entry { ${w.name}Entry(date: Date()) }
+}
+
+struct ${w.name}Provider: TimelineProvider {
+    func placeholder(in context: Context) -> ${w.name}Entry { .placeholder }
+    func getSnapshot(in context: Context, completion: @escaping (${w.name}Entry) -> Void) { completion(.placeholder) }
+    func getTimeline(in context: Context, completion: @escaping (Timeline<${w.name}Entry>) -> Void) {
+        let nextUpdate = Calendar.current.date(byAdding: .minute, value: 15, to: Date())!
+        completion(Timeline(entries: [.placeholder], policy: .after(nextUpdate)))
+    }
+}
+
+struct ${w.name}EntryView: View {
+    @Environment(\\.widgetFamily) var family
+    let entry: ${w.name}Entry
+    
+    var body: some View {
+        switch family {
+        case .systemSmall:
+            Image(${smallImage})
+                .resizable()
+                .aspectRatio(contentMode: .fill)
+        case .systemMedium:
+            Image(${mediumImage})
+                .resizable()
+                .aspectRatio(contentMode: .fill)
+        case .systemLarge, .systemExtraLarge:
+            Image(${largeImage})
+                .resizable()
+                .aspectRatio(contentMode: .fill)
+        default:
+            Image(${smallImage})
+                .resizable()
+                .aspectRatio(contentMode: .fill)
+        }
+    }
+}
+
+struct ${w.name}: Widget {
+    let kind: String = "${w.name}"
+    ${deepLinkLine}
+    
+    var body: some WidgetConfiguration {
+        StaticConfiguration(kind: kind, provider: ${w.name}Provider()) { entry in
+            if #available(iOS 17.0, *) {
+                ${w.name}EntryView(entry: entry)
+                    .containerBackground(.clear, for: .widget)
+                    .widgetURL(deepLinkUrl)
+            } else {
+                ${w.name}EntryView(entry: entry)
+                    .widgetURL(deepLinkUrl)
+            }
+        }
+        .configurationDisplayName("${w.displayName}")
+        .description("${w.description}")
+        .supportedFamilies([${w.widgetFamilies.map((f) => `.${f}`).join(", ")}])
+        .contentMarginsDisabled()
+    }
+}`;
+}
+function generateListWidgetCode(w, deepLinkLine) {
+    const bgColor = w.style?.backgroundColor
+        ? `Color(hex: "${w.style.backgroundColor}")`
+        : ".clear";
+    const titleColor = w.style?.titleColor
+        ? `Color(hex: "${w.style.titleColor}")`
+        : ".primary";
+    const subtitleColor = w.style?.subtitleColor
+        ? `Color(hex: "${w.style.subtitleColor}")`
+        : ".secondary";
+    const accentColor = w.style?.accentColor
+        ? `Color(hex: "${w.style.accentColor}")`
+        : ".accentColor";
+    return `
+// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+// MARK: - ${w.name} (List)
+// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+struct ${w.name}Entry: TimelineEntry {
+    let date: Date
+    let items: [WidgetListItem]
+    let fallbackTitle: String
+    let fallbackSubtitle: String
+    
+    static var placeholder: ${w.name}Entry {
+        ${w.name}Entry(
+            date: Date(),
+            items: [],
+            fallbackTitle: "${w.fallbackTitle}",
+            fallbackSubtitle: "${w.fallbackSubtitle}"
+        )
+    }
+}
+
+struct ${w.name}Provider: TimelineProvider {
+    func placeholder(in context: Context) -> ${w.name}Entry { .placeholder }
+    
+    func getSnapshot(in context: Context, completion: @escaping (${w.name}Entry) -> Void) {
+        completion(createEntry())
+    }
+    
+    func getTimeline(in context: Context, completion: @escaping (Timeline<${w.name}Entry>) -> Void) {
+        let entry = createEntry()
+        let nextUpdate = Calendar.current.date(byAdding: .minute, value: 15, to: Date())!
+        completion(Timeline(entries: [entry], policy: .after(nextUpdate)))
+    }
+    
+    private func createEntry() -> ${w.name}Entry {
+        // Read items JSON from shared UserDefaults
+        var items: [WidgetListItem] = []
+        if let rawItems = WidgetDataProvider.getJSON(forKey: "${w.name}_items") as? [[String: Any]] {
+            items = rawItems.enumerated().map { WidgetListItem(from: $0.element, index: $0.offset) }
+        }
+        
+        return ${w.name}Entry(
+            date: Date(),
+            items: items,
+            fallbackTitle: WidgetDataProvider.getString(forKey: "${w.name}_title", default: "${w.fallbackTitle}"),
+            fallbackSubtitle: WidgetDataProvider.getString(forKey: "${w.name}_subtitle", default: "${w.fallbackSubtitle}")
+        )
+    }
+}
+
+// MARK: ${w.name} List Item Row
+
+struct ${w.name}ItemRow: View {
+    let item: WidgetListItem
+    let defaultTitleColor: Color
+    let defaultDescColor: Color
+    let defaultAccentColor: Color
+    
+    var body: some View {
+        HStack(spacing: 12) {
+            if let icon = item.icon {
+                WidgetIconView(config: icon, accentColor: defaultAccentColor)
+            }
+            
+            VStack(alignment: .leading, spacing: 2) {
+                Text(item.title.text)
+                    .font(item.title.resolvedFont(default: .subheadline))
+                    .fontWeight(item.title.resolvedWeight(default: .semibold))
+                    .foregroundColor(
+                        item.title.color != nil
+                            ? Color(hex: item.title.color!)
+                            : defaultTitleColor
+                    )
+                    .lineLimit(1)
+                    .truncationMode(.tail)
+                
+                if let desc = item.description, !desc.text.isEmpty {
+                    Text(desc.text)
+                        .font(desc.resolvedFont(default: .caption))
+                        .fontWeight(desc.resolvedWeight(default: .regular))
+                        .foregroundColor(
+                            desc.color != nil
+                                ? Color(hex: desc.color!)
+                                : defaultDescColor
+                        )
+                        .lineLimit(1)
+                        .truncationMode(.tail)
+                }
+            }
+            
+            Spacer()
+            
+            if let rightIcon = item.rightIcon {
+                WidgetIconView(config: rightIcon, accentColor: defaultAccentColor)
+            }
+        }
+    }
+}
+
+// MARK: ${w.name} Views
+
+struct ${w.name}EntryView: View {
+    @Environment(\\.widgetFamily) var family
+    let entry: ${w.name}Entry
+    
+    private let titleColor: Color = ${titleColor}
+    private let subtitleColor: Color = ${subtitleColor}
+    private let accentColor: Color = ${accentColor}
+    
+    var body: some View {
+        if entry.items.isEmpty {
+            // Fallback: no data set yet
+            VStack(spacing: 8) {${w.showAppIcon
+        ? `
+                Image("AppIcon")
+                    .resizable()
+                    .frame(width: 40, height: 40)
+                    .cornerRadius(10)`
+        : ""}
+                Text(entry.fallbackTitle)
+                    .font(.headline)
+                    .foregroundColor(titleColor)
+                Text(entry.fallbackSubtitle)
+                    .font(.caption)
+                    .foregroundColor(subtitleColor)
+            }
+            .frame(maxWidth: .infinity, maxHeight: .infinity)
+            .background(${bgColor})
+        } else {
+            VStack(alignment: .leading, spacing: 8) {
+                ForEach(entry.items.prefix(maxItems)) { item in
+                    if let deepLink = item.deepLink, let url = URL(string: deepLink) {
+                        Link(destination: url) {
+                            ${w.name}ItemRow(
+                                item: item,
+                                defaultTitleColor: titleColor,
+                                defaultDescColor: subtitleColor,
+                                defaultAccentColor: accentColor
+                            )
+                        }
+                    } else {
+                        ${w.name}ItemRow(
+                            item: item,
+                            defaultTitleColor: titleColor,
+                            defaultDescColor: subtitleColor,
+                            defaultAccentColor: accentColor
+                        )
+                    }
+                }
+            }
+            .padding()
+            .frame(maxWidth: .infinity, maxHeight: .infinity, alignment: .topLeading)
+            .background(${bgColor})
+        }
+    }
+    
+    private var maxItems: Int {
+        switch family {
+        case .systemSmall: return 3
+        case .systemMedium: return 3
+        case .systemLarge, .systemExtraLarge: return 7
+        default: return 3
+        }
+    }
+}
+
+struct ${w.name}: Widget {
+    let kind: String = "${w.name}"
+    ${deepLinkLine}
+    
+    var body: some WidgetConfiguration {
+        StaticConfiguration(kind: kind, provider: ${w.name}Provider()) { entry in
+            if #available(iOS 17.0, *) {
+                ${w.name}EntryView(entry: entry)
+                    .containerBackground(${bgColor}, for: .widget)
+                    .widgetURL(deepLinkUrl)
+            } else {
+                ${w.name}EntryView(entry: entry)
+                    .padding()
+                    .background(${bgColor})
+                    .widgetURL(deepLinkUrl)
+            }
+        }
+        .configurationDisplayName("${w.displayName}")
+        .description("${w.description}")
+        .supportedFamilies([${w.widgetFamilies.map((f) => `.${f}`).join(", ")}])
+    }
+}`;
+}
+function generateGridWidgetCode(w, deepLinkLine) {
+    // Parse gridLayout (e.g. "3x2" → 3 columns, 2 rows)
+    let gridCols = null;
+    let gridRows = null;
+    if (w.gridLayout) {
+        const match = w.gridLayout.match(/^(\d+)x(\d+)$/);
+        if (match) {
+            gridCols = parseInt(match[1], 10);
+            gridRows = parseInt(match[2], 10);
+        }
+    }
+    const bgColor = w.style?.backgroundColor
+        ? `Color(hex: "${w.style.backgroundColor}")`
+        : ".clear";
+    const titleColor = w.style?.titleColor
+        ? `Color(hex: "${w.style.titleColor}")`
+        : ".primary";
+    const subtitleColor = w.style?.subtitleColor
+        ? `Color(hex: "${w.style.subtitleColor}")`
+        : ".secondary";
+    const accentColor = w.style?.accentColor
+        ? `Color(hex: "${w.style.accentColor}")`
+        : ".accentColor";
+    return `
+// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+// MARK: - ${w.name} (Grid)
+// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+struct ${w.name}Entry: TimelineEntry {
+    let date: Date
+    let items: [WidgetListItem]
+    let fallbackTitle: String
+    let fallbackSubtitle: String
+    
+    static var placeholder: ${w.name}Entry {
+        ${w.name}Entry(
+            date: Date(),
+            items: [],
+            fallbackTitle: "${w.fallbackTitle}",
+            fallbackSubtitle: "${w.fallbackSubtitle}"
+        )
+    }
+}
+
+struct ${w.name}Provider: TimelineProvider {
+    func placeholder(in context: Context) -> ${w.name}Entry { .placeholder }
+    
+    func getSnapshot(in context: Context, completion: @escaping (${w.name}Entry) -> Void) {
+        completion(createEntry())
+    }
+    
+    func getTimeline(in context: Context, completion: @escaping (Timeline<${w.name}Entry>) -> Void) {
+        let entry = createEntry()
+        let nextUpdate = Calendar.current.date(byAdding: .minute, value: 15, to: Date())!
+        completion(Timeline(entries: [entry], policy: .after(nextUpdate)))
+    }
+    
+    private func createEntry() -> ${w.name}Entry {
+        var items: [WidgetListItem] = []
+        if let rawItems = WidgetDataProvider.getJSON(forKey: "${w.name}_items") as? [[String: Any]] {
+            items = rawItems.enumerated().map { WidgetListItem(from: $0.element, index: $0.offset) }
+        }
+        
+        return ${w.name}Entry(
+            date: Date(),
+            items: items,
+            fallbackTitle: WidgetDataProvider.getString(forKey: "${w.name}_title", default: "${w.fallbackTitle}"),
+            fallbackSubtitle: WidgetDataProvider.getString(forKey: "${w.name}_subtitle", default: "${w.fallbackSubtitle}")
+        )
+    }
+}
+
+// MARK: ${w.name} Grid Item Cell
+
+struct ${w.name}GridCell: View {
+    let item: WidgetListItem
+    let defaultTitleColor: Color
+    let defaultAccentColor: Color
+    
+    var body: some View {
+        VStack(spacing: 6) {
+            if let icon = item.icon {
+                WidgetIconView(config: icon, accentColor: defaultAccentColor)
+            }
+            
+            Text(item.title.text)
+                .font(item.title.resolvedFont(default: .caption))
+                .fontWeight(item.title.resolvedWeight(default: .medium))
+                .foregroundColor(
+                    item.title.color != nil
+                        ? Color(hex: item.title.color!)
+                        : defaultTitleColor
+                )
+                .lineLimit(1)
+                .truncationMode(.tail)
+        }
+        .frame(maxWidth: .infinity)
+    }
+}
+
+// MARK: ${w.name} Views
+
+struct ${w.name}EntryView: View {
+    @Environment(\\.widgetFamily) var family
+    let entry: ${w.name}Entry
+    
+    private let titleColor: Color = ${titleColor}
+    private let subtitleColor: Color = ${subtitleColor}
+    private let accentColor: Color = ${accentColor}
+    
+    var body: some View {
+        if entry.items.isEmpty {
+            VStack(spacing: 8) {${w.showAppIcon
+        ? `
+                Image("AppIcon")
+                    .resizable()
+                    .frame(width: 40, height: 40)
+                    .cornerRadius(10)`
+        : ""}
+                Text(entry.fallbackTitle)
+                    .font(.headline)
+                    .foregroundColor(titleColor)
+                Text(entry.fallbackSubtitle)
+                    .font(.caption)
+                    .foregroundColor(subtitleColor)
+            }
+            .frame(maxWidth: .infinity, maxHeight: .infinity)
+            .background(${bgColor})
+        } else {
+            let columns = Array(repeating: GridItem(.flexible(), spacing: 8), count: gridColumns)
+            
+            LazyVGrid(columns: columns, spacing: 12) {
+                ForEach(entry.items.prefix(maxItems)) { item in
+                    if let deepLink = item.deepLink, let url = URL(string: deepLink) {
+                        Link(destination: url) {
+                            ${w.name}GridCell(
+                                item: item,
+                                defaultTitleColor: titleColor,
+                                defaultAccentColor: accentColor
+                            )
+                        }
+                    } else {
+                        ${w.name}GridCell(
+                            item: item,
+                            defaultTitleColor: titleColor,
+                            defaultAccentColor: accentColor
+                        )
+                    }
+                }
+            }
+            .padding()
+            .frame(maxWidth: .infinity, maxHeight: .infinity, alignment: .top)
+            .background(${bgColor})
+        }
+    }
+    
+    private var gridColumns: Int {
+        ${gridCols
+        ? `return ${gridCols}`
+        : `switch family {
+        case .systemSmall: return 2
+        case .systemMedium: return 4
+        case .systemLarge, .systemExtraLarge: return 4
+        default: return 3
+        }`}
+    }
+    
+    private var maxItems: Int {
+        ${gridCols && gridRows
+        ? `return ${gridCols * gridRows}`
+        : `switch family {
+        case .systemSmall: return 4
+        case .systemMedium: return 4
+        case .systemLarge, .systemExtraLarge: return 8
+        default: return 4
+        }`}
+    }
+}
+
+struct ${w.name}: Widget {
+    let kind: String = "${w.name}"
+    ${deepLinkLine}
+    
+    var body: some WidgetConfiguration {
+        StaticConfiguration(kind: kind, provider: ${w.name}Provider()) { entry in
+            if #available(iOS 17.0, *) {
+                ${w.name}EntryView(entry: entry)
+                    .containerBackground(${bgColor}, for: .widget)
+                    .widgetURL(deepLinkUrl)
+            } else {
+                ${w.name}EntryView(entry: entry)
+                    .padding()
+                    .background(${bgColor})
+                    .widgetURL(deepLinkUrl)
+            }
+        }
+        .configurationDisplayName("${w.displayName}")
+        .description("${w.description}")
+        .supportedFamilies([${w.widgetFamilies.map((f) => `.${f}`).join(", ")}])
+    }
+}`;
+}
+function generateSingleTypeWidgetCode(w, deepLinkLine) {
+    const bgColor = w.style?.backgroundColor
+        ? `Color(hex: "${w.style.backgroundColor}")`
+        : ".clear";
+    const titleColor = w.style?.titleColor
+        ? `Color(hex: "${w.style.titleColor}")`
+        : ".primary";
+    const subtitleColor = w.style?.subtitleColor
+        ? `Color(hex: "${w.style.subtitleColor}")`
+        : ".secondary";
+    const accentColor = w.style?.accentColor
+        ? `Color(hex: "${w.style.accentColor}")`
+        : ".accentColor";
+    const appIconSmall = w.showAppIcon
+        ? `Image("AppIcon")
+                    .resizable()
+                    .frame(width: 32, height: 32)
+                    .cornerRadius(8)`
+        : "";
+    const appIconMedium = w.showAppIcon
+        ? `Image("AppIcon")
+                .resizable()
+                .frame(width: 48, height: 48)
+                .cornerRadius(12)`
+        : "";
+    const appIconLarge = w.showAppIcon
+        ? `Image("AppIcon")
+                    .resizable()
+                    .frame(width: 56, height: 56)
+                    .cornerRadius(14)`
+        : "";
+    return `
+// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+// MARK: - ${w.name}
+// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+struct ${w.name}Entry: TimelineEntry {
+    let date: Date
+    let title: String
+    let subtitle: String
+    let value: Int
+    
+    static var placeholder: ${w.name}Entry {
+        ${w.name}Entry(
+            date: Date(),
+            title: "${w.displayName}",
+            subtitle: "",
+            value: 0
+        )
+    }
+}
+
+struct ${w.name}Provider: TimelineProvider {
+    func placeholder(in context: Context) -> ${w.name}Entry {
+        return .placeholder
+    }
+    
+    func getSnapshot(in context: Context, completion: @escaping (${w.name}Entry) -> Void) {
+        completion(createEntry())
+    }
+    
+    func getTimeline(in context: Context, completion: @escaping (Timeline<${w.name}Entry>) -> Void) {
+        let entry = createEntry()
+        let nextUpdate = Calendar.current.date(byAdding: .minute, value: 15, to: Date())!
+        let timeline = Timeline(entries: [entry], policy: .after(nextUpdate))
+        completion(timeline)
+    }
+    
+    private func createEntry() -> ${w.name}Entry {
+        return ${w.name}Entry(
+            date: Date(),
+            title: WidgetDataProvider.getString(forKey: "${w.name}_title", default: "${w.displayName}"),
+            subtitle: WidgetDataProvider.getString(forKey: "${w.name}_subtitle", default: ""),
+            value: WidgetDataProvider.getInt(forKey: "${w.name}_value", default: 0)
+        )
+    }
+}
+
+// MARK: ${w.name} Views
+
+struct ${w.name}SmallView: View {
+    let entry: ${w.name}Entry
+    
+    var body: some View {
+        VStack(alignment: .leading, spacing: 4) {
+            HStack {
+                ${appIconSmall}
+                Text(entry.title)
+                    .font(.headline)
+                    .fontWeight(.bold)
+                    .foregroundColor(${titleColor})
+                Spacer()
+            }
+            
+            if !entry.subtitle.isEmpty {
+                Text(entry.subtitle)
+                    .font(.caption)
+                    .foregroundColor(${subtitleColor})
+            }
+            
+            Spacer()
+            
+            Text("\\(entry.value)")
+                .font(.title)
+                .fontWeight(.bold)
+                .foregroundColor(${accentColor})
+        }
+        .padding()
+        .background(${bgColor})
+    }
+}
+
+struct ${w.name}MediumView: View {
+    let entry: ${w.name}Entry
+    
+    var body: some View {
+        HStack {
+            ${appIconMedium}
+            
+            VStack(alignment: .leading, spacing: 4) {
+                Text(entry.title)
+                    .font(.headline)
+                    .fontWeight(.bold)
+                    .foregroundColor(${titleColor})
+                
+                if !entry.subtitle.isEmpty {
+                    Text(entry.subtitle)
+                        .font(.subheadline)
+                        .foregroundColor(${subtitleColor})
+                }
+                
+                Spacer()
+            }
+            
+            Spacer()
+            
+            VStack {
+                Spacer()
+                Text("\\(entry.value)")
+                    .font(.largeTitle)
+                    .fontWeight(.bold)
+                    .foregroundColor(${accentColor})
+                Spacer()
+            }
+        }
+        .padding()
+        .background(${bgColor})
+    }
+}
+
+struct ${w.name}LargeView: View {
+    let entry: ${w.name}Entry
+    
+    var body: some View {
+        VStack(alignment: .leading, spacing: 12) {
+            HStack {
+                ${appIconLarge}
+                VStack(alignment: .leading) {
+                    Text(entry.title)
+                        .font(.title2)
+                        .fontWeight(.bold)
+                        .foregroundColor(${titleColor})
+                    if !entry.subtitle.isEmpty {
+                        Text(entry.subtitle)
+                            .font(.body)
+                            .foregroundColor(${subtitleColor})
+                    }
+                }
+                Spacer()
+            }
+            
+            Spacer()
+            
+            HStack {
+                Spacer()
+                Text("\\(entry.value)")
+                    .font(.system(size: 64))
+                    .fontWeight(.bold)
+                    .foregroundColor(${accentColor})
+                Spacer()
+            }
+            
+            Spacer()
+        }
+        .padding()
+        .background(${bgColor})
+    }
+}
+
+struct ${w.name}EntryView: View {
+    @Environment(\\.widgetFamily) var family
+    let entry: ${w.name}Entry
+    
+    var body: some View {
+        switch family {
+        case .systemSmall:
+            ${w.name}SmallView(entry: entry)
+        case .systemMedium:
+            ${w.name}MediumView(entry: entry)
+        case .systemLarge, .systemExtraLarge:
+            ${w.name}LargeView(entry: entry)
+        default:
+            ${w.name}SmallView(entry: entry)
+        }
+    }
+}
+
+struct ${w.name}: Widget {
+    let kind: String = "${w.name}"
+    ${deepLinkLine}
+    
+    var body: some WidgetConfiguration {
+        StaticConfiguration(kind: kind, provider: ${w.name}Provider()) { entry in
+            if #available(iOS 17.0, *) {
+                ${w.name}EntryView(entry: entry)
+                    .containerBackground(${bgColor}, for: .widget)
+                    .widgetURL(deepLinkUrl)
+            } else {
+                ${w.name}EntryView(entry: entry)
+                    .padding()
+                    .background(${bgColor})
+                    .widgetURL(deepLinkUrl)
+            }
+        }
+        .configurationDisplayName("${w.displayName}")
+        .description("${w.description}")
+        .supportedFamilies([${w.widgetFamilies.map((f) => `.${f}`).join(", ")}])
+    }
+}`;
+}
+/** Generate the full Swift file with all widgets + WidgetBundle */
+function generateWidgetSwiftCode(props, bundleId) {
+    const dataProvider = generateDataProviderCode(props, bundleId);
+    const widgetBlocks = props.widgets
+        .map((w) => generateSingleWidgetCode(w))
+        .join("\n");
+    const bundleBody = props.widgets.map((w) => `        ${w.name}()`).join("\n");
+    // Include Color hex extension if any widget uses style or is list/single type
+    // (list/single items can have per-item colors set at runtime)
+    const needsColorExt = props.widgets.some((w) => w.type === "list" ||
+        w.type === "single" ||
+        w.style?.backgroundColor ||
+        w.style?.titleColor ||
+        w.style?.subtitleColor ||
+        w.style?.accentColor);
+    const colorExtension = needsColorExt
+        ? `
+// MARK: - Color Hex Extension
+
+extension Color {
+    init(hex: String) {
+        let hex = hex.trimmingCharacters(in: CharacterSet.alphanumerics.inverted)
+        var int: UInt64 = 0
+        Scanner(string: hex).scanHexInt64(&int)
+        let a, r, g, b: UInt64
+        switch hex.count {
+        case 6: (a, r, g, b) = (255, (int >> 16) & 0xFF, (int >> 8) & 0xFF, int & 0xFF)
+        case 8: (a, r, g, b) = ((int >> 24) & 0xFF, (int >> 16) & 0xFF, (int >> 8) & 0xFF, int & 0xFF)
+        default: (a, r, g, b) = (255, 0, 0, 0)
+        }
+        self.init(
+            .sRGB,
+            red: Double(r) / 255,
+            green: Double(g) / 255,
+            blue: Double(b) / 255,
+            opacity: Double(a) / 255
+        )
+    }
+}
+`
+        : "";
+    // Determine if we need UIKit import (for UIImage check in icon rendering)
+    const needsUIKit = props.widgets.some((w) => w.type === "list" || w.type === "single");
+    const uiKitImport = needsUIKit ? "\nimport UIKit" : "";
+    return `//
+//  Widgets.swift
+//  ${props.extensionName}
+//
+//  Auto-generated by nn-widgets
+//
+
+import WidgetKit
+import SwiftUI${uiKitImport}
+${colorExtension}
+// MARK: - Widget Data Provider
+${dataProvider}
+${widgetBlocks}
+
+// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+// MARK: - Widget Bundle
+// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+@main
+struct AppWidgetsBundle: WidgetBundle {
+    var body: some Widget {
+${bundleBody}
+    }
+}
+`;
+}
+// ──────────────────────────────────────────────
+//  Plist / entitlements helpers
+// ──────────────────────────────────────────────
+function generateWidgetEntitlements(appGroupId, useAppGroups) {
+    if (!useAppGroups || !appGroupId) {
+        return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+</dict>
+</plist>
+`;
+    }
+    return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>com.apple.security.application-groups</key>
+    <array>
+        <string>${appGroupId}</string>
+    </array>
+</dict>
+</plist>
+`;
+}
+function generateWidgetInfoPlist(props, bundleId) {
+    return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>CFBundleDevelopmentRegion</key>
+    <string>$(DEVELOPMENT_LANGUAGE)</string>
+    <key>CFBundleDisplayName</key>
+    <string>${props.extensionName}</string>
+    <key>CFBundleExecutable</key>
+    <string>$(EXECUTABLE_NAME)</string>
+    <key>CFBundleIdentifier</key>
+    <string>$(PRODUCT_BUNDLE_IDENTIFIER)</string>
+    <key>CFBundleInfoDictionaryVersion</key>
+    <string>6.0</string>
+    <key>CFBundleName</key>
+    <string>$(PRODUCT_NAME)</string>
+    <key>CFBundlePackageType</key>
+    <string>$(PRODUCT_BUNDLE_PACKAGE_TYPE)</string>
+    <key>CFBundleShortVersionString</key>
+    <string>$(MARKETING_VERSION)</string>
+    <key>CFBundleVersion</key>
+    <string>$(CURRENT_PROJECT_VERSION)</string>
+    <key>NSExtension</key>
+    <dict>
+        <key>NSExtensionPointIdentifier</key>
+        <string>com.apple.widgetkit-extension</string>
+    </dict>
+</dict>
+</plist>
+`;
+}
+// ──────────────────────────────────────────────
+//  Config plugin
+// ──────────────────────────────────────────────
+const withIosWidget = (config, props = {}) => {
+    const bundleIdentifier = config.ios?.bundleIdentifier || "com.app.widget";
+    // Resolve props with defaults (normalisation happens in index.ts,
+    // but we handle it here as well for standalone usage)
+    const resolvedProps = resolveIosProps(props, config.name || "Widget", bundleIdentifier);
+    const extensionName = resolvedProps.extensionName;
+    const useAppGroups = resolvedProps.ios.useAppGroups;
+    const appGroupId = resolvedProps.ios.appGroupIdentifier;
+    // Add App Groups to main app entitlements (only if enabled)
+    if (useAppGroups && appGroupId) {
+        config = (0, config_plugins_1.withEntitlementsPlist)(config, (config) => {
+            config.modResults["com.apple.security.application-groups"] =
+                config.modResults["com.apple.security.application-groups"] || [];
+            const groups = config.modResults["com.apple.security.application-groups"];
+            if (!groups.includes(appGroupId)) {
+                groups.push(appGroupId);
+            }
+            return config;
+        });
+        config = (0, config_plugins_1.withInfoPlist)(config, (config) => {
+            config.modResults["NNWidgetsAppGroup"] = appGroupId;
+            return config;
+        });
+    }
+    // Configure Xcode project with widget extension
+    config = (0, config_plugins_1.withXcodeProject)(config, async (config) => {
+        const xcodeProject = config.modResults;
+        const projectRoot = config.modRequest.projectRoot;
+        const projectName = config.modRequest.projectName || "App";
+        const iosPath = path.join(projectRoot, "ios");
+        const extensionPath = path.join(iosPath, extensionName);
+        const extensionBundleId = `${bundleIdentifier}.${extensionName}`;
+        // Check if target already exists
+        const existingTarget = xcodeProject.pbxTargetByName(extensionName);
+        if (existingTarget) {
+            console.log(`[nn-widgets] Widget extension target "${extensionName}" already exists, skipping...`);
+            return config;
+        }
+        // Create extension directory
+        if (!fs.existsSync(extensionPath)) {
+            fs.mkdirSync(extensionPath, { recursive: true });
+        }
+        // Write single Swift file containing ALL widgets
+        const swiftCode = generateWidgetSwiftCode(resolvedProps, bundleIdentifier);
+        const swiftFileName = "Widgets.swift";
+        fs.writeFileSync(path.join(extensionPath, swiftFileName), swiftCode);
+        // Write entitlements
+        const entitlements = generateWidgetEntitlements(appGroupId, useAppGroups);
+        const entitlementsFileName = `${extensionName}.entitlements`;
+        fs.writeFileSync(path.join(extensionPath, entitlementsFileName), entitlements);
+        // Write Info.plist
+        const infoPlist = generateWidgetInfoPlist(resolvedProps, bundleIdentifier);
+        fs.writeFileSync(path.join(extensionPath, "Info.plist"), infoPlist);
+        // Create Assets.xcassets for widget extension
+        const assetsPath = path.join(extensionPath, "Assets.xcassets");
+        if (!fs.existsSync(assetsPath)) {
+            fs.mkdirSync(assetsPath, { recursive: true });
+            fs.writeFileSync(path.join(assetsPath, "Contents.json"), JSON.stringify({ info: { author: "xcode", version: 1 } }, null, 2));
+            // Create AccentColor
+            const accentColorPath = path.join(assetsPath, "AccentColor.colorset");
+            fs.mkdirSync(accentColorPath, { recursive: true });
+            fs.writeFileSync(path.join(accentColorPath, "Contents.json"), JSON.stringify({
+                colors: [{ idiom: "universal" }],
+                info: { author: "xcode", version: 1 },
+            }, null, 2));
+            // Create WidgetBackground
+            const widgetBgPath = path.join(assetsPath, "WidgetBackground.colorset");
+            fs.mkdirSync(widgetBgPath, { recursive: true });
+            fs.writeFileSync(path.join(widgetBgPath, "Contents.json"), JSON.stringify({
+                colors: [{ idiom: "universal" }],
+                info: { author: "xcode", version: 1 },
+            }, null, 2));
+            // Copy AppIcon if ANY widget has showAppIcon enabled
+            const needsAppIcon = resolvedProps.widgets.some((w) => w.showAppIcon);
+            if (needsAppIcon) {
+                const mainAppAssetsPath = path.join(iosPath, projectName, "Images.xcassets", "AppIcon.appiconset");
+                const widgetAppIconPath = path.join(assetsPath, "AppIcon.imageset");
+                if (fs.existsSync(mainAppAssetsPath)) {
+                    fs.mkdirSync(widgetAppIconPath, { recursive: true });
+                    const iconFiles = fs
+                        .readdirSync(mainAppAssetsPath)
+                        .filter((f) => f.endsWith(".png"));
+                    if (iconFiles.length > 0) {
+                        const iconToCopy = iconFiles.find((f) => f.includes("1024") || f.includes("512") || f.includes("180")) || iconFiles[0];
+                        const sourcePath = path.join(mainAppAssetsPath, iconToCopy);
+                        const destPath = path.join(widgetAppIconPath, "AppIcon.png");
+                        fs.copyFileSync(sourcePath, destPath);
+                        fs.writeFileSync(path.join(widgetAppIconPath, "Contents.json"), JSON.stringify({
+                            images: [
+                                {
+                                    filename: "AppIcon.png",
+                                    idiom: "universal",
+                                    scale: "1x",
+                                },
+                                { idiom: "universal", scale: "2x" },
+                                { idiom: "universal", scale: "3x" },
+                            ],
+                            info: { author: "xcode", version: 1 },
+                        }, null, 2));
+                    }
+                }
+            }
+        }
+        // ── Copy widget images to Assets.xcassets ──
+        for (const w of resolvedProps.widgets) {
+            if (!w.image)
+                continue;
+            const sizes = [
+                { key: "small", path: w.image.small },
+                { key: "medium", path: w.image.medium },
+                { key: "large", path: w.image.large },
+            ];
+            for (const size of sizes) {
+                if (!size.path)
+                    continue;
+                const assetName = `${w.name}_${size.key}`;
+                const imagesetPath = path.join(assetsPath, `${assetName}.imageset`);
+                fs.mkdirSync(imagesetPath, { recursive: true });
+                // Resolve source path relative to projectRoot
+                const imgSourcePath = path.isAbsolute(size.path)
+                    ? size.path
+                    : path.join(projectRoot, size.path);
+                if (!fs.existsSync(imgSourcePath)) {
+                    console.warn(`[nn-widgets] Widget image not found: ${imgSourcePath} (widget: ${w.name}, size: ${size.key})`);
+                    continue;
+                }
+                const ext = path.extname(imgSourcePath);
+                const destFileName = `${assetName}${ext}`;
+                fs.copyFileSync(imgSourcePath, path.join(imagesetPath, destFileName));
+                fs.writeFileSync(path.join(imagesetPath, "Contents.json"), JSON.stringify({
+                    images: [
+                        { filename: destFileName, idiom: "universal", scale: "1x" },
+                        { idiom: "universal", scale: "2x" },
+                        { idiom: "universal", scale: "3x" },
+                    ],
+                    info: { author: "xcode", version: 1 },
+                }, null, 2));
+                console.log(`[nn-widgets] Copied widget image: ${assetName} → ${imagesetPath}`);
+            }
+        }
+        // ── Copy widget icons to Assets.xcassets ──
+        for (const w of resolvedProps.widgets) {
+            if (!w.icons)
+                continue;
+            for (const [iconName, iconPath] of Object.entries(w.icons)) {
+                const imagesetPath = path.join(assetsPath, `${iconName}.imageset`);
+                fs.mkdirSync(imagesetPath, { recursive: true });
+                const imgSourcePath = path.isAbsolute(iconPath)
+                    ? iconPath
+                    : path.join(projectRoot, iconPath);
+                if (!fs.existsSync(imgSourcePath)) {
+                    console.warn(`[nn-widgets] Widget icon not found: ${imgSourcePath} (widget: ${w.name}, icon: ${iconName})`);
+                    continue;
+                }
+                const ext = path.extname(imgSourcePath);
+                const destFileName = `${iconName}${ext}`;
+                fs.copyFileSync(imgSourcePath, path.join(imagesetPath, destFileName));
+                fs.writeFileSync(path.join(imagesetPath, "Contents.json"), JSON.stringify({
+                    images: [
+                        {
+                            filename: destFileName,
+                            idiom: "universal",
+                            scale: "1x",
+                        },
+                        { idiom: "universal", scale: "2x" },
+                        { idiom: "universal", scale: "3x" },
+                    ],
+                    info: { author: "xcode", version: 1 },
+                }, null, 2));
+                console.log(`[nn-widgets] Copied widget icon: ${iconName} → ${imagesetPath}`);
+            }
+        }
+        // ── Xcode project manipulation ──────────────────
+        // Create PBXGroup for extension
+        const widgetGroup = xcodeProject.addPbxGroup([], extensionName, extensionName);
+        // Add group to the main project group
+        const projectSection = xcodeProject.pbxProjectSection();
+        for (const key in projectSection) {
+            if (projectSection[key] && projectSection[key].mainGroup) {
+                const mainGroupUuid = projectSection[key].mainGroup;
+                const pbxGroupSection = xcodeProject.hash.project.objects["PBXGroup"];
+                if (pbxGroupSection?.[mainGroupUuid]?.children) {
+                    pbxGroupSection[mainGroupUuid].children.push({
+                        value: widgetGroup.uuid,
+                        comment: extensionName,
+                    });
+                }
+                break;
+            }
+        }
+        // Create the widget extension target
+        const target = xcodeProject.addTarget(extensionName, "app_extension", extensionName, extensionBundleId);
+        if (!target) {
+            console.error("[nn-widgets] Failed to create widget extension target");
+            return config;
+        }
+        const targetUuid = target.uuid;
+        // Add Swift file to sources build phase
+        const swiftFileRef = xcodeProject.generateUuid();
+        const pbxFileReferenceSection = xcodeProject.hash.project.objects["PBXFileReference"];
+        pbxFileReferenceSection[swiftFileRef] = {
+            isa: "PBXFileReference",
+            lastKnownFileType: "sourcecode.swift",
+            path: `${extensionName}/${swiftFileName}`,
+            sourceTree: '"<group>"',
+        };
+        pbxFileReferenceSection[`${swiftFileRef}_comment`] = swiftFileName;
+        const sourcesBuildPhase = xcodeProject.addBuildPhase([], "PBXSourcesBuildPhase", "Sources", targetUuid);
+        if (sourcesBuildPhase?.buildPhase) {
+            const buildFileUuid = xcodeProject.generateUuid();
+            const pbxBuildFileSection = xcodeProject.hash.project.objects["PBXBuildFile"];
+            pbxBuildFileSection[buildFileUuid] = {
+                isa: "PBXBuildFile",
+                fileRef: swiftFileRef,
+                fileRef_comment: swiftFileName,
+            };
+            pbxBuildFileSection[`${buildFileUuid}_comment`] =
+                `${swiftFileName} in Sources`;
+            sourcesBuildPhase.buildPhase.files.push({
+                value: buildFileUuid,
+                comment: `${swiftFileName} in Sources`,
+            });
+        }
+        // Resources & Frameworks build phases
+        const resourcesBuildPhase = xcodeProject.addBuildPhase([], "PBXResourcesBuildPhase", "Resources", targetUuid);
+        // Add Assets.xcassets to the widget extension's Resources build phase
+        const assetsFileRef = xcodeProject.generateUuid();
+        pbxFileReferenceSection[assetsFileRef] = {
+            isa: "PBXFileReference",
+            lastKnownFileType: "folder.assetcatalog",
+            path: `${extensionName}/Assets.xcassets`,
+            sourceTree: '"<group>"',
+        };
+        pbxFileReferenceSection[`${assetsFileRef}_comment`] = "Assets.xcassets";
+        if (resourcesBuildPhase?.buildPhase) {
+            const assetsBuildFileUuid = xcodeProject.generateUuid();
+            const pbxBuildFileSection2 = xcodeProject.hash.project.objects["PBXBuildFile"];
+            pbxBuildFileSection2[assetsBuildFileUuid] = {
+                isa: "PBXBuildFile",
+                fileRef: assetsFileRef,
+                fileRef_comment: "Assets.xcassets",
+            };
+            pbxBuildFileSection2[`${assetsBuildFileUuid}_comment`] =
+                "Assets.xcassets in Resources";
+            resourcesBuildPhase.buildPhase.files.push({
+                value: assetsBuildFileUuid,
+                comment: "Assets.xcassets in Resources",
+            });
+        }
+        xcodeProject.addBuildPhase([], "PBXFrameworksBuildPhase", "Frameworks", targetUuid);
+        // Configure build settings
+        const configurations = xcodeProject.pbxXCBuildConfigurationSection();
+        for (const configKey in configurations) {
+            const configObj = configurations[configKey];
+            if (typeof configObj === "object" && configObj.buildSettings) {
+                const bs = configObj.buildSettings;
+                if (bs.PRODUCT_BUNDLE_IDENTIFIER === `"${extensionBundleId}"` ||
+                    bs.PRODUCT_BUNDLE_IDENTIFIER === extensionBundleId ||
+                    bs.PRODUCT_NAME === `"${extensionName}"` ||
+                    bs.PRODUCT_NAME === extensionName) {
+                    bs.ASSETCATALOG_COMPILER_GLOBAL_ACCENT_COLOR_NAME = '"AccentColor"';
+                    bs.ASSETCATALOG_COMPILER_WIDGET_BACKGROUND_COLOR_NAME =
+                        '"WidgetBackground"';
+                    bs.CODE_SIGN_ENTITLEMENTS = `"${extensionName}/${entitlementsFileName}"`;
+                    bs.CODE_SIGN_STYLE = "Automatic";
+                    bs.CURRENT_PROJECT_VERSION = "1";
+                    bs.GENERATE_INFOPLIST_FILE = "NO";
+                    bs.INFOPLIST_FILE = `"${extensionName}/Info.plist"`;
+                    bs.INFOPLIST_KEY_CFBundleDisplayName = `"${resolvedProps.extensionName}"`;
+                    bs.INFOPLIST_KEY_NSHumanReadableCopyright = '""';
+                    bs.IPHONEOS_DEPLOYMENT_TARGET = resolvedProps.ios.deploymentTarget;
+                    bs.LD_RUNPATH_SEARCH_PATHS =
+                        '"$(inherited) @executable_path/Frameworks @executable_path/../../Frameworks"';
+                    bs.MARKETING_VERSION = "1.0";
+                    bs.PRODUCT_BUNDLE_IDENTIFIER = `"${extensionBundleId}"`;
+                    bs.PRODUCT_NAME = '"$(TARGET_NAME)"';
+                    bs.SKIP_INSTALL = "YES";
+                    bs.SWIFT_EMIT_LOC_STRINGS = "YES";
+                    bs.SWIFT_VERSION = "5.0";
+                    bs.TARGETED_DEVICE_FAMILY = '"1,2"';
+                    if (resolvedProps.ios.devTeam) {
+                        bs.DEVELOPMENT_TEAM = resolvedProps.ios.devTeam;
+                    }
+                }
+            }
+        }
+        // Embed extension in main app
+        const mainTarget = xcodeProject.getFirstTarget();
+        if (mainTarget?.uuid) {
+            xcodeProject.addTargetDependency(mainTarget.uuid, [targetUuid]);
+            const nativeTargetSection = xcodeProject.hash.project.objects["PBXNativeTarget"];
+            let productRef = null;
+            for (const key in nativeTargetSection) {
+                if (typeof nativeTargetSection[key] === "object" &&
+                    nativeTargetSection[key].name === extensionName) {
+                    productRef = nativeTargetSection[key].productReference;
+                    break;
+                }
+            }
+            if (productRef) {
+                const copyFilesBuildPhaseUuid = xcodeProject.generateUuid();
+                const buildFileUuid = xcodeProject.generateUuid();
+                const pbxBuildFileSection = xcodeProject.hash.project.objects["PBXBuildFile"];
+                pbxBuildFileSection[buildFileUuid] = {
+                    isa: "PBXBuildFile",
+                    fileRef: productRef,
+                    fileRef_comment: `${extensionName}.appex`,
+                    settings: { ATTRIBUTES: ["RemoveHeadersOnCopy"] },
+                };
+                pbxBuildFileSection[`${buildFileUuid}_comment`] =
+                    `${extensionName}.appex in Embed Foundation Extensions`;
+                const pbxCopyFilesBuildPhaseSection = xcodeProject.hash.project.objects["PBXCopyFilesBuildPhase"] || {};
+                xcodeProject.hash.project.objects["PBXCopyFilesBuildPhase"] =
+                    pbxCopyFilesBuildPhaseSection;
+                pbxCopyFilesBuildPhaseSection[copyFilesBuildPhaseUuid] = {
+                    isa: "PBXCopyFilesBuildPhase",
+                    buildActionMask: 2147483647,
+                    dstPath: '""',
+                    dstSubfolderSpec: 13,
+                    files: [
+                        {
+                            value: buildFileUuid,
+                            comment: `${extensionName}.appex in Embed Foundation Extensions`,
+                        },
+                    ],
+                    name: '"Embed Foundation Extensions"',
+                    runOnlyForDeploymentPostprocessing: 0,
+                };
+                pbxCopyFilesBuildPhaseSection[`${copyFilesBuildPhaseUuid}_comment`] =
+                    "Embed Foundation Extensions";
+                for (const key in nativeTargetSection) {
+                    if (typeof nativeTargetSection[key] === "object" &&
+                        nativeTargetSection[key].name === projectName) {
+                        if (!nativeTargetSection[key].buildPhases) {
+                            nativeTargetSection[key].buildPhases = [];
+                        }
+                        nativeTargetSection[key].buildPhases.push({
+                            value: copyFilesBuildPhaseUuid,
+                            comment: "Embed Foundation Extensions",
+                        });
+                        break;
+                    }
+                }
+            }
+        }
+        const widgetNames = resolvedProps.widgets.map((w) => w.name).join(", ");
+        console.log(`[nn-widgets] Created iOS widget extension "${extensionName}" with widgets: ${widgetNames}`);
+        return config;
+    });
+    return config;
+};
+exports.withIosWidget = withIosWidget;
+// ──────────────────────────────────────────────
+//  Props resolution helper
+// ──────────────────────────────────────────────
+function resolveIosProps(props, appName, bundleIdentifier) {
+    const useAppGroups = props.ios?.useAppGroups !== false;
+    // Normalise widgets array (handle legacy single-widget format)
+    let widgets;
+    if (props.widgets && props.widgets.length > 0) {
+        widgets = props.widgets.map((w) => {
+            // Resolve image: normalise string → per-size object
+            let resolvedImage;
+            if (w.image) {
+                if (typeof w.image === "string") {
+                    resolvedImage = { small: w.image, medium: w.image, large: w.image };
+                }
+                else {
+                    resolvedImage = {
+                        small: w.image.small,
+                        medium: w.image.medium,
+                        large: w.image.large,
+                    };
+                    // Only include if at least one size is set
+                    if (!resolvedImage.small &&
+                        !resolvedImage.medium &&
+                        !resolvedImage.large) {
+                        resolvedImage = undefined;
+                    }
+                }
+            }
+            // Auto-detect type: if image is set and type is not, use "image"
+            const hasImage = resolvedImage &&
+                (resolvedImage.small || resolvedImage.medium || resolvedImage.large);
+            let resolvedType = w.type || (hasImage ? "image" : "single");
+            return {
+                name: w.name,
+                displayName: w.displayName,
+                description: w.description || "A widget for your app",
+                type: resolvedType,
+                deepLinkUrl: w.deepLinkUrl,
+                showAppIcon: w.showAppIcon !== false,
+                widgetFamilies: w.widgetFamilies || [
+                    "systemSmall",
+                    "systemMedium",
+                    "systemLarge",
+                ],
+                image: resolvedImage,
+                icons: w.icons,
+                gridLayout: w.gridLayout,
+                style: w.style,
+                fallbackTitle: w.fallbackTitle || w.displayName,
+                fallbackSubtitle: w.fallbackSubtitle || "Open app to start",
+                android: {
+                    minWidth: w.android?.minWidth || props.android?.minWidth || 110,
+                    minHeight: w.android?.minHeight || props.android?.minHeight || 40,
+                    resizeMode: w.android?.resizeMode ||
+                        props.android?.resizeMode ||
+                        "horizontal|vertical",
+                },
+            };
+        });
+    }
+    else {
+        // Legacy single-widget format → convert to widgets[]
+        widgets = [
+            {
+                name: props.widgetName || "AppWidget",
+                displayName: props.displayName || appName,
+                description: props.description || "A widget for your app",
+                type: "single",
+                deepLinkUrl: props.ios?.deepLinkUrl || `${bundleIdentifier}://widget`,
+                showAppIcon: props.ios?.showAppIcon !== false,
+                widgetFamilies: props.ios?.widgetFamilies || [
+                    "systemSmall",
+                    "systemMedium",
+                    "systemLarge",
+                ],
+                fallbackTitle: props.displayName || appName,
+                fallbackSubtitle: "Open app to start",
+                android: {
+                    minWidth: props.android?.minWidth || 110,
+                    minHeight: props.android?.minHeight || 40,
+                    resizeMode: props.android?.resizeMode || "horizontal|vertical",
+                },
+            },
+        ];
+    }
+    return {
+        extensionName: "WidgetsExtension",
+        widgets,
+        ios: {
+            deploymentTarget: props.ios?.deploymentTarget || "17.0",
+            useAppGroups,
+            appGroupIdentifier: useAppGroups
+                ? props.ios?.appGroupIdentifier || `group.${bundleIdentifier}`
+                : undefined,
+            devTeam: props.ios?.devTeam,
+        },
+        android: {
+            minSdkVersion: props.android?.minSdkVersion || 26,
+            updatePeriodMillis: props.android?.updatePeriodMillis || 1800000,
+        },
+    };
+}
+exports.default = exports.withIosWidget;