dsh-notch 0.3.1

package/macos/Sources/NotchMarkdown.swift

@@ -0,0 +1,266 @@
+import AppKit
+import SwiftUI
+
+/// Block Markdown using DSH body type: 14pt system, 12pt SF Mono.
+enum NotchMarkdown {
+  static let bodySize: CGFloat = 14
+  static let headingSize: CGFloat = 17
+  static let codeSize: CGFloat = 12
+}
+
+struct NotchMarkdownView: View {
+  let source: String
+
+  var body: some View {
+    VStack(alignment: .leading, spacing: 10) {
+      ForEach(Array(blocks.enumerated()), id: \.offset) { _, block in
+        blockView(block)
+      }
+    }
+    .frame(maxWidth: .infinity, alignment: .leading)
+  }
+
+  private var blocks: [Block] { Block.parse(source) }
+
+  @ViewBuilder
+  private func blockView(_ block: Block) -> some View {
+    switch block {
+    case .heading(let level, let text):
+      inline(text)
+        .font(.system(size: level <= 1 ? 18 : level == 2 ? 16 : 15, weight: .semibold))
+        .foregroundStyle(.white)
+        .padding(.top, level <= 2 ? 8 : 4)
+    case .paragraph(let text):
+      inline(text)
+        .font(.system(size: NotchMarkdown.bodySize))
+        .foregroundStyle(Color.white.opacity(0.9))
+        .lineSpacing(6)
+    case .list(let items, let ordered):
+      VStack(alignment: .leading, spacing: 4) {
+        ForEach(Array(items.enumerated()), id: \.offset) { i, item in
+          HStack(alignment: .top, spacing: 8) {
+            Text(ordered ? "\(i + 1)." : "•")
+              .font(.system(size: NotchMarkdown.bodySize, weight: .medium))
+              .foregroundStyle(Color.white.opacity(0.55))
+              .frame(width: 18, alignment: .trailing)
+            inline(item)
+              .font(.system(size: NotchMarkdown.bodySize))
+              .foregroundStyle(Color.white.opacity(0.9))
+              .lineSpacing(5)
+          }
+        }
+      }
+    case .table(let headers, let rows):
+      table(headers: headers, rows: rows)
+    case .code(let text):
+      Text(text)
+        .font(.system(size: NotchMarkdown.codeSize, design: .monospaced))
+        .foregroundStyle(Color.white.opacity(0.92))
+        .frame(maxWidth: .infinity, alignment: .leading)
+        .padding(10)
+        .background(
+          RoundedRectangle(cornerRadius: 8, style: .continuous)
+            .fill(Color.white.opacity(0.07))
+        )
+    case .quote(let text):
+      inline(text)
+        .font(.system(size: NotchMarkdown.bodySize))
+        .foregroundStyle(Color.white.opacity(0.7))
+        .padding(.leading, 10)
+        .overlay(alignment: .leading) {
+          Rectangle().fill(Color.white.opacity(0.28)).frame(width: 2)
+        }
+    case .rule:
+      Divider().overlay(Color.white.opacity(0.18))
+    }
+  }
+
+  private func inline(_ markdown: String) -> Text {
+    var options = AttributedString.MarkdownParsingOptions()
+    options.interpretedSyntax = .inlineOnlyPreservingWhitespace
+    options.failurePolicy = .returnPartiallyParsedIfPossible
+    if let parsed = try? AttributedString(markdown: markdown, options: options) {
+      var styled = parsed
+      for run in styled.runs {
+        if run.inlinePresentationIntent?.contains(.code) == true {
+          styled[run.range].font = .system(size: NotchMarkdown.codeSize, design: .monospaced)
+          styled[run.range].backgroundColor = NSColor.white.withAlphaComponent(0.1)
+        }
+      }
+      return Text(styled)
+    }
+    return Text(markdown)
+  }
+
+  private func table(headers: [String], rows: [[String]]) -> some View {
+    let columns = max(headers.count, rows.map(\.count).max() ?? 0)
+    return VStack(alignment: .leading, spacing: 0) {
+      if !headers.isEmpty {
+        tableRow(cells: headers, header: true, columns: columns)
+        Rectangle().fill(Color.white.opacity(0.2)).frame(height: 1)
+      }
+      ForEach(Array(rows.enumerated()), id: \.offset) { i, row in
+        tableRow(cells: row, header: false, columns: columns)
+        if i < rows.count - 1 {
+          Rectangle().fill(Color.white.opacity(0.08)).frame(height: 1)
+        }
+      }
+    }
+    .padding(8)
+    .background(
+      RoundedRectangle(cornerRadius: 8, style: .continuous)
+        .stroke(Color.white.opacity(0.16), lineWidth: 1)
+    )
+  }
+
+  private func tableRow(cells: [String], header: Bool, columns: Int) -> some View {
+    HStack(alignment: .top, spacing: 0) {
+      ForEach(0..<columns, id: \.self) { i in
+        let cell = i < cells.count ? cells[i] : ""
+        Text(cell)
+          .font(.system(size: 12, weight: header ? .semibold : .regular))
+          .foregroundStyle(Color.white.opacity(header ? 0.95 : 0.82))
+          .frame(maxWidth: .infinity, alignment: .leading)
+          .padding(.vertical, 5)
+          .padding(.horizontal, 6)
+        if i < columns - 1 {
+          Rectangle().fill(Color.white.opacity(0.1)).frame(width: 1)
+        }
+      }
+    }
+  }
+}
+
+private enum Block {
+  case heading(Int, String)
+  case paragraph(String)
+  case list([String], Bool)
+  case table([String], [[String]])
+  case code(String)
+  case quote(String)
+  case rule
+
+  static func parse(_ source: String) -> [Block] {
+    let lines = source.replacingOccurrences(of: "\r\n", with: "\n").split(separator: "\n", omittingEmptySubsequences: false).map(String.init)
+    var blocks: [Block] = []
+    var i = 0
+    while i < lines.count {
+      let raw = lines[i]
+      let line = raw.trimmingCharacters(in: .whitespaces)
+      if line.isEmpty { i += 1; continue }
+      if line.hasPrefix("```") {
+        i += 1
+        var body: [String] = []
+        while i < lines.count, !lines[i].trimmingCharacters(in: .whitespaces).hasPrefix("```") {
+          body.append(lines[i])
+          i += 1
+        }
+        if i < lines.count { i += 1 }
+        blocks.append(.code(body.joined(separator: "\n")))
+        continue
+      }
+      if line == "---" || line == "***" || line == "___" {
+        blocks.append(.rule)
+        i += 1
+        continue
+      }
+      if let heading = heading(line) {
+        blocks.append(heading)
+        i += 1
+        continue
+      }
+      if line.hasPrefix("|") && i + 1 < lines.count, isTableDivider(lines[i + 1]) {
+        let headers = cells(line)
+        i += 2
+        var rows: [[String]] = []
+        while i < lines.count, lines[i].trimmingCharacters(in: .whitespaces).hasPrefix("|") {
+          rows.append(cells(lines[i]))
+          i += 1
+        }
+        blocks.append(.table(headers, rows))
+        continue
+      }
+      if line.hasPrefix("> ") || line == ">" {
+        var quoted: [String] = []
+        while i < lines.count {
+          let t = lines[i].trimmingCharacters(in: .whitespaces)
+          if t.hasPrefix("> ") { quoted.append(String(t.dropFirst(2))) }
+          else if t == ">" { quoted.append("") }
+          else { break }
+          i += 1
+        }
+        blocks.append(.quote(quoted.joined(separator: "\n")))
+        continue
+      }
+      if isBullet(line) || isOrdered(line) {
+        let ordered = isOrdered(line)
+        var items: [String] = []
+        while i < lines.count {
+          let t = lines[i].trimmingCharacters(in: .whitespaces)
+          if ordered, let item = orderedItem(t) { items.append(item) }
+          else if !ordered, let item = bulletItem(t) { items.append(item) }
+          else { break }
+          i += 1
+        }
+        blocks.append(.list(items, ordered))
+        continue
+      }
+      var para: [String] = [line]
+      i += 1
+      while i < lines.count {
+        let t = lines[i].trimmingCharacters(in: .whitespaces)
+        if t.isEmpty || t.hasPrefix("#") || t.hasPrefix("|") || t.hasPrefix("```") || t.hasPrefix("> ") || isBullet(t) || isOrdered(t) || t == "---" { break }
+        para.append(t)
+        i += 1
+      }
+      blocks.append(.paragraph(para.joined(separator: " ")))
+    }
+    return blocks
+  }
+
+  private static func heading(_ line: String) -> Block? {
+    guard line.hasPrefix("#") else { return nil }
+    var level = 0
+    for ch in line {
+      if ch == "#" { level += 1 } else { break }
+    }
+    guard level > 0, level <= 6, line.count > level, line[line.index(line.startIndex, offsetBy: level)] == " " else { return nil }
+    return .heading(level, String(line.dropFirst(level + 1)))
+  }
+
+  private static func isTableDivider(_ line: String) -> Bool {
+    let t = line.trimmingCharacters(in: .whitespaces)
+    guard t.hasPrefix("|") else { return false }
+    return t.replacingOccurrences(of: "|", with: "").replacingOccurrences(of: ":", with: "").replacingOccurrences(of: "-", with: "").replacingOccurrences(of: " ", with: "").isEmpty
+  }
+
+  private static func cells(_ line: String) -> [String] {
+    var parts = line.split(separator: "|", omittingEmptySubsequences: false).map { $0.trimmingCharacters(in: .whitespaces) }
+    if parts.first == "" { parts.removeFirst() }
+    if parts.last == "" { parts.removeLast() }
+    return parts
+  }
+
+  private static func isBullet(_ line: String) -> Bool {
+    line.hasPrefix("- ") || line.hasPrefix("* ")
+  }
+
+  private static func bulletItem(_ line: String) -> String? {
+    if line.hasPrefix("- ") { return String(line.dropFirst(2)) }
+    if line.hasPrefix("* ") { return String(line.dropFirst(2)) }
+    return nil
+  }
+
+  private static func isOrdered(_ line: String) -> Bool {
+    orderedItem(line) != nil
+  }
+
+  private static func orderedItem(_ line: String) -> String? {
+    guard let dot = line.firstIndex(of: ".") else { return nil }
+    let n = line[..<dot]
+    guard !n.isEmpty, n.allSatisfy(\.isNumber) else { return nil }
+    let rest = line[line.index(after: dot)...]
+    guard rest.first == " " else { return nil }
+    return String(rest.dropFirst())
+  }
+}

package/macos/Sources/Panel.swift

@@ -0,0 +1,153 @@
+import AppKit
+import SwiftUI
+
+enum NotchGeometryAnimation {
+  static let animation = Animation.spring(duration: 0.4, bounce: 0.08)
+  static let duration: TimeInterval = 0.4
+  static func progress(_ t: Double) -> Double {
+    let x = min(1, max(0, t))
+    return x*x*x*(x*(6*x-15)+10)
+  }
+}
+
+final class NotchPanel: NSPanel {
+  private var resizeTimer: Timer?
+  private var resizeTarget: NSSize?
+  private var resizeGeneration = 0
+
+  func cancelResize() {
+    resizeTimer?.invalidate()
+    resizeTimer = nil
+    resizeTarget = nil
+    resizeGeneration += 1
+  }
+
+  /// Animate one native rectangle, preserving its top-right edge at every frame.
+  func resizeAnchored(to size: NSSize, animated: Bool = true) {
+    guard resizeTarget != size else { return }
+    cancelResize()
+    let generation = resizeGeneration
+    resizeTarget = size
+    let start = frame
+    let end = NSRect(x: start.maxX - size.width, y: start.maxY - size.height, width: size.width, height: size.height)
+    guard animated, !NSWorkspace.shared.accessibilityDisplayShouldReduceMotion else {
+      setFrame(end, display: true)
+      return
+    }
+    if #available(macOS 15.0, *) {
+      NSAnimationContext.animate(NotchGeometryAnimation.animation) {
+        self.animator().setFrame(end, display: true)
+      }
+      return
+    }
+    let began = ProcessInfo.processInfo.systemUptime
+    resizeTimer = Timer.scheduledTimer(withTimeInterval: 1.0 / 60.0, repeats: true) { [weak self] _ in
+      Task { @MainActor in
+        guard let self, self.resizeGeneration == generation else { return }
+        let t = min(1, (ProcessInfo.processInfo.systemUptime - began) / NotchGeometryAnimation.duration)
+        let progress = NotchGeometryAnimation.progress(t)
+        let width = start.width + (size.width - start.width) * progress
+        let height = start.height + (size.height - start.height) * progress
+        self.setFrame(NSRect(x: start.maxX - width, y: start.maxY - height, width: width, height: height), display: true)
+        if t >= 1 { self.resizeTimer?.invalidate(); self.resizeTimer = nil }
+      }
+    }
+  }
+
+  override var canBecomeKey: Bool { true }
+  override var canBecomeMain: Bool { false }
+
+  // An accessory panel has no active app Edit menu to route Command keys.
+  // Handle only standard editing commands, and only for our focused editor.
+  override func performKeyEquivalent(with event: NSEvent) -> Bool {
+    guard isKeyWindow, let editor = firstResponder as? NSTextView else {
+      return super.performKeyEquivalent(with: event)
+    }
+    let flags = event.modifierFlags.intersection(.deviceIndependentFlagsMask)
+    guard flags.contains(.command), !flags.contains(.control), !flags.contains(.option) else {
+      return super.performKeyEquivalent(with: event)
+    }
+    let key = event.charactersIgnoringModifiers?.lowercased()
+    if flags.contains(.shift) {
+      if key == "z", editor.isEditable, let undo = editor.undoManager, undo.canRedo {
+        undo.redo()
+        return true
+      }
+      return super.performKeyEquivalent(with: event)
+    }
+    switch key {
+    case "a": editor.selectAll(nil)
+    case "c": editor.copy(nil)
+    case "x" where editor.isEditable: editor.cut(nil)
+    case "v" where editor.isEditable: editor.paste(nil)
+    case "z" where editor.isEditable:
+      guard let undo = editor.undoManager, undo.canUndo else {
+        return super.performKeyEquivalent(with: event)
+      }
+      undo.undo()
+    default: return super.performKeyEquivalent(with: event)
+    }
+    return true
+  }
+
+  convenience init(size: NSSize) {
+    self.init(
+      contentRect: NSRect(origin: .zero, size: size),
+      styleMask: [.borderless, .nonactivatingPanel],
+      backing: .buffered,
+      defer: false
+    )
+    level = .statusBar
+    collectionBehavior = [.canJoinAllSpaces, .stationary, .fullScreenAuxiliary]
+    isOpaque = false
+    backgroundColor = .clear
+    appearance = NSAppearance(named: .darkAqua)
+    hasShadow = false
+    isMovable = false
+    hidesOnDeactivate = false
+    becomesKeyOnlyIfNeeded = true
+    isReleasedWhenClosed = false
+  }
+
+  /// Put the SwiftUI host on top of a real window-backed HUD blur.
+  /// A VisualEffect inside NSHostingView is covered by the hosting view's opaque fill.
+  func embedHost(_ hosting: NSView) {
+    let effect = NSVisualEffectView(frame: contentView?.bounds ?? NSRect(origin: .zero, size: frame.size))
+    effect.material = .hudWindow
+    effect.blendingMode = .behindWindow
+    effect.state = .active
+    effect.isEmphasized = true
+    effect.autoresizingMask = [.width, .height]
+    effect.wantsLayer = true
+    effect.layer?.masksToBounds = true
+    effect.layer?.cornerRadius = 16
+    effect.layer?.maskedCorners = [.layerMinXMinYCorner, .layerMinXMaxYCorner]
+    effect.appearance = NSAppearance(named: .darkAqua)
+    contentView = effect
+    hosting.autoresizingMask = [.width, .height]
+    hosting.frame = effect.bounds
+    hosting.wantsLayer = true
+    hosting.layer?.isOpaque = false
+    hosting.layer?.backgroundColor = NSColor.clear.cgColor
+    effect.addSubview(hosting)
+  }
+}
+
+final class NotchHostingView<Content: View>: NSHostingView<Content> {
+  override var isOpaque: Bool { false }
+
+  // The panel is intentionally nonactivating. A click must reach SwiftUI
+  // controls immediately, even while another app is the active application.
+  override func acceptsFirstMouse(for event: NSEvent?) -> Bool { true }
+}
+
+struct NotchScreenLayout {
+  let edgeInset: CGFloat
+  let maximumHeight: CGFloat
+
+  init(availableHeight: CGFloat, preferredInset: CGFloat = 100) {
+    let height = max(1, availableHeight)
+    edgeInset = min(preferredInset, max(0, (height - 1) / 2))
+    maximumHeight = height - 2 * edgeInset
+  }
+}