1
0
mirror of https://github.com/laurent22/joplin.git synced 2024-12-21 09:38:01 +02:00
joplin/ReactNativeClient/lib/services/interop/InteropService_Exporter_Md.ts
Laurent Cozic 3d8577a689 Plugins: Added support for content scripts
- For now, supports Markdown-it plugins
- Also fixed slow rendering of notes in some cases
- Simplified how Markdown-It plugins are created and cleaned MdToHtml code

commit 89576de289
Merge: c75aa21f 5292fc14
Author: Laurent Cozic <laurent@cozic.net>
Date:   Wed Oct 21 00:23:00 2020 +0100

    Merge branch 'release-1.3' into plugin_content_scripts

commit c75aa21ffd
Author: Laurent Cozic <laurent@cozic.net>
Date:   Wed Oct 21 00:19:52 2020 +0100

    Fixed tests

commit 075187729d
Author: Laurent Cozic <laurent@cozic.net>
Date:   Wed Oct 21 00:11:53 2020 +0100

    Fixed tests

commit 14696b8c65
Author: Laurent Cozic <laurent@cozic.net>
Date:   Tue Oct 20 23:27:58 2020 +0100

    Fixed slow rendering of note

commit 61c09f5bf8
Author: Laurent Cozic <laurent@cozic.net>
Date:   Tue Oct 20 22:35:21 2020 +0100

    Clean up

commit 9f7ea7d865
Author: Laurent Cozic <laurent@cozic.net>
Date:   Tue Oct 20 20:05:31 2020 +0100

    Updated doc

commit 98bf3bde8d
Author: Laurent Cozic <laurent@cozic.net>
Date:   Tue Oct 20 19:56:34 2020 +0100

    Finished converting plugins

commit fe90d92e01
Author: Laurent Cozic <laurent@cozic.net>
Date:   Tue Oct 20 17:52:02 2020 +0100

    Simplified how Markdown-It plugins are created

commit 47c7b864cb
Author: Laurent Cozic <laurent@cozic.net>
Date:   Mon Oct 19 16:40:11 2020 +0100

    Clean up rules

commit d927a238bb
Author: Laurent Cozic <laurent@cozic.net>
Date:   Mon Oct 19 14:29:40 2020 +0100

    Fixed tests

commit 388a56c5dd
Author: Laurent Cozic <laurent@cozic.net>
Date:   Mon Oct 19 14:00:47 2020 +0100

    Add support for content scripts
2020-10-21 00:23:55 +01:00

135 lines
5.1 KiB
TypeScript

const InteropService_Exporter_Base = require('lib/services/interop/InteropService_Exporter_Base').default;
const { basename, dirname, friendlySafeFilename } = require('lib/path-utils');
const BaseModel = require('lib/BaseModel');
const Folder = require('lib/models/Folder');
const Note = require('lib/models/Note');
const shim = require('lib/shim').default;
const markdownUtils = require('lib/markdownUtils').default;
export default class InteropService_Exporter_Md extends InteropService_Exporter_Base {
async init(destDir:string) {
this.destDir_ = destDir;
this.resourceDir_ = destDir ? `${destDir}/_resources` : null;
this.createdDirs_ = [];
await shim.fsDriver().mkdir(this.destDir_);
await shim.fsDriver().mkdir(this.resourceDir_);
}
async makeDirPath_(item:any, pathPart:string = null, findUniqueFilename:boolean = true) {
let output = '';
while (true) {
if (item.type_ === BaseModel.TYPE_FOLDER) {
if (pathPart) {
output = `${pathPart}/${output}`;
} else {
output = `${friendlySafeFilename(item.title, null, true)}/${output}`;
if (findUniqueFilename) output = await shim.fsDriver().findUniqueFilename(output);
}
}
if (!item.parent_id) return output;
item = await Folder.load(item.parent_id);
}
}
async relaceLinkedItemIdsByRelativePaths_(item:any) {
const relativePathToRoot = await this.makeDirPath_(item, '..');
const newBody = await this.replaceResourceIdsByRelativePaths_(item.body, relativePathToRoot);
return await this.replaceNoteIdsByRelativePaths_(newBody, relativePathToRoot);
}
async replaceResourceIdsByRelativePaths_(noteBody:string, relativePathToRoot:string) {
const linkedResourceIds = await Note.linkedResourceIds(noteBody);
const resourcePaths = this.context() && this.context().resourcePaths ? this.context().resourcePaths : {};
const createRelativePath = function(resourcePath:string) {
return `${relativePathToRoot}_resources/${basename(resourcePath)}`;
};
return await this.replaceItemIdsByRelativePaths_(noteBody, linkedResourceIds, resourcePaths, createRelativePath);
}
async replaceNoteIdsByRelativePaths_(noteBody:string, relativePathToRoot:string) {
const linkedNoteIds = await Note.linkedNoteIds(noteBody);
const notePaths = this.context() && this.context().notePaths ? this.context().notePaths : {};
const createRelativePath = function(notePath:string) {
return markdownUtils.escapeLinkUrl(`${relativePathToRoot}${notePath}`.trim());
};
return await this.replaceItemIdsByRelativePaths_(noteBody, linkedNoteIds, notePaths, createRelativePath);
}
async replaceItemIdsByRelativePaths_(noteBody:string, linkedItemIds:string[], paths:any, fn_createRelativePath:Function) {
let newBody = noteBody;
for (let i = 0; i < linkedItemIds.length; i++) {
const id = linkedItemIds[i];
const itemPath = fn_createRelativePath(paths[id]);
newBody = newBody.replace(new RegExp(`:/${id}`, 'g'), itemPath);
}
return newBody;
}
async prepareForProcessingItemType(itemType:number, itemsToExport:any[]) {
if (itemType === BaseModel.TYPE_NOTE) {
// Create unique file path for the note
const context:any = {
notePaths: {},
};
for (let i = 0; i < itemsToExport.length; i++) {
const itemType = itemsToExport[i].type;
if (itemType !== itemType) continue;
const itemOrId = itemsToExport[i].itemOrId;
const note = typeof itemOrId === 'object' ? itemOrId : await Note.load(itemOrId);
if (!note) continue;
let notePath = `${await this.makeDirPath_(note, null, false)}${friendlySafeFilename(note.title, null, true)}.md`;
notePath = await shim.fsDriver().findUniqueFilename(`${this.destDir_}/${notePath}`, Object.values(context.notePaths));
context.notePaths[note.id] = notePath;
}
// Strip the absolute path to export dir and keep only the relative paths
const destDir = this.destDir_;
Object.keys(context.notePaths).map(function(id) {
context.notePaths[id] = context.notePaths[id].substr(destDir.length + 1);
});
this.updateContext(context);
}
}
async processItem(_itemType:number, item:any) {
if ([BaseModel.TYPE_NOTE, BaseModel.TYPE_FOLDER].indexOf(item.type_) < 0) return;
if (item.type_ === BaseModel.TYPE_FOLDER) {
const dirPath = `${this.destDir_}/${await this.makeDirPath_(item)}`;
if (this.createdDirs_.indexOf(dirPath) < 0) {
await shim.fsDriver().mkdir(dirPath);
this.createdDirs_.push(dirPath);
}
} else if (item.type_ === BaseModel.TYPE_NOTE) {
const notePaths = this.context() && this.context().notePaths ? this.context().notePaths : {};
const noteFilePath = `${this.destDir_}/${notePaths[item.id]}`;
const noteBody = await this.relaceLinkedItemIdsByRelativePaths_(item);
const modNote = Object.assign({}, item, { body: noteBody });
const noteContent = await Note.serializeForEdit(modNote);
await shim.fsDriver().mkdir(dirname(noteFilePath));
await shim.fsDriver().writeFile(noteFilePath, noteContent, 'utf-8');
}
}
async processResource(_resource:any, filePath:string) {
const destResourcePath = `${this.resourceDir_}/${basename(filePath)}`;
await shim.fsDriver().copy(filePath, destResourcePath);
}
async close() {}
}