TagData.js

import AsyncStorage from "@react-native-async-storage/async-storage";

NodeDataKey = 'userDataRoot';
InitialData = { path: 'root', children: new Array() };

const getParsedNodeData = async () => {
  let jsonData = JSON.parse(await AsyncStorage.getItem(NodeDataKey));
  if (!jsonData || jsonData.path != 'root') {
    throw new Error("User data malformed!");
  }
  return jsonData;
}

const saveNodeData = async (rootNode) => {
  const jsonStringData = JSON.stringify(rootNode);
  await AsyncStorage.setItem(NodeDataKey, jsonStringData);
}

const getNodeByPath = (path, node) => {
  let pathCopy = path.slice(0);
  let pathComponent = pathCopy.shift();

  if (pathComponent != node.path) {
    return null;
  }

  if (!pathCopy.length) {
    return node;
  }

  for (i in node.children) {
    let childNode = getNodeByPath(pathCopy, node.children[i]);
    if (childNode) return childNode;
  }

  return null;
}

class TagData {
  // Never hold a reference to this object.
  constructor(rootNode) {
    this.rootNode = rootNode;
  }

  commit = async () => {
    try {
      await saveNodeData(this.rootNode);
    } catch (e) {
      console.error("Error saving user data:");
      console.error(e);
    }
  }

  static importJSONString = async (jsonString) => {
    try {
      let jsonData = JSON.parse(jsonString);
      if (!jsonData || jsonData.path != 'root') {
        console.log("Error parsing JSON data:");
        console.log("Root node should have an element \"path\" equal to \"root\".");
        console.log(data);
        throw new Error("FAILED: JSON data malformed!");
      } else {
        await saveNodeData(jsonData);
      }
    } catch (e) {
      console.log("Error parsing JSON data:");
      console.log(e);
      throw new Error("Data is not JSON!");
    }
  }

  static getRoot = async () => {
    try {
      const data = new TagData(await getParsedNodeData());
      console.log("Loaded user data");
      return data;
    } catch (e) {
      console.log(e);
      console.log("Reverting to empty set.");
      console.log(InitialData);
      return new TagData(JSON.parse(JSON.stringify(InitialData)));
    }
  }

  static clear = async () => {
    await AsyncStorage.removeItem(NodeDataKey);
  }

  getNodeByPath = (path) => {
    return getNodeByPath(path, this.rootNode);
  }

  toggleHighPriority = (path) => {
    let node = this.getNodeByPath(path);

    node.highPriority = !node.highPriority;
  }

  updatePath = (path, newItems, title) => {
    let node = this.getNodeByPath(path);

    // Early out if nothing is entered.
    if (node == undefined && newItems.length == 0 && !title) {
      return false;
    }

    if (!node) {
      node = {
        path: path.pop(),
        children: [],
        data: newItems,
        title: title,
      }
      let parent = this.getNodeByPath(path);
      parent.children.push(node);
    } else {
      node.data = newItems;
      node.title = title;
    }

    return true;
  }

  deleteNode = (path) => {
    let nodePath = path.pop();
    let parentNode = this.getNodeByPath(path);
    let nodeIdx = parentNode.children.findIndex((value) => {
      return value.path == nodePath;
    });
    parentNode.children.splice(nodeIdx, 1);
  }
}

export default TagData;