fix: automatically convert Super notes to Markdown for the Plaintext Backups feature

packages/web/src/javascripts/Application/Device/DesktopManager.ts

@@ -1,3 +1,4 @@
+import { InvisibleSuperConverter } from '@/Components/SuperEditor/Tools/InvisibleMarkdownConverter'
 import {
   SNComponent,
   ComponentMutator,
@@ -38,6 +39,9 @@ export class DesktopManager
     private backups: BackupServiceInterface,
   ) {
     super(application, new InternalEventBus())
+
+    const markdownConverter = new InvisibleSuperConverter()
+    backups.setSuperConverter(markdownConverter)
   }
 
   async handleWatchedDirectoriesChanges(changes: DesktopWatchedDirectoriesChanges): Promise<void> {

packages/web/src/javascripts/Components/SuperEditor/SuperNoteConverter.tsx

@@ -6,7 +6,7 @@ import Icon from '../Icon/Icon'
 import Modal, { ModalAction } from '../Modal/Modal'
 import { EditorMenuItem } from '../NotesOptions/EditorMenuItem'
 import { NoteViewController } from '../NoteView/Controller/NoteViewController'
-import { exportSuperNote } from './SuperNoteExporter'
+import { InvisibleSuperConverter } from './Tools/InvisibleMarkdownConverter'
 
 const SuperNoteConverter = ({
   note,
@@ -47,7 +47,7 @@ const SuperNoteConverter = ({
       return note.text
     }
 
-    return exportSuperNote(note, format)
+    return new InvisibleSuperConverter().convertString(note.text, format)
   }, [format, note])
 
   const componentViewer = useMemo(() => {

packages/web/src/javascripts/Components/SuperEditor/SuperNoteExporter.ts

@@ -1,43 +0,0 @@
-import { createHeadlessEditor } from '@lexical/headless'
-import { $convertToMarkdownString } from '@lexical/markdown'
-import { MarkdownTransformers } from './MarkdownTransformers'
-import { $generateHtmlFromNodes } from '@lexical/html'
-import { BlockEditorNodes } from './Lexical/Nodes/AllNodes'
-import BlocksEditorTheme from './Lexical/Theme/Theme'
-import { SNNote } from '@standardnotes/models'
-
-export const exportSuperNote = (note: SNNote, format: 'txt' | 'md' | 'html' | 'json') => {
-  const headlessEditor = createHeadlessEditor({
-    namespace: 'BlocksEditor',
-    theme: BlocksEditorTheme,
-    editable: false,
-    onError: (error: Error) => console.error(error),
-    nodes: [...BlockEditorNodes],
-  })
-
-  headlessEditor.setEditorState(headlessEditor.parseEditorState(note.text))
-
-  let content: string | undefined
-
-  headlessEditor.update(() => {
-    switch (format) {
-      case 'txt':
-      case 'md':
-        content = $convertToMarkdownString(MarkdownTransformers)
-        break
-      case 'html':
-        content = $generateHtmlFromNodes(headlessEditor)
-        break
-      case 'json':
-      default:
-        content = note.text
-        break
-    }
-  })
-
-  if (!content) {
-    throw new Error('Could not export note')
-  }
-
-  return content
-}

packages/web/src/javascripts/Components/SuperEditor/Tools/InvisibleMarkdownConverter.tsx

@@ -0,0 +1,57 @@
+import { createHeadlessEditor } from '@lexical/headless'
+import { $convertToMarkdownString } from '@lexical/markdown'
+import { SuperConverterServiceInterface } from '@standardnotes/snjs'
+import { LexicalEditor } from 'lexical'
+import BlocksEditorTheme from '../Lexical/Theme/Theme'
+import { BlockEditorNodes } from '../Lexical/Nodes/AllNodes'
+import { MarkdownTransformers } from '../MarkdownTransformers'
+import { $generateHtmlFromNodes } from '@lexical/html'
+
+export class InvisibleSuperConverter implements SuperConverterServiceInterface {
+  private editor: LexicalEditor
+
+  constructor() {
+    this.editor = createHeadlessEditor({
+      namespace: 'BlocksEditor',
+      theme: BlocksEditorTheme,
+      editable: false,
+      onError: (error: Error) => console.error(error),
+      nodes: [...BlockEditorNodes],
+    })
+  }
+
+  convertString(superString: string, format: 'txt' | 'md' | 'html' | 'json'): string {
+    if (superString.length === 0) {
+      return superString
+    }
+
+    this.editor.setEditorState(this.editor.parseEditorState(superString))
+
+    let content: string | undefined
+
+    this.editor.update(
+      () => {
+        switch (format) {
+          case 'txt':
+          case 'md':
+            content = $convertToMarkdownString(MarkdownTransformers)
+            break
+          case 'html':
+            content = $generateHtmlFromNodes(this.editor)
+            break
+          case 'json':
+          default:
+            content = superString
+            break
+        }
+      },
+      { discrete: true },
+    )
+
+    if (!content) {
+      throw new Error('Could not export note')
+    }
+
+    return content
+  }
+}

packages/web/src/javascripts/Utils/NoteExportUtils.ts

@@ -1,5 +1,5 @@
 import { WebApplication } from '@/Application/Application'
-import { exportSuperNote } from '@/Components/SuperEditor/SuperNoteExporter'
+import { InvisibleSuperConverter } from '@/Components/SuperEditor/Tools/InvisibleMarkdownConverter'
 import { NoteType, PrefKey, SNNote } from '@standardnotes/snjs'
 
 export const getNoteFormat = (application: WebApplication, note: SNNote) => {
@@ -38,7 +38,8 @@ export const getNoteBlob = (application: WebApplication, note: SNNote) => {
       type = 'text/plain'
       break
   }
-  const content = note.noteType === NoteType.Super ? exportSuperNote(note, format) : note.text
+  const content =
+    note.noteType === NoteType.Super ? new InvisibleSuperConverter().convertString(note.text, format) : note.text
   const blob = new Blob([content], {
     type,
   })