StripeSelection

Remarks

Implements

Remarks

Implements

Remarks

Implements

Remarks

Implements

Overrides

Remarks

Parameters

items - IStripe

The item(s) to prepend to the enumeration

Returns

↪IEnumerable<IStripe>

A new live view over the original enumerable that has each of the items appended to it.

Examples

const list = List.fromArray([1, 2, 3, 4])

const appendedEnumerable = list.append(5, 6)
console.log(appendedEnumerable.toArray()) // yields [1,2,3,4,5,6]

// show live updates
list.add(4.5)

console.log(appendedEnumerable.toArray()) // yields [1,2,3,4,4.5,5,6]

See Also

Overrides

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.

Returns

↪IStripe

The element at the given index, or undefined if the index is not within the range of this enumerable.

Examples

const enumerable = IEnumerable.from([1, 2, 3, 4])
console.log(enumerable.at(0)) // yields 1
console.log(enumerable.at(-1)) // yields 4
console.log(enumerable.at(5)) // yields undefined

Overrides

Remarks

See Also

Implements

Remarks

Parameters

elements - Object

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

Returns

↪IEnumerable<IStripe>

A dynamic composite enumerable.

Examples

const enumerable1 = IEnumerable.from([1, 2])
const enumerable2 = IEnumerable.from([3, 4])

console.log(enumerable1.concat(enumerable2).toArray()) // yields [1,2,3,4]

// single values can be used, too
console.log(enumerable1.concat(3, 4).toArray()) // yields [1,2,3,4]

// arrays are flattened
console.log(enumerable1.concat([5, 6], [7, 8]).toArray()) // now contains [1,2,5,6,7,8]

// works with arrays and array-like collections, too
console.log(enumerable1.concat([3, 4]).toArray()) // yields [1,2,3,4]

const list1 = List.fromArray([1, 2])
const list2 = List.fromArray([3, 4])

const result = list1.concat(list2)

console.log(result.toArray()) // yields [1,2,3,4]

list1.add(2.5)

// result changed also
console.log(result.toArray()) // yields [1,2,2.5,3,4]

list2.add(5)

// result changed also
console.log(result.toArray()) // yields [1,2,2.5,3,4,5]

See Also

Overrides

Remarks

ParametersOptions Overload

keySelector - function(IStripe):Object

The optional function that determines the key to determine distinctness of the elements. If omitted, the element itself is used.

Signature Details

function(element: IStripe) : Object

A function which creates a key for the given element.

Parameters

element - IStripe

The element to get the key for.

Returns

Object

The key for the element.

thisArg - Object

The optional object to use for thisin the keySelector function.

Returns

↪IEnumerable<IStripe>

A new live view over the original enumerable that yields each element with a given key at most once.

Examples

const enumerable = IEnumerable.from([1, 2, 3, 3, 4])

const result = enumerable.distinct()

console.log(result.toArray()) // yields [1,2,3,4]

See Also

Overrides

Parameters

predicate - function(IStripe, number, IEnumerable<IStripe>):boolean

A predicate function which returns true if the element matches a condition.

Signature Details

function(element: IStripe, index: number, source: IEnumerable<IStripe>) : boolean

The predicate to use for IEnumerable<T>.

Parameters

element - IStripe

The current element to test.

index - number

The element's index in the

source - IEnumerable<IStripe>

The enumerable this function is called upon.

Returns

boolean

true if the item matches the condition.

thisArg - Object

The optional object to use for this in the function.

Returns

↪boolean

true if all elements of the enumerable match the given predicate, false otherwise.

Throws

Exception({ name: 'ArgumentError' })

predicate is null.

Examples

const enumerable = IEnumerable.from([1, 2, 3, 4])

console.log(enumerable.every((item) => item < 5)) // true

console.log(enumerable.every((item) => item < 4)) // false

Overrides

Remarks

Parameters

predicate - function(IStripe, number, IEnumerable<IStripe>):boolean

A predicate function which returns true if the given element should be included in the resulting enumerable.

Signature Details

function(element: IStripe, index: number, source: IEnumerable<IStripe>) : boolean

The predicate to use for IEnumerable<T>.

Parameters

element - IStripe

The current element to test.

index - number

The element's index in the

source - IEnumerable<IStripe>

The enumerable this function is called upon.

Returns

boolean

true if the item matches the condition.

thisArg - Object

The optional object to use for this in the function.

Returns

↪IEnumerable<IStripe>

A dynamic enumerable of the elements which match the given predicate.

Examples

const enumerable = IEnumerable.from([10, 2, 30, 4, 5, 6])

const result = enumerable.filter((item) => item < 5)

console.log(result.toArray()) // yields [2,4]

const list = List.fromArray([10, 2, 30, 4, 5, 6])

const result = list.filter((item) => item < 5)

list.add(1)

// result changed also
console.log(result.toArray()) // yields [2,4,1]

Overrides

ParametersOptions Overload

predicate - function(IStripe, number, IEnumerable<IStripe>):boolean

A predicate function which returns true if the given element should be returned.

Signature Details

function(element: IStripe, index: number, source: IEnumerable<IStripe>) : boolean

The predicate to use for IEnumerable<T>.

Parameters

element - IStripe

The current element to test.

index - number

The element's index in the

source - IEnumerable<IStripe>

The enumerable this function is called upon.

Returns

boolean

true if the item matches the condition.

thisArg - Object

The optional object to use for this in the function.

Returns

↪IStripe

The first element of this enumerable, its first element that matches a given predicate, or null if there is no such element.

Examples

const enumerable = IEnumerable.from([10, 2, 3, 9, 5, 6])

console.log(enumerable.find((item) => item < 5)) // yields 2

// no matches with the given predicate
console.log(enumerable.find((item) => item < 2)) // yields null

Overrides

Parameters

predicate - function(IStripe, number, IEnumerable<IStripe>):boolean

A predicate function which returns true if an item matches the search conditions.

Signature Details

function(element: IStripe, index: number, source: IEnumerable<IStripe>) : boolean

The predicate to use for IEnumerable<T>.

Parameters

element - IStripe

The current element to test.

index - number

The element's index in the

source - IEnumerable<IStripe>

The enumerable this function is called upon.

Returns

boolean

true if the item matches the condition.

thisArg - Object

The optional object to use for this in the function.

Returns

↪number

The index of the first item for which predicate returns true or -1 if there is no such item in the enumerable.

Overrides

ParametersOptions Overload

predicate - function(IStripe, number, IEnumerable<IStripe>):boolean

A predicate function which returns true if the given element should be returned.

Signature Details

function(element: IStripe, index: number, source: IEnumerable<IStripe>) : boolean

The predicate to use for IEnumerable<T>.

Parameters

element - IStripe

The current element to test.

index - number

The element's index in the

source - IEnumerable<IStripe>

The enumerable this function is called upon.

Returns

boolean

true if the item matches the condition.

thisArg - Object

The optional object to use for this in the function.

Returns

↪IStripe

The last element of this enumerable, its last element that matches a given predicate, or null if there is no such element.

Examples

const enumerable = IEnumerable.from([10, 2, 3, 9, 5, 6])

console.log(enumerable.findLast((item) => item < 5)) // yields 3

// no matches with the given predicate
console.log(enumerable.findLast((item) => item < 2)) // yields null

Overrides

Parameters

predicate - function(IStripe, number, IEnumerable<IStripe>):boolean

A predicate function which returns true if an item matches the search conditions.

Signature Details

function(element: IStripe, index: number, source: IEnumerable<IStripe>) : boolean

The predicate to use for IEnumerable<T>.

Parameters

element - IStripe

The current element to test.

index - number

The element's index in the

source - IEnumerable<IStripe>

The enumerable this function is called upon.

Returns

boolean

true if the item matches the condition.

thisArg - Object

The optional object to use for this in the function.

Returns

↪number

The index of the last item for which predicate returns true or -1 if there is no such item in the enumerable.

Overrides

Remarks

ParametersOptions Overload

predicate - function(IStripe, number, IEnumerable<IStripe>):boolean

A function which returns true if the given element should be returned.

Signature Details

function(element: IStripe, index: number, source: IEnumerable<IStripe>) : boolean

The predicate to use for IEnumerable<T>.

Parameters

element - IStripe

The current element to test.

index - number

The element's index in the

source - IEnumerable<IStripe>

The enumerable this function is called upon.

Returns

boolean

true if the item matches the condition.

thisArg - Object

The optional object to use for this in the function.

Returns

↪IStripe

The first matching element of this enumerable.

Throws

Exception({ name: 'InvalidOperationError' })

If this enumerable does not contain a matching element.

Examples

const enumerable = IEnumerable.from([10, 2, 3, 9, 5, 6])

console.log(enumerable.first((item) => item < 5)) // yields 2

// no matches with the given predicate
console.log(enumerable.first((item) => item < 2)) // throws exception

See Also

Overrides

Remarks

Type Parameters

TResult

Parameters

selector - function(IStripe, number, IEnumerable<IStripe>):IEnumerable<TResult>

A function which returns an enumerable for each element of this enumerable.

Signature Details

function(element: IStripe, index: number, source: IEnumerable<IStripe>) : IEnumerable<TResult>

The selector to use for the IEnumerable<T>.

A function which returns a result of type IEnumerable<T> for each element.

Parameters

element - IStripe

The current element create a result for.

index - number

The element's index in the

source - IEnumerable<IStripe>

The enumerable this function is called upon.

Returns

IEnumerable<TResult>

A result of type of TResult created from the element.

thisArg - Object

The optional object to use for this in the function.

Returns

↪IEnumerable<TResult>

A flattened dynamic enumerable of the enumerables provided for each element of this enumerable.

Examples

const enumerable = IEnumerable.from([1, 2, 3])

const result = enumerable.flatMap((item) =>
  IEnumerable.from([item, item * 2])
)

console.log(result.toArray()) // yields [1,2,2,4,3,6]const enumerable = IEnumerable.from<number>([1, 2, 3])

const result = enumerable.flatMap((item) =>
  IEnumerable.from<number>([item, item * 2])
)

console.log(result.toArray()) // yields [1,2,2,4,3,6]

const list = List.fromArray([[1], [2], [3]])

const result = list.flatMap((item) => IEnumerable.from([item[0] * 2]))

list.add([4])

// result changed also
console.log(result.toArray()) // yields [2,4,6,8]const list = List.fromArray<number[]>([[1], [2], [3]])

const result = list.flatMap((item) =>
  IEnumerable.from<number>([item[0] * 2])
)

list.add([4])

// result changed also
console.log(result.toArray()) // yields [2,4,6,8]

Overrides

Parameters

action - function(IStripe, number, IEnumerable<IStripe>):void

The function to call for each element.

Signature Details

function(element: IStripe, index: number, source: IEnumerable<IStripe>)

An action to execute for each element of an IEnumerable<T>.

Parameters

element - IStripe

The current element.

index - number

The element's index in the

source - IEnumerable<IStripe>

The enumerable this function is called upon.

thisArg - Object

The optional object to use for this in the function.

Examples

const enumerable = IEnumerable.from([1, 2, 3, 4])

enumerable.forEach((item) => console.log(item)) // 1 2 3 4

// accessing the index
enumerable.forEach((item, index) =>
  console.log(`Item #${index} is ${item}`)
)

Overrides

Remarks

Returns

↪IEnumerator<IStripe>

The IEnumerator<T> which can be used to iterate over the items in this instance

Implements

Remarks

Type Parameters

TKey

The type of the key elements.

TResult

The type of the created elements.

ParametersOptions Overload

keySelector - function(IStripe, number, IEnumerable<IStripe>):TKey

A function which selects from each element the key.

Signature Details

function(element: IStripe, index: number, source: IEnumerable<IStripe>) : TKey

A function which creates a key for the given element.

Parameters

element - IStripe

The element to get the key for.

index - number

The index of the element in the underlying .

source - IEnumerable<IStripe>

The underlying

Returns

TKey

resultCreator - function(TKey, IEnumerable<IStripe>, number):TResult

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.

Signature Details

function(key: TKey, group: IEnumerable<IStripe>, index: number) : TResult

A function which transforms a group of elements and their common key into a resulting object.

Parameters

key - TKey

The key of the provided group.

group - IEnumerable<IStripe>

The group of elements with the given key.

index - number

The index of the group.

Returns

TResult

A resulting object for the given group with the given key.

thisArg - Object

The optional value to use as this when executing the keySelector and resultCreator .

Returns

↪IEnumerable<TResult>

An enumeration of groups of the original enumerable.

Examples

const enumerable = IEnumerable.from([
  { type: 'A', amount: 1 },
  { type: 'A', amount: 2 },
  { type: 'B', amount: 4 }
])

// without result creator
const groups1 = enumerable.groupBy((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 creator
const 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}]const enumerable = IEnumerable.from([
  { type: 'A', amount: 1 },
  { type: 'A', amount: 2 },
  { type: 'B', amount: 4 }
])

// without result creator
const 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 creator
const 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}]

const val = IEnumerable.ofRange(1, 10)
  .groupBy(
    (value, index) => index % 2,
    (key, items, index) => [`key ${index % 2}`, items.toArray()]
  )
  .toArray()

// [
//   ["key 0",[1,3,5,7,9]],
//   ["key 1",[2,4,6,8,10]]
// ]const val = IEnumerable.ofRange(1, 10)
  .groupBy(
    (value, index) => index % 2,
    (key, items, index) => [`key ${index % 2}`, items!.toArray()]
  )
  .toArray()

// [
//   ["key 0",[1,3,5,7,9]],
//   ["key 1",[2,4,6,8,10]]
// ]

const enumerable = IEnumerable.from([
  { value: 0, key: 'a' },
  { value: 1, key: 'b' },
  { value: 2, key: 'b' },
  { value: 3, key: 'a' }
])

const obj = Object.fromEntries(
  enumerable.groupBy(
    (item) => item.key,
    (key, items) => [key, items.toArray()]
  )
)

// {
//   a: [{value:0, key:a}, {value:3, key:a}],
//   b: [{value:1, key:b}, {value:2, key:b}]
// }const enumerable: IEnumerable<{ value: number; key: string }> =
  IEnumerable.from([
    { value: 0, key: 'a' },
    { value: 1, key: 'b' },
    { value: 2, key: 'b' },
    { value: 3, key: 'a' }
  ])

const obj = Object.fromEntries(
  enumerable.groupBy(
    (item) => item.key,
    (key, items) => [key, items!.toArray()]
  ) as Iterable<[unknown, unknown]>
)

// {
//   a: [{value:0, key:a}, {value:3, key:a}],
//   b: [{value:1, key:b}, {value:2, key:b}]
// }

Overrides

Parameters

value - IStripe

The value to search for.

Returns

↪boolean

true if this enumerable contains the given value, false otherwise.

Examples

const enumerable = IEnumerable.from([1, 2, 3, 4])

console.log(enumerable.includes(2)) // true

console.log(enumerable.includes(5)) // false

Overrides

Parameters

item - IStripe

The item to search for.

fromIndex - number

Returns

↪number

The index of the given item in the enumerable. -1 if the item is not in the enumerable.

Overrides

Parameters

stripe - IStripe

The stripe to test

Returns

↪boolean

true iff stripe is currently selected

See Also

Implements

Remarks

ParametersOptions Overload

predicate - function(IStripe, number, IEnumerable<IStripe>):boolean

A function which returns true if the given element should be returned.

Signature Details

function(element: IStripe, index: number, source: IEnumerable<IStripe>) : boolean

The predicate to use for IEnumerable<T>.

Parameters

element - IStripe

The current element to test.

index - number

The element's index in the

source - IEnumerable<IStripe>

The enumerable this function is called upon.

Returns

boolean

true if the item matches the condition.

thisArg - Object

The optional object to use for this in the function.

Returns

↪IStripe

The last element of this enumerable.

Throws

Exception({ name: 'InvalidOperationError' })

If the enumerable is empty.

Examples

const enumerable1 = IEnumerable.from([1, 2, 3, 4])
console.log(enumerable1.last()) // yields 4

// if the enumerable is empty then an exception will be thrown
const enumerable2 = IEnumerable.from([])
console.log(enumerable2.last()) // throws exception

See Also

Overrides

Remarks

Type Parameters

TResult

The type of the mapped elements.

Parameters

selector - function(IStripe, number, IEnumerable<IStripe>):TResult

A function which converts each element into a new element of the type TResult.

Signature Details

function(element: IStripe, index: number, source: IEnumerable<IStripe>) : TResult

The selector to use for the IEnumerable<T>.

A function which returns a result of type TResult for each element.

Parameters

element - IStripe

The current element create a result for.

index - number

The element's index in the

source - IEnumerable<IStripe>

The enumerable this function is called upon.

Returns

TResult

A result of type TResult created from the element.

thisArg - Object

The optional value to use as this when executing the selector.

Returns

↪IEnumerable<TResult>

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 index
const result2 = enumerable.map((item, index) => item * index)

console.log(result2.toArray()) // yields [0, 2, 6]

// with index and enumerable
const 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"]const enumerable = IEnumerable.from([1, 2, 3])

const result = enumerable.map((item) => item * 2)

console.log(result.toArray()) // yields [2, 4, 6]

// with index
const result2 = enumerable.map((item, index) => item * index)

console.log(result2.toArray()) // yields [0, 2, 6]

// with index and enumerable
const 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"]

const list = List.fromArray([1, 2, 3])

const result = list.map((item) => item * 2)

list.add(4)

// result changed also
console.log(result.toArray()) // yields [2,4,6,8]

Overrides

Remarks

Type Parameters

TResult

Returns

↪IEnumerable<TResult>

A typed enumerable.

Overrides

Parameters

evt - ItemSelectionChangedEventArgs<IStripe>

The parameters for the event

Remarks

Type Parameters

TKey

ParametersOptions Overload

keySelector - function(IStripe):TKey

The function that determines the key for sorting the elements. If omitted, the element itself is used.

Signature Details

function(element: IStripe) : TKey

A function which creates a key for the given element.

Parameters

element - IStripe

The element to get the key for.

Returns

TKey

The key for the element.

comparer - function(TKey, TKey):number

A function with the signature function(key1, key2):Number which is used for the sort operation to compare the key elements in the enumerable. May be omitted.

Signature Details

function(value1: TKey, value2: TKey) : number

Compares the given values.

Parameters

value1 - TKey

The first value to compare.

value2 - TKey

The second value to compare.

Returns

number

A value less than 0 if value 1 is smaller than value2, 0 if both values are equal, greater than 0 otherwise.

thisArg - Object

Returns

↪IEnumerable<IStripe>

An enumeration of groups of the original enumerable.

Examples

const enumerable = IEnumerable.from([
  { type: 'name-6', rank: 8 },
  { type: 'name-23', rank: 4 },
  { type: 'name-3', rank: 5 }
])

// order by the elements' rank, without a comparer function
const sortedEnumerable1 = enumerable.orderBy((entry) => entry.rank)

console.log(sortedEnumerable1.toArray())
// [{ "type": "name-23", "rank": 4 }, { "type": "name-3", "rank": 5 }, { "type": "name-6", "rank": 8 }]

// order by the elements' type using numeric collation to get a more "natural" order, with a comparer function
const collator = new Intl.Collator(undefined, {
  numeric: true,
  sensitivity: 'base'
})
const sortedEnumerable2 = enumerable.orderBy(
  (entry) => entry.type,
  collator.compare
)

console.log(sortedEnumerable2.toArray())
// [{ "type": "name-3", "rank": 5 }, { "type": "name-6", "rank": 8 },{ "type": "name-23", "rank": 4 }]

Overrides

Remarks

Type Parameters

TKey

ParametersOptions Overload

keySelector - function(IStripe):TKey

The function that determines the key for sorting the elements. If omitted, the element itself is used.

Signature Details

function(element: IStripe) : TKey

A function which creates a key for the given element.

Parameters

element - IStripe

The element to get the key for.

Returns

TKey

The key for the element.

comparer - function(TKey, TKey):number

A function with the signature function(key1, key2):Number which is used for the sort operation to compare the key elements in the enumerable. May be omitted.

Signature Details

function(value1: TKey, value2: TKey) : number

Compares the given values.

Parameters

value1 - TKey

The first value to compare.

value2 - TKey

The second value to compare.

Returns

number

A value less than 0 if value 1 is smaller than value2, 0 if both values are equal, greater than 0 otherwise.

thisArg - Object

Returns

↪IEnumerable<IStripe>

An enumeration of groups of the original enumerable.

Examples

const enumerable = IEnumerable.from([
  { type: 'A' },
  { type: 'B' },
  { type: 'C' },
  { type: 'D' }
])

// order by the elements' types, without a comparer function
const sortedEnumerable1 = enumerable.orderByDescending(
  (entry) => entry.type
)

console.log(sortedEnumerable1.toArray())
// [{ "type": "D" }, { "type": "C" }, { "type": "B" }, { "type": "A" }]

Overrides

Parameters

items - IStripe

The item(s) to prepend to the enumeration

Returns

↪IEnumerable<IStripe>

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 too
const enumerable2 = IEnumerable.from([3, 4, 5, 6])
console.log(enumerable2.prepend(1, 2).toArray()) // yields [1,2,3,4,5,6]

See Also

Overrides

Type Parameters

TAccumulate

The type of the accumulated value.

Parameters

accumulator - function(TAccumulate, IStripe, number, IEnumerable<IStripe>):TAccumulate

A function which "adds" (accumulates) a value depending on the element and index to the initial value and returns the result.

Signature Details

function(total: TAccumulate, element: IStripe, index: number, source: IEnumerable<IStripe>) : TAccumulate

The accumulator to use for the IEnumerable<T>.

A function which returns a result of type TAccumulate as an accumulation of total and element.

Parameters

total - TAccumulate

The previously returned value of the function.

element - IStripe

The current element to accumulate.

index - number

The element's index in the

source - IEnumerable<IStripe>

The enumerable this function is called upon.

Returns

TAccumulate

A result of type TAccumulate created from the element.

initialValue - TAccumulate

The initial value for the accumulator. Omit/use the reduce overload if you don't want to specify an initial value.

Returns

↪TAccumulate

The result of the accumulation.

Examples

const enumerable = IEnumerable.from([1, 2, 3, 4, 5])

const result = enumerable.reduce(
  (accumulator, currentValue) => Math.max(accumulator, currentValue),
  0
)

console.log(result) // expected output: 5

See Also

Overrides

Parameters

accumulator - function(IStripe, IStripe, number, IEnumerable<IStripe>):IStripe

A function which "adds" (accumulates) a value depending on the element and index to the initial value and returns the result.

Signature Details

function(total: IStripe, element: IStripe, index: number, source: IEnumerable<IStripe>) : IStripe

The accumulator to use for the IEnumerable<T>.

A function which returns a result of type TAccumulate as an accumulation of total and element.

Parameters

total - IStripe

The previously returned value of the function.

element - IStripe

The current element to accumulate.

index - number

The element's index in the

source - IEnumerable<IStripe>

The enumerable this function is called upon.

Returns

IStripe

A result of type TAccumulate created from the element.

Returns

↪IStripe

The result of the accumulation.

Examples

const enumerable = IEnumerable.from([1, 2, 3, 4, 5])

const result = enumerable.reduce(
  (accumulator, currentValue) => accumulator + currentValue
)

console.log(result) // expected output: 15

See Also

Overrides

Type Parameters

TAccumulate

The type of the accumulated value.

Parameters

accumulator - function(TAccumulate, IStripe, number, IEnumerable<IStripe>):TAccumulate

A function which "adds" (accumulates) a value depending on the element and index to the seed value and returns the result.

Signature Details

function(total: TAccumulate, element: IStripe, index: number, source: IEnumerable<IStripe>) : TAccumulate

The accumulator to use for the IEnumerable<T>.

A function which returns a result of type TAccumulate as an accumulation of total and element.

Parameters

total - TAccumulate

The previously returned value of the function.

element - IStripe

The current element to accumulate.

index - number

The element's index in the

source - IEnumerable<IStripe>

The enumerable this function is called upon.

Returns

TAccumulate

A result of type TAccumulate created from the element.

initialValue - TAccumulate

The initial value for the accumulator. Omit/use the reduceRight overload if you don't want to specify an initial value.

Returns

↪TAccumulate

The final value of the accumulation.

Examples

const enumerable = IEnumerable.from(['a', 'b', 'c', 'd'])

const result = enumerable.reduceRight(
  (accumulator, currentValue) => currentValue + accumulator,
  '.'
)

console.log(result) // yields 'abcd.'

See Also

Overrides

Parameters

accumulator - function(IStripe, IStripe, number, IEnumerable<IStripe>):IStripe

A function which "adds" (accumulates) a value depending on the element and index to the seed value and returns the result.

Signature Details

function(total: IStripe, element: IStripe, index: number, source: IEnumerable<IStripe>) : IStripe

The accumulator to use for the IEnumerable<T>.

A function which returns a result of type TAccumulate as an accumulation of total and element.

Parameters

total - IStripe

The previously returned value of the function.

element - IStripe

The current element to accumulate.

index - number

The element's index in the

source - IEnumerable<IStripe>

The enumerable this function is called upon.

Returns

IStripe

A result of type TAccumulate created from the element.

Returns

↪IStripe

The result of the accumulation.

Examples

const enumerable = IEnumerable.from([
  [0, 1],
  [2, 3],
  [4, 5]
])

const result = enumerable.reduceRight((accumulator, currentValue) =>
  accumulator.concat(currentValue)
)

console.log(result) // yields [4,5,2,3,0,1]

See Also

Overrides

Remarks

Parameters

item - IStripe

The item to set the selection state for.

selected - boolean

Whether to select the object.

See Also

Implements

Parameters

amount - number

The number of elements to skip at the beginning.

Returns

↪IEnumerable<IStripe>

A new live view over the original enumerable that skips amount elements.

Examples

const enumerable = IEnumerable.from([1, 2, 3, 4, 5, 6, 7])

const result = enumerable.skip(3)

console.log(result.toArray()) // yields [4,5,6,7]

See Also

Overrides

Remarks

Parameters

predicate - function(IStripe, number, IEnumerable<IStripe>):boolean

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.

Signature Details

function(element: IStripe, index: number, source: IEnumerable<IStripe>) : boolean

The predicate to use for IEnumerable<T>.

Parameters

element - IStripe

The current element to test.

index - number

The element's index in the

source - IEnumerable<IStripe>

The enumerable this function is called upon.

Returns

boolean

true if the item matches the condition.

thisArg - Object

The optional object to use for thisin the predicate function.

Returns

↪IEnumerable<IStripe>

A new live view over the original enumerable that discards elements at the beginnging of the original enumeration while the predicate yields true.

Examples

const enumerable = IEnumerable.from([
  'a',
  'b',
  'c',
  'd',
  'a',
  'b',
  'c',
  'd'
])

const result = enumerable.skipWhile(
  (element) => element.charCodeAt(0) < 'c'.charCodeAt(0)
)

console.log(result.toArray()) // yields ["c", "d", "a", "b", "c", "d"]

See Also

Overrides

ParametersOptions Overload

predicate - function(IStripe, number, IEnumerable<IStripe>):boolean

A function which returns true if the element matches a condition.

Signature Details

function(element: IStripe, index: number, source: IEnumerable<IStripe>) : boolean

The predicate to use for IEnumerable<T>.

Parameters

element - IStripe

The current element to test.

index - number

The element's index in the

source - IEnumerable<IStripe>

The enumerable this function is called upon.

Returns

boolean

true if the item matches the condition.

thisArg - Object

The optional object to use for this in the function.

Returns

↪boolean

Whether this enumerable contains any elements matching the given predicate.

Examples

const enumerable = IEnumerable.from([1, 2, 3, 4, 5, 6, 7])

const result = enumerable.some((item) => item % 2 === 0)

console.log(result) // true

Overrides

Parameters

selector - function(IStripe, number, IEnumerable<IStripe>):number

A function which returns a numeric value for the given element.

Signature Details

function(element: IStripe, index: number, source: IEnumerable<IStripe>) : number

The selector to use for the IEnumerable<T>.

A function which returns a result of type TResult for each element.

Parameters

element - IStripe

The current element create a result for.

index - number

The element's index in the

source - IEnumerable<IStripe>

The enumerable this function is called upon.

Returns

number

A result of type TResult created from the element.

thisArg - Object

The optional object to use for this in the function.

Returns

↪number

The sum of the elements of the enumerable.

Examples

const enumerable = IEnumerable.from([
  { type: 'A', amount: 3 },
  { type: 'B', amount: 2 },
  { type: 'C', amount: 2 },
  { type: 'D', amount: 5 }
])

const result = enumerable.sum((element) => element.amount)

console.log(result) // yields 12

Overrides

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.

Returns

↪IEnumerable<IStripe>

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 enumerable
console.log(enumerable.take(2).toArray()) // yields [1,2]

// negative parameter means taking elements from the end of the enumerable
console.log(enumerable.take(-2).toArray()) // yields [6,7]

See Also

Overrides

Remarks

Parameters

predicate - function(IStripe, number, IEnumerable<IStripe>):boolean

A function which returns true as long as the elements should be added to the returned enumerable.

Signature Details

function(element: IStripe, index: number, source: IEnumerable<IStripe>) : boolean

The predicate to use for IEnumerable<T>.

Parameters

element - IStripe

The current element to test.

index - number

The element's index in the

source - IEnumerable<IStripe>

The enumerable this function is called upon.

Returns

boolean

true if the item matches the condition.

thisArg - Object

The optional object to use for thisin the function.

Returns

↪IEnumerable<IStripe>

A dynamic enumerable that is a subset of the original enumerable.

Examples

const enumerable = IEnumerable.from([1, 2, 3, 30, 4, 5])

const result = enumerable.takeWhile((item) => item < 5)

console.log(result.toArray()) // yields [1,2,3]

Overrides

Returns

↪IStripe[]

An array with the elements of this enumerable.

Overrides

Returns

↪List<IStripe>

A List<T> of the elements of this enumerable.

Overrides

Remarks

Returns

↪IEnumerable<IStripe>

A dynamic enumerable which contains the elements of the original enumerable in reverse order.

Examples

const enumerable = IEnumerable.from([1, 2, 3, 4, 5])

const result = enumerable.toReversed()

console.log(result.toArray()) // yields [5,4,3,2,1]

const list = List.fromArray([1, 2, 3, 4, 5])

const result = list.toReversed()

list.add(0)

// result changed also
console.log(result.toArray()) // yields [0,5,4,3,2,1]

Overrides

See Also

Overrides

Event Registration

Event Deregistration