# List recent posts (paginated)
GET https://yoursite.com/wp-json/wp/v2/posts

# Get a single post with embedded featured image
GET https://yoursite.com/wp-json/wp/v2/posts/42?_embed

# Paginate and filter by category
GET https://yoursite.com/wp-json/wp/v2/posts?page=1&per_page=10&categories=5

# Search posts
GET https://yoursite.com/wp-json/wp/v2/posts?search=swift+tutorial

# Get all categories
GET https://yoursite.com/wp-json/wp/v2/categories

# Get pages
GET https://yoursite.com/wp-json/wp/v2/pages

# WooCommerce products (needs WC API key)
GET https://yoursite.com/wp-json/wc/v3/products

import Foundation

struct Post: Codable, Identifiable {
    let id: Int
    let date: String
    let slug: String
    let title: RenderedText
    let content: RenderedText
    let excerpt: RenderedText
    let embedded: Embedded?

    enum CodingKeys: String, CodingKey {
        case id, date, slug, title, content, excerpt
        case embedded = "_embedded"
    }

    var featuredImageURL: URL? {
        embedded?.featuredMedia?.first?.sourceURL.flatMap { URL(string: $0) }
    }
}

struct RenderedText: Codable {
    let rendered: String
}

struct Embedded: Codable {
    let featuredMedia: [FeaturedMedia]?
    enum CodingKeys: String, CodingKey {
        case featuredMedia = "wp:featuredmedia"
    }
}

struct FeaturedMedia: Codable {
    let id: Int
    let sourceURL: String?
    enum CodingKeys: String, CodingKey {
        case id
        case sourceURL = "source_url"
    }
}

struct WPCategory: Codable, Identifiable {
    let id: Int
    let name: String
    let slug: String
    let count: Int
}

import Foundation

class WordPressService {

    // ← Replace with your WordPress site URL
    private let baseURL = "https://yoursite.com/wp-json/wp/v2"

    private let decoder: JSONDecoder = {
        let d = JSONDecoder()
        d.keyDecodingStrategy = .convertFromSnakeCase
        return d
    }()

    // Fetch paginated posts with embedded featured images
    func fetchPosts(page: Int = 1, perPage: Int = 10) async throws -> [Post] {
        var components = URLComponents(string: "\(baseURL)/posts")!
        components.queryItems = [
            .init(name: "page",     value: "\(page)"),
            .init(name: "per_page", value: "\(perPage)"),
            .init(name: "_embed",   value: "true")    // pulls featured image
        ]
        let (data, response) = try await URLSession.shared.data(from: components.url!)
        guard let http = response as? HTTPURLResponse,
              http.statusCode == 200 else {
            throw URLError(.badServerResponse)
        }
        return try decoder.decode([Post].self, from: data)
    }

    // Fetch a single post by ID
    func fetchPost(id: Int) async throws -> Post {
        let url = URL(string: "\(baseURL)/posts/\(id)?_embed=true")!
        let (data, _) = try await URLSession.shared.data(from: url)
        return try decoder.decode(Post.self, from: data)
    }

    // Search posts by keyword
    func searchPosts(query: String) async throws -> [Post] {
        var components = URLComponents(string: "\(baseURL)/posts")!
        components.queryItems = [.init(name: "search", value: query)]
        let (data, _) = try await URLSession.shared.data(from: components.url!)
        return try decoder.decode([Post].self, from: data)
    }

    // Fetch all categories
    func fetchCategories() async throws -> [WPCategory] {
        let url = URL(string: "\(baseURL)/categories?per_page=50")!
        let (data, _) = try await URLSession.shared.data(from: url)
        return try decoder.decode([WPCategory].self, from: data)
    }
}

import SwiftUI
import Combine

@MainActor
class PostsViewModel: ObservableObject {

    @Published var posts: [Post] = []
    @Published var isLoading = false
    @Published var errorMessage: String? = nil
    @Published var currentPage = 1
    @Published var hasMorePages = true

    private let service = WordPressService()

    func loadPosts(reset: Bool = false) {
        guard !isLoading else { return }
        if reset { currentPage = 1; posts = []; hasMorePages = true }
        guard hasMorePages else { return }

        isLoading = true
        Task {
            do {
                let newPosts = try await service.fetchPosts(page: currentPage)
                posts.append(contentsOf: newPosts)
                hasMorePages = newPosts.count == 10
                currentPage += 1
                errorMessage = nil
            } catch {
                errorMessage = error.localizedDescription
            }
            isLoading = false
        }
    }
}

import SwiftUI

struct PostListView: View {
    @StateObject var viewModel = PostsViewModel()

    var body: some View {
        NavigationView {
            Group {
                if viewModel.isLoading && viewModel.posts.isEmpty {
                    ProgressView("Loading posts…")
                } else if let error = viewModel.errorMessage {
                    ContentUnavailableView(error, systemImage: "wifi.slash")
                } else {
                    List {
                        ForEach(viewModel.posts) { post in
                            NavigationLink(destination: PostDetailView(post: post)) {
                                PostRowView(post: post)
                            }
                        }
                        // Infinite scroll trigger
                        if viewModel.hasMorePages {
                            ProgressView()
                                .onAppear { viewModel.loadPosts() }
                        }
                    }
                    .listStyle(.plain)
                    .refreshable { viewModel.loadPosts(reset: true) }
                }
            }
            .navigationTitle("Latest Posts")
            .onAppear { viewModel.loadPosts() }
        }
    }
}

struct PostRowView: View {
    let post: Post

    var body: some View {
        HStack(spacing: 12) {
            if let url = post.featuredImageURL {
                AsyncImage(url: url) { img in
                    img.resizable().scaledToFill()
                } placeholder: { Color.gray.opacity(0.15) }
                .frame(width: 80, height: 80)
                .cornerRadius(10)
                .clipped()
            }
            VStack(alignment: .leading, spacing: 4) {
                Text(post.title.rendered.strippingHTML())
                    .font(.headline)
                    .lineLimit(2)
                Text(post.excerpt.rendered.strippingHTML())
                    .font(.subheadline)
                    .foregroundColor(.secondary)
                    .lineLimit(2)
            }
        }
        .padding(.vertical, 6)
    }
}

// Helper: strip HTML tags from WordPress rendered strings
extension String {
    func strippingHTML() -> String {
        guard let data = data(using: .utf8) else { return self }
        let options: [NSAttributedString.DocumentReadingOptionKey: Any] = [
            .documentType: NSAttributedString.DocumentType.html,
            .characterEncoding: String.Encoding.utf8.rawValue
        ]
        return (try? NSAttributedString(data: data, options: options, documentAttributes: nil))?.string ?? self
    }
}

{
  "name": "Your WordPress Site",
  "short_name": "YourSite",
  "description": "Your site tagline",
  "start_url": "/",
  "display": "standalone",
  "background_color": "#ffffff",
  "theme_color": "#0071E3",
  "icons": [
    { "src": "/icon-180.png", "sizes": "180x180", "type": "image/png" },
    { "src": "/icon-512.png", "sizes": "512x512", "type": "image/png" }
  ]
}

import UIKit
import UserNotifications

class AppDelegate: NSObject, UIApplicationDelegate, UNUserNotificationCenterDelegate {

    func application(_ application: UIApplication,
                     didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {

        UNUserNotificationCenter.current().delegate = self

        let authOptions: UNAuthorizationOptions = [.alert, .badge, .sound]
        UNUserNotificationCenter.current().requestAuthorization(options: authOptions) { granted, _ in
            guard granted else { return }
            DispatchQueue.main.async {
                application.registerForRemoteNotifications()
            }
        }
        return true
    }

    // Receive device token — send it to your WordPress backend
    func application(_ application: UIApplication,
                     didRegisterForRemoteNotificationsWithDeviceToken deviceToken: Data) {
        let tokenString = deviceToken.map { String(format: "%02.2hhx", $0) }.joined()
        WordPressService().registerDeviceToken(tokenString)
    }

    // Handle foreground notifications
    func userNotificationCenter(_ center: UNUserNotificationCenter,
                                willPresent notification: UNNotification,
                                withCompletionHandler completionHandler: @escaping (UNNotificationPresentationOptions) -> Void) {
        completionHandler([.banner, .sound, .badge])
    }
}

import Foundation

struct WCProduct: Codable, Identifiable {
    let id: Int
    let name: String
    let price: String
    let regularPrice: String
    let shortDescription: String
    let images: [WCImage]
    let stockStatus: String
}

struct WCImage: Codable {
    let id: Int
    let src: String
}

class WooCommerceService {
    private let baseURL  = "https://yoursite.com/wp-json/wc/v3"
    private let consumerKey    = "ck_your_consumer_key"
    private let consumerSecret = "cs_your_consumer_secret"

    private func makeRequest(path: String) -> URLRequest {
        var components = URLComponents(string: "\(baseURL)\(path)")!
        components.queryItems = [
            .init(name: "consumer_key",    value: consumerKey),
            .init(name: "consumer_secret", value: consumerSecret)
        ]
        return URLRequest(url: components.url!)
    }

    func fetchProducts(page: Int = 1) async throws -> [WCProduct] {
        var req = makeRequest(path: "/products")
        let (data, _) = try await URLSession.shared.data(for: req)
        let decoder = JSONDecoder()
        decoder.keyDecodingStrategy = .convertFromSnakeCase
        return try decoder.decode([WCProduct].self, from: data)
    }
}