move Peered to implementation directory

Implementation/Peered/NoteEditor/ManageMembersView.swift

@@ -0,0 +1,28 @@
+//
+//  ManageMembersView.swift
+//  Peered
+//
+//  Created by Oskar Chybowski on 06/10/2025.
+//
+import SwiftUI
+
+struct ManageMembersView: View {
+	@Bindable var noteAdvertiser: NoteEditingSessionServer
+	let noteTitle: String
+	@Binding var noteContent: String
+	
+	var body: some View {
+		List(noteAdvertiser.visiblePeers) { peer in
+			HStack {
+				Text(peer.id)
+				
+				Spacer()
+				
+					PeerStateButton(peerState: peer.state) {
+						noteAdvertiser.invite(peer: peer, to: .init(title: noteTitle, noteSnapshot: noteContent))
+					}
+			}
+		}
+		.navigationTitle("Visible users")
+	}
+}

Implementation/Peered/NoteEditor/NoteEditingSessionServer.swift

@@ -0,0 +1,124 @@
+import MultipeerConnectivity
+import Foundation
+import Combine
+
+struct OwnPeer {
+	let peer: MCPeerID
+	
+	static var fallback: Self { Self(peer: .init(displayName: "fallback_user")) }
+}
+
+struct Peer: Identifiable {
+	enum ConnectionState {
+		case available
+		case joined
+		case rejected
+		case invitationPending
+	}
+	
+	var id: String {
+		mcPeer.displayName
+	}
+	let mcPeer: MCPeerID
+	var state: ConnectionState
+}
+
+@Observable
+final class NoteEditingSessionServer: NSObject {
+	private let session: MCSession
+	private let browser: MCNearbyServiceBrowser
+	private let ownPeer: OwnPeer
+	
+	var visiblePeers: [Peer] = []
+	let noteChangesEmitter = PassthroughSubject<String, Never>()
+	
+	init(peer: OwnPeer) {
+		ownPeer = peer
+		browser = .init(peer: peer.peer, serviceType: "peered")
+		session = .init(peer: peer.peer)
+		super.init()
+		browser.delegate = self
+		session.delegate = self
+	}
+	
+	func startServer() {
+		browser.startBrowsingForPeers()
+	}
+	
+	func stopServer() {
+		browser.stopBrowsingForPeers()
+	}
+	
+	func invite(peer: Peer, to note: NoteInvitation.NoteContent) {
+		guard peer.state == .available else { return }
+		browser.invitePeer(
+			peer.mcPeer,
+			to: session,
+			withContext: try! JSONEncoder().encode(note),
+			timeout: 5
+		)
+		
+		let idxToUpdate = visiblePeers.firstIndex(where: { $0.mcPeer == peer.mcPeer })!
+		visiblePeers[idxToUpdate].state = .invitationPending
+	}
+}
+
+extension NoteEditingSessionServer: MCNearbyServiceBrowserDelegate {
+	func browser(
+		_ browser: MCNearbyServiceBrowser,
+		foundPeer peerID: MCPeerID,
+		withDiscoveryInfo info: [String : String]?
+	) {
+		guard !visiblePeers.contains(where: { $0.mcPeer == peerID }) && peerID.displayName != ownPeer.peer.displayName else { return }
+		let newPeer = Peer(mcPeer: peerID, state: .available)
+		visiblePeers.append(newPeer)
+	}
+	
+	func browser(_ browser: MCNearbyServiceBrowser, lostPeer peerID: MCPeerID) {
+		guard let peerIdx = visiblePeers.firstIndex(where: { $0.mcPeer == peerID }) else { return }
+		visiblePeers.remove(at: peerIdx)
+	}
+}
+
+extension NoteEditingSessionServer: MCSessionDelegate {
+	func session(
+		_ session: MCSession,
+		peer peerID: MCPeerID,
+		didChange state: MCSessionState
+	) {
+		
+	}
+	
+	func session(
+		_ session: MCSession,
+		didReceive stream: InputStream,
+		withName streamName: String,
+		fromPeer peerID: MCPeerID
+	) {
+		
+	}
+	
+	func session(
+		_ session: MCSession,
+		didStartReceivingResourceWithName resourceName: String,
+		fromPeer peerID: MCPeerID,
+		with progress: Progress
+	) {
+		
+	}
+	
+	func session(
+		_ session: MCSession,
+		didFinishReceivingResourceWithName resourceName: String,
+		fromPeer peerID: MCPeerID,
+		at localURL: URL?,
+		withError error: (any Error)?
+	) {
+		
+	}
+	
+	func session(_ session: MCSession, didReceive data: Data, fromPeer peerID: MCPeerID) {
+		guard let note = String(data: data, encoding: .utf8) else { fatalError() }
+		noteChangesEmitter.send(note)
+	}
+}

Implementation/Peered/NoteEditor/NoteEditorScreen.swift

@@ -0,0 +1,61 @@
+//
+//  NoteEditorScreen.swift
+//  Peered
+//
+//  Created by Oskar Chybowski on 25/09/2025.
+//
+
+import SwiftUI
+import MultipeerConnectivity
+
+struct NoteEditorScreen: View {
+	let note: Note
+	@State private var noteAdvertiser: NoteEditingSessionServer
+	@State private var noteContent: String = ""
+	@State private var timer = Timer.publish(every: 5, on: .current, in: .common)
+		.autoconnect()
+	@State private var showManageMembers = false
+	
+	init(note: Note, peer: OwnPeer) {
+		self.note = note
+		self._noteAdvertiser = .init(initialValue: .init(peer: peer))
+	}
+	
+	var body: some View {
+		TextEditor(text: $noteContent)
+			.toolbar {
+				ToolbarItem(placement: .primaryAction) {
+					Button("Manage members") {
+						showManageMembers = true
+					}
+				}
+			}
+			.sheet(isPresented: $showManageMembers) {
+				NavigationStack {
+					ManageMembersView(
+						noteAdvertiser: noteAdvertiser,
+						noteTitle: note.name,
+						noteContent: $noteContent
+					)
+				}
+			}
+			.onReceive(noteAdvertiser.noteChangesEmitter) { updatedNote in
+				self.noteContent = updatedNote
+			}
+			.onAppear {
+				noteContent = try! String(contentsOf: note.path, encoding: .utf8)
+				noteAdvertiser.startServer()
+			}
+			.onDisappear {
+				noteAdvertiser.stopServer()
+				saveNote()
+			}
+			.onReceive(timer) { _ in
+				saveNote()
+			}
+	}
+	
+	func saveNote() {
+		try! noteContent.write(to: note.path, atomically: true, encoding: .utf8)
+	}
+}

Implementation/Peered/NoteEditor/PeerStateButton.swift

@@ -0,0 +1,26 @@
+//
+//  PeerStateButton.swift
+//  Peered
+//
+//  Created by Oskar Chybowski on 06/10/2025.
+//
+
+import SwiftUI
+
+struct PeerStateButton: View {
+	let peerState: Peer.ConnectionState
+	let onTap: () -> Void
+	
+	var body: some View {
+		switch peerState {
+		case .available:
+			Button("Invite", action: onTap)
+		case .joined:
+			Text("Joined")
+		case .rejected:
+			Text("Rejected")
+		case .invitationPending:
+			Text("Invitation pending")
+		}
+	}
+}

Implementation/Peered/NoteEditor/SharedNoteEditor.swift

@@ -0,0 +1,48 @@
+//
+//  SharedNoteEditor.swift
+//  Peered
+//
+//  Created by Oskar Chybowski on 07/10/2025.
+//
+import SwiftUI
+
+struct SharedNoteEditor: View {
+	@State var note: String?
+	@State var sendTask: Task<Void, Never>?
+	@State var invitation: NoteInvitation
+	@Bindable var noteClient: NoteEditingSessionClient
+	
+	init(
+		invitation: NoteInvitation,
+		noteClient: NoteEditingSessionClient
+	) {
+		self._invitation = .init(initialValue: invitation)
+		self._noteClient = .init(noteClient)
+	}
+	
+	var body: some View {
+		ZStack {
+		if let note = Binding($note) {
+			TextEditor(text: note)
+		} else {
+			ProgressView {
+				Text("Fetching note...")
+			}
+		}
+		}
+		.onChange(of: note) { _, newValue in
+			sendTask?.cancel()
+			sendTask = Task {
+				try? await Task.sleep(nanoseconds: 500000000)
+				guard let note else { return }
+				DispatchQueue.main.async {
+					noteClient.send(note: note, to: invitation.invitatorID)
+				}
+			}
+		}
+		.onAppear {
+			invitation.accept()
+			note = invitation.note.noteSnapshot
+		}
+	}
+}