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), + }, + ] +}