Block editor: change block type

xcode/Subconscious/Shared/AppTheme.swift

@@ -88,7 +88,7 @@ extension Color {
     static let icon = SwiftUI.Color.accentColor
     static let secondaryIcon = SwiftUI.Color.secondary
     static let tertiaryIcon = SwiftUI.Color(
-        uiColor: UIColor.tertiarySystemFill
+        uiColor: UIColor.tertiaryLabel
     )
     static let buttonText = SwiftUI.Color.accentColor
     /// Fill for pressed-state overlays
@@ -188,3 +188,16 @@ extension UIColor {
         UIColor(Color.accentColor)
     }
 }
+
+extension ShadowStyle {
+    static func brandShadowLg(
+        _ colorScheme: ColorScheme
+    ) -> ShadowStyle {
+        ShadowStyle(
+            color: Color.brandDropShadow(colorScheme).opacity(0.5),
+            radius: 8,
+            x: 0,
+            y: 4
+        )
+    }
+}

xcode/Subconscious/Shared/Components/Detail/MemoEditorDetail.swift

@@ -179,7 +179,7 @@ struct MemoEditorDetailView: View {
     }
 
     private func blockEditor() -> some View {
-        BlockEditor.Representable(
+        BlockEditor.BlockEditorView(
             store: blockEditorStore
         )
         .frame(

xcode/Subconscious/Shared/Library/ColorUtilities.swift

@@ -7,6 +7,144 @@
 
 import SwiftUI
 
+extension UIColor {
+    convenience init(
+        light lightModeColor: UIColor,
+        dark darkModeColor: UIColor
+     ) {
+        self.init { traitCollection in
+            switch traitCollection.userInterfaceStyle {
+            case .light:
+                return lightModeColor
+            case .dark:
+                return darkModeColor
+            default:
+                return lightModeColor
+            }
+        }
+    }
+}
+
+extension Color {
+    init(
+        light lightModeColor: Color,
+        dark darkModeColor: Color
+     ) {
+         self.init(
+            UIColor(
+                light: UIColor(lightModeColor),
+                dark: UIColor(darkModeColor)
+            )
+         )
+    }
+}
+
+extension Color {
+    /// A color theme describes a foreground, background, and border
+    struct Theme: Hashable {
+        var foreground: Color
+        var background: Color
+        var border: Color = .clear
+    }
+}
+
+extension View {
+    /// Apply a theme to this view
+    func theme(_ theme: Color.Theme) -> some View {
+        self
+            .foregroundStyle(theme.foreground)
+            .background(theme.background)
+    }
+}
+
+
+
+extension Color {
+    /// Describe themes for all states of a button
+    struct ButtonTheme: Hashable {
+        var normal: Theme
+        var pressed: Theme
+        var disabled: Theme
+
+        /// Describes a button state
+        enum State: Hashable {
+            case normal
+            case pressed
+            case disabled
+
+            init(
+                isPressed: Bool,
+                isEnabled: Bool = true
+            ) {
+                guard isEnabled else {
+                    self = .disabled
+                    return
+                }
+                guard !isPressed else {
+                    self = .pressed
+                    return
+                }
+                self = .normal
+            }
+        }
+
+        /// Choose a theme given a button state
+        func choose(_ state: ButtonTheme.State) -> Theme {
+            switch state {
+            case .normal:
+                return normal
+            case .pressed:
+                return pressed
+            case .disabled:
+                return disabled
+            }
+        }
+    }
+}
+
+extension View {
+    /// Apply a button theme to this view for a given state
+    func theme(
+        _ buttonTheme: Color.ButtonTheme,
+        state: Color.ButtonTheme.State
+    ) -> some View {
+        let theme = buttonTheme.choose(state)
+        return self
+            .animation(.default, value: state)
+            .theme(theme)
+    }
+
+    /// Apply a button theme to this view depending on whether it is
+    /// enabled, pressed, etc.
+    func theme(
+        _ buttonTheme: Color.ButtonTheme,
+        isPressed: Bool,
+        isEnabled: Bool = true
+    ) -> some View {
+        theme(
+            buttonTheme,
+            state: .init(isPressed: isPressed, isEnabled: isEnabled)
+        )
+    }
+}
+
+extension Color {
+    /// Describe button themes for multiple roles
+    struct ButtonRoleTheme: Hashable {
+        var normal: ButtonTheme
+        var destructive: ButtonTheme
+
+        func forRole(_ buttonRole: ButtonRole? = nil) -> ButtonTheme {
+            switch buttonRole {
+            case let .some(role) where role == .destructive:
+                return destructive
+            default:
+                return normal
+            }
+        }
+    }
+}
+
 extension Color {
     static func chooseForState(
         isPressed: Bool,
@@ -26,3 +164,26 @@ extension Color {
         }
     }
 }
+
+struct ColorUtilities_Previews: PreviewProvider {
+    static var previews: some View {
+        VStack {
+            Text("Hello world")
+                .padding()
+                .theme(
+                    .init(
+                        foreground: .blue,
+                        background: .secondaryBackground
+                    )
+                )
+            Text("Hello world")
+                .padding()
+                .theme(
+                    .init(
+                        foreground: .red,
+                        background: .secondaryBackground
+                    )
+                )
+        }
+    }
+}