@hearthlog/native 0.0.0-stage → 0.1.1

package/swift/iOS/SignInViewController.swift

@@ -0,0 +1,62 @@
+import UIKit
+import WebKit
+
+/// The Cloudflare Access login, in a sheet. It shares the app's data store, so the session cookie
+/// Access sets is the one the app's web view sends. The sheet closes itself as soon as Access sends
+/// the person back to the app.
+@MainActor
+final class SignInViewController: UIViewController, WKNavigationDelegate {
+    private let policy: NavigationPolicy
+    private let webView: WKWebView
+    private let url: URL
+    private let onFinished: (Bool) -> Void
+    private var finished = false
+
+    init(site: SiteConfig, policy: NavigationPolicy, dataStore: WKWebsiteDataStore, url: URL, onFinished: @escaping (Bool) -> Void) {
+        self.policy = policy
+        self.url = url
+        self.onFinished = onFinished
+        let configuration = WKWebViewConfiguration()
+        configuration.websiteDataStore = dataStore
+        webView = WKWebView(frame: .zero, configuration: configuration)
+        super.init(nibName: nil, bundle: nil)
+        title = "Sign in to \(site.title)"
+        navigationItem.leftBarButtonItem = UIBarButtonItem(systemItem: .cancel, primaryAction: UIAction { [weak self] _ in
+            self?.dismiss(animated: true)
+        })
+    }
+
+    required init?(coder: NSCoder) { fatalError("init(coder:) is not used") }
+
+    override func viewDidLoad() {
+        super.viewDidLoad()
+        view.backgroundColor = .systemBackground
+        webView.frame = view.bounds
+        webView.autoresizingMask = [.flexibleWidth, .flexibleHeight]
+        webView.navigationDelegate = self
+        view.addSubview(webView)
+        webView.load(URLRequest(url: url))
+    }
+
+    func webView(_ webView: WKWebView, decidePolicyFor navigationAction: WKNavigationAction) async -> WKNavigationActionPolicy {
+        let url = navigationAction.request.url
+        if policy.finishesSignIn(url) {
+            finish(success: true)
+            return .cancel
+        }
+        return policy.allowsSignIn(url) ? .allow : .cancel
+    }
+
+    /// Swiping the sheet away or tapping Cancel ends the sign-in without a session.
+    override func viewDidDisappear(_ animated: Bool) {
+        super.viewDidDisappear(animated)
+        if isMovingFromParent || navigationController?.isBeingDismissed == true { finish(success: false) }
+    }
+
+    private func finish(success: Bool) {
+        guard !finished else { return }
+        finished = true
+        onFinished(success)
+        if success { navigationController?.dismiss(animated: true) }
+    }
+}

package/swift/iOS/WebViewController.swift

@@ -0,0 +1,196 @@
+import UIKit
+import UserNotifications
+import WebKit
+
+/// The whole app on iOS: the site, edge to edge. The page draws its own header and dock (as glass),
+/// so this only supplies what the page can't: sheets, share, haptics, reminders and the app badge.
+@MainActor
+final class WebViewController: UIViewController, StorWebHostDelegate {
+    let host: StorWebHost
+    private let flush = BackgroundFlush()
+    private var signIn: SignInViewController?
+
+    init(site: SiteConfig) {
+        #if DEBUG
+        let inspectable = true
+        #else
+        let inspectable = false
+        #endif
+        host = StorWebHost(site: site, kind: .ios, inspectable: inspectable)
+        super.init(nibName: nil, bundle: nil)
+        host.delegate = self
+    }
+
+    required init?(coder: NSCoder) { fatalError("init(coder:) is not used") }
+
+    override func viewDidLoad() {
+        super.viewDidLoad()
+        view.backgroundColor = .systemBackground
+        host.webView.frame = view.bounds
+        host.webView.autoresizingMask = [.flexibleWidth, .flexibleHeight]
+        view.addSubview(host.webView)
+    }
+
+    /// The phone layout and its dock are portrait; an iPad turns freely.
+    override var supportedInterfaceOrientations: UIInterfaceOrientationMask {
+        UIDevice.current.userInterfaceIdiom == .phone ? .portrait : .all
+    }
+
+    // MARK: Lifecycle
+
+    func didEnterBackground() {
+        flush.begin()
+    }
+
+    func willEnterForeground() {
+        flush.end()
+        host.dispatch(["type": "resume"])
+    }
+
+    // MARK: Messages
+
+    func host(_ host: StorWebHost, received message: ShellMessage) {
+        switch message {
+        case .appearance(let preference, _, let background):
+            overrideUserInterfaceStyle = preference == .dark ? .dark : preference == .light ? .light : .unspecified
+            if let color = UIColor(hex: background) {
+                view.backgroundColor = color
+                host.webView.underPageBackgroundColor = color
+            }
+        case .badge(let count):
+            setBadge(count)
+        case .reminders(let reminders):
+            Task { await ReminderScheduler.shared.apply(reminders) }
+        case .outbox(let pending):
+            flush.pending = pending
+        case .haptic(let success):
+            UINotificationFeedbackGenerator().notificationOccurred(success ? .success : .warning)
+        case .menu, .lights, .drag, .backgroundHover:
+            break
+        }
+    }
+
+    private func setBadge(_ count: Int) {
+        Task {
+            // Showing a number needs the notification permission; clearing one does not.
+            if count > 0, !(await ReminderScheduler.shared.authorize()) { return }
+            try? await UNUserNotificationCenter.current().setBadgeCount(count)
+        }
+    }
+
+    // MARK: StorWebHostDelegate
+
+    func host(_ host: StorWebHost, openWindowFor configuration: WKWebViewConfiguration, url: URL) -> WKWebView? {
+        let webView = WKWebView(frame: .zero, configuration: configuration)
+        webView.navigationDelegate = host
+        webView.uiDelegate = host
+        webView.isInspectable = host.webView.isInspectable
+        let popup = PopupViewController(webView: webView, title: host.site.title)
+        presenter.present(UINavigationController(rootViewController: popup), animated: true)
+        return webView
+    }
+
+    func host(_ host: StorWebHost, showSignIn url: URL) {
+        guard signIn == nil else { return }
+        let controller = SignInViewController(site: host.site, policy: host.policy, dataStore: host.dataStore, url: url) { [weak self] success in
+            guard let self else { return }
+            self.signIn = nil
+            if success { self.host.reloadAfterSignIn() }
+        }
+        signIn = controller
+        presenter.present(UINavigationController(rootViewController: controller), animated: true)
+    }
+
+    func host(_ host: StorWebHost, openExternally url: URL) {
+        UIApplication.shared.open(url)
+    }
+
+    /// Downloads land in a temporary folder and leave through the share sheet, which offers Save to Files.
+    func host(_ host: StorWebHost, chooseDestinationFor suggestedFilename: String) async -> URL? {
+        let directory = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString, isDirectory: true)
+        guard (try? FileManager.default.createDirectory(at: directory, withIntermediateDirectories: true)) != nil else { return nil }
+        let name = (suggestedFilename as NSString).lastPathComponent
+        return directory.appendingPathComponent(name.isEmpty ? "download" : name)
+    }
+
+    func host(_ host: StorWebHost, savedDownload url: URL) {
+        let sheet = UIActivityViewController(activityItems: [url], applicationActivities: nil)
+        if let popover = sheet.popoverPresentationController {
+            popover.sourceView = view
+            popover.sourceRect = CGRect(x: view.bounds.midX, y: view.bounds.midY, width: 0, height: 0)
+            popover.permittedArrowDirections = []
+        }
+        presenter.present(sheet, animated: true)
+    }
+
+    func host(_ host: StorWebHost, present dialog: JSDialog) async -> JSDialogResult {
+        await withCheckedContinuation { continuation in
+            let alert: UIAlertController
+            switch dialog {
+            case .alert(let message):
+                alert = UIAlertController(title: host.site.title, message: message, preferredStyle: .alert)
+                alert.addAction(UIAlertAction(title: "OK", style: .default) { _ in continuation.resume(returning: .ok(nil)) })
+            case .confirm(let message):
+                alert = UIAlertController(title: host.site.title, message: message, preferredStyle: .alert)
+                alert.addAction(UIAlertAction(title: "Cancel", style: .cancel) { _ in continuation.resume(returning: .cancel) })
+                alert.addAction(UIAlertAction(title: "OK", style: .default) { _ in continuation.resume(returning: .ok(nil)) })
+            case .prompt(let message, let defaultText):
+                alert = UIAlertController(title: host.site.title, message: message, preferredStyle: .alert)
+                alert.addTextField { $0.text = defaultText }
+                alert.addAction(UIAlertAction(title: "Cancel", style: .cancel) { _ in continuation.resume(returning: .cancel) })
+                alert.addAction(UIAlertAction(title: "OK", style: .default) { [weak alert] _ in
+                    continuation.resume(returning: .ok(alert?.textFields?.first?.text))
+                })
+            }
+            presenter.present(alert, animated: true)
+        }
+    }
+
+    /// Whatever is on top, so a sheet can open over another sheet.
+    private var presenter: UIViewController {
+        var top: UIViewController = self
+        while let next = top.presentedViewController { top = next }
+        return top
+    }
+}
+
+/// A window the page opened itself, such as a PDF in its own viewer.
+@MainActor
+final class PopupViewController: UIViewController {
+    private let webView: WKWebView
+
+    init(webView: WKWebView, title: String) {
+        self.webView = webView
+        super.init(nibName: nil, bundle: nil)
+        self.title = title
+        navigationItem.rightBarButtonItem = UIBarButtonItem(systemItem: .done, primaryAction: UIAction { [weak self] _ in
+            self?.dismiss(animated: true)
+        })
+    }
+
+    required init?(coder: NSCoder) { fatalError("init(coder:) is not used") }
+
+    override func viewDidLoad() {
+        super.viewDidLoad()
+        view.backgroundColor = .systemBackground
+        webView.frame = view.bounds
+        webView.autoresizingMask = [.flexibleWidth, .flexibleHeight]
+        view.addSubview(webView)
+    }
+}
+
+private extension UIColor {
+    /// `#rgb` or `#rrggbb`, as the page's theme tokens are written.
+    convenience init?(hex: String?) {
+        guard var text = hex?.trimmingCharacters(in: .whitespaces), text.hasPrefix("#") else { return nil }
+        text.removeFirst()
+        if text.count == 3 { text = text.map { "\($0)\($0)" }.joined() }
+        guard text.count == 6, let value = Int(text, radix: 16) else { return nil }
+        self.init(
+            red: CGFloat((value >> 16) & 0xFF) / 255,
+            green: CGFloat((value >> 8) & 0xFF) / 255,
+            blue: CGFloat(value & 0xFF) / 255,
+            alpha: 1
+        )
+    }
+}

package/swift/macOS/AppDelegate.swift

@@ -0,0 +1,190 @@
+import AppKit
+import UserNotifications
+import WebKit
+
+@MainActor
+final class AppDelegate: NSObject, NSApplicationDelegate, UNUserNotificationCenterDelegate, NSMenuItemValidation {
+    let site = SiteConfig.load()
+
+    private lazy var menu = AppMenu(appName: site.title)
+    private var controllers: [MainWindowController] = []
+    private var popups: [PopupWindowController] = []
+    #if STOR_DEV
+    private var popupTitles: [NSKeyValueObservation] = []
+    #endif
+
+    private var inspectable: Bool {
+        #if STOR_DEV
+        true
+        #else
+        Bundle.main.object(forInfoDictionaryKey: "StorInspectable") as? Bool ?? false
+        #endif
+    }
+
+    // MARK: Lifecycle
+
+    func applicationDidFinishLaunching(_ notification: Notification) {
+        UNUserNotificationCenter.current().delegate = self
+        menu.install()
+        openWindow(path: "/")
+        NSApp.activate()
+    }
+
+    /// The date may have moved on while the app was in the background, so the page plans its reminders again.
+    func applicationDidBecomeActive(_ notification: Notification) {
+        controllers.forEach { $0.host.dispatch(["type": "resume"]) }
+    }
+
+    func applicationShouldHandleReopen(_ sender: NSApplication, hasVisibleWindows flag: Bool) -> Bool {
+        if !flag { openWindow(path: "/") }
+        return true
+    }
+
+    /// Right-clicking the Dock icon lists the pages the page reported, with a section's sub-pages.
+    func applicationDockMenu(_ sender: NSApplication) -> NSMenu? {
+        menu.dockMenu()
+    }
+
+    /// Closing the last window keeps the app, so sync and reminders carry on.
+    func applicationShouldTerminateAfterLastWindowClosed(_ sender: NSApplication) -> Bool { false }
+
+    func applicationShouldTerminate(_ sender: NSApplication) -> NSApplication.TerminateReply {
+        let pending = controllers.map(\.pendingUploads).max() ?? 0
+        guard pending > 0 else { return .terminateNow }
+        let alert = NSAlert()
+        alert.messageText = "Quit \(site.title)?"
+        alert.informativeText = "\(pending) \(pending == 1 ? "change hasn't" : "changes haven't") been sent yet. \(pending == 1 ? "It is" : "They are") saved on this Mac and will upload the next time the app opens."
+        alert.addButton(withTitle: "Quit")
+        alert.addButton(withTitle: "Cancel")
+        return alert.runModal() == .alertFirstButtonReturn ? .terminateNow : .terminateCancel
+    }
+
+    // MARK: Windows
+
+    @discardableResult
+    func openWindow(path: String) -> MainWindowController {
+        let isFirst = controllers.isEmpty
+        let controller = MainWindowController(site: site, app: self, inspectable: inspectable, restoresFrame: isFirst)
+        // Another window opens just down and right of the one in front, so it never hides it exactly.
+        if let window = controller.window, let front = activeController?.window {
+            window.setFrameTopLeftPoint(NSPoint(x: front.frame.minX + 28, y: front.frame.maxY - 28))
+        }
+        controllers.append(controller)
+        controller.host.load(path: path)
+        controller.showWindow(nil)
+        #if STOR_DEV
+        DevTools.schedule(for: controller)
+        #endif
+        return controller
+    }
+
+    func windowClosed(_ controller: MainWindowController) {
+        controllers.removeAll { $0 === controller }
+    }
+
+    func openPopup(configuration: WKWebViewConfiguration, host: StorWebHost) -> WKWebView {
+        let webView = WKWebView(frame: .zero, configuration: configuration)
+        webView.navigationDelegate = host
+        webView.uiDelegate = host
+        webView.isInspectable = inspectable
+        let popup = PopupWindowController(webView: webView, title: site.title) { [weak self] closed in
+            self?.popups.removeAll { $0 === closed }
+        }
+        popups.append(popup)
+        popup.showWindow(nil)
+        #if STOR_DEV
+        DevTools.log("popup opened")
+        popupTitles.append(webView.observe(\.title) { webView, _ in DevTools.log("popup title \(webView.title ?? "")") })
+        #endif
+        return webView
+    }
+
+    private var activeController: MainWindowController? {
+        controllers.first { $0.window === NSApp.keyWindow } ?? controllers.first { $0.window?.isVisible == true }
+    }
+
+    var menuSummary: String { menu.summary }
+
+    // MARK: Messages from the page that concern the whole app
+
+    func handle(_ message: ShellMessage) {
+        #if STOR_DEV
+        DevTools.log("message \(message)")
+        #endif
+        switch message {
+        case .appearance(let preference, _, _):
+            NSApp.appearance = preference == .system ? nil : NSAppearance(named: preference == .dark ? .darkAqua : .aqua)
+        case .badge(let count):
+            NSApp.dockTile.badgeLabel = count > 0 ? String(count) : nil
+        case .reminders(let reminders):
+            #if STOR_DEV
+            if DevTools.environment["STOR_DEV_NO_NOTIFICATIONS"] == "1" {
+                DevTools.log("reminders planned \(ReminderScheduler.plan(reminders, now: Date()).map(\.id))")
+                break
+            }
+            #endif
+            Task { await ReminderScheduler.shared.apply(reminders) }
+        case .menu(let destinations, let actions):
+            menu.update(destinations: destinations, actions: actions)
+        case .lights, .outbox, .haptic, .drag, .backgroundHover:
+            break
+        }
+    }
+
+    // MARK: Menu actions
+
+    @objc func newWindow(_ sender: Any?) {
+        openWindow(path: "/")
+    }
+
+    @objc func openPath(_ sender: NSMenuItem) {
+        guard let path = sender.representedObject as? String else { return }
+        open(path: path)
+    }
+
+    @objc func toggleSidebar(_ sender: Any?) {
+        activeController?.host.dispatch(["type": "toggle-sidebar"])
+    }
+
+    @objc func reload(_ sender: Any?) {
+        activeController?.host.webView.reload()
+    }
+
+    @objc func goBack(_ sender: Any?) {
+        activeController?.host.webView.goBack()
+    }
+
+    @objc func goForward(_ sender: Any?) {
+        activeController?.host.webView.goForward()
+    }
+
+    func validateMenuItem(_ item: NSMenuItem) -> Bool {
+        switch item.action {
+        case #selector(goBack(_:)): return activeController?.host.webView.canGoBack ?? false
+        case #selector(goForward(_:)): return activeController?.host.webView.canGoForward ?? false
+        case #selector(toggleSidebar(_:)), #selector(reload(_:)): return activeController != nil
+        default: return true
+        }
+    }
+
+    private func open(path: String) {
+        if let controller = activeController {
+            controller.host.navigate(to: path)
+            controller.window?.makeKeyAndOrderFront(nil)
+        } else {
+            openWindow(path: path)
+        }
+        NSApp.activate()
+    }
+
+    // MARK: Notifications
+
+    nonisolated func userNotificationCenter(_ center: UNUserNotificationCenter, willPresent notification: UNNotification) async -> UNNotificationPresentationOptions {
+        [.banner, .list, .sound]
+    }
+
+    nonisolated func userNotificationCenter(_ center: UNUserNotificationCenter, didReceive response: UNNotificationResponse) async {
+        guard let path = response.notification.request.content.userInfo["path"] as? String else { return }
+        await MainActor.run { open(path: path) }
+    }
+}

package/swift/macOS/AppMenu.swift

@@ -0,0 +1,159 @@
+import AppKit
+
+/// The Mac menu bar. The standard items are fixed; File's create shortcuts and Go's sections come from
+/// the page, which knows which features this site has, and each one opens a route that already exists.
+@MainActor
+final class AppMenu {
+    private let appName: String
+    private let fileMenu = NSMenu(title: "File")
+    private let goMenu = NSMenu(title: "Go")
+    private var destinations: [MenuEntry] = []
+    private var actions: [MenuEntry] = []
+
+    init(appName: String) {
+        self.appName = appName
+    }
+
+    func install() {
+        let main = NSMenu()
+        main.addItem(submenuItem(appMenu()))
+        main.addItem(submenuItem(fileMenu))
+        main.addItem(submenuItem(editMenu()))
+        main.addItem(submenuItem(viewMenu()))
+        main.addItem(submenuItem(goMenu))
+        let window = windowMenu()
+        main.addItem(submenuItem(window))
+        NSApp.mainMenu = main
+        NSApp.windowsMenu = window
+        rebuildDynamicMenus()
+    }
+
+    /// File, Go and the Dock menu as they stand, for the debugging aids.
+    var summary: String {
+        "File=\(fileMenu.items.map(\.title)) Go=\(goMenu.items.map(\.title)) Dock=\(dockSummary)"
+    }
+
+    /// The Dock icon's menu: every available section, its sub-pages as submenus, then a new window.
+    func dockMenu() -> NSMenu {
+        let menu = NSMenu(title: appName)
+        for destination in destinations {
+            menu.addItem(destinationItem(destination))
+        }
+        if !destinations.isEmpty { menu.addItem(.separator()) }
+        menu.addItem(item("New Window", #selector(AppDelegate.newWindow(_:)), "", []))
+        return menu
+    }
+
+    private func destinationItem(_ destination: MenuEntry) -> NSMenuItem {
+        guard !destination.children.isEmpty else {
+            // A Dock menu has no key equivalents, so sections open on a plain click.
+            return pathItem(destination.title, destination.path, "", [])
+        }
+        let item = NSMenuItem(title: destination.title, action: nil, keyEquivalent: "")
+        let submenu = NSMenu(title: destination.title)
+        for child in destination.children {
+            submenu.addItem(pathItem(child.title, child.path, "", []))
+        }
+        item.submenu = submenu
+        return item
+    }
+
+    private var dockSummary: String {
+        dockMenu().items.filter { !$0.isSeparatorItem }.map { item in
+            guard let submenu = item.submenu else { return item.title }
+            return "\(item.title)[\(submenu.items.map(\.title).joined(separator: ","))]"
+        }.joined(separator: " ")
+    }
+
+    func update(destinations: [MenuEntry], actions: [MenuEntry]) {
+        guard destinations != self.destinations || actions != self.actions else { return }
+        self.destinations = destinations
+        self.actions = actions
+        rebuildDynamicMenus()
+    }
+
+    // MARK: Menus
+
+    private func appMenu() -> NSMenu {
+        let menu = NSMenu(title: appName)
+        menu.addItem(item("About \(appName)", #selector(NSApplication.orderFrontStandardAboutPanel(_:))))
+        menu.addItem(.separator())
+        menu.addItem(item("Hide \(appName)", #selector(NSApplication.hide(_:)), "h"))
+        menu.addItem(item("Hide Others", #selector(NSApplication.hideOtherApplications(_:)), "h", [.command, .option]))
+        menu.addItem(item("Show All", #selector(NSApplication.unhideAllApplications(_:))))
+        menu.addItem(.separator())
+        menu.addItem(item("Quit \(appName)", #selector(NSApplication.terminate(_:)), "q"))
+        return menu
+    }
+
+    private func editMenu() -> NSMenu {
+        let menu = NSMenu(title: "Edit")
+        menu.addItem(item("Undo", Selector(("undo:")), "z"))
+        menu.addItem(item("Redo", Selector(("redo:")), "z", [.command, .shift]))
+        menu.addItem(.separator())
+        menu.addItem(item("Cut", #selector(NSText.cut(_:)), "x"))
+        menu.addItem(item("Copy", #selector(NSText.copy(_:)), "c"))
+        menu.addItem(item("Paste", #selector(NSText.paste(_:)), "v"))
+        menu.addItem(item("Select All", #selector(NSText.selectAll(_:)), "a"))
+        return menu
+    }
+
+    private func viewMenu() -> NSMenu {
+        let menu = NSMenu(title: "View")
+        menu.addItem(item("Toggle Sidebar", #selector(AppDelegate.toggleSidebar(_:)), "s", [.command, .control]))
+        menu.addItem(item("Reload", #selector(AppDelegate.reload(_:)), "r"))
+        menu.addItem(.separator())
+        menu.addItem(item("Enter Full Screen", #selector(NSWindow.toggleFullScreen(_:)), "f", [.command, .control]))
+        return menu
+    }
+
+    private func windowMenu() -> NSMenu {
+        let menu = NSMenu(title: "Window")
+        menu.addItem(item("Minimize", #selector(NSWindow.performMiniaturize(_:)), "m"))
+        menu.addItem(item("Zoom", #selector(NSWindow.performZoom(_:))))
+        menu.addItem(.separator())
+        menu.addItem(item("Bring All to Front", #selector(NSApplication.arrangeInFront(_:))))
+        return menu
+    }
+
+    private func rebuildDynamicMenus() {
+        fileMenu.removeAllItems()
+        for (index, action) in actions.enumerated() {
+            // The first two get the conventional New shortcuts.
+            let (key, modifiers): (String, NSEvent.ModifierFlags) = index == 0 ? ("n", [.command]) : index == 1 ? ("n", [.command, .shift]) : ("", [])
+            fileMenu.addItem(pathItem(action.title.capitalized, action.path, key, modifiers))
+        }
+        if !actions.isEmpty { fileMenu.addItem(.separator()) }
+        fileMenu.addItem(item("New Window", #selector(AppDelegate.newWindow(_:)), "n", [.command, .option]))
+        fileMenu.addItem(.separator())
+        fileMenu.addItem(item("Close Window", #selector(NSWindow.performClose(_:)), "w"))
+
+        goMenu.removeAllItems()
+        goMenu.addItem(item("Back", #selector(AppDelegate.goBack(_:)), "["))
+        goMenu.addItem(item("Forward", #selector(AppDelegate.goForward(_:)), "]"))
+        if !destinations.isEmpty { goMenu.addItem(.separator()) }
+        for (index, destination) in destinations.enumerated() {
+            goMenu.addItem(pathItem(destination.title, destination.path, index < 9 ? String(index + 1) : "", [.command]))
+        }
+    }
+
+    // MARK: Items
+
+    private func submenuItem(_ menu: NSMenu) -> NSMenuItem {
+        let item = NSMenuItem(title: menu.title, action: nil, keyEquivalent: "")
+        item.submenu = menu
+        return item
+    }
+
+    private func item(_ title: String, _ action: Selector, _ key: String = "", _ modifiers: NSEvent.ModifierFlags = [.command]) -> NSMenuItem {
+        let item = NSMenuItem(title: title, action: action, keyEquivalent: key)
+        item.keyEquivalentModifierMask = modifiers
+        return item
+    }
+
+    private func pathItem(_ title: String, _ path: String, _ key: String, _ modifiers: NSEvent.ModifierFlags) -> NSMenuItem {
+        let item = item(title, #selector(AppDelegate.openPath(_:)), key, modifiers)
+        item.representedObject = path
+        return item
+    }
+}