source: trip-planner-front/node_modules/rxjs/src/internal/Subscription.ts@ 571e0df

Last change on this file since 571e0df was 6a3a178, checked in by Ema <ema_spirova@…>, 3 years ago

initial commit

  • Property mode set to 100644
File size: 7.9 KB
Line 
1import { isArray } from './util/isArray';
2import { isObject } from './util/isObject';
3import { isFunction } from './util/isFunction';
4import { UnsubscriptionError } from './util/UnsubscriptionError';
5import { SubscriptionLike, TeardownLogic } from './types';
6
7/**
8 * Represents a disposable resource, such as the execution of an Observable. A
9 * Subscription has one important method, `unsubscribe`, that takes no argument
10 * and just disposes the resource held by the subscription.
11 *
12 * Additionally, subscriptions may be grouped together through the `add()`
13 * method, which will attach a child Subscription to the current Subscription.
14 * When a Subscription is unsubscribed, all its children (and its grandchildren)
15 * will be unsubscribed as well.
16 *
17 * @class Subscription
18 */
19export class Subscription implements SubscriptionLike {
20 /** @nocollapse */
21 public static EMPTY: Subscription = (function(empty: any) {
22 empty.closed = true;
23 return empty;
24 }(new Subscription()));
25
26 /**
27 * A flag to indicate whether this Subscription has already been unsubscribed.
28 * @type {boolean}
29 */
30 public closed: boolean = false;
31
32 /** @internal */
33 protected _parentOrParents: Subscription | Subscription[] = null;
34 /** @internal */
35 private _subscriptions: SubscriptionLike[] = null;
36
37 /**
38 * @param {function(): void} [unsubscribe] A function describing how to
39 * perform the disposal of resources when the `unsubscribe` method is called.
40 */
41 constructor(unsubscribe?: () => void) {
42 if (unsubscribe) {
43 (this as any)._ctorUnsubscribe = true;
44 (this as any)._unsubscribe = unsubscribe;
45 }
46 }
47
48 /**
49 * Disposes the resources held by the subscription. May, for instance, cancel
50 * an ongoing Observable execution or cancel any other type of work that
51 * started when the Subscription was created.
52 * @return {void}
53 */
54 unsubscribe(): void {
55 let errors: any[];
56
57 if (this.closed) {
58 return;
59 }
60
61 let { _parentOrParents, _ctorUnsubscribe, _unsubscribe, _subscriptions } = (this as any);
62
63 this.closed = true;
64 this._parentOrParents = null;
65 // null out _subscriptions first so any child subscriptions that attempt
66 // to remove themselves from this subscription will noop
67 this._subscriptions = null;
68
69 if (_parentOrParents instanceof Subscription) {
70 _parentOrParents.remove(this);
71 } else if (_parentOrParents !== null) {
72 for (let index = 0; index < _parentOrParents.length; ++index) {
73 const parent = _parentOrParents[index];
74 parent.remove(this);
75 }
76 }
77
78 if (isFunction(_unsubscribe)) {
79 // It's only possible to null _unsubscribe - to release the reference to
80 // any teardown function passed in the constructor - if the property was
81 // actually assigned in the constructor, as there are some classes that
82 // are derived from Subscriber (which derives from Subscription) that
83 // implement an _unsubscribe method as a mechanism for obtaining
84 // unsubscription notifications and some of those subscribers are
85 // recycled. Also, in some of those subscribers, _unsubscribe switches
86 // from a prototype method to an instance property - see notifyNext in
87 // RetryWhenSubscriber.
88 if (_ctorUnsubscribe) {
89 (this as any)._unsubscribe = undefined;
90 }
91 try {
92 _unsubscribe.call(this);
93 } catch (e) {
94 errors = e instanceof UnsubscriptionError ? flattenUnsubscriptionErrors(e.errors) : [e];
95 }
96 }
97
98 if (isArray(_subscriptions)) {
99 let index = -1;
100 let len = _subscriptions.length;
101
102 while (++index < len) {
103 const sub = _subscriptions[index];
104 if (isObject(sub)) {
105 try {
106 sub.unsubscribe();
107 } catch (e) {
108 errors = errors || [];
109 if (e instanceof UnsubscriptionError) {
110 errors = errors.concat(flattenUnsubscriptionErrors(e.errors));
111 } else {
112 errors.push(e);
113 }
114 }
115 }
116 }
117 }
118
119 if (errors) {
120 throw new UnsubscriptionError(errors);
121 }
122 }
123
124 /**
125 * Adds a tear down to be called during the unsubscribe() of this
126 * Subscription. Can also be used to add a child subscription.
127 *
128 * If the tear down being added is a subscription that is already
129 * unsubscribed, is the same reference `add` is being called on, or is
130 * `Subscription.EMPTY`, it will not be added.
131 *
132 * If this subscription is already in an `closed` state, the passed
133 * tear down logic will be executed immediately.
134 *
135 * When a parent subscription is unsubscribed, any child subscriptions that were added to it are also unsubscribed.
136 *
137 * @param {TeardownLogic} teardown The additional logic to execute on
138 * teardown.
139 * @return {Subscription} Returns the Subscription used or created to be
140 * added to the inner subscriptions list. This Subscription can be used with
141 * `remove()` to remove the passed teardown logic from the inner subscriptions
142 * list.
143 */
144 add(teardown: TeardownLogic): Subscription {
145 let subscription = (<Subscription>teardown);
146
147 if (!teardown) {
148 return Subscription.EMPTY;
149 }
150
151 switch (typeof teardown) {
152 case 'function':
153 subscription = new Subscription(<(() => void)>teardown);
154 case 'object':
155 if (subscription === this || subscription.closed || typeof subscription.unsubscribe !== 'function') {
156 // This also covers the case where `subscription` is `Subscription.EMPTY`, which is always in `closed` state.
157 return subscription;
158 } else if (this.closed) {
159 subscription.unsubscribe();
160 return subscription;
161 } else if (!(subscription instanceof Subscription)) {
162 const tmp = subscription;
163 subscription = new Subscription();
164 subscription._subscriptions = [tmp];
165 }
166 break;
167 default: {
168 throw new Error('unrecognized teardown ' + teardown + ' added to Subscription.');
169 }
170 }
171
172 // Add `this` as parent of `subscription` if that's not already the case.
173 let { _parentOrParents } = subscription;
174 if (_parentOrParents === null) {
175 // If we don't have a parent, then set `subscription._parents` to
176 // the `this`, which is the common case that we optimize for.
177 subscription._parentOrParents = this;
178 } else if (_parentOrParents instanceof Subscription) {
179 if (_parentOrParents === this) {
180 // The `subscription` already has `this` as a parent.
181 return subscription;
182 }
183 // If there's already one parent, but not multiple, allocate an
184 // Array to store the rest of the parent Subscriptions.
185 subscription._parentOrParents = [_parentOrParents, this];
186 } else if (_parentOrParents.indexOf(this) === -1) {
187 // Only add `this` to the _parentOrParents list if it's not already there.
188 _parentOrParents.push(this);
189 } else {
190 // The `subscription` already has `this` as a parent.
191 return subscription;
192 }
193
194 // Optimize for the common case when adding the first subscription.
195 const subscriptions = this._subscriptions;
196 if (subscriptions === null) {
197 this._subscriptions = [subscription];
198 } else {
199 subscriptions.push(subscription);
200 }
201
202 return subscription;
203 }
204
205 /**
206 * Removes a Subscription from the internal list of subscriptions that will
207 * unsubscribe during the unsubscribe process of this Subscription.
208 * @param {Subscription} subscription The subscription to remove.
209 * @return {void}
210 */
211 remove(subscription: Subscription): void {
212 const subscriptions = this._subscriptions;
213 if (subscriptions) {
214 const subscriptionIndex = subscriptions.indexOf(subscription);
215 if (subscriptionIndex !== -1) {
216 subscriptions.splice(subscriptionIndex, 1);
217 }
218 }
219 }
220}
221
222function flattenUnsubscriptionErrors(errors: any[]) {
223 return errors.reduce((errs, err) => errs.concat((err instanceof UnsubscriptionError) ? err.errors : err), []);
224}
Note: See TracBrowser for help on using the repository browser.