updated API docs

docs/frontend_api/entities_note_short.js.html

@@ -28,6 +28,7 @@
         <article>
             <pre class="prettyprint source linenums"><code>import server from '../services/server.js';
 import Attribute from './attribute.js';
+import branches from "../services/branches.js";
 
 const LABEL = 'label';
 const LABEL_DEFINITION = 'label-definition';
@@ -41,7 +42,12 @@ const RELATION_DEFINITION = 'relation-definition';
  * This note's representation is used in note tree and is kept in TreeCache.
  */
 class NoteShort {
-    constructor(treeCache, row) {
+    /**
+     * @param {TreeCache} treeCache
+     * @param {Object.&lt;string, Object>} row
+     * @param {Branch[]} branches - all relevant branches, i.e. where this note is either child or parent
+     */
+    constructor(treeCache, row, branches) {
         this.treeCache = treeCache;
         /** @param {string} */
         this.noteId = row.noteId;
@@ -57,6 +63,55 @@ class NoteShort {
         this.archived = row.archived;
         /** @param {string} */
         this.cssClass = row.cssClass;
+
+        /** @type {string[]} */
+        this.parents = [];
+        /** @type {string[]} */
+        this.children = [];
+
+        /** @type {Object.&lt;string, string>} */
+        this.parentToBranch = {};
+
+        /** @type {Object.&lt;string, string>} */
+        this.childToBranch = {};
+
+        for (const branch of branches) {
+            if (this.noteId === branch.noteId) {
+                this.parents.push(branch.parentNoteId);
+                this.parentToBranch[branch.parentNoteId] = branch.branchId;
+            }
+            else if (this.noteId === branch.parentNoteId) {
+                this.children.push(branch.noteId);
+                this.childToBranch[branch.noteId] = branch.branchId;
+            }
+            else {
+                throw new Error(`Unknown branch ${branch.branchId} for note ${this.noteId}`);
+            }
+        }
+    }
+
+    addParent(parentNoteId, branchId) {
+        if (!this.parents.includes(parentNoteId)) {
+            this.parents.push(parentNoteId);
+        }
+
+        this.parentToBranch[parentNoteId] = branchId;
+    }
+
+    addChild(childNoteId, branchId) {
+        if (!this.children.includes(childNoteId)) {
+            this.children.push(childNoteId);
+        }
+
+        this.childToBranch[childNoteId] = branchId;
+
+        const branchIdPos = {};
+
+        for (const branchId of Object.values(this.childToBranch)) {
+            branchIdPos[branchId] = this.treeCache.branches[branchId].notePosition;
+        }
+
+        this.children.sort((a, b) => branchIdPos[this.childToBranch[a]] &lt; branchIdPos[this.childToBranch[b]] ? -1 : 1);
     }
 
     /** @returns {boolean} */
@@ -86,48 +141,41 @@ class NoteShort {
 
     /** @returns {Promise&lt;Branch[]>} */
     async getBranches() {
-        const branchIds = this.treeCache.parents[this.noteId].map(
-            parentNoteId => this.treeCache.getBranchIdByChildParent(this.noteId, parentNoteId));
+        const branchIds = Object.values(this.parentToBranch);
 
         return this.treeCache.getBranches(branchIds);
     }
 
     /** @returns {boolean} */
     hasChildren() {
-        return this.treeCache.children[this.noteId]
-            &amp;&amp; this.treeCache.children[this.noteId].length > 0;
+        return this.children.length > 0;
     }
 
     /** @returns {Promise&lt;Branch[]>} */
     async getChildBranches() {
-        if (!this.treeCache.children[this.noteId]) {
-            return [];
-        }
+        const branchIds = Object.values(this.childToBranch);
 
-        const branchIds = this.treeCache.children[this.noteId].map(
-            childNoteId => this.treeCache.getBranchIdByChildParent(childNoteId, this.noteId));
-
-        return await this.treeCache.getBranches(branchIds);
+        return this.treeCache.getBranches(branchIds);
     }
 
     /** @returns {string[]} */
     getParentNoteIds() {
-        return this.treeCache.parents[this.noteId] || [];
+        return this.parents;
     }
 
     /** @returns {Promise&lt;NoteShort[]>} */
     async getParentNotes() {
-        return await this.treeCache.getNotes(this.getParentNoteIds());
+        return await this.treeCache.getNotes(this.parents);
     }
 
     /** @returns {string[]} */
     getChildNoteIds() {
-        return this.treeCache.children[this.noteId] || [];
+        return this.children;
     }
 
     /** @returns {Promise&lt;NoteShort[]>} */
     async getChildNotes() {
-        return await this.treeCache.getNotes(this.getChildNoteIds());
+        return await this.treeCache.getNotes(this.children);
     }
 
     /**