If you record to the cell an instance of class which inherits of cellx.EventEmitter
,
then the cell will subscribe to its change
event and will claim it as own:
let value = cellx(new cellx.EventEmitter());
value.subscribe((err, evt) => {
console.log(evt.target instanceof cellx.EventEmitter);
});
value().emit('change');
// => true
Due to this, you can create your collections, upon updating those collections you will update the cell containing them and dependent cells will be recalculated. Two such collections already is added to the cellx:
Example:
let map = new cellx.ObservableMap({
key1: 1,
key2: 2,
key3: 3
});
cellx.ObservableMap
repeats
Map from ECMAScript 2015,
except for the following differences:
- inherits of
cellx.EventEmitter
and generates an eventchange
when changing their records; - has a method
clone
, which creates a copy of map; - data on initialization can be not only an array but also in the form of an object (in this case, only strings will be counted as keys, and the key difference between object and Map is in the fact that the keys in the Map can be of any type) or another map.
Example:
let list = new cellx.ObservableList([1, 2, 3]);
Like cellx.ObservableMap
, list generates an event change
upon any change of its records.
During initialization the list may take option itemComparator
, which will implement the assortment of its items:
let list = new cellx.ObservableList([
{ x: 5 },
{ x: 1 },
{ x: 10 }
], {
itemComparator: (a, b) => {
if (a.x < b.x) { return -1; }
if (a.x > b.x) { return 1; }
return 0;
}
});
console.log(list.toArray());
// => [{ x: 1 }, { x: 5 }, { x: 10 }]
list.addRange([{ x: 100 }, { x: -100 }, { x: 7 }]);
console.log(list.toArray());
// => [{ x: -100 }, { x: 1 }, { x: 5 }, { x: 7 }, { x: 10 }, { x: 100 }]
If instead of itemComparator
you pass the option sorted
with the value true
, it will use the standard itemComparator
:
let list = new cellx.ObservableList([5, 1, 10], { sorted: true });
console.log(list.toArray());
// => [1, 5, 10]
list.addRange([100, -100, 7]);
console.log(list.toArray());
// => [-100, 1, 5, 7, 10, 100]
Length of the list. Read-only.
Function for comparing items in the sorted list. Read-only.
Whether or not the list is sorted. Read-only.
Important difference between list and array is that the list can't contain so-called "holes"
that is, when it will try to read or set the item of the index beyond the existing range of indexes,
an exception will be generated.
Range extension (adding of items) occurs through methods add
, addRange
, insert
and insertRange
.
In such case, in the last two methods passed index
can not be longer than the length of the list.
Sorted list suggests that its items are always in sorted order. Methods
set
, setRange
, insert
and insertRange
are contrary to this statement, they either will break the correct order
of sorting or (for preservation of this order) will install/paste past the specified index, i.e.
will not work properly. Therefore, when you call the sorted list, they always generate an exception. It is possible to
add items to the sorted list through the methods add
and addRange
, or during initialization of the list.
Type signature: (item) -> boolean;
.
Checks if the item is in the list.
Type signature: (item, fromIndex?: int) -> int;
.
Type signature: (item, fromIndex?: int) -> int;
.
Type signature: (index: int) -> *;
.
Type signature: (index: int, count?: uint) -> Array;
.
If count
is unspecified it makes copies till the end of the list.
Type signature: (index: int, item) -> cellx.ObservableList;
.
Type signature: (index: int, items: Array) -> cellx.ObservableList;
.
Type signature: (item, unique?: boolean) -> cellx.ObservableList;
.
Type signature: (items: Array, uniques?: boolean) -> cellx.ObservableList;
.
Type signature: (index: int, item) -> cellx.ObservableList;
.
Type signature: (index: int, items: Array) -> cellx.ObservableList;
.
Type signature: (item, fromIndex?: int) -> boolean;
.
Removes the first occurrence of item
in the list.
Type signature: (item, fromIndex?: int) -> boolean;
.
It removes all occurrences of item
list.
Type signature: (index: int) -> *;
.
Type signature: (index: int, count?: uint) -> Array;
.
If count
is unspecified it will remove everything till the end of the list.
Type signature: (oldItem, newItem, fromIndex?: int) -> boolean;
.
Type signature: (oldItem, newItem, fromIndex?: int) -> boolean;
.
Type signature: () -> cellx.ObservableList;
.
Type signature: (separator?: string) -> string;
.
Type signature: (cb: (item, index: uint, list: cellx.ObservableList), context?);
.
Type signature: (cb: (item, index: uint, list: cellx.ObservableList) -> *, context?) -> Array;
.
Type signature: (cb: (item, index: uint, list: cellx.ObservableList) -> ?boolean, context?) -> Array;
.
Type signature: (cb: (item, index: uint, list: cellx.ObservableList) -> ?boolean, context?) -> boolean;
.
Type signature: (cb: (item, index: uint, list: cellx.ObservableList) -> ?boolean, context?) -> boolean;
.
Type signature: (cb: (accumulator, item, index: uint, list: cellx.ObservableList) -> *, initialValue?) -> *;
.
Type signature: (cb: (accumulator, item, index: uint, list: cellx.ObservableList) -> *, initialValue?) -> *;
.
Type signature: (cb: (item, index: uint, list: cellx.ObservableList) -> ?boolean, fromIndex?: int) -> *;
.
Type signature: (cb: (item, index: uint, list: cellx.ObservableList) -> ?boolean, fromIndex?: int) -> *;
.
Type signature: (cb: (item, index: uint, list: cellx.ObservableList) -> ?boolean, fromIndex?: int) -> int;
.
Type signature: (cb: (item, index: uint, list: cellx.ObservableList) -> ?boolean, fromIndex?: int) -> int;
.
Type signature: () -> cellx.ObservableList;
.
Type signature: () -> Array;
.
Type signature: () -> string;
.