Подключение из iOS

enum API {
    static let base = URL(string: "https://api.desperatemeasure.tech")!

    static func url(_ path: String) -> URL {
        base.appendingPathComponent(path)
    }

    /// Пути к медиа приходят относительными: /media/elio/1-1200.webp
    static func asset(_ relative: String) -> URL {
        URL(string: relative, relativeTo: base)!.absoluteURL
    }
}

curl https://api.desperatemeasure.tech/openapi.json -o openapi.json
swift-openapi-generator generate openapi.json --mode types

struct ImageSet: Codable, Hashable {
    let thumb: String
    let detail: String
    let full: String
}

struct Dimensions: Codable, Hashable {
    let shape: String?
    let diameterMm: Int?
    let diameterExtendedMm: Int?
    let widthMm: Int?
    let widthExtendedMm: Int?
    let depthMm: Int?
    let heightMm: Int?
    let heightOptionsMm: [Int]
    let parsed: Bool
}

struct BaseOption: Codable, Hashable, Identifiable {
    let id: String
    let label: String
    let price: Int
    let dimensions: Dimensions
    /// [идентификатор группы: [идентификатор варианта: надбавка]]
    let priceMatrix: [String: [String: Int]]
    /// [идентификатор опции: надбавка]
    let optionPrices: [String: Int]
}

struct Choice: Codable, Hashable, Identifiable {
    let id: String
    let label: String
    let swatches: [String]
}

struct ChoiceGroup: Codable, Hashable, Identifiable {
    let id: String
    let title: String
    let options: [Choice]
}

struct BaseGroup: Codable, Hashable {
    let id: String
    let title: String
    let options: [BaseOption]
}

struct Extra: Codable, Hashable, Identifiable {
    let id: String
    let label: String
    let price: Int
}

struct Finish: Codable, Hashable, Identifiable {
    let id: String
    let label: String
    let image: String?
}

struct FinishSection: Codable, Hashable {
    let part: String
    let category: String
    let items: [Finish]
}

struct Product: Codable, Hashable, Identifiable {
    var id: String { slug }

    let slug: String
    let title: String
    let category: String
    let isNew: Bool
    let description: String

    let priceFrom: Int?
    let priceTo: Int?
    let priceOnRequest: Bool
    let priceWarnings: [String]

    let images: [ImageSet]
    let hasAr: Bool
    let modelUrl: String?

    let baseGroup: BaseGroup
    let deltaGroups: [ChoiceGroup]
    let extras: [Extra]
    let finishes: [FinishSection]
}

struct ProductSummary: Codable, Hashable, Identifiable {
    var id: String { slug }

    let slug: String
    let title: String
    let category: String
    let isNew: Bool
    let priceFrom: Int?
    let priceOnRequest: Bool
    let hasAr: Bool
    let image: ImageSet?
}

struct Category: Codable, Hashable, Identifiable {
    let id: String
    let title: String
    let count: Int
}

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

    private func get<T: Decodable>(_ path: String, query: [URLQueryItem] = []) async throws -> T {
        var components = URLComponents(url: API.url(path), resolvingAgainstBaseURL: false)!
        if !query.isEmpty { components.queryItems = query }

        let (data, response) = try await URLSession.shared.data(from: components.url!)
        guard let http = response as? HTTPURLResponse else { throw CatalogError.badResponse }
        guard http.statusCode == 200 else {
            throw CatalogError.http(status: http.statusCode, body: String(decoding: data, as: UTF8.self))
        }
        return try decoder.decode(T.self, from: data)
    }

    func categories() async throws -> [Category] {
        try await get("v1/categories")
    }

    func products(category: String? = nil, hasAR: Bool? = nil) async throws -> [ProductSummary] {
        var query: [URLQueryItem] = []
        if let category { query.append(.init(name: "category", value: category)) }
        if let hasAR { query.append(.init(name: "has_ar", value: hasAR ? "true" : "false")) }
        return try await get("v1/products", query: query)
    }

    func product(_ slug: String) async throws -> Product {
        try await get("v1/products/\(slug)")
    }
}

enum CatalogError: Error {
    case badResponse
    case http(status: Int, body: String)
}

struct Configuration {
    /// Идентификатор выбранного варианта базовой группы (размер или ткань).
    var baseOptionID: String
    /// [идентификатор группы: идентификатор выбранного варианта]
    var selections: [String: String]
    /// Отмеченные опции
    var extras: Set<String>
}

extension Product {
    /// Конфигурация по умолчанию: первый вариант в каждой группе, опции сняты.
    var defaultConfiguration: Configuration {
        Configuration(
            baseOptionID: baseGroup.options[0].id,
            selections: Dictionary(uniqueKeysWithValues: deltaGroups.compactMap { group in
                group.options.first.map { (group.id, $0.id) }
            }),
            extras: []
        )
    }

    func price(for config: Configuration) -> Int? {
        guard let base = baseGroup.options.first(where: { $0.id == config.baseOptionID }) else {
            return nil
        }
        let deltas = config.selections.reduce(0) { sum, pair in
            sum + (base.priceMatrix[pair.key]?[pair.value] ?? 0)
        }
        let options = config.extras.reduce(0) { $0 + (base.optionPrices[$1] ?? 0) }
        return base.price + deltas + options
    }
}

extension Int {
    var asRubles: String {
        let f = NumberFormatter()
        f.numberStyle = .currency
        f.currencyCode = "RUB"
        f.maximumFractionDigits = 0
        f.locale = Locale(identifier: "ru_RU")
        return f.string(from: NSNumber(value: self)) ?? "\(self) ₽"
    }
}

struct ConfiguratorView: View {
    let product: Product
    @State private var config: Configuration

    init(product: Product) {
        self.product = product
        _config = State(initialValue: product.defaultConfiguration)
    }

    var body: some View {
        VStack(alignment: .leading, spacing: 24) {
            // базовая группа — размер или ткань
            picker(title: product.baseGroup.title,
                   options: product.baseGroup.options.map { ($0.id, $0.label) },
                   selection: $config.baseOptionID)

            // группы надбавок
            ForEach(product.deltaGroups) { group in
                picker(title: group.title,
                       options: group.options.map { ($0.id, $0.label) },
                       selection: Binding(
                           get: { config.selections[group.id] ?? "" },
                           set: { config.selections[group.id] = $0 }))
            }

            // опции-галочки
            ForEach(product.extras) { extra in
                Toggle(extra.label, isOn: Binding(
                    get: { config.extras.contains(extra.id) },
                    set: { on in
                        if on { config.extras.insert(extra.id) }
                        else { config.extras.remove(extra.id) }
                    }))
            }

            if let total = product.price(for: config) {
                Text(total.asRubles).font(.title2.bold())
            } else if product.priceOnRequest {
                Text("Цена по запросу").foregroundStyle(.secondary)
            }
        }
    }

    @ViewBuilder
    private func picker(title: String, options: [(String, String)], selection: Binding<String>) -> some View {
        VStack(alignment: .leading, spacing: 8) {
            Text(title).font(.subheadline).foregroundStyle(.secondary)
            Picker(title, selection: selection) {
                ForEach(options, id: \.0) { Text($0.1).tag($0.0) }
            }
            .pickerStyle(.segmented)
        }
    }
}

import QuickLook

struct ARQuickLook: UIViewControllerRepresentable {
    let modelURL: URL

    func makeUIViewController(context: Context) -> QLPreviewController {
        let controller = QLPreviewController()
        controller.dataSource = context.coordinator
        return controller
    }

    func updateUIViewController(_ controller: QLPreviewController, context: Context) {}

    func makeCoordinator() -> Coordinator { Coordinator(url: modelURL) }

    final class Coordinator: NSObject, QLPreviewControllerDataSource {
        let url: URL
        init(url: URL) { self.url = url }

        func numberOfPreviewItems(in controller: QLPreviewController) -> Int { 1 }
        func previewController(_ controller: QLPreviewController,
                               previewItemAt index: Int) -> QLPreviewItem {
            url as QLPreviewItem
        }
    }
}

func downloadModel(_ product: Product) async throws -> URL {
    guard let path = product.modelUrl else { throw CatalogError.badResponse }
    let remote = API.asset(path)
    let destination = FileManager.default.temporaryDirectory
        .appendingPathComponent("\(product.slug).usdz")

    if FileManager.default.fileExists(atPath: destination.path) { return destination }

    let (temp, _) = try await URLSession.shared.download(from: remote)
    try? FileManager.default.removeItem(at: destination)
    try FileManager.default.moveItem(at: temp, to: destination)
    return destination
}

import RealityKit

func makeTable(for option: BaseOption, texture: TextureResource?) -> ModelEntity? {
    let d = option.dimensions
    guard d.parsed, d.shape == "round",
          let diameterMm = d.diameterMm, let heightMm = d.heightMm else { return nil }

    let radius = Float(diameterMm) / 2000   // миллиметры в метры
    let height = Float(heightMm) / 1000
    let topThickness: Float = 0.03

    var material = PhysicallyBasedMaterial()
    if let texture {
        material.baseColor = .init(texture: .init(texture))
    }
    material.roughness = 0.35
    material.metallic = 0.0

    let top = ModelEntity(
        mesh: .generateCylinder(height: topThickness, radius: radius),
        materials: [material]
    )
    top.position.y = height - topThickness / 2

    let base = ModelEntity(
        mesh: .generateCylinder(height: height - topThickness, radius: radius * 0.18),
        materials: [material]
    )
    base.position.y = (height - topThickness) / 2

    let table = ModelEntity()
    table.addChild(top)
    table.addChild(base)
    return table
}

AsyncImage(url: API.asset(summary.image?.thumb ?? "")) { image in
    image.resizable().aspectRatio(contentMode: .fill)
} placeholder: {
    Color.secondary.opacity(0.1)
}