Nested Sets для Javascript

//....
 return nstd.Structure.sort((a, b) => {
      if (a.lkey > b.lkey) return 1
      if (a.lkey < b.lkey) return -1
      return 0
    })

// better replace with 
 return nstd.Structure.sort((a, b) => a.lkey - b.lkey )

Это какой-то ужас, а не код...

Вот примеры того, как код писать нельзя:

  _nestedsets.removeItem = function (itemId) {
     // ...
     for (var i = 0; i < nstd.Structure.length; i++) {
        if (nstd.Structure[i].itemId === itemId) {
          var childs = nstd.getChilds(nstd.Structure[i]._id)

// ...

 _nestedsets.getChilds = function (nodeId, depth) {
    var nstd = this

    var parentNode = nstd.getNode(nodeId)

  _nestedsets.getNode = function (nodeId, asCopy) {
    var nstd = this

    var selectedNode = nstd.Structure.filter(n => n._id === nodeId)

Тут в массиве нод по индексу берётся _id, после чего сразу же в том же самом массиве выполняется по этому _id поиск...

          var childs = nstd.getChilds(nstd.Structure[i]._id)
          for (var j = 0; j < childs.length; j++) {
            nstd.removeNode(childs[j]._id)
          }

removeNode удаляет всё поддерево нод. Зачем тут вообще цикл и почему нельзя было написать просто nstd.removeNode(nstd.Structure[i]._id)?

На пустом месте оквадратили линейный алгоритм!

    var childs = nstd.getNodes().filter(n => {
      return n.lkey >= parentNode.lkey && n.rkey <= parentNode.rkey && nodeId !== n._id && (depth === undefined ? true : n.depth <= (parentNode.depth + depth))
    })

    // ...

      childs.sort((a, b) => {
        if (a.lkey > b.lkey) return 1
        if (a.lkey < b.lkey) return -1
        return 0
      })

getNodes() возвращает уже упорядоченный массив. Зачем его сортировать ещё раз по тому же самому свойству? С каких пор фильтрация сбивает сортировку?

      var results = []
      // ...
      .map(n => {
        n.data = nstd.Data[n.itemId]
        results.push(n)
      })
      childs = results

Ну а .map(n => nstd.Data[n.itemId]) не судьба написать было? Зачем тут вообще массив results?

И ещё вопрос: зачем использовать метод .map в качестве заменителя цикла for-of, если у массивов есть метод .forEach для тех же целей?

И ещё один пример как не надо писать в том же самом месте, что и прошлые два.

    if (childs.length > 0) {
      var results = []
      childs.sort((a, b) => {
        if (a.lkey > b.lkey) return 1
        if (a.lkey < b.lkey) return -1
        return 0
      }).map(n => {
        n.data = nstd.Data[n.itemId]
        results.push(n)
      })
      childs = results
    }

Зачем тут условный оператор? Что sort, что map на пустом массиве прекрасно работают. Если это была попытка оптимизации — то экономить надо в первую очередь на асимптотике, во вторую очередь на лишних массивах, и лишь в последнюю очередь на спичках.

Ну и последнее

var nstd = this

Зачем так делать в 2020м году? В стрелочных функциях this не "теряется", и его больше не требуется подобным способом "беречь".

Не говоря уже о том, что у вас уже есть переменная _nestedsets для тех же целей.

const maxId = Math.max(...this.Structure.map(o => o._id)) || 0

var arr = Array.from(Array(100000), () => ({_id: Math.round(Math.random() * 10000)}));
console.time('reduce');// 1180ms
for(var i = 0; i < 1000; i++)
    arr.reduce((a,{_id}) => (a > _id ? a : _id), -Infinity)
console.timeEnd('reduce');
console.time('rest args');// 1748ms
for(var i = 0; i < 1000; i++)
    Math.max(...arr.map(x => x._id))
console.timeEnd('rest args');