Improve editor fidelity

docmostly/Features/Editor/NativeEditorCommand+Behavior.swift

@@ -25,14 +25,168 @@ extension NativeEditorCommand {
     func matchPriority(query: String) -> Int? {
         guard query.isEmpty == false else { return 0 }
 
-        if title.localizedStandardContains(query) || rawValue.localizedStandardContains(query) {
+        if title.localizedStandardContainsAtWordStart(query) {
             return 0
         }
 
-        if subtitle.localizedStandardContains(query) {
+        if searchTerms.contains(where: { $0.localizedStandardContains(query) }) {
             return 1
         }
 
+        if title.fuzzyMatchesSlashCommandQuery(query) {
+            return 2
+        }
+
+        if rawValue.localizedStandardContains(query) {
+            return 3
+        }
+
+        if subtitle.localizedStandardContains(query) {
+            return 3
+        }
+
+        if title.localizedStandardContains(query) {
+            return 4
+        }
+
         return nil
     }
+
+    private var searchTerms: [String] {
+        switch self {
+        case .paragraph:
+            ["p", "text", "paragraph"]
+        case .heading1:
+            ["title", "big", "large", "h1"]
+        case .heading2:
+            ["subtitle", "medium", "h2"]
+        case .heading3:
+            ["subtitle", "small", "h3"]
+        case .bulletedList:
+            ["unordered", "point", "list"]
+        case .numberedList:
+            ["numbered", "ordered", "list", "ol"]
+        case .todoList:
+            ["todo", "task", "list", "check", "checkbox"]
+        case .quote:
+            ["blockquote", "quotes"]
+        case .codeBlock:
+            ["codeblock", "snippet"]
+        case .image:
+            ["photo", "picture", "media", "file", "attachment"]
+        case .video:
+            ["mp4", "media", "file", "attachment"]
+        case .audio:
+            ["music", "sound", "mp3", "media", "file", "attachment"]
+        case .pdf:
+            ["document", "embed"]
+        case .fileAttachment:
+            ["upload", "csv", "zip"]
+        case .table:
+            ["rows", "columns"]
+        case .baseInline:
+            ["base", "database", "grid", "spreadsheet"]
+        case .kanban:
+            ["board", "cards", "status", "task", "database"]
+        case .callout:
+            ["notice", "panel", "info", "warning", "success", "error", "danger"]
+        case .details:
+            ["collapsible", "block", "toggle", "details", "expand"]
+        case .mathInline:
+            ["math", "inline", "mathinline", "inlinemath", "inline math", "equation", "katex", "latex", "tex"]
+        case .pageBreak:
+            ["page", "break", "pagebreak", "print"]
+        case .divider:
+            ["horizontal rule", "hr"]
+        case .columns:
+            ["layout", "split", "side"]
+        case .columns3:
+            ["layout", "split", "triple"]
+        case .columns4, .columns5:
+            ["layout", "split"]
+        case .subpages:
+            ["child", "children", "nested", "hierarchy", "toc"]
+        case .syncedBlock:
+            ["sync", "excerpt", "transclusion", "reusable", "snippet"]
+        case .embed:
+            ["url", "external", "iframe"]
+        case .iframeEmbed:
+            ["iframe"]
+        case .airtableEmbed:
+            ["airtable"]
+        case .loomEmbed:
+            ["loom"]
+        case .figmaEmbed:
+            ["figma"]
+        case .typeformEmbed:
+            ["typeform"]
+        case .miroEmbed:
+            ["miro"]
+        case .youtubeEmbed:
+            ["youtube", "yt", "media", "video"]
+        case .vimeoEmbed:
+            ["vimeo"]
+        case .framerEmbed:
+            ["framer"]
+        case .googleDriveEmbed:
+            ["google drive", "gdrive"]
+        case .googleSheetsEmbed:
+            ["google sheets", "gsheets"]
+        case .mathBlock:
+            ["math", "block", "mathblock", "block math", "equation", "katex", "latex", "tex"]
+        case .mermaid:
+            ["diagrams", "chart", "uml"]
+        case .drawio:
+            ["diagrams", "charts", "uml", "whiteboard"]
+        case .excalidraw:
+            ["diagrams", "draw", "sketch", "whiteboard"]
+        case .date:
+            ["today"]
+        case .time:
+            ["now", "clock"]
+        case .status:
+            ["badge", "label", "lozenge"]
+        case .emoji:
+            ["icon", "smiley", "emoticon", "symbol", "reaction"]
+        }
+    }
+}
+
+private extension String {
+    func localizedStandardContainsAtWordStart(_ query: String) -> Bool {
+        guard query.isEmpty == false else { return true }
+
+        var searchStart = startIndex
+        while searchStart < endIndex {
+            let searchText = self[searchStart..<endIndex]
+            guard let range = searchText.localizedStandardRange(of: query) else { return false }
+            if range.lowerBound == startIndex {
+                return true
+            }
+
+            let previousIndex = index(before: range.lowerBound)
+            let previousCharacter = self[previousIndex]
+            if previousCharacter.isWhitespace || previousCharacter.isPunctuation {
+                return true
+            }
+            searchStart = range.upperBound
+        }
+
+        return false
+    }
+
+    func fuzzyMatchesSlashCommandQuery(_ query: String) -> Bool {
+        let normalizedQuery = query.lowercased()
+        guard normalizedQuery.isEmpty == false else { return true }
+
+        var queryIndex = normalizedQuery.startIndex
+        for character in lowercased() where character == normalizedQuery[queryIndex] {
+            queryIndex = normalizedQuery.index(after: queryIndex)
+            if queryIndex == normalizedQuery.endIndex {
+                return true
+            }
+        }
+
+        return false
+    }
 }

docmostly/Features/Editor/NativeEditorCommand+RichBlocks.swift

@@ -108,18 +108,20 @@ extension NativeEditorCommand {
     }
 
     var defaultTableRows: [NativeEditorTableRow] {
-        [
-            NativeEditorTableRow(cells: [
-                NativeEditorTableCell(plainText: "Column 1", isHeader: true, backgroundColorName: nil),
-                NativeEditorTableCell(plainText: "Column 2", isHeader: true, backgroundColorName: nil)
-            ]),
-            NativeEditorTableRow(cells: [
-                NativeEditorTableCell(plainText: "", isHeader: false, backgroundColorName: nil),
-                NativeEditorTableCell(plainText: "", isHeader: false, backgroundColorName: nil)
-            ])
+        let columnCount = 3
+        return [
+            tableRow(columnCount: columnCount, isHeader: true),
+            tableRow(columnCount: columnCount, isHeader: false),
+            tableRow(columnCount: columnCount, isHeader: false)
         ]
     }
 
+    private func tableRow(columnCount: Int, isHeader: Bool) -> NativeEditorTableRow {
+        NativeEditorTableRow(cells: (0..<columnCount).map { _ in
+            NativeEditorTableCell(plainText: "", isHeader: isHeader, backgroundColorName: nil)
+        })
+    }
+
     private var baseBlock: NativeEditorBaseBlock {
         if case .base(let base) = blockKind {
             return base
@@ -129,9 +131,15 @@ extension NativeEditorCommand {
     }
 
     private var defaultSyncedBlockID: String {
-        "sync-\(UUID().uuidString)"
+        var generator = SystemRandomNumberGenerator()
+        return String((0..<Self.docmostNodeIDLength).map { _ in
+            Self.docmostNodeIDAlphabet.randomElement(using: &generator) ?? "a"
+        })
     }
 
+    private static let docmostNodeIDAlphabet = Array("abcdefghijklmnopqrstuvwxyz")
+    private static let docmostNodeIDLength = 12
+
     private func richBlock(id: UUID, kind: NativeEditorBlockKind, rawNode: ProseMirrorNode) -> NativeEditorBlock {
         NativeEditorBlock(
             id: id,
@@ -155,19 +163,16 @@ extension NativeEditorCommand {
     }
 
     private var tableNode: ProseMirrorNode {
-        ProseMirrorNode(type: "table", content: [
-            tableRowNode(cellType: "tableHeader", texts: ["Column 1", "Column 2"]),
-            tableRowNode(cellType: "tableCell", texts: ["", ""])
-        ])
+        ProseMirrorNode(type: "table", content: defaultTableRows.map(tableRowNode))
     }
 
-    private func tableRowNode(cellType: String, texts: [String]) -> ProseMirrorNode {
+    private func tableRowNode(from row: NativeEditorTableRow) -> ProseMirrorNode {
         ProseMirrorNode(
             type: "tableRow",
-            content: texts.map { text in
+            content: row.cells.map { cell in
                 ProseMirrorNode(
-                    type: cellType,
-                    content: [paragraphNode(text)]
+                    type: cell.isHeader ? "tableHeader" : "tableCell",
+                    content: [paragraphNode(cell.plainText)]
                 )
             }
         )

docmostly/Features/Editor/NativeEditorCommand.swift

@@ -104,33 +104,33 @@ enum NativeEditorCommand: String, CaseIterable, Identifiable {
     var title: String {
         switch self {
         case .paragraph:
-            "Paragraph"
+            "Text"
         case .heading1:
             "Heading 1"
         case .heading2:
             "Heading 2"
         case .heading3:
             "Heading 3"
         case .bulletedList:
-            "Bulleted List"
+            "Bullet list"
         case .numberedList:
-            "Numbered List"
+            "Numbered list"
         case .todoList:
-            "To-do List"
+            "To-do list"
         case .quote:
             "Quote"
         case .codeBlock:
-            "Code Block"
+            "Code"
         case .image:
             "Image"
         case .video:
             "Video"
         case .audio:
             "Audio"
         case .pdf:
-            "PDF"
+            "Embed PDF"
         case .fileAttachment:
-            "File"
+            "File attachment"
         case .table:
             "Table"
         case .baseInline:
@@ -140,11 +140,11 @@ enum NativeEditorCommand: String, CaseIterable, Identifiable {
         case .callout:
             "Callout"
         case .details:
-            "Details"
+            "Toggle block"
         case .mathInline:
-            "Math Inline"
+            "Math inline"
         case .pageBreak:
-            "Page Break"
+            "Page break"
         case .divider:
             "Divider"
         case .columns:
@@ -156,9 +156,9 @@ enum NativeEditorCommand: String, CaseIterable, Identifiable {
         case .columns5:
             "5 Columns"
         case .subpages:
-            "Subpages"
+            "Subpages (Child pages)"
         case .syncedBlock:
-            "Synced Block"
+            "Synced block"
         case .embed:
             "Embed"
         case .iframeEmbed:
@@ -184,13 +184,13 @@ enum NativeEditorCommand: String, CaseIterable, Identifiable {
         case .googleSheetsEmbed:
             "Google Sheets"
         case .mathBlock:
-            "Math Block"
+            "Math block"
         case .mermaid:
-            "Mermaid"
+            "Mermaid diagram"
         case .drawio:
-            "Draw.io"
+            "Draw.io (diagrams.net)"
         case .excalidraw:
-            "Excalidraw"
+            "Excalidraw (Whiteboard)"
         case .date:
             "Date"
         case .time:
@@ -229,9 +229,9 @@ enum NativeEditorCommand: String, CaseIterable, Identifiable {
         case .audio:
             "Audio placeholder"
         case .pdf:
-            "PDF placeholder"
+            "Upload and embed a PDF file"
         case .fileAttachment:
-            "File attachment placeholder"
+            "Upload any file from your device"
         case .table:
             "Two-column table"
         case .baseInline:
@@ -241,7 +241,7 @@ enum NativeEditorCommand: String, CaseIterable, Identifiable {
         case .callout:
             "Highlighted note"
         case .details:
-            "Collapsible detail section"
+            "Insert collapsible block"
         case .mathInline:
             "Inline equation"
         case .pageBreak:

docmostly/Features/Editor/NativeEditorDocument+Decoding.swift

@@ -16,13 +16,15 @@ nonisolated extension NativeEditorDocument {
     static func textBlock(kind: NativeEditorBlockKind, node: ProseMirrorNode) -> NativeEditorBlock {
         let inlineContent = inlineContent(from: node.content ?? [])
         let needsRawPreservation = inlineContent.contains(where: \.requiresRawPreservation)
+        let needsAttrPreservation = editableAttrsNeedRawPreservation(kind: kind, node: node)
+        let rawNode = needsRawPreservation || needsAttrPreservation ? node : nil
 
         return NativeEditorBlock(
             kind: kind,
             text: attributedText(from: inlineContent),
             alignment: NativeEditorTextAlignment(attrs: node.attrs),
             inlineContent: needsRawPreservation ? inlineContent : nil,
-            rawNode: needsRawPreservation ? node : nil
+            rawNode: rawNode
         )
     }
 
@@ -60,6 +62,25 @@ nonisolated extension NativeEditorDocument {
         }
     }
 
+    private static func editableAttrsNeedRawPreservation(
+        kind: NativeEditorBlockKind,
+        node: ProseMirrorNode
+    ) -> Bool {
+        guard let attrs = node.attrs, attrs.isEmpty == false else { return false }
+
+        let modeledKeys: Set<String>
+        switch kind {
+        case .paragraph:
+            modeledKeys = ["textAlign"]
+        case .heading:
+            modeledKeys = ["level", "textAlign"]
+        default:
+            return false
+        }
+
+        return attrs.keys.contains { modeledKeys.contains($0) == false }
+    }
+
     private static func editableBlocks(from node: ProseMirrorNode) -> [NativeEditorBlock]? {
         if let singleBlock = singleEditableBlock(from: node) {
             return [singleBlock]