distinct.js
3.97 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
"use strict";
var __extends = (this && this.__extends) || function (d, b) {
for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
var OuterSubscriber_1 = require('../OuterSubscriber');
var subscribeToResult_1 = require('../util/subscribeToResult');
var Set_1 = require('../util/Set');
/**
* Returns an Observable that emits all items emitted by the source Observable that are distinct by comparison from previous items.
* If a keySelector function is provided, then it will project each value from the source observable into a new value that it will
* check for equality with previously projected values. If a keySelector function is not provided, it will use each value from the
* source observable directly with an equality check against previous values.
* In JavaScript runtimes that support `Set`, this operator will use a `Set` to improve performance of the distinct value checking.
* In other runtimes, this operator will use a minimal implementation of `Set` that relies on an `Array` and `indexOf` under the
* hood, so performance will degrade as more values are checked for distinction. Even in newer browsers, a long-running `distinct`
* use might result in memory leaks. To help alleviate this in some scenarios, an optional `flushes` parameter is also provided so
* that the internal `Set` can be "flushed", basically clearing it of values.
* @param {function} [keySelector] optional function to select which value you want to check as distinct.
* @param {Observable} [flushes] optional Observable for flushing the internal HashSet of the operator.
* @return {Observable} an Observable that emits items from the source Observable with distinct values.
* @method distinct
* @owner Observable
*/
function distinct(keySelector, flushes) {
return this.lift(new DistinctOperator(keySelector, flushes));
}
exports.distinct = distinct;
var DistinctOperator = (function () {
function DistinctOperator(keySelector, flushes) {
this.keySelector = keySelector;
this.flushes = flushes;
}
DistinctOperator.prototype.call = function (subscriber, source) {
return source.subscribe(new DistinctSubscriber(subscriber, this.keySelector, this.flushes));
};
return DistinctOperator;
}());
/**
* We need this JSDoc comment for affecting ESDoc.
* @ignore
* @extends {Ignored}
*/
var DistinctSubscriber = (function (_super) {
__extends(DistinctSubscriber, _super);
function DistinctSubscriber(destination, keySelector, flushes) {
_super.call(this, destination);
this.keySelector = keySelector;
this.values = new Set_1.Set();
if (flushes) {
this.add(subscribeToResult_1.subscribeToResult(this, flushes));
}
}
DistinctSubscriber.prototype.notifyNext = function (outerValue, innerValue, outerIndex, innerIndex, innerSub) {
this.values.clear();
};
DistinctSubscriber.prototype.notifyError = function (error, innerSub) {
this._error(error);
};
DistinctSubscriber.prototype._next = function (value) {
if (this.keySelector) {
this._useKeySelector(value);
}
else {
this._finalizeNext(value, value);
}
};
DistinctSubscriber.prototype._useKeySelector = function (value) {
var key;
var destination = this.destination;
try {
key = this.keySelector(value);
}
catch (err) {
destination.error(err);
return;
}
this._finalizeNext(key, value);
};
DistinctSubscriber.prototype._finalizeNext = function (key, value) {
var values = this.values;
if (!values.has(key)) {
values.add(key);
this.destination.next(value);
}
};
return DistinctSubscriber;
}(OuterSubscriber_1.OuterSubscriber));
exports.DistinctSubscriber = DistinctSubscriber;
//# sourceMappingURL=distinct.js.map