KaxhyapUI is an open-source SwiftUI toolkit that fills gaps in SwiftUI by providing components, extensions, and utilities that complement the standard library and make development faster and more enjoyable.

Early versions focus on practical UI components and helpers. Future releases will also introduce Liquid Glass inspired UI built for Apple's evolving design direction.

Features

• SwiftUI components that streamline common UI needs
• Reusable, modular view building blocks
• Practical API utilities and extensions
• Built using modern system APIs without legacy compatibility
• Distributed via Swift Package Manager

KaxhyapUI is designed for developers who embrace modern SwiftUI development.

KaxhyapUI follows a set of core principles that guide every component we build.

KaxhyapUI is built for modern Apple platforms.

KaxhyapUI is distributed using Swift Package Manager.

Adding the Package

Follow these steps to add KaxhyapUI to your Xcode project:

https://github.com/sachinkaxhyap/KaxhyapUI

Importing the Library

Once added, import KaxhyapUI in your SwiftUI files:

import KaxhyapUI

This means:

• APIs are not frozen
• Breaking changes may occur between releases
• Feedback and suggestions are welcome
• The library is actively developed

API stability will be introduced starting with version 1.0.0.

KaxhyapUI is built as a collection of independent, reusable SwiftUI components.

Each component:

Available Components

A view that displays different content based on the current async state—handling loading, success, error, and empty states in a consistent way.

AsyncStateView eliminates boilerplate code when working with asynchronous data loading patterns, providing sensible defaults while remaining fully customizable.

Platform Requirements

AsyncState Enum

The component is powered by the AsyncState enum which represents the state of an asynchronous operation:

public enum AsyncState<T> {
    case idle
    case loading
    case success(T)
    case failure(Error)
    case empty
}

Helper Properties

The AsyncState enum provides convenient computed properties:

state.isLoading  // Bool - true if loading
state.data       // T? - the success value if present
state.error      // Error? - the error if failed

Basic Usage

Create an AsyncStateView by providing a state and a content builder for the success case:

import KaxhyapUI

struct ContentView: View {
    @State private var state: AsyncState<[Item]> = .idle
    
    var body: some View {
        AsyncStateView(state: state) { items in
            List(items) { item in
                Text(item.name)
            }
        }
    }
}

Adding Retry Functionality

Provide a retry closure to enable retry buttons on the error state:

AsyncStateView(state: viewModel.state) { data in
    List(data) { item in
        Text(item.name)
    }
} retry: {
    viewModel.load()
}

Customizing Empty State

Use the .emptyState() modifier to customize the empty state appearance:

AsyncStateView(state: state) { items in
    List(items) { item in
        ItemRow(item: item)
    }
}
.emptyState(
    title: "No Items",
    systemImage: "folder",
    description: "Add your first item to get started"
)

Customizing Error State

Use the .errorState() modifier to customize the error state appearance:

AsyncStateView(state: state) { data in
    DataView(data: data)
} retry: {
    viewModel.refresh()
}
.errorState(
    title: "Connection Failed",
    systemImage: "wifi.slash"
)

Complete Example

Here's a full example showing AsyncStateView integrated with a ViewModel:

import SwiftUI
import KaxhyapUI

@Observable
class ItemsViewModel {
    var state: AsyncState<[Item]> = .idle
    
    func load() async {
        state = .loading
        do {
            let items = try await fetchItems()
            state = items.isEmpty ? .empty : .success(items)
        } catch {
            state = .failure(error)
        }
    }
}

struct ItemsView: View {
    @State private var viewModel = ItemsViewModel()
    
    var body: some View {
        NavigationStack {
            AsyncStateView(state: viewModel.state) { items in
                List(items) { item in
                    Text(item.name)
                }
            } retry: {
                Task { await viewModel.load() }
            }
            .emptyState(
                title: "No Items",
                systemImage: "folder",
                description: "Your items will appear here"
            )
            .navigationTitle("Items")
        }
        .task {
            await viewModel.load()
        }
    }
}

Default Values

AsyncStateView provides sensible defaults that you can override:

Best Practices

The WebView component provides a simple way to display web content in SwiftUI applications.

It supports two presentation styles:

• An embedded web view using the system web rendering engine
• A system Safari-based view for external web content

Common Use Cases

Basic Usage

To display a web page inside your SwiftUI view, create a WebViewK instance and provide a valid URL:

import KaxhyapUI

struct ContentView: View {
    var body: some View {
        WebViewK(url: URL(string: "https://example.com"))
    }
}

You can place WebViewK inside any SwiftUI layout such as a VStack, NavigationStack, or TabView.

Presentation Styles

WebViewK supports two presentation styles:

WebViewK(url: url, style: .embedded)

WebViewK(url: url, style: .safari)

Handling Invalid URLs

If WebViewK is created without a valid URL, it automatically shows a system "content unavailable" view. This prevents crashes and provides a clear user-facing message.

Best Practices

Limitations

WebViewK focuses on simplicity and common use cases. Advanced customization such as:

• JavaScript message handling
• Custom navigation controls
• Deep web-to-native communication

These features may be added in future versions but are intentionally out of scope for the initial beta release.

A lightweight toast notification that slides in from the bottom of the screen, with support for clear and prominent visual styles, optional action buttons, and auto-dismiss.

Toast is applied as a SwiftUI view modifier using .toast(). It automatically adapts to the platform — using glass effects on iOS 26+ and material backgrounds on earlier versions.

Platform Requirements

Preview

Clear

Clear + Action

Prominent

Prominent + Action

ToastStyle Enum

The visual appearance of the toast is controlled by the ToastStyle enum:

public enum ToastStyle {
    case clear
    case prominent(Color)
}

.toast(message: "Copied", isPresented: $show, style: .clear)

.toast(message: "Saved", isPresented: $show, style: .prominent(.blue))

Basic Usage

Apply the .toast() modifier to any view to present a toast notification from the bottom:

import KaxhyapUI

struct ContentView: View {
    @State private var showToast = false
    
    var body: some View {
        VStack {
            Button("Copy") {
                showToast = true
            }
        }
        .frame(maxHeight: .infinity)
        .toast(
            message: "Copied to clipboard",
            isPresented: $showToast,
            systemImage: "checkmark.circle"
        )
    }
}

Adding an Action Button

Provide an actionTitle and an action closure to display a tappable button inside the toast:

.toast(
    message: "Item deleted",
    isPresented: $showToast,
    systemImage: "trash",
    style: .prominent(.red),
    actionTitle: "Undo"
) {
    viewModel.undoDelete()
}

Using a Custom Asset Image

Instead of an SF Symbol, you can use a custom image asset from your asset catalog:

.toast(
    message: "Achievement unlocked!",
    isPresented: $showToast,
    image: "trophy-icon",
    style: .prominent(.orange)
)

Complete Example

Here's a full example showing multiple toast styles in a single view:

import SwiftUI
import KaxhyapUI

struct ToastDemoView: View {
    @State private var showClear = false
    @State private var showClearAction = false
    @State private var showProminent = false
    @State private var showProminentAction = false
    
    var body: some View {
        VStack(spacing: 16) {
            Button("Clear") {
                showClear = true
            }
            
            Button("Clear + Action") {
                showClearAction = true
            }
            
            Button("Prominent") {
                showProminent = true
            }
            
            Button("Prominent + Action") {
                showProminentAction = true
            }
        }
        .toast(
            message: "Copied to clipboard",
            isPresented: $showClear,
            systemImage: "checkmark.circle",
            style: .clear
        )
        .toast(
            message: "Copied to clipboard",
            isPresented: $showClearAction,
            systemImage: "checkmark.circle",
            style: .clear,
            actionTitle: "Undo"
        ) {
            showClearAction = false
        }
        .toast(
            message: "Saved successfully",
            isPresented: $showProminent,
            systemImage: "checkmark.circle",
            style: .prominent(.blue)
        )
        .toast(
            message: "Saved successfully",
            isPresented: $showProminentAction,
            systemImage: "arrow.uturn.backward",
            style: .prominent(.blue),
            actionTitle: "Undo"
        ) {
            showProminentAction = false
        }
    }
}

Parameters

Platform Adaptation

Toast automatically adapts its rendering based on the OS version:

Best Practices

Compress images to fit within a specified maximum file size using an intelligent binary search algorithm.

The Image Compressor extension provides a simple API to compress UIImage (iOS) and NSImage (macOS) instances to a target file size in kilobytes. It automatically handles quality adjustment and progressive resizing when needed.

Platform Requirements

Common Use Cases

Basic Usage

Compress an image to fit within a maximum file size:

import KaxhyapUI

let originalImage: UIImage = // ... from camera, picker, etc.

// Compress to maximum 500 KB
if let compressedData = originalImage.compressedTo(maxSizeKB: 500) {
    // Upload compressedData to server or save locally
}

import KaxhyapUI

let originalImage: NSImage = // ... from file, pasteboard, etc.

// Compress to maximum 500 KB
if let compressedData = originalImage.compressedTo(maxSizeKB: 500) {
    // Upload compressedData to server or save locally
}

Async Usage

For large images, use the async version to avoid blocking the main thread:

// Compress asynchronously
let compressedData = await originalImage.compressedTo(maxSizeKB: 500)

// Or use in a Task
Task {
    if let data = await image.compressedTo(maxSizeKB: 200) {
        await uploadImage(data)
    }
}

How It Works

The compressor uses a multi-step approach to achieve the target file size:

Complete Example

Here's a full example showing image compression in a photo upload flow:

import SwiftUI
import PhotosUI
import KaxhyapUI

struct PhotoUploadView: View {
    @State private var selectedItem: PhotosPickerItem?
    @State private var isCompressing = false
    @State private var uploadStatus: String?
    
    var body: some View {
        VStack(spacing: 20) {
            PhotosPicker(selection: $selectedItem, matching: .images) {
                Label("Select Photo", systemImage: "photo")
            }
            
            if isCompressing {
                ProgressView("Compressing...")
            }
            
            if let status = uploadStatus {
                Text(status)
                    .foregroundStyle(.secondary)
            }
        }
        .onChange(of: selectedItem) { _, newItem in
            Task {
                await processImage(newItem)
            }
        }
    }
    
    private func processImage(_ item: PhotosPickerItem?) async {
        guard let item,
              let data = try? await item.loadTransferable(type: Data.self),
              let image = UIImage(data: data) else {
            return
        }
        
        isCompressing = true
        
        // Compress to max 500 KB for upload
        if let compressedData = await image.compressedTo(maxSizeKB: 500) {
            let originalKB = data.count / 1024
            let compressedKB = compressedData.count / 1024
            uploadStatus = "Compressed: \(originalKB) KB → \(compressedKB) KB"
            
            // Upload compressedData...
        } else {
            uploadStatus = "Compression failed"
        }
        
        isCompressing = false
    }
}

Parameters

Return Value

Returns Data? containing the compressed JPEG image data, or nil if:

• The maxSizeKB parameter is 0 or negative
• The image cannot be converted to JPEG format
• Compression fails for any other reason

Best Practices

Planned future work for KaxhyapUI includes:

Stability and API guarantees will come with v1.0.0. The roadmap may evolve based on platform changes and community feedback.

We welcome discussions, issues, and contributions.

When contributing, please follow these guidelines:

Discussion, feedback, and suggestions are encouraged.

If you find KaxhyapUI useful, here's how you can help:

Community input helps shape the future of the library.