return (errorCode) => {
   if (errorCode) {
     m.startComputation()
     _errorCode = errorCode
     m.endComputation()
   }
   return _errorCode || ErrorCodes.NONE
 }

let search = (treeViewInstance, value) => {
  m.startComputation()

  let searchTerm = value.toLowerCase()

  if (willChange) {
    radio(PubSubTopics.TREE_STRUCTURE_CHANGED).unsubscribe(updateAllNodes)
    clearTimeout(willChange)
    m.endComputation()
  }
  let context = { treeViewInstance: treeViewInstance, searchTerm: searchTerm }
  willChange = setTimeout(updateAllNodes.bind(context), 300)
  // retrigger the search every time the tree structure changes (this happens when nodes are created/deleted)
  radio(PubSubTopics.TREE_STRUCTURE_CHANGED).subscribe([updateAllNodes, context])
}

 return function selectedAccessor(selected) {
   if (selected !== void 0) {
     cachedSelected = selected
     m.startComputation()
     if (selected) {
       // deselect all previously selected nodes
       root.selectedNodes().map((node) => {
         node.selected(false)
       })
       // override all previously cached selected nodes with the currently selected one
       root.selectedNodes([this])
     } else {
       root.selectedNodes(root.selectedNodes().filter((node) => {
         return node.id() !== this.id()
       }))
     }
     m.endComputation()
   }
   return cachedSelected
 }

let updateAllNodes = function () {
  let treeViewInstance = this.treeViewInstance
  let searchTerm = this.searchTerm
  let markSearchResult = (childNode) => {
    if (searchTerm && searchTerm !== '') {
      let searchTermFound = (childNode.title().toLowerCase().indexOf(searchTerm) > -1)
      childNode.highlighted(searchTermFound)
      childNode.blurred(!searchTermFound)
    } else {
      childNode.highlighted(false)
      childNode.blurred(false)
    }
  }
  treeViewInstance.getRootNodes().map((rootNode) => {
    if (rootNode.isLeaf()) {
      markSearchResult(rootNode)
    } else {
      rootNode.traverseChildNodes(markSearchResult)
    }
  })
  m.endComputation()
}

 return new Promise((resolve, reject) => {
   if (!childData) {
     reject('[createChild] Tree node creation failed: No data given! Please check your options.childData object.')
   } else if (!childData.id) {
     reject('[createChild] Tree node creation failed: No id given! Please ensure options.childData.id is filled with a "valid" id string.' +
       ' "Valid" id strings are based on HTML element ids.')
   } else if (!childData.title) {
     reject('[createChild] Tree node creation failed: No title given! Please ensure options.childData.title is filled with a string.')
   } else {
     childData.root = root
     childData.parent = nodeData
     childData.events = nodeData.events
     if (nodeData.errorCode() === ErrorCodes.NOT_FOUND) {
       nodeData.errorCode(ErrorCodes.NONE)
     }
     let newTreeNode = createNodeData(childData)
     let newChildList = nodeData.children()
     newChildList.push(newTreeNode)
     nodeData.children(newChildList)
     m.startComputation()
     resolve(newTreeNode)
     m.endComputation()
   }
 })

 fs.readFile(storedFileName, "utf-8", (err: any, data: any) => {
     m.startComputation();
     context.loadData(data);
     m.endComputation();
 });