construct macOS apps utilizing solely the Swift Bundle Supervisor?

Swift scripts and macOS apps

Swift compiler 101, you’ll be able to create, construct and run a Swift file utilizing the swiftc command. Contemplate the most straightforward Swift program that we are able to all think about in a principal.swift file:

print("Hiya world!")

In Swift if we need to print one thing, we do not even need to import the Basis framework, we are able to merely compile and run this piece of code by working the next:

swiftc principal.swift 	# compile principal.swift
chmod +x principal 		# add the executable permission
./principal 			# run the binary

The excellent news that we are able to take this one step additional by auto-invoking the Swift compiler underneath the hood with a shebang.

#! /usr/bin/swift

print("Hiya world!")

Now should you merely run the ./principal.swift file it will print out the well-known “Hiya world!” textual content. 👋

Due to the program-loader mechanism and naturally the Swift interpreter we are able to skip an additional step and run our single-source Swift code as simple as an everyday shell script. The excellent news is that we are able to import all type of system frameworks which are a part of the Swift toolchain. With the assistance of Basis we are able to construct fairly helpful or fully ineffective command line utilities.

#!/usr/bin/env swift

import Basis
import Dispatch

guard CommandLine.arguments.rely == 2 else {
    fatalError("Invalid arguments")
}
let urlString =  CommandLine.arguments[1]
guard let url = URL(string: urlString) else {
    fatalError("Invalid URL")   
}

struct Todo: Codable {
    let title: String
    let accomplished: Bool
}

let process = URLSession.shared.dataTask(with: url) { information, response, error in 
    if let error = error {
        fatalError("Error: (error.localizedDescription)")
    }
    guard let response = response as? HTTPURLResponse, response.statusCode == 200 else {
        fatalError("Error: invalid HTTP response code")
    }
    guard let information = information else {
        fatalError("Error: lacking response information")
    }

    do {
        let decoder = JSONDecoder()
        let todos = strive decoder.decode([Todo].self, from: information)
        print("Record of todos:")
        print(todos.map { " - [" + ($0.completed ? "✅" : "❌") + "] ($0.title)" }.joined(separator: "n"))
        exit(0)
    }
    catch {
        fatalError("Error: (error.localizedDescription)")
    }
}
process.resume()
dispatchMain()

If you happen to name this instance with a URL that may return an inventory of todos it will print a pleasant listing of the gadgets.

./principal.swift https://jsonplaceholder.typicode.com/todos

Sure, you’ll be able to say that this script is totally ineffective, however for my part it is an incredible demo app, because it covers the best way to test command line arguments (CommandLine.arguments), it additionally reveals you the best way to wait (dispatchMain) for an async process, similar to a HTTP name by the community utilizing the URLSession API to complete and exit utilizing the appropriate technique when one thing fails (fatalError) or should you attain the top of execution (exit(0)). Just some strains of code, nevertheless it comprises a lot information.

Have you ever observed the brand new shebang? When you have a number of Swift variations put in in your system, you should utilize the env shebang to go along with the primary one which’s out there in your PATH.

It is not simply Basis, however you’ll be able to import AppKit and even SwiftUI. Nicely, not underneath Linux in fact, since these frameworks are solely out there for macOS plus you’ll need Xcode put in in your system, since some stuff in Swift the toolchain continues to be tied to the IDE, however why? 😢

Anyway, again to the subject, here is the boilerplate code for a macOS utility Swift script that may be began from the Terminal with one easy ./principal.swift command and nothing extra.

#!/usr/bin/env swift

import AppKit
import SwiftUI

@out there(macOS 10.15, *)
struct HelloView: View {
    var physique: some View {
        Textual content("Hiya world!")
    }
}

@out there(macOS 10.15, *)
class WindowDelegate: NSObject, NSWindowDelegate {

    func windowWillClose(_ notification: Notification) {
        NSApplication.shared.terminate(0)
    }
}


@out there(macOS 10.15, *)
class AppDelegate: NSObject, NSApplicationDelegate {
    let window = NSWindow()
    let windowDelegate = WindowDelegate()

    func applicationDidFinishLaunching(_ notification: Notification) {
        let appMenu = NSMenuItem()
        appMenu.submenu = NSMenu()
        appMenu.submenu?.addItem(NSMenuItem(title: "Stop", motion: #selector(NSApplication.terminate(_:)), keyEquivalent: "q"))
        let mainMenu = NSMenu(title: "My Swift Script")
        mainMenu.addItem(appMenu)
        NSApplication.shared.mainMenu = mainMenu
        
        let dimension = CGSize(width: 480, peak: 270)
        window.setContentSize(dimension)
        window.styleMask = [.closable, .miniaturizable, .resizable, .titled]
        window.delegate = windowDelegate
        window.title = "My Swift Script"

        let view = NSHostingView(rootView: HelloView())
        view.body = CGRect(origin: .zero, dimension: dimension)
        view.autoresizingMask = [.height, .width]
        window.contentView!.addSubview(view)
        window.middle()
        window.makeKeyAndOrderFront(window)
        
        NSApp.setActivationPolicy(.common)
        NSApp.activate(ignoringOtherApps: true)
    }
}

let app = NSApplication.shared
let delegate = AppDelegate()
app.delegate = delegate
app.run()

Particular thanks goes to karwa for the authentic gist. Additionally if you’re into Storyboard-less macOS app improvement, it is best to positively check out this text by @kicsipixel. These assets helped me so much to place collectively what I wanted. I nonetheless needed to lengthen the gist with a correct menu setup and the activation coverage, however now this model acts like a real-world macOS utility that works like a appeal. There is just one concern right here… the script file is getting crowded. 🙈

Swift Bundle Supervisor and macOS apps

So, if we observe the identical logic, which means we are able to construct an executable bundle that may invoke AppKit associated stuff utilizing the Swift Bundle Supervisor. Straightforward as a pie. 🥧

mkdir MyApp
cd MyApp 
swift bundle init --type=executable

Now we are able to separate the parts into standalone information, we are able to additionally take away the provision checking, since we will add a platform constraint utilizing our Bundle.swift manifest file. If you do not know a lot about how the Swift Bundle Supervisor works, please learn my SPM tutorial, or if you’re merely curious in regards to the construction of a Bundle.swift file, you’ll be able to learn my article in regards to the Swift Bundle manifest file. Let’s begin with the manifest updates.

import PackageDescription

let bundle = Bundle(
    title: "MyApp",
    platforms: [
        .macOS(.v10_15)
    ],
    dependencies: [
        
    ],
    targets: [
        .target(name: "MyApp", dependencies: []),
        .testTarget(title: "MyAppTests", dependencies: ["MyApp"]),
    ]
)

Now we are able to place the HelloView struct into a brand new HelloView.swift file.

import SwiftUI

struct HelloView: View {
    var physique: some View {
        Textual content("Hiya world!")
    }
}

The window delegate can have its personal place inside a WindowDelegate.swift file.

import AppKit

class WindowDelegate: NSObject, NSWindowDelegate {

    func windowWillClose(_ notification: Notification) {
        NSApplication.shared.terminate(0)
    }
}

We will apply the identical factor to the AppDelegate class.

import AppKit
import SwiftUI

class AppDelegate: NSObject, NSApplicationDelegate {
    let window = NSWindow()
    let windowDelegate = WindowDelegate()

    func applicationDidFinishLaunching(_ notification: Notification) {
        let appMenu = NSMenuItem()
        appMenu.submenu = NSMenu()
        appMenu.submenu?.addItem(NSMenuItem(title: "Stop", motion: #selector(NSApplication.terminate(_:)), keyEquivalent: "q"))
        let mainMenu = NSMenu(title: "My Swift Script")
        mainMenu.addItem(appMenu)
        NSApplication.shared.mainMenu = mainMenu
        
        let dimension = CGSize(width: 480, peak: 270)
        window.setContentSize(dimension)
        window.styleMask = [.closable, .miniaturizable, .resizable, .titled]
        window.delegate = windowDelegate
        window.title = "My Swift Script"

        let view = NSHostingView(rootView: HelloView())
        view.body = CGRect(origin: .zero, dimension: dimension)
        view.autoresizingMask = [.height, .width]
        window.contentView!.addSubview(view)
        window.middle()
        window.makeKeyAndOrderFront(window)
        
        NSApp.setActivationPolicy(.common)
        NSApp.activate(ignoringOtherApps: true)
    }
}

Lastly we are able to replace the primary.swift file and provoke every little thing that must be performed.

import AppKit

let app = NSApplication.shared
let delegate = AppDelegate()
app.delegate = delegate
app.run()

The excellent news is that this strategy works, so you’ll be able to develop, construct and run apps domestically, however sadly you’ll be able to’t submit them to the Mac App Retailer, because the remaining utility bundle will not appear like an actual macOS bundle. The binary just isn’t code signed, plus you may want an actual macOS goal in Xcode to submit the appliance. Then why trouble with this strategy?

Nicely, simply because it’s enjoyable and I may even keep away from utilizing Xcode with the assistance of SourceKit-LSP and a few Editor configuration. The most effective half is that SourceKit-LSP is now a part of Xcode, so you do not have to put in something particular, simply configure your favourite IDE and begin coding.

You can even bundle assets, since this characteristic is offered from Swift 5.3, and use them by the Bundle.module variable if wanted. I already tried this, works fairly properly, and it’s so a lot enjoyable to develop apps for the mac with out the additional overhead that Xcode comes with. 🥳