let canvas = UIHostingController(rootView: Canvas())
        navigationController?.pushViewController(canvas, animated: true)
//        performSegue(withIdentifier: "toCanvasView", sender: self)

// MARK: -

struct Canvas: View {
    @State var hideExceptPaper = true
    var delegateBridge: DelegateBridgeObject!
   
    
    init(drawing: PKDrawing = PKDrawing()) {
        defer {
            delegateBridge = DelegateBridgeObject(toolPicker: toolPicker, hideExceptPaper: $hideExceptPaper)
        }
    }

    init(_ state: Binding<Bool>) {
        _selected = state
    }

 Button("Delete", role: .destructive, action: delete)

struct NotesGrid_Previews: PreviewProvider {
    static var previews: some View {
        let image = UIImage(systemName: "pencil.and.outline")!
        let data = image.pngData()!
        let drawing = try! PKDrawing(data: data) // 変換できない
        
        NotesGrid(drawings: [drawing])
    }
}

let scrollToBottomButton = Image(systemName: "arrow.down.circle")

var body: some View {
        ZStack {
// ……
            VStack {
                Spacer()
                HStack {
                    Spacer()
                    scrollToBottomButton
                        .resizable()
                        .frame(width: 200.0, height: 200.0)
                        .padding()
                }
            }
        }
    }

import SwiftUI

@main
struct PiecesOfPaperApp: App {
    @State private var shouldShowPurple = false
    
    var body: some Scene {
        WindowGroup {
            NavigationLink(
                destination: NotesGrid(),
                isActive: $shouldShowPurple) {
                    Canvas()
                }
                .onAppear {
                    shouldShowPurple = true
                }
        }
    }
}

Button(action: { open(drawing: viewModel.drawings[index]) }) {

    func open(drawing: PKDrawing) {
        Router.shared.toggleStateValue()
        Router.shared.updateDrawing(drawing: drawing)
    }

init(drawing: PKDrawing = PKDrawing()) {
        delegateBridge = DelegateBridgeObject(toolPicker: toolPicker, canvas: self)
// Variable 'self.delegateBridge' used before being initialized

    init(drawing: PKDrawing = PKDrawing()) {
        delegateBridge = DelegateBridgeObject(toolPicker: toolPicker)
        delegateBridge.canvas = self

PlayButton(isPlaying: Binding.constant(true))

func save(drawing: PKDrawing) {
        let id = Date().description
        let path = iCloudURL.appendingPathComponent(id + ".png")
        let png = drawing.image(from: drawing.bounds, scale: UIScreen.main.scale).pngData()
        try! png?.write(to: path)
    }

let png = drawing.image(from: drawing.bounds, scale: UIScreen.main.scale).pngData()

final class NotesViewModel: ObservableObject {
    @Published var drawings = [PKDrawing]()
    var temp = [PKDrawing]()
    
    init() {
        let allFileNames = try! FileManager.default.contentsOfDirectory(atPath: FilePath.iCloudURL.path)
        let drawingFileNames = allFileNames.filter { $0.hasSuffix(".drawing") }.sorted(by: <)
        
        let dispatchGroup = DispatchGroup()
        let dispatchQueue = DispatchQueue(label: "queue")
        
        drawingFileNames.forEach { filename in
            dispatchGroup.enter()
            dispatchQueue.async(group: dispatchGroup) { [weak self] in
                self?.asyncTemp(filename: filename) { drawing in
                    defer { dispatchGroup.leave() }
                    DispatchQueue.main.async {
                        self?.temp.append(drawing)
                    }
                }
            }
        }
        
        dispatchGroup.notify(queue: .main) {
            self.drawings = self.temp
        }
    }
    
    func asyncTemp(filename: String, comp: @escaping (PKDrawing) -> Void) {
        DispatchQueue.global().async {
            let url = FilePath.iCloudURL.appendingPathComponent(filename)
            guard FileManager.default.fileExists(atPath: url.path) else { return }
            let document = NoteDocument(fileURL: url)
            document.open() { success in
                if success {
                    guard let data = document.drawingData,
                          let drawing = try? PKDrawing(data: data) else { return }
                    comp(drawing)
                } else {
                    fatalError("could not open document")
                }
            }
        }
    }

    init(drawing: PKDrawing) {
        delegateBridge = CanvasDelegateBridgeObject(toolPicker: toolPicker)
        delegateBridge.canvas = self
        canvasView.delegate = delegateBridge
        if !drawing.strokes.isEmpty {
            canvasView.drawing = drawing
        }
        addPencilInteraction()
    }

struct Condition {
    enum sortOrder {
        case .ascending, .desending
    }

    enum sortBy {
        // プロパティ
    }

    enum filterBy {
        // tag名
    }
}

Image(uiImage: noteDocument.drawing.image(from: noteDocument.drawing.bounds, scale: 1.0))
                .resizable()
                .scaledToFit()
                .frame(width: 250.0, height: 190.0)
                .background(Color(UIColor.secondarySystemBackground))
                .shadow(radius: 5.0)
        }

private var noteDocuments = [NoteDocument]() {
        didSet {
            if counter <= noteDocuments.count {
                DispatchQueue.main.async { [weak self] in
                    guard let self = self else { return }
                    self.publishedNoteDocuments = self.noteDocuments.sorted { $0.entity.updatedDate < $1.entity.updatedDate }
                    self.isLoaded = true
                }
                noteDocuments.removeAll()
                counter = 0
            }
        }
    }

    private var noteDocuments = [NoteDocument]() {
        didSet {
            if counter <= noteDocuments.count {
                DispatchQueue.main.async { [weak self] in
                    guard let self = self else { return }
                    self.publishedNoteDocuments = self.noteDocuments.sorted { $0.entity.updatedDate < $1.entity.updatedDate }
                    self.isLoaded = true
                    self.noteDocuments.removeAll()
                    self.counter = 0
                }
            }
        }
    }

@main
struct PiecesOfPaperApp: App {
    @State var isAppLaunch = true
    @State var isShowCanvas = false
    @State var noteDocument: NoteDocument?

    @StateObject var inboxNoteViewModel = NotesViewModel(targetDirectory: .inbox)
    @StateObject var allNoteViewModel = NotesViewModel(targetDirectory: .all)
    @StateObject var archivedNoteViewModel = NotesViewModel(targetDirectory: .archived)

    var body: some Scene {
        WindowGroup {
            NavigationView {
                SideBarList(isAppLaunch: $isAppLaunch)
                    .environmentObject(inboxNoteViewModel)
                    .environmentObject(allNoteViewModel)
                    .environmentObject(archivedNoteViewModel)
            }

struct SideBarList: View {
    @Binding var isAppLaunch: Bool
    @EnvironmentObject var inboxNoteViewModel: NotesViewModel
    @EnvironmentObject var allNoteViewModel: NotesViewModel
    @EnvironmentObject var archivedNoteViewModel: NotesViewModel

@main
struct PiecesOfPaperApp: App {
    @State var isAppLaunch = true
    @State var isShowCanvas = false
    @State var isShowTagList = false
    @State var noteDocument: NoteDocument?
    @State var taggingNoteDocument: NoteDocument?

    var body: some Scene {
        WindowGroup {
            if taggingNoteDocument != nil {
//                Text("Happy")
                TagList(noteDocument: taggingNoteDocument)
            } else {
                NavigationView {
                    SideBarList(isAppLaunch: $isAppLaunch)
                }
                .fullScreenCover(isPresented: $isShowCanvas) {
                    NavigationView {
                        Canvas(noteDocument: noteDocument)
                    }
                }
                .sheet(isPresented: $isShowTagList) {
                    TagList(noteDocument: taggingNoteDocument)
                }
                .onAppear {
                    guard isAppLaunch else { return }
                    CanvasRouter.shared.bind(isShowCanvas: $isShowCanvas, noteDocument: $noteDocument)
                    CanvasRouter.shared.openNewCanvas()
                    TagListRouter.shared.bind(isShowTagList: $isShowTagList, taggingNoteDocument: $taggingNoteDocument)
                    DrawingsPlistConverter.convert()
                    isAppLaunch = false
                }
            }
        }
    }
}

final class TagListToNoteViewModel: ObservableObject {
…
    @Published var noteDocument: NoteDocument?
…
    func add(tagName: String, noteDocument: NoteDocument) {
        noteDocument.entity.tags.append(tagName)
        save(noteDocument: noteDocument)
    }

Group {
                HStack {
                    Image(systemName: "plus.circle")
                    Text("Add a tag")
                    Spacer()
                }
                .padding(.horizontal)
                TagHStack(tags: viewModel.nonFilteringTag, action: viewModel.add)
                    .padding(.horizontal)
            }
            .background(Color.gray)

            .background(Color.gray.opacity(0.2))
            .padding()

            .toolbar {
                ToolbarItemGroup {
                    Button(action: { isShowActivityView.toggle() }) {
                        Image(systemName: "square.and.arrow.up")
                    }
                    Button(action: close) {
                        Image(systemName: "tray.full")
                    }
                }
            }

    var objectWillChange = ObjectWillChangePublisher()
    var publishedNoteDocuments = [NoteDocument]()
    var isLoaded = false
    var isListConditionSheet = false {
        didSet {
            objectWillChange.send()
        }
    }

// NG: noteDocuments = Array(noteDocuments.drop { $0.entity.id == document.entity.id })
noteDocuments = Array(noteDocuments.filter { $0.entity.id != document.entity.id })

Swift/ContiguousArrayBuffer.swift:580: Fatal error: Index out of range

    @State var noteDocument: NoteDocument?
…
        .onChange(of: noteDocument) { document in
            canvasViewModel.document = document
        }

struct PiecesOfPaperApp: App {
    @StateObject var canvasViewModel = CanvasViewModel()
    @State var noteDocument: NoteDocument? // <-もはや不要
…
                    CanvasRouter.shared.bind(isShowCanvas: $isShowCanvas, noteDocument: $canvasViewModel.document)

toolPicker.showsDrawingPolicyControls = false

extension CanvasDelegateBridgeObject: PKCanvasViewDelegate {
    func canvasViewDrawingDidChange(_ canvasView: PKCanvasView) {
        updateContentSizeIfNeeded(canvasView)
        
        guard UserPreference().enabledAutoSave else { return }
        delegate?.save(drawing: canvasView.drawing)
    }
    
    private func updateContentSizeIfNeeded(_ canvasView: PKCanvasView) {
        guard !canvasView.drawing.bounds.isNull else { return }
        canvasView.contentSize = CGSize(width: canvasView.drawing.bounds.width * 1.2, height: canvasView.drawing.bounds.height * 1.2)
    }
}

    var body: some View {
        LazyVGrid(columns: [gridItem]) {
            ForEach((0..<viewModel.publishedNoteDocuments.count), id: \.self) { index in
                VStack {

// publish() <- crash: Swift/ContiguousArrayBuffer.swift:580: Fatal error: Index out of range
update()

.contentShape(RoundedRectangle(cornerRadius: 20)) 

.onAppear {
    guard viewModel.isAppLaunch else { return }
    defer {
        viewModel.isAppLaunch = false
    }

    CanvasRouter.shared.bind(isShowCanvas: $viewModel.isShowCanvas, noteDocument: $canvasViewModel.document)
    // I thought this can work, but SwiftUI cannot pass the document data...
    TagListRouter.shared.bind(isShowTagList: $viewModel.isShowTagList)
    viewModel.hasDrawingPlist = DrawingsPlistConverter.hasDrawingsPlist
    DrawingsPlistConverter.convert()

    guard didShowOnboarding else {
        viewModel.showOnboarding = true
        return
    }

    guard !UserPreference().shouldGrantiCloud else {
        viewModel.iCloudDenying = true
        return
    }

    CanvasRouter.shared.openNewCanvas()
}

    override func traitCollectionDidChange(_ previousTraitCollection: UITraitCollection?) {
        if previousTraitCollection?.userInterfaceStyle != traitCollection.userInterfaceStyle {
            reload()
        }
    }

    @Environment(\.colorScheme) private var colorScheme: ColorScheme
    private var image: UIImage {
        return noteDocument.entity.drawing.image(from: noteDocument.entity.drawing.bounds, scale: 1.0)
    }