ruby_everywhere 0.1.15 → 0.3.0

data/lib/everywhere/ui.rb

@@ -31,6 +31,24 @@ module Everywhere
     def cyan(t)    = paint(t, 36)
     def gray(t)    = paint(t, 90) # bright black — dimmer than dim() on most themes
 
+    # Display casing for os tokens. Target IDs ("macos-arm64") stay lowercase
+    # wherever they're typed or stored; use these only in human-facing output.
+    OS_LABELS = {
+      "macos"   => "macOS",
+      "ios"     => "iOS",
+      "android" => "Android",
+      "windows" => "Windows",
+      "linux"   => "Linux"
+    }.freeze
+
+    def os_label(os) = OS_LABELS.fetch(os.to_s, os.to_s)
+
+    # "macos-arm64" → "macOS-arm64"
+    def target_label(target)
+      os, arch = target.to_s.split("-", 2)
+      [ os_label(os), arch ].compact.join("-")
+    end
+
     # --- output levels --------------------------------------------------------
     #
     #   phase   ●  a major phase boundary (build / sign / notarize)

data/lib/everywhere/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Everywhere
-  VERSION = "0.1.15"
+  VERSION = "0.3.0"
 
   # Version of the @rubyeverywhere/bridge JS this gem ships. bridge/ in the
   # gem IS the npm package (served to Rails apps by Everywhere::Engine,

data/support/mobile/ios/App/App.xcconfig

@@ -0,0 +1,6 @@
+// Overwritten by `every build --target ios-*` on every stamp — do not edit by hand.
+PRODUCT_BUNDLE_IDENTIFIER = com.rubyeverywhere.app
+MARKETING_VERSION = 0.1.0
+CURRENT_PROJECT_VERSION = 1
+INFOPLIST_KEY_CFBundleDisplayName = RubyEverywhere
+DEVELOPMENT_TEAM =

data/support/mobile/ios/App/AppDelegate.swift

@@ -0,0 +1,164 @@
+import HotwireNative
+import UIKit
+import UserNotifications
+import WebKit
+
+@main
+class AppDelegate: UIResponder, UIApplicationDelegate {
+    func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
+        configureAppearance()
+        configureHotwire()
+        UNUserNotificationCenter.current().delegate = self
+        return true
+    }
+
+    // MARK: UISceneSession Lifecycle
+
+    func application(_ application: UIApplication, configurationForConnecting connectingSceneSession: UISceneSession, options: UIScene.ConnectionOptions) -> UISceneConfiguration {
+        UISceneConfiguration(name: "Default", sessionRole: connectingSceneSession.role)
+    }
+
+    // MARK: Configuration
+
+    private func configureAppearance() {
+        // Make navigation bars opaque.
+        UINavigationBar.appearance().scrollEdgeAppearance = .init()
+    }
+
+    private func configureHotwire() {
+        let config = EverywhereConfig.shared
+
+        // The path configuration (rules + auth-gated tabs) is loaded by the
+        // SceneDelegate once a scene connects — it mirrors the web view's
+        // cookies into the shared store first, so the auth-gated tab list is
+        // fetched as the signed-in user (see SceneDelegate.loadPathConfiguration).
+
+        Hotwire.config.applicationUserAgentPrefix = config.userAgentPrefix
+        Hotwire.config.backButtonDisplayMode = .minimal
+        Hotwire.config.showDoneButtonOnModals = true
+        #if DEBUG
+        Hotwire.config.debugLoggingEnabled = true
+        #endif
+
+        Hotwire.registerBridgeComponents([
+            NotificationComponent.self,
+            HapticsComponent.self,
+            PermissionsComponent.self,
+            BiometricsComponent.self,
+            StorageComponent.self,
+            MenuComponent.self
+        ] + EverywhereExtensions.components)
+
+        // Handles Everywhere.reloadTabs() from the page (a dedicated message
+        // handler, so it works regardless of which bridge components are
+        // mounted). Posts a notification the SceneDelegate acts on.
+        let controlHandler = WebControlHandler()
+
+        // Mirrors the framework's default web view factory (WKWebView.debugInspectable):
+        // the configuration we receive already carries Hotwire's process pool and
+        // user agent, so we only add our user script before creating the web view.
+        Hotwire.config.makeCustomWebView = { configuration in
+            // Expose the app's identity to the page before any of its scripts
+            // run. Built here, per web view: webConfigJSON carries the
+            // instance override, which changes when a picker re-roots the app.
+            let configScript = WKUserScript(
+                source: "window.__EVERYWHERE_CONFIG__ = \(config.webConfigJSON);",
+                injectionTime: .atDocumentStart,
+                forMainFrameOnly: true
+            )
+            configuration.userContentController.addUserScript(configScript)
+            // Re-add defensively: a reused configuration would throw on a
+            // duplicate handler name.
+            configuration.userContentController.removeScriptMessageHandler(forName: "everywhereControl")
+            configuration.userContentController.add(controlHandler, name: "everywhereControl")
+            let webView = WKWebView(frame: .zero, configuration: configuration)
+            #if DEBUG
+            if #available(iOS 16.4, *) {
+                webView.isInspectable = true
+            }
+            #endif
+            return webView
+        }
+    }
+}
+
+// MARK: - Page → shell control messages
+
+extension Notification.Name {
+    static let everywhereReloadConfig = Notification.Name("EverywhereReloadConfig")
+    static let everywhereResetApp = Notification.Name("EverywhereResetApp")
+    static let everywhereSetTabBadge = Notification.Name("EverywhereSetTabBadge")
+    static let everywhereSetInstance = Notification.Name("EverywhereSetInstance")
+    static let everywhereClearInstance = Notification.Name("EverywhereClearInstance")
+    /// Posted by `everywhereVisit(_:)` from native extension code.
+    static let everywhereNativeVisit = Notification.Name("EverywhereNativeVisit")
+}
+
+/// Receives `window.webkit.messageHandlers.everywhereControl` messages and
+/// turns them into app-wide notifications. Holds no references to the web view
+/// or delegates, so retaining it on the content controller can't cycle.
+///   { action: "reloadConfig" }                    → refresh tabs/path config
+///   { action: "reset", to: "/path" }              → full app reset, then land on `to`
+///   { action: "setBadge", count: 3 }              → app icon badge (0 clears)
+///   { action: "setTabBadge", path: "/x", count: 3 } → tab bar badge (0 clears)
+///   { action: "setInstance", url: "https://…", to: "/path"? } → persist instance root + reset
+///   { action: "clearInstance", to: "/path"? }     → back to the stamped root + reset
+final class WebControlHandler: NSObject, WKScriptMessageHandler {
+    func userContentController(_ controller: WKUserContentController, didReceive message: WKScriptMessage) {
+        guard let body = message.body as? [String: Any],
+              let action = body["action"] as? String
+        else { return }
+
+        #if DEBUG
+        NSLog("everywhereControl: %@", String(describing: body))
+        #endif
+
+        switch action {
+        case "reloadConfig":
+            NotificationCenter.default.post(name: .everywhereReloadConfig, object: nil)
+        case "reset":
+            let info = (body["to"] as? String).map { ["to": $0] }
+            NotificationCenter.default.post(name: .everywhereResetApp, object: nil, userInfo: info)
+        case "setBadge":
+            setAppBadge((body["count"] as? NSNumber)?.intValue ?? 0)
+        case "setTabBadge":
+            guard let path = body["path"] as? String else { return }
+            NotificationCenter.default.post(
+                name: .everywhereSetTabBadge, object: nil,
+                userInfo: ["path": path, "count": (body["count"] as? NSNumber)?.intValue ?? 0])
+        case "setInstance":
+            guard let url = body["url"] as? String else { return }
+            var info: [String: Any] = ["url": url]
+            if let to = body["to"] as? String { info["to"] = to }
+            NotificationCenter.default.post(name: .everywhereSetInstance, object: nil, userInfo: info)
+        case "clearInstance":
+            let info = (body["to"] as? String).map { ["to": $0] }
+            NotificationCenter.default.post(name: .everywhereClearInstance, object: nil, userInfo: info)
+        default:
+            break
+        }
+    }
+
+    /// Provisional authorization is silent — no permission prompt for a badge.
+    private func setAppBadge(_ count: Int) {
+        let center = UNUserNotificationCenter.current()
+        center.requestAuthorization(options: [.badge, .provisional]) { granted, _ in
+            guard granted else { return }
+            if #available(iOS 16.0, *) {
+                center.setBadgeCount(count)
+            } else {
+                DispatchQueue.main.async {
+                    UIApplication.shared.applicationIconBadgeNumber = count
+                }
+            }
+        }
+    }
+}
+
+// MARK: - UNUserNotificationCenterDelegate
+
+extension AppDelegate: UNUserNotificationCenterDelegate {
+    func userNotificationCenter(_ center: UNUserNotificationCenter, willPresent notification: UNNotification, withCompletionHandler completionHandler: @escaping (UNNotificationPresentationOptions) -> Void) {
+        completionHandler([.banner, .sound])
+    }
+}

data/support/mobile/ios/App/Assets.xcassets/AccentColor.colorset/Contents.json

@@ -0,0 +1,20 @@
+{
+  "colors" : [
+    {
+      "color" : {
+        "color-space" : "srgb",
+        "components" : {
+          "alpha" : "1.000",
+          "blue" : "0x2D",
+          "green" : "0x34",
+          "red" : "0xCC"
+        }
+      },
+      "idiom" : "universal"
+    }
+  ],
+  "info" : {
+    "author" : "xcode",
+    "version" : 1
+  }
+}

data/support/mobile/ios/App/Assets.xcassets/AppIcon.appiconset/Contents.json

@@ -0,0 +1,14 @@
+{
+  "images" : [
+    {
+      "filename" : "AppIcon.png",
+      "idiom" : "universal",
+      "platform" : "ios",
+      "size" : "1024x1024"
+    }
+  ],
+  "info" : {
+    "author" : "xcode",
+    "version" : 1
+  }
+}

data/support/mobile/ios/App/Assets.xcassets/Contents.json

@@ -0,0 +1,6 @@
+{
+  "info" : {
+    "author" : "xcode",
+    "version" : 1
+  }
+}

data/support/mobile/ios/App/Assets.xcassets/LaunchBackground.colorset/Contents.json

@@ -0,0 +1,38 @@
+{
+  "colors" : [
+    {
+      "color" : {
+        "color-space" : "srgb",
+        "components" : {
+          "alpha" : "1.000",
+          "blue" : "0xF7",
+          "green" : "0xF9",
+          "red" : "0xFA"
+        }
+      },
+      "idiom" : "universal"
+    },
+    {
+      "appearances" : [
+        {
+          "appearance" : "luminosity",
+          "value" : "dark"
+        }
+      ],
+      "color" : {
+        "color-space" : "srgb",
+        "components" : {
+          "alpha" : "1.000",
+          "blue" : "0x1A",
+          "green" : "0x1B",
+          "red" : "0x1C"
+        }
+      },
+      "idiom" : "universal"
+    }
+  ],
+  "info" : {
+    "author" : "xcode",
+    "version" : 1
+  }
+}

data/support/mobile/ios/App/Base.lproj/LaunchScreen.storyboard

@@ -0,0 +1,32 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<document type="com.apple.InterfaceBuilder3.CocoaTouch.Storyboard.XIB" version="3.0" toolsVersion="22505" targetRuntime="iOS.CocoaTouch" propertyAccessControl="none" useAutolayout="YES" launchScreen="YES" useTraitCollections="YES" useSafeAreas="YES" colorMatched="YES" initialViewController="01J-lp-oVM">
+    <device id="retina6_12" orientation="portrait" appearance="light"/>
+    <dependencies>
+        <plugIn identifier="com.apple.InterfaceBuilder.IBCocoaTouchPlugin" version="22504"/>
+        <capability name="Named colors" minToolsVersion="9.0"/>
+        <capability name="Safe area layout guides" minToolsVersion="9.0"/>
+        <capability name="documents saved in the Xcode 8 format" minToolsVersion="8.0"/>
+    </dependencies>
+    <scenes>
+        <!--View Controller-->
+        <scene sceneID="EHf-IW-A2E">
+            <objects>
+                <viewController id="01J-lp-oVM" sceneMemberID="viewController">
+                    <view key="view" contentMode="scaleToFill" id="Ze5-6b-2t3">
+                        <rect key="frame" x="0.0" y="0.0" width="393" height="852"/>
+                        <autoresizingMask key="autoresizingMask" widthSizable="YES" heightSizable="YES"/>
+                        <viewLayoutGuide key="safeArea" id="6Tk-OE-BBY"/>
+                        <color key="backgroundColor" name="LaunchBackground"/>
+                    </view>
+                </viewController>
+                <placeholder placeholderIdentifier="IBFirstResponder" id="iYj-Kq-Ea1" userLabel="First Responder" sceneMemberID="firstResponder"/>
+            </objects>
+            <point key="canvasLocation" x="53" y="375"/>
+        </scene>
+    </scenes>
+    <resources>
+        <namedColor name="LaunchBackground">
+            <color red="0.98039215686274506" green="0.97647058823529409" blue="0.96862745098039216" alpha="1" colorSpace="custom" customColorSpace="sRGB"/>
+        </namedColor>
+    </resources>
+</document>

data/support/mobile/ios/App/Bridge/BiometricsComponent.swift

@@ -0,0 +1,276 @@
+import Foundation
+import HotwireNative
+import LocalAuthentication
+import Security
+
+/// Bridge component backing `everywhere--biometrics`. Handles `query`
+/// (availability + biometry type), `authenticate` (Face ID / Touch ID
+/// prompt, optionally falling back to the device passcode), and the
+/// `credential*` events (a biometric-protected keychain secret powering
+/// "sign in with Face ID"), replying `{available, biometry, status}`,
+/// `{authenticated, error?}`, and `{stored|token|enrolled|cleared, error?}`.
+///
+/// Biometrics must be declared in everywhere.yml — that's what stamps
+/// NSFaceIDUsageDescription, and evaluating a Face ID policy without it
+/// crashes the app — so undeclared use short-circuits before any system API.
+///
+/// This proves presence to the PAGE only (gate a screen, confirm an action);
+/// it is not authentication the server can trust.
+final class BiometricsComponent: BridgeComponent {
+    override nonisolated class var name: String { "everywhere--biometrics" }
+
+    override func onReceive(message: Message) {
+        let declared = EverywhereConfig.shared.declaresPermission("biometrics")
+
+        switch message.event {
+        case "query":
+            declared ? query(message)
+                     : reply(message, QueryReply(available: false, biometry: "none", status: "undeclared"))
+        case "authenticate":
+            declared ? authenticate(message)
+                     : reply(message, AuthReply(authenticated: false, error: "undeclared"))
+        case "credentialStore", "credentialGet", "credentialStatus", "credentialClear":
+            declared ? credential(message)
+                     : reply(message, CredentialReply(error: "undeclared"))
+        default:
+            break
+        }
+    }
+
+    private func query(_ message: Message) {
+        let context = LAContext()
+        var error: NSError?
+        let available = context.canEvaluatePolicy(.deviceOwnerAuthenticationWithBiometrics, error: &error)
+        // biometryType is only valid after canEvaluatePolicy; it still reports
+        // the hardware's type when the check fails (e.g. nothing enrolled).
+        reply(message, QueryReply(
+            available: available,
+            biometry: biometryName(context.biometryType),
+            status: available ? "available" : describe(error)))
+    }
+
+    private func authenticate(_ message: Message) {
+        let data: Payload? = message.data()
+        let policy: LAPolicy = data?.allowPasscode == true
+            ? .deviceOwnerAuthentication
+            : .deviceOwnerAuthenticationWithBiometrics
+        let reason = (data?.reason?.trimmingCharacters(in: .whitespacesAndNewlines)).flatMap { $0.isEmpty ? nil : $0 }
+            ?? "Confirm it's you."
+
+        let context = LAContext()
+        var error: NSError?
+        guard context.canEvaluatePolicy(policy, error: &error) else {
+            return reply(message, AuthReply(authenticated: false, error: describe(error)))
+        }
+
+        context.evaluatePolicy(policy, localizedReason: reason) { [weak self] success, error in
+            self?.reply(message, AuthReply(authenticated: success, error: success ? nil : self?.describe(error as NSError?)))
+        }
+    }
+
+    // MARK: Keychain credential (the "sign in with Face ID" token)
+    //
+    // A server-issued secret stored with SecAccessControl(.biometryCurrentSet):
+    // reading it IS the Face ID prompt, and iOS invalidates the item whenever
+    // biometric enrollment changes (a newly added face/finger kills it).
+    // Keychain calls that show UI block their thread, so everything runs off
+    // the main queue and replies through the nonisolated helper.
+
+    private func credential(_ message: Message) {
+        let event = message.event
+        let data: Payload? = message.data()
+
+        DispatchQueue.global(qos: .userInitiated).async { [weak self] in
+            guard let self else { return }
+            switch event {
+            case "credentialStore":
+                self.reply(message, self.storeCredential(data?.token, reason: data?.reason ?? "Enable biometric sign-in"))
+            case "credentialGet":
+                self.reply(message, self.readCredential(reason: data?.reason ?? "Sign in"))
+            case "credentialStatus":
+                self.reply(message, self.credentialStatus())
+            default: // credentialClear
+                self.reply(message, self.clearCredential())
+            }
+        }
+    }
+
+    private nonisolated static let credentialService =
+        (Bundle.main.bundleIdentifier ?? "com.rubyeverywhere.app") + ".biometric-login"
+
+    private nonisolated var credentialQuery: [String: Any] {
+        [kSecClass as String: kSecClassGenericPassword,
+         kSecAttrService as String: Self.credentialService,
+         kSecAttrAccount as String: "login"]
+    }
+
+    /// Blocking biometric check on the calling (background) queue. Returns the
+    /// authenticated context on success — pass it into a keychain read so
+    /// hardware shows exactly one prompt — or the error string on failure.
+    /// Real devices enforce the item ACL regardless; the Simulator doesn't
+    /// honor keychain ACLs, so this explicit pass is what keeps sim and
+    /// device behavior aligned.
+    private nonisolated func biometricCheck(reason: String) -> (context: LAContext?, error: String?) {
+        let context = LAContext()
+        context.localizedReason = reason
+
+        var authError: NSError?
+        guard context.canEvaluatePolicy(.deviceOwnerAuthenticationWithBiometrics, error: &authError) else {
+            return (nil, describe(authError))
+        }
+
+        let gate = DispatchSemaphore(value: 0)
+        var passed = false
+        var evalError: NSError?
+        context.evaluatePolicy(.deviceOwnerAuthenticationWithBiometrics, localizedReason: reason) { ok, error in
+            passed = ok
+            evalError = error as NSError?
+            gate.signal()
+        }
+        gate.wait()
+        return passed ? (context, nil) : (nil, describe(evalError))
+    }
+
+    /// Storing runs the check too: writes don't trigger the ACL, but enabling
+    /// a sign-in credential is a security change — confirm it's the owner.
+    private nonisolated func storeCredential(_ token: String?, reason: String) -> CredentialReply {
+        guard let token, !token.isEmpty, let data = token.data(using: .utf8) else {
+            return CredentialReply(stored: false, error: "failed")
+        }
+
+        if let error = biometricCheck(reason: reason).error {
+            return CredentialReply(stored: false, error: error)
+        }
+
+        SecItemDelete(credentialQuery as CFDictionary)
+
+        // WhenUnlocked (not WhenPasscodeSet): real devices can't enroll
+        // biometrics without a passcode, so protection is equivalent — but
+        // WhenPasscodeSet makes SecItemAdd fail on passcode-less simulators.
+        // .biometryCurrentSet is the actual gate either way.
+        var accessError: Unmanaged<CFError>?
+        guard let access = SecAccessControlCreateWithFlags(
+            nil, kSecAttrAccessibleWhenUnlockedThisDeviceOnly, .biometryCurrentSet, &accessError)
+        else { return CredentialReply(stored: false, error: "notAvailable") }
+
+        var attrs = credentialQuery
+        attrs[kSecValueData as String] = data
+        attrs[kSecAttrAccessControl as String] = access
+
+        let status = SecItemAdd(attrs as CFDictionary, nil)
+        return status == errSecSuccess
+            ? CredentialReply(stored: true)
+            : CredentialReply(stored: false, error: keychainError(status), code: status)
+    }
+
+    private nonisolated func readCredential(reason: String) -> CredentialReply {
+        let check = biometricCheck(reason: reason)
+        guard let context = check.context else {
+            return CredentialReply(error: check.error ?? "failed")
+        }
+
+        var query = credentialQuery
+        query[kSecReturnData as String] = true
+        query[kSecUseAuthenticationContext as String] = context
+
+        var result: CFTypeRef?
+        let status = SecItemCopyMatching(query as CFDictionary, &result)
+        guard status == errSecSuccess, let data = result as? Data,
+              let token = String(data: data, encoding: .utf8)
+        else { return CredentialReply(error: keychainError(status), code: status) }
+
+        return CredentialReply(token: token)
+    }
+
+    /// Whether a credential exists, without triggering Face ID:
+    /// interactionNotAllowed means "it's there but needs auth" — enrolled.
+    private nonisolated func credentialStatus() -> CredentialReply {
+        let context = LAContext()
+        context.interactionNotAllowed = true
+
+        var query = credentialQuery
+        query[kSecUseAuthenticationContext as String] = context
+
+        let status = SecItemCopyMatching(query as CFDictionary, nil)
+        return CredentialReply(enrolled: status == errSecSuccess || status == errSecInteractionNotAllowed)
+    }
+
+    private nonisolated func clearCredential() -> CredentialReply {
+        let status = SecItemDelete(credentialQuery as CFDictionary)
+        let cleared = status == errSecSuccess || status == errSecItemNotFound
+        return CredentialReply(cleared: cleared, error: cleared ? nil : keychainError(status))
+    }
+
+    private nonisolated func keychainError(_ status: OSStatus) -> String {
+        switch status {
+        case errSecUserCanceled: "canceled"
+        case errSecItemNotFound: "notEnrolled"
+        case errSecAuthFailed: "failed"
+        default: "failed"
+        }
+    }
+
+    /// Replies on the exact message that asked (same rationale as
+    /// PermissionsComponent: concurrent messages for one event make
+    /// `reply(to: event)` target only the last-received message).
+    /// nonisolated so LAContext's background completion can call it directly;
+    /// the actual reply still hops to the main actor.
+    private nonisolated func reply(_ message: Message, _ payload: Encodable) {
+        Task { @MainActor in
+            self.reply(with: message.replacing(data: payload))
+        }
+    }
+
+    private func biometryName(_ type: LABiometryType) -> String {
+        switch type {
+        case .faceID: return "faceID"
+        case .touchID: return "touchID"
+        default:
+            if #available(iOS 17.0, *), type == .opticID { return "opticID" }
+            return "none"
+        }
+    }
+
+    private nonisolated func describe(_ error: NSError?) -> String {
+        guard let error, error.domain == LAErrorDomain,
+              let code = LAError.Code(rawValue: error.code)
+        else { return "failed" }
+
+        switch code {
+        case .userCancel, .systemCancel, .appCancel: return "canceled"
+        case .userFallback: return "fallback"
+        case .biometryLockout: return "lockout"
+        case .biometryNotEnrolled: return "notEnrolled"
+        case .biometryNotAvailable: return "notAvailable"
+        case .passcodeNotSet: return "passcodeNotSet"
+        default: return "failed"
+        }
+    }
+
+    private struct Payload: Decodable {
+        let reason: String?
+        let allowPasscode: Bool?
+        let token: String?
+    }
+
+    private struct QueryReply: Encodable {
+        let available: Bool
+        let biometry: String
+        let status: String
+    }
+
+    private struct AuthReply: Encodable {
+        let authenticated: Bool
+        let error: String?
+    }
+
+    private struct CredentialReply: Encodable {
+        var stored: Bool? = nil
+        var token: String? = nil
+        var enrolled: Bool? = nil
+        var cleared: Bool? = nil
+        var error: String? = nil
+        /// Raw OSStatus on keychain failures — diagnosis, not API.
+        var code: Int32? = nil
+    }
+}

data/support/mobile/ios/App/Bridge/HapticsComponent.swift

@@ -0,0 +1,47 @@
+import Foundation
+import HotwireNative
+import UIKit
+
+/// Bridge component backing `everywhere--haptics`: plays impact, notification,
+/// and selection feedback for `Everywhere.haptics.*` calls from the page.
+final class HapticsComponent: BridgeComponent {
+    override nonisolated class var name: String { "everywhere--haptics" }
+
+    override func onReceive(message: Message) {
+        switch message.event {
+        case "impact":
+            let style: Payload? = message.data()
+            UIImpactFeedbackGenerator(style: impactStyle(style?.style)).impactOccurred()
+        case "notification":
+            let type: Payload? = message.data()
+            UINotificationFeedbackGenerator().notificationOccurred(notificationType(type?.type))
+        case "selection":
+            UISelectionFeedbackGenerator().selectionChanged()
+        default:
+            break
+        }
+    }
+
+    private func impactStyle(_ name: String?) -> UIImpactFeedbackGenerator.FeedbackStyle {
+        switch name {
+        case "light": .light
+        case "heavy": .heavy
+        case "soft": .soft
+        case "rigid": .rigid
+        default: .medium
+        }
+    }
+
+    private func notificationType(_ name: String?) -> UINotificationFeedbackGenerator.FeedbackType {
+        switch name {
+        case "warning": .warning
+        case "error": .error
+        default: .success
+        }
+    }
+
+    private struct Payload: Decodable {
+        let style: String?
+        let type: String?
+    }
+}