Class SortedTree<T>

Type Parameters

Hierarchy (view full)

Tree<T>
- SortedTree

Index

Constructors

Constructors

constructor

new SortedTree<T>(defaultComparator?): SortedTree<T>
Type Parameters
- T
Parameters
- Optional defaultComparator: Comparator<[string, T]>
Returns SortedTree<T>
Overrides Tree.constructor
- Defined in sortedtree.ts:13

Query

contains

contains(value): boolean
Checks if the tree contains a node with the given value.
Parameters
- value: T
  The value to check.
Returns boolean
True if a node with the given value exists in the tree; otherwise, false.
Inherited from Tree.contains
- Defined in tree.ts:80

contents(): {
[key: string]: ReadonlyTreeEntry<T>;
}
Gives access to the Tree store directly for reference reasons; Warning: cannot be modified, lest something get messed up with three internal state.

Returns {
[key: string]: ReadonlyTreeEntry<T>;
}
the tree store
- [key: string]: ReadonlyTreeEntry<T>
Inherited from Tree.contents
- Defined in tree.ts:163

depth

depth(key): number
Calculates the depth of the node with the given key in the tree. The depth is the number of ancestors a node has.
Parameters
- key: string
  The key of the node to calculate the depth for.
Returns number
The depth of the node.
Inherited from Tree.depth
- Defined in tree.ts:174

entry

entry(key): undefined | ReadonlyTreeEntry<T>
Gives access to the Tree Entry directly for reference reasons; Warning: cannot be modified, lest something get messed up with three internal state.
Parameters
- key: string
  The key of the node to get the entry of.
Returns undefined | ReadonlyTreeEntry<T>
the tree entry
Inherited from Tree.entry
- Defined in tree.ts:154

findIndexOf

findIndexOf(searcher): number
returns the index of a given key using the searcher predicate, or -1 if not found
Parameters
- searcher: KeyedDiscriminator<T>
Returns number
- Defined in sortedtree.ts:287

findKeyOf

findKeyOf(discriminator): undefined | string
Returns the key of the first node that satisfies the given discriminator function.
Parameters
- discriminator: Discriminator<T>
  The discriminator function.
Returns undefined | string
The key of the first node that satisfies the discriminator function, or undefined if not found.
Inherited from Tree.findKeyOf
- Defined in tree.ts:112

get

get(key): undefined | T
Gets the value associated with the node of the given key.
Parameters
- key: string
  The key of the node to get the value of.
Returns undefined | T
The value associated with the node.
Inherited from Tree.get
- Defined in tree.ts:144

has

has(key): boolean
Checks if the tree contains the specified key.
Parameters
- key: string
  The key to check.
Returns boolean
True if the key exists in the tree; otherwise, false.
Inherited from Tree.has
- Defined in tree.ts:70

indexOf

indexOf(key): number
returns the index of a given key, or -1 if the key is not present
Parameters
- key: string
Returns number
- Defined in sortedtree.ts:277

isLeaf

isLeaf(key): boolean
Checks if the node with the given key is a leaf node (has no children).
Parameters
- key: string
  The key of the node to check.
Returns boolean
True if the node is a leaf; otherwise, false.
Inherited from Tree.isLeaf
- Defined in tree.ts:134

isRoot

isRoot(key): boolean
Checks if the node with the given key is a root of the tree.
Parameters
- key: string
  The key of the node to check.
Returns boolean
True if the node is the root; otherwise, false.
Inherited from Tree.isRoot
- Defined in tree.ts:124

keyAt

keyAt(index): undefined | string
returns the key at a given index or undefined if index is out of bounds.
Parameters
- index: number
Returns undefined | string
- Defined in sortedtree.ts:212

keyOf

keyOf(value): undefined | string
Returns the key associated with the given value in the tree.
Parameters
- value: T
  The value to find the key for.
Returns undefined | string
The key associated with the value, or undefined if not found.
Inherited from Tree.keyOf
- Defined in tree.ts:100

keys

keys(): readonly string[]
Gives access to the sorted Tree keys directly for reference reasons; Warning: cannot be modified, lest something get messed up with three internal state.

Returns readonly string[]
the tree keys, in order
- Defined in sortedtree.ts:54

size

size(): number
How many entries are in the tree

Returns number
The number of entries.
Inherited from Tree.size
- Defined in tree.ts:183

some

some(discriminator): boolean
Checks if any node in the tree satisfies the given discriminator function.
Parameters
- discriminator: Discriminator<T>
  The discriminator function.
Returns boolean
True if any node satisfies the discriminator function; otherwise, false.
Inherited from Tree.some
- Defined in tree.ts:90

subtreeCount

subtreeCount(): number
How many subtrees are in the tree

Returns number
The number of subtrees
Inherited from Tree.subtreeCount
- Defined in tree.ts:192

subtrees

subtrees(): Tree<T>[]
splits out each subtree as a member of an array

Returns Tree<T>[]
an array of subtrees.
Inherited from Tree.subtrees
- Defined in tree.ts:600

valueAt

valueAt(index): undefined | T
returns the value at a given index or undefined if index is out of bounds.
Parameters
- index: number
Returns undefined | T
- Defined in sortedtree.ts:225

Modify

add

add(key, parent, value): void
Adds a new node to the tree with the given key, parent, and value. If a node with the given key already exists in the tree, this method does nothing.
Parameters
- key: string
  The key of the new node to add.
- parent: null | string
  The key of the parent node for the new node. Use null if the node is a root node.
- value: T
  The value associated with the new node.
Returns void
Overrides Tree.add
- Defined in sortedtree.ts:375

addLeaf

addLeaf(key, parent, value): void
Adds a new node to the tree with the given key, parent, and value. If a node with the given key already exists in the tree, this method does nothing.
Parameters
- key: string
  The key of the new node to add.
- parent: string
  The key of the parent node for the new node.
- value: T
  The value associated with the new node.
Returns void
Inherited from Tree.addLeaf
- Defined in tree.ts:248

addRoot

addRoot(key, value): void
Adds a new root to the tree with the given key, and value. If a node with the given key already exists in the tree, this method does nothing.
Parameters
- key: string
  The key of the new node to add.
- value: T
  The value associated with the new node.
Returns void
Inherited from Tree.addRoot
- Defined in tree.ts:236

clear

clear(): void
Empties the whole forest

Returns void
Overrides Tree.clear
- Defined in sortedtree.ts:347

condense

condense(merger): void
Condenses the tree by merging nodes with one child with that one child using the provided merger function. The merger function takes two adjacent nodes 'parent' and 'child', and if applicable, returns a new merged node 'r'. If the merger function returns void, no merge is performed between 'parent' and 'child'.
Parameters
- merger: ((a, b) => void | {
  key: string;
  value: T;
  })
  The function to merge adjacent nodes with single children.
  - - (a, b): void | {
      key: string;
      value: T;
      }
    - Parameters
      a: TreeEntry<T>
      b: TreeEntry<T>
      Returns void | {
      key: string;
      value: T;
      }
Returns void
Overrides Tree.condense
- Defined in sortedtree.ts:505

detach

detach(key): void
Detaches a part of a tree at the given key, and makes that node the root of a new subtree within this tree.
Parameters
- key: null | string
  The key of the node to be detatched - the new root of it's own subtree.
Returns void
Overrides Tree.detach
- Defined in sortedtree.ts:514

emplace

emplace(key, parent, value): void
Adds a node to a given parent if it doesn't exist, otherweise will update an existing node and move the node to be a child of the designated parent
Parameters
- key: string
  The key of the node to update.
- parent: null | string
  If the node is to be inserted, it will become a child of this node, otherwise it is ignored
- value: T
  The new value to set for the node.
Returns void
Inherited from Tree.emplace
- Defined in tree.ts:318

emplaceWith

emplaceWith(key, parent, updater): void
Adds a node to a given parent if it doesn't exist, otherweise will update an existing node and move the node to be a child of the designated parent
Parameters
- key: string
  The key of the node to update.
- parent: null | string
  If the node is to be inserted, it will become a child of this node, otherwise it is ignored
- updater: Updater<undefined | T, T>
  The callback that will take in the previous value and return the new value.
Returns void
Inherited from Tree.emplaceWith
- Defined in tree.ts:334

graft

graft(sapling, saplingRoot, graftPoint): void
Grafts a sapling tree into the current tree, connecting it to a specific node. The sapling tree will be added as a subtree rooted at the graft point in the current tree.
Parameters
- sapling: Tree<T>
  The sapling tree to graft into the current tree.
- saplingRoot: string
  The key of the root node of the sapling tree to graft.
- graftPoint: string
  The key of the node in the current tree where the sapling will be grafted.
Returns void
Inherited from Tree.graft
- Defined in tree.ts:393

move

move(key, parent): void
Will move a node, and by extension its children, to under the designated new parent If the node does not exist, this method does nothing.
Parameters
- key: string
  The key of the node to update.
- parent: null | string
  The new parent node.
Returns void
Overrides Tree.move
- Defined in sortedtree.ts:427

pluck

pluck(key): undefined | T
Removes the node with the given key from the tree. that node's childrens become detached within the original tree as additional roots.
Parameters
- key: string
  The key of the node to be removed from the tree.
Returns undefined | T
The value of the node that was removed, or undefined if the node does not exist.
Overrides Tree.pluck
- Defined in sortedtree.ts:460

populate

populate<F>(list, allocator): void
Given a list of nodes, allocate them into the forest.
Type Parameters
- F
Parameters
- list: Iterable<F>
- allocator: ((data) => void | IterableOr<{
      key: string;
      parent: null | string;
      value: T;
  }>)
  - - (data): void | IterableOr<{
          key: string;
          parent: null | string;
          value: T;
      }>
    - Parameters
      data: F
      Returns void | IterableOr<{
          key: string;
          parent: null | string;
          value: T;
      }>
Returns void
Overrides Tree.populate
- Defined in sortedtree.ts:355

populateAsync

populateAsync<F>(list, allocator): Promise<void>
Given a list of nodes, allocate them into the forest, but asynchronously
Type Parameters
- F
Parameters
- list: Iterable<F>
- allocator: ((data) => Promise<void | IterableOr<{
      key: string;
      parent: null | string;
      value: T;
  }>>)
  - - (data): Promise<void | IterableOr<{
          key: string;
          parent: null | string;
          value: T;
      }>>
    - Parameters
      data: F
      Returns Promise<void | IterableOr<{
          key: string;
          parent: null | string;
          value: T;
      }>>
Returns Promise<void>
Overrides Tree.populateAsync
- Defined in sortedtree.ts:364

prune

prune(key): SortedTree<T>
Creates a new tree by pruning the subtree rooted at the node with the given key from the original tree. The pruned tree includes the node and its descendants as a new tree instance. Items are removed from the original tree.
Parameters
- key: string
  The key of the node that serves as the root of the subtree to be pruned.
Returns SortedTree<T>
A new Tree instance representing the pruned subtree.
Overrides Tree.prune
- Defined in sortedtree.ts:472

sort

sort(comparator?): void
Sorts the tree in place.
Parameters
- Optional comparator: Comparator<[string, T]>
  override the default comparator with this comparator
Returns void
- Defined in sortedtree.ts:246

splice

splice(key): undefined | T
Removes the node with the given key from the tree and splices its children into its parent's children list.
Parameters
- key: string
  The key of the node to be spliced.
Returns undefined | T
The value of the node that was spliced, or undefined if the node does not exist.
Overrides Tree.splice
- Defined in sortedtree.ts:493

sprout

sprout(key, generation): void
Adds multiple child nodes to an existing node in the tree with the given key. If the node does not exist, this method does nothing.
Parameters
- key: string
  The key of the node to which children should be added.
- generation: Iterable<[string, T]> | {
      [key: string]: T;
  } | Iterable<{
      key: string;
      value: T;
  }>
  An iterable of [string, T] pairs, or an object with key-value pairs, or an iterable of { key: string, value: T } objects.
Returns void
Inherited from Tree.sprout
- Defined in tree.ts:411

trim

trim(key): undefined | T
Removes a node so long as it has no children, otherwise, does nothing.
Parameters
- key: string
  The key of the node to be removed.
Returns undefined | T
The value removed or undefined if it was not removed or the node was not present.
Overrides Tree.trim
- Defined in sortedtree.ts:437

truncate

truncate(key): undefined | {
[key: string]: T;
}
Truncates the subtree rooted at the node with the given key from the tree and returns a key-value collection of those removed. The original tree will no longer include the node and its descendants.
Parameters
- key: string
  The key of the node that serves as the root of the subtree to be truncated.
Returns undefined | {
[key: string]: T;
}
An object representing the truncated subtree, where the keys are the keys of the nodes, and the values are the values associated with each node (or undefined if the node was not present)
Overrides Tree.truncate
- Defined in sortedtree.ts:448

update

update(key, value): void
Updates the value of an existing node in the tree with the given key. If the node does not exist, this method does nothing.
Parameters
- key: string
  The key of the node to update.
- value: T | Updater<T>
  The new value to set for the node.
Returns void
Inherited from Tree.update
- Defined in tree.ts:259

updateWith

updateWith(key, updater): void
Updates the value of an existing node in the tree with the given key. If the node does not exist, this method does nothing.
Parameters
- key: string
  The key of the node to update.
- updater: Updater<T>
  The callback that will take in the previous value and return the new value
Returns void
Inherited from Tree.updateWith
- Defined in tree.ts:273

upsert

upsert(key, parent, value): void
Adds a node to a given parent if it doesn't exist, otherweise will update an existing node and ignore parent
Parameters
- key: string
  The key of the node to update.
- parent: null | string
  If the node is to be inserted, it will become a child of this node, otherwise it is ignored
- value: T
  The new value to set for the node.
Returns void
Inherited from Tree.upsert
- Defined in tree.ts:287

upsertWith

upsertWith(key, parent, updater): void
Adds a node to a given parent if it doesn't exist, otherweise will update an existing node and ignore parent
Parameters
- key: string
  The key of the node to update.
- parent: null | string
  If the node is to be inserted, it will become a child of this node, otherwise it is ignored
- updater: Updater<undefined | T, T>
  The callback that will take in the previous value and return the new value.
Returns void
Inherited from Tree.upsertWith
- Defined in tree.ts:302

Hierarchy / Ancestors

ancestorCollection

ancestorCollection(key): {
[key: string]: T;
}
Returns an object representing the ancestors nodes of the given node, with keys as node keys and values as node values, from closest to root.
Parameters
- key: string
  The key of the node for which to find the ancestors.
Returns {
[key: string]: T;
}
An array of values representing the ancestor nodes.
- [key: string]: T
Inherited from Tree.ancestorCollection
- Defined in tree.ts:867

ancestorKeys

ancestorKeys(key): string[]
Returns an array of keys representing the ancestor nodes of the node with the given key, from closest to root.
Parameters
- key: string
  The key of the node for which to find the ancestors.
Returns string[]
An array of keys representing the ancestor nodes.
Inherited from Tree.ancestorKeys
- Defined in tree.ts:820

ancestorPairs

ancestorPairs(key): {
key: string;
value: T;
}[]
Returns an array of objects representing the ancestor keys and nodes of the node with the given key, from closest to root.
Parameters
- key: string
  The key of the node for which to find the ancestors.
Returns {
key: string;
value: T;
}[]
An array of values representing the ancestor nodes.
Inherited from Tree.ancestorPairs
- Defined in tree.ts:880

ancestorTuples

ancestorTuples(key): [string, T][]
Returns an array of tuples representing the ancestor keys and nodes of the node with the given key, from closest to root.
Parameters
- key: string
  The key of the node for which to find the ancestors.
Returns [string, T][]
An array of values representing the ancestor nodes.
Inherited from Tree.ancestorTuples
- Defined in tree.ts:857

ancestorValues

ancestorValues(key): T[]
Returns an array of values representing the ancestor nodes of the node with the given key, from closest to root.
Parameters
- key: string
  The key of the node for which to find the ancestors.
Returns T[]
An array of values representing the ancestor nodes.
Inherited from Tree.ancestorValues
- Defined in tree.ts:847

ancestors

ancestors(key): T[]
Returns an array of values representing the ancestor nodes of the node with the given key, from closest to root.
Parameters
- key: string
  The key of the node for which to find the ancestors.
Returns T[]
An array of values representing the ancestor nodes.

Alias
ancestorValues
Inherited from Tree.ancestors
- Defined in tree.ts:837

mapAncestors

mapAncestors<R>(mapper, key): R[]
Maps a function to each ancestors of the target node, from closest to root.
Type Parameters
- R
  The type of the result.
Parameters
- mapper: KeyedMapper<T, string, R>
  The mapping function to be applied. It takes three arguments:
  - value (type T): The value associated with the current node being processed.
  - key (string): The key of the current node being processed.
  - i (number): The index of the current node in the ancestor line.
- key: string
  the node from which to iterate the descendents from
Returns R[]
- An array containing the results of applying the mapper to all nodes.
Inherited from Tree.mapAncestors
- Defined in tree.ts:937

mapAncestorsDownwards

mapAncestorsDownwards<R>(mapper, key): R[]
Maps a function to each ancestors of the target node, from root to closest.
Type Parameters
- R
  The type of the result.
Parameters
- mapper: KeyedMapper<T, string, R>
  The mapping function to be applied. It takes three arguments:
  - value (type T): The value associated with the current node being processed.
  - key (string): The key of the current node being processed.
  - i (number): The index of the current node in the ancestor line.
- key: string
  the node from which to iterate the descendents from
Returns R[]
- An array containing the results of applying the mapper to all nodes.
Inherited from Tree.mapAncestorsDownwards
- Defined in tree.ts:955

reduceAncestors

reduceAncestors<R>(reducer, start, key): R
Applies a reducer function to each ancestors in the tree from the given node, from closest to root
Type Parameters
- R = void
Parameters
- reducer: KeyedReducer<T, string, R>
  The reducer function to be applied. It takes four arguments:
  - key (string): The key of the current node being processed.
  - value (type T): The value associated with the current node being processed.
  - i (number): The index of the current node in the ancestor list traversal.
  - accumulation (type R): The accumulated result from previous reductions.
- start: R
  The initial value of the accumulator for the reduction.
- key: string
  the node from which to traverse upward from
Returns R
The final accumulated result after applying the reducer to all nodes.
Inherited from Tree.reduceAncestors
- Defined in tree.ts:899

reduceAncestorsDownwards

reduceAncestorsDownwards<R>(reducer, start, key): R
Applies a reducer function to each ancestors in the tree from the given node, from root to closest
Type Parameters
- R = void
Parameters
- reducer: KeyedReducer<T, string, R>
  The reducer function to be applied. It takes four arguments:
  - key (string): The key of the current node being processed.
  - value (type T): The value associated with the current node being processed.
  - i (number): The index of the current node in the ancestor list traversal.
  - accumulation (type R): The accumulated result from previous reductions.
- start: R
  The initial value of the accumulator for the reduction.
- key: string
  the node from which to traverse upward from
Returns R
The final accumulated result after applying the reducer to all nodes.
Inherited from Tree.reduceAncestorsDownwards
- Defined in tree.ts:917

Hierarchy / Children

children

children(key): T[]
Returns an array of values representing the child nodes of the node with the given key.
Parameters
- key: string
  The key of the node for which to find the children.
Returns T[]
An array of values representing the child nodes.

Alias
childrenValues
Inherited from Tree.children
- Defined in tree.ts:980

childrenCollection

childrenCollection(key): {
[key: string]: T;
}
Returns an object representing the children nodes of the given node, with keys as node keys and values as node values.
Parameters
- key: string
  The key of the node for which to find the children.
Returns {
[key: string]: T;
}
An array of values representing the child nodes.
- [key: string]: T
Inherited from Tree.childrenCollection
- Defined in tree.ts:1010

childrenKeys

childrenKeys(key): string[]
Returns an array of keys representing the child nodes of the node with the given key.
Parameters
- key: string
  The key of the node for which to find the children.
Returns string[]
An array of keys representing the child nodes.
Inherited from Tree.childrenKeys
- Defined in tree.ts:969

childrenPairs

childrenPairs(key): {
key: string;
value: T;
}[]
Returns an array of objects representing the children keys and nodes of the node with the given key.
Parameters
- key: string
  The key of the node for which to find the children.
Returns {
key: string;
value: T;
}[]
An array of values representing the children nodes.
Inherited from Tree.childrenPairs
- Defined in tree.ts:1023

childrenTuples

childrenTuples(key): [string, T][]
Returns an array of tuples representing the children keys of the given node
Parameters
- key: string
  The key of the node for which to find the children.
Returns [string, T][]
An array of values representing the children nodes.
Inherited from Tree.childrenTuples
- Defined in tree.ts:1000

childrenValues

childrenValues(key): T[]
Returns an array of values representing the child nodes of the node with the given key.
Parameters
- key: string
  The key of the node for which to find the children.
Returns T[]
An array of values representing the child nodes.
Inherited from Tree.childrenValues
- Defined in tree.ts:990

mapChildren

mapChildren<R>(mapper, key): R[]
Maps a function to each child of the target node.
Type Parameters
- R
  The type of the result.
Parameters
- mapper: KeyedMapper<T, string, R>
  The mapping function to be applied. It takes three arguments:
  - value (type T): The value associated with the current node being processed.
  - key (string): The key of the current node being processed.
  - i (number): The index of the current node in the child.
- key: string
  the node from which to get children from
Returns R[]
- An array containing the results of applying the mapper to all nodes.
Inherited from Tree.mapChildren
- Defined in tree.ts:1060

reduceChildren

reduceChildren<R>(reducer, start, key): R
Applies a reducer function to each child of the given node
Type Parameters
- R = void
Parameters
- reducer: KeyedReducer<T, string, R>
  The reducer function to be applied. It takes four arguments:
  - key (string): The key of the current node being processed.
  - value (type T): The value associated with the current node being processed.
  - i (number): The index of the current node in the child.
  - accumulation (type R): The accumulated result from previous reductions.
- start: R
  The initial value of the accumulator for the reduction.
- key: string
  the node from which to get children from
Returns R
The final accumulated result after applying the reducer to all nodes.
Inherited from Tree.reduceChildren
- Defined in tree.ts:1042

Hierarchy / Descendents

deepDescendentCollection

deepDescendentCollection(key): {
[key: string]: T;
}
Returns an object representing the descendent nodes of the given node, with keys as node keys and values as node values in depth-first order.
Parameters
- key: string
  The key of the node for which to find the descendents.
Returns {
[key: string]: T;
}
An array of values representing the descendents nodes.
- [key: string]: T
Inherited from Tree.deepDescendentCollection
- Defined in tree.ts:1344

deepDescendentKeys

deepDescendentKeys(key): string[]
Returns an array of keys representing the descendant nodes of the node with the given key in depth-first order.
Parameters
- key: string
  The key of the node for which to find the descendants.
Returns string[]
An array of keys representing the descendant nodes.
Inherited from Tree.deepDescendentKeys
- Defined in tree.ts:1297

deepDescendentPairs

deepDescendentPairs(key): {
key: string;
value: T;
}[]
Returns an array of objects representing the descendent keys and nodes of the node with the given key in depth-first order.
Parameters
- key: string
  The key of the node for which to find the descendents.
Returns {
key: string;
value: T;
}[]
An array of values representing the descendent nodes.
Inherited from Tree.deepDescendentPairs
- Defined in tree.ts:1357

deepDescendentTuples

deepDescendentTuples(key): [string, T][]
Returns an array of tuples representing the descemdemt keys and nodes of the node with the given key in depth-first order.
Parameters
- key: string
  The key of the node for which to find the descendents.
Returns [string, T][]
An array of values representing the descendent nodes.
Inherited from Tree.deepDescendentTuples
- Defined in tree.ts:1334

deepDescendentValues

deepDescendentValues(key): T[]
Returns an array of values representing the descendant nodes of the node with the given key in depth-first order.
Parameters
- key: string
  The key of the node for which to find the descendants.
Returns T[]
An array of values representing the descendant nodes.
Inherited from Tree.deepDescendentValues
- Defined in tree.ts:1324

deepDescendents

deepDescendents(key): T[]
Returns an array of values representing the descendant nodes of the node with the given key in depth-first order.
Parameters
- key: string
  The key of the node for which to find the descendants.
Returns T[]
An array of values representing the descendant nodes.

Alias
deepDescendentValues
Inherited from Tree.deepDescendents
- Defined in tree.ts:1314

mapDeepDescendents

mapDeepDescendents<R>(mapper, key): R[]
Maps a function to each descendent of the target node in a depth-order traversal.
Type Parameters
- R
  The type of the result.
Parameters
- mapper: KeyedMapper<T, string, R>
  The mapping function to be applied. It takes three arguments:
  - value (type T): The value associated with the current node being processed.
  - key (string): The key of the current node being processed.
  - i (number): The index of the current node in the depth-order traversal.
- key: string
  the node from which to iterate the descendents from
Returns R[]
- An array containing the results of applying the mapper to all nodes.
Inherited from Tree.mapDeepDescendents
- Defined in tree.ts:1394

mapWideDescendents

mapWideDescendents<R>(mapper, key): R[]
Maps a function to each descendent of the target node in a wide-order traversal.
Type Parameters
- R
  The type of the result.
Parameters
- mapper: KeyedMapper<T, string, R>
  The mapping function to be applied. It takes three arguments:
  - value (type T): The value associated with the current node being processed.
  - key (string): The key of the current node being processed.
  - i (number): The index of the current node in the wide-order traversal.
- key: string
  the node from which to iterate the descendents from
Returns R[]
- An array containing the results of applying the mapper to all nodes.
Inherited from Tree.mapWideDescendents
- Defined in tree.ts:1285

reduceDeepDescendents

reduceDeepDescendents<R>(reducer, start, key): R
Applies a reducer function to each descendent in the tree in a depth-first traversal.
Type Parameters
- R = void
Parameters
- reducer: KeyedReducer<T, string, R>
  The reducer function to be applied. It takes four arguments:
  - key (string): The key of the current node being processed.
  - value (type T): The value associated with the current node being processed.
  - i (number): The index of the current node in the depth-first traversal.
  - accumulation (type R): The accumulated result from previous reductions.
- start: R
  The initial value of the accumulator for the reduction.
- key: string
  the node from which to iterate the descendents from
Returns R
The final accumulated result after applying the reducer to all nodes.
Inherited from Tree.reduceDeepDescendents
- Defined in tree.ts:1376

reduceWideDescendents

reduceWideDescendents<R>(reducer, start, key): R
Applies a reducer function to each descendent in the tree in a width-first traversal.
Type Parameters
- R = void
Parameters
- reducer: KeyedReducer<T, string, R>
  The reducer function to be applied. It takes four arguments:
  - key (string): The key of the current node being processed.
  - value (type T): The value associated with the current node being processed.
  - i (number): The index of the current node in the width-first traversal.
  - accumulation (type R): The accumulated result from previous reductions.
- start: R
  The initial value of the accumulator for the reduction.
- key: string
  the node from which to iterate the descendents from
Returns R
The final accumulated result after applying the reducer to all nodes.
Inherited from Tree.reduceWideDescendents
- Defined in tree.ts:1267

wideDescendentCollection

wideDescendentCollection(key): {
[key: string]: T;
}
Returns an object representing the descendent nodes of the given node, with keys as node keys and values as node values in width-first order.
Parameters
- key: string
  The key of the node for which to find the descendents.
Returns {
[key: string]: T;
}
An array of values representing the descendents nodes.
- [key: string]: T
Inherited from Tree.wideDescendentCollection
- Defined in tree.ts:1235

wideDescendentKeys

wideDescendentKeys(key): string[]
Returns an array of keys representing the descendant nodes of the node with the given key.
Parameters
- key: string
  The key of the node for which to find the descendants.
Returns string[]
An array of keys representing the descendant nodes.
Inherited from Tree.wideDescendentKeys
- Defined in tree.ts:1182

wideDescendentPairs

wideDescendentPairs(key): {
key: string;
value: T;
}[]
Returns an array of objects representing the descendent keys and nodes of the node with the given key in width-first order.
Parameters
- key: string
  The key of the node for which to find the descendents.
Returns {
key: string;
value: T;
}[]
An array of values representing the descendent nodes.
Inherited from Tree.wideDescendentPairs
- Defined in tree.ts:1248

wideDescendentTuples

wideDescendentTuples(key): [string, T][]
Returns an array of tuples representing the descemdemt keys and nodes of the node with the given key in width-first order.
Parameters
- key: string
  The key of the node for which to find the descendents.
Returns [string, T][]
An array of values representing the descendent nodes.
Inherited from Tree.wideDescendentTuples
- Defined in tree.ts:1225

wideDescendentValues

wideDescendentValues(key): T[]
Returns an array of values representing the descendant nodes of the node with the given key.
Parameters
- key: string
  The key of the node for which to find the descendants.
Returns T[]
An array of values representing the descendant nodes.
Inherited from Tree.wideDescendentValues
- Defined in tree.ts:1215

wideDescendents

wideDescendents(key): T[]
Returns an array of values representing the descendant nodes of the node with the given key.
Parameters
- key: string
  The key of the node for which to find the descendants.
Returns T[]
An array of values representing the descendant nodes.

Alias
wideDescendentValues
Inherited from Tree.wideDescendents
- Defined in tree.ts:1205

Hierarchy / Leaves

leafCollection

leafCollection(origin?, ...moreOrigins?): {
[key: string]: T;
}
Returns an object representing the leaf nodes of the tree, with keys as node keys and values as node values.
Parameters
- Optional origin: string | string[]
  where the traversal begins. If unspecified, will be all root nodes, thus traversal the whole forest.
- Optional Rest ...moreOrigins: string[]
Returns {
[key: string]: T;
}
An object representing the leaf nodes.
- [key: string]: T
Inherited from Tree.leafCollection
- Defined in tree.ts:1561

leafKeys

leafKeys(origin?, ...moreOrigins): string[]
Returns an array of keys representing the leaf nodes of the tree.
Parameters
- origin: string | string[] = ...
- Rest ...moreOrigins: string[]
Returns string[]
An array of keys representing the leaf nodes.
Overrides Tree.leafKeys
- Defined in sortedtree.ts:327

leafPairs

leafPairs(origin?, ...moreOrigins?): {
key: string;
value: T;
}[]
Returns an array of objects object representing the leaf keys and value of the tree.
Parameters
- Optional origin: string | string[]
  where the traversal begins. If unspecified, will be all root nodes, thus traversal the whole forest.
- Optional Rest ...moreOrigins: string[]
Returns {
key: string;
value: T;
}[]
An object representing the leaf nodes.
Inherited from Tree.leafPairs
- Defined in tree.ts:1575

leafTuples

leafTuples(origin?, ...moreOrigins?): [string, T][]
Returns an array of key-value pairs representing the leaf nodes of the tree.
Parameters
- Optional origin: string | string[]
  where the traversal begins. If unspecified, will be all root nodes, thus traversal the whole forest.
- Optional Rest ...moreOrigins: string[]
Returns [string, T][]
An array of key-value pairs representing the leaf nodes.
Inherited from Tree.leafTuples
- Defined in tree.ts:1550

leafValues

leafValues(origin?, ...moreOrigins?): T[]
Returns an array of values representing the leaf nodes of the tree.
Parameters
- Optional origin: string | string[]
  where the traversal begins. If unspecified, will be all root nodes, thus traversal the whole forest.
- Optional Rest ...moreOrigins: string[]
Returns T[]
An array of values representing the leaf nodes.
Inherited from Tree.leafValues
- Defined in tree.ts:1539

leaves

leaves(origin?, ...moreOrigins?): T[]
Returns an array of values representing the leaf nodes of the tree.
Parameters
- Optional origin: string | string[]
  where the traversal begins. If unspecified, will be all root nodes, thus traversal the whole forest.
- Optional Rest ...moreOrigins: string[]
Returns T[]
An array of values representing the leaf nodes.

Alias
leafValues
Inherited from Tree.leaves
- Defined in tree.ts:1528

mapLeaves

mapLeaves<R>(mapper, origin?, ...moreOrigins?): R[]
Maps a function to each sibling of the target node.
Type Parameters
- R
  The type of the result.
Parameters
- mapper: KeyedMapper<T, string, R>
  The mapping function to be applied. It takes three arguments:
  - value (type T): The value associated with the current node being processed.
  - key (string): The key of the current node being processed.
  - i (number): The index of the current node in the sibling.
- Optional origin: string | string[]
  where the traversal begins. If unspecified, will be all root nodes, thus traversal the whole forest.
- Optional Rest ...moreOrigins: string[]
Returns R[]
- An array containing the results of applying the mapper to all nodes.
Inherited from Tree.mapLeaves
- Defined in tree.ts:1614

reduceLeaves

reduceLeaves<R>(reducer, start, origin?, ...moreOrigins?): R
Applies a reducer function to each sibling of the given node
Type Parameters
- R = void
Parameters
- reducer: KeyedReducer<T, string, R>
  The reducer function to be applied. It takes four arguments:
  - key (string): The key of the current node being processed.
  - value (type T): The value associated with the current node being processed.
  - i (number): The index of the current node in the sibling.
  - accumulation (type R): The accumulated result from previous reductions.
- start: R
  The initial value of the accumulator for the reduction.
- Optional origin: string | string[]
  where the traversal begins. If unspecified, will be all root nodes, thus traversal the whole forest.
- Optional Rest ...moreOrigins: string[]
Returns R
The final accumulated result after applying the reducer to all nodes.
Inherited from Tree.reduceLeaves
- Defined in tree.ts:1595

Hierarchy / Parent

parent

parent(key): undefined | T
Returns the value of the parent node of the node with the given key.
Parameters
- key: string
  The key of the node for which to find the parent.
Returns undefined | T
The value of the parent node, or undefined if the node has no parent or the key does not exist.

Alias
parentValue
Inherited from Tree.parent
- Defined in tree.ts:775

parentKey

parentKey(key): undefined | null | string
Returns the key of the parent node of the node with the given key.
Parameters
- key: string
  The key of the node for which to find the parent.
Returns undefined | null | string
The key of the parent node as a string, or null if the node has no parent, or undefined if the node was not in the key
Inherited from Tree.parentKey
- Defined in tree.ts:761

parentPair

parentPair(key): {
key: undefined | null | string;
value: undefined | T;
}
Returns an objects representing the pareent key and node of the given node.
Parameters
- key: string
  The key of the node for which to find the parent.
Returns {
key: undefined | null | string;
value: undefined | T;
}
An object representing the parent node.
- key: undefined | null | string
- value: undefined | T
Inherited from Tree.parentPair
- Defined in tree.ts:810

parentTuple

parentTuple(key): [undefined | null | string, undefined | T]
Returns a tuples representing this nodes parent key and value.
Parameters
- key: string
  The key of the node for which to find the parent.
Returns [undefined | null | string, undefined | T]
A tuple consistent of the parent key and value, if applicable.
Inherited from Tree.parentTuple
- Defined in tree.ts:800

parentValue

parentValue(key): undefined | T
Returns the value of the parent node of the node with the given key.
Parameters
- key: string
  The key of the node for which to find the parent.
Returns undefined | T
The value of the parent node, or undefined if the node has no parent or the key does not exist.
Inherited from Tree.parentValue
- Defined in tree.ts:785

Hierarchy / Root

mapRoots

mapRoots<R>(mapper): R[]
Maps a function to each root of the tree.
Type Parameters
- R
  The type of the result.
Parameters
- mapper: KeyedMapper<T, string, R>
  The mapping function to be applied. It takes three arguments:
  - value (type T): The value associated with the current node being processed.
  - key (string): The key of the current node being processed.
  - i (number): The index of the current node in the root list.
Returns R[]
- An array containing the results of applying the mapper to all root nodes.
Inherited from Tree.mapRoots
- Defined in tree.ts:1491

reduceRoots

reduceRoots<R>(reducer, start): R
Applies a reducer function to each root of the tree
Type Parameters
- R = void
Parameters
- reducer: KeyedReducer<T, string, R>
  The reducer function to be applied. It takes four arguments:
  - key (string): The key of the current node being processed.
  - value (type T): The value associated with the current node being processed.
  - i (number): The index of the current node in the root list.
  - accumulation (type R): The accumulated result from previous reductions.
- start: R
  The initial value of the accumulator for the reduction.
Returns R
The final accumulated result after applying the reducer to all root nodes.
Inherited from Tree.reduceRoots
- Defined in tree.ts:1474

rootCollection

rootCollection(): {
[key: string]: T;
}
Returns an object representing the root nodes of the tree, with keys as node keys and values as node values.

Returns {
[key: string]: T;
}
An object representing the root nodes.
- [key: string]: T
Inherited from Tree.rootCollection
- Defined in tree.ts:1444

rootKeyOf

rootKeyOf(key): undefined | string
Get the root key of the subtree that this key is in.
Parameters
- key: string
  The key to check.
Returns undefined | string
The root key in question.
Inherited from Tree.rootKeyOf
- Defined in tree.ts:740

rootKeys

rootKeys(): string[]
Returns an array of keys representing the root nodes of the tree.

Returns string[]
An array of keys representing the root nodes.
Overrides Tree.rootKeys
- Defined in sortedtree.ts:318

rootPairs

rootPairs(): {
key: string;
value: T;
}[]
Returns an array of objects representing the root keys and nodes of the tree.

Returns {
key: string;
value: T;
}[]
An array of values representing the sibling nodes.
Inherited from Tree.rootPairs
- Defined in tree.ts:1456

rootTuples

rootTuples(): [string, T][]
Returns an array of key-value pairs representing the root nodes of the tree.

Returns [string, T][]
An array of key-value pairs representing the root nodes.
Inherited from Tree.rootTuples
- Defined in tree.ts:1435

rootValues

rootValues(): T[]
Returns an array of values representing the root nodes of the tree.

Returns T[]
An array of values representing the root nodes.
Inherited from Tree.rootValues
- Defined in tree.ts:1426

roots

roots(): T[]
Returns an array of values representing the root nodes of the tree.

Returns T[]
An array of values representing the root nodes.

Alias
rootValues
Inherited from Tree.roots
- Defined in tree.ts:1417

Hierarchy / Siblings

findSiblingIndexOf

findSiblingIndexOf(key, selector): number
gives the index of a given key amongst it's siblings using a predicate
Parameters
- key: string
- selector: KeyedDiscriminator<T>
Returns number
- Defined in sortedtree.ts:65

mapSiblings

mapSiblings<R>(mapper, key): R[]
Maps a function to each sibling of the target node.
Type Parameters
- R
  The type of the result.
Parameters
- mapper: KeyedMapper<T, string, R>
  The mapping function to be applied. It takes three arguments:
  - value (type T): The value associated with the current node being processed.
  - key (string): The key of the current node being processed.
  - i (number): The index of the current node in the sibling.
- key: string
  the node from which to get siblings from
Returns R[]
- An array containing the results of applying the mapper to all nodes.
Inherited from Tree.mapSiblings
- Defined in tree.ts:1170

reduceSiblings

reduceSiblings<R>(reducer, start, key): R
Applies a reducer function to each sibling of the given node
Type Parameters
- R = void
Parameters
- reducer: KeyedReducer<T, string, R>
  The reducer function to be applied. It takes four arguments:
  - key (string): The key of the current node being processed.
  - value (type T): The value associated with the current node being processed.
  - i (number): The index of the current node in the sibling.
  - accumulation (type R): The accumulated result from previous reductions.
- start: R
  The initial value of the accumulator for the reduction.
- key: string
  the node from which to get siblings from
Returns R
The final accumulated result after applying the reducer to all nodes.
Inherited from Tree.reduceSiblings
- Defined in tree.ts:1152

siblingCollection

siblingCollection(key): {
[key: string]: T;
}
Returns an object representing the sibling nodes of the given node, with keys as node keys and values as node values.
Parameters
- key: string
  The key of the node for which to find the sibling.
Returns {
[key: string]: T;
}
An array of values representing the sibling nodes.
- [key: string]: T
Inherited from Tree.siblingCollection
- Defined in tree.ts:1120

siblingIndexOf

siblingIndexOf(key): number
gives the index of a given key amongst it's siblings.
Parameters
- key: string
Returns number
- Defined in sortedtree.ts:44

siblingKeys

siblingKeys(key): string[]
Returns an array of keys representing the sibling nodes of the node with the given key.
Parameters
- key: string
  The key of the node for which to find the siblings.
Returns string[]
An array of keys representing the sibling nodes.
Inherited from Tree.siblingKeys
- Defined in tree.ts:1072

siblingPairs

siblingPairs(key): {
key: string;
value: T;
}[]
Returns an array of objects representing the sibling keys and nodes of the node with the given key.
Parameters
- key: string
  The key of the node for which to find the sibling.
Returns {
key: string;
value: T;
}[]
An array of values representing the sibling nodes.
Inherited from Tree.siblingPairs
- Defined in tree.ts:1133

siblingTuples

siblingTuples(key): [string, T][]
Returns an array of tuples representing the sibling keys and nodes of the node with the given key.
Parameters
- key: string
  The key of the node for which to find the siblings.
Returns [string, T][]
An array of values representing the sibling nodes.
Inherited from Tree.siblingTuples
- Defined in tree.ts:1110

siblingValues

siblingValues(key): T[]
Returns an array of values representing the sibling nodes of the node with the given key.
Parameters
- key: string
  The key of the node for which to find the siblings.
Returns T[]
An array of values representing the sibling nodes.
Inherited from Tree.siblingValues
- Defined in tree.ts:1100

siblings

siblings(key): T[]
Returns an array of values representing the sibling nodes of the node with the given key.
Parameters
- key: string
  The key of the node for which to find the siblings.
Returns T[]
An array of values representing the sibling nodes.

Alias
siblingValues
Inherited from Tree.siblings
- Defined in tree.ts:1090

Properties

`Protected` _comparator

_comparator: Comparator<[string, T]>

`Protected` _keys

_keys: string[]

`Protected` _store

_store: {
[key: string]: TreeEntry<T>;
}

Type declaration

[key: string]: TreeEntry<T>

Traversal / Deep

deepKeys

deepKeys(origin?, ...moreOrigins?): string[]
Returns an array of keys representing all nodes in the tree in a depth-first traversal.
Parameters
- Optional origin: string | string[] = ...
  where the traversal begins. If unspecified, will be all root nodes, thus traversal the whole forest.
- Optional Rest ...moreOrigins: string[]
Returns string[]
An array of keys representing all nodes in the tree in a depth-first traversal.
Inherited from Tree.deepKeys
- Defined in tree.ts:1726

deepPairs

deepPairs(origin?, ...moreOrigins?): {
key: string;
value: T;
}[]
Returns an array of key-value pairs representing the nodes of the tree in a depth-first traversal.
Parameters
- Optional origin: string | string[]
  where the traversal begins. If unspecified, will be all root nodes, thus traversal the whole forest.
- Optional Rest ...moreOrigins: string[]
Returns {
key: string;
value: T;
}[]
An array of objects representing the key-value pairs of the nodes in depth-first. Each object in the array has two properties: key (string) representing the key of the node and value (type T) representing the value associated with the node.
Inherited from Tree.deepPairs
- Defined in tree.ts:1767

deepTuples

deepTuples(origin?, ...moreOrigins?): [string, T][]
Returns an array of key-value tuples representing all nodes in the tree in a depth-first traversal.
Parameters
- Optional origin: string | string[]
  where the traversal begins. If unspecified, will be all root nodes, thus traversal the whole forest.
- Optional Rest ...moreOrigins: string[]
Returns [string, T][]
An array of key-value tuples representing all nodes in the tree in a depth-first traversal.
Inherited from Tree.deepTuples
- Defined in tree.ts:1755

deepUpwardKeys

deepUpwardKeys(origin?, ...moreOrigins?): string[]
Returns an array of keys representing all nodes in the tree in a depth-first traversal.
Parameters
- Optional origin: string | string[]
  where the traversal begins. If unspecified, will be all root nodes, thus traversal the whole forest.
- Optional Rest ...moreOrigins: string[]
Returns string[]
An array of keys representing all nodes in the tree in a depth-first traversal.
Inherited from Tree.deepUpwardKeys
- Defined in tree.ts:1925

deepUpwardPairs

deepUpwardPairs(origin?, ...moreOrigins?): {
key: string;
value: T;
}[]
Returns an array of key-value pairs representing all nodes in the tree in a depth-first traversal.
Parameters
- Optional origin: string | string[]
  where the traversal begins. If unspecified, will be all root nodes, thus traversal the whole forest.
- Optional Rest ...moreOrigins: string[]
Returns {
key: string;
value: T;
}[]
An array of key-value pairs representing all nodes in the tree in a depth-first traversal.
Inherited from Tree.deepUpwardPairs
- Defined in tree.ts:1971

deepUpwardTuples

deepUpwardTuples(origin?, ...moreOrigins?): [string, T][]
Returns an array of key-value tuples representing all nodes in the tree in a depth-first traversal.
Parameters
- Optional origin: string | string[]
  where the traversal begins. If unspecified, will be all root nodes, thus traversal the whole forest.
- Optional Rest ...moreOrigins: string[]
Returns [string, T][]
An array of key-value tuples representing all nodes in the tree in a depth-first traversal.
Inherited from Tree.deepUpwardTuples
- Defined in tree.ts:1960

deepUpwardValues

deepUpwardValues(origin?, ...moreOrigins?): T[]
Returns an array of values associated with all nodes in the tree in a depth-first traversal.
Parameters
- Optional origin: string | string[]
  where the traversal begins. If unspecified, will be all root nodes, thus traversal the whole forest.
- Optional Rest ...moreOrigins: string[]
Returns T[]
An array of values associated with all nodes in the tree in a depth-first traversal.
Inherited from Tree.deepUpwardValues
- Defined in tree.ts:1949

deepValues

deepValues(origin?, ...moreOrigins?): T[]
Returns an array of values associated with all nodes in the tree in a depth-first traversal.
Parameters
- Optional origin: string | string[]
  where the traversal begins. If unspecified, will be all root nodes, thus traversal the whole forest.
- Optional Rest ...moreOrigins: string[]
Returns T[]
An array of values associated with all nodes in the tree in a depth-first traversal.
Inherited from Tree.deepValues
- Defined in tree.ts:1744

mapDeep

mapDeep<R>(mapper, origin?, ...moreOrigins?): R[]
Maps a function to each node in the tree in a deep-order traversal.
Type Parameters
- R
  The type of the result.
Parameters
- mapper: KeyedMapper<T, string, R>
  The mapping function to be applied. It takes three arguments:
  - value (type T): The value associated with the current node being processed.
  - key (string): The key of the current node being processed.
  - i (number): The index of the current node in the deep-order traversal.
- Optional origin: string | string[]
  where the traversal begins. If unspecified, will be all root nodes, thus traversal the whole forest.
- Optional Rest ...moreOrigins: string[]
Returns R[]
- An array containing the results of applying the mapper to all nodes.
Inherited from Tree.mapDeep
- Defined in tree.ts:1806

mapUpwardsDeep

mapUpwardsDeep<R>(mapper, origin?, ...moreOrigins?): R[]
Maps a function to each node in the tree in a deep-order traversal, starting at leaves and going upwards towards roots.
Type Parameters
- R
  The type of the result.
Parameters
- mapper: KeyedMapper<T, string, R>
  The mapping function to be applied. It takes three arguments:
  - value (type T): The value associated with the current node being processed.
  - key (string): The key of the current node being processed.
  - i (number): The index of the current node in the deep-order traversal.
- Optional origin: string | string[]
  where the traversal begins. If unspecified, will be all root nodes, thus traversal the whole forest.
- Optional Rest ...moreOrigins: string[]
Returns R[]
- An array containing the results of applying the mapper to all nodes.
Inherited from Tree.mapUpwardsDeep
- Defined in tree.ts:2010

reduceDeep

reduceDeep<R>(reducer, start, origin?, ...moreOrigins?): R
Applies a reducer function to each node in the tree in a depth-first traversal.
Type Parameters
- R = void
Parameters
- reducer: KeyedReducer<T, string, R>
  The reducer function to be applied. It takes four arguments:
  - key (string): The key of the current node being processed.
  - value (type T): The value associated with the current node being processed.
  - i (number): The index of the current node in the depth-first traversal.
  - accumulation (type R): The accumulated result from previous reductions.
- start: R
  The initial value of the accumulator for the reduction.
- Optional origin: string | string[]
  where the traversal begins. If unspecified, will be all root nodes, thus traversal the whole forest.
- Optional Rest ...moreOrigins: string[]
Returns R
The final accumulated result after applying the reducer to all nodes.
Inherited from Tree.reduceDeep
- Defined in tree.ts:1787

reduceUpwardsDeep

reduceUpwardsDeep<R>(reducer, start, origin?, ...moreOrigins?): R
Applies a reducer function to each node in the tree in a depth-first traversal.
Type Parameters
- R = void
Parameters
- reducer: KeyedReducer<T, string, R>
  The reducer function to be applied. It takes four arguments:
  - key (string): The key of the current node being processed.
  - value (type T): The value associated with the current node being processed.
  - i (number): The index of the current node in the depth-first traversal.
  - accumulation (type R): The accumulated result from previous reductions.
- start: R
  The initial value of the accumulator for the reduction.
- Optional origin: string | string[]
  where the traversal begins. If unspecified, will be all root nodes, thus traversal the whole forest.
- Optional Rest ...moreOrigins: string[]
Returns R
The final accumulated result after applying the reducer to all nodes.
Inherited from Tree.reduceUpwardsDeep
- Defined in tree.ts:1991

Traversal / Flat Path

flatPathKeys

flatPathKeys(from, to): string[]
Finds the keys representing the path from one node to another in the ordered flattened form of the tree.
Parameters
- from: string
  the key of the starting node
- to: string
  the key of the ending node
Returns string[]
An array of keys representing the path.
- Defined in sortedtree.ts:300

next(key): undefined | T
returns the value of the next node relative to the given key in the flattened tree.
Parameters
- key: string
Returns undefined | T
- Defined in sortedtree.ts:94

nextKey

nextKey(key): undefined | string
returns the key of the next node relative to the given key in the flattened tree.
Parameters
- key: string
Returns undefined | string
- Defined in sortedtree.ts:78

nextKeyWith

nextKeyWith(key, selector): undefined | string
returns the key of the next node that satisifes the selector relative to the given key in the flattened tree.
Parameters
- key: string
- selector: KeyedDiscriminator<T>
Returns undefined | string
- Defined in sortedtree.ts:108

nextWith

nextWith(key, selector): undefined | T
returns the value of the next node that satisifes the selector relative to the given key in the flattened tree.
Parameters
- key: string
- selector: KeyedDiscriminator<T>
Returns undefined | T
- Defined in sortedtree.ts:127

prev(key): undefined | T
returns the value of the previous node relative to the given key in the flattened tree.
Parameters
- key: string
Returns undefined | T
- Defined in sortedtree.ts:161

prevKey

prevKey(key): undefined | string
returns the key of the previous node relative to the given key in the flattened tree.
Parameters
- key: string
Returns undefined | string
- Defined in sortedtree.ts:145

prevKeyWith

prevKeyWith(key, selector): undefined | string
returns the value of the previous node that satisifes the selector relative to the given key in the flattened tree.
Parameters
- key: string
- selector: ((value, key) => boolean)
  - - (value, key): boolean
    - Parameters
      value: T
      key: string
      Returns boolean
Returns undefined | string
- Defined in sortedtree.ts:175

prevWith

prevWith(key, selector): undefined | T
returns the value of the previous node that satisifes the selector relative to the given key in the flattened tree.
Parameters
- key: string
- selector: ((value, key) => boolean)
  - - (value, key): boolean
    - Parameters
      value: T
      key: string
      Returns boolean
Returns undefined | T
- Defined in sortedtree.ts:194

Traversal / Path

mapPath

mapPath<R>(from, to, mapper): R[]
Maps a function to each node in the a path starting at 'from' node and ending at 'to' node.
Type Parameters
- R = void
  The type of the result.
Parameters
- from: string
  The key of the starting node.
- to: string
  The key of the ending node.
- mapper: KeyedMapper<T, string, R>
  The mapping function to be applied. It takes three arguments:
  - value (type T): The value associated with the current node being processed.
  - key (string): The key of the current node being processed.
  - i (number): The index of the current node in the wide-order traversal.
Returns R[]
- An array containing the results of applying the mapper to all nodes.
Inherited from Tree.mapPath
- Defined in tree.ts:2144

pathKeys

pathKeys(from, to): string[]
Finds the keys representing the path from one node to another in the tree, if it exists. If no such path is viable, the array will be empty.
Parameters
- from: string
  The key of the starting node.
- to: string
  The key of the ending node.
Returns string[]
An array of keys representing the path from the starting node to the ending node, if it exists. If no such path is viable, the array will be empty.
Inherited from Tree.pathKeys
- Defined in tree.ts:2027

pathPairs

pathPairs(from, to): {
key: string;
value: T;
}[]
Returns an array of key-value representing the nodes along the path from one node to another in the tree, if it exists.
Parameters
- from: string
  The key of the starting node.
- to: string
  The key of the ending node.
Returns {
key: string;
value: T;
}[]
An array of objects representing the key-value pairs of the nodes in depth-first. Each object in the array has two properties: key (string) representing the key of the node and value (type T) representing the value associated with the node.
Inherited from Tree.pathPairs
- Defined in tree.ts:2105

pathTuples

pathTuples(from, to): [string, T][]
Finds the key-value tuples representing the nodes along the path from one node to another in the tree, if it exists.
Parameters
- from: string
  The key of the starting node.
- to: string
  The key of the ending node.
Returns [string, T][]
An array of key-value tuples representing the nodes along the path from the starting node to the ending node, if it exists.
Inherited from Tree.pathTuples
- Defined in tree.ts:2093

pathValues

pathValues(from, to): T[]
Finds the values associated with the nodes along the path from one node to another in the tree, if it exists.
Parameters
- from: string
  The key of the starting node.
- to: string
  The key of the ending node.
Returns T[]
An array of values associated with the nodes along the path from the starting node to the ending node, if it exists.
Inherited from Tree.pathValues
- Defined in tree.ts:2082

reducePath

reducePath<R>(from, to, reducer, start): R
Applies a reducer function to each node along the path from one node to another in the tree, if it exists.
Type Parameters
- R = void
Parameters
- from: string
  The key of the starting node.
- to: string
  The key of the ending node.
- reducer: KeyedReducer<T, string, R>
  The reducer function to be applied. It takes four arguments:
  - key (string): The key of the current node being processed.
  - value (type T): The value associated with the current node being processed.
  - i (number): The index of the current node along the path.
  - accumulation (type R): The accumulated result from previous reductions.
- start: R
  The initial value of the accumulator for the reduction.
Returns R
The final accumulated result after applying the reducer to all nodes along the path.
Inherited from Tree.reducePath
- Defined in tree.ts:2125

Traversal / Wide

mapUpwardsWide

mapUpwardsWide<R>(mapper, origin?, ...moreOrigins?): R[]
Maps a function to each node in the tree in a wide-order traversal, starting at leaves and going upwards towards roots.
Type Parameters
- R
  The type of the result.
Parameters
- mapper: KeyedMapper<T, string, R>
  The mapping function to be applied. It takes three arguments:
  - value (type T): The value associated with the current node being processed.
  - key (string): The key of the current node being processed.
  - i (number): The index of the current node in the wide-order traversal.
- Optional origin: string | string[]
  where the traversal begins. If unspecified, will be all root nodes, thus traversal the whole forest.
- Optional Rest ...moreOrigins: string[]
Returns R[]
- An array containing the results of applying the mapper to all nodes.
Inherited from Tree.mapUpwardsWide
- Defined in tree.ts:1912

mapWide

mapWide<R>(mapper, origin?, ...moreOrigins?): R[]
Maps a function to each node in the tree in a wide-order traversal.
Type Parameters
- R
  The type of the result.
Parameters
- mapper: KeyedMapper<T, string, R>
  The mapping function to be applied. It takes three arguments:
  - value (type T): The value associated with the current node being processed.
  - key (string): The key of the current node being processed.
  - i (number): The index of the current node in the wide-order traversal.
- Optional origin: string | string[]
  where the traversal begins. If unspecified, will be all root nodes, thus traversal the whole forest.
- Optional Rest ...moreOrigins: string[]
Returns R[]
- An array containing the results of applying the mapper to all nodes.
Inherited from Tree.mapWide
- Defined in tree.ts:1713

reduceUpwardsWide

reduceUpwardsWide<R>(reducer, start, origin?, ...moreOrigins?): R
Applies a reducer function to each node in the tree in a width-first traversal.
Type Parameters
- R = void
Parameters
- reducer: KeyedReducer<T, string, R>
  The reducer function to be applied. It takes four arguments:
  - key (string): The key of the current node being processed.
  - value (type T): The value associated with the current node being processed.
  - i (number): The index of the current node in the width-first traversal.
  - accumulation (type R): The accumulated result from previous reductions.
- start: R
  The initial value of the accumulator for the reduction.
- Optional origin: string | string[]
  where the traversal begins. If unspecified, will be all root nodes, thus traversal the whole forest.
- Optional Rest ...moreOrigins: string[]
Returns R
The final accumulated result after applying the reducer to all nodes.
Inherited from Tree.reduceUpwardsWide
- Defined in tree.ts:1893

reduceWide

reduceWide<R>(reducer, start, origin?, ...moreOrigins?): R
Applies a reducer function to each node in the tree in a width-first traversal.
Type Parameters
- R = void
Parameters
- reducer: KeyedReducer<T, string, R>
  The reducer function to be applied. It takes four arguments:
  - key (string): The key of the current node being processed.
  - value (type T): The value associated with the current node being processed.
  - i (number): The index of the current node in the width-first traversal.
  - accumulation (type R): The accumulated result from previous reductions.
- start: R
  The initial value of the accumulator for the reduction.
- Optional origin: string | string[]
  where the traversal begins. If unspecified, will be all root nodes, thus traversal the whole forest.
- Optional Rest ...moreOrigins: string[]
Returns R
The final accumulated result after applying the reducer to all nodes.
Inherited from Tree.reduceWide
- Defined in tree.ts:1694

wideKeys

wideKeys(origin?, ...moreOrigins?): string[]
Returns an array of keys representing the nodes of the tree in a width-first traversal.
Parameters
- Optional origin: string | string[] = ...
  where the traversal begins. If unspecified, will be all root nodes, thus traversal the whole forest.
- Optional Rest ...moreOrigins: string[]
Returns string[]
An array of keys representing the nodes in width-first.
Inherited from Tree.wideKeys
- Defined in tree.ts:1627

widePairs

widePairs(origin?, ...moreOrigins?): {
key: string;
value: T;
}[]
Returns an array of key-value pairs representing the nodes of the tree in a width-first traversal.
Parameters
- Optional origin: string | string[]
  where the traversal begins. If unspecified, will be all root nodes, thus traversal the whole forest.
- Optional Rest ...moreOrigins: string[]
Returns {
key: string;
value: T;
}[]
An array of objects representing the key-value pairs of the nodes in width-first. Each object in the array has two properties: key (string) representing the key of the node and value (type T) representing the value associated with the node.
Inherited from Tree.widePairs
- Defined in tree.ts:1674

wideTuples

wideTuples(origin?, ...moreOrigins?): [string, T][]
Returns an array of key-value tuples representing the nodes of the tree in a width-first traversal.
Parameters
- Optional origin: string | string[]
  where the traversal begins. If unspecified, will be all root nodes, thus traversal the whole forest.
- Optional Rest ...moreOrigins: string[]
Returns [string, T][]
An array of key-value tuples representing the nodes in width-first.
Inherited from Tree.wideTuples
- Defined in tree.ts:1662

wideUpwardKeys

wideUpwardKeys(origin?, ...moreOrigins?): string[]
Returns an array of keys representing the nodes of the tree in a width-first traversal starting from leaf nodes.
Parameters
- Optional origin: string | string[]
  where the traversal begins. If unspecified, will be all root nodes, thus traversal the whole forest.
- Optional Rest ...moreOrigins: string[]
Returns string[]
An array of keys representing the nodes in width-first starting from leaf nodes.
Inherited from Tree.wideUpwardKeys
- Defined in tree.ts:1819

wideUpwardPairs

wideUpwardPairs(origin?, ...moreOrigins?): {
key: string;
value: T;
}[]
Returns an array of key-value pairs representing the nodes of the tree in a width-first traversal starting from leaf nodes.
Parameters
- Optional origin: string | string[]
  where the traversal begins. If unspecified, will be all root nodes, thus traversal the whole forest.
- Optional Rest ...moreOrigins: string[]
Returns {
key: string;
value: T;
}[]
An array of objects representing the key-value pairs of the nodes in width-first. Each object in the array has two properties: key (string) representing the key of the node and value (type T) representing the value associated with the node.
Inherited from Tree.wideUpwardPairs
- Defined in tree.ts:1873

wideUpwardTuples

wideUpwardTuples(origin?, ...moreOrigins?): [string, T][]
Returns an array of key-value pairs representing the nodes of the tree in a width-first traversal starting from leaf nodes.
Parameters
- Optional origin: string | string[]
  where the traversal begins. If unspecified, will be all root nodes, thus traversal the whole forest.
- Optional Rest ...moreOrigins: string[]
Returns [string, T][]
An array of key-value pairs representing the nodes in width-first starting from leaf nodes.
Inherited from Tree.wideUpwardTuples
- Defined in tree.ts:1861

wideUpwardValues

wideUpwardValues(origin?, ...moreOrigins?): T[]
Returns an array of values representing the nodes of the tree in a width-first traversal starting from leaf nodes.
Parameters
- Optional origin: string | string[]
  where the traversal begins. If unspecified, will be all root nodes, thus traversal the whole forest.
- Optional Rest ...moreOrigins: string[]
Returns T[]
An array of values representing the nodes in width-first starting from leaf nodes.
Inherited from Tree.wideUpwardValues
- Defined in tree.ts:1850

wideValues

wideValues(origin?, ...moreOrigins?): T[]
Returns an array of values representing the nodes of the tree in a width-first traversal.
Parameters
- Optional origin: string | string[]
  where the traversal begins. If unspecified, will be all root nodes, thus traversal the whole forest.
- Optional Rest ...moreOrigins: string[]
Returns T[]
An array of values representing the nodes in width-first.
Inherited from Tree.wideValues
- Defined in tree.ts:1651

Utility

setComparator

setComparator(comparator): void
set the default comparator of the SortedTree to a new comparator.
Parameters
- comparator: Comparator<[string, T]>
  the comparator to replace the default comprator with
Returns void
- Defined in sortedtree.ts:237

`Static` DEFAULT_COMPARATOR

DEFAULT_COMPARATOR(__namedParameters, __namedParameters): number
Parameters
- __namedParameters: [string, unknown]
- __namedParameters: [string, unknown]
Returns number
- Defined in sortedtree.ts:22

`Static` from

from<T>(contents, comparator?): SortedTree<T>
Creates a new tree from a raw store. This does not do any validation checks for completeness.
Type Parameters
- T
Parameters
- contents: {
  [key: string]: TreeEntry<T>;
  }
  the raw store to use as a tree
  - [key: string]: TreeEntry<T>
- Optional comparator: Comparator<[string, T]>
Returns SortedTree<T>
Overrides Tree.from
- Defined in sortedtree.ts:30

Class SortedTree<T>

Type Parameters

Hierarchy (view full)

Index

Constructors

Query

Modify

Hierarchy / Ancestors

Hierarchy / Children

Hierarchy / Descendents

Hierarchy / Leaves

Hierarchy / Parent

Hierarchy / Root

Hierarchy / Siblings

Properties

Traversal / Deep

Traversal / Flat Path

Traversal / Path

Traversal / Wide

Utility

Constructors

constructor

Type Parameters

Parameters

Returns SortedTree<T>

Query

contains

Parameters

Returns boolean

contents

Returns { [key: string]: ReadonlyTreeEntry<T>; }

[key: string]: ReadonlyTreeEntry<T>

depth

Parameters

Returns number

entry

Parameters

Returns undefined | ReadonlyTreeEntry<T>

findIndexOf

Parameters

Returns number

findKeyOf

Parameters

Returns undefined | string

get

Parameters

Returns undefined | T

has

Parameters

Returns boolean

indexOf

Parameters

Returns number

isLeaf

Parameters

Returns boolean

isRoot

Parameters

Returns boolean

keyAt

Parameters

Returns undefined | string

keyOf

Parameters

Returns undefined | string

keys

Returns readonly string[]

size

Returns number

some

Parameters

Returns boolean

subtreeCount

Returns number

subtrees

Returns Tree<T>[]

valueAt

Parameters

Returns undefined | T

Modify

Returns {
[key: string]: ReadonlyTreeEntry<T>;
}

Returns void | {
key: string;
value: T;
}

Returns void | IterableOr<{
key: string;
parent: null | string;
value: T;
}>

Returns Promise<void | IterableOr<{
key: string;
parent: null | string;
value: T;
}>>

Returns undefined | {
[key: string]: T;
}