An implementation of this interface is typically obtained from selection.
This interface provides access to the IObservableCollection<T> instances that manage the set of selected nodes, edges, labels, ports, and bends. The methods on the instance that use IModelItem parameters delegate to the corresponding domain-specific selection models.
Typically, only items that are in the current graph may be selected and the selection will automatically be adjusted when elements get removed from the graph.
Examples
In order to work with the selection of a graph, obtain the selection from the GraphComponent:Working with the graph selection.
// Determine whether an item is selectedlet selected = graphComponent.selection.includes(node)// alternatively, if you know the type:selected = graphComponent.selection.nodes.includes(node)// Deselect an edgegraphComponent.selection.remove(edge)// check whether the selection is emptyconst isEmpty = graphComponent.selection.size === 0// Iterate over selected nodesfor (const n of graphComponent.selection.nodes) { // ...}// Iterate all selected itemsgraphComponent.selection.forEach((selection) => { // ...})// Unselect all edgesgraphComponent.selection.edges.clear()// clear the whole selectiongraphComponent.selection.clear()// select all nodesgraphComponent.graph.nodes.forEach((n) => { graphComponent.selection.nodes.add(n)})// listen to low-level changes in the selectiongraphComponent.selection.addEventListener('item-added', (args) => { console.log(`Selected ${args.item}`)})graphComponent.selection.addEventListener('item-removed', (args) => { console.log(`Deselected ${args.item}`)})
Returns the element at the given index in this enumerable.
This is modeled after the Array.prototype.at function, with the important difference, that null will be returned instead of undefined in the case of an invalid index.
Parameters
index: number
The index of the element to return. Supports relative indexing from the end of the enumerable when passed a negative index. In other words, if a negative number is used, the returned element will be found by counting back from the end of the enumerable.
The element at the given index, or null if the index is not within the valid range of this enumerable.
Examples
const enumerable = IEnumerable.from([1, 2, 3, 4])console.log(enumerable.at(0)) // yields 1console.log(enumerable.at(-1)) // yields 4console.log(enumerable.at(5)) // yields null!// using ?? for default valuesconsole.log(enumerable.at(10) ?? 0) // yields 0// use ! when you know that this is validconsole.log(enumerable.at(0)!.toFixed())// use optional chaining when you are unsure whether the index is validconsole.log(enumerable.at(20)?.toFixed())// combine optional chaining and null-coalescing operator when you are unsureconsole.log(enumerable.at(30)?.toLocaleString() ?? 'no value')
Concatenates this enumerable with the given other elements in a new dynamic IEnumerable<T>.
The returned enumerable is dynamic, in other words, if elements are added or removed from one of the original enumerables, the returned enumerable changes, too. If you want to store the current state of the concatenation, create a list or array of it.
Parameters
elements: any
Rest arguments to be appended. In case the elements are enumerable-like, too, they will be will be enumerated after the others have been enumerated. But this can also be simple objects of type T in which case they will be appended to the enumerable just like with append
Creates a wrapped view of an enumerable which skips a number of elements at the beginning while the given predicate yields true.
While the predicate yields true for the elements of the original enumerable, the elements are skipped. The new enumeration will start with the first element for which the predicate yields false. All subsequent elements will be yielded.
The predicate function that determines what elements should be skipped. While the predicate yields true for the provided item, the element will not be yielded.
Returns a dynamic IEnumerable<T> of the elements of this enumerable which match the given predicate.
The returned enumerable is dynamic, in other words, if elements are added or removed from one of the original enumerables, the returned enumerable changes, too. If you want to store the current state of the filtered enumerable, create a list or array of it.
Returns a dynamic IEnumerable<T> of the elements of this enumerable which match the given type guard.
The returned enumerable is dynamic, in other words, if elements are added or removed from one of the original enumerables, the returned enumerable changes, too. If you want to store the current state of the filtered enumerable, create a list or array of it.
A type predicate function which returns true if the given element is of the desired type and should be included in the resulting enumerable. The signature of the predicate must include a type guard, for example
function isFish(pet: Fish | Bird): pet is Fish { return (pet as Fish).swim !== undefined}
thisArg?: any
The optional object to use for this in the function.
Returns a dynamic IEnumerable<T> of the elements of this enumerable which match the given type guard.
The returned enumerable is dynamic, in other words, if elements are added or removed from one of the original enumerables, the returned enumerable changes, too. If you want to store the current state of the filtered enumerable, create a list or array of it.
A type predicate function which returns true if the given element is of the desired type and should be included in the resulting enumerable. The signature of the predicate must include a type guard, for example
function isFish(pet: Fish | Bird): pet is Fish { return (pet as Fish).swim !== undefined}
thisArg?: any
The optional object to use for this in the function.
Returns a flattened dynamic IEnumerable<T> of this enumerable using the given selector function which returns an enumerable for each element of this enumerable.
The returned enumerable is dynamic, in other words, if elements are added or removed from one of the original enumerables, the returned enumerable changes, too. If you want to store its current state, create a list or array of it.
Gets an IEnumerator<T> which can be used to enumerate the items this instance represents.
This is the low-level API that needs to be implemented by all enumerables. Clients will only have to use this API, rarely, as iteration is more conveniently handled by the forEach method or using the iterable (for(let item of enumerable){}) protocol.
Groups the elements in the enumerable according to the equality of a key.
For each element in the original enumerable the keySelector will be used to retrieve a key. All elements with the same key will be provided to the optional resultCreator function that receives both the key, and an IEnumerable<T> of the elements that match that key to create a resulting object that will be yielded by this enumerable. Note that the resulting enumerable does not necessarily preserve the order of the (first) appearance of their elements in the original sequence. The elements of each group passed to the resultCreator are in the order of their original appearance.
This implementation differs from the TC39 proposal for array grouping. See the example "Using groupBy to create an object" to mimic the proposal's groupBy behavior.
An optional function which transforms each group of elements and their common key into a resulting object. If omitted, the default implementation will create arrays of length 2 where the first element is the key and the second element is an IEnumerable<TSource> of the elements with the corresponding key.
An enumeration of groups of the original enumerable.
Examples
A simple groupBy example
const enumerable = IEnumerable.from([ { type: 'A', amount: 1 }, { type: 'A', amount: 2 }, { type: 'B', amount: 4 },])// without result creatorconst groups1 = enumerable.groupBy<string, string>( (element) => element.type,)for (const g of groups1) { console.log(`Type is ${g[0]} and has ${g[1].length} members.`)}// Type is A and has 2 members.// Type is B and has 1 members.// with result creatorconst groups2 = enumerable.groupBy( (element) => element.type, (type, elements) => ({ type, amount: elements.sum((item) => item.amount), }),)console.log(groups2.toArray()) // yields [{"type":"A","amount":4},{"type":"B","amount":4}]
The last element of this enumerable, or null if the enumerable is empty.
Examples
const enumerable = IEnumerable.from([1, 2, 3, 4])console.log(enumerable.last()) // yields 4// if the enumerable is empty null will be returnedconst empty = IEnumerable.from([])console.log(empty.last()) // yields null
Returns a dynamic IEnumerable<T> of this enumerable using the given selector function which returns a new object for each element of this enumerable.
The returned enumerable is dynamic, in other words, if elements are added or removed from one of the original enumerables, the returned enumerable changes, too. If you want to store its current state, create a list or array of it.
A dynamic enumerable of the results of the provided function.
Examples
const enumerable = IEnumerable.from([1, 2, 3])const result = enumerable.map((item) => item * 2)console.log(result.toArray()) // yields [2, 4, 6]// with indexconst result2 = enumerable.map((item, index) => item * index)console.log(result2.toArray()) // yields [0, 2, 6]// with index and enumerableconst result3 = enumerable.map( (item, index, enumerable) => `Item no ${index} of ${enumerable.size} is ${item}`,)console.log(result3.toArray())// ["Item no 0 of 3 is 1","Item no 1 of 3 is 2","Item no 2 of 3 is 3"]
The returned enumerable is dynamic
const list = List.fromArray([1, 2, 3])const result = list.map((item) => item * 2)list.add(4)// result changed alsoconsole.log(result.toArray()) // yields [2,4,6,8]
A new live view over the original enumerable that has items prepended to it.
Examples
const enumerable1 = IEnumerable.from([1, 2, 3, 4])console.log(enumerable1.prepend(0).toArray()) // yields [0,1,2,3,4]// more than one value can be used tooconst enumerable2 = IEnumerable.from([3, 4, 5, 6])console.log(enumerable2.prepend(1, 2).toArray()) // yields [1,2,3,4,5,6]
Creates a dynamic view of this enumerable with the given number of elements taken from the start or end of this enumerable.
Parameters
count: number
The number of elements in the created enumerable. If the number is positive, the elements are taken from the beginning, otherwise, the elements are taken from the end.
A dynamic iew of this enumerable with the given number of elements.
Examples
const enumerable = IEnumerable.from([1, 2, 3, 4, 5, 6, 7])// positive parameter means taking elements from the beginning of the enumerableconsole.log(enumerable.take(2).toArray()) // yields [1,2]// negative parameter means taking elements from the end of the enumerableconsole.log(enumerable.take(-2).toArray()) // yields [6,7]
Returns a dynamic IEnumerable<T> that contains the elements from this enumerable as long as the given predicate is true.
The returned enumerable is dynamic, in other words, if elements are added or removed from one of the original enumerables, the returned enumerable changes, too. If you want to store its current state, create a list or array of it.
Returns an dynamic enumerable which contains the elements of this enumerable in reverse order.
The returned enumerable is dynamic, in other words, if elements are added or removed from one of the original enumerables, the returned enumerable changes, too. If you want to store its current state, create a list or array of it.
A function with the signature (a, b) => number which is used for the sort operation to compare the elements in the enumerable. May be omitted. If omitted, the elements are sorted by converting them to strings first. Numbers are sorted as numbers without converting them to strings (this is different to the EcmaScript implementation).