trilium/src/public/javascripts/services/frontend_script_api.js

364 lines
11 KiB
JavaScript
Raw Normal View History

2018-08-23 18:55:45 +08:00
import treeService from './tree.js';
import server from './server.js';
import utils from './utils.js';
2019-10-20 16:00:18 +08:00
import toastService from './toast.js';
2018-08-23 18:55:45 +08:00
import linkService from './link.js';
import treeCache from './tree_cache.js';
import noteDetailService from './note_detail.js';
import noteTooltipService from './note_tooltip.js';
2019-08-17 17:28:36 +08:00
import protectedSessionService from './protected_session.js';
import dateNotesService from './date_notes.js';
import StandardWidget from '../widgets/standard_widget.js';
import ws from "./ws.js";
import hoistedNoteService from "./hoisted_note.js";
2018-08-23 18:55:45 +08:00
/**
2018-08-23 21:33:19 +08:00
* This is the main frontend API interface for scripts. It's published in the local "api" object.
*
2018-08-23 18:55:45 +08:00
* @constructor
* @hideconstructor
*/
2019-10-05 16:55:29 +08:00
function FrontendScriptApi(startNote, currentNote, originEntity = null, tabContext = null, $container = null) {
2018-08-23 18:55:45 +08:00
const $pluginButtons = $("#plugin-buttons");
2019-10-05 16:55:29 +08:00
/** @property {jQuery} container of all the rendered script content */
this.$container = $container;
2018-08-23 18:55:45 +08:00
/** @property {object} note where script started executing */
this.startNote = startNote;
/** @property {object} note where script is currently executing */
this.currentNote = currentNote;
/** @property {object|null} entity whose event triggered this execution */
this.originEntity = originEntity;
// to keep consistency with backend API
this.dayjs = dayjs;
/** @property {TabContext|null} - experimental! */
this.tabContext = tabContext;
2019-08-17 17:28:36 +08:00
/** @property {StandardWidget} */
this.StandardWidget = StandardWidget;
2018-08-23 18:55:45 +08:00
/**
* Activates note in the tree and in the note detail.
*
* @method
* @param {string} notePath (or noteId)
* @returns {Promise<void>}
*/
this.activateNote = async (notePath, noteLoadedListener) => {
await treeService.activateNote(notePath, async () => {
await treeService.scrollToActiveNote();
if (noteLoadedListener) {
noteLoadedListener();
}
});
};
2018-08-23 18:55:45 +08:00
/**
* Activates newly created note. Compared to this.activateNote() also refreshes tree.
*
* @param {string} notePath (or noteId)
* @return {Promise<void>}
*/
this.activateNewNote = async notePath => {
await treeService.reload();
await treeService.activateNote(notePath, noteDetailService.focusAndSelectTitle);
2018-08-23 18:55:45 +08:00
};
2018-08-23 21:33:19 +08:00
/**
* @typedef {Object} ToolbarButtonOptions
* @property {string} title
* @property {string} [icon] - name of the JAM icon to be used (e.g. "clock" for "jam-clock" icon)
2018-08-23 21:33:19 +08:00
* @property {function} action - callback handling the click on the button
* @property {string} [shortcut] - keyboard shortcut for the button, e.g. "alt+t"
*/
2018-08-23 18:55:45 +08:00
/**
* Adds new button the the plugin area.
*
2018-08-23 21:33:19 +08:00
* @param {ToolbarButtonOptions} opts
2018-08-23 18:55:45 +08:00
*/
this.addButtonToToolbar = opts => {
const buttonId = "toolbar-button-" + opts.title.replace(/[^a-zA-Z0-9]/g, "-");
const button = $('<button>')
2018-11-06 04:12:03 +08:00
.addClass("btn btn-sm")
.click(opts.action);
if (opts.icon) {
button.append($("<span>").addClass("jam jam-" + opts.icon))
.append("&nbsp;");
}
button.append($("<span>").text(opts.title));
2018-08-23 18:55:45 +08:00
button.attr('id', buttonId);
2018-08-28 03:08:02 +08:00
if ($("#" + buttonId).replaceWith(button).length === 0) {
$pluginButtons.append(button);
}
2018-08-23 18:55:45 +08:00
if (opts.shortcut) {
utils.bindGlobalShortcut(opts.shortcut, opts.action);
2018-08-23 18:55:45 +08:00
button.attr("title", "Shortcut " + opts.shortcut);
}
};
function prepareParams(params) {
if (!params) {
return params;
}
return params.map(p => {
if (typeof p === "function") {
return "!@#Function: " + p.toString();
}
else {
return p;
}
});
}
/**
* Executes given anonymous function on the server.
* Internally this serializes the anonymous function into string and sends it to backend via AJAX.
*
* @param {string} script - script to be executed on the backend
2018-08-23 21:33:19 +08:00
* @param {Array.<?>} params - list of parameters to the anonymous function to be send to backend
2018-08-23 18:55:45 +08:00
* @return {Promise<*>} return value of the executed function on the backend
*/
this.runOnServer = async (script, params = []) => {
if (typeof script === "function") {
script = script.toString();
}
const ret = await server.post('script/exec', {
script: script,
params: prepareParams(params),
startNoteId: startNote.noteId,
currentNoteId: currentNote.noteId,
originEntityName: "notes", // currently there's no other entity on frontend which can trigger event
originEntityId: originEntity ? originEntity.noteId : null
2019-10-19 21:12:25 +08:00
}, {
'trilium-source-id': "script"
2018-08-23 18:55:45 +08:00
});
if (ret.success) {
// wait until all the changes done in the script has been synced to frontend before continuing
await ws.waitForSyncId(ret.maxSyncId);
2018-08-23 18:55:45 +08:00
return ret.executionResult;
}
else {
throw new Error("server error: " + ret.error);
}
};
/**
* This is a powerful search method - you can search by attributes and their values, e.g.:
* "@dateModified =* MONTH AND @log". See full documentation for all options at: https://github.com/zadam/trilium/wiki/Search
*
* @method
* @param {string} searchString
* @returns {Promise<NoteShort[]>}
*/
this.searchForNotes = async searchString => {
const noteIds = await this.runOnServer(async searchString => {
const notes = await api.searchForNotes(searchString);
return notes.map(note => note.noteId);
}, [searchString]);
return await treeCache.getNotes(noteIds);
};
/**
* This is a powerful search method - you can search by attributes and their values, e.g.:
* "@dateModified =* MONTH AND @log". See full documentation for all options at: https://github.com/zadam/trilium/wiki/Search
*
* @method
* @param {string} searchString
* @returns {Promise<NoteShort|null>}
*/
this.searchForNote = async searchString => {
const notes = await this.searchForNotes(searchString);
return notes.length > 0 ? notes[0] : null;
};
2019-04-10 03:13:47 +08:00
/**
* Returns note by given noteId. If note is missing from cache, it's loaded.
**
* @param {string} noteId
* @return {Promise<NoteShort>}
*/
this.getNote = async noteId => await treeCache.getNote(noteId);
2018-08-23 18:55:45 +08:00
/**
* Returns list of notes. If note is missing from cache, it's loaded.
*
* This is often used to bulk-fill the cache with notes which would have to be picked one by one
* otherwise (by e.g. createNoteLink())
*
2018-08-23 21:33:19 +08:00
* @param {string[]} noteIds
2018-08-23 18:55:45 +08:00
* @param {boolean} [silentNotFoundError] - don't report error if the note is not found
2018-08-23 21:33:19 +08:00
* @return {Promise<NoteShort[]>}
2018-08-23 18:55:45 +08:00
*/
this.getNotes = async (noteIds, silentNotFoundError = false) => await treeCache.getNotes(noteIds, silentNotFoundError);
/**
2019-10-26 16:00:26 +08:00
* Update frontend tree (note) cache from the backend.
*
* @param {string[]} noteIds
* @method
*/
2019-10-26 16:00:26 +08:00
this.reloadNotes = async noteIds => await treeCache.reloadNotes(noteIds);
2018-08-23 18:55:45 +08:00
/**
* Instance name identifies particular Trilium instance. It can be useful for scripts
* if some action needs to happen on only one specific instance.
*
* @return {string}
*/
this.getInstanceName = () => window.glob.instanceName;
/**
* @method
* @param {Date} date
* @returns {string} date in YYYY-MM-DD format
*/
this.formatDateISO = utils.formatDateISO;
/**
* @method
* @param {string} str
* @returns {Date} parsed object
*/
this.parseDate = utils.parseDate;
/**
* Show info message to the user.
*
* @method
* @param {string} message
*/
2019-10-20 16:00:18 +08:00
this.showMessage = toastService.showMessage;
2018-08-23 18:55:45 +08:00
/**
* Show error message to the user.
*
* @method
* @param {string} message
*/
2019-10-20 16:00:18 +08:00
this.showError = toastService.showError;
2018-08-23 18:55:45 +08:00
/**
* Refresh tree
*
* @method
* @returns {Promise<void>}
*/
this.refreshTree = treeService.reload;
/**
* Create note link (jQuery object) for given note.
*
* @method
* @param {string} notePath (or noteId)
* @param {string} [noteTitle] - if not present we'll use note title
*/
this.createNoteLink = linkService.createNoteLink;
/**
* @method
* @returns {NoteFull} active note (loaded into right pane)
*/
2019-10-20 18:29:34 +08:00
this.getActiveTabNote = noteDetailService.getActiveTabNote;
2019-04-10 03:13:47 +08:00
/**
* @method
2019-05-15 04:29:47 +08:00
* @returns {Promise<string|null>} returns note path of active note or null if there isn't active note
2019-04-10 03:13:47 +08:00
*/
2019-10-20 18:29:34 +08:00
this.getActiveTabNotePath = noteDetailService.getActiveTabNotePath;
2019-04-10 03:13:47 +08:00
/**
* This method checks whether user navigated away from the note from which the scripts has been started.
* This is necessary because script execution is async and by the time it is finished, the user might have
* already navigated away from this page - the end result would be that script might return data for the wrong
* note.
*
* @method
* @return {boolean} returns true if the original note is still loaded, false if user switched to another
*/
this.isNoteStillActive = () => {
2019-09-08 17:25:57 +08:00
return tabContext.note && this.originEntity.noteId === tabContext.note.noteId;
};
/**
* @method
* @param {function} func - callback called on note change as user is typing (not necessarily tied to save event)
*/
this.onNoteChange = noteDetailService.onNoteChange;
/**
* @method
* @param {object} $el - jquery object on which to setup the tooltip
*/
this.setupElementTooltip = noteTooltipService.setupElementTooltip;
/**
* @method
*/
this.protectActiveNote = protectedSessionService.protectNoteAndSendToServer;
/**
* Returns date-note for today. If it doesn't exist, it is automatically created.
*
* @method
* @return {Promise<NoteShort>}
*/
this.getTodayNote = dateNotesService.getTodayNote;
/**
* Returns date-note. If it doesn't exist, it is automatically created.
*
* @method
* @param {string} date - e.g. "2019-04-29"
* @return {Promise<NoteShort>}
*/
this.getDateNote = dateNotesService.getDateNote;
/**
* Returns month-note. If it doesn't exist, it is automatically created.
*
* @method
* @param {string} month - e.g. "2019-04"
* @return {Promise<NoteShort>}
*/
this.getMonthNote = dateNotesService.getMonthNote;
/**
* Returns year-note. If it doesn't exist, it is automatically created.
*
* @method
* @param {string} year - e.g. "2019"
* @return {Promise<NoteShort>}
*/
this.getYearNote = dateNotesService.getYearNote;
/**
* Hoist note. See https://github.com/zadam/trilium/wiki/Note-hoisting
*
* @method
* @param {string} noteId - set hoisted note. 'root' will effectively unhoist
* @return {Promise}
*/
this.setHoistedNoteId = hoistedNoteService.setHoistedNoteId;
2018-08-23 18:55:45 +08:00
}
export default FrontendScriptApi;