From 05745fc77ccf3b9d2cf2a63f04ab0ca4daae82c2 Mon Sep 17 00:00:00 2001 From: Komediruzecki Date: Fri, 18 Dec 2020 23:08:49 +0100 Subject: [PATCH] Initial batch export for PDF Add prepare export functions in exports.ts Add handling of menus for folder exports Add support for non-recursive/recursive exports Add export progress bar Add support for storage export Add component for batch export handling (state, procedure) Refactor folder and storage export to use the component Fix cancelation state logic Add dim background on export procedure Add support for note statistics Add current note exporting vs total number of notes to export beside export note operation Remove getAttachment data helper function Set note title to untitled if note has no title Refactor writeNoteData function Fix PDF export push message to include export type (HTML when set) Update naming of few variables in export Remove unnecessary try/catch in PDF conversion function Refactor attachment linking Add better handling of injecting attachments Removed old code for pdf conversion header/footer Fix attachment rendering in PDF export from HTML tag Add support for attachment rendering from HTML tags for PDF export Add better support for attachment regex: single and double qoutes Add untitled-note_id for notes without title Fix startsWith condition by adding additional '/' to find sub-folders Update code after rebase v0.14.1 Fix progress bar (use new one) Refactor NoteContextMenu Update batch export after rebase v0.14.3 Update batch export to use new exports API Update exports to validate untitled note names --- src/components/atoms/ProgressBar.tsx | 5 +- .../molecules/ExportProgressItem.tsx | 587 ++++++++++++++++++ .../molecules/FolderNavigatorItem.tsx | 142 ++++- .../molecules/StorageNavigatorFragment.tsx | 55 +- src/lib/exports.ts | 60 +- 5 files changed, 803 insertions(+), 46 deletions(-) create mode 100644 src/components/molecules/ExportProgressItem.tsx 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), + }, + ] +}