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

191 lines
6.4 KiB
JavaScript
Raw Normal View History

import Branch from "../entities/branch.js";
import NoteShort from "../entities/note_short.js";
2019-08-27 02:21:43 +08:00
import ws from "./ws.js";
import server from "./server.js";
/**
* TreeCache keeps a read only cache of note tree structure in frontend's memory.
2019-10-28 02:17:32 +08:00
* - notes are loaded lazily when unknown noteId is requested
* - when note is loaded, all its parent and child branches are loaded as well. For a branch to be used, it's not must be loaded before
* - deleted notes are present in the cache as well, but they don't have any branches. As a result check for deleted branch is done by presence check - if the branch is not there even though the corresponding note has been loaded, we can infer it is deleted.
*
* Note and branch deletions are corner cases and usually not needed.
*/
class TreeCache {
constructor() {
this.init();
}
init() {
/** @type {Object.<string, NoteShort>} */
this.notes = {};
/** @type {Object.<string, Branch>} */
this.branches = {};
}
load(noteRows, branchRows) {
this.init();
this.addResp(noteRows, branchRows);
}
addResp(noteRows, branchRows) {
2019-10-26 15:51:08 +08:00
const branchesByNotes = {};
for (const branchRow of branchRows) {
const branch = new Branch(this, branchRow);
2019-10-26 15:51:08 +08:00
branchesByNotes[branch.noteId] = branchesByNotes[branch.noteId] || [];
branchesByNotes[branch.noteId].push(branch);
branchesByNotes[branch.parentNoteId] = branchesByNotes[branch.parentNoteId] || [];
branchesByNotes[branch.parentNoteId].push(branch);
}
2019-10-26 15:51:08 +08:00
for (const noteRow of noteRows) {
const {noteId} = noteRow;
const oldNote = this.notes[noteId];
if (oldNote) {
for (const childNoteId of oldNote.children) {
const childNote = this.notes[childNoteId];
if (childNote) {
childNote.parents = childNote.parents.filter(p => p !== noteId);
2019-10-28 02:17:32 +08:00
delete this.branches[childNote.parentToBranch[noteId]];
2019-10-26 15:51:08 +08:00
delete childNote.parentToBranch[noteId];
}
}
2019-04-14 04:10:16 +08:00
2019-10-26 15:51:08 +08:00
for (const parentNoteId of oldNote.parents) {
const parentNote = this.notes[parentNoteId];
2019-04-14 04:10:16 +08:00
2019-10-26 15:51:08 +08:00
if (parentNote) {
parentNote.children = parentNote.children.filter(p => p !== noteId);
2019-04-14 04:10:16 +08:00
2019-10-28 02:17:32 +08:00
delete this.branches[parentNote.childToBranch[noteId]];
2019-10-26 15:51:08 +08:00
delete parentNote.childToBranch[noteId];
}
}
2019-10-20 18:29:34 +08:00
}
2019-04-14 04:10:16 +08:00
for (const branch of branchesByNotes[noteId] || []) { // can be empty for deleted notes
2019-10-28 02:17:32 +08:00
this.branches[branch.branchId] = branch;
2019-10-27 02:48:56 +08:00
}
const note = new NoteShort(this, noteRow, branchesByNotes[noteId] || []);
2019-04-14 04:10:16 +08:00
2019-10-26 15:51:08 +08:00
this.notes[note.noteId] = note;
2019-04-14 04:10:16 +08:00
2019-10-26 15:51:08 +08:00
for (const childNoteId of note.children) {
const childNote = this.notes[childNoteId];
2019-04-14 04:10:16 +08:00
2019-10-26 15:51:08 +08:00
if (childNote) {
childNote.addParent(noteId, note.childToBranch[childNoteId]);
}
}
2019-10-26 15:51:08 +08:00
for (const parentNoteId of note.parents) {
const parentNote = this.notes[parentNoteId];
2019-10-26 15:51:08 +08:00
if (parentNote) {
parentNote.addChild(noteId, note.parentToBranch[parentNoteId]);
}
}
}
}
async reloadNotes(noteIds) {
const resp = await server.post('tree/load', { noteIds });
this.addResp(resp.notes, resp.branches);
for (const note of resp.notes) {
if (note.type === 'search') {
const searchResults = await server.get('search-note/' + note.noteId);
2019-11-17 02:07:32 +08:00
if (!searchResults) {
throw new Error(`Search note ${note.noteId} failed.`);
}
// force to load all the notes at once instead of one by one
await treeCache.getNotes(searchResults.map(res => res.noteId));
const branches = resp.branches.filter(b => b.noteId === note.noteId || b.parentNoteId === note.noteId);
searchResults.forEach((result, index) => branches.push({
// branchId should be repeatable since sometimes we reload some notes without rerendering the tree
branchId: "virt" + result.noteId + '-' + note.noteId,
noteId: result.noteId,
parentNoteId: note.noteId,
prefix: treeCache.getBranch(result.branchId).prefix,
notePosition: (index + 1) * 10
}));
// update this note with standard (parent) branches + virtual (children) branches
treeCache.addResp([note], branches);
}
}
}
2019-04-14 04:10:16 +08:00
/** @return {Promise<NoteShort[]>} */
async getNotes(noteIds, silentNotFoundError = false) {
const missingNoteIds = noteIds.filter(noteId => this.notes[noteId] === undefined);
if (missingNoteIds.length > 0) {
await this.reloadNotes(missingNoteIds);
}
return noteIds.map(noteId => {
if (!this.notes[noteId] && !silentNotFoundError) {
2019-08-27 02:21:43 +08:00
ws.logError(`Can't find note "${noteId}"`);
2018-08-06 17:30:37 +08:00
2018-08-12 18:59:38 +08:00
return null;
}
else {
return this.notes[noteId];
}
2018-08-12 18:59:38 +08:00
}).filter(note => note !== null);
}
2019-04-14 04:10:16 +08:00
/** @return {Promise<boolean>} */
async noteExists(noteId) {
const notes = await this.getNotes([noteId], true);
return notes.length === 1;
}
/** @return {Promise<NoteShort>} */
2019-09-08 17:25:57 +08:00
async getNote(noteId, silentNotFoundError = false) {
2018-05-27 04:16:34 +08:00
if (noteId === 'none') {
return null;
}
2019-09-08 17:25:57 +08:00
return (await this.getNotes([noteId], silentNotFoundError))[0];
}
getBranches(branchIds) {
return branchIds
.map(branchId => this.getBranch(branchId))
.filter(b => b !== null);
}
/** @return {Branch} */
getBranch(branchId, silentNotFoundError = false) {
if (!(branchId in this.branches)) {
if (!silentNotFoundError) {
console.error(`Not existing branch ${branchId}`);
}
}
2019-10-27 02:48:56 +08:00
else {
return this.branches[branchId];
}
}
}
const treeCache = new TreeCache();
export default treeCache;