Class LoroTree<T>

createNode

• createNode(parent?: `${number}@${number}`, index?: number): LoroTreeNode<T>

  Create a new tree node as the child of parent and return a LoroTreeNode instance. If the parent is undefined, the tree node will be a root node.

  If the index is not provided, the new node will be appended to the end.

  Parameters

  • Optionalparent: `${number}@${number}`
  • Optionalindex: number

  Returns LoroTreeNode<T>

  Example

  import { LoroDoc } from "loro-crdt";
  
  const doc = new LoroDoc();
  const tree = doc.getTree("tree");
  const root = tree.createNode();
  const node = tree.createNode(undefined, 0);
  
  //  undefined
  //    /   \
  // node  root
  Copy

delete

• delete(target: `${number}@${number}`): void

  Parameters

  • target: `${number}@${number}`

  Returns void

• delete(target: `${number}@${number}`): void

  Delete a tree node from the forest.

  Parameters

  • target: `${number}@${number}`

  Returns void

  Example

  import { LoroDoc } from "loro-crdt";
  
  const doc = new LoroDoc();
  const tree = doc.getTree("tree");
  const root = tree.createNode();
  const node = root.createNode();
  tree.delete(node.id);
  Copy

disableFractionalIndex

• disableFractionalIndex(): void

  Disable the fractional index generation when you don't need the Tree's siblings to be sorted. The fractional index will always be set to the same default value 0.

  After calling this, you cannot use tree.moveTo(), tree.moveBefore(), tree.moveAfter(), and tree.createAt().

  Returns void

enableFractionalIndex

• enableFractionalIndex(jitter: number): void

  Set whether to generate a fractional index for moving and creating.

  A fractional index can be used to determine the position of tree nodes among their siblings.

  The jitter is used to avoid conflicts when multiple users are creating a node at the same position. A value of 0 is the default, which means no jitter; any value larger than 0 will enable jitter.

  Generally speaking, higher jitter value will increase the size of the operation Read more about it

  Parameters

  • jitter: number

  Returns void

free

• free(): void

  Returns void

getAttached

• getAttached(): undefined | LoroTree<Record<string, unknown>>

  Get the attached container associated with this.

  Returns an attached Container that equals to this or created by this, otherwise undefined.

  Returns undefined | LoroTree<Record<string, unknown>>

getNodeByID

• getNodeByID(target: `${number}@${number}`): undefined | LoroTreeNode<T>

  Get LoroTreeNode by the TreeID.

  Parameters

  • target: `${number}@${number}`

  Returns undefined | LoroTreeNode<T>

getNodes

• getNodes(options?: { withDeleted?: boolean }): LoroTreeNode<T>[]

  Parameters

  • Optionaloptions: { withDeleted?: boolean }

  Returns LoroTreeNode<T>[]

getShallowValue

• getShallowValue(): TreeNodeShallowValue[]

  Get the shallow value of the tree.

  Unlike toJSON() which recursively resolves nested containers to their values, getShallowValue() returns container IDs as strings for any nested containers.

  Returns TreeNodeShallowValue[]

  Example

  const doc = new LoroDoc();
  doc.setPeerId("1");
  const tree = doc.getTree("tree");
  const root = tree.createNode();
  root.data.set("name", "root");
  const text = root.data.setContainer("content", new LoroText());
  text.insert(0, "Hello");
  
  console.log(tree.getShallowValue());
  // [{
  //   id: "0@1",
  //   parent: null,
  //   index: 0,
  //   fractional_index: "80",
  //   meta: "cid:0@1:Map",
  //   children: []
  // }]
  
  console.log(tree.toJSON());
  // [{
  //   id: "0@1",
  //   parent: null,
  //   index: 0,
  //   fractional_index: "80",
  //   meta: {
  //     name: "root",
  //     content: "Hello"
  //   },
  //   children: []
  // }]
  Copy

has

• has(target: `${number}@${number}`): boolean

  Parameters

  • target: `${number}@${number}`

  Returns boolean

• has(target: `${number}@${number}`): boolean

  Return true if the tree contains the TreeID, include deleted node.

  Parameters

  • target: `${number}@${number}`

  Returns boolean

isAttached

• isAttached(): boolean

  Whether the container is attached to a document.

  If it's detached, the operations on the container will not be persisted.

  Returns boolean

isDeleted

• isDeleted(): boolean

  Check if the container is deleted

  Returns boolean

isFractionalIndexEnabled

• isFractionalIndexEnabled(): boolean

  Whether the tree enables the fractional index generation.

  Returns boolean

isNodeDeleted

• isNodeDeleted(target: `${number}@${number}`): boolean

  Return None if the node is not exist, otherwise return Some(true) if the node is deleted.

  Parameters

  • target: `${number}@${number}`

  Returns boolean

kind

• kind(): "Tree"

  "Tree"

  Returns "Tree"

move

• move(
      target: `${number}@${number}`,
      parent?: `${number}@${number}`,
      index?: number,
  ): void

  Parameters

  • target: `${number}@${number}`
  • Optionalparent: `${number}@${number}`
  • Optionalindex: number

  Returns void

• move(
      target: `${number}@${number}`,
      parent: undefined | `${number}@${number}`,
      index?: number,
  ): void

  Move the target tree node to be a child of the parent. It's not allowed that the target is an ancestor of the parent or the target and the parent are the same node.

  Parameters

  • target: `${number}@${number}`
  • parent: undefined | `${number}@${number}`
  • Optionalindex: number

  Returns void

  Example

  import { LoroDoc } from "loro-crdt";
  
  const doc = new LoroDoc();
  const tree = doc.getTree("tree");
  const root = tree.createNode();
  const node = root.createNode();
  const node2 = node.createNode();
  tree.move(node2.id, root.id);
  // Error will be thrown if move operation creates a cycle
  // tree.move(root.id, node.id);
  Copy

nodes

• nodes(): LoroTreeNode<Record<string, unknown>>[]

  Get all tree nodes of the forest, including deleted nodes.

  Returns LoroTreeNode<Record<string, unknown>>[]

  Example

  import { LoroDoc } from "loro-crdt";
  
  const doc = new LoroDoc();
  const tree = doc.getTree("tree");
  const root = tree.createNode();
  const node = root.createNode();
  const node2 = node.createNode();
  console.log(tree.nodes());
  Copy

parent

• parent(): undefined | Container

  Get the parent container of the tree container.

  • The parent container of the root tree is undefined.
  • The object returned is a new js object each time because it need to cross the WASM boundary.

  Returns undefined | Container

roots

• roots(): LoroTreeNode<Record<string, unknown>>[]

  Get the root nodes of the forest.

  Returns LoroTreeNode<Record<string, unknown>>[]

subscribe

• subscribe(listener: Listener): Subscription

  Parameters

  • listener: Listener

  Returns Subscription

toArray

• toArray(): TreeNodeValue[]

  Returns TreeNodeValue[]

toJSON

• toJSON(): any

  Get the hierarchy array with metadata of the forest.

  Returns any

  Example

  import { LoroDoc } from "loro-crdt";
  
  const doc = new LoroDoc();
  const tree = doc.getTree("tree");
  const root = tree.createNode();
  root.data.set("color", "red");
  // [ { id: '0@F2462C4159C4C8D1', parent: null, meta: { color: 'red' }, children: [] } ]
  console.log(tree.toJSON());
  Copy

constructor

• new LoroTree<T extends Record<string, unknown> = Record<string, unknown>>(): LoroTree<
      T,
  >

  Create a new detached LoroTree (not attached to any LoroDoc).

  The edits on a detached container will not be persisted. To attach the container to the document, please insert it into an attached container.

  Type Parameters

  • T extends Record<string, unknown> = Record<string, unknown>

  Returns LoroTree<T>

constructor

• new LoroTree(): LoroTree<T>

  Returns LoroTree<T>

Readonlyid