2018-08-29 20:44:35 +02:00
<!DOCTYPE html>
< html lang = "en" >
< head >
< meta charset = "utf-8" >
< title > JSDoc: Source: services/frontend_script_api.js< / title >
< script src = "scripts/prettify/prettify.js" > < / script >
< script src = "scripts/prettify/lang-css.js" > < / script >
<!-- [if lt IE 9]>
< script src = "//html5shiv.googlecode.com/svn/trunk/html5.js" > < / script >
<![endif]-->
< link type = "text/css" rel = "stylesheet" href = "styles/prettify-tomorrow.css" >
< link type = "text/css" rel = "stylesheet" href = "styles/jsdoc-default.css" >
< / head >
< body >
< div id = "main" >
< h1 class = "page-title" > Source: services/frontend_script_api.js< / h1 >
< section >
< article >
< pre class = "prettyprint source linenums" > < code > import treeService from './tree.js';
import server from './server.js';
import utils from './utils.js';
import infoService from './info.js';
import linkService from './link.js';
import treeCache from './tree_cache.js';
2018-09-03 16:05:28 +02:00
import noteDetailService from './note_detail.js';
2018-10-07 16:27:12 +02:00
import noteTypeService from './note_type.js';
2018-08-29 20:44:35 +02:00
/**
* This is the main frontend API interface for scripts. It's published in the local "api" object.
*
* @constructor
* @hideconstructor
*/
function FrontendScriptApi(startNote, currentNote, originEntity = null) {
const $pluginButtons = $("#plugin-buttons");
/** @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;
/**
* Activates note in the tree and in the note detail.
*
* @method
* @param {string} notePath (or noteId)
* @returns {Promise< void>}
*/
this.activateNote = treeService.activateNote;
/**
* 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, true);
};
/**
* @typedef {Object} ToolbarButtonOptions
* @property {string} title
2018-11-09 20:45:28 +01:00
* @property {string} [icon] - name of the JAM icon to be used (e.g. "clock" for "jam-clock" icon)
2018-08-29 20:44:35 +02:00
* @property {function} action - callback handling the click on the button
* @property {string} [shortcut] - keyboard shortcut for the button, e.g. "alt+t"
*/
/**
* Adds new button the the plugin area.
*
* @param {ToolbarButtonOptions} opts
*/
this.addButtonToToolbar = opts => {
const buttonId = "toolbar-button-" + opts.title.replace(/[^a-zA-Z0-9]/g, "-");
const button = $('< button>')
2018-11-08 23:49:44 +01:00
.addClass("btn btn-sm")
2018-11-13 12:50:08 +01:00
.click(opts.action);
if (opts.icon) {
button.append($("< span>").addClass("jam jam-" + opts.icon))
.append("& nbsp;");
}
button.append($("< span>").text(opts.title));
2018-08-29 20:44:35 +02:00
button.attr('id', buttonId);
if ($("#" + buttonId).replaceWith(button).length === 0) {
$pluginButtons.append(button);
}
if (opts.shortcut) {
$(document).bind('keydown', opts.shortcut, opts.action);
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
* @param {Array.< ?>} params - list of parameters to the anonymous function to be send to backend
* @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
});
if (ret.success) {
return ret.executionResult;
}
else {
throw new Error("server error: " + ret.error);
}
};
/**
* 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())
*
* @param {string[]} noteIds
* @param {boolean} [silentNotFoundError] - don't report error if the note is not found
* @return {Promise< NoteShort[]>}
*/
this.getNotes = async (noteIds, silentNotFoundError = false) => await treeCache.getNotes(noteIds, silentNotFoundError);
/**
* 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
*/
this.showMessage = infoService.showMessage;
/**
* Show error message to the user.
*
* @method
* @param {string} message
*/
this.showError = infoService.showError;
/**
* 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;
2018-09-03 16:05:28 +02:00
/**
* @method
* @returns {string} content of currently loaded note in the editor (HTML, code etc.)
*/
this.getCurrentNoteContent = noteDetailService.getCurrentNoteContent;
/**
* @method
2018-10-07 16:27:12 +02:00
* @param {function} func - callback called on note change as user is typing (not necessarily tied to save event)
2018-09-03 16:05:28 +02:00
*/
this.onNoteChange = noteDetailService.onNoteChange;
2018-10-07 16:27:12 +02:00
/**
* @method
* @returns {array} list of default code mime types
*/
this.getDefaultCodeMimeTypes = noteTypeService.getDefaultCodeMimeTypes;
/**
* @method
* @returns {array} list of currently used code mime types
*/
this.getCodeMimeTypes = noteTypeService.getCodeMimeTypes;
/**
* @method
* @param {array} types - list of mime types to be used
*/
this.setCodeMimeTypes = noteTypeService.setCodeMimeTypes;
2018-08-29 20:44:35 +02:00
}
export default FrontendScriptApi;< / code > < / pre >
< / article >
< / section >
< / div >
< nav >
< h2 > < a href = "index.html" > Home< / a > < / h2 > < h3 > Classes< / h3 > < ul > < li > < a href = "Branch.html" > Branch< / a > < / li > < li > < a href = "FrontendScriptApi.html" > FrontendScriptApi< / a > < / li > < li > < a href = "NoteFull.html" > NoteFull< / a > < / li > < li > < a href = "NoteShort.html" > NoteShort< / a > < / li > < / ul > < h3 > < a href = "global.html" > Global< / a > < / h3 >
< / nav >
< br class = "clear" >
< footer >
2018-11-13 12:50:08 +01:00
Documentation generated by < a href = "https://github.com/jsdoc3/jsdoc" > JSDoc 3.5.5< / a > on Tue Nov 13 2018 12:12:04 GMT+0100 (Central European Standard Time)
2018-08-29 20:44:35 +02:00
< / footer >
< script > prettyPrint ( ) ; < / script >
< script src = "scripts/linenumber.js" > < / script >
< / body >
< / html >
