diff --git a/src/components/atoms/ProgressBar.tsx b/src/components/atoms/ProgressBar.tsx
index 8045a1a53b..e2dbbea8e6 100644
--- a/src/components/atoms/ProgressBar.tsx
+++ b/src/components/atoms/ProgressBar.tsx
@@ -3,10 +3,11 @@ import styled from '../../lib/styled'
interface ProgressBarProps {
progress: number
+ className?: string
}
-const ProgressBar = ({ progress }: ProgressBarProps) => {
- return
+const ProgressBar = ({ progress, className }: ProgressBarProps) => {
+ return
}
const ProgressBarStyled = styled.div`
diff --git a/src/components/molecules/ExportProgressItem.tsx b/src/components/molecules/ExportProgressItem.tsx
new file mode 100644
index 0000000000..d0a29a0dd0
--- /dev/null
+++ b/src/components/molecules/ExportProgressItem.tsx
@@ -0,0 +1,587 @@
+import React, { useCallback, useRef, useState } from 'react'
+import ProgressBar from '../atoms/ProgressBar'
+import styled from '../../lib/styled/styled'
+import { border } from '../../lib/styled/styleFunctions'
+import { usePreferences } from '../../lib/preferences'
+import { usePreviewStyle } from '../../lib/preview'
+import { useToast } from '../../lib/toast'
+import {
+ getPathByName,
+ mkdir,
+ showOpenDialog,
+ writeFile,
+} from '../../lib/electronOnly'
+import {
+ convertNoteDocToMarkdownString,
+ convertNoteDocToPdfBuffer,
+ exportNoteAsHtmlFile,
+ getValidNoteTitle,
+} from '../../lib/exports'
+import { useTranslation } from 'react-i18next'
+import { useDb } from '../../lib/db'
+import { useEffectOnce, useSetState } from 'react-use'
+import {
+ AllDocsMap,
+ Attachment,
+ FolderDoc,
+ NoteDoc,
+ ObjectMap,
+} from '../../lib/db/types'
+import { entries, keys, values } from '../../lib/db/utils'
+import { join } from 'path'
+import { filenamify } from '../../lib/string'
+
+interface ExportProcedureData {
+ folderName: string
+ folderPathname: string
+ exportType: string
+ recursive: boolean
+ exportingStorage: boolean
+}
+
+interface ExportProgressItemProps {
+ storageId: string
+ exportSettings: ExportProcedureData
+ onFinish: () => void
+}
+
+interface ExportOperationState {
+ exportOperation: string
+ exportSubOperationTitle: string
+ exportSubOperationContent: string
+ exportProgressValue: number
+}
+
+const exportProgressMaxValue = 100
+function convertValueToPercentage(value: number) {
+ if (!Number.isFinite(value) || value < 0) {
+ throw new Error(`Value '${value}' cannot be converted to percentage.`)
+ }
+ return Math.floor(value * 100)
+}
+
+const ExportProgressItem = ({
+ storageId,
+ exportSettings,
+ onFinish,
+}: ExportProgressItemProps) => {
+ const { preferences } = usePreferences()
+ const includeFrontMatter = preferences['markdown.includeFrontMatter']
+ const { previewStyle } = usePreviewStyle()
+ const { pushMessage } = useToast()
+ const { t } = useTranslation()
+ const { storageMap } = useDb()
+
+ const [showExportProgress, setShowExportProgress] = useState(false)
+ const [exportErrors, setExportErrors] = useState([])
+ const [exportState, setExportState] = useSetState({
+ exportOperation: '',
+ exportSubOperationTitle: '',
+ exportSubOperationContent: '',
+ exportProgressValue: 0,
+ })
+ const canceledRef = useRef(false)
+
+ const [dialogIsOpen, setDialogIsOpen] = useState(false)
+ const openDialog = useCallback(async () => {
+ if (dialogIsOpen) {
+ return
+ }
+ setDialogIsOpen(true)
+ try {
+ const result = await showOpenDialog({
+ properties: ['openDirectory', 'createDirectory'],
+ buttonLabel: t('folder.select'),
+ defaultPath: getPathByName('home'),
+ })
+ if (result.canceled) {
+ return
+ }
+ if (result.filePaths == null) {
+ return
+ }
+
+ return result.filePaths[0]
+ } catch (error) {
+ throw error
+ } finally {
+ setDialogIsOpen(false)
+ }
+ }, [dialogIsOpen, t])
+
+ const resetExportingStates = useCallback(() => {
+ setShowExportProgress(false)
+ setExportState({
+ exportOperation: '',
+ exportSubOperationTitle: '',
+ exportSubOperationContent: '',
+ exportProgressValue: 0,
+ })
+ setExportErrors([])
+ }, [setExportState])
+
+ const addExportError = useCallback((error: string) => {
+ setExportErrors((state) => [...state, error])
+ }, [])
+
+ const cancelExporting = useCallback(() => {
+ canceledRef.current = true
+ resetExportingStates()
+ }, [resetExportingStates])
+
+ const isExportingCanceled = useCallback(() => {
+ return canceledRef.current
+ }, [])
+
+ const createExportDirectories = useCallback(
+ async (folderMap: ObjectMap, rootDir: string) => {
+ for (const folderPath of keys(folderMap)) {
+ if (isExportingCanceled()) {
+ return
+ }
+
+ if (folderPath == '/' && !exportSettings.exportingStorage) {
+ continue
+ }
+
+ if (!exportSettings.exportingStorage) {
+ if (
+ exportSettings.recursive &&
+ folderPath != exportSettings.folderPathname &&
+ !folderPath.startsWith(exportSettings.folderPathname + '/')
+ ) {
+ continue
+ }
+ if (
+ !exportSettings.recursive &&
+ folderPath != exportSettings.folderPathname
+ ) {
+ continue
+ }
+ }
+
+ const fullPath = join(
+ rootDir,
+ folderPath.substring(folderPath.indexOf(exportSettings.folderName))
+ )
+
+ setExportState({
+ exportSubOperationTitle: `Creating directory: ${fullPath.replace(
+ rootDir,
+ '.'
+ )}`,
+ })
+ await mkdir(fullPath)
+ }
+ },
+ [
+ exportSettings.exportingStorage,
+ exportSettings.folderName,
+ exportSettings.folderPathname,
+ exportSettings.recursive,
+ isExportingCanceled,
+ setExportState,
+ ]
+ )
+
+ const getNotesForExport = useCallback(
+ (noteMap: ObjectMap): NoteDoc[] => {
+ if (exportSettings.exportingStorage) {
+ return values(noteMap)
+ }
+
+ const notesToExport: NoteDoc[] = []
+ for (const [, noteDoc] of entries(noteMap)) {
+ if (noteDoc.trashed) {
+ continue
+ }
+ if (
+ exportSettings.recursive &&
+ noteDoc.folderPathname != exportSettings.folderPathname &&
+ !noteDoc.folderPathname.startsWith(
+ exportSettings.folderPathname + '/'
+ )
+ ) {
+ continue
+ }
+ if (
+ !exportSettings.recursive &&
+ noteDoc.folderPathname != exportSettings.folderPathname
+ ) {
+ continue
+ }
+
+ notesToExport.push(noteDoc)
+ }
+ return notesToExport
+ },
+ [
+ exportSettings.exportingStorage,
+ exportSettings.folderPathname,
+ exportSettings.recursive,
+ ]
+ )
+
+ const exportNotes = useCallback(
+ async (
+ noteMap: ObjectMap,
+ attachmentMap: ObjectMap,
+ rootDir: string
+ ): Promise => {
+ const notesToExport: NoteDoc[] = getNotesForExport(noteMap)
+
+ let exportingNoteIndex = 0
+ for (const noteDoc of notesToExport) {
+ if (isExportingCanceled()) {
+ return exportingNoteIndex
+ }
+
+ const noteExportFolder = exportSettings.recursive
+ ? noteDoc.folderPathname.substring(
+ exportSettings.folderPathname.indexOf(exportSettings.folderName)
+ )
+ : exportSettings.folderName
+
+ const exportNoteFilenameWithoutExtension = `${filenamify(
+ getValidNoteTitle(noteDoc)
+ )}`
+ const exportNotePathname = join(
+ join(rootDir, noteExportFolder),
+ `${exportNoteFilenameWithoutExtension}.${exportSettings.exportType}`
+ )
+ setExportState({
+ exportProgressValue: convertValueToPercentage(
+ exportingNoteIndex / notesToExport.length
+ ),
+ exportSubOperationTitle: `Exporting note: ${
+ noteDoc.title ? noteDoc.title : 'No title'
+ } (${exportingNoteIndex}/${notesToExport.length})`,
+ exportSubOperationContent: `Location: ${exportNotePathname.replace(
+ rootDir,
+ '.'
+ )}`,
+ })
+
+ switch (exportSettings.exportType) {
+ case 'html':
+ await exportNoteAsHtmlFile(
+ join(rootDir, noteExportFolder),
+ exportNoteFilenameWithoutExtension,
+ noteDoc as NoteDoc,
+ preferences['markdown.codeBlockTheme'],
+ preferences['general.theme'],
+ pushMessage,
+ attachmentMap,
+ previewStyle,
+ true
+ ).catch((err) => {
+ addExportError(
+ `Cannot export: '${exportNotePathname.substring(
+ exportNotePathname.lastIndexOf('/')
+ )}', reason: ${err}`
+ )
+ })
+ break
+ case 'md':
+ const mdString = await convertNoteDocToMarkdownString(
+ noteDoc as NoteDoc,
+ includeFrontMatter
+ )
+ try {
+ await writeFile(exportNotePathname, mdString)
+ } catch (err) {
+ addExportError(
+ `Cannot export: '${exportNotePathname.substring(
+ exportNotePathname.lastIndexOf('/')
+ )}', reason: ${err}`
+ )
+ }
+ break
+ case 'pdf':
+ default:
+ try {
+ const pdfBuffer = await convertNoteDocToPdfBuffer(
+ noteDoc as NoteDoc,
+ preferences['markdown.codeBlockTheme'],
+ preferences['general.theme'],
+ pushMessage,
+ attachmentMap,
+ previewStyle
+ )
+ await writeFile(exportNotePathname, pdfBuffer)
+ } catch (err) {
+ addExportError(
+ `Cannot export: '${exportNotePathname.substring(
+ exportNotePathname.lastIndexOf('/')
+ )}', reason: ${err}`
+ )
+ }
+ break
+ }
+ exportingNoteIndex++
+ }
+
+ return exportingNoteIndex
+ },
+ [
+ getNotesForExport,
+ isExportingCanceled,
+ exportSettings.recursive,
+ exportSettings.folderPathname,
+ exportSettings.folderName,
+ exportSettings.exportType,
+ setExportState,
+ preferences,
+ pushMessage,
+ previewStyle,
+ includeFrontMatter,
+ addExportError,
+ ]
+ )
+
+ const startExportingNotes = useCallback(async () => {
+ const savePathname = await openDialog()
+ if (!savePathname) {
+ return
+ }
+
+ const storage = storageMap[storageId]
+ if (!storage) {
+ pushMessage({
+ title: 'Cannot find storage',
+ description: 'Please check storage and try again later.',
+ })
+ console.warn('Storage ID cannot be found: ' + storageId)
+ return
+ }
+
+ setShowExportProgress(true)
+ try {
+ const rootDir = exportSettings.exportingStorage
+ ? join(savePathname, storage.name)
+ : savePathname
+ const allDocsMap: AllDocsMap = await storage.db.getAllDocsMap()
+ const { noteMap, folderMap } = allDocsMap
+
+ setExportState({ exportOperation: 'Creating directories' })
+ try {
+ if (exportSettings.recursive) {
+ await createExportDirectories(folderMap, rootDir)
+ } else {
+ await mkdir(join(rootDir, exportSettings.folderName))
+ }
+ } catch (err) {
+ addExportError('Cannot make directories: ' + err)
+ console.warn('Please check write access for destination directories: ')
+ }
+
+ if (exportErrors.length === 0) {
+ setExportState({ exportOperation: 'Exporting notes' })
+
+ try {
+ const exportedNotesCount = await exportNotes(
+ noteMap,
+ storage.attachmentMap,
+ rootDir
+ )
+ if (isExportingCanceled()) {
+ pushMessage({
+ title: 'Export canceled',
+ description: `Exported ${exportedNotesCount} notes.`,
+ })
+ } else {
+ pushMessage({
+ title: 'Export finished',
+ description: `Exported ${exportedNotesCount} notes successfully.`,
+ })
+ }
+ } catch (err) {
+ addExportError('Exporting notes error: ' + err)
+ console.warn('Unknown failure while exporting notes, reason: ' + err)
+ }
+ }
+
+ if (exportErrors.length > 0) {
+ pushMessage({
+ title: 'Export errors',
+ description: `Status: [${exportErrors.join(', ')}].`,
+ })
+ console.warn('Errors during export: ', exportErrors)
+ }
+ } catch (error) {
+ pushMessage({
+ title: 'Export failed',
+ description: 'Reason: ' + error,
+ })
+ console.warn('Export failed with: ', error)
+ console.warn('Errors during export: ', exportErrors)
+ }
+ }, [
+ openDialog,
+ storageMap,
+ storageId,
+ pushMessage,
+ exportSettings.exportingStorage,
+ exportSettings.recursive,
+ exportSettings.folderName,
+ setExportState,
+ exportErrors,
+ isExportingCanceled,
+ createExportDirectories,
+ addExportError,
+ exportNotes,
+ ])
+
+ useEffectOnce(() => {
+ startExportingNotes().finally(onFinish)
+ })
+
+ return (
+
+ {showExportProgress && (
+
+
+
+ {exportState.exportSubOperationTitle && (
+
+ )}
+ {exportState.exportSubOperationContent && (
+
+ )}
+
+
+
+
+
+
+ )}
+ {showExportProgress && }
+
+ )
+}
+
+const ExportInfoItem = styled.div`
+ margin-bottom: 1em;
+ max-width: 600px;
+`
+
+const OperationInfoItem = styled.div`
+ text-overflow: ellipsis;
+ white-space: nowrap;
+ overflow: hidden;
+ max-width: 750px;
+ &:before {
+ content: attr(content);
+ }
+`
+
+const SubOperationInfoItem = styled.div`
+ text-overflow: ellipsis;
+ white-space: nowrap;
+ overflow: hidden;
+ max-width: 750px;
+ word-wrap: break-word;
+
+ &:before {
+ content: attr(content);
+ }
+`
+
+const ProgressStatusContainer = styled.div`
+ display: flex;
+ justify-content: space-between;
+ flex-direction: row;
+ align-items: center;
+
+ & > .batchExportProgressStyle {
+ margin-right: 5px;
+ margin-top: 8px;
+ margin-bottom: 0;
+ }
+`
+
+const Button = styled.button`
+ align-self: flex-end;
+
+ background-color: black;
+ color: white;
+ height: 25px;
+ padding: 5px;
+ border-radius: 5px;
+ font-size: 14px;
+ cursor: pointer;
+ text-align: center;
+ border: none;
+
+ min-width: 60px;
+`
+
+const ProgressContainerItem = styled.div`
+ width: 600px;
+ position: absolute;
+ left: 50%;
+ margin-left: -240px;
+ margin-top: 300px;
+
+ background-color: ${({ theme }) => theme.navBackgroundColor};
+ max-width: 750px;
+ max-height: 480px;
+ z-index: 6002;
+ ${border};
+ border-radius: 10px;
+ padding: 10px;
+
+ progress[value] {
+ /* Reset the default appearance */
+ -webkit-appearance: none;
+ appearance: none;
+ height: 15px;
+ }
+
+ progress[value]::-webkit-progress-bar {
+ border-radius: 2px;
+ box-shadow: 0 2px 5px rgba(0, 0, 0, 0.25) inset;
+ }
+
+ progress[value]::-webkit-progress-value {
+ background-color: ${({ theme }) => theme.primaryButtonBackgroundColor};
+ border-radius: 2px;
+ }
+`
+
+const ExportProgressBarItem = styled.div`
+ z-index: 6000;
+ position: fixed;
+ top: 0;
+ left: 0;
+ bottom: 0;
+ right: 0;
+`
+
+const DimBackground = styled.div`
+ position: absolute;
+ z-index: 6001;
+ top: 0;
+ left: 0;
+ right: 0;
+ bottom: 0;
+ background-color: rgba(0, 0, 0, 0.4);
+`
+
+export default ExportProgressItem
diff --git a/src/components/molecules/FolderNavigatorItem.tsx b/src/components/molecules/FolderNavigatorItem.tsx
index b8fedd29a7..64a5f9c564 100644
--- a/src/components/molecules/FolderNavigatorItem.tsx
+++ b/src/components/molecules/FolderNavigatorItem.tsx
@@ -1,4 +1,4 @@
-import React, { useCallback, useMemo, MouseEvent } from 'react'
+import React, { useCallback, useMemo, MouseEvent, useState } from 'react'
import { useDb } from '../../lib/db'
import { useDialog, DialogIconTypes } from '../../lib/dialog'
import NavigatorItem from '../atoms/NavigatorItem'
@@ -16,6 +16,9 @@ import {
import NavigatorButton from '../atoms/NavigatorButton'
import { useRouter } from '../../lib/router'
import { openContextMenu } from '../../lib/electronOnly'
+import { MenuItemConstructorOptions } from 'electron'
+import ExportProgressItem from './ExportProgressItem'
+import { getExportAsMenuItems } from '../../lib/exports'
interface FolderNavigatorItemProps {
active: boolean
@@ -109,6 +112,62 @@ const FolderNavigatorItem = ({
showPromptToRenameFolder(folderPathname)
}, [folderPathname, showPromptToRenameFolder])
+ const [exportSettings, setExportSettings] = useState({
+ folderName: '',
+ folderPathname: '',
+ exportType: '',
+ recursive: false,
+ exportingStorage: false,
+ })
+
+ const [exportProcedureRunning, setExportProcedure] = useState(false)
+
+ const startFolderExport = useCallback(
+ (folderName, folderPathname, exportType, recursive) => {
+ setExportSettings({
+ folderName: folderName,
+ folderPathname: folderPathname,
+ exportType: exportType,
+ recursive: recursive,
+ exportingStorage: false,
+ })
+ setExportProcedure(true)
+ },
+ []
+ )
+
+ const getExportMenu = useCallback(
+ (menuLabel: string): MenuItemConstructorOptions => {
+ return {
+ type: 'submenu',
+ label: menuLabel,
+ submenu: [
+ {
+ type: 'submenu',
+ label: 'Recursive',
+ submenu: getExportAsMenuItems(
+ folderName,
+ folderPathname,
+ true,
+ startFolderExport
+ ),
+ },
+ {
+ type: 'submenu',
+ label: 'Non-recursive',
+ submenu: getExportAsMenuItems(
+ folderName,
+ folderPathname,
+ false,
+ startFolderExport
+ ),
+ },
+ ],
+ }
+ },
+ [folderName, folderPathname, startFolderExport]
+ )
+
const openFolderContextMenu = useCallback(
(event: React.MouseEvent) => {
event.preventDefault()
@@ -128,6 +187,11 @@ const FolderNavigatorItem = ({
{
type: 'separator',
},
+ getExportMenu('Export Folder'),
+ {
+ type: 'separator',
+ },
+
{
type: 'normal',
label: t('folder.rename'),
@@ -144,10 +208,11 @@ const FolderNavigatorItem = ({
})
},
[
- folderPathname,
- t,
createNoteInFolder,
createSubFolder,
+ getExportMenu,
+ t,
+ folderPathname,
showRenamePrompt,
showFolderRemoveMessageBox,
]
@@ -225,37 +290,46 @@ const FolderNavigatorItem = ({
}
return (
-
-
-
-
- >
- }
- onDragOver={preventDefault}
- onDrop={handleDrop}
- />
+ <>
+
+
+
+
+ >
+ }
+ onDragOver={preventDefault}
+ onDrop={handleDrop}
+ />
+ {exportProcedureRunning && (
+ setExportProcedure(false)}
+ />
+ )}
+ >
)
}
diff --git a/src/components/molecules/StorageNavigatorFragment.tsx b/src/components/molecules/StorageNavigatorFragment.tsx
index fd01f9282a..ee492337be 100644
--- a/src/components/molecules/StorageNavigatorFragment.tsx
+++ b/src/components/molecules/StorageNavigatorFragment.tsx
@@ -1,4 +1,5 @@
import React, {
+ useState,
useMemo,
useCallback,
MouseEventHandler,
@@ -33,6 +34,8 @@ import FolderNoteNavigatorFragment from './FolderNoteNavigatorFragment'
import { useRouteParams, usePathnameWithoutNoteId } from '../../lib/routeParams'
import NavigatorHeader from '../atoms/NavigatorHeader'
import NavigatorSeparator from '../atoms/NavigatorSeparator'
+import { getExportAsMenuItems } from '../../lib/exports'
+import ExportProgressItem from './ExportProgressItem'
interface StorageNavigatorFragmentProps {
storage: NoteStorage
@@ -58,6 +61,15 @@ const StorageNavigatorFragment = ({
const { preferences } = usePreferences()
const storageId = storage.id
+ const [exportSettings, setExportSettings] = useState({
+ folderName: '',
+ folderPathname: '',
+ exportType: '',
+ recursive: false,
+ exportingStorage: true,
+ })
+ const [exportProcedureRunning, setExportProcedure] = useState(false)
+
const createNoteInFolderAndRedirect = useCallback(
async (folderPathname: string) => {
report(analyticsEvents.createNote)
@@ -161,6 +173,36 @@ const StorageNavigatorFragment = ({
showPromptToCreateFolder('/')
}, [showPromptToCreateFolder])
+ const startStorageExport = useCallback(
+ (folderName, folderPathname, exportType, recursive) => {
+ setExportSettings({
+ folderName: folderName,
+ folderPathname: folderPathname,
+ exportType: exportType,
+ recursive: recursive,
+ exportingStorage: true,
+ })
+ setExportProcedure(true)
+ },
+ []
+ )
+
+ const getExportMenu = useCallback(
+ (menuLabel: string): MenuItemConstructorOptions => {
+ return {
+ type: 'submenu',
+ label: menuLabel,
+ submenu: getExportAsMenuItems(
+ storage.name,
+ '/',
+ true,
+ startStorageExport
+ ),
+ }
+ },
+ [startStorageExport, storage.name]
+ )
+
const openWorkspaceContextMenu: MouseEventHandler = useCallback(
(event) => {
event.preventDefault()
@@ -176,11 +218,15 @@ const StorageNavigatorFragment = ({
label: t('folder.create'),
click: createNewFolderInRootFolder,
},
+ {
+ type: 'separator',
+ },
+ getExportMenu('Export Storage'),
]
openContextMenu({ menuItems })
},
- [createNewNoteInRootFolder, createNewFolderInRootFolder, t]
+ [createNewNoteInRootFolder, t, createNewFolderInRootFolder, getExportMenu]
)
const attachments = useMemo(() => Object.values(storage.attachmentMap), [
@@ -266,6 +312,13 @@ const StorageNavigatorFragment = ({
}}
/>
)}
+ {exportProcedureRunning && (
+ setExportProcedure(false)}
+ />
+ )}
>
)
}
diff --git a/src/lib/exports.ts b/src/lib/exports.ts
index 17c101efcc..f419dee3e6 100644
--- a/src/lib/exports.ts
+++ b/src/lib/exports.ts
@@ -40,6 +40,7 @@ import {
import remarkSlug from 'remark-slug'
import { rehypePosition } from '../cloud/lib/rehypePosition'
import remarkAdmonitions from 'remark-admonitions'
+import { MenuItemConstructorOptions } from 'electron'
interface ImageData {
name: string
@@ -432,6 +433,10 @@ function revokeAttachmentsUrls(attachmentUrls: string[]) {
})
}
+export function getValidNoteTitle(note: NoteDoc): string {
+ return note.title ? note.title : 'Untitled-' + note._id
+}
+
export function convertNoteDocToMarkdownString(
note: NoteDoc,
includeFrontMatter: boolean
@@ -524,7 +529,8 @@ export const exportNoteAsHtmlFile = async (
generalThemeName: string,
pushMessage: (context: any) => any,
attachmentMap: ObjectMap,
- previewStyle?: string
+ previewStyle?: string,
+ silent?: boolean
): Promise => {
try {
const markdownHtmlContent = await convertNoteDocToMarkdownHtmlString(
@@ -574,22 +580,28 @@ export const exportNoteAsHtmlFile = async (
)
await writeFile(saveLocation, htmlString)
} catch (error) {
- pushMessage({
- title: 'Note processing failed',
- description: 'Please check markdown syntax and try again later.',
- })
- console.warn(error)
+ if (silent !== null && silent === true) {
+ throw new Error(
+ error ? error.message : 'Note processing failed, check markdown syntax.'
+ )
+ } else {
+ pushMessage({
+ title: 'Note processing failed',
+ description: 'Please check markdown syntax and try again later.',
+ })
+ console.warn(error)
+ }
}
}
-export async function convertNoteDocToPdfBuffer(
+export const convertNoteDocToPdfBuffer = async (
note: NoteDoc,
codeBlockTheme: string,
generalThemeName: string,
pushMessage: (context: any) => any,
attachmentMap: ObjectMap,
previewStyle?: string
-): Promise {
+): Promise => {
const markdownHtmlContent = await convertNoteDocToMarkdownHtmlString(
note,
codeBlockTheme
@@ -645,7 +657,7 @@ export const exportNoteAsPdfFile = async (
attachmentMap,
previewStyle
)
- const pdfName = `${filenamify(note.title)}.pdf`
+ const pdfName = `${filenamify(getValidNoteTitle(note))}.pdf`
downloadBlob(new Blob([pdfBuffer]), pdfName)
} catch (error) {
@@ -656,3 +668,33 @@ export const exportNoteAsPdfFile = async (
})
}
}
+
+export function getExportAsMenuItems(
+ folderName: string,
+ folderPathname: string,
+ recursive: boolean,
+ startExport: (
+ folderName: string,
+ folderPathname: string,
+ exportType: string,
+ recursive: boolean
+ ) => void
+): MenuItemConstructorOptions[] {
+ return [
+ {
+ type: 'normal',
+ label: 'Export as Markdown (.md)',
+ click: () => startExport(folderName, folderPathname, 'md', recursive),
+ },
+ {
+ type: 'normal',
+ label: 'Export as HTML (.html)',
+ click: () => startExport(folderName, folderPathname, 'html', recursive),
+ },
+ {
+ type: 'normal',
+ label: 'Export as PDF (.pdf)',
+ click: () => startExport(folderName, folderPathname, 'pdf', recursive),
+ },
+ ]
+}