Dockery/Trilium
1
0
Fork 0
mirror of https://github.com/zadam/trilium.git synced 2025-10-30 09:56:36 +01:00
Code Issues Packages Projects Releases Activity

basic lazy loading of tree now works, still WIP

Browse Source
This commit is contained in:
azivner
2018-04-16 20:40:18 -04:00
parent 1687ed7e0b
commit 82de1c88d4
6 changed files with 154 additions and 75 deletions
Download Patch File Download Diff File Expand all files Collapse all files

107
src/public/javascripts/services/tree_cache.js
View File

@@ -2,45 +2,82 @@ import utils from "./utils.js";
import Branch from "../entities/branch.js";
import NoteShort from "../entities/note_short.js";
import infoService from "./info.js";
import server from "./server.js";
class TreeCache {
load(noteRows, branchRows) {
this.parents = [];
this.children = [];
load(noteRows, branchRows, parentToChildren) {
this.parents = {};
this.children = {};
this.childParentToBranch = {};
/** @type {Object.<string, NoteShort>} */
this.notes = {};
/** @type {Object.<string, Branch>} */
this.branches = {};
this.addResp(noteRows, branchRows, parentToChildren);
}
addResp(noteRows, branchRows, parentToChildren) {
for (const noteRow of noteRows) {
const note = new NoteShort(this, noteRow);
this.notes[note.noteId] = note;
}
/** @type {Object.<string, Branch>} */
this.branches = {};
for (const branchRow of branchRows) {
const branch = new Branch(this, branchRow);
this.addBranch(branch);
}
for (const relation of parentToChildren) {
this.addBranchRelationship(relation.branchId, relation.childNoteId, relation.parentNoteId);
}
}
/** @return NoteShort */
async getNote(noteId) {
if (this.notes[noteId] === undefined) {
const resp = await server.post('tree/load', {
noteIds: [noteId]
});
this.addResp(resp.notes, resp.branches, resp.parentToChildren);
}
if (!this.notes[noteId]) {
throw new Error(`Can't find note ${noteId}`);
}
return this.notes[noteId];
}
addBranch(branch) {
this.branches[branch.branchId] = branch;
this.parents[branch.noteId] = this.parents[branch.noteId] || [];
this.parents[branch.noteId].push(this.notes[branch.parentNoteId]);
this.addBranchRelationship(branch.branchId, branch.noteId, branch.parentNoteId);
}
this.children[branch.parentNoteId] = this.children[branch.parentNoteId] || [];
this.children[branch.parentNoteId].push(this.notes[branch.noteId]);
addBranchRelationship(branchId, childNoteId, parentNoteId) {
this.addParentChildRelationship(parentNoteId, childNoteId);
this.childParentToBranch[branch.noteId + '-' + branch.parentNoteId] = branch;
this.childParentToBranch[childNoteId + '-' + parentNoteId] = branchId;
}
addParentChildRelationship(parentNoteId, childNoteId) {
this.parents[childNoteId] = this.parents[childNoteId] || [];
if (!this.parents[childNoteId].includes(parentNoteId)) {
this.parents[childNoteId].push(parentNoteId);
}
this.children[parentNoteId] = this.children[parentNoteId] || [];
if (!this.children[parentNoteId].includes(childNoteId)) {
this.children[parentNoteId].push(childNoteId);
}
}
add(note, branch) {
@@ -51,19 +88,34 @@ class TreeCache {
/** @return Branch */
async getBranch(branchId) {
if (this.branches[branchId] === undefined) {
const resp = await server.post('tree/load', {
branchIds: [branchId]
});
this.addResp(resp.notes, resp.branches, resp.parentToChildren);
}
if (!this.branches[branchId]) {
throw new Error(`Can't find branch ${branchId}`);
}
return this.branches[branchId];
}
/** @return Branch */
async getBranchByChildParent(childNoteId, parentNoteId) {
const key = (childNoteId + '-' + parentNoteId);
const branch = this.childParentToBranch[key];
// this will make sure the note and its relationships are loaded
await this.getNote(parentNoteId);
if (!branch) {
const key = (childNoteId + '-' + parentNoteId);
const branchId = this.childParentToBranch[key];
if (!branchId) {
infoService.throwError("Cannot find branch for child-parent=" + key);
}
return branch;
return await this.getBranch(branchId);
}
/* Move note from one parent to another. */
@@ -78,33 +130,14 @@ class TreeCache {
delete treeCache.childParentToBranch[childNoteId + '-' + oldParentNoteId]; // this is correct because we know that oldParentId isn't same as newParentId
// remove old associations
treeCache.parents[childNoteId] = treeCache.parents[childNoteId].filter(p => p.noteId !== oldParentNoteId);
treeCache.children[oldParentNoteId] = treeCache.children[oldParentNoteId].filter(ch => ch.noteId !== childNoteId);
treeCache.parents[childNoteId] = treeCache.parents[childNoteId].filter(p => p !== oldParentNoteId);
treeCache.children[oldParentNoteId] = treeCache.children[oldParentNoteId].filter(ch => ch !== childNoteId);
// add new associations
treeCache.parents[childNoteId].push(await treeCache.getNote(newParentNoteId));
treeCache.parents[childNoteId].push(newParentNoteId);
treeCache.children[newParentNoteId] = treeCache.children[newParentNoteId] || []; // this might be first child
treeCache.children[newParentNoteId].push(await treeCache.getNote(childNoteId));
}
removeParentChildRelation(parentNoteId, childNoteId) {
utils.assertArguments(parentNoteId, childNoteId);
treeCache.parents[childNoteId] = treeCache.parents[childNoteId].filter(p => p.noteId !== parentNoteId);
treeCache.children[parentNoteId] = treeCache.children[parentNoteId].filter(ch => ch.noteId !== childNoteId);
delete treeCache.childParentToBranch[childNoteId + '-' + parentNoteId];
}
async setParentChildRelation(branchId, parentNoteId, childNoteId) {
treeCache.parents[childNoteId] = treeCache.parents[childNoteId] || [];
treeCache.parents[childNoteId].push(await treeCache.getNote(parentNoteId));
treeCache.children[parentNoteId] = treeCache.children[parentNoteId] || [];
treeCache.children[parentNoteId].push(await treeCache.getNote(childNoteId));
treeCache.childParentToBranch[childNoteId + '-' + parentNoteId] = await treeCache.getBranch(branchId);
treeCache.children[newParentNoteId].push(childNoteId);
}
}