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

import treeService from './tree.js';
import utils from './utils.js';
import server from './server.js';
import infoService from "./info.js";
import treeCache from "./tree_cache.js";

async function moveBeforeNode(nodesToMove, beforeNode) {
    nodesToMove = filterRootNote(nodesToMove);

    if (beforeNode.data.noteId === 'root') {
        alert('Cannot move notes before root note.');
        return;
    }

    for (const nodeToMove of nodesToMove) {
        const resp = await server.put('branches/' + nodeToMove.data.branchId + '/move-before/' + beforeNode.data.branchId);

        if (!resp.success) {
            alert(resp.message);
            return;
        }

        await changeNode(nodeToMove, node => node.moveTo(beforeNode, 'before'));
    }
}

async function moveAfterNode(nodesToMove, afterNode) {
    nodesToMove = filterRootNote(nodesToMove);

    if (afterNode.data.noteId === 'root') {
        alert('Cannot move notes after root note.');
        return;
    }

    nodesToMove.reverse(); // need to reverse to keep the note order

    for (const nodeToMove of nodesToMove) {
        const resp = await server.put('branches/' + nodeToMove.data.branchId + '/move-after/' + afterNode.data.branchId);

        if (!resp.success) {
            alert(resp.message);
            return;
        }

        await changeNode(nodeToMove, node => node.moveTo(afterNode, 'after'));
    }
}

async function moveToNode(nodesToMove, toNode) {
    nodesToMove = filterRootNote(nodesToMove);

    for (const nodeToMove of nodesToMove) {
        const resp = await server.put('branches/' + nodeToMove.data.branchId + '/move-to/' + toNode.data.noteId);

        if (!resp.success) {
            alert(resp.message);
            return;
        }

        await changeNode(nodeToMove, async node => {
            // first expand which will force lazy load and only then move the node
            // if this is not expanded before moving, then lazy load won't happen because it already contains node
            // this doesn't work if this isn't a folder yet, that's why we expand second time below
            await toNode.setExpanded(true);

            node.moveTo(toNode);

            toNode.folder = true;
            toNode.renderTitle();

            // this expands the note in case it become the folder only after the move
            await toNode.setExpanded(true);
        });
    }
}

function filterRootNote(nodes) {
    // some operations are not possible on root notes
    return nodes.filter(node => node.data.noteId !== 'root');
}

async function deleteNodes(nodes) {
    nodes = filterRootNote(nodes);

    if (nodes.length === 0 || !confirm('Are you sure you want to delete select note(s) and all the sub-notes?')) {
        return;
    }

    for (const node of nodes) {
        await server.remove('branches/' + node.data.branchId);
    }

    // following code assumes that nodes contain only top-most selected nodes - getSelectedNodes has been
    // called with stopOnParent=true
    let next = nodes[nodes.length - 1].getNextSibling();

    if (!next) {
        next = nodes[0].getPrevSibling();
    }

    if (!next && !utils.isTopLevelNode(nodes[0])) {
        next = nodes[0].getParent();
    }

    if (next) {
        // activate next element after this one is deleted so we don't lose focus
        next.setActive();

        treeService.setCurrentNotePathToHash(next);
    }

    infoService.showMessage("Note(s) has been deleted.");

    await treeService.reload();
}

async function moveNodeUpInHierarchy(node) {
    if (utils.isRootNode(node) || utils.isTopLevelNode(node)) {
        return;
    }

    const resp = await server.put('branches/' + node.data.branchId + '/move-after/' + node.getParent().data.branchId);

    if (!resp.success) {
        alert(resp.message);
        return;
    }

    if (!utils.isTopLevelNode(node) && node.getParent().getChildren().length <= 1) {
        node.getParent().folder = false;
        node.getParent().renderTitle();
    }

    await changeNode(node, node => node.moveTo(node.getParent(), 'after'));
}

async function changeNode(node, func) {
    utils.assertArguments(node.data.parentNoteId, node.data.noteId);

    const childNoteId = node.data.noteId;
    const oldParentNoteId = node.data.parentNoteId;

    await func(node);

    const newParentNoteId = node.data.parentNoteId = utils.isTopLevelNode(node) ? 'root' : node.getParent().data.noteId;

    await treeCache.moveNote(childNoteId, oldParentNoteId, newParentNoteId);

    treeService.setCurrentNotePathToHash(node);
}

export default {
    moveBeforeNode,
    moveAfterNode,
    moveToNode,
    deleteNodes,
    moveNodeUpInHierarchy
};