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
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
|
import { PartialObserver } from './types';
import { Observable } from './Observable';
import { empty } from './observable/empty';
import { of } from './observable/of';
import { throwError } from './observable/throwError';
export const enum NotificationKind {
NEXT = 'N',
ERROR = 'E',
COMPLETE = 'C',
}
/**
* Represents a push-based event or value that an {@link Observable} can emit.
* This class is particularly useful for operators that manage notifications,
* like {@link materialize}, {@link dematerialize}, {@link observeOn}, and
* others. Besides wrapping the actual delivered value, it also annotates it
* with metadata of, for instance, what type of push message it is (`next`,
* `error`, or `complete`).
*
* @see {@link materialize}
* @see {@link dematerialize}
* @see {@link observeOn}
*
* @class Notification<T>
*/
export class Notification<T> {
hasValue: boolean;
constructor(public kind: NotificationKind, public value?: T, public error?: any) {
this.hasValue = kind === NotificationKind.NEXT;
}
/**
* Delivers to the given `observer` the value wrapped by this Notification.
* @param {Observer} observer
* @return
*/
observe(observer: PartialObserver<T>): any {
switch (this.kind) {
case NotificationKind.NEXT:
return observer.next && observer.next(this.value);
case NotificationKind.ERROR:
return observer.error && observer.error(this.error);
case NotificationKind.COMPLETE:
return observer.complete && observer.complete();
}
}
/**
* Given some {@link Observer} callbacks, deliver the value represented by the
* current Notification to the correctly corresponding callback.
* @param {function(value: T): void} next An Observer `next` callback.
* @param {function(err: any): void} [error] An Observer `error` callback.
* @param {function(): void} [complete] An Observer `complete` callback.
* @return {any}
*/
do(next: (value: T) => void, error?: (err: any) => void, complete?: () => void): any {
const kind = this.kind;
switch (kind) {
case NotificationKind.NEXT:
return next && next(this.value);
case NotificationKind.ERROR:
return error && error(this.error);
case NotificationKind.COMPLETE:
return complete && complete();
}
}
/**
* Takes an Observer or its individual callback functions, and calls `observe`
* or `do` methods accordingly.
* @param {Observer|function(value: T): void} nextOrObserver An Observer or
* the `next` callback.
* @param {function(err: any): void} [error] An Observer `error` callback.
* @param {function(): void} [complete] An Observer `complete` callback.
* @return {any}
*/
accept(nextOrObserver: PartialObserver<T> | ((value: T) => void), error?: (err: any) => void, complete?: () => void) {
if (nextOrObserver && typeof (<PartialObserver<T>>nextOrObserver).next === 'function') {
return this.observe(<PartialObserver<T>>nextOrObserver);
} else {
return this.do(<(value: T) => void>nextOrObserver, error, complete);
}
}
/**
* Returns a simple Observable that just delivers the notification represented
* by this Notification instance.
* @return {any}
*/
toObservable(): Observable<T> {
const kind = this.kind;
switch (kind) {
case NotificationKind.NEXT:
return of(this.value);
case NotificationKind.ERROR:
return throwError(this.error);
case NotificationKind.COMPLETE:
return empty();
}
throw new Error('unexpected notification kind value');
}
private static completeNotification: Notification<any> = new Notification(NotificationKind.COMPLETE);
private static undefinedValueNotification: Notification<any> = new Notification(NotificationKind.NEXT, undefined);
/**
* A shortcut to create a Notification instance of the type `next` from a
* given value.
* @param {T} value The `next` value.
* @return {Notification<T>} The "next" Notification representing the
* argument.
* @nocollapse
*/
static createNext<T>(value: T): Notification<T> {
if (typeof value !== 'undefined') {
return new Notification(NotificationKind.NEXT, value);
}
return Notification.undefinedValueNotification;
}
/**
* A shortcut to create a Notification instance of the type `error` from a
* given error.
* @param {any} [err] The `error` error.
* @return {Notification<T>} The "error" Notification representing the
* argument.
* @nocollapse
*/
static createError<T>(err?: any): Notification<T> {
return new Notification(NotificationKind.ERROR, undefined, err);
}
/**
* A shortcut to create a Notification instance of the type `complete`.
* @return {Notification<any>} The valueless "complete" Notification.
* @nocollapse
*/
static createComplete(): Notification<any> {
return Notification.completeNotification;
}
}
|
