@reactivex/rxjs
Version:
Reactive Extensions for modern JavaScript
111 lines • 3.61 kB
JavaScript
;
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
}
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var Subscriber_1 = require("../Subscriber");
/**
* Emits false if the input observable emits any values, or emits true if the
* input observable completes without emitting any values.
*
* <span class="informal">Tells whether any values are emitted by an observable</span>
*
* 
*
* `isEmpty` transforms an Observable that emits values into an Observable that
* emits a single boolean value representing whether or not any values were
* emitted by the source Observable. As soon as the source Observable emits a
* value, `isEmpty` will emit a `false` and complete. If the source Observable
* completes having not emitted anything, `isEmpty` will emit a `true` and
* complete.
*
* A similar effect could be achieved with {@link count}, but `isEmpty` can emit
* a `false` value sooner.
*
* ## Examples
*
* Emit `false` for a non-empty Observable
* ```javascript
* import { Subject } from 'rxjs';
* import { isEmpty } from 'rxjs/operators';
*
* const source = new Subject<string>();
* const result = source.pipe(isEmpty());
* source.subscribe(x => console.log(x));
* result.subscribe(x => console.log(x));
* source.next('a');
* source.next('b');
* source.next('c');
* source.complete();
*
* // Results in:
* // a
* // false
* // b
* // c
* ```
*
* Emit `true` for an empty Observable
* ```javascript
* import { EMPTY } from 'rxjs';
* import { isEmpty } from 'rxjs/operators';
*
* const result = EMPTY.pipe(isEmpty());
* result.subscribe(x => console.log(x));
* // Results in:
* // true
* ```
*
* @see {@link count}
* @see {@link EMPTY}
*
* @return {OperatorFunction<T, boolean>} An Observable of a boolean value indicating whether observable was empty or not
* @method isEmpty
* @owner Observable
*/
function isEmpty() {
return function (source) { return source.lift(new IsEmptyOperator()); };
}
exports.isEmpty = isEmpty;
var IsEmptyOperator = /** @class */ (function () {
function IsEmptyOperator() {
}
IsEmptyOperator.prototype.call = function (observer, source) {
return source.subscribe(new IsEmptySubscriber(observer));
};
return IsEmptyOperator;
}());
/**
* We need this JSDoc comment for affecting ESDoc.
* @ignore
* @extends {Ignored}
*/
var IsEmptySubscriber = /** @class */ (function (_super) {
__extends(IsEmptySubscriber, _super);
function IsEmptySubscriber(destination) {
return _super.call(this, destination) || this;
}
IsEmptySubscriber.prototype.notifyComplete = function (isEmpty) {
var destination = this.destination;
destination.next(isEmpty);
destination.complete();
};
IsEmptySubscriber.prototype._next = function (value) {
this.notifyComplete(false);
};
IsEmptySubscriber.prototype._complete = function () {
this.notifyComplete(true);
};
return IsEmptySubscriber;
}(Subscriber_1.Subscriber));
//# sourceMappingURL=isEmpty.js.map