1 | import { __awaiter, __generator, __spreadArray, __assign, __rest, __extends } from 'tslib';
|
2 | import { ErrorFactory, deepEqual, isBrowserExtension, isMobileCordova, isReactNative, FirebaseError, querystring, getModularInstance, base64Decode, isIE, getUA, createSubscribe, querystringDecode, extractQuerystring, isEmpty } from '@firebase/util';
|
3 | import { SDK_VERSION, _getProvider, _registerComponent, registerVersion } from '@firebase/app';
|
4 | import { Component } from '@firebase/component';
|
5 | import { Logger, LogLevel } from '@firebase/logger';
|
6 |
|
7 | var STORAGE_AVAILABLE_KEY = '__sak';
|
8 |
|
9 |
|
10 |
|
11 |
|
12 |
|
13 |
|
14 |
|
15 |
|
16 |
|
17 |
|
18 |
|
19 |
|
20 |
|
21 |
|
22 |
|
23 |
|
24 |
|
25 |
|
26 |
|
27 |
|
28 |
|
29 |
|
30 | function _allSettled(promises) {
|
31 | var _this = this;
|
32 | return Promise.all(promises.map(function (promise) { return __awaiter(_this, void 0, void 0, function () {
|
33 | var value, reason_1;
|
34 | return __generator(this, function (_a) {
|
35 | switch (_a.label) {
|
36 | case 0:
|
37 | _a.trys.push([0, 2, , 3]);
|
38 | return [4 , promise];
|
39 | case 1:
|
40 | value = _a.sent();
|
41 | return [2 , {
|
42 | fulfilled: true,
|
43 | value: value
|
44 | }];
|
45 | case 2:
|
46 | reason_1 = _a.sent();
|
47 | return [2 , {
|
48 | fulfilled: false,
|
49 | reason: reason_1
|
50 | }];
|
51 | case 3: return [2 ];
|
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 | var Receiver = (function () {
|
78 | function Receiver(eventTarget) {
|
79 | this.eventTarget = eventTarget;
|
80 | this.handlersMap = {};
|
81 | this.boundEventHandler = this.handleEvent.bind(this);
|
82 | }
|
83 | |
84 |
|
85 |
|
86 |
|
87 |
|
88 |
|
89 | Receiver._getInstance = function (eventTarget) {
|
90 |
|
91 |
|
92 |
|
93 | var existingInstance = this.receivers.find(function (receiver) {
|
94 | return receiver.isListeningto(eventTarget);
|
95 | });
|
96 | if (existingInstance) {
|
97 | return existingInstance;
|
98 | }
|
99 | var newInstance = new Receiver(eventTarget);
|
100 | this.receivers.push(newInstance);
|
101 | return newInstance;
|
102 | };
|
103 | Receiver.prototype.isListeningto = function (eventTarget) {
|
104 | return this.eventTarget === eventTarget;
|
105 | };
|
106 | |
107 |
|
108 |
|
109 |
|
110 |
|
111 |
|
112 |
|
113 |
|
114 |
|
115 |
|
116 | Receiver.prototype.handleEvent = function (event) {
|
117 | return __awaiter(this, void 0, void 0, function () {
|
118 | var messageEvent, _a, eventId, eventType, data, handlers, promises, response;
|
119 | var _this = this;
|
120 | return __generator(this, function (_b) {
|
121 | switch (_b.label) {
|
122 | case 0:
|
123 | messageEvent = event;
|
124 | _a = messageEvent.data, eventId = _a.eventId, eventType = _a.eventType, data = _a.data;
|
125 | handlers = this.handlersMap[eventType];
|
126 | if (!(handlers === null || handlers === void 0 ? void 0 : handlers.size)) {
|
127 | return [2 ];
|
128 | }
|
129 | messageEvent.ports[0].postMessage({
|
130 | status: "ack" ,
|
131 | eventId: eventId,
|
132 | eventType: eventType
|
133 | });
|
134 | promises = Array.from(handlers).map(function (handler) { return __awaiter(_this, void 0, void 0, function () { return __generator(this, function (_a) {
|
135 | return [2 , handler(messageEvent.origin, data)];
|
136 | }); }); });
|
137 | return [4 , _allSettled(promises)];
|
138 | case 1:
|
139 | response = _b.sent();
|
140 | messageEvent.ports[0].postMessage({
|
141 | status: "done" ,
|
142 | eventId: eventId,
|
143 | eventType: eventType,
|
144 | response: response
|
145 | });
|
146 | return [2 ];
|
147 | }
|
148 | });
|
149 | });
|
150 | };
|
151 | |
152 |
|
153 |
|
154 |
|
155 |
|
156 |
|
157 |
|
158 | Receiver.prototype._subscribe = function (eventType, eventHandler) {
|
159 | if (Object.keys(this.handlersMap).length === 0) {
|
160 | this.eventTarget.addEventListener('message', this.boundEventHandler);
|
161 | }
|
162 | if (!this.handlersMap[eventType]) {
|
163 | this.handlersMap[eventType] = new Set();
|
164 | }
|
165 | this.handlersMap[eventType].add(eventHandler);
|
166 | };
|
167 | |
168 |
|
169 |
|
170 |
|
171 |
|
172 |
|
173 |
|
174 | Receiver.prototype._unsubscribe = function (eventType, eventHandler) {
|
175 | if (this.handlersMap[eventType] && eventHandler) {
|
176 | this.handlersMap[eventType].delete(eventHandler);
|
177 | }
|
178 | if (!eventHandler || this.handlersMap[eventType].size === 0) {
|
179 | delete this.handlersMap[eventType];
|
180 | }
|
181 | if (Object.keys(this.handlersMap).length === 0) {
|
182 | this.eventTarget.removeEventListener('message', this.boundEventHandler);
|
183 | }
|
184 | };
|
185 | Receiver.receivers = [];
|
186 | return Receiver;
|
187 | }());
|
188 |
|
189 |
|
190 |
|
191 |
|
192 |
|
193 |
|
194 |
|
195 |
|
196 |
|
197 |
|
198 |
|
199 |
|
200 |
|
201 |
|
202 |
|
203 |
|
204 |
|
205 | function _generateEventId(prefix, digits) {
|
206 | if (prefix === void 0) { prefix = ''; }
|
207 | if (digits === void 0) { digits = 10; }
|
208 | var random = '';
|
209 | for (var i = 0; i < digits; i++) {
|
210 | random += Math.floor(Math.random() * 10);
|
211 | }
|
212 | return prefix + random;
|
213 | }
|
214 |
|
215 |
|
216 |
|
217 |
|
218 |
|
219 |
|
220 |
|
221 |
|
222 |
|
223 |
|
224 |
|
225 |
|
226 |
|
227 |
|
228 |
|
229 |
|
230 |
|
231 |
|
232 |
|
233 |
|
234 |
|
235 | var Sender = (function () {
|
236 | function Sender(target) {
|
237 | this.target = target;
|
238 | this.handlers = new Set();
|
239 | }
|
240 | |
241 |
|
242 |
|
243 |
|
244 |
|
245 | Sender.prototype.removeMessageHandler = function (handler) {
|
246 | if (handler.messageChannel) {
|
247 | handler.messageChannel.port1.removeEventListener('message', handler.onMessage);
|
248 | handler.messageChannel.port1.close();
|
249 | }
|
250 | this.handlers.delete(handler);
|
251 | };
|
252 | |
253 |
|
254 |
|
255 |
|
256 |
|
257 |
|
258 |
|
259 |
|
260 |
|
261 |
|
262 |
|
263 |
|
264 |
|
265 | Sender.prototype._send = function (eventType, data, timeout) {
|
266 | if (timeout === void 0) { timeout = 50 ; }
|
267 | return __awaiter(this, void 0, void 0, function () {
|
268 | var messageChannel, completionTimer, handler;
|
269 | var _this = this;
|
270 | return __generator(this, function (_a) {
|
271 | messageChannel = typeof MessageChannel !== 'undefined' ? new MessageChannel() : null;
|
272 | if (!messageChannel) {
|
273 | throw new Error("connection_unavailable" );
|
274 | }
|
275 | return [2 , new Promise(function (resolve, reject) {
|
276 | var eventId = _generateEventId('', 20);
|
277 | messageChannel.port1.start();
|
278 | var ackTimer = setTimeout(function () {
|
279 | reject(new Error("unsupported_event" ));
|
280 | }, timeout);
|
281 | handler = {
|
282 | messageChannel: messageChannel,
|
283 | onMessage: function (event) {
|
284 | var messageEvent = event;
|
285 | if (messageEvent.data.eventId !== eventId) {
|
286 | return;
|
287 | }
|
288 | switch (messageEvent.data.status) {
|
289 | case "ack" :
|
290 |
|
291 | clearTimeout(ackTimer);
|
292 | completionTimer = setTimeout(function () {
|
293 | reject(new Error("timeout" ));
|
294 | }, 3000 );
|
295 | break;
|
296 | case "done" :
|
297 |
|
298 | clearTimeout(completionTimer);
|
299 | resolve(messageEvent.data.response);
|
300 | break;
|
301 | default:
|
302 | clearTimeout(ackTimer);
|
303 | clearTimeout(completionTimer);
|
304 | reject(new Error("invalid_response" ));
|
305 | break;
|
306 | }
|
307 | }
|
308 | };
|
309 | _this.handlers.add(handler);
|
310 | messageChannel.port1.addEventListener('message', handler.onMessage);
|
311 | _this.target.postMessage({
|
312 | eventType: eventType,
|
313 | eventId: eventId,
|
314 | data: data
|
315 | }, [messageChannel.port2]);
|
316 | }).finally(function () {
|
317 | if (handler) {
|
318 | _this.removeMessageHandler(handler);
|
319 | }
|
320 | })];
|
321 | });
|
322 | });
|
323 | };
|
324 | return Sender;
|
325 | }());
|
326 |
|
327 |
|
328 |
|
329 |
|
330 |
|
331 |
|
332 |
|
333 |
|
334 |
|
335 |
|
336 |
|
337 |
|
338 |
|
339 |
|
340 |
|
341 |
|
342 |
|
343 |
|
344 |
|
345 |
|
346 |
|
347 | function _window() {
|
348 | return window;
|
349 | }
|
350 | function _setWindowLocation(url) {
|
351 | _window().location.href = url;
|
352 | }
|
353 |
|
354 |
|
355 |
|
356 |
|
357 |
|
358 |
|
359 |
|
360 |
|
361 |
|
362 |
|
363 |
|
364 |
|
365 |
|
366 |
|
367 |
|
368 |
|
369 |
|
370 | function _isWorker() {
|
371 | return (typeof _window()['WorkerGlobalScope'] !== 'undefined' &&
|
372 | typeof _window()['importScripts'] === 'function');
|
373 | }
|
374 | function _getActiveServiceWorker() {
|
375 | return __awaiter(this, void 0, void 0, function () {
|
376 | var registration;
|
377 | return __generator(this, function (_b) {
|
378 | switch (_b.label) {
|
379 | case 0:
|
380 | if (!(navigator === null || navigator === void 0 ? void 0 : navigator.serviceWorker)) {
|
381 | return [2 , null];
|
382 | }
|
383 | _b.label = 1;
|
384 | case 1:
|
385 | _b.trys.push([1, 3, , 4]);
|
386 | return [4 , navigator.serviceWorker.ready];
|
387 | case 2:
|
388 | registration = _b.sent();
|
389 | return [2 , registration.active];
|
390 | case 3:
|
391 | _b.sent();
|
392 | return [2 , null];
|
393 | case 4: return [2 ];
|
394 | }
|
395 | });
|
396 | });
|
397 | }
|
398 | function _getServiceWorkerController() {
|
399 | var _a;
|
400 | return ((_a = navigator === null || navigator === void 0 ? void 0 : navigator.serviceWorker) === null || _a === void 0 ? void 0 : _a.controller) || null;
|
401 | }
|
402 | function _getWorkerGlobalScope() {
|
403 | return _isWorker() ? self : null;
|
404 | }
|
405 |
|
406 |
|
407 |
|
408 |
|
409 |
|
410 |
|
411 |
|
412 |
|
413 |
|
414 |
|
415 |
|
416 |
|
417 |
|
418 |
|
419 |
|
420 |
|
421 |
|
422 | var DB_NAME = 'firebaseLocalStorageDb';
|
423 | var DB_VERSION = 1;
|
424 | var DB_OBJECTSTORE_NAME = 'firebaseLocalStorage';
|
425 | var DB_DATA_KEYPATH = 'fbase_key';
|
426 |
|
427 |
|
428 |
|
429 |
|
430 |
|
431 |
|
432 | var DBPromise = (function () {
|
433 | function DBPromise(request) {
|
434 | this.request = request;
|
435 | }
|
436 | DBPromise.prototype.toPromise = function () {
|
437 | var _this = this;
|
438 | return new Promise(function (resolve, reject) {
|
439 | _this.request.addEventListener('success', function () {
|
440 | resolve(_this.request.result);
|
441 | });
|
442 | _this.request.addEventListener('error', function () {
|
443 | reject(_this.request.error);
|
444 | });
|
445 | });
|
446 | };
|
447 | return DBPromise;
|
448 | }());
|
449 | function getObjectStore(db, isReadWrite) {
|
450 | return db
|
451 | .transaction([DB_OBJECTSTORE_NAME], isReadWrite ? 'readwrite' : 'readonly')
|
452 | .objectStore(DB_OBJECTSTORE_NAME);
|
453 | }
|
454 | function _deleteDatabase() {
|
455 | var request = indexedDB.deleteDatabase(DB_NAME);
|
456 | return new DBPromise(request).toPromise();
|
457 | }
|
458 | function _openDatabase() {
|
459 | var _this = this;
|
460 | var request = indexedDB.open(DB_NAME, DB_VERSION);
|
461 | return new Promise(function (resolve, reject) {
|
462 | request.addEventListener('error', function () {
|
463 | reject(request.error);
|
464 | });
|
465 | request.addEventListener('upgradeneeded', function () {
|
466 | var db = request.result;
|
467 | try {
|
468 | db.createObjectStore(DB_OBJECTSTORE_NAME, { keyPath: DB_DATA_KEYPATH });
|
469 | }
|
470 | catch (e) {
|
471 | reject(e);
|
472 | }
|
473 | });
|
474 | request.addEventListener('success', function () { return __awaiter(_this, void 0, void 0, function () {
|
475 | var db, _a;
|
476 | return __generator(this, function (_b) {
|
477 | switch (_b.label) {
|
478 | case 0:
|
479 | db = request.result;
|
480 | if (!!db.objectStoreNames.contains(DB_OBJECTSTORE_NAME)) return [3 , 3];
|
481 |
|
482 | db.close();
|
483 | return [4 , _deleteDatabase()];
|
484 | case 1:
|
485 | _b.sent();
|
486 | _a = resolve;
|
487 | return [4 , _openDatabase()];
|
488 | case 2:
|
489 | _a.apply(void 0, [_b.sent()]);
|
490 | return [3 , 4];
|
491 | case 3:
|
492 | resolve(db);
|
493 | _b.label = 4;
|
494 | case 4: return [2 ];
|
495 | }
|
496 | });
|
497 | }); });
|
498 | });
|
499 | }
|
500 | function _putObject(db, key, value) {
|
501 | return __awaiter(this, void 0, void 0, function () {
|
502 | var request;
|
503 | var _a;
|
504 | return __generator(this, function (_b) {
|
505 | request = getObjectStore(db, true).put((_a = {},
|
506 | _a[DB_DATA_KEYPATH] = key,
|
507 | _a.value = value,
|
508 | _a));
|
509 | return [2 , new DBPromise(request).toPromise()];
|
510 | });
|
511 | });
|
512 | }
|
513 | function getObject(db, key) {
|
514 | return __awaiter(this, void 0, void 0, function () {
|
515 | var request, data;
|
516 | return __generator(this, function (_a) {
|
517 | switch (_a.label) {
|
518 | case 0:
|
519 | request = getObjectStore(db, false).get(key);
|
520 | return [4 , new DBPromise(request).toPromise()];
|
521 | case 1:
|
522 | data = _a.sent();
|
523 | return [2 , data === undefined ? null : data.value];
|
524 | }
|
525 | });
|
526 | });
|
527 | }
|
528 | function _deleteObject(db, key) {
|
529 | var request = getObjectStore(db, true).delete(key);
|
530 | return new DBPromise(request).toPromise();
|
531 | }
|
532 | var _POLLING_INTERVAL_MS$1 = 800;
|
533 | var _TRANSACTION_RETRY_COUNT = 3;
|
534 | var IndexedDBLocalPersistence = (function () {
|
535 | function IndexedDBLocalPersistence() {
|
536 | this.type = "LOCAL" ;
|
537 | this._shouldAllowMigration = true;
|
538 | this.listeners = {};
|
539 | this.localCache = {};
|
540 |
|
541 |
|
542 | this.pollTimer = null;
|
543 | this.pendingWrites = 0;
|
544 | this.receiver = null;
|
545 | this.sender = null;
|
546 | this.serviceWorkerReceiverAvailable = false;
|
547 | this.activeServiceWorker = null;
|
548 |
|
549 | this._workerInitializationPromise =
|
550 | this.initializeServiceWorkerMessaging().then(function () { }, function () { });
|
551 | }
|
552 | IndexedDBLocalPersistence.prototype._openDb = function () {
|
553 | return __awaiter(this, void 0, void 0, function () {
|
554 | var _a;
|
555 | return __generator(this, function (_b) {
|
556 | switch (_b.label) {
|
557 | case 0:
|
558 | if (this.db) {
|
559 | return [2 , this.db];
|
560 | }
|
561 | _a = this;
|
562 | return [4 , _openDatabase()];
|
563 | case 1:
|
564 | _a.db = _b.sent();
|
565 | return [2 , this.db];
|
566 | }
|
567 | });
|
568 | });
|
569 | };
|
570 | IndexedDBLocalPersistence.prototype._withRetries = function (op) {
|
571 | return __awaiter(this, void 0, void 0, function () {
|
572 | var numAttempts, db, e_1;
|
573 | return __generator(this, function (_a) {
|
574 | switch (_a.label) {
|
575 | case 0:
|
576 | numAttempts = 0;
|
577 | _a.label = 1;
|
578 | case 1:
|
579 | _a.label = 2;
|
580 | case 2:
|
581 | _a.trys.push([2, 5, , 6]);
|
582 | return [4 , this._openDb()];
|
583 | case 3:
|
584 | db = _a.sent();
|
585 | return [4 , op(db)];
|
586 | case 4: return [2 , _a.sent()];
|
587 | case 5:
|
588 | e_1 = _a.sent();
|
589 | if (numAttempts++ > _TRANSACTION_RETRY_COUNT) {
|
590 | throw e_1;
|
591 | }
|
592 | if (this.db) {
|
593 | this.db.close();
|
594 | this.db = undefined;
|
595 | }
|
596 | return [3 , 6];
|
597 | case 6: return [3 , 1];
|
598 | case 7: return [2 ];
|
599 | }
|
600 | });
|
601 | });
|
602 | };
|
603 | |
604 |
|
605 |
|
606 |
|
607 | IndexedDBLocalPersistence.prototype.initializeServiceWorkerMessaging = function () {
|
608 | return __awaiter(this, void 0, void 0, function () {
|
609 | return __generator(this, function (_a) {
|
610 | return [2 , _isWorker() ? this.initializeReceiver() : this.initializeSender()];
|
611 | });
|
612 | });
|
613 | };
|
614 | |
615 |
|
616 |
|
617 | IndexedDBLocalPersistence.prototype.initializeReceiver = function () {
|
618 | return __awaiter(this, void 0, void 0, function () {
|
619 | var _this = this;
|
620 | return __generator(this, function (_a) {
|
621 | this.receiver = Receiver._getInstance(_getWorkerGlobalScope());
|
622 |
|
623 | this.receiver._subscribe("keyChanged" , function (_origin, data) { return __awaiter(_this, void 0, void 0, function () {
|
624 | var keys;
|
625 | return __generator(this, function (_a) {
|
626 | switch (_a.label) {
|
627 | case 0: return [4 , this._poll()];
|
628 | case 1:
|
629 | keys = _a.sent();
|
630 | return [2 , {
|
631 | keyProcessed: keys.includes(data.key)
|
632 | }];
|
633 | }
|
634 | });
|
635 | }); });
|
636 |
|
637 | this.receiver._subscribe("ping" , function (_origin, _data) { return __awaiter(_this, void 0, void 0, function () {
|
638 | return __generator(this, function (_a) {
|
639 | return [2 , ["keyChanged" ]];
|
640 | });
|
641 | }); });
|
642 | return [2 ];
|
643 | });
|
644 | });
|
645 | };
|
646 | |
647 |
|
648 |
|
649 |
|
650 |
|
651 |
|
652 |
|
653 | IndexedDBLocalPersistence.prototype.initializeSender = function () {
|
654 | var _a, _b;
|
655 | return __awaiter(this, void 0, void 0, function () {
|
656 | var _c, results;
|
657 | return __generator(this, function (_d) {
|
658 | switch (_d.label) {
|
659 | case 0:
|
660 |
|
661 | _c = this;
|
662 | return [4 , _getActiveServiceWorker()];
|
663 | case 1:
|
664 |
|
665 | _c.activeServiceWorker = _d.sent();
|
666 | if (!this.activeServiceWorker) {
|
667 | return [2 ];
|
668 | }
|
669 | this.sender = new Sender(this.activeServiceWorker);
|
670 | return [4 , this.sender._send("ping" , {}, 800 )];
|
671 | case 2:
|
672 | results = _d.sent();
|
673 | if (!results) {
|
674 | return [2 ];
|
675 | }
|
676 | if (((_a = results[0]) === null || _a === void 0 ? void 0 : _a.fulfilled) &&
|
677 | ((_b = results[0]) === null || _b === void 0 ? void 0 : _b.value.includes("keyChanged" ))) {
|
678 | this.serviceWorkerReceiverAvailable = true;
|
679 | }
|
680 | return [2 ];
|
681 | }
|
682 | });
|
683 | });
|
684 | };
|
685 | |
686 |
|
687 |
|
688 |
|
689 |
|
690 |
|
691 |
|
692 |
|
693 |
|
694 | IndexedDBLocalPersistence.prototype.notifyServiceWorker = function (key) {
|
695 | return __awaiter(this, void 0, void 0, function () {
|
696 | return __generator(this, function (_b) {
|
697 | switch (_b.label) {
|
698 | case 0:
|
699 | if (!this.sender ||
|
700 | !this.activeServiceWorker ||
|
701 | _getServiceWorkerController() !== this.activeServiceWorker) {
|
702 | return [2 ];
|
703 | }
|
704 | _b.label = 1;
|
705 | case 1:
|
706 | _b.trys.push([1, 3, , 4]);
|
707 | return [4 , this.sender._send("keyChanged" , { key: key },
|
708 |
|
709 | this.serviceWorkerReceiverAvailable
|
710 | ? 800
|
711 | : 50 )];
|
712 | case 2:
|
713 | _b.sent();
|
714 | return [3 , 4];
|
715 | case 3:
|
716 | _b.sent();
|
717 | return [3 , 4];
|
718 | case 4: return [2 ];
|
719 | }
|
720 | });
|
721 | });
|
722 | };
|
723 | IndexedDBLocalPersistence.prototype._isAvailable = function () {
|
724 | return __awaiter(this, void 0, void 0, function () {
|
725 | var db;
|
726 | return __generator(this, function (_b) {
|
727 | switch (_b.label) {
|
728 | case 0:
|
729 | _b.trys.push([0, 4, , 5]);
|
730 | if (!indexedDB) {
|
731 | return [2 , false];
|
732 | }
|
733 | return [4 , _openDatabase()];
|
734 | case 1:
|
735 | db = _b.sent();
|
736 | return [4 , _putObject(db, STORAGE_AVAILABLE_KEY, '1')];
|
737 | case 2:
|
738 | _b.sent();
|
739 | return [4 , _deleteObject(db, STORAGE_AVAILABLE_KEY)];
|
740 | case 3:
|
741 | _b.sent();
|
742 | return [2 , true];
|
743 | case 4:
|
744 | _b.sent();
|
745 | return [3 , 5];
|
746 | case 5: return [2 , false];
|
747 | }
|
748 | });
|
749 | });
|
750 | };
|
751 | IndexedDBLocalPersistence.prototype._withPendingWrite = function (write) {
|
752 | return __awaiter(this, void 0, void 0, function () {
|
753 | return __generator(this, function (_a) {
|
754 | switch (_a.label) {
|
755 | case 0:
|
756 | this.pendingWrites++;
|
757 | _a.label = 1;
|
758 | case 1:
|
759 | _a.trys.push([1, , 3, 4]);
|
760 | return [4 , write()];
|
761 | case 2:
|
762 | _a.sent();
|
763 | return [3 , 4];
|
764 | case 3:
|
765 | this.pendingWrites--;
|
766 | return [7 ];
|
767 | case 4: return [2 ];
|
768 | }
|
769 | });
|
770 | });
|
771 | };
|
772 | IndexedDBLocalPersistence.prototype._set = function (key, value) {
|
773 | return __awaiter(this, void 0, void 0, function () {
|
774 | var _this = this;
|
775 | return __generator(this, function (_a) {
|
776 | return [2 , this._withPendingWrite(function () { return __awaiter(_this, void 0, void 0, function () {
|
777 | return __generator(this, function (_a) {
|
778 | switch (_a.label) {
|
779 | case 0: return [4 , this._withRetries(function (db) { return _putObject(db, key, value); })];
|
780 | case 1:
|
781 | _a.sent();
|
782 | this.localCache[key] = value;
|
783 | return [2 , this.notifyServiceWorker(key)];
|
784 | }
|
785 | });
|
786 | }); })];
|
787 | });
|
788 | });
|
789 | };
|
790 | IndexedDBLocalPersistence.prototype._get = function (key) {
|
791 | return __awaiter(this, void 0, void 0, function () {
|
792 | var obj;
|
793 | return __generator(this, function (_a) {
|
794 | switch (_a.label) {
|
795 | case 0: return [4 , this._withRetries(function (db) {
|
796 | return getObject(db, key);
|
797 | })];
|
798 | case 1:
|
799 | obj = (_a.sent());
|
800 | this.localCache[key] = obj;
|
801 | return [2 , obj];
|
802 | }
|
803 | });
|
804 | });
|
805 | };
|
806 | IndexedDBLocalPersistence.prototype._remove = function (key) {
|
807 | return __awaiter(this, void 0, void 0, function () {
|
808 | var _this = this;
|
809 | return __generator(this, function (_a) {
|
810 | return [2 , this._withPendingWrite(function () { return __awaiter(_this, void 0, void 0, function () {
|
811 | return __generator(this, function (_a) {
|
812 | switch (_a.label) {
|
813 | case 0: return [4 , this._withRetries(function (db) { return _deleteObject(db, key); })];
|
814 | case 1:
|
815 | _a.sent();
|
816 | delete this.localCache[key];
|
817 | return [2 , this.notifyServiceWorker(key)];
|
818 | }
|
819 | });
|
820 | }); })];
|
821 | });
|
822 | });
|
823 | };
|
824 | IndexedDBLocalPersistence.prototype._poll = function () {
|
825 | return __awaiter(this, void 0, void 0, function () {
|
826 | var result, keys, keysInResult, _i, result_1, _a, key, value, _b, _c, localKey;
|
827 | return __generator(this, function (_d) {
|
828 | switch (_d.label) {
|
829 | case 0: return [4 , this._withRetries(function (db) {
|
830 | var getAllRequest = getObjectStore(db, false).getAll();
|
831 | return new DBPromise(getAllRequest).toPromise();
|
832 | })];
|
833 | case 1:
|
834 | result = _d.sent();
|
835 | if (!result) {
|
836 | return [2 , []];
|
837 | }
|
838 |
|
839 | if (this.pendingWrites !== 0) {
|
840 | return [2 , []];
|
841 | }
|
842 | keys = [];
|
843 | keysInResult = new Set();
|
844 | for (_i = 0, result_1 = result; _i < result_1.length; _i++) {
|
845 | _a = result_1[_i], key = _a.fbase_key, value = _a.value;
|
846 | keysInResult.add(key);
|
847 | if (JSON.stringify(this.localCache[key]) !== JSON.stringify(value)) {
|
848 | this.notifyListeners(key, value);
|
849 | keys.push(key);
|
850 | }
|
851 | }
|
852 | for (_b = 0, _c = Object.keys(this.localCache); _b < _c.length; _b++) {
|
853 | localKey = _c[_b];
|
854 | if (this.localCache[localKey] && !keysInResult.has(localKey)) {
|
855 |
|
856 | this.notifyListeners(localKey, null);
|
857 | keys.push(localKey);
|
858 | }
|
859 | }
|
860 | return [2 , keys];
|
861 | }
|
862 | });
|
863 | });
|
864 | };
|
865 | IndexedDBLocalPersistence.prototype.notifyListeners = function (key, newValue) {
|
866 | this.localCache[key] = newValue;
|
867 | var listeners = this.listeners[key];
|
868 | if (listeners) {
|
869 | for (var _i = 0, _a = Array.from(listeners); _i < _a.length; _i++) {
|
870 | var listener = _a[_i];
|
871 | listener(newValue);
|
872 | }
|
873 | }
|
874 | };
|
875 | IndexedDBLocalPersistence.prototype.startPolling = function () {
|
876 | var _this = this;
|
877 | this.stopPolling();
|
878 | this.pollTimer = setInterval(function () { return __awaiter(_this, void 0, void 0, function () { return __generator(this, function (_a) {
|
879 | return [2 , this._poll()];
|
880 | }); }); }, _POLLING_INTERVAL_MS$1);
|
881 | };
|
882 | IndexedDBLocalPersistence.prototype.stopPolling = function () {
|
883 | if (this.pollTimer) {
|
884 | clearInterval(this.pollTimer);
|
885 | this.pollTimer = null;
|
886 | }
|
887 | };
|
888 | IndexedDBLocalPersistence.prototype._addListener = function (key, listener) {
|
889 | if (Object.keys(this.listeners).length === 0) {
|
890 | this.startPolling();
|
891 | }
|
892 | if (!this.listeners[key]) {
|
893 | this.listeners[key] = new Set();
|
894 |
|
895 | void this._get(key);
|
896 | }
|
897 | this.listeners[key].add(listener);
|
898 | };
|
899 | IndexedDBLocalPersistence.prototype._removeListener = function (key, listener) {
|
900 | if (this.listeners[key]) {
|
901 | this.listeners[key].delete(listener);
|
902 | if (this.listeners[key].size === 0) {
|
903 | delete this.listeners[key];
|
904 | }
|
905 | }
|
906 | if (Object.keys(this.listeners).length === 0) {
|
907 | this.stopPolling();
|
908 | }
|
909 | };
|
910 | IndexedDBLocalPersistence.type = 'LOCAL';
|
911 | return IndexedDBLocalPersistence;
|
912 | }());
|
913 |
|
914 |
|
915 |
|
916 |
|
917 |
|
918 |
|
919 | var indexedDBLocalPersistence = IndexedDBLocalPersistence;
|
920 |
|
921 |
|
922 |
|
923 |
|
924 |
|
925 |
|
926 |
|
927 |
|
928 |
|
929 |
|
930 |
|
931 |
|
932 |
|
933 |
|
934 |
|
935 |
|
936 |
|
937 | function _debugErrorMap() {
|
938 | var _a;
|
939 | return _a = {},
|
940 | _a["admin-restricted-operation" ] = 'This operation is restricted to administrators only.',
|
941 | _a["argument-error" ] = '',
|
942 | _a["app-not-authorized" ] = "This app, identified by the domain where it's hosted, is not " +
|
943 | 'authorized to use Firebase Authentication with the provided API key. ' +
|
944 | 'Review your key configuration in the Google API console.',
|
945 | _a["app-not-installed" ] = 'The requested mobile application corresponding to the identifier (' +
|
946 | 'Android package name or iOS bundle ID) provided is not installed on ' +
|
947 | 'this device.',
|
948 | _a["captcha-check-failed" ] = 'The reCAPTCHA response token provided is either invalid, expired, ' +
|
949 | 'already used or the domain associated with it does not match the list ' +
|
950 | 'of whitelisted domains.',
|
951 | _a["code-expired" ] = 'The SMS code has expired. Please re-send the verification code to try ' +
|
952 | 'again.',
|
953 | _a["cordova-not-ready" ] = 'Cordova framework is not ready.',
|
954 | _a["cors-unsupported" ] = 'This browser is not supported.',
|
955 | _a["credential-already-in-use" ] = 'This credential is already associated with a different user account.',
|
956 | _a["custom-token-mismatch" ] = 'The custom token corresponds to a different audience.',
|
957 | _a["requires-recent-login" ] = 'This operation is sensitive and requires recent authentication. Log in ' +
|
958 | 'again before retrying this request.',
|
959 | _a["dependent-sdk-initialized-before-auth" ] = 'Another Firebase SDK was initialized and is trying to use Auth before Auth is ' +
|
960 | 'initialized. Please be sure to call `initializeAuth` or `getAuth` before ' +
|
961 | 'starting any other Firebase SDK.',
|
962 | _a["dynamic-link-not-activated" ] = 'Please activate Dynamic Links in the Firebase Console and agree to the terms and ' +
|
963 | 'conditions.',
|
964 | _a["email-change-needs-verification" ] = 'Multi-factor users must always have a verified email.',
|
965 | _a["email-already-in-use" ] = 'The email address is already in use by another account.',
|
966 | _a["emulator-config-failed" ] = 'Auth instance has already been used to make a network call. Auth can ' +
|
967 | 'no longer be configured to use the emulator. Try calling ' +
|
968 | '"connectAuthEmulator()" sooner.',
|
969 | _a["expired-action-code" ] = 'The action code has expired.',
|
970 | _a["cancelled-popup-request" ] = 'This operation has been cancelled due to another conflicting popup being opened.',
|
971 | _a["internal-error" ] = 'An internal AuthError has occurred.',
|
972 | _a["invalid-app-credential" ] = 'The phone verification request contains an invalid application verifier.' +
|
973 | ' The reCAPTCHA token response is either invalid or expired.',
|
974 | _a["invalid-app-id" ] = 'The mobile app identifier is not registed for the current project.',
|
975 | _a["invalid-user-token" ] = "This user's credential isn't valid for this project. This can happen " +
|
976 | "if the user's token has been tampered with, or if the user isn't for " +
|
977 | 'the project associated with this API key.',
|
978 | _a["invalid-auth-event" ] = 'An internal AuthError has occurred.',
|
979 | _a["invalid-verification-code" ] = 'The SMS verification code used to create the phone auth credential is ' +
|
980 | 'invalid. Please resend the verification code sms and be sure to use the ' +
|
981 | 'verification code provided by the user.',
|
982 | _a["invalid-continue-uri" ] = 'The continue URL provided in the request is invalid.',
|
983 | _a["invalid-cordova-configuration" ] = 'The following Cordova plugins must be installed to enable OAuth sign-in: ' +
|
984 | 'cordova-plugin-buildinfo, cordova-universal-links-plugin, ' +
|
985 | 'cordova-plugin-browsertab, cordova-plugin-inappbrowser and ' +
|
986 | 'cordova-plugin-customurlscheme.',
|
987 | _a["invalid-custom-token" ] = 'The custom token format is incorrect. Please check the documentation.',
|
988 | _a["invalid-dynamic-link-domain" ] = 'The provided dynamic link domain is not configured or authorized for the current project.',
|
989 | _a["invalid-email" ] = 'The email address is badly formatted.',
|
990 | _a["invalid-emulator-scheme" ] = 'Emulator URL must start with a valid scheme (http:// or https://).',
|
991 | _a["invalid-api-key" ] = 'Your API key is invalid, please check you have copied it correctly.',
|
992 | _a["invalid-cert-hash" ] = 'The SHA-1 certificate hash provided is invalid.',
|
993 | _a["invalid-credential" ] = 'The supplied auth credential is malformed or has expired.',
|
994 | _a["invalid-message-payload" ] = 'The email template corresponding to this action contains invalid characters in its message. ' +
|
995 | 'Please fix by going to the Auth email templates section in the Firebase Console.',
|
996 | _a["invalid-multi-factor-session" ] = 'The request does not contain a valid proof of first factor successful sign-in.',
|
997 | _a["invalid-oauth-provider" ] = 'EmailAuthProvider is not supported for this operation. This operation ' +
|
998 | 'only supports OAuth providers.',
|
999 | _a["invalid-oauth-client-id" ] = 'The OAuth client ID provided is either invalid or does not match the ' +
|
1000 | 'specified API key.',
|
1001 | _a["unauthorized-domain" ] = 'This domain is not authorized for OAuth operations for your Firebase ' +
|
1002 | 'project. Edit the list of authorized domains from the Firebase console.',
|
1003 | _a["invalid-action-code" ] = 'The action code is invalid. This can happen if the code is malformed, ' +
|
1004 | 'expired, or has already been used.',
|
1005 | _a["wrong-password" ] = 'The password is invalid or the user does not have a password.',
|
1006 | _a["invalid-persistence-type" ] = 'The specified persistence type is invalid. It can only be local, session or none.',
|
1007 | _a["invalid-phone-number" ] = 'The format of the phone number provided is incorrect. Please enter the ' +
|
1008 | 'phone number in a format that can be parsed into E.164 format. E.164 ' +
|
1009 | 'phone numbers are written in the format [+][country code][subscriber ' +
|
1010 | 'number including area code].',
|
1011 | _a["invalid-provider-id" ] = 'The specified provider ID is invalid.',
|
1012 | _a["invalid-recipient-email" ] = 'The email corresponding to this action failed to send as the provided ' +
|
1013 | 'recipient email address is invalid.',
|
1014 | _a["invalid-sender" ] = 'The email template corresponding to this action contains an invalid sender email or name. ' +
|
1015 | 'Please fix by going to the Auth email templates section in the Firebase Console.',
|
1016 | _a["invalid-verification-id" ] = 'The verification ID used to create the phone auth credential is invalid.',
|
1017 | _a["invalid-tenant-id" ] = "The Auth instance's tenant ID is invalid.",
|
1018 | _a["login-blocked" ] = "Login blocked by user-provided method: {$originalMessage}",
|
1019 | _a["missing-android-pkg-name" ] = 'An Android Package Name must be provided if the Android App is required to be installed.',
|
1020 | _a["auth-domain-config-required" ] = 'Be sure to include authDomain when calling firebase.initializeApp(), ' +
|
1021 | 'by following the instructions in the Firebase console.',
|
1022 | _a["missing-app-credential" ] = 'The phone verification request is missing an application verifier ' +
|
1023 | 'assertion. A reCAPTCHA response token needs to be provided.',
|
1024 | _a["missing-verification-code" ] = 'The phone auth credential was created with an empty SMS verification code.',
|
1025 | _a["missing-continue-uri" ] = 'A continue URL must be provided in the request.',
|
1026 | _a["missing-iframe-start" ] = 'An internal AuthError has occurred.',
|
1027 | _a["missing-ios-bundle-id" ] = 'An iOS Bundle ID must be provided if an App Store ID is provided.',
|
1028 | _a["missing-or-invalid-nonce" ] = 'The request does not contain a valid nonce. This can occur if the ' +
|
1029 | 'SHA-256 hash of the provided raw nonce does not match the hashed nonce ' +
|
1030 | 'in the ID token payload.',
|
1031 | _a["missing-multi-factor-info" ] = 'No second factor identifier is provided.',
|
1032 | _a["missing-multi-factor-session" ] = 'The request is missing proof of first factor successful sign-in.',
|
1033 | _a["missing-phone-number" ] = 'To send verification codes, provide a phone number for the recipient.',
|
1034 | _a["missing-verification-id" ] = 'The phone auth credential was created with an empty verification ID.',
|
1035 | _a["app-deleted" ] = 'This instance of FirebaseApp has been deleted.',
|
1036 | _a["multi-factor-info-not-found" ] = 'The user does not have a second factor matching the identifier provided.',
|
1037 | _a["multi-factor-auth-required" ] = 'Proof of ownership of a second factor is required to complete sign-in.',
|
1038 | _a["account-exists-with-different-credential" ] = 'An account already exists with the same email address but different ' +
|
1039 | 'sign-in credentials. Sign in using a provider associated with this ' +
|
1040 | 'email address.',
|
1041 | _a["network-request-failed" ] = 'A network AuthError (such as timeout, interrupted connection or unreachable host) has occurred.',
|
1042 | _a["no-auth-event" ] = 'An internal AuthError has occurred.',
|
1043 | _a["no-such-provider" ] = 'User was not linked to an account with the given provider.',
|
1044 | _a["null-user" ] = 'A null user object was provided as the argument for an operation which ' +
|
1045 | 'requires a non-null user object.',
|
1046 | _a["operation-not-allowed" ] = 'The given sign-in provider is disabled for this Firebase project. ' +
|
1047 | 'Enable it in the Firebase console, under the sign-in method tab of the ' +
|
1048 | 'Auth section.',
|
1049 | _a["operation-not-supported-in-this-environment" ] = 'This operation is not supported in the environment this application is ' +
|
1050 | 'running on. "location.protocol" must be http, https or chrome-extension' +
|
1051 | ' and web storage must be enabled.',
|
1052 | _a["popup-blocked" ] = 'Unable to establish a connection with the popup. It may have been blocked by the browser.',
|
1053 | _a["popup-closed-by-user" ] = 'The popup has been closed by the user before finalizing the operation.',
|
1054 | _a["provider-already-linked" ] = 'User can only be linked to one identity for the given provider.',
|
1055 | _a["quota-exceeded" ] = "The project's quota for this operation has been exceeded.",
|
1056 | _a["redirect-cancelled-by-user" ] = 'The redirect operation has been cancelled by the user before finalizing.',
|
1057 | _a["redirect-operation-pending" ] = 'A redirect sign-in operation is already pending.',
|
1058 | _a["rejected-credential" ] = 'The request contains malformed or mismatching credentials.',
|
1059 | _a["second-factor-already-in-use" ] = 'The second factor is already enrolled on this account.',
|
1060 | _a["maximum-second-factor-count-exceeded" ] = 'The maximum allowed number of second factors on a user has been exceeded.',
|
1061 | _a["tenant-id-mismatch" ] = "The provided tenant ID does not match the Auth instance's tenant ID",
|
1062 | _a["timeout" ] = 'The operation has timed out.',
|
1063 | _a["user-token-expired" ] = "The user's credential is no longer valid. The user must sign in again.",
|
1064 | _a["too-many-requests" ] = 'We have blocked all requests from this device due to unusual activity. ' +
|
1065 | 'Try again later.',
|
1066 | _a["unauthorized-continue-uri" ] = 'The domain of the continue URL is not whitelisted. Please whitelist ' +
|
1067 | 'the domain in the Firebase console.',
|
1068 | _a["unsupported-first-factor" ] = 'Enrolling a second factor or signing in with a multi-factor account requires sign-in with a supported first factor.',
|
1069 | _a["unsupported-persistence-type" ] = 'The current environment does not support the specified persistence type.',
|
1070 | _a["unsupported-tenant-operation" ] = 'This operation is not supported in a multi-tenant context.',
|
1071 | _a["unverified-email" ] = 'The operation requires a verified email.',
|
1072 | _a["user-cancelled" ] = 'The user did not grant your application the permissions it requested.',
|
1073 | _a["user-not-found" ] = 'There is no user record corresponding to this identifier. The user may ' +
|
1074 | 'have been deleted.',
|
1075 | _a["user-disabled" ] = 'The user account has been disabled by an administrator.',
|
1076 | _a["user-mismatch" ] = 'The supplied credentials do not correspond to the previously signed in user.',
|
1077 | _a["user-signed-out" ] = '',
|
1078 | _a["weak-password" ] = 'The password must be 6 characters long or more.',
|
1079 | _a["web-storage-unsupported" ] = 'This browser is not supported or 3rd party cookies and data may be disabled.',
|
1080 | _a["already-initialized" ] = 'initializeAuth() has already been called with ' +
|
1081 | 'different options. To avoid this error, call initializeAuth() with the ' +
|
1082 | 'same options as when it was originally called, or call getAuth() to return the' +
|
1083 | ' already initialized instance.',
|
1084 | _a;
|
1085 | }
|
1086 | function _prodErrorMap() {
|
1087 | var _a;
|
1088 |
|
1089 |
|
1090 |
|
1091 | return _a = {},
|
1092 | _a["dependent-sdk-initialized-before-auth" ] = 'Another Firebase SDK was initialized and is trying to use Auth before Auth is ' +
|
1093 | 'initialized. Please be sure to call `initializeAuth` or `getAuth` before ' +
|
1094 | 'starting any other Firebase SDK.',
|
1095 | _a;
|
1096 | }
|
1097 |
|
1098 |
|
1099 |
|
1100 |
|
1101 |
|
1102 |
|
1103 |
|
1104 | var debugErrorMap = _debugErrorMap;
|
1105 |
|
1106 |
|
1107 |
|
1108 |
|
1109 |
|
1110 |
|
1111 |
|
1112 | var prodErrorMap = _prodErrorMap;
|
1113 | var _DEFAULT_AUTH_ERROR_FACTORY = new ErrorFactory('auth', 'Firebase', _prodErrorMap());
|
1114 |
|
1115 |
|
1116 |
|
1117 |
|
1118 |
|
1119 |
|
1120 |
|
1121 |
|
1122 |
|
1123 |
|
1124 |
|
1125 | var AUTH_ERROR_CODES_MAP_DO_NOT_USE_INTERNALLY = {
|
1126 | ADMIN_ONLY_OPERATION: 'auth/admin-restricted-operation',
|
1127 | ARGUMENT_ERROR: 'auth/argument-error',
|
1128 | APP_NOT_AUTHORIZED: 'auth/app-not-authorized',
|
1129 | APP_NOT_INSTALLED: 'auth/app-not-installed',
|
1130 | CAPTCHA_CHECK_FAILED: 'auth/captcha-check-failed',
|
1131 | CODE_EXPIRED: 'auth/code-expired',
|
1132 | CORDOVA_NOT_READY: 'auth/cordova-not-ready',
|
1133 | CORS_UNSUPPORTED: 'auth/cors-unsupported',
|
1134 | CREDENTIAL_ALREADY_IN_USE: 'auth/credential-already-in-use',
|
1135 | CREDENTIAL_MISMATCH: 'auth/custom-token-mismatch',
|
1136 | CREDENTIAL_TOO_OLD_LOGIN_AGAIN: 'auth/requires-recent-login',
|
1137 | DEPENDENT_SDK_INIT_BEFORE_AUTH: 'auth/dependent-sdk-initialized-before-auth',
|
1138 | DYNAMIC_LINK_NOT_ACTIVATED: 'auth/dynamic-link-not-activated',
|
1139 | EMAIL_CHANGE_NEEDS_VERIFICATION: 'auth/email-change-needs-verification',
|
1140 | EMAIL_EXISTS: 'auth/email-already-in-use',
|
1141 | EMULATOR_CONFIG_FAILED: 'auth/emulator-config-failed',
|
1142 | EXPIRED_OOB_CODE: 'auth/expired-action-code',
|
1143 | EXPIRED_POPUP_REQUEST: 'auth/cancelled-popup-request',
|
1144 | INTERNAL_ERROR: 'auth/internal-error',
|
1145 | INVALID_API_KEY: 'auth/invalid-api-key',
|
1146 | INVALID_APP_CREDENTIAL: 'auth/invalid-app-credential',
|
1147 | INVALID_APP_ID: 'auth/invalid-app-id',
|
1148 | INVALID_AUTH: 'auth/invalid-user-token',
|
1149 | INVALID_AUTH_EVENT: 'auth/invalid-auth-event',
|
1150 | INVALID_CERT_HASH: 'auth/invalid-cert-hash',
|
1151 | INVALID_CODE: 'auth/invalid-verification-code',
|
1152 | INVALID_CONTINUE_URI: 'auth/invalid-continue-uri',
|
1153 | INVALID_CORDOVA_CONFIGURATION: 'auth/invalid-cordova-configuration',
|
1154 | INVALID_CUSTOM_TOKEN: 'auth/invalid-custom-token',
|
1155 | INVALID_DYNAMIC_LINK_DOMAIN: 'auth/invalid-dynamic-link-domain',
|
1156 | INVALID_EMAIL: 'auth/invalid-email',
|
1157 | INVALID_EMULATOR_SCHEME: 'auth/invalid-emulator-scheme',
|
1158 | INVALID_IDP_RESPONSE: 'auth/invalid-credential',
|
1159 | INVALID_MESSAGE_PAYLOAD: 'auth/invalid-message-payload',
|
1160 | INVALID_MFA_SESSION: 'auth/invalid-multi-factor-session',
|
1161 | INVALID_OAUTH_CLIENT_ID: 'auth/invalid-oauth-client-id',
|
1162 | INVALID_OAUTH_PROVIDER: 'auth/invalid-oauth-provider',
|
1163 | INVALID_OOB_CODE: 'auth/invalid-action-code',
|
1164 | INVALID_ORIGIN: 'auth/unauthorized-domain',
|
1165 | INVALID_PASSWORD: 'auth/wrong-password',
|
1166 | INVALID_PERSISTENCE: 'auth/invalid-persistence-type',
|
1167 | INVALID_PHONE_NUMBER: 'auth/invalid-phone-number',
|
1168 | INVALID_PROVIDER_ID: 'auth/invalid-provider-id',
|
1169 | INVALID_RECIPIENT_EMAIL: 'auth/invalid-recipient-email',
|
1170 | INVALID_SENDER: 'auth/invalid-sender',
|
1171 | INVALID_SESSION_INFO: 'auth/invalid-verification-id',
|
1172 | INVALID_TENANT_ID: 'auth/invalid-tenant-id',
|
1173 | MFA_INFO_NOT_FOUND: 'auth/multi-factor-info-not-found',
|
1174 | MFA_REQUIRED: 'auth/multi-factor-auth-required',
|
1175 | MISSING_ANDROID_PACKAGE_NAME: 'auth/missing-android-pkg-name',
|
1176 | MISSING_APP_CREDENTIAL: 'auth/missing-app-credential',
|
1177 | MISSING_AUTH_DOMAIN: 'auth/auth-domain-config-required',
|
1178 | MISSING_CODE: 'auth/missing-verification-code',
|
1179 | MISSING_CONTINUE_URI: 'auth/missing-continue-uri',
|
1180 | MISSING_IFRAME_START: 'auth/missing-iframe-start',
|
1181 | MISSING_IOS_BUNDLE_ID: 'auth/missing-ios-bundle-id',
|
1182 | MISSING_OR_INVALID_NONCE: 'auth/missing-or-invalid-nonce',
|
1183 | MISSING_MFA_INFO: 'auth/missing-multi-factor-info',
|
1184 | MISSING_MFA_SESSION: 'auth/missing-multi-factor-session',
|
1185 | MISSING_PHONE_NUMBER: 'auth/missing-phone-number',
|
1186 | MISSING_SESSION_INFO: 'auth/missing-verification-id',
|
1187 | MODULE_DESTROYED: 'auth/app-deleted',
|
1188 | NEED_CONFIRMATION: 'auth/account-exists-with-different-credential',
|
1189 | NETWORK_REQUEST_FAILED: 'auth/network-request-failed',
|
1190 | NULL_USER: 'auth/null-user',
|
1191 | NO_AUTH_EVENT: 'auth/no-auth-event',
|
1192 | NO_SUCH_PROVIDER: 'auth/no-such-provider',
|
1193 | OPERATION_NOT_ALLOWED: 'auth/operation-not-allowed',
|
1194 | OPERATION_NOT_SUPPORTED: 'auth/operation-not-supported-in-this-environment',
|
1195 | POPUP_BLOCKED: 'auth/popup-blocked',
|
1196 | POPUP_CLOSED_BY_USER: 'auth/popup-closed-by-user',
|
1197 | PROVIDER_ALREADY_LINKED: 'auth/provider-already-linked',
|
1198 | QUOTA_EXCEEDED: 'auth/quota-exceeded',
|
1199 | REDIRECT_CANCELLED_BY_USER: 'auth/redirect-cancelled-by-user',
|
1200 | REDIRECT_OPERATION_PENDING: 'auth/redirect-operation-pending',
|
1201 | REJECTED_CREDENTIAL: 'auth/rejected-credential',
|
1202 | SECOND_FACTOR_ALREADY_ENROLLED: 'auth/second-factor-already-in-use',
|
1203 | SECOND_FACTOR_LIMIT_EXCEEDED: 'auth/maximum-second-factor-count-exceeded',
|
1204 | TENANT_ID_MISMATCH: 'auth/tenant-id-mismatch',
|
1205 | TIMEOUT: 'auth/timeout',
|
1206 | TOKEN_EXPIRED: 'auth/user-token-expired',
|
1207 | TOO_MANY_ATTEMPTS_TRY_LATER: 'auth/too-many-requests',
|
1208 | UNAUTHORIZED_DOMAIN: 'auth/unauthorized-continue-uri',
|
1209 | UNSUPPORTED_FIRST_FACTOR: 'auth/unsupported-first-factor',
|
1210 | UNSUPPORTED_PERSISTENCE: 'auth/unsupported-persistence-type',
|
1211 | UNSUPPORTED_TENANT_OPERATION: 'auth/unsupported-tenant-operation',
|
1212 | UNVERIFIED_EMAIL: 'auth/unverified-email',
|
1213 | USER_CANCELLED: 'auth/user-cancelled',
|
1214 | USER_DELETED: 'auth/user-not-found',
|
1215 | USER_DISABLED: 'auth/user-disabled',
|
1216 | USER_MISMATCH: 'auth/user-mismatch',
|
1217 | USER_SIGNED_OUT: 'auth/user-signed-out',
|
1218 | WEAK_PASSWORD: 'auth/weak-password',
|
1219 | WEB_STORAGE_UNSUPPORTED: 'auth/web-storage-unsupported',
|
1220 | ALREADY_INITIALIZED: 'auth/already-initialized'
|
1221 | };
|
1222 |
|
1223 |
|
1224 |
|
1225 |
|
1226 |
|
1227 |
|
1228 |
|
1229 |
|
1230 |
|
1231 |
|
1232 |
|
1233 |
|
1234 |
|
1235 |
|
1236 |
|
1237 |
|
1238 |
|
1239 | var logClient = new Logger('@firebase/auth');
|
1240 | function _logError(msg) {
|
1241 | var args = [];
|
1242 | for (var _i = 1; _i < arguments.length; _i++) {
|
1243 | args[_i - 1] = arguments[_i];
|
1244 | }
|
1245 | if (logClient.logLevel <= LogLevel.ERROR) {
|
1246 | logClient.error.apply(logClient, __spreadArray(["Auth (" + SDK_VERSION + "): " + msg], args));
|
1247 | }
|
1248 | }
|
1249 |
|
1250 |
|
1251 |
|
1252 |
|
1253 |
|
1254 |
|
1255 |
|
1256 |
|
1257 |
|
1258 |
|
1259 |
|
1260 |
|
1261 |
|
1262 |
|
1263 |
|
1264 |
|
1265 |
|
1266 | function _fail(authOrCode) {
|
1267 | var rest = [];
|
1268 | for (var _i = 1; _i < arguments.length; _i++) {
|
1269 | rest[_i - 1] = arguments[_i];
|
1270 | }
|
1271 | throw createErrorInternal.apply(void 0, __spreadArray([authOrCode], rest));
|
1272 | }
|
1273 | function _createError(authOrCode) {
|
1274 | var rest = [];
|
1275 | for (var _i = 1; _i < arguments.length; _i++) {
|
1276 | rest[_i - 1] = arguments[_i];
|
1277 | }
|
1278 | return createErrorInternal.apply(void 0, __spreadArray([authOrCode], rest));
|
1279 | }
|
1280 | function _errorWithCustomMessage(auth, code, message) {
|
1281 | var _a;
|
1282 | var errorMap = __assign(__assign({}, prodErrorMap()), (_a = {}, _a[code] = message, _a));
|
1283 | var factory = new ErrorFactory('auth', 'Firebase', errorMap);
|
1284 | return factory.create(code, {
|
1285 | appName: auth.name,
|
1286 | });
|
1287 | }
|
1288 | function _assertInstanceOf(auth, object, instance) {
|
1289 | var constructorInstance = instance;
|
1290 | if (!(object instanceof constructorInstance)) {
|
1291 | if (constructorInstance.name !== object.constructor.name) {
|
1292 | _fail(auth, "argument-error" );
|
1293 | }
|
1294 | throw _errorWithCustomMessage(auth, "argument-error" , "Type of " + object.constructor.name + " does not match expected instance." +
|
1295 | "Did you pass a reference from a different Auth SDK?");
|
1296 | }
|
1297 | }
|
1298 | function createErrorInternal(authOrCode) {
|
1299 | var _a;
|
1300 | var rest = [];
|
1301 | for (var _i = 1; _i < arguments.length; _i++) {
|
1302 | rest[_i - 1] = arguments[_i];
|
1303 | }
|
1304 | if (typeof authOrCode !== 'string') {
|
1305 | var code = rest[0];
|
1306 | var fullParams = __spreadArray([], rest.slice(1));
|
1307 | if (fullParams[0]) {
|
1308 | fullParams[0].appName = authOrCode.name;
|
1309 | }
|
1310 | return (_a = authOrCode._errorFactory).create.apply(_a, __spreadArray([code], fullParams));
|
1311 | }
|
1312 | return _DEFAULT_AUTH_ERROR_FACTORY.create.apply(_DEFAULT_AUTH_ERROR_FACTORY, __spreadArray([authOrCode], rest));
|
1313 | }
|
1314 | function _assert(assertion, authOrCode) {
|
1315 | var rest = [];
|
1316 | for (var _i = 2; _i < arguments.length; _i++) {
|
1317 | rest[_i - 2] = arguments[_i];
|
1318 | }
|
1319 | if (!assertion) {
|
1320 | throw createErrorInternal.apply(void 0, __spreadArray([authOrCode], rest));
|
1321 | }
|
1322 | }
|
1323 |
|
1324 |
|
1325 |
|
1326 |
|
1327 |
|
1328 |
|
1329 | function debugFail(failure) {
|
1330 |
|
1331 |
|
1332 | var message = "INTERNAL ASSERTION FAILED: " + failure;
|
1333 | _logError(message);
|
1334 |
|
1335 |
|
1336 |
|
1337 | throw new Error(message);
|
1338 | }
|
1339 |
|
1340 |
|
1341 |
|
1342 |
|
1343 |
|
1344 |
|
1345 |
|
1346 | function debugAssert(assertion, message) {
|
1347 | if (!assertion) {
|
1348 | debugFail(message);
|
1349 | }
|
1350 | }
|
1351 |
|
1352 |
|
1353 |
|
1354 |
|
1355 |
|
1356 |
|
1357 |
|
1358 |
|
1359 |
|
1360 |
|
1361 |
|
1362 |
|
1363 |
|
1364 |
|
1365 |
|
1366 |
|
1367 |
|
1368 | var instanceCache = new Map();
|
1369 | function _getInstance(cls) {
|
1370 | debugAssert(cls instanceof Function, 'Expected a class definition');
|
1371 | var instance = instanceCache.get(cls);
|
1372 | if (instance) {
|
1373 | debugAssert(instance instanceof cls, 'Instance stored in cache mismatched with class');
|
1374 | return instance;
|
1375 | }
|
1376 | instance = new cls();
|
1377 | instanceCache.set(cls, instance);
|
1378 | return instance;
|
1379 | }
|
1380 |
|
1381 |
|
1382 |
|
1383 |
|
1384 |
|
1385 |
|
1386 |
|
1387 |
|
1388 |
|
1389 |
|
1390 |
|
1391 |
|
1392 |
|
1393 |
|
1394 |
|
1395 |
|
1396 |
|
1397 |
|
1398 |
|
1399 |
|
1400 |
|
1401 |
|
1402 |
|
1403 |
|
1404 |
|
1405 |
|
1406 |
|
1407 |
|
1408 |
|
1409 |
|
1410 |
|
1411 |
|
1412 |
|
1413 |
|
1414 |
|
1415 |
|
1416 |
|
1417 |
|
1418 |
|
1419 |
|
1420 |
|
1421 |
|
1422 | function initializeAuth(app, deps) {
|
1423 | var provider = _getProvider(app, 'auth');
|
1424 | if (provider.isInitialized()) {
|
1425 | var auth_1 = provider.getImmediate();
|
1426 | var initialOptions = provider.getOptions();
|
1427 | if (deepEqual(initialOptions, deps !== null && deps !== void 0 ? deps : {})) {
|
1428 | return auth_1;
|
1429 | }
|
1430 | else {
|
1431 | _fail(auth_1, "already-initialized" );
|
1432 | }
|
1433 | }
|
1434 | var auth = provider.initialize({ options: deps });
|
1435 | return auth;
|
1436 | }
|
1437 | function _initializeAuthInstance(auth, deps) {
|
1438 | var persistence = (deps === null || deps === void 0 ? void 0 : deps.persistence) || [];
|
1439 | var hierarchy = (Array.isArray(persistence) ? persistence : [persistence]).map(_getInstance);
|
1440 | if (deps === null || deps === void 0 ? void 0 : deps.errorMap) {
|
1441 | auth._updateErrorMap(deps.errorMap);
|
1442 | }
|
1443 |
|
1444 |
|
1445 |
|
1446 | auth._initializeWithPersistence(hierarchy, deps === null || deps === void 0 ? void 0 : deps.popupRedirectResolver);
|
1447 | }
|
1448 |
|
1449 |
|
1450 |
|
1451 |
|
1452 |
|
1453 |
|
1454 |
|
1455 |
|
1456 |
|
1457 |
|
1458 |
|
1459 |
|
1460 |
|
1461 |
|
1462 |
|
1463 |
|
1464 |
|
1465 | function _getCurrentUrl() {
|
1466 | var _a;
|
1467 | return (typeof self !== 'undefined' && ((_a = self.location) === null || _a === void 0 ? void 0 : _a.href)) || '';
|
1468 | }
|
1469 | function _isHttpOrHttps() {
|
1470 | return _getCurrentScheme() === 'http:' || _getCurrentScheme() === 'https:';
|
1471 | }
|
1472 | function _getCurrentScheme() {
|
1473 | var _a;
|
1474 | return (typeof self !== 'undefined' && ((_a = self.location) === null || _a === void 0 ? void 0 : _a.protocol)) || null;
|
1475 | }
|
1476 |
|
1477 |
|
1478 |
|
1479 |
|
1480 |
|
1481 |
|
1482 |
|
1483 |
|
1484 |
|
1485 |
|
1486 |
|
1487 |
|
1488 |
|
1489 |
|
1490 |
|
1491 |
|
1492 |
|
1493 |
|
1494 |
|
1495 |
|
1496 | function _isOnline() {
|
1497 | if (typeof navigator !== 'undefined' &&
|
1498 | navigator &&
|
1499 | 'onLine' in navigator &&
|
1500 | typeof navigator.onLine === 'boolean' &&
|
1501 |
|
1502 |
|
1503 |
|
1504 |
|
1505 |
|
1506 | (_isHttpOrHttps() || isBrowserExtension() || 'connection' in navigator)) {
|
1507 | return navigator.onLine;
|
1508 | }
|
1509 |
|
1510 | return true;
|
1511 | }
|
1512 | function _getUserLanguage() {
|
1513 | if (typeof navigator === 'undefined') {
|
1514 | return null;
|
1515 | }
|
1516 | var navigatorLanguage = navigator;
|
1517 | return (
|
1518 |
|
1519 | (navigatorLanguage.languages && navigatorLanguage.languages[0]) ||
|
1520 |
|
1521 |
|
1522 | navigatorLanguage.language ||
|
1523 |
|
1524 | null);
|
1525 | }
|
1526 |
|
1527 |
|
1528 |
|
1529 |
|
1530 |
|
1531 |
|
1532 |
|
1533 |
|
1534 |
|
1535 |
|
1536 |
|
1537 |
|
1538 |
|
1539 |
|
1540 |
|
1541 |
|
1542 |
|
1543 |
|
1544 |
|
1545 |
|
1546 |
|
1547 |
|
1548 | var Delay = (function () {
|
1549 | function Delay(shortDelay, longDelay) {
|
1550 | this.shortDelay = shortDelay;
|
1551 | this.longDelay = longDelay;
|
1552 |
|
1553 | debugAssert(longDelay > shortDelay, 'Short delay should be less than long delay!');
|
1554 | this.isMobile = isMobileCordova() || isReactNative();
|
1555 | }
|
1556 | Delay.prototype.get = function () {
|
1557 | if (!_isOnline()) {
|
1558 |
|
1559 | return Math.min(5000 , this.shortDelay);
|
1560 | }
|
1561 |
|
1562 |
|
1563 |
|
1564 |
|
1565 | return this.isMobile ? this.longDelay : this.shortDelay;
|
1566 | };
|
1567 | return Delay;
|
1568 | }());
|
1569 |
|
1570 |
|
1571 |
|
1572 |
|
1573 |
|
1574 |
|
1575 |
|
1576 |
|
1577 |
|
1578 |
|
1579 |
|
1580 |
|
1581 |
|
1582 |
|
1583 |
|
1584 |
|
1585 |
|
1586 | function _emulatorUrl(config, path) {
|
1587 | debugAssert(config.emulator, 'Emulator should always be set here');
|
1588 | var url = config.emulator.url;
|
1589 | if (!path) {
|
1590 | return url;
|
1591 | }
|
1592 | return "" + url + (path.startsWith('/') ? path.slice(1) : path);
|
1593 | }
|
1594 |
|
1595 |
|
1596 |
|
1597 |
|
1598 |
|
1599 |
|
1600 |
|
1601 |
|
1602 |
|
1603 |
|
1604 |
|
1605 |
|
1606 |
|
1607 |
|
1608 |
|
1609 |
|
1610 |
|
1611 | var FetchProvider = (function () {
|
1612 | function FetchProvider() {
|
1613 | }
|
1614 | FetchProvider.initialize = function (fetchImpl, headersImpl, responseImpl) {
|
1615 | this.fetchImpl = fetchImpl;
|
1616 | if (headersImpl) {
|
1617 | this.headersImpl = headersImpl;
|
1618 | }
|
1619 | if (responseImpl) {
|
1620 | this.responseImpl = responseImpl;
|
1621 | }
|
1622 | };
|
1623 | FetchProvider.fetch = function () {
|
1624 | if (this.fetchImpl) {
|
1625 | return this.fetchImpl;
|
1626 | }
|
1627 | if (typeof self !== 'undefined' && 'fetch' in self) {
|
1628 | return self.fetch;
|
1629 | }
|
1630 | debugFail('Could not find fetch implementation, make sure you call FetchProvider.initialize() with an appropriate polyfill');
|
1631 | };
|
1632 | FetchProvider.headers = function () {
|
1633 | if (this.headersImpl) {
|
1634 | return this.headersImpl;
|
1635 | }
|
1636 | if (typeof self !== 'undefined' && 'Headers' in self) {
|
1637 | return self.Headers;
|
1638 | }
|
1639 | debugFail('Could not find Headers implementation, make sure you call FetchProvider.initialize() with an appropriate polyfill');
|
1640 | };
|
1641 | FetchProvider.response = function () {
|
1642 | if (this.responseImpl) {
|
1643 | return this.responseImpl;
|
1644 | }
|
1645 | if (typeof self !== 'undefined' && 'Response' in self) {
|
1646 | return self.Response;
|
1647 | }
|
1648 | debugFail('Could not find Response implementation, make sure you call FetchProvider.initialize() with an appropriate polyfill');
|
1649 | };
|
1650 | return FetchProvider;
|
1651 | }());
|
1652 |
|
1653 |
|
1654 |
|
1655 |
|
1656 |
|
1657 |
|
1658 |
|
1659 |
|
1660 |
|
1661 |
|
1662 |
|
1663 |
|
1664 |
|
1665 |
|
1666 |
|
1667 |
|
1668 |
|
1669 | var _a$1;
|
1670 |
|
1671 |
|
1672 |
|
1673 | var SERVER_ERROR_MAP = (_a$1 = {},
|
1674 |
|
1675 | _a$1["CREDENTIAL_MISMATCH" ] = "custom-token-mismatch" ,
|
1676 |
|
1677 | _a$1["MISSING_CUSTOM_TOKEN" ] = "internal-error" ,
|
1678 |
|
1679 | _a$1["INVALID_IDENTIFIER" ] = "invalid-email" ,
|
1680 |
|
1681 | _a$1["MISSING_CONTINUE_URI" ] = "internal-error" ,
|
1682 |
|
1683 | _a$1["INVALID_PASSWORD" ] = "wrong-password" ,
|
1684 |
|
1685 | _a$1["MISSING_PASSWORD" ] = "internal-error" ,
|
1686 |
|
1687 | _a$1["EMAIL_EXISTS" ] = "email-already-in-use" ,
|
1688 | _a$1["PASSWORD_LOGIN_DISABLED" ] = "operation-not-allowed" ,
|
1689 |
|
1690 | _a$1["INVALID_IDP_RESPONSE" ] = "invalid-credential" ,
|
1691 | _a$1["INVALID_PENDING_TOKEN" ] = "invalid-credential" ,
|
1692 | _a$1["FEDERATED_USER_ID_ALREADY_LINKED" ] = "credential-already-in-use" ,
|
1693 |
|
1694 | _a$1["MISSING_REQ_TYPE" ] = "internal-error" ,
|
1695 |
|
1696 | _a$1["EMAIL_NOT_FOUND" ] = "user-not-found" ,
|
1697 | _a$1["RESET_PASSWORD_EXCEED_LIMIT" ] = "too-many-requests" ,
|
1698 | _a$1["EXPIRED_OOB_CODE" ] = "expired-action-code" ,
|
1699 | _a$1["INVALID_OOB_CODE" ] = "invalid-action-code" ,
|
1700 |
|
1701 | _a$1["MISSING_OOB_CODE" ] = "internal-error" ,
|
1702 |
|
1703 | _a$1["CREDENTIAL_TOO_OLD_LOGIN_AGAIN" ] = "requires-recent-login" ,
|
1704 | _a$1["INVALID_ID_TOKEN" ] = "invalid-user-token" ,
|
1705 | _a$1["TOKEN_EXPIRED" ] = "user-token-expired" ,
|
1706 | _a$1["USER_NOT_FOUND" ] = "user-token-expired" ,
|
1707 |
|
1708 | _a$1["TOO_MANY_ATTEMPTS_TRY_LATER" ] = "too-many-requests" ,
|
1709 |
|
1710 | _a$1["INVALID_CODE" ] = "invalid-verification-code" ,
|
1711 | _a$1["INVALID_SESSION_INFO" ] = "invalid-verification-id" ,
|
1712 | _a$1["INVALID_TEMPORARY_PROOF" ] = "invalid-credential" ,
|
1713 | _a$1["MISSING_SESSION_INFO" ] = "missing-verification-id" ,
|
1714 | _a$1["SESSION_EXPIRED" ] = "code-expired" ,
|
1715 |
|
1716 |
|
1717 |
|
1718 | _a$1["MISSING_ANDROID_PACKAGE_NAME" ] = "missing-android-pkg-name" ,
|
1719 | _a$1["UNAUTHORIZED_DOMAIN" ] = "unauthorized-continue-uri" ,
|
1720 |
|
1721 | _a$1["INVALID_OAUTH_CLIENT_ID" ] = "invalid-oauth-client-id" ,
|
1722 |
|
1723 | _a$1["ADMIN_ONLY_OPERATION" ] = "admin-restricted-operation" ,
|
1724 |
|
1725 | _a$1["INVALID_MFA_PENDING_CREDENTIAL" ] = "invalid-multi-factor-session" ,
|
1726 | _a$1["MFA_ENROLLMENT_NOT_FOUND" ] = "multi-factor-info-not-found" ,
|
1727 | _a$1["MISSING_MFA_ENROLLMENT_ID" ] = "missing-multi-factor-info" ,
|
1728 | _a$1["MISSING_MFA_PENDING_CREDENTIAL" ] = "missing-multi-factor-session" ,
|
1729 | _a$1["SECOND_FACTOR_EXISTS" ] = "second-factor-already-in-use" ,
|
1730 | _a$1["SECOND_FACTOR_LIMIT_EXCEEDED" ] = "maximum-second-factor-count-exceeded" ,
|
1731 |
|
1732 | _a$1["BLOCKING_FUNCTION_ERROR_RESPONSE" ] = "internal-error" ,
|
1733 | _a$1);
|
1734 |
|
1735 |
|
1736 |
|
1737 |
|
1738 |
|
1739 |
|
1740 |
|
1741 |
|
1742 |
|
1743 |
|
1744 |
|
1745 |
|
1746 |
|
1747 |
|
1748 |
|
1749 |
|
1750 |
|
1751 | var DEFAULT_API_TIMEOUT_MS = new Delay(30000, 60000);
|
1752 | function _addTidIfNecessary(auth, request) {
|
1753 | if (auth.tenantId && !request.tenantId) {
|
1754 | return __assign(__assign({}, request), { tenantId: auth.tenantId });
|
1755 | }
|
1756 | return request;
|
1757 | }
|
1758 | function _performApiRequest(auth, method, path, request, customErrorMap) {
|
1759 | if (customErrorMap === void 0) { customErrorMap = {}; }
|
1760 | return __awaiter(this, void 0, void 0, function () {
|
1761 | var _this = this;
|
1762 | return __generator(this, function (_a) {
|
1763 | return [2 , _performFetchWithErrorHandling(auth, customErrorMap, function () { return __awaiter(_this, void 0, void 0, function () {
|
1764 | var body, params, query, headers;
|
1765 | return __generator(this, function (_a) {
|
1766 | switch (_a.label) {
|
1767 | case 0:
|
1768 | body = {};
|
1769 | params = {};
|
1770 | if (request) {
|
1771 | if (method === "GET" ) {
|
1772 | params = request;
|
1773 | }
|
1774 | else {
|
1775 | body = {
|
1776 | body: JSON.stringify(request)
|
1777 | };
|
1778 | }
|
1779 | }
|
1780 | query = querystring(__assign({ key: auth.config.apiKey }, params)).slice(1);
|
1781 | return [4 , auth._getAdditionalHeaders()];
|
1782 | case 1:
|
1783 | headers = _a.sent();
|
1784 | headers["Content-Type" ] = 'application/json';
|
1785 | if (auth.languageCode) {
|
1786 | headers["X-Firebase-Locale" ] = auth.languageCode;
|
1787 | }
|
1788 | return [2 , FetchProvider.fetch()(_getFinalTarget(auth, auth.config.apiHost, path, query), __assign({ method: method,
|
1789 | headers: headers, referrerPolicy: 'no-referrer' }, body))];
|
1790 | }
|
1791 | });
|
1792 | }); })];
|
1793 | });
|
1794 | });
|
1795 | }
|
1796 | function _performFetchWithErrorHandling(auth, customErrorMap, fetchFn) {
|
1797 | return __awaiter(this, void 0, void 0, function () {
|
1798 | var errorMap, networkTimeout, response, json, errorMessage, _a, serverErrorCode, serverErrorMessage, authError, e_1;
|
1799 | return __generator(this, function (_b) {
|
1800 | switch (_b.label) {
|
1801 | case 0:
|
1802 | auth._canInitEmulator = false;
|
1803 | errorMap = __assign(__assign({}, SERVER_ERROR_MAP), customErrorMap);
|
1804 | _b.label = 1;
|
1805 | case 1:
|
1806 | _b.trys.push([1, 4, , 5]);
|
1807 | networkTimeout = new NetworkTimeout(auth);
|
1808 | return [4 , Promise.race([
|
1809 | fetchFn(),
|
1810 | networkTimeout.promise
|
1811 | ])];
|
1812 | case 2:
|
1813 | response = _b.sent();
|
1814 |
|
1815 |
|
1816 | networkTimeout.clearNetworkTimeout();
|
1817 | return [4 , response.json()];
|
1818 | case 3:
|
1819 | json = _b.sent();
|
1820 | if ('needConfirmation' in json) {
|
1821 | throw _makeTaggedError(auth, "account-exists-with-different-credential" , json);
|
1822 | }
|
1823 | if (response.ok && !('errorMessage' in json)) {
|
1824 | return [2 , json];
|
1825 | }
|
1826 | else {
|
1827 | errorMessage = response.ok ? json.errorMessage : json.error.message;
|
1828 | _a = errorMessage.split(' : '), serverErrorCode = _a[0], serverErrorMessage = _a[1];
|
1829 | if (serverErrorCode === "FEDERATED_USER_ID_ALREADY_LINKED" ) {
|
1830 | throw _makeTaggedError(auth, "credential-already-in-use" , json);
|
1831 | }
|
1832 | else if (serverErrorCode === "EMAIL_EXISTS" ) {
|
1833 | throw _makeTaggedError(auth, "email-already-in-use" , json);
|
1834 | }
|
1835 | authError = errorMap[serverErrorCode] ||
|
1836 | serverErrorCode
|
1837 | .toLowerCase()
|
1838 | .replace(/[_\s]+/g, '-');
|
1839 | if (serverErrorMessage) {
|
1840 | throw _errorWithCustomMessage(auth, authError, serverErrorMessage);
|
1841 | }
|
1842 | else {
|
1843 | _fail(auth, authError);
|
1844 | }
|
1845 | }
|
1846 | return [3 , 5];
|
1847 | case 4:
|
1848 | e_1 = _b.sent();
|
1849 | if (e_1 instanceof FirebaseError) {
|
1850 | throw e_1;
|
1851 | }
|
1852 | _fail(auth, "network-request-failed" );
|
1853 | return [3 , 5];
|
1854 | case 5: return [2 ];
|
1855 | }
|
1856 | });
|
1857 | });
|
1858 | }
|
1859 | function _performSignInRequest(auth, method, path, request, customErrorMap) {
|
1860 | if (customErrorMap === void 0) { customErrorMap = {}; }
|
1861 | return __awaiter(this, void 0, void 0, function () {
|
1862 | var serverResponse;
|
1863 | return __generator(this, function (_a) {
|
1864 | switch (_a.label) {
|
1865 | case 0: return [4 , _performApiRequest(auth, method, path, request, customErrorMap)];
|
1866 | case 1:
|
1867 | serverResponse = (_a.sent());
|
1868 | if ('mfaPendingCredential' in serverResponse) {
|
1869 | _fail(auth, "multi-factor-auth-required" , {
|
1870 | _serverResponse: serverResponse
|
1871 | });
|
1872 | }
|
1873 | return [2 , serverResponse];
|
1874 | }
|
1875 | });
|
1876 | });
|
1877 | }
|
1878 | function _getFinalTarget(auth, host, path, query) {
|
1879 | var base = "" + host + path + "?" + query;
|
1880 | if (!auth.config.emulator) {
|
1881 | return auth.config.apiScheme + "://" + base;
|
1882 | }
|
1883 | return _emulatorUrl(auth.config, base);
|
1884 | }
|
1885 | var NetworkTimeout = (function () {
|
1886 | function NetworkTimeout(auth) {
|
1887 | var _this = this;
|
1888 | this.auth = auth;
|
1889 |
|
1890 |
|
1891 |
|
1892 | this.timer = null;
|
1893 | this.promise = new Promise(function (_, reject) {
|
1894 | _this.timer = setTimeout(function () {
|
1895 | return reject(_createError(_this.auth, "network-request-failed" ));
|
1896 | }, DEFAULT_API_TIMEOUT_MS.get());
|
1897 | });
|
1898 | }
|
1899 | NetworkTimeout.prototype.clearNetworkTimeout = function () {
|
1900 | clearTimeout(this.timer);
|
1901 | };
|
1902 | return NetworkTimeout;
|
1903 | }());
|
1904 | function _makeTaggedError(auth, code, response) {
|
1905 | var errorParams = {
|
1906 | appName: auth.name
|
1907 | };
|
1908 | if (response.email) {
|
1909 | errorParams.email = response.email;
|
1910 | }
|
1911 | if (response.phoneNumber) {
|
1912 | errorParams.phoneNumber = response.phoneNumber;
|
1913 | }
|
1914 | var error = _createError(auth, code, errorParams);
|
1915 |
|
1916 | error.customData._tokenResponse = response;
|
1917 | return error;
|
1918 | }
|
1919 |
|
1920 |
|
1921 |
|
1922 |
|
1923 |
|
1924 |
|
1925 |
|
1926 |
|
1927 |
|
1928 |
|
1929 |
|
1930 |
|
1931 |
|
1932 |
|
1933 |
|
1934 |
|
1935 |
|
1936 | function deleteAccount(auth, request) {
|
1937 | return __awaiter(this, void 0, void 0, function () {
|
1938 | return __generator(this, function (_a) {
|
1939 | return [2 , _performApiRequest(auth, "POST" , "/v1/accounts:delete" , request)];
|
1940 | });
|
1941 | });
|
1942 | }
|
1943 | function deleteLinkedAccounts(auth, request) {
|
1944 | return __awaiter(this, void 0, void 0, function () {
|
1945 | return __generator(this, function (_a) {
|
1946 | return [2 , _performApiRequest(auth, "POST" , "/v1/accounts:update" , request)];
|
1947 | });
|
1948 | });
|
1949 | }
|
1950 | function getAccountInfo(auth, request) {
|
1951 | return __awaiter(this, void 0, void 0, function () {
|
1952 | return __generator(this, function (_a) {
|
1953 | return [2 , _performApiRequest(auth, "POST" , "/v1/accounts:lookup" , request)];
|
1954 | });
|
1955 | });
|
1956 | }
|
1957 |
|
1958 |
|
1959 |
|
1960 |
|
1961 |
|
1962 |
|
1963 |
|
1964 |
|
1965 |
|
1966 |
|
1967 |
|
1968 |
|
1969 |
|
1970 |
|
1971 |
|
1972 |
|
1973 |
|
1974 | function utcTimestampToDateString(utcTimestamp) {
|
1975 | if (!utcTimestamp) {
|
1976 | return undefined;
|
1977 | }
|
1978 | try {
|
1979 |
|
1980 | var date = new Date(Number(utcTimestamp));
|
1981 |
|
1982 | if (!isNaN(date.getTime())) {
|
1983 |
|
1984 | return date.toUTCString();
|
1985 | }
|
1986 | }
|
1987 | catch (e) {
|
1988 |
|
1989 | }
|
1990 | return undefined;
|
1991 | }
|
1992 |
|
1993 |
|
1994 |
|
1995 |
|
1996 |
|
1997 |
|
1998 |
|
1999 |
|
2000 |
|
2001 |
|
2002 |
|
2003 |
|
2004 |
|
2005 |
|
2006 |
|
2007 |
|
2008 |
|
2009 |
|
2010 |
|
2011 |
|
2012 |
|
2013 |
|
2014 |
|
2015 |
|
2016 |
|
2017 |
|
2018 |
|
2019 |
|
2020 |
|
2021 | function getIdToken(user, forceRefresh) {
|
2022 | if (forceRefresh === void 0) { forceRefresh = false; }
|
2023 | return getModularInstance(user).getIdToken(forceRefresh);
|
2024 | }
|
2025 |
|
2026 |
|
2027 |
|
2028 |
|
2029 |
|
2030 |
|
2031 |
|
2032 |
|
2033 |
|
2034 |
|
2035 |
|
2036 |
|
2037 | function getIdTokenResult(user, forceRefresh) {
|
2038 | if (forceRefresh === void 0) { forceRefresh = false; }
|
2039 | return __awaiter(this, void 0, void 0, function () {
|
2040 | var userInternal, token, claims, firebase, signInProvider;
|
2041 | return __generator(this, function (_a) {
|
2042 | switch (_a.label) {
|
2043 | case 0:
|
2044 | userInternal = getModularInstance(user);
|
2045 | return [4 , userInternal.getIdToken(forceRefresh)];
|
2046 | case 1:
|
2047 | token = _a.sent();
|
2048 | claims = _parseToken(token);
|
2049 | _assert(claims && claims.exp && claims.auth_time && claims.iat, userInternal.auth, "internal-error" );
|
2050 | firebase = typeof claims.firebase === 'object' ? claims.firebase : undefined;
|
2051 | signInProvider = firebase === null || firebase === void 0 ? void 0 : firebase['sign_in_provider'];
|
2052 | return [2 , {
|
2053 | claims: claims,
|
2054 | token: token,
|
2055 | authTime: utcTimestampToDateString(secondsStringToMilliseconds(claims.auth_time)),
|
2056 | issuedAtTime: utcTimestampToDateString(secondsStringToMilliseconds(claims.iat)),
|
2057 | expirationTime: utcTimestampToDateString(secondsStringToMilliseconds(claims.exp)),
|
2058 | signInProvider: signInProvider || null,
|
2059 | signInSecondFactor: (firebase === null || firebase === void 0 ? void 0 : firebase['sign_in_second_factor']) || null
|
2060 | }];
|
2061 | }
|
2062 | });
|
2063 | });
|
2064 | }
|
2065 | function secondsStringToMilliseconds(seconds) {
|
2066 | return Number(seconds) * 1000;
|
2067 | }
|
2068 | function _parseToken(token) {
|
2069 | var _a = token.split('.'), algorithm = _a[0], payload = _a[1], signature = _a[2];
|
2070 | if (algorithm === undefined ||
|
2071 | payload === undefined ||
|
2072 | signature === undefined) {
|
2073 | _logError('JWT malformed, contained fewer than 3 sections');
|
2074 | return null;
|
2075 | }
|
2076 | try {
|
2077 | var decoded = base64Decode(payload);
|
2078 | if (!decoded) {
|
2079 | _logError('Failed to decode base64 JWT payload');
|
2080 | return null;
|
2081 | }
|
2082 | return JSON.parse(decoded);
|
2083 | }
|
2084 | catch (e) {
|
2085 | _logError('Caught error parsing JWT payload as JSON', e);
|
2086 | return null;
|
2087 | }
|
2088 | }
|
2089 |
|
2090 |
|
2091 |
|
2092 | function _tokenExpiresIn(token) {
|
2093 | var parsedToken = _parseToken(token);
|
2094 | _assert(parsedToken, "internal-error" );
|
2095 | _assert(typeof parsedToken.exp !== 'undefined', "internal-error" );
|
2096 | _assert(typeof parsedToken.iat !== 'undefined', "internal-error" );
|
2097 | return Number(parsedToken.exp) - Number(parsedToken.iat);
|
2098 | }
|
2099 |
|
2100 |
|
2101 |
|
2102 |
|
2103 |
|
2104 |
|
2105 |
|
2106 |
|
2107 |
|
2108 |
|
2109 |
|
2110 |
|
2111 |
|
2112 |
|
2113 |
|
2114 |
|
2115 |
|
2116 | function _logoutIfInvalidated(user, promise, bypassAuthState) {
|
2117 | if (bypassAuthState === void 0) { bypassAuthState = false; }
|
2118 | return __awaiter(this, void 0, void 0, function () {
|
2119 | var e_1;
|
2120 | return __generator(this, function (_a) {
|
2121 | switch (_a.label) {
|
2122 | case 0:
|
2123 | if (bypassAuthState) {
|
2124 | return [2 , promise];
|
2125 | }
|
2126 | _a.label = 1;
|
2127 | case 1:
|
2128 | _a.trys.push([1, 3, , 6]);
|
2129 | return [4 , promise];
|
2130 | case 2: return [2 , _a.sent()];
|
2131 | case 3:
|
2132 | e_1 = _a.sent();
|
2133 | if (!(e_1 instanceof FirebaseError && isUserInvalidated(e_1))) return [3 , 5];
|
2134 | if (!(user.auth.currentUser === user)) return [3 , 5];
|
2135 | return [4 , user.auth.signOut()];
|
2136 | case 4:
|
2137 | _a.sent();
|
2138 | _a.label = 5;
|
2139 | case 5: throw e_1;
|
2140 | case 6: return [2 ];
|
2141 | }
|
2142 | });
|
2143 | });
|
2144 | }
|
2145 | function isUserInvalidated(_a) {
|
2146 | var code = _a.code;
|
2147 | return (code === "auth/" + "user-disabled" ||
|
2148 | code === "auth/" + "user-token-expired" );
|
2149 | }
|
2150 |
|
2151 |
|
2152 |
|
2153 |
|
2154 |
|
2155 |
|
2156 |
|
2157 |
|
2158 |
|
2159 |
|
2160 |
|
2161 |
|
2162 |
|
2163 |
|
2164 |
|
2165 |
|
2166 |
|
2167 | var ProactiveRefresh = (function () {
|
2168 | function ProactiveRefresh(user) {
|
2169 | this.user = user;
|
2170 | this.isRunning = false;
|
2171 |
|
2172 |
|
2173 |
|
2174 |
|
2175 | this.timerId = null;
|
2176 | this.errorBackoff = 30000 ;
|
2177 | }
|
2178 | ProactiveRefresh.prototype._start = function () {
|
2179 | if (this.isRunning) {
|
2180 | return;
|
2181 | }
|
2182 | this.isRunning = true;
|
2183 | this.schedule();
|
2184 | };
|
2185 | ProactiveRefresh.prototype._stop = function () {
|
2186 | if (!this.isRunning) {
|
2187 | return;
|
2188 | }
|
2189 | this.isRunning = false;
|
2190 | if (this.timerId !== null) {
|
2191 | clearTimeout(this.timerId);
|
2192 | }
|
2193 | };
|
2194 | ProactiveRefresh.prototype.getInterval = function (wasError) {
|
2195 | var _a;
|
2196 | if (wasError) {
|
2197 | var interval = this.errorBackoff;
|
2198 | this.errorBackoff = Math.min(this.errorBackoff * 2, 960000 );
|
2199 | return interval;
|
2200 | }
|
2201 | else {
|
2202 |
|
2203 | this.errorBackoff = 30000 ;
|
2204 | var expTime = (_a = this.user.stsTokenManager.expirationTime) !== null && _a !== void 0 ? _a : 0;
|
2205 | var interval = expTime - Date.now() - 300000 ;
|
2206 | return Math.max(0, interval);
|
2207 | }
|
2208 | };
|
2209 | ProactiveRefresh.prototype.schedule = function (wasError) {
|
2210 | var _this = this;
|
2211 | if (wasError === void 0) { wasError = false; }
|
2212 | if (!this.isRunning) {
|
2213 |
|
2214 | return;
|
2215 | }
|
2216 | var interval = this.getInterval(wasError);
|
2217 | this.timerId = setTimeout(function () { return __awaiter(_this, void 0, void 0, function () {
|
2218 | return __generator(this, function (_a) {
|
2219 | switch (_a.label) {
|
2220 | case 0: return [4 , this.iteration()];
|
2221 | case 1:
|
2222 | _a.sent();
|
2223 | return [2 ];
|
2224 | }
|
2225 | });
|
2226 | }); }, interval);
|
2227 | };
|
2228 | ProactiveRefresh.prototype.iteration = function () {
|
2229 | return __awaiter(this, void 0, void 0, function () {
|
2230 | var e_1;
|
2231 | return __generator(this, function (_a) {
|
2232 | switch (_a.label) {
|
2233 | case 0:
|
2234 | _a.trys.push([0, 2, , 3]);
|
2235 | return [4 , this.user.getIdToken(true)];
|
2236 | case 1:
|
2237 | _a.sent();
|
2238 | return [3 , 3];
|
2239 | case 2:
|
2240 | e_1 = _a.sent();
|
2241 |
|
2242 | if (e_1.code === "auth/" + "network-request-failed" ) {
|
2243 | this.schedule( true);
|
2244 | }
|
2245 | return [2 ];
|
2246 | case 3:
|
2247 | this.schedule();
|
2248 | return [2 ];
|
2249 | }
|
2250 | });
|
2251 | });
|
2252 | };
|
2253 | return ProactiveRefresh;
|
2254 | }());
|
2255 |
|
2256 |
|
2257 |
|
2258 |
|
2259 |
|
2260 |
|
2261 |
|
2262 |
|
2263 |
|
2264 |
|
2265 |
|
2266 |
|
2267 |
|
2268 |
|
2269 |
|
2270 |
|
2271 |
|
2272 | var UserMetadata = (function () {
|
2273 | function UserMetadata(createdAt, lastLoginAt) {
|
2274 | this.createdAt = createdAt;
|
2275 | this.lastLoginAt = lastLoginAt;
|
2276 | this._initializeTime();
|
2277 | }
|
2278 | UserMetadata.prototype._initializeTime = function () {
|
2279 | this.lastSignInTime = utcTimestampToDateString(this.lastLoginAt);
|
2280 | this.creationTime = utcTimestampToDateString(this.createdAt);
|
2281 | };
|
2282 | UserMetadata.prototype._copy = function (metadata) {
|
2283 | this.createdAt = metadata.createdAt;
|
2284 | this.lastLoginAt = metadata.lastLoginAt;
|
2285 | this._initializeTime();
|
2286 | };
|
2287 | UserMetadata.prototype.toJSON = function () {
|
2288 | return {
|
2289 | createdAt: this.createdAt,
|
2290 | lastLoginAt: this.lastLoginAt
|
2291 | };
|
2292 | };
|
2293 | return UserMetadata;
|
2294 | }());
|
2295 |
|
2296 |
|
2297 |
|
2298 |
|
2299 |
|
2300 |
|
2301 |
|
2302 |
|
2303 |
|
2304 |
|
2305 |
|
2306 |
|
2307 |
|
2308 |
|
2309 |
|
2310 |
|
2311 |
|
2312 | function _reloadWithoutSaving(user) {
|
2313 | var _a;
|
2314 | return __awaiter(this, void 0, void 0, function () {
|
2315 | var auth, idToken, response, coreAccount, newProviderData, providerData, oldIsAnonymous, newIsAnonymous, isAnonymous, updates;
|
2316 | return __generator(this, function (_b) {
|
2317 | switch (_b.label) {
|
2318 | case 0:
|
2319 | auth = user.auth;
|
2320 | return [4 , user.getIdToken()];
|
2321 | case 1:
|
2322 | idToken = _b.sent();
|
2323 | return [4 , _logoutIfInvalidated(user, getAccountInfo(auth, { idToken: idToken }))];
|
2324 | case 2:
|
2325 | response = _b.sent();
|
2326 | _assert(response === null || response === void 0 ? void 0 : response.users.length, auth, "internal-error" );
|
2327 | coreAccount = response.users[0];
|
2328 | user._notifyReloadListener(coreAccount);
|
2329 | newProviderData = ((_a = coreAccount.providerUserInfo) === null || _a === void 0 ? void 0 : _a.length)
|
2330 | ? extractProviderData(coreAccount.providerUserInfo)
|
2331 | : [];
|
2332 | providerData = mergeProviderData(user.providerData, newProviderData);
|
2333 | oldIsAnonymous = user.isAnonymous;
|
2334 | newIsAnonymous = !(user.email && coreAccount.passwordHash) && !(providerData === null || providerData === void 0 ? void 0 : providerData.length);
|
2335 | isAnonymous = !oldIsAnonymous ? false : newIsAnonymous;
|
2336 | updates = {
|
2337 | uid: coreAccount.localId,
|
2338 | displayName: coreAccount.displayName || null,
|
2339 | photoURL: coreAccount.photoUrl || null,
|
2340 | email: coreAccount.email || null,
|
2341 | emailVerified: coreAccount.emailVerified || false,
|
2342 | phoneNumber: coreAccount.phoneNumber || null,
|
2343 | tenantId: coreAccount.tenantId || null,
|
2344 | providerData: providerData,
|
2345 | metadata: new UserMetadata(coreAccount.createdAt, coreAccount.lastLoginAt),
|
2346 | isAnonymous: isAnonymous
|
2347 | };
|
2348 | Object.assign(user, updates);
|
2349 | return [2 ];
|
2350 | }
|
2351 | });
|
2352 | });
|
2353 | }
|
2354 |
|
2355 |
|
2356 |
|
2357 |
|
2358 |
|
2359 |
|
2360 |
|
2361 | function reload(user) {
|
2362 | return __awaiter(this, void 0, void 0, function () {
|
2363 | var userInternal;
|
2364 | return __generator(this, function (_a) {
|
2365 | switch (_a.label) {
|
2366 | case 0:
|
2367 | userInternal = getModularInstance(user);
|
2368 | return [4 , _reloadWithoutSaving(userInternal)];
|
2369 | case 1:
|
2370 | _a.sent();
|
2371 |
|
2372 |
|
2373 |
|
2374 | return [4 , userInternal.auth._persistUserIfCurrent(userInternal)];
|
2375 | case 2:
|
2376 |
|
2377 |
|
2378 |
|
2379 | _a.sent();
|
2380 | userInternal.auth._notifyListenersIfCurrent(userInternal);
|
2381 | return [2 ];
|
2382 | }
|
2383 | });
|
2384 | });
|
2385 | }
|
2386 | function mergeProviderData(original, newData) {
|
2387 | var deduped = original.filter(function (o) { return !newData.some(function (n) { return n.providerId === o.providerId; }); });
|
2388 | return __spreadArray(__spreadArray([], deduped), newData);
|
2389 | }
|
2390 | function extractProviderData(providers) {
|
2391 | return providers.map(function (_a) {
|
2392 | var providerId = _a.providerId, provider = __rest(_a, ["providerId"]);
|
2393 | return {
|
2394 | providerId: providerId,
|
2395 | uid: provider.rawId || '',
|
2396 | displayName: provider.displayName || null,
|
2397 | email: provider.email || null,
|
2398 | phoneNumber: provider.phoneNumber || null,
|
2399 | photoURL: provider.photoUrl || null
|
2400 | };
|
2401 | });
|
2402 | }
|
2403 |
|
2404 |
|
2405 |
|
2406 |
|
2407 |
|
2408 |
|
2409 |
|
2410 |
|
2411 |
|
2412 |
|
2413 |
|
2414 |
|
2415 |
|
2416 |
|
2417 |
|
2418 |
|
2419 |
|
2420 | function requestStsToken(auth, refreshToken) {
|
2421 | return __awaiter(this, void 0, void 0, function () {
|
2422 | var response;
|
2423 | var _this = this;
|
2424 | return __generator(this, function (_a) {
|
2425 | switch (_a.label) {
|
2426 | case 0: return [4 , _performFetchWithErrorHandling(auth, {}, function () { return __awaiter(_this, void 0, void 0, function () {
|
2427 | var body, _a, tokenApiHost, apiKey, url, headers;
|
2428 | return __generator(this, function (_b) {
|
2429 | switch (_b.label) {
|
2430 | case 0:
|
2431 | body = querystring({
|
2432 | 'grant_type': 'refresh_token',
|
2433 | 'refresh_token': refreshToken
|
2434 | }).slice(1);
|
2435 | _a = auth.config, tokenApiHost = _a.tokenApiHost, apiKey = _a.apiKey;
|
2436 | url = _getFinalTarget(auth, tokenApiHost, "/v1/token" , "key=" + apiKey);
|
2437 | return [4 , auth._getAdditionalHeaders()];
|
2438 | case 1:
|
2439 | headers = _b.sent();
|
2440 | headers["Content-Type" ] = 'application/x-www-form-urlencoded';
|
2441 | return [2 , FetchProvider.fetch()(url, {
|
2442 | method: "POST" ,
|
2443 | headers: headers,
|
2444 | body: body
|
2445 | })];
|
2446 | }
|
2447 | });
|
2448 | }); })];
|
2449 | case 1:
|
2450 | response = _a.sent();
|
2451 |
|
2452 | return [2 , {
|
2453 | accessToken: response.access_token,
|
2454 | expiresIn: response.expires_in,
|
2455 | refreshToken: response.refresh_token
|
2456 | }];
|
2457 | }
|
2458 | });
|
2459 | });
|
2460 | }
|
2461 |
|
2462 |
|
2463 |
|
2464 |
|
2465 |
|
2466 |
|
2467 |
|
2468 |
|
2469 |
|
2470 |
|
2471 |
|
2472 |
|
2473 |
|
2474 |
|
2475 |
|
2476 |
|
2477 |
|
2478 |
|
2479 |
|
2480 |
|
2481 |
|
2482 |
|
2483 |
|
2484 | var StsTokenManager = (function () {
|
2485 | function StsTokenManager() {
|
2486 | this.refreshToken = null;
|
2487 | this.accessToken = null;
|
2488 | this.expirationTime = null;
|
2489 | }
|
2490 | Object.defineProperty(StsTokenManager.prototype, "isExpired", {
|
2491 | get: function () {
|
2492 | return (!this.expirationTime ||
|
2493 | Date.now() > this.expirationTime - 30000 );
|
2494 | },
|
2495 | enumerable: false,
|
2496 | configurable: true
|
2497 | });
|
2498 | StsTokenManager.prototype.updateFromServerResponse = function (response) {
|
2499 | _assert(response.idToken, "internal-error" );
|
2500 | _assert(typeof response.idToken !== 'undefined', "internal-error" );
|
2501 | _assert(typeof response.refreshToken !== 'undefined', "internal-error" );
|
2502 | var expiresIn = 'expiresIn' in response && typeof response.expiresIn !== 'undefined'
|
2503 | ? Number(response.expiresIn)
|
2504 | : _tokenExpiresIn(response.idToken);
|
2505 | this.updateTokensAndExpiration(response.idToken, response.refreshToken, expiresIn);
|
2506 | };
|
2507 | StsTokenManager.prototype.getToken = function (auth, forceRefresh) {
|
2508 | if (forceRefresh === void 0) { forceRefresh = false; }
|
2509 | return __awaiter(this, void 0, void 0, function () {
|
2510 | return __generator(this, function (_a) {
|
2511 | switch (_a.label) {
|
2512 | case 0:
|
2513 | _assert(!this.accessToken || this.refreshToken, auth, "user-token-expired" );
|
2514 | if (!forceRefresh && this.accessToken && !this.isExpired) {
|
2515 | return [2 , this.accessToken];
|
2516 | }
|
2517 | if (!this.refreshToken) return [3 , 2];
|
2518 | return [4 , this.refresh(auth, this.refreshToken)];
|
2519 | case 1:
|
2520 | _a.sent();
|
2521 | return [2 , this.accessToken];
|
2522 | case 2: return [2 , null];
|
2523 | }
|
2524 | });
|
2525 | });
|
2526 | };
|
2527 | StsTokenManager.prototype.clearRefreshToken = function () {
|
2528 | this.refreshToken = null;
|
2529 | };
|
2530 | StsTokenManager.prototype.refresh = function (auth, oldToken) {
|
2531 | return __awaiter(this, void 0, void 0, function () {
|
2532 | var _a, accessToken, refreshToken, expiresIn;
|
2533 | return __generator(this, function (_b) {
|
2534 | switch (_b.label) {
|
2535 | case 0: return [4 , requestStsToken(auth, oldToken)];
|
2536 | case 1:
|
2537 | _a = _b.sent(), accessToken = _a.accessToken, refreshToken = _a.refreshToken, expiresIn = _a.expiresIn;
|
2538 | this.updateTokensAndExpiration(accessToken, refreshToken, Number(expiresIn));
|
2539 | return [2 ];
|
2540 | }
|
2541 | });
|
2542 | });
|
2543 | };
|
2544 | StsTokenManager.prototype.updateTokensAndExpiration = function (accessToken, refreshToken, expiresInSec) {
|
2545 | this.refreshToken = refreshToken || null;
|
2546 | this.accessToken = accessToken || null;
|
2547 | this.expirationTime = Date.now() + expiresInSec * 1000;
|
2548 | };
|
2549 | StsTokenManager.fromJSON = function (appName, object) {
|
2550 | var refreshToken = object.refreshToken, accessToken = object.accessToken, expirationTime = object.expirationTime;
|
2551 | var manager = new StsTokenManager();
|
2552 | if (refreshToken) {
|
2553 | _assert(typeof refreshToken === 'string', "internal-error" , {
|
2554 | appName: appName
|
2555 | });
|
2556 | manager.refreshToken = refreshToken;
|
2557 | }
|
2558 | if (accessToken) {
|
2559 | _assert(typeof accessToken === 'string', "internal-error" , {
|
2560 | appName: appName
|
2561 | });
|
2562 | manager.accessToken = accessToken;
|
2563 | }
|
2564 | if (expirationTime) {
|
2565 | _assert(typeof expirationTime === 'number', "internal-error" , {
|
2566 | appName: appName
|
2567 | });
|
2568 | manager.expirationTime = expirationTime;
|
2569 | }
|
2570 | return manager;
|
2571 | };
|
2572 | StsTokenManager.prototype.toJSON = function () {
|
2573 | return {
|
2574 | refreshToken: this.refreshToken,
|
2575 | accessToken: this.accessToken,
|
2576 | expirationTime: this.expirationTime
|
2577 | };
|
2578 | };
|
2579 | StsTokenManager.prototype._assign = function (stsTokenManager) {
|
2580 | this.accessToken = stsTokenManager.accessToken;
|
2581 | this.refreshToken = stsTokenManager.refreshToken;
|
2582 | this.expirationTime = stsTokenManager.expirationTime;
|
2583 | };
|
2584 | StsTokenManager.prototype._clone = function () {
|
2585 | return Object.assign(new StsTokenManager(), this.toJSON());
|
2586 | };
|
2587 | StsTokenManager.prototype._performRefresh = function () {
|
2588 | return debugFail('not implemented');
|
2589 | };
|
2590 | return StsTokenManager;
|
2591 | }());
|
2592 |
|
2593 |
|
2594 |
|
2595 |
|
2596 |
|
2597 |
|
2598 |
|
2599 |
|
2600 |
|
2601 |
|
2602 |
|
2603 |
|
2604 |
|
2605 |
|
2606 |
|
2607 |
|
2608 |
|
2609 | function assertStringOrUndefined(assertion, appName) {
|
2610 | _assert(typeof assertion === 'string' || typeof assertion === 'undefined', "internal-error" , { appName: appName });
|
2611 | }
|
2612 | var UserImpl = (function () {
|
2613 | function UserImpl(_a) {
|
2614 | var uid = _a.uid, auth = _a.auth, stsTokenManager = _a.stsTokenManager, opt = __rest(_a, ["uid", "auth", "stsTokenManager"]);
|
2615 |
|
2616 | this.providerId = "firebase" ;
|
2617 | this.proactiveRefresh = new ProactiveRefresh(this);
|
2618 | this.reloadUserInfo = null;
|
2619 | this.reloadListener = null;
|
2620 | this.uid = uid;
|
2621 | this.auth = auth;
|
2622 | this.stsTokenManager = stsTokenManager;
|
2623 | this.accessToken = stsTokenManager.accessToken;
|
2624 | this.displayName = opt.displayName || null;
|
2625 | this.email = opt.email || null;
|
2626 | this.emailVerified = opt.emailVerified || false;
|
2627 | this.phoneNumber = opt.phoneNumber || null;
|
2628 | this.photoURL = opt.photoURL || null;
|
2629 | this.isAnonymous = opt.isAnonymous || false;
|
2630 | this.tenantId = opt.tenantId || null;
|
2631 | this.providerData = opt.providerData ? __spreadArray([], opt.providerData) : [];
|
2632 | this.metadata = new UserMetadata(opt.createdAt || undefined, opt.lastLoginAt || undefined);
|
2633 | }
|
2634 | UserImpl.prototype.getIdToken = function (forceRefresh) {
|
2635 | return __awaiter(this, void 0, void 0, function () {
|
2636 | var accessToken;
|
2637 | return __generator(this, function (_a) {
|
2638 | switch (_a.label) {
|
2639 | case 0: return [4 , _logoutIfInvalidated(this, this.stsTokenManager.getToken(this.auth, forceRefresh))];
|
2640 | case 1:
|
2641 | accessToken = _a.sent();
|
2642 | _assert(accessToken, this.auth, "internal-error" );
|
2643 | if (!(this.accessToken !== accessToken)) return [3 , 3];
|
2644 | this.accessToken = accessToken;
|
2645 | return [4 , this.auth._persistUserIfCurrent(this)];
|
2646 | case 2:
|
2647 | _a.sent();
|
2648 | this.auth._notifyListenersIfCurrent(this);
|
2649 | _a.label = 3;
|
2650 | case 3: return [2 , accessToken];
|
2651 | }
|
2652 | });
|
2653 | });
|
2654 | };
|
2655 | UserImpl.prototype.getIdTokenResult = function (forceRefresh) {
|
2656 | return getIdTokenResult(this, forceRefresh);
|
2657 | };
|
2658 | UserImpl.prototype.reload = function () {
|
2659 | return reload(this);
|
2660 | };
|
2661 | UserImpl.prototype._assign = function (user) {
|
2662 | if (this === user) {
|
2663 | return;
|
2664 | }
|
2665 | _assert(this.uid === user.uid, this.auth, "internal-error" );
|
2666 | this.displayName = user.displayName;
|
2667 | this.photoURL = user.photoURL;
|
2668 | this.email = user.email;
|
2669 | this.emailVerified = user.emailVerified;
|
2670 | this.phoneNumber = user.phoneNumber;
|
2671 | this.isAnonymous = user.isAnonymous;
|
2672 | this.tenantId = user.tenantId;
|
2673 | this.providerData = user.providerData.map(function (userInfo) { return (__assign({}, userInfo)); });
|
2674 | this.metadata._copy(user.metadata);
|
2675 | this.stsTokenManager._assign(user.stsTokenManager);
|
2676 | };
|
2677 | UserImpl.prototype._clone = function (auth) {
|
2678 | return new UserImpl(__assign(__assign({}, this), { auth: auth, stsTokenManager: this.stsTokenManager._clone() }));
|
2679 | };
|
2680 | UserImpl.prototype._onReload = function (callback) {
|
2681 |
|
2682 | _assert(!this.reloadListener, this.auth, "internal-error" );
|
2683 | this.reloadListener = callback;
|
2684 | if (this.reloadUserInfo) {
|
2685 | this._notifyReloadListener(this.reloadUserInfo);
|
2686 | this.reloadUserInfo = null;
|
2687 | }
|
2688 | };
|
2689 | UserImpl.prototype._notifyReloadListener = function (userInfo) {
|
2690 | if (this.reloadListener) {
|
2691 | this.reloadListener(userInfo);
|
2692 | }
|
2693 | else {
|
2694 |
|
2695 | this.reloadUserInfo = userInfo;
|
2696 | }
|
2697 | };
|
2698 | UserImpl.prototype._startProactiveRefresh = function () {
|
2699 | this.proactiveRefresh._start();
|
2700 | };
|
2701 | UserImpl.prototype._stopProactiveRefresh = function () {
|
2702 | this.proactiveRefresh._stop();
|
2703 | };
|
2704 | UserImpl.prototype._updateTokensIfNecessary = function (response, reload) {
|
2705 | if (reload === void 0) { reload = false; }
|
2706 | return __awaiter(this, void 0, void 0, function () {
|
2707 | var tokensRefreshed;
|
2708 | return __generator(this, function (_a) {
|
2709 | switch (_a.label) {
|
2710 | case 0:
|
2711 | tokensRefreshed = false;
|
2712 | if (response.idToken &&
|
2713 | response.idToken !== this.stsTokenManager.accessToken) {
|
2714 | this.stsTokenManager.updateFromServerResponse(response);
|
2715 | tokensRefreshed = true;
|
2716 | }
|
2717 | if (!reload) return [3 , 2];
|
2718 | return [4 , _reloadWithoutSaving(this)];
|
2719 | case 1:
|
2720 | _a.sent();
|
2721 | _a.label = 2;
|
2722 | case 2: return [4 , this.auth._persistUserIfCurrent(this)];
|
2723 | case 3:
|
2724 | _a.sent();
|
2725 | if (tokensRefreshed) {
|
2726 | this.auth._notifyListenersIfCurrent(this);
|
2727 | }
|
2728 | return [2 ];
|
2729 | }
|
2730 | });
|
2731 | });
|
2732 | };
|
2733 | UserImpl.prototype.delete = function () {
|
2734 | return __awaiter(this, void 0, void 0, function () {
|
2735 | var idToken;
|
2736 | return __generator(this, function (_a) {
|
2737 | switch (_a.label) {
|
2738 | case 0: return [4 , this.getIdToken()];
|
2739 | case 1:
|
2740 | idToken = _a.sent();
|
2741 | return [4 , _logoutIfInvalidated(this, deleteAccount(this.auth, { idToken: idToken }))];
|
2742 | case 2:
|
2743 | _a.sent();
|
2744 | this.stsTokenManager.clearRefreshToken();
|
2745 |
|
2746 |
|
2747 | return [2 , this.auth.signOut()];
|
2748 | }
|
2749 | });
|
2750 | });
|
2751 | };
|
2752 | UserImpl.prototype.toJSON = function () {
|
2753 | return __assign(__assign({ uid: this.uid, email: this.email || undefined, emailVerified: this.emailVerified, displayName: this.displayName || undefined, isAnonymous: this.isAnonymous, photoURL: this.photoURL || undefined, phoneNumber: this.phoneNumber || undefined, tenantId: this.tenantId || undefined, providerData: this.providerData.map(function (userInfo) { return (__assign({}, userInfo)); }), stsTokenManager: this.stsTokenManager.toJSON(),
|
2754 |
|
2755 |
|
2756 | _redirectEventId: this._redirectEventId }, this.metadata.toJSON()), {
|
2757 |
|
2758 | apiKey: this.auth.config.apiKey, appName: this.auth.name });
|
2759 | };
|
2760 | Object.defineProperty(UserImpl.prototype, "refreshToken", {
|
2761 | get: function () {
|
2762 | return this.stsTokenManager.refreshToken || '';
|
2763 | },
|
2764 | enumerable: false,
|
2765 | configurable: true
|
2766 | });
|
2767 | UserImpl._fromJSON = function (auth, object) {
|
2768 | var _a, _b, _c, _d, _e, _f, _g, _h;
|
2769 | var displayName = (_a = object.displayName) !== null && _a !== void 0 ? _a : undefined;
|
2770 | var email = (_b = object.email) !== null && _b !== void 0 ? _b : undefined;
|
2771 | var phoneNumber = (_c = object.phoneNumber) !== null && _c !== void 0 ? _c : undefined;
|
2772 | var photoURL = (_d = object.photoURL) !== null && _d !== void 0 ? _d : undefined;
|
2773 | var tenantId = (_e = object.tenantId) !== null && _e !== void 0 ? _e : undefined;
|
2774 | var _redirectEventId = (_f = object._redirectEventId) !== null && _f !== void 0 ? _f : undefined;
|
2775 | var createdAt = (_g = object.createdAt) !== null && _g !== void 0 ? _g : undefined;
|
2776 | var lastLoginAt = (_h = object.lastLoginAt) !== null && _h !== void 0 ? _h : undefined;
|
2777 | var uid = object.uid, emailVerified = object.emailVerified, isAnonymous = object.isAnonymous, providerData = object.providerData, plainObjectTokenManager = object.stsTokenManager;
|
2778 | _assert(uid && plainObjectTokenManager, auth, "internal-error" );
|
2779 | var stsTokenManager = StsTokenManager.fromJSON(this.name, plainObjectTokenManager);
|
2780 | _assert(typeof uid === 'string', auth, "internal-error" );
|
2781 | assertStringOrUndefined(displayName, auth.name);
|
2782 | assertStringOrUndefined(email, auth.name);
|
2783 | _assert(typeof emailVerified === 'boolean', auth, "internal-error" );
|
2784 | _assert(typeof isAnonymous === 'boolean', auth, "internal-error" );
|
2785 | assertStringOrUndefined(phoneNumber, auth.name);
|
2786 | assertStringOrUndefined(photoURL, auth.name);
|
2787 | assertStringOrUndefined(tenantId, auth.name);
|
2788 | assertStringOrUndefined(_redirectEventId, auth.name);
|
2789 | assertStringOrUndefined(createdAt, auth.name);
|
2790 | assertStringOrUndefined(lastLoginAt, auth.name);
|
2791 | var user = new UserImpl({
|
2792 | uid: uid,
|
2793 | auth: auth,
|
2794 | email: email,
|
2795 | emailVerified: emailVerified,
|
2796 | displayName: displayName,
|
2797 | isAnonymous: isAnonymous,
|
2798 | photoURL: photoURL,
|
2799 | phoneNumber: phoneNumber,
|
2800 | tenantId: tenantId,
|
2801 | stsTokenManager: stsTokenManager,
|
2802 | createdAt: createdAt,
|
2803 | lastLoginAt: lastLoginAt
|
2804 | });
|
2805 | if (providerData && Array.isArray(providerData)) {
|
2806 | user.providerData = providerData.map(function (userInfo) { return (__assign({}, userInfo)); });
|
2807 | }
|
2808 | if (_redirectEventId) {
|
2809 | user._redirectEventId = _redirectEventId;
|
2810 | }
|
2811 | return user;
|
2812 | };
|
2813 | |
2814 |
|
2815 |
|
2816 |
|
2817 |
|
2818 | UserImpl._fromIdTokenResponse = function (auth, idTokenResponse, isAnonymous) {
|
2819 | if (isAnonymous === void 0) { isAnonymous = false; }
|
2820 | return __awaiter(this, void 0, void 0, function () {
|
2821 | var stsTokenManager, user;
|
2822 | return __generator(this, function (_a) {
|
2823 | switch (_a.label) {
|
2824 | case 0:
|
2825 | stsTokenManager = new StsTokenManager();
|
2826 | stsTokenManager.updateFromServerResponse(idTokenResponse);
|
2827 | user = new UserImpl({
|
2828 | uid: idTokenResponse.localId,
|
2829 | auth: auth,
|
2830 | stsTokenManager: stsTokenManager,
|
2831 | isAnonymous: isAnonymous
|
2832 | });
|
2833 |
|
2834 | return [4 , _reloadWithoutSaving(user)];
|
2835 | case 1:
|
2836 |
|
2837 | _a.sent();
|
2838 | return [2 , user];
|
2839 | }
|
2840 | });
|
2841 | });
|
2842 | };
|
2843 | return UserImpl;
|
2844 | }());
|
2845 |
|
2846 |
|
2847 |
|
2848 |
|
2849 |
|
2850 |
|
2851 |
|
2852 |
|
2853 |
|
2854 |
|
2855 |
|
2856 |
|
2857 |
|
2858 |
|
2859 |
|
2860 |
|
2861 |
|
2862 | var InMemoryPersistence = (function () {
|
2863 | function InMemoryPersistence() {
|
2864 | this.type = "NONE" ;
|
2865 | this.storage = {};
|
2866 | }
|
2867 | InMemoryPersistence.prototype._isAvailable = function () {
|
2868 | return __awaiter(this, void 0, void 0, function () {
|
2869 | return __generator(this, function (_a) {
|
2870 | return [2 , true];
|
2871 | });
|
2872 | });
|
2873 | };
|
2874 | InMemoryPersistence.prototype._set = function (key, value) {
|
2875 | return __awaiter(this, void 0, void 0, function () {
|
2876 | return __generator(this, function (_a) {
|
2877 | this.storage[key] = value;
|
2878 | return [2 ];
|
2879 | });
|
2880 | });
|
2881 | };
|
2882 | InMemoryPersistence.prototype._get = function (key) {
|
2883 | return __awaiter(this, void 0, void 0, function () {
|
2884 | var value;
|
2885 | return __generator(this, function (_a) {
|
2886 | value = this.storage[key];
|
2887 | return [2 , value === undefined ? null : value];
|
2888 | });
|
2889 | });
|
2890 | };
|
2891 | InMemoryPersistence.prototype._remove = function (key) {
|
2892 | return __awaiter(this, void 0, void 0, function () {
|
2893 | return __generator(this, function (_a) {
|
2894 | delete this.storage[key];
|
2895 | return [2 ];
|
2896 | });
|
2897 | });
|
2898 | };
|
2899 | InMemoryPersistence.prototype._addListener = function (_key, _listener) {
|
2900 |
|
2901 | return;
|
2902 | };
|
2903 | InMemoryPersistence.prototype._removeListener = function (_key, _listener) {
|
2904 |
|
2905 | return;
|
2906 | };
|
2907 | InMemoryPersistence.type = 'NONE';
|
2908 | return InMemoryPersistence;
|
2909 | }());
|
2910 |
|
2911 |
|
2912 |
|
2913 |
|
2914 |
|
2915 | var inMemoryPersistence = InMemoryPersistence;
|
2916 |
|
2917 |
|
2918 |
|
2919 |
|
2920 |
|
2921 |
|
2922 |
|
2923 |
|
2924 |
|
2925 |
|
2926 |
|
2927 |
|
2928 |
|
2929 |
|
2930 |
|
2931 |
|
2932 |
|
2933 | function _persistenceKeyName(key, apiKey, appName) {
|
2934 | return "firebase" + ":" + key + ":" + apiKey + ":" + appName;
|
2935 | }
|
2936 | var PersistenceUserManager = (function () {
|
2937 | function PersistenceUserManager(persistence, auth, userKey) {
|
2938 | this.persistence = persistence;
|
2939 | this.auth = auth;
|
2940 | this.userKey = userKey;
|
2941 | var _a = this.auth, config = _a.config, name = _a.name;
|
2942 | this.fullUserKey = _persistenceKeyName(this.userKey, config.apiKey, name);
|
2943 | this.fullPersistenceKey = _persistenceKeyName("persistence" , config.apiKey, name);
|
2944 | this.boundEventHandler = auth._onStorageEvent.bind(auth);
|
2945 | this.persistence._addListener(this.fullUserKey, this.boundEventHandler);
|
2946 | }
|
2947 | PersistenceUserManager.prototype.setCurrentUser = function (user) {
|
2948 | return this.persistence._set(this.fullUserKey, user.toJSON());
|
2949 | };
|
2950 | PersistenceUserManager.prototype.getCurrentUser = function () {
|
2951 | return __awaiter(this, void 0, void 0, function () {
|
2952 | var blob;
|
2953 | return __generator(this, function (_a) {
|
2954 | switch (_a.label) {
|
2955 | case 0: return [4 , this.persistence._get(this.fullUserKey)];
|
2956 | case 1:
|
2957 | blob = _a.sent();
|
2958 | return [2 , blob ? UserImpl._fromJSON(this.auth, blob) : null];
|
2959 | }
|
2960 | });
|
2961 | });
|
2962 | };
|
2963 | PersistenceUserManager.prototype.removeCurrentUser = function () {
|
2964 | return this.persistence._remove(this.fullUserKey);
|
2965 | };
|
2966 | PersistenceUserManager.prototype.savePersistenceForRedirect = function () {
|
2967 | return this.persistence._set(this.fullPersistenceKey, this.persistence.type);
|
2968 | };
|
2969 | PersistenceUserManager.prototype.setPersistence = function (newPersistence) {
|
2970 | return __awaiter(this, void 0, void 0, function () {
|
2971 | var currentUser;
|
2972 | return __generator(this, function (_a) {
|
2973 | switch (_a.label) {
|
2974 | case 0:
|
2975 | if (this.persistence === newPersistence) {
|
2976 | return [2 ];
|
2977 | }
|
2978 | return [4 , this.getCurrentUser()];
|
2979 | case 1:
|
2980 | currentUser = _a.sent();
|
2981 | return [4 , this.removeCurrentUser()];
|
2982 | case 2:
|
2983 | _a.sent();
|
2984 | this.persistence = newPersistence;
|
2985 | if (currentUser) {
|
2986 | return [2 , this.setCurrentUser(currentUser)];
|
2987 | }
|
2988 | return [2 ];
|
2989 | }
|
2990 | });
|
2991 | });
|
2992 | };
|
2993 | PersistenceUserManager.prototype.delete = function () {
|
2994 | this.persistence._removeListener(this.fullUserKey, this.boundEventHandler);
|
2995 | };
|
2996 | PersistenceUserManager.create = function (auth, persistenceHierarchy, userKey) {
|
2997 | if (userKey === void 0) { userKey = "authUser" ; }
|
2998 | return __awaiter(this, void 0, void 0, function () {
|
2999 | var availablePersistences, selectedPersistence, key, userToMigrate, _i, persistenceHierarchy_1, persistence, blob, user, migrationHierarchy;
|
3000 | var _this = this;
|
3001 | return __generator(this, function (_b) {
|
3002 | switch (_b.label) {
|
3003 | case 0:
|
3004 | if (!persistenceHierarchy.length) {
|
3005 | return [2 , new PersistenceUserManager(_getInstance(inMemoryPersistence), auth, userKey)];
|
3006 | }
|
3007 | return [4 , Promise.all(persistenceHierarchy.map(function (persistence) { return __awaiter(_this, void 0, void 0, function () {
|
3008 | return __generator(this, function (_a) {
|
3009 | switch (_a.label) {
|
3010 | case 0: return [4 , persistence._isAvailable()];
|
3011 | case 1:
|
3012 | if (_a.sent()) {
|
3013 | return [2 , persistence];
|
3014 | }
|
3015 | return [2 , undefined];
|
3016 | }
|
3017 | });
|
3018 | }); }))];
|
3019 | case 1:
|
3020 | availablePersistences = (_b.sent()).filter(function (persistence) { return persistence; });
|
3021 | selectedPersistence = availablePersistences[0] ||
|
3022 | _getInstance(inMemoryPersistence);
|
3023 | key = _persistenceKeyName(userKey, auth.config.apiKey, auth.name);
|
3024 | userToMigrate = null;
|
3025 | _i = 0, persistenceHierarchy_1 = persistenceHierarchy;
|
3026 | _b.label = 2;
|
3027 | case 2:
|
3028 | if (!(_i < persistenceHierarchy_1.length)) return [3 , 7];
|
3029 | persistence = persistenceHierarchy_1[_i];
|
3030 | _b.label = 3;
|
3031 | case 3:
|
3032 | _b.trys.push([3, 5, , 6]);
|
3033 | return [4 , persistence._get(key)];
|
3034 | case 4:
|
3035 | blob = _b.sent();
|
3036 | if (blob) {
|
3037 | user = UserImpl._fromJSON(auth, blob);
|
3038 | if (persistence !== selectedPersistence) {
|
3039 | userToMigrate = user;
|
3040 | }
|
3041 | selectedPersistence = persistence;
|
3042 | return [3 , 7];
|
3043 | }
|
3044 | return [3 , 6];
|
3045 | case 5:
|
3046 | _b.sent();
|
3047 | return [3 , 6];
|
3048 | case 6:
|
3049 | _i++;
|
3050 | return [3 , 2];
|
3051 | case 7:
|
3052 | migrationHierarchy = availablePersistences.filter(function (p) { return p._shouldAllowMigration; });
|
3053 |
|
3054 | if (!selectedPersistence._shouldAllowMigration ||
|
3055 | !migrationHierarchy.length) {
|
3056 | return [2 , new PersistenceUserManager(selectedPersistence, auth, userKey)];
|
3057 | }
|
3058 | selectedPersistence = migrationHierarchy[0];
|
3059 | if (!userToMigrate) return [3 , 9];
|
3060 |
|
3061 |
|
3062 | return [4 , selectedPersistence._set(key, userToMigrate.toJSON())];
|
3063 | case 8:
|
3064 |
|
3065 |
|
3066 | _b.sent();
|
3067 | _b.label = 9;
|
3068 | case 9:
|
3069 |
|
3070 |
|
3071 | return [4 , Promise.all(persistenceHierarchy.map(function (persistence) { return __awaiter(_this, void 0, void 0, function () {
|
3072 | return __generator(this, function (_b) {
|
3073 | switch (_b.label) {
|
3074 | case 0:
|
3075 | if (!(persistence !== selectedPersistence)) return [3 , 4];
|
3076 | _b.label = 1;
|
3077 | case 1:
|
3078 | _b.trys.push([1, 3, , 4]);
|
3079 | return [4 , persistence._remove(key)];
|
3080 | case 2:
|
3081 | _b.sent();
|
3082 | return [3 , 4];
|
3083 | case 3:
|
3084 | _b.sent();
|
3085 | return [3 , 4];
|
3086 | case 4: return [2 ];
|
3087 | }
|
3088 | });
|
3089 | }); }))];
|
3090 | case 10:
|
3091 |
|
3092 |
|
3093 | _b.sent();
|
3094 | return [2 , new PersistenceUserManager(selectedPersistence, auth, userKey)];
|
3095 | }
|
3096 | });
|
3097 | });
|
3098 | };
|
3099 | return PersistenceUserManager;
|
3100 | }());
|
3101 |
|
3102 |
|
3103 |
|
3104 |
|
3105 |
|
3106 |
|
3107 |
|
3108 |
|
3109 |
|
3110 |
|
3111 |
|
3112 |
|
3113 |
|
3114 |
|
3115 |
|
3116 |
|
3117 |
|
3118 |
|
3119 |
|
3120 |
|
3121 | function _getBrowserName(userAgent) {
|
3122 | var ua = userAgent.toLowerCase();
|
3123 | if (ua.includes('opera/') || ua.includes('opr/') || ua.includes('opios/')) {
|
3124 | return "Opera" ;
|
3125 | }
|
3126 | else if (_isIEMobile(ua)) {
|
3127 |
|
3128 | return "IEMobile" ;
|
3129 | }
|
3130 | else if (ua.includes('msie') || ua.includes('trident/')) {
|
3131 | return "IE" ;
|
3132 | }
|
3133 | else if (ua.includes('edge/')) {
|
3134 | return "Edge" ;
|
3135 | }
|
3136 | else if (_isFirefox(ua)) {
|
3137 | return "Firefox" ;
|
3138 | }
|
3139 | else if (ua.includes('silk/')) {
|
3140 | return "Silk" ;
|
3141 | }
|
3142 | else if (_isBlackBerry(ua)) {
|
3143 |
|
3144 | return "Blackberry" ;
|
3145 | }
|
3146 | else if (_isWebOS(ua)) {
|
3147 |
|
3148 | return "Webos" ;
|
3149 | }
|
3150 | else if (_isSafari(ua)) {
|
3151 | return "Safari" ;
|
3152 | }
|
3153 | else if ((ua.includes('chrome/') || _isChromeIOS(ua)) &&
|
3154 | !ua.includes('edge/')) {
|
3155 | return "Chrome" ;
|
3156 | }
|
3157 | else if (_isAndroid(ua)) {
|
3158 |
|
3159 | return "Android" ;
|
3160 | }
|
3161 | else {
|
3162 |
|
3163 | var re = /([a-zA-Z\d\.]+)\/[a-zA-Z\d\.]*$/;
|
3164 | var matches = userAgent.match(re);
|
3165 | if ((matches === null || matches === void 0 ? void 0 : matches.length) === 2) {
|
3166 | return matches[1];
|
3167 | }
|
3168 | }
|
3169 | return "Other" ;
|
3170 | }
|
3171 | function _isFirefox(ua) {
|
3172 | if (ua === void 0) { ua = getUA(); }
|
3173 | return /firefox\//i.test(ua);
|
3174 | }
|
3175 | function _isSafari(userAgent) {
|
3176 | if (userAgent === void 0) { userAgent = getUA(); }
|
3177 | var ua = userAgent.toLowerCase();
|
3178 | return (ua.includes('safari/') &&
|
3179 | !ua.includes('chrome/') &&
|
3180 | !ua.includes('crios/') &&
|
3181 | !ua.includes('android'));
|
3182 | }
|
3183 | function _isChromeIOS(ua) {
|
3184 | if (ua === void 0) { ua = getUA(); }
|
3185 | return /crios\//i.test(ua);
|
3186 | }
|
3187 | function _isIEMobile(ua) {
|
3188 | if (ua === void 0) { ua = getUA(); }
|
3189 | return /iemobile/i.test(ua);
|
3190 | }
|
3191 | function _isAndroid(ua) {
|
3192 | if (ua === void 0) { ua = getUA(); }
|
3193 | return /android/i.test(ua);
|
3194 | }
|
3195 | function _isBlackBerry(ua) {
|
3196 | if (ua === void 0) { ua = getUA(); }
|
3197 | return /blackberry/i.test(ua);
|
3198 | }
|
3199 | function _isWebOS(ua) {
|
3200 | if (ua === void 0) { ua = getUA(); }
|
3201 | return /webos/i.test(ua);
|
3202 | }
|
3203 | function _isIOS(ua) {
|
3204 | if (ua === void 0) { ua = getUA(); }
|
3205 | return /iphone|ipad|ipod/i.test(ua);
|
3206 | }
|
3207 | function _isIOS7Or8(ua) {
|
3208 | if (ua === void 0) { ua = getUA(); }
|
3209 | return (/(iPad|iPhone|iPod).*OS 7_\d/i.test(ua) ||
|
3210 | /(iPad|iPhone|iPod).*OS 8_\d/i.test(ua));
|
3211 | }
|
3212 | function _isIOSStandalone(ua) {
|
3213 | var _a;
|
3214 | if (ua === void 0) { ua = getUA(); }
|
3215 | return _isIOS(ua) && !!((_a = window.navigator) === null || _a === void 0 ? void 0 : _a.standalone);
|
3216 | }
|
3217 | function _isIE10() {
|
3218 | return isIE() && document.documentMode === 10;
|
3219 | }
|
3220 | function _isMobileBrowser(ua) {
|
3221 | if (ua === void 0) { ua = getUA(); }
|
3222 |
|
3223 | return (_isIOS(ua) ||
|
3224 | _isAndroid(ua) ||
|
3225 | _isWebOS(ua) ||
|
3226 | _isBlackBerry(ua) ||
|
3227 | /windows phone/i.test(ua) ||
|
3228 | _isIEMobile(ua));
|
3229 | }
|
3230 | function _isIframe() {
|
3231 | try {
|
3232 |
|
3233 |
|
3234 | return !!(window && window !== window.top);
|
3235 | }
|
3236 | catch (e) {
|
3237 | return false;
|
3238 | }
|
3239 | }
|
3240 |
|
3241 |
|
3242 |
|
3243 |
|
3244 |
|
3245 |
|
3246 |
|
3247 |
|
3248 |
|
3249 |
|
3250 |
|
3251 |
|
3252 |
|
3253 |
|
3254 |
|
3255 |
|
3256 |
|
3257 |
|
3258 |
|
3259 |
|
3260 | function _getClientVersion(clientPlatform, frameworks) {
|
3261 | if (frameworks === void 0) { frameworks = []; }
|
3262 | var reportedPlatform;
|
3263 | switch (clientPlatform) {
|
3264 | case "Browser" :
|
3265 |
|
3266 | reportedPlatform = _getBrowserName(getUA());
|
3267 | break;
|
3268 | case "Worker" :
|
3269 |
|
3270 |
|
3271 |
|
3272 | reportedPlatform = _getBrowserName(getUA()) + "-" + clientPlatform;
|
3273 | break;
|
3274 | default:
|
3275 | reportedPlatform = clientPlatform;
|
3276 | }
|
3277 | var reportedFrameworks = frameworks.length
|
3278 | ? frameworks.join(',')
|
3279 | : 'FirebaseCore-web';
|
3280 | return reportedPlatform + "/" + "JsCore" + "/" + SDK_VERSION + "/" + reportedFrameworks;
|
3281 | }
|
3282 |
|
3283 |
|
3284 |
|
3285 |
|
3286 |
|
3287 |
|
3288 |
|
3289 |
|
3290 |
|
3291 |
|
3292 |
|
3293 |
|
3294 |
|
3295 |
|
3296 |
|
3297 |
|
3298 |
|
3299 | var AuthMiddlewareQueue = (function () {
|
3300 | function AuthMiddlewareQueue(auth) {
|
3301 | this.auth = auth;
|
3302 | this.queue = [];
|
3303 | }
|
3304 | AuthMiddlewareQueue.prototype.pushCallback = function (callback, onAbort) {
|
3305 | var _this = this;
|
3306 |
|
3307 |
|
3308 | var wrappedCallback = function (user) { return new Promise(function (resolve, reject) {
|
3309 | try {
|
3310 | var result = callback(user);
|
3311 |
|
3312 |
|
3313 | resolve(result);
|
3314 | }
|
3315 | catch (e) {
|
3316 |
|
3317 | reject(e);
|
3318 | }
|
3319 | }); };
|
3320 |
|
3321 | wrappedCallback.onAbort = onAbort;
|
3322 | this.queue.push(wrappedCallback);
|
3323 | var index = this.queue.length - 1;
|
3324 | return function () {
|
3325 |
|
3326 |
|
3327 | _this.queue[index] = function () { return Promise.resolve(); };
|
3328 | };
|
3329 | };
|
3330 | AuthMiddlewareQueue.prototype.runMiddleware = function (nextUser) {
|
3331 | return __awaiter(this, void 0, void 0, function () {
|
3332 | var onAbortStack, _i, _a, beforeStateCallback, e_1, _b, onAbortStack_1, onAbort;
|
3333 | return __generator(this, function (_c) {
|
3334 | switch (_c.label) {
|
3335 | case 0:
|
3336 | if (this.auth.currentUser === nextUser) {
|
3337 | return [2 ];
|
3338 | }
|
3339 | onAbortStack = [];
|
3340 | _c.label = 1;
|
3341 | case 1:
|
3342 | _c.trys.push([1, 6, , 7]);
|
3343 | _i = 0, _a = this.queue;
|
3344 | _c.label = 2;
|
3345 | case 2:
|
3346 | if (!(_i < _a.length)) return [3 , 5];
|
3347 | beforeStateCallback = _a[_i];
|
3348 | return [4 , beforeStateCallback(nextUser)];
|
3349 | case 3:
|
3350 | _c.sent();
|
3351 |
|
3352 | if (beforeStateCallback.onAbort) {
|
3353 | onAbortStack.push(beforeStateCallback.onAbort);
|
3354 | }
|
3355 | _c.label = 4;
|
3356 | case 4:
|
3357 | _i++;
|
3358 | return [3 , 2];
|
3359 | case 5: return [3 , 7];
|
3360 | case 6:
|
3361 | e_1 = _c.sent();
|
3362 |
|
3363 |
|
3364 | onAbortStack.reverse();
|
3365 | for (_b = 0, onAbortStack_1 = onAbortStack; _b < onAbortStack_1.length; _b++) {
|
3366 | onAbort = onAbortStack_1[_b];
|
3367 | try {
|
3368 | onAbort();
|
3369 | }
|
3370 | catch (_) { }
|
3371 | }
|
3372 | throw this.auth._errorFactory.create("login-blocked" , { originalMessage: e_1.message });
|
3373 | case 7: return [2 ];
|
3374 | }
|
3375 | });
|
3376 | });
|
3377 | };
|
3378 | return AuthMiddlewareQueue;
|
3379 | }());
|
3380 |
|
3381 |
|
3382 |
|
3383 |
|
3384 |
|
3385 |
|
3386 |
|
3387 |
|
3388 |
|
3389 |
|
3390 |
|
3391 |
|
3392 |
|
3393 |
|
3394 |
|
3395 |
|
3396 |
|
3397 | var AuthImpl = (function () {
|
3398 | function AuthImpl(app, heartbeatServiceProvider, config) {
|
3399 | this.app = app;
|
3400 | this.heartbeatServiceProvider = heartbeatServiceProvider;
|
3401 | this.config = config;
|
3402 | this.currentUser = null;
|
3403 | this.emulatorConfig = null;
|
3404 | this.operations = Promise.resolve();
|
3405 | this.authStateSubscription = new Subscription(this);
|
3406 | this.idTokenSubscription = new Subscription(this);
|
3407 | this.beforeStateQueue = new AuthMiddlewareQueue(this);
|
3408 | this.redirectUser = null;
|
3409 | this.isProactiveRefreshEnabled = false;
|
3410 |
|
3411 |
|
3412 | this._canInitEmulator = true;
|
3413 | this._isInitialized = false;
|
3414 | this._deleted = false;
|
3415 | this._initializationPromise = null;
|
3416 | this._popupRedirectResolver = null;
|
3417 | this._errorFactory = _DEFAULT_AUTH_ERROR_FACTORY;
|
3418 |
|
3419 |
|
3420 |
|
3421 | this.lastNotifiedUid = undefined;
|
3422 | this.languageCode = null;
|
3423 | this.tenantId = null;
|
3424 | this.settings = { appVerificationDisabledForTesting: false };
|
3425 | this.frameworks = [];
|
3426 | this.name = app.name;
|
3427 | this.clientVersion = config.sdkClientVersion;
|
3428 | }
|
3429 | AuthImpl.prototype._initializeWithPersistence = function (persistenceHierarchy, popupRedirectResolver) {
|
3430 | var _this = this;
|
3431 | if (popupRedirectResolver) {
|
3432 | this._popupRedirectResolver = _getInstance(popupRedirectResolver);
|
3433 | }
|
3434 |
|
3435 |
|
3436 | this._initializationPromise = this.queue(function () { return __awaiter(_this, void 0, void 0, function () {
|
3437 | var _a;
|
3438 | var _b, _c;
|
3439 | return __generator(this, function (_d) {
|
3440 | switch (_d.label) {
|
3441 | case 0:
|
3442 | if (this._deleted) {
|
3443 | return [2 ];
|
3444 | }
|
3445 | _a = this;
|
3446 | return [4 , PersistenceUserManager.create(this, persistenceHierarchy)];
|
3447 | case 1:
|
3448 | _a.persistenceManager = _d.sent();
|
3449 | if (this._deleted) {
|
3450 | return [2 ];
|
3451 | }
|
3452 | if (!((_b = this._popupRedirectResolver) === null || _b === void 0 ? void 0 : _b._shouldInitProactively)) return [3 , 5];
|
3453 | _d.label = 2;
|
3454 | case 2:
|
3455 | _d.trys.push([2, 4, , 5]);
|
3456 | return [4 , this._popupRedirectResolver._initialize(this)];
|
3457 | case 3:
|
3458 | _d.sent();
|
3459 | return [3 , 5];
|
3460 | case 4:
|
3461 | _d.sent();
|
3462 | return [3 , 5];
|
3463 | case 5: return [4 , this.initializeCurrentUser(popupRedirectResolver)];
|
3464 | case 6:
|
3465 | _d.sent();
|
3466 | this.lastNotifiedUid = ((_c = this.currentUser) === null || _c === void 0 ? void 0 : _c.uid) || null;
|
3467 | if (this._deleted) {
|
3468 | return [2 ];
|
3469 | }
|
3470 | this._isInitialized = true;
|
3471 | return [2 ];
|
3472 | }
|
3473 | });
|
3474 | }); });
|
3475 | return this._initializationPromise;
|
3476 | };
|
3477 | |
3478 |
|
3479 |
|
3480 | AuthImpl.prototype._onStorageEvent = function () {
|
3481 | return __awaiter(this, void 0, void 0, function () {
|
3482 | var user;
|
3483 | return __generator(this, function (_a) {
|
3484 | switch (_a.label) {
|
3485 | case 0:
|
3486 | if (this._deleted) {
|
3487 | return [2 ];
|
3488 | }
|
3489 | return [4 , this.assertedPersistence.getCurrentUser()];
|
3490 | case 1:
|
3491 | user = _a.sent();
|
3492 | if (!this.currentUser && !user) {
|
3493 |
|
3494 | return [2 ];
|
3495 | }
|
3496 | if (!(this.currentUser && user && this.currentUser.uid === user.uid)) return [3 , 3];
|
3497 |
|
3498 | this._currentUser._assign(user);
|
3499 |
|
3500 |
|
3501 | return [4 , this.currentUser.getIdToken()];
|
3502 | case 2:
|
3503 |
|
3504 |
|
3505 | _a.sent();
|
3506 | return [2 ];
|
3507 | case 3:
|
3508 |
|
3509 |
|
3510 | return [4 , this._updateCurrentUser(user, true)];
|
3511 | case 4:
|
3512 |
|
3513 |
|
3514 | _a.sent();
|
3515 | return [2 ];
|
3516 | }
|
3517 | });
|
3518 | });
|
3519 | };
|
3520 | AuthImpl.prototype.initializeCurrentUser = function (popupRedirectResolver) {
|
3521 | var _a;
|
3522 | return __awaiter(this, void 0, void 0, function () {
|
3523 | var previouslyStoredUser, futureCurrentUser, needsTocheckMiddleware, redirectUserEventId, storedUserEventId, result, e_2;
|
3524 | return __generator(this, function (_b) {
|
3525 | switch (_b.label) {
|
3526 | case 0: return [4 , this.assertedPersistence.getCurrentUser()];
|
3527 | case 1:
|
3528 | previouslyStoredUser = (_b.sent());
|
3529 | futureCurrentUser = previouslyStoredUser;
|
3530 | needsTocheckMiddleware = false;
|
3531 | if (!(popupRedirectResolver && this.config.authDomain)) return [3 , 4];
|
3532 | return [4 , this.getOrInitRedirectPersistenceManager()];
|
3533 | case 2:
|
3534 | _b.sent();
|
3535 | redirectUserEventId = (_a = this.redirectUser) === null || _a === void 0 ? void 0 : _a._redirectEventId;
|
3536 | storedUserEventId = futureCurrentUser === null || futureCurrentUser === void 0 ? void 0 : futureCurrentUser._redirectEventId;
|
3537 | return [4 , this.tryRedirectSignIn(popupRedirectResolver)];
|
3538 | case 3:
|
3539 | result = _b.sent();
|
3540 |
|
3541 |
|
3542 |
|
3543 |
|
3544 | if ((!redirectUserEventId || redirectUserEventId === storedUserEventId) &&
|
3545 | (result === null || result === void 0 ? void 0 : result.user)) {
|
3546 | futureCurrentUser = result.user;
|
3547 | needsTocheckMiddleware = true;
|
3548 | }
|
3549 | _b.label = 4;
|
3550 | case 4:
|
3551 |
|
3552 | if (!futureCurrentUser) {
|
3553 | return [2 , this.directlySetCurrentUser(null)];
|
3554 | }
|
3555 | if (!!futureCurrentUser._redirectEventId) return [3 , 9];
|
3556 | if (!needsTocheckMiddleware) return [3 , 8];
|
3557 | _b.label = 5;
|
3558 | case 5:
|
3559 | _b.trys.push([5, 7, , 8]);
|
3560 | return [4 , this.beforeStateQueue.runMiddleware(futureCurrentUser)];
|
3561 | case 6:
|
3562 | _b.sent();
|
3563 | return [3 , 8];
|
3564 | case 7:
|
3565 | e_2 = _b.sent();
|
3566 | futureCurrentUser = previouslyStoredUser;
|
3567 |
|
3568 |
|
3569 | this._popupRedirectResolver._overrideRedirectResult(this, function () { return Promise.reject(e_2); });
|
3570 | return [3 , 8];
|
3571 | case 8:
|
3572 | if (futureCurrentUser) {
|
3573 | return [2 , this.reloadAndSetCurrentUserOrClear(futureCurrentUser)];
|
3574 | }
|
3575 | else {
|
3576 | return [2 , this.directlySetCurrentUser(null)];
|
3577 | }
|
3578 | case 9:
|
3579 | _assert(this._popupRedirectResolver, this, "argument-error" );
|
3580 | return [4 , this.getOrInitRedirectPersistenceManager()];
|
3581 | case 10:
|
3582 | _b.sent();
|
3583 |
|
3584 |
|
3585 |
|
3586 | if (this.redirectUser &&
|
3587 | this.redirectUser._redirectEventId === futureCurrentUser._redirectEventId) {
|
3588 | return [2 , this.directlySetCurrentUser(futureCurrentUser)];
|
3589 | }
|
3590 | return [2 , this.reloadAndSetCurrentUserOrClear(futureCurrentUser)];
|
3591 | }
|
3592 | });
|
3593 | });
|
3594 | };
|
3595 | AuthImpl.prototype.tryRedirectSignIn = function (redirectResolver) {
|
3596 | return __awaiter(this, void 0, void 0, function () {
|
3597 | var result;
|
3598 | return __generator(this, function (_a) {
|
3599 | switch (_a.label) {
|
3600 | case 0:
|
3601 | result = null;
|
3602 | _a.label = 1;
|
3603 | case 1:
|
3604 | _a.trys.push([1, 3, , 5]);
|
3605 | return [4 , this._popupRedirectResolver._completeRedirectFn(this, redirectResolver, true)];
|
3606 | case 2:
|
3607 |
|
3608 |
|
3609 | result = _a.sent();
|
3610 | return [3 , 5];
|
3611 | case 3:
|
3612 | _a.sent();
|
3613 |
|
3614 |
|
3615 | return [4 , this._setRedirectUser(null)];
|
3616 | case 4:
|
3617 |
|
3618 |
|
3619 | _a.sent();
|
3620 | return [3 , 5];
|
3621 | case 5: return [2 , result];
|
3622 | }
|
3623 | });
|
3624 | });
|
3625 | };
|
3626 | AuthImpl.prototype.reloadAndSetCurrentUserOrClear = function (user) {
|
3627 | return __awaiter(this, void 0, void 0, function () {
|
3628 | var e_4;
|
3629 | return __generator(this, function (_a) {
|
3630 | switch (_a.label) {
|
3631 | case 0:
|
3632 | _a.trys.push([0, 2, , 3]);
|
3633 | return [4 , _reloadWithoutSaving(user)];
|
3634 | case 1:
|
3635 | _a.sent();
|
3636 | return [3 , 3];
|
3637 | case 2:
|
3638 | e_4 = _a.sent();
|
3639 | if (e_4.code !== "auth/" + "network-request-failed" ) {
|
3640 |
|
3641 |
|
3642 | return [2 , this.directlySetCurrentUser(null)];
|
3643 | }
|
3644 | return [3 , 3];
|
3645 | case 3: return [2 , this.directlySetCurrentUser(user)];
|
3646 | }
|
3647 | });
|
3648 | });
|
3649 | };
|
3650 | AuthImpl.prototype.useDeviceLanguage = function () {
|
3651 | this.languageCode = _getUserLanguage();
|
3652 | };
|
3653 | AuthImpl.prototype._delete = function () {
|
3654 | return __awaiter(this, void 0, void 0, function () {
|
3655 | return __generator(this, function (_a) {
|
3656 | this._deleted = true;
|
3657 | return [2 ];
|
3658 | });
|
3659 | });
|
3660 | };
|
3661 | AuthImpl.prototype.updateCurrentUser = function (userExtern) {
|
3662 | return __awaiter(this, void 0, void 0, function () {
|
3663 | var user;
|
3664 | return __generator(this, function (_a) {
|
3665 | user = userExtern
|
3666 | ? getModularInstance(userExtern)
|
3667 | : null;
|
3668 | if (user) {
|
3669 | _assert(user.auth.config.apiKey === this.config.apiKey, this, "invalid-user-token" );
|
3670 | }
|
3671 | return [2 , this._updateCurrentUser(user && user._clone(this))];
|
3672 | });
|
3673 | });
|
3674 | };
|
3675 | AuthImpl.prototype._updateCurrentUser = function (user, skipBeforeStateCallbacks) {
|
3676 | if (skipBeforeStateCallbacks === void 0) { skipBeforeStateCallbacks = false; }
|
3677 | return __awaiter(this, void 0, void 0, function () {
|
3678 | var _this = this;
|
3679 | return __generator(this, function (_a) {
|
3680 | switch (_a.label) {
|
3681 | case 0:
|
3682 | if (this._deleted) {
|
3683 | return [2 ];
|
3684 | }
|
3685 | if (user) {
|
3686 | _assert(this.tenantId === user.tenantId, this, "tenant-id-mismatch" );
|
3687 | }
|
3688 | if (!!skipBeforeStateCallbacks) return [3 , 2];
|
3689 | return [4 , this.beforeStateQueue.runMiddleware(user)];
|
3690 | case 1:
|
3691 | _a.sent();
|
3692 | _a.label = 2;
|
3693 | case 2: return [2 , this.queue(function () { return __awaiter(_this, void 0, void 0, function () {
|
3694 | return __generator(this, function (_a) {
|
3695 | switch (_a.label) {
|
3696 | case 0: return [4 , this.directlySetCurrentUser(user)];
|
3697 | case 1:
|
3698 | _a.sent();
|
3699 | this.notifyAuthListeners();
|
3700 | return [2 ];
|
3701 | }
|
3702 | });
|
3703 | }); })];
|
3704 | }
|
3705 | });
|
3706 | });
|
3707 | };
|
3708 | AuthImpl.prototype.signOut = function () {
|
3709 | return __awaiter(this, void 0, void 0, function () {
|
3710 | return __generator(this, function (_a) {
|
3711 | switch (_a.label) {
|
3712 | case 0:
|
3713 |
|
3714 | return [4 , this.beforeStateQueue.runMiddleware(null)];
|
3715 | case 1:
|
3716 |
|
3717 | _a.sent();
|
3718 | if (!(this.redirectPersistenceManager || this._popupRedirectResolver)) return [3 , 3];
|
3719 | return [4 , this._setRedirectUser(null)];
|
3720 | case 2:
|
3721 | _a.sent();
|
3722 | _a.label = 3;
|
3723 | case 3:
|
3724 |
|
3725 |
|
3726 | return [2 , this._updateCurrentUser(null, true)];
|
3727 | }
|
3728 | });
|
3729 | });
|
3730 | };
|
3731 | AuthImpl.prototype.setPersistence = function (persistence) {
|
3732 | var _this = this;
|
3733 | return this.queue(function () { return __awaiter(_this, void 0, void 0, function () {
|
3734 | return __generator(this, function (_a) {
|
3735 | switch (_a.label) {
|
3736 | case 0: return [4 , this.assertedPersistence.setPersistence(_getInstance(persistence))];
|
3737 | case 1:
|
3738 | _a.sent();
|
3739 | return [2 ];
|
3740 | }
|
3741 | });
|
3742 | }); });
|
3743 | };
|
3744 | AuthImpl.prototype._getPersistence = function () {
|
3745 | return this.assertedPersistence.persistence.type;
|
3746 | };
|
3747 | AuthImpl.prototype._updateErrorMap = function (errorMap) {
|
3748 | this._errorFactory = new ErrorFactory('auth', 'Firebase', errorMap());
|
3749 | };
|
3750 | AuthImpl.prototype.onAuthStateChanged = function (nextOrObserver, error, completed) {
|
3751 | return this.registerStateListener(this.authStateSubscription, nextOrObserver, error, completed);
|
3752 | };
|
3753 | AuthImpl.prototype.beforeAuthStateChanged = function (callback, onAbort) {
|
3754 | return this.beforeStateQueue.pushCallback(callback, onAbort);
|
3755 | };
|
3756 | AuthImpl.prototype.onIdTokenChanged = function (nextOrObserver, error, completed) {
|
3757 | return this.registerStateListener(this.idTokenSubscription, nextOrObserver, error, completed);
|
3758 | };
|
3759 | AuthImpl.prototype.toJSON = function () {
|
3760 | var _a;
|
3761 | return {
|
3762 | apiKey: this.config.apiKey,
|
3763 | authDomain: this.config.authDomain,
|
3764 | appName: this.name,
|
3765 | currentUser: (_a = this._currentUser) === null || _a === void 0 ? void 0 : _a.toJSON()
|
3766 | };
|
3767 | };
|
3768 | AuthImpl.prototype._setRedirectUser = function (user, popupRedirectResolver) {
|
3769 | return __awaiter(this, void 0, void 0, function () {
|
3770 | var redirectManager;
|
3771 | return __generator(this, function (_a) {
|
3772 | switch (_a.label) {
|
3773 | case 0: return [4 , this.getOrInitRedirectPersistenceManager(popupRedirectResolver)];
|
3774 | case 1:
|
3775 | redirectManager = _a.sent();
|
3776 | return [2 , user === null
|
3777 | ? redirectManager.removeCurrentUser()
|
3778 | : redirectManager.setCurrentUser(user)];
|
3779 | }
|
3780 | });
|
3781 | });
|
3782 | };
|
3783 | AuthImpl.prototype.getOrInitRedirectPersistenceManager = function (popupRedirectResolver) {
|
3784 | return __awaiter(this, void 0, void 0, function () {
|
3785 | var resolver, _a, _b;
|
3786 | return __generator(this, function (_c) {
|
3787 | switch (_c.label) {
|
3788 | case 0:
|
3789 | if (!!this.redirectPersistenceManager) return [3 , 3];
|
3790 | resolver = (popupRedirectResolver && _getInstance(popupRedirectResolver)) ||
|
3791 | this._popupRedirectResolver;
|
3792 | _assert(resolver, this, "argument-error" );
|
3793 | _a = this;
|
3794 | return [4 , PersistenceUserManager.create(this, [_getInstance(resolver._redirectPersistence)], "redirectUser" )];
|
3795 | case 1:
|
3796 | _a.redirectPersistenceManager = _c.sent();
|
3797 | _b = this;
|
3798 | return [4 , this.redirectPersistenceManager.getCurrentUser()];
|
3799 | case 2:
|
3800 | _b.redirectUser =
|
3801 | _c.sent();
|
3802 | _c.label = 3;
|
3803 | case 3: return [2 , this.redirectPersistenceManager];
|
3804 | }
|
3805 | });
|
3806 | });
|
3807 | };
|
3808 | AuthImpl.prototype._redirectUserForId = function (id) {
|
3809 | var _a, _b;
|
3810 | return __awaiter(this, void 0, void 0, function () {
|
3811 | var _this = this;
|
3812 | return __generator(this, function (_c) {
|
3813 | switch (_c.label) {
|
3814 | case 0:
|
3815 | if (!this._isInitialized) return [3 , 2];
|
3816 | return [4 , this.queue(function () { return __awaiter(_this, void 0, void 0, function () { return __generator(this, function (_a) {
|
3817 | return [2 ];
|
3818 | }); }); })];
|
3819 | case 1:
|
3820 | _c.sent();
|
3821 | _c.label = 2;
|
3822 | case 2:
|
3823 | if (((_a = this._currentUser) === null || _a === void 0 ? void 0 : _a._redirectEventId) === id) {
|
3824 | return [2 , this._currentUser];
|
3825 | }
|
3826 | if (((_b = this.redirectUser) === null || _b === void 0 ? void 0 : _b._redirectEventId) === id) {
|
3827 | return [2 , this.redirectUser];
|
3828 | }
|
3829 | return [2 , null];
|
3830 | }
|
3831 | });
|
3832 | });
|
3833 | };
|
3834 | AuthImpl.prototype._persistUserIfCurrent = function (user) {
|
3835 | return __awaiter(this, void 0, void 0, function () {
|
3836 | var _this = this;
|
3837 | return __generator(this, function (_a) {
|
3838 | if (user === this.currentUser) {
|
3839 | return [2 , this.queue(function () { return __awaiter(_this, void 0, void 0, function () { return __generator(this, function (_a) {
|
3840 | return [2 , this.directlySetCurrentUser(user)];
|
3841 | }); }); })];
|
3842 | }
|
3843 | return [2 ];
|
3844 | });
|
3845 | });
|
3846 | };
|
3847 |
|
3848 | AuthImpl.prototype._notifyListenersIfCurrent = function (user) {
|
3849 | if (user === this.currentUser) {
|
3850 | this.notifyAuthListeners();
|
3851 | }
|
3852 | };
|
3853 | AuthImpl.prototype._key = function () {
|
3854 | return this.config.authDomain + ":" + this.config.apiKey + ":" + this.name;
|
3855 | };
|
3856 | AuthImpl.prototype._startProactiveRefresh = function () {
|
3857 | this.isProactiveRefreshEnabled = true;
|
3858 | if (this.currentUser) {
|
3859 | this._currentUser._startProactiveRefresh();
|
3860 | }
|
3861 | };
|
3862 | AuthImpl.prototype._stopProactiveRefresh = function () {
|
3863 | this.isProactiveRefreshEnabled = false;
|
3864 | if (this.currentUser) {
|
3865 | this._currentUser._stopProactiveRefresh();
|
3866 | }
|
3867 | };
|
3868 | Object.defineProperty(AuthImpl.prototype, "_currentUser", {
|
3869 |
|
3870 | get: function () {
|
3871 | return this.currentUser;
|
3872 | },
|
3873 | enumerable: false,
|
3874 | configurable: true
|
3875 | });
|
3876 | AuthImpl.prototype.notifyAuthListeners = function () {
|
3877 | var _a, _b;
|
3878 | if (!this._isInitialized) {
|
3879 | return;
|
3880 | }
|
3881 | this.idTokenSubscription.next(this.currentUser);
|
3882 | var currentUid = (_b = (_a = this.currentUser) === null || _a === void 0 ? void 0 : _a.uid) !== null && _b !== void 0 ? _b : null;
|
3883 | if (this.lastNotifiedUid !== currentUid) {
|
3884 | this.lastNotifiedUid = currentUid;
|
3885 | this.authStateSubscription.next(this.currentUser);
|
3886 | }
|
3887 | };
|
3888 | AuthImpl.prototype.registerStateListener = function (subscription, nextOrObserver, error, completed) {
|
3889 | var _this = this;
|
3890 | if (this._deleted) {
|
3891 | return function () { };
|
3892 | }
|
3893 | var cb = typeof nextOrObserver === 'function'
|
3894 | ? nextOrObserver
|
3895 | : nextOrObserver.next.bind(nextOrObserver);
|
3896 | var promise = this._isInitialized
|
3897 | ? Promise.resolve()
|
3898 | : this._initializationPromise;
|
3899 | _assert(promise, this, "internal-error" );
|
3900 |
|
3901 |
|
3902 | promise.then(function () { return cb(_this.currentUser); });
|
3903 | if (typeof nextOrObserver === 'function') {
|
3904 | return subscription.addObserver(nextOrObserver, error, completed);
|
3905 | }
|
3906 | else {
|
3907 | return subscription.addObserver(nextOrObserver);
|
3908 | }
|
3909 | };
|
3910 | |
3911 |
|
3912 |
|
3913 |
|
3914 |
|
3915 | AuthImpl.prototype.directlySetCurrentUser = function (user) {
|
3916 | return __awaiter(this, void 0, void 0, function () {
|
3917 | return __generator(this, function (_a) {
|
3918 | switch (_a.label) {
|
3919 | case 0:
|
3920 | if (this.currentUser && this.currentUser !== user) {
|
3921 | this._currentUser._stopProactiveRefresh();
|
3922 | if (user && this.isProactiveRefreshEnabled) {
|
3923 | user._startProactiveRefresh();
|
3924 | }
|
3925 | }
|
3926 | this.currentUser = user;
|
3927 | if (!user) return [3 , 2];
|
3928 | return [4 , this.assertedPersistence.setCurrentUser(user)];
|
3929 | case 1:
|
3930 | _a.sent();
|
3931 | return [3 , 4];
|
3932 | case 2: return [4 , this.assertedPersistence.removeCurrentUser()];
|
3933 | case 3:
|
3934 | _a.sent();
|
3935 | _a.label = 4;
|
3936 | case 4: return [2 ];
|
3937 | }
|
3938 | });
|
3939 | });
|
3940 | };
|
3941 | AuthImpl.prototype.queue = function (action) {
|
3942 |
|
3943 |
|
3944 | this.operations = this.operations.then(action, action);
|
3945 | return this.operations;
|
3946 | };
|
3947 | Object.defineProperty(AuthImpl.prototype, "assertedPersistence", {
|
3948 | get: function () {
|
3949 | _assert(this.persistenceManager, this, "internal-error" );
|
3950 | return this.persistenceManager;
|
3951 | },
|
3952 | enumerable: false,
|
3953 | configurable: true
|
3954 | });
|
3955 | AuthImpl.prototype._logFramework = function (framework) {
|
3956 | if (!framework || this.frameworks.includes(framework)) {
|
3957 | return;
|
3958 | }
|
3959 | this.frameworks.push(framework);
|
3960 |
|
3961 |
|
3962 | this.frameworks.sort();
|
3963 | this.clientVersion = _getClientVersion(this.config.clientPlatform, this._getFrameworks());
|
3964 | };
|
3965 | AuthImpl.prototype._getFrameworks = function () {
|
3966 | return this.frameworks;
|
3967 | };
|
3968 | AuthImpl.prototype._getAdditionalHeaders = function () {
|
3969 | var _a;
|
3970 | return __awaiter(this, void 0, void 0, function () {
|
3971 | var headers, heartbeatsHeader;
|
3972 | var _b;
|
3973 | return __generator(this, function (_c) {
|
3974 | switch (_c.label) {
|
3975 | case 0:
|
3976 | headers = (_b = {},
|
3977 | _b["X-Client-Version" ] = this.clientVersion,
|
3978 | _b);
|
3979 | if (this.app.options.appId) {
|
3980 | headers["X-Firebase-gmpid" ] = this.app.options.appId;
|
3981 | }
|
3982 | return [4 , ((_a = this.heartbeatServiceProvider.getImmediate({
|
3983 | optional: true,
|
3984 | })) === null || _a === void 0 ? void 0 : _a.getHeartbeatsHeader())];
|
3985 | case 1:
|
3986 | heartbeatsHeader = _c.sent();
|
3987 | if (heartbeatsHeader) {
|
3988 | headers["X-Firebase-Client" ] = heartbeatsHeader;
|
3989 | }
|
3990 | return [2 , headers];
|
3991 | }
|
3992 | });
|
3993 | });
|
3994 | };
|
3995 | return AuthImpl;
|
3996 | }());
|
3997 |
|
3998 |
|
3999 |
|
4000 |
|
4001 |
|
4002 |
|
4003 | function _castAuth(auth) {
|
4004 | return getModularInstance(auth);
|
4005 | }
|
4006 |
|
4007 | var Subscription = (function () {
|
4008 | function Subscription(auth) {
|
4009 | var _this = this;
|
4010 | this.auth = auth;
|
4011 | this.observer = null;
|
4012 | this.addObserver = createSubscribe(function (observer) { return (_this.observer = observer); });
|
4013 | }
|
4014 | Object.defineProperty(Subscription.prototype, "next", {
|
4015 | get: function () {
|
4016 | _assert(this.observer, this.auth, "internal-error" );
|
4017 | return this.observer.next.bind(this.observer);
|
4018 | },
|
4019 | enumerable: false,
|
4020 | configurable: true
|
4021 | });
|
4022 | return Subscription;
|
4023 | }());
|
4024 |
|
4025 |
|
4026 |
|
4027 |
|
4028 |
|
4029 |
|
4030 |
|
4031 |
|
4032 |
|
4033 |
|
4034 |
|
4035 |
|
4036 |
|
4037 |
|
4038 |
|
4039 |
|
4040 |
|
4041 |
|
4042 |
|
4043 |
|
4044 |
|
4045 |
|
4046 |
|
4047 | function connectAuthEmulator(auth, url, options) {
|
4048 | var authInternal = _castAuth(auth);
|
4049 | _assert(authInternal._canInitEmulator, authInternal, "emulator-config-failed" );
|
4050 | _assert(/^https?:\/\//.test(url), authInternal, "invalid-emulator-scheme" );
|
4051 | var disableWarnings = !!(options === null || options === void 0 ? void 0 : options.disableWarnings);
|
4052 | var protocol = extractProtocol(url);
|
4053 | var _a = extractHostAndPort(url), host = _a.host, port = _a.port;
|
4054 | var portStr = port === null ? '' : ":" + port;
|
4055 |
|
4056 | authInternal.config.emulator = { url: protocol + "//" + host + portStr + "/" };
|
4057 | authInternal.settings.appVerificationDisabledForTesting = true;
|
4058 | authInternal.emulatorConfig = Object.freeze({
|
4059 | host: host,
|
4060 | port: port,
|
4061 | protocol: protocol.replace(':', ''),
|
4062 | options: Object.freeze({ disableWarnings: disableWarnings })
|
4063 | });
|
4064 | if (!disableWarnings) {
|
4065 | emitEmulatorWarning();
|
4066 | }
|
4067 | }
|
4068 | function extractProtocol(url) {
|
4069 | var protocolEnd = url.indexOf(':');
|
4070 | return protocolEnd < 0 ? '' : url.substr(0, protocolEnd + 1);
|
4071 | }
|
4072 | function extractHostAndPort(url) {
|
4073 | var protocol = extractProtocol(url);
|
4074 | var authority = /(\/\/)?([^?#/]+)/.exec(url.substr(protocol.length));
|
4075 | if (!authority) {
|
4076 | return { host: '', port: null };
|
4077 | }
|
4078 | var hostAndPort = authority[2].split('@').pop() || '';
|
4079 | var bracketedIPv6 = /^(\[[^\]]+\])(:|$)/.exec(hostAndPort);
|
4080 | if (bracketedIPv6) {
|
4081 | var host = bracketedIPv6[1];
|
4082 | return { host: host, port: parsePort(hostAndPort.substr(host.length + 1)) };
|
4083 | }
|
4084 | else {
|
4085 | var _a = hostAndPort.split(':'), host = _a[0], port = _a[1];
|
4086 | return { host: host, port: parsePort(port) };
|
4087 | }
|
4088 | }
|
4089 | function parsePort(portStr) {
|
4090 | if (!portStr) {
|
4091 | return null;
|
4092 | }
|
4093 | var port = Number(portStr);
|
4094 | if (isNaN(port)) {
|
4095 | return null;
|
4096 | }
|
4097 | return port;
|
4098 | }
|
4099 | function emitEmulatorWarning() {
|
4100 | function attachBanner() {
|
4101 | var el = document.createElement('p');
|
4102 | var sty = el.style;
|
4103 | el.innerText =
|
4104 | 'Running in emulator mode. Do not use with production credentials.';
|
4105 | sty.position = 'fixed';
|
4106 | sty.width = '100%';
|
4107 | sty.backgroundColor = '#ffffff';
|
4108 | sty.border = '.1em solid #000000';
|
4109 | sty.color = '#b50000';
|
4110 | sty.bottom = '0px';
|
4111 | sty.left = '0px';
|
4112 | sty.margin = '0px';
|
4113 | sty.zIndex = '10000';
|
4114 | sty.textAlign = 'center';
|
4115 | el.classList.add('firebase-emulator-warning');
|
4116 | document.body.appendChild(el);
|
4117 | }
|
4118 | if (typeof console !== 'undefined' && typeof console.info === 'function') {
|
4119 | console.info('WARNING: You are using the Auth Emulator,' +
|
4120 | ' which is intended for local testing only. Do not use with' +
|
4121 | ' production credentials.');
|
4122 | }
|
4123 | if (typeof window !== 'undefined' &&
|
4124 | typeof document !== 'undefined') {
|
4125 | if (document.readyState === 'loading') {
|
4126 | window.addEventListener('DOMContentLoaded', attachBanner);
|
4127 | }
|
4128 | else {
|
4129 | attachBanner();
|
4130 | }
|
4131 | }
|
4132 | }
|
4133 |
|
4134 |
|
4135 |
|
4136 |
|
4137 |
|
4138 |
|
4139 |
|
4140 |
|
4141 |
|
4142 |
|
4143 |
|
4144 |
|
4145 |
|
4146 |
|
4147 |
|
4148 |
|
4149 |
|
4150 |
|
4151 |
|
4152 |
|
4153 |
|
4154 |
|
4155 |
|
4156 |
|
4157 |
|
4158 | var AuthCredential = (function () {
|
4159 |
|
4160 | function AuthCredential(
|
4161 | /**
|
4162 | * The authentication provider ID for the credential.
|
4163 | *
|
4164 | * @remarks
|
4165 | * For example, 'facebook.com', or 'google.com'.
|
4166 | */
|
4167 | providerId,
|
4168 | |
4169 |
|
4170 |
|
4171 |
|
4172 |
|
4173 |
|
4174 |
|
4175 |
|
4176 | signInMethod) {
|
4177 | this.providerId = providerId;
|
4178 | this.signInMethod = signInMethod;
|
4179 | }
|
4180 | |
4181 |
|
4182 |
|
4183 |
|
4184 |
|
4185 | AuthCredential.prototype.toJSON = function () {
|
4186 | return debugFail('not implemented');
|
4187 | };
|
4188 |
|
4189 | AuthCredential.prototype._getIdTokenResponse = function (_auth) {
|
4190 | return debugFail('not implemented');
|
4191 | };
|
4192 |
|
4193 | AuthCredential.prototype._linkToIdToken = function (_auth, _idToken) {
|
4194 | return debugFail('not implemented');
|
4195 | };
|
4196 |
|
4197 | AuthCredential.prototype._getReauthenticationResolver = function (_auth) {
|
4198 | return debugFail('not implemented');
|
4199 | };
|
4200 | return AuthCredential;
|
4201 | }());
|
4202 |
|
4203 |
|
4204 |
|
4205 |
|
4206 |
|
4207 |
|
4208 |
|
4209 |
|
4210 |
|
4211 |
|
4212 |
|
4213 |
|
4214 |
|
4215 |
|
4216 |
|
4217 |
|
4218 |
|
4219 | function resetPassword(auth, request) {
|
4220 | return __awaiter(this, void 0, void 0, function () {
|
4221 | return __generator(this, function (_a) {
|
4222 | return [2 , _performApiRequest(auth, "POST" , "/v1/accounts:resetPassword" , _addTidIfNecessary(auth, request))];
|
4223 | });
|
4224 | });
|
4225 | }
|
4226 | function updateEmailPassword(auth, request) {
|
4227 | return __awaiter(this, void 0, void 0, function () {
|
4228 | return __generator(this, function (_a) {
|
4229 | return [2 , _performApiRequest(auth, "POST" , "/v1/accounts:update" , request)];
|
4230 | });
|
4231 | });
|
4232 | }
|
4233 | function applyActionCode$1(auth, request) {
|
4234 | return __awaiter(this, void 0, void 0, function () {
|
4235 | return __generator(this, function (_a) {
|
4236 | return [2 , _performApiRequest(auth, "POST" , "/v1/accounts:update" , _addTidIfNecessary(auth, request))];
|
4237 | });
|
4238 | });
|
4239 | }
|
4240 |
|
4241 |
|
4242 |
|
4243 |
|
4244 |
|
4245 |
|
4246 |
|
4247 |
|
4248 |
|
4249 |
|
4250 |
|
4251 |
|
4252 |
|
4253 |
|
4254 |
|
4255 |
|
4256 |
|
4257 | function signInWithPassword(auth, request) {
|
4258 | return __awaiter(this, void 0, void 0, function () {
|
4259 | return __generator(this, function (_a) {
|
4260 | return [2 , _performSignInRequest(auth, "POST" , "/v1/accounts:signInWithPassword" , _addTidIfNecessary(auth, request))];
|
4261 | });
|
4262 | });
|
4263 | }
|
4264 | function sendOobCode(auth, request) {
|
4265 | return __awaiter(this, void 0, void 0, function () {
|
4266 | return __generator(this, function (_a) {
|
4267 | return [2 , _performApiRequest(auth, "POST" , "/v1/accounts:sendOobCode" , _addTidIfNecessary(auth, request))];
|
4268 | });
|
4269 | });
|
4270 | }
|
4271 | function sendEmailVerification$1(auth, request) {
|
4272 | return __awaiter(this, void 0, void 0, function () {
|
4273 | return __generator(this, function (_a) {
|
4274 | return [2 , sendOobCode(auth, request)];
|
4275 | });
|
4276 | });
|
4277 | }
|
4278 | function sendPasswordResetEmail$1(auth, request) {
|
4279 | return __awaiter(this, void 0, void 0, function () {
|
4280 | return __generator(this, function (_a) {
|
4281 | return [2 , sendOobCode(auth, request)];
|
4282 | });
|
4283 | });
|
4284 | }
|
4285 | function sendSignInLinkToEmail$1(auth, request) {
|
4286 | return __awaiter(this, void 0, void 0, function () {
|
4287 | return __generator(this, function (_a) {
|
4288 | return [2 , sendOobCode(auth, request)];
|
4289 | });
|
4290 | });
|
4291 | }
|
4292 | function verifyAndChangeEmail(auth, request) {
|
4293 | return __awaiter(this, void 0, void 0, function () {
|
4294 | return __generator(this, function (_a) {
|
4295 | return [2 , sendOobCode(auth, request)];
|
4296 | });
|
4297 | });
|
4298 | }
|
4299 |
|
4300 |
|
4301 |
|
4302 |
|
4303 |
|
4304 |
|
4305 |
|
4306 |
|
4307 |
|
4308 |
|
4309 |
|
4310 |
|
4311 |
|
4312 |
|
4313 |
|
4314 |
|
4315 |
|
4316 | function signInWithEmailLink$1(auth, request) {
|
4317 | return __awaiter(this, void 0, void 0, function () {
|
4318 | return __generator(this, function (_a) {
|
4319 | return [2 , _performSignInRequest(auth, "POST" , "/v1/accounts:signInWithEmailLink" , _addTidIfNecessary(auth, request))];
|
4320 | });
|
4321 | });
|
4322 | }
|
4323 | function signInWithEmailLinkForLinking(auth, request) {
|
4324 | return __awaiter(this, void 0, void 0, function () {
|
4325 | return __generator(this, function (_a) {
|
4326 | return [2 , _performSignInRequest(auth, "POST" , "/v1/accounts:signInWithEmailLink" , _addTidIfNecessary(auth, request))];
|
4327 | });
|
4328 | });
|
4329 | }
|
4330 |
|
4331 |
|
4332 |
|
4333 |
|
4334 |
|
4335 |
|
4336 |
|
4337 |
|
4338 |
|
4339 |
|
4340 |
|
4341 |
|
4342 |
|
4343 |
|
4344 |
|
4345 |
|
4346 |
|
4347 |
|
4348 |
|
4349 |
|
4350 |
|
4351 |
|
4352 |
|
4353 |
|
4354 |
|
4355 |
|
4356 |
|
4357 | var EmailAuthCredential = (function (_super) {
|
4358 | __extends(EmailAuthCredential, _super);
|
4359 |
|
4360 | function EmailAuthCredential(
|
4361 | /** @internal */
|
4362 | _email,
|
4363 | /** @internal */
|
4364 | _password, signInMethod,
|
4365 | /** @internal */
|
4366 | _tenantId) {
|
4367 | if (_tenantId === void 0) { _tenantId = null; }
|
4368 | var _this = _super.call(this, "password" , signInMethod) || this;
|
4369 | _this._email = _email;
|
4370 | _this._password = _password;
|
4371 | _this._tenantId = _tenantId;
|
4372 | return _this;
|
4373 | }
|
4374 |
|
4375 | EmailAuthCredential._fromEmailAndPassword = function (email, password) {
|
4376 | return new EmailAuthCredential(email, password, "password" );
|
4377 | };
|
4378 |
|
4379 | EmailAuthCredential._fromEmailAndCode = function (email, oobCode, tenantId) {
|
4380 | if (tenantId === void 0) { tenantId = null; }
|
4381 | return new EmailAuthCredential(email, oobCode, "emailLink" , tenantId);
|
4382 | };
|
4383 |
|
4384 | EmailAuthCredential.prototype.toJSON = function () {
|
4385 | return {
|
4386 | email: this._email,
|
4387 | password: this._password,
|
4388 | signInMethod: this.signInMethod,
|
4389 | tenantId: this._tenantId
|
4390 | };
|
4391 | };
|
4392 | |
4393 |
|
4394 |
|
4395 |
|
4396 |
|
4397 |
|
4398 |
|
4399 |
|
4400 | EmailAuthCredential.fromJSON = function (json) {
|
4401 | var obj = typeof json === 'string' ? JSON.parse(json) : json;
|
4402 | if ((obj === null || obj === void 0 ? void 0 : obj.email) && (obj === null || obj === void 0 ? void 0 : obj.password)) {
|
4403 | if (obj.signInMethod === "password" ) {
|
4404 | return this._fromEmailAndPassword(obj.email, obj.password);
|
4405 | }
|
4406 | else if (obj.signInMethod === "emailLink" ) {
|
4407 | return this._fromEmailAndCode(obj.email, obj.password, obj.tenantId);
|
4408 | }
|
4409 | }
|
4410 | return null;
|
4411 | };
|
4412 |
|
4413 | EmailAuthCredential.prototype._getIdTokenResponse = function (auth) {
|
4414 | return __awaiter(this, void 0, void 0, function () {
|
4415 | return __generator(this, function (_a) {
|
4416 | switch (this.signInMethod) {
|
4417 | case "password" :
|
4418 | return [2 , signInWithPassword(auth, {
|
4419 | returnSecureToken: true,
|
4420 | email: this._email,
|
4421 | password: this._password
|
4422 | })];
|
4423 | case "emailLink" :
|
4424 | return [2 , signInWithEmailLink$1(auth, {
|
4425 | email: this._email,
|
4426 | oobCode: this._password
|
4427 | })];
|
4428 | default:
|
4429 | _fail(auth, "internal-error" );
|
4430 | }
|
4431 | return [2 ];
|
4432 | });
|
4433 | });
|
4434 | };
|
4435 |
|
4436 | EmailAuthCredential.prototype._linkToIdToken = function (auth, idToken) {
|
4437 | return __awaiter(this, void 0, void 0, function () {
|
4438 | return __generator(this, function (_a) {
|
4439 | switch (this.signInMethod) {
|
4440 | case "password" :
|
4441 | return [2 , updateEmailPassword(auth, {
|
4442 | idToken: idToken,
|
4443 | returnSecureToken: true,
|
4444 | email: this._email,
|
4445 | password: this._password
|
4446 | })];
|
4447 | case "emailLink" :
|
4448 | return [2 , signInWithEmailLinkForLinking(auth, {
|
4449 | idToken: idToken,
|
4450 | email: this._email,
|
4451 | oobCode: this._password
|
4452 | })];
|
4453 | default:
|
4454 | _fail(auth, "internal-error" );
|
4455 | }
|
4456 | return [2 ];
|
4457 | });
|
4458 | });
|
4459 | };
|
4460 |
|
4461 | EmailAuthCredential.prototype._getReauthenticationResolver = function (auth) {
|
4462 | return this._getIdTokenResponse(auth);
|
4463 | };
|
4464 | return EmailAuthCredential;
|
4465 | }(AuthCredential));
|
4466 |
|
4467 |
|
4468 |
|
4469 |
|
4470 |
|
4471 |
|
4472 |
|
4473 |
|
4474 |
|
4475 |
|
4476 |
|
4477 |
|
4478 |
|
4479 |
|
4480 |
|
4481 |
|
4482 |
|
4483 | function signInWithIdp(auth, request) {
|
4484 | return __awaiter(this, void 0, void 0, function () {
|
4485 | return __generator(this, function (_a) {
|
4486 | return [2 , _performSignInRequest(auth, "POST" , "/v1/accounts:signInWithIdp" , _addTidIfNecessary(auth, request))];
|
4487 | });
|
4488 | });
|
4489 | }
|
4490 |
|
4491 |
|
4492 |
|
4493 |
|
4494 |
|
4495 |
|
4496 |
|
4497 |
|
4498 |
|
4499 |
|
4500 |
|
4501 |
|
4502 |
|
4503 |
|
4504 |
|
4505 |
|
4506 |
|
4507 | var IDP_REQUEST_URI$1 = 'http://localhost';
|
4508 |
|
4509 |
|
4510 |
|
4511 |
|
4512 |
|
4513 |
|
4514 |
|
4515 |
|
4516 | var OAuthCredential = (function (_super) {
|
4517 | __extends(OAuthCredential, _super);
|
4518 | function OAuthCredential() {
|
4519 | var _this = _super !== null && _super.apply(this, arguments) || this;
|
4520 | _this.pendingToken = null;
|
4521 | return _this;
|
4522 | }
|
4523 |
|
4524 | OAuthCredential._fromParams = function (params) {
|
4525 | var cred = new OAuthCredential(params.providerId, params.signInMethod);
|
4526 | if (params.idToken || params.accessToken) {
|
4527 |
|
4528 | if (params.idToken) {
|
4529 | cred.idToken = params.idToken;
|
4530 | }
|
4531 | if (params.accessToken) {
|
4532 | cred.accessToken = params.accessToken;
|
4533 | }
|
4534 |
|
4535 | if (params.nonce && !params.pendingToken) {
|
4536 | cred.nonce = params.nonce;
|
4537 | }
|
4538 | if (params.pendingToken) {
|
4539 | cred.pendingToken = params.pendingToken;
|
4540 | }
|
4541 | }
|
4542 | else if (params.oauthToken && params.oauthTokenSecret) {
|
4543 |
|
4544 | cred.accessToken = params.oauthToken;
|
4545 | cred.secret = params.oauthTokenSecret;
|
4546 | }
|
4547 | else {
|
4548 | _fail("argument-error" );
|
4549 | }
|
4550 | return cred;
|
4551 | };
|
4552 |
|
4553 | OAuthCredential.prototype.toJSON = function () {
|
4554 | return {
|
4555 | idToken: this.idToken,
|
4556 | accessToken: this.accessToken,
|
4557 | secret: this.secret,
|
4558 | nonce: this.nonce,
|
4559 | pendingToken: this.pendingToken,
|
4560 | providerId: this.providerId,
|
4561 | signInMethod: this.signInMethod
|
4562 | };
|
4563 | };
|
4564 | |
4565 |
|
4566 |
|
4567 |
|
4568 |
|
4569 |
|
4570 |
|
4571 |
|
4572 |
|
4573 | OAuthCredential.fromJSON = function (json) {
|
4574 | var obj = typeof json === 'string' ? JSON.parse(json) : json;
|
4575 | var providerId = obj.providerId, signInMethod = obj.signInMethod, rest = __rest(obj, ["providerId", "signInMethod"]);
|
4576 | if (!providerId || !signInMethod) {
|
4577 | return null;
|
4578 | }
|
4579 | var cred = new OAuthCredential(providerId, signInMethod);
|
4580 | cred.idToken = rest.idToken || undefined;
|
4581 | cred.accessToken = rest.accessToken || undefined;
|
4582 | cred.secret = rest.secret;
|
4583 | cred.nonce = rest.nonce;
|
4584 | cred.pendingToken = rest.pendingToken || null;
|
4585 | return cred;
|
4586 | };
|
4587 |
|
4588 | OAuthCredential.prototype._getIdTokenResponse = function (auth) {
|
4589 | var request = this.buildRequest();
|
4590 | return signInWithIdp(auth, request);
|
4591 | };
|
4592 |
|
4593 | OAuthCredential.prototype._linkToIdToken = function (auth, idToken) {
|
4594 | var request = this.buildRequest();
|
4595 | request.idToken = idToken;
|
4596 | return signInWithIdp(auth, request);
|
4597 | };
|
4598 |
|
4599 | OAuthCredential.prototype._getReauthenticationResolver = function (auth) {
|
4600 | var request = this.buildRequest();
|
4601 | request.autoCreate = false;
|
4602 | return signInWithIdp(auth, request);
|
4603 | };
|
4604 | OAuthCredential.prototype.buildRequest = function () {
|
4605 | var request = {
|
4606 | requestUri: IDP_REQUEST_URI$1,
|
4607 | returnSecureToken: true
|
4608 | };
|
4609 | if (this.pendingToken) {
|
4610 | request.pendingToken = this.pendingToken;
|
4611 | }
|
4612 | else {
|
4613 | var postBody = {};
|
4614 | if (this.idToken) {
|
4615 | postBody['id_token'] = this.idToken;
|
4616 | }
|
4617 | if (this.accessToken) {
|
4618 | postBody['access_token'] = this.accessToken;
|
4619 | }
|
4620 | if (this.secret) {
|
4621 | postBody['oauth_token_secret'] = this.secret;
|
4622 | }
|
4623 | postBody['providerId'] = this.providerId;
|
4624 | if (this.nonce && !this.pendingToken) {
|
4625 | postBody['nonce'] = this.nonce;
|
4626 | }
|
4627 | request.postBody = querystring(postBody);
|
4628 | }
|
4629 | return request;
|
4630 | };
|
4631 | return OAuthCredential;
|
4632 | }(AuthCredential));
|
4633 |
|
4634 |
|
4635 |
|
4636 |
|
4637 |
|
4638 |
|
4639 |
|
4640 |
|
4641 |
|
4642 |
|
4643 |
|
4644 |
|
4645 |
|
4646 |
|
4647 |
|
4648 |
|
4649 |
|
4650 | var _a;
|
4651 | function sendPhoneVerificationCode(auth, request) {
|
4652 | return __awaiter(this, void 0, void 0, function () {
|
4653 | return __generator(this, function (_a) {
|
4654 | return [2 , _performApiRequest(auth, "POST" , "/v1/accounts:sendVerificationCode" , _addTidIfNecessary(auth, request))];
|
4655 | });
|
4656 | });
|
4657 | }
|
4658 | function signInWithPhoneNumber(auth, request) {
|
4659 | return __awaiter(this, void 0, void 0, function () {
|
4660 | return __generator(this, function (_a) {
|
4661 | return [2 , _performSignInRequest(auth, "POST" , "/v1/accounts:signInWithPhoneNumber" , _addTidIfNecessary(auth, request))];
|
4662 | });
|
4663 | });
|
4664 | }
|
4665 | function linkWithPhoneNumber(auth, request) {
|
4666 | return __awaiter(this, void 0, void 0, function () {
|
4667 | var response;
|
4668 | return __generator(this, function (_a) {
|
4669 | switch (_a.label) {
|
4670 | case 0: return [4 , _performSignInRequest(auth, "POST" , "/v1/accounts:signInWithPhoneNumber" , _addTidIfNecessary(auth, request))];
|
4671 | case 1:
|
4672 | response = _a.sent();
|
4673 | if (response.temporaryProof) {
|
4674 | throw _makeTaggedError(auth, "account-exists-with-different-credential" , response);
|
4675 | }
|
4676 | return [2 , response];
|
4677 | }
|
4678 | });
|
4679 | });
|
4680 | }
|
4681 | var VERIFY_PHONE_NUMBER_FOR_EXISTING_ERROR_MAP_ = (_a = {},
|
4682 | _a["USER_NOT_FOUND" ] = "user-not-found" ,
|
4683 | _a);
|
4684 | function verifyPhoneNumberForExisting(auth, request) {
|
4685 | return __awaiter(this, void 0, void 0, function () {
|
4686 | var apiRequest;
|
4687 | return __generator(this, function (_a) {
|
4688 | apiRequest = __assign(__assign({}, request), { operation: 'REAUTH' });
|
4689 | return [2 , _performSignInRequest(auth, "POST" , "/v1/accounts:signInWithPhoneNumber" , _addTidIfNecessary(auth, apiRequest), VERIFY_PHONE_NUMBER_FOR_EXISTING_ERROR_MAP_)];
|
4690 | });
|
4691 | });
|
4692 | }
|
4693 |
|
4694 |
|
4695 |
|
4696 |
|
4697 |
|
4698 |
|
4699 |
|
4700 |
|
4701 |
|
4702 |
|
4703 |
|
4704 |
|
4705 |
|
4706 |
|
4707 |
|
4708 |
|
4709 |
|
4710 |
|
4711 |
|
4712 |
|
4713 |
|
4714 |
|
4715 | var PhoneAuthCredential = (function (_super) {
|
4716 | __extends(PhoneAuthCredential, _super);
|
4717 | function PhoneAuthCredential(params) {
|
4718 | var _this = _super.call(this, "phone" , "phone" ) || this;
|
4719 | _this.params = params;
|
4720 | return _this;
|
4721 | }
|
4722 |
|
4723 | PhoneAuthCredential._fromVerification = function (verificationId, verificationCode) {
|
4724 | return new PhoneAuthCredential({ verificationId: verificationId, verificationCode: verificationCode });
|
4725 | };
|
4726 |
|
4727 | PhoneAuthCredential._fromTokenResponse = function (phoneNumber, temporaryProof) {
|
4728 | return new PhoneAuthCredential({ phoneNumber: phoneNumber, temporaryProof: temporaryProof });
|
4729 | };
|
4730 |
|
4731 | PhoneAuthCredential.prototype._getIdTokenResponse = function (auth) {
|
4732 | return signInWithPhoneNumber(auth, this._makeVerificationRequest());
|
4733 | };
|
4734 |
|
4735 | PhoneAuthCredential.prototype._linkToIdToken = function (auth, idToken) {
|
4736 | return linkWithPhoneNumber(auth, __assign({ idToken: idToken }, this._makeVerificationRequest()));
|
4737 | };
|
4738 |
|
4739 | PhoneAuthCredential.prototype._getReauthenticationResolver = function (auth) {
|
4740 | return verifyPhoneNumberForExisting(auth, this._makeVerificationRequest());
|
4741 | };
|
4742 |
|
4743 | PhoneAuthCredential.prototype._makeVerificationRequest = function () {
|
4744 | var _a = this.params, temporaryProof = _a.temporaryProof, phoneNumber = _a.phoneNumber, verificationId = _a.verificationId, verificationCode = _a.verificationCode;
|
4745 | if (temporaryProof && phoneNumber) {
|
4746 | return { temporaryProof: temporaryProof, phoneNumber: phoneNumber };
|
4747 | }
|
4748 | return {
|
4749 | sessionInfo: verificationId,
|
4750 | code: verificationCode
|
4751 | };
|
4752 | };
|
4753 |
|
4754 | PhoneAuthCredential.prototype.toJSON = function () {
|
4755 | var obj = {
|
4756 | providerId: this.providerId
|
4757 | };
|
4758 | if (this.params.phoneNumber) {
|
4759 | obj.phoneNumber = this.params.phoneNumber;
|
4760 | }
|
4761 | if (this.params.temporaryProof) {
|
4762 | obj.temporaryProof = this.params.temporaryProof;
|
4763 | }
|
4764 | if (this.params.verificationCode) {
|
4765 | obj.verificationCode = this.params.verificationCode;
|
4766 | }
|
4767 | if (this.params.verificationId) {
|
4768 | obj.verificationId = this.params.verificationId;
|
4769 | }
|
4770 | return obj;
|
4771 | };
|
4772 |
|
4773 | PhoneAuthCredential.fromJSON = function (json) {
|
4774 | if (typeof json === 'string') {
|
4775 | json = JSON.parse(json);
|
4776 | }
|
4777 | var _a = json, verificationId = _a.verificationId, verificationCode = _a.verificationCode, phoneNumber = _a.phoneNumber, temporaryProof = _a.temporaryProof;
|
4778 | if (!verificationCode &&
|
4779 | !verificationId &&
|
4780 | !phoneNumber &&
|
4781 | !temporaryProof) {
|
4782 | return null;
|
4783 | }
|
4784 | return new PhoneAuthCredential({
|
4785 | verificationId: verificationId,
|
4786 | verificationCode: verificationCode,
|
4787 | phoneNumber: phoneNumber,
|
4788 | temporaryProof: temporaryProof
|
4789 | });
|
4790 | };
|
4791 | return PhoneAuthCredential;
|
4792 | }(AuthCredential));
|
4793 |
|
4794 |
|
4795 |
|
4796 |
|
4797 |
|
4798 |
|
4799 |
|
4800 |
|
4801 |
|
4802 |
|
4803 |
|
4804 |
|
4805 |
|
4806 |
|
4807 |
|
4808 |
|
4809 |
|
4810 |
|
4811 |
|
4812 |
|
4813 |
|
4814 |
|
4815 | function parseMode(mode) {
|
4816 | switch (mode) {
|
4817 | case 'recoverEmail':
|
4818 | return "RECOVER_EMAIL" ;
|
4819 | case 'resetPassword':
|
4820 | return "PASSWORD_RESET" ;
|
4821 | case 'signIn':
|
4822 | return "EMAIL_SIGNIN" ;
|
4823 | case 'verifyEmail':
|
4824 | return "VERIFY_EMAIL" ;
|
4825 | case 'verifyAndChangeEmail':
|
4826 | return "VERIFY_AND_CHANGE_EMAIL" ;
|
4827 | case 'revertSecondFactorAddition':
|
4828 | return "REVERT_SECOND_FACTOR_ADDITION" ;
|
4829 | default:
|
4830 | return null;
|
4831 | }
|
4832 | }
|
4833 |
|
4834 |
|
4835 |
|
4836 |
|
4837 |
|
4838 | function parseDeepLink(url) {
|
4839 | var link = querystringDecode(extractQuerystring(url))['link'];
|
4840 |
|
4841 | var doubleDeepLink = link
|
4842 | ? querystringDecode(extractQuerystring(link))['deep_link_id']
|
4843 | : null;
|
4844 |
|
4845 | var iOSDeepLink = querystringDecode(extractQuerystring(url))['deep_link_id'];
|
4846 | var iOSDoubleDeepLink = iOSDeepLink
|
4847 | ? querystringDecode(extractQuerystring(iOSDeepLink))['link']
|
4848 | : null;
|
4849 | return iOSDoubleDeepLink || iOSDeepLink || doubleDeepLink || link || url;
|
4850 | }
|
4851 |
|
4852 |
|
4853 |
|
4854 |
|
4855 |
|
4856 |
|
4857 | var ActionCodeURL = (function () {
|
4858 | |
4859 |
|
4860 |
|
4861 |
|
4862 |
|
4863 |
|
4864 | function ActionCodeURL(actionLink) {
|
4865 | var _a, _b, _c, _d, _e, _f;
|
4866 | var searchParams = querystringDecode(extractQuerystring(actionLink));
|
4867 | var apiKey = (_a = searchParams["apiKey" ]) !== null && _a !== void 0 ? _a : null;
|
4868 | var code = (_b = searchParams["oobCode" ]) !== null && _b !== void 0 ? _b : null;
|
4869 | var operation = parseMode((_c = searchParams["mode" ]) !== null && _c !== void 0 ? _c : null);
|
4870 |
|
4871 | _assert(apiKey && code && operation, "argument-error" );
|
4872 | this.apiKey = apiKey;
|
4873 | this.operation = operation;
|
4874 | this.code = code;
|
4875 | this.continueUrl = (_d = searchParams["continueUrl" ]) !== null && _d !== void 0 ? _d : null;
|
4876 | this.languageCode = (_e = searchParams["languageCode" ]) !== null && _e !== void 0 ? _e : null;
|
4877 | this.tenantId = (_f = searchParams["tenantId" ]) !== null && _f !== void 0 ? _f : null;
|
4878 | }
|
4879 | |
4880 |
|
4881 |
|
4882 |
|
4883 |
|
4884 |
|
4885 |
|
4886 |
|
4887 |
|
4888 | ActionCodeURL.parseLink = function (link) {
|
4889 | var actionLink = parseDeepLink(link);
|
4890 | try {
|
4891 | return new ActionCodeURL(actionLink);
|
4892 | }
|
4893 | catch (_a) {
|
4894 | return null;
|
4895 | }
|
4896 | };
|
4897 | return ActionCodeURL;
|
4898 | }());
|
4899 |
|
4900 |
|
4901 |
|
4902 |
|
4903 |
|
4904 |
|
4905 | function parseActionCodeURL(link) {
|
4906 | return ActionCodeURL.parseLink(link);
|
4907 | }
|
4908 |
|
4909 |
|
4910 |
|
4911 |
|
4912 |
|
4913 |
|
4914 |
|
4915 |
|
4916 |
|
4917 |
|
4918 |
|
4919 |
|
4920 |
|
4921 |
|
4922 |
|
4923 |
|
4924 |
|
4925 |
|
4926 |
|
4927 |
|
4928 |
|
4929 |
|
4930 | var EmailAuthProvider = (function () {
|
4931 | function EmailAuthProvider() {
|
4932 | |
4933 |
|
4934 |
|
4935 | this.providerId = EmailAuthProvider.PROVIDER_ID;
|
4936 | }
|
4937 | |
4938 |
|
4939 |
|
4940 |
|
4941 |
|
4942 |
|
4943 |
|
4944 |
|
4945 |
|
4946 |
|
4947 |
|
4948 |
|
4949 |
|
4950 |
|
4951 |
|
4952 |
|
4953 |
|
4954 |
|
4955 | EmailAuthProvider.credential = function (email, password) {
|
4956 | return EmailAuthCredential._fromEmailAndPassword(email, password);
|
4957 | };
|
4958 | |
4959 |
|
4960 |
|
4961 |
|
4962 |
|
4963 |
|
4964 |
|
4965 |
|
4966 |
|
4967 |
|
4968 |
|
4969 |
|
4970 |
|
4971 |
|
4972 |
|
4973 |
|
4974 |
|
4975 |
|
4976 |
|
4977 |
|
4978 |
|
4979 |
|
4980 | EmailAuthProvider.credentialWithLink = function (email, emailLink) {
|
4981 | var actionCodeUrl = ActionCodeURL.parseLink(emailLink);
|
4982 | _assert(actionCodeUrl, "argument-error" );
|
4983 | return EmailAuthCredential._fromEmailAndCode(email, actionCodeUrl.code, actionCodeUrl.tenantId);
|
4984 | };
|
4985 | |
4986 |
|
4987 |
|
4988 | EmailAuthProvider.PROVIDER_ID = "password" ;
|
4989 | |
4990 |
|
4991 |
|
4992 | EmailAuthProvider.EMAIL_PASSWORD_SIGN_IN_METHOD = "password" ;
|
4993 | |
4994 |
|
4995 |
|
4996 | EmailAuthProvider.EMAIL_LINK_SIGN_IN_METHOD = "emailLink" ;
|
4997 | return EmailAuthProvider;
|
4998 | }());
|
4999 |
|
5000 |
|
5001 |
|
5002 |
|
5003 |
|
5004 |
|
5005 |
|
5006 |
|
5007 |
|
5008 |
|
5009 |
|
5010 |
|
5011 |
|
5012 |
|
5013 |
|
5014 |
|
5015 |
|
5016 |
|
5017 |
|
5018 |
|
5019 |
|
5020 |
|
5021 |
|
5022 |
|
5023 | var FederatedAuthProvider = (function () {
|
5024 | |
5025 |
|
5026 |
|
5027 |
|
5028 |
|
5029 | function FederatedAuthProvider(providerId) {
|
5030 | this.providerId = providerId;
|
5031 |
|
5032 | this.defaultLanguageCode = null;
|
5033 |
|
5034 | this.customParameters = {};
|
5035 | }
|
5036 | |
5037 |
|
5038 |
|
5039 |
|
5040 |
|
5041 | FederatedAuthProvider.prototype.setDefaultLanguage = function (languageCode) {
|
5042 | this.defaultLanguageCode = languageCode;
|
5043 | };
|
5044 | |
5045 |
|
5046 |
|
5047 |
|
5048 |
|
5049 |
|
5050 |
|
5051 |
|
5052 |
|
5053 |
|
5054 | FederatedAuthProvider.prototype.setCustomParameters = function (customOAuthParameters) {
|
5055 | this.customParameters = customOAuthParameters;
|
5056 | return this;
|
5057 | };
|
5058 | |
5059 |
|
5060 |
|
5061 | FederatedAuthProvider.prototype.getCustomParameters = function () {
|
5062 | return this.customParameters;
|
5063 | };
|
5064 | return FederatedAuthProvider;
|
5065 | }());
|
5066 |
|
5067 |
|
5068 |
|
5069 |
|
5070 |
|
5071 |
|
5072 |
|
5073 |
|
5074 |
|
5075 |
|
5076 |
|
5077 |
|
5078 |
|
5079 |
|
5080 |
|
5081 |
|
5082 |
|
5083 |
|
5084 |
|
5085 |
|
5086 |
|
5087 |
|
5088 |
|
5089 | var BaseOAuthProvider = (function (_super) {
|
5090 | __extends(BaseOAuthProvider, _super);
|
5091 | function BaseOAuthProvider() {
|
5092 | var _this = _super !== null && _super.apply(this, arguments) || this;
|
5093 |
|
5094 | _this.scopes = [];
|
5095 | return _this;
|
5096 | }
|
5097 | |
5098 |
|
5099 |
|
5100 |
|
5101 |
|
5102 | BaseOAuthProvider.prototype.addScope = function (scope) {
|
5103 |
|
5104 | if (!this.scopes.includes(scope)) {
|
5105 | this.scopes.push(scope);
|
5106 | }
|
5107 | return this;
|
5108 | };
|
5109 | |
5110 |
|
5111 |
|
5112 | BaseOAuthProvider.prototype.getScopes = function () {
|
5113 | return __spreadArray([], this.scopes);
|
5114 | };
|
5115 | return BaseOAuthProvider;
|
5116 | }(FederatedAuthProvider));
|
5117 |
|
5118 |
|
5119 |
|
5120 |
|
5121 |
|
5122 |
|
5123 |
|
5124 |
|
5125 |
|
5126 |
|
5127 |
|
5128 |
|
5129 |
|
5130 |
|
5131 |
|
5132 |
|
5133 |
|
5134 |
|
5135 |
|
5136 |
|
5137 |
|
5138 |
|
5139 |
|
5140 |
|
5141 |
|
5142 |
|
5143 |
|
5144 |
|
5145 |
|
5146 |
|
5147 |
|
5148 |
|
5149 |
|
5150 |
|
5151 |
|
5152 |
|
5153 |
|
5154 |
|
5155 |
|
5156 |
|
5157 | var OAuthProvider = (function (_super) {
|
5158 | __extends(OAuthProvider, _super);
|
5159 | function OAuthProvider() {
|
5160 | return _super !== null && _super.apply(this, arguments) || this;
|
5161 | }
|
5162 | |
5163 |
|
5164 |
|
5165 |
|
5166 | OAuthProvider.credentialFromJSON = function (json) {
|
5167 | var obj = typeof json === 'string' ? JSON.parse(json) : json;
|
5168 | _assert('providerId' in obj && 'signInMethod' in obj, "argument-error" );
|
5169 | return OAuthCredential._fromParams(obj);
|
5170 | };
|
5171 | |
5172 |
|
5173 |
|
5174 |
|
5175 |
|
5176 |
|
5177 |
|
5178 |
|
5179 |
|
5180 |
|
5181 |
|
5182 |
|
5183 |
|
5184 |
|
5185 |
|
5186 |
|
5187 |
|
5188 |
|
5189 |
|
5190 |
|
5191 |
|
5192 | OAuthProvider.prototype.credential = function (params) {
|
5193 | return this._credential(__assign(__assign({}, params), { nonce: params.rawNonce }));
|
5194 | };
|
5195 |
|
5196 | OAuthProvider.prototype._credential = function (params) {
|
5197 | _assert(params.idToken || params.accessToken, "argument-error" );
|
5198 |
|
5199 | return OAuthCredential._fromParams(__assign(__assign({}, params), { providerId: this.providerId, signInMethod: this.providerId }));
|
5200 | };
|
5201 | |
5202 |
|
5203 |
|
5204 |
|
5205 |
|
5206 | OAuthProvider.credentialFromResult = function (userCredential) {
|
5207 | return OAuthProvider.oauthCredentialFromTaggedObject(userCredential);
|
5208 | };
|
5209 | |
5210 |
|
5211 |
|
5212 |
|
5213 |
|
5214 |
|
5215 | OAuthProvider.credentialFromError = function (error) {
|
5216 | return OAuthProvider.oauthCredentialFromTaggedObject((error.customData || {}));
|
5217 | };
|
5218 | OAuthProvider.oauthCredentialFromTaggedObject = function (_a) {
|
5219 | var tokenResponse = _a._tokenResponse;
|
5220 | if (!tokenResponse) {
|
5221 | return null;
|
5222 | }
|
5223 | var _b = tokenResponse, oauthIdToken = _b.oauthIdToken, oauthAccessToken = _b.oauthAccessToken, oauthTokenSecret = _b.oauthTokenSecret, pendingToken = _b.pendingToken, nonce = _b.nonce, providerId = _b.providerId;
|
5224 | if (!oauthAccessToken &&
|
5225 | !oauthTokenSecret &&
|
5226 | !oauthIdToken &&
|
5227 | !pendingToken) {
|
5228 | return null;
|
5229 | }
|
5230 | if (!providerId) {
|
5231 | return null;
|
5232 | }
|
5233 | try {
|
5234 | return new OAuthProvider(providerId)._credential({
|
5235 | idToken: oauthIdToken,
|
5236 | accessToken: oauthAccessToken,
|
5237 | nonce: nonce,
|
5238 | pendingToken: pendingToken
|
5239 | });
|
5240 | }
|
5241 | catch (e) {
|
5242 | return null;
|
5243 | }
|
5244 | };
|
5245 | return OAuthProvider;
|
5246 | }(BaseOAuthProvider));
|
5247 |
|
5248 |
|
5249 |
|
5250 |
|
5251 |
|
5252 |
|
5253 |
|
5254 |
|
5255 |
|
5256 |
|
5257 |
|
5258 |
|
5259 |
|
5260 |
|
5261 |
|
5262 |
|
5263 |
|
5264 |
|
5265 |
|
5266 |
|
5267 |
|
5268 |
|
5269 |
|
5270 |
|
5271 |
|
5272 |
|
5273 |
|
5274 |
|
5275 |
|
5276 |
|
5277 |
|
5278 |
|
5279 |
|
5280 |
|
5281 |
|
5282 |
|
5283 |
|
5284 |
|
5285 |
|
5286 |
|
5287 |
|
5288 |
|
5289 |
|
5290 |
|
5291 |
|
5292 |
|
5293 |
|
5294 |
|
5295 |
|
5296 |
|
5297 |
|
5298 |
|
5299 |
|
5300 |
|
5301 |
|
5302 |
|
5303 | var FacebookAuthProvider = (function (_super) {
|
5304 | __extends(FacebookAuthProvider, _super);
|
5305 | function FacebookAuthProvider() {
|
5306 | return _super.call(this, "facebook.com" ) || this;
|
5307 | }
|
5308 | |
5309 |
|
5310 |
|
5311 |
|
5312 |
|
5313 |
|
5314 |
|
5315 |
|
5316 |
|
5317 |
|
5318 |
|
5319 |
|
5320 | FacebookAuthProvider.credential = function (accessToken) {
|
5321 | return OAuthCredential._fromParams({
|
5322 | providerId: FacebookAuthProvider.PROVIDER_ID,
|
5323 | signInMethod: FacebookAuthProvider.FACEBOOK_SIGN_IN_METHOD,
|
5324 | accessToken: accessToken
|
5325 | });
|
5326 | };
|
5327 | |
5328 |
|
5329 |
|
5330 |
|
5331 |
|
5332 | FacebookAuthProvider.credentialFromResult = function (userCredential) {
|
5333 | return FacebookAuthProvider.credentialFromTaggedObject(userCredential);
|
5334 | };
|
5335 | |
5336 |
|
5337 |
|
5338 |
|
5339 |
|
5340 |
|
5341 | FacebookAuthProvider.credentialFromError = function (error) {
|
5342 | return FacebookAuthProvider.credentialFromTaggedObject((error.customData || {}));
|
5343 | };
|
5344 | FacebookAuthProvider.credentialFromTaggedObject = function (_a) {
|
5345 | var tokenResponse = _a._tokenResponse;
|
5346 | if (!tokenResponse || !('oauthAccessToken' in tokenResponse)) {
|
5347 | return null;
|
5348 | }
|
5349 | if (!tokenResponse.oauthAccessToken) {
|
5350 | return null;
|
5351 | }
|
5352 | try {
|
5353 | return FacebookAuthProvider.credential(tokenResponse.oauthAccessToken);
|
5354 | }
|
5355 | catch (_b) {
|
5356 | return null;
|
5357 | }
|
5358 | };
|
5359 |
|
5360 | FacebookAuthProvider.FACEBOOK_SIGN_IN_METHOD = "facebook.com" ;
|
5361 |
|
5362 | FacebookAuthProvider.PROVIDER_ID = "facebook.com" ;
|
5363 | return FacebookAuthProvider;
|
5364 | }(BaseOAuthProvider));
|
5365 |
|
5366 |
|
5367 |
|
5368 |
|
5369 |
|
5370 |
|
5371 |
|
5372 |
|
5373 |
|
5374 |
|
5375 |
|
5376 |
|
5377 |
|
5378 |
|
5379 |
|
5380 |
|
5381 |
|
5382 |
|
5383 |
|
5384 |
|
5385 |
|
5386 |
|
5387 |
|
5388 |
|
5389 |
|
5390 |
|
5391 |
|
5392 |
|
5393 |
|
5394 |
|
5395 |
|
5396 |
|
5397 |
|
5398 |
|
5399 |
|
5400 |
|
5401 |
|
5402 |
|
5403 |
|
5404 |
|
5405 |
|
5406 |
|
5407 |
|
5408 |
|
5409 |
|
5410 |
|
5411 |
|
5412 |
|
5413 |
|
5414 |
|
5415 |
|
5416 |
|
5417 |
|
5418 |
|
5419 |
|
5420 |
|
5421 |
|
5422 |
|
5423 | var GoogleAuthProvider = (function (_super) {
|
5424 | __extends(GoogleAuthProvider, _super);
|
5425 | function GoogleAuthProvider() {
|
5426 | var _this = _super.call(this, "google.com" ) || this;
|
5427 | _this.addScope('profile');
|
5428 | return _this;
|
5429 | }
|
5430 | |
5431 |
|
5432 |
|
5433 |
|
5434 |
|
5435 |
|
5436 |
|
5437 |
|
5438 |
|
5439 |
|
5440 |
|
5441 |
|
5442 |
|
5443 | GoogleAuthProvider.credential = function (idToken, accessToken) {
|
5444 | return OAuthCredential._fromParams({
|
5445 | providerId: GoogleAuthProvider.PROVIDER_ID,
|
5446 | signInMethod: GoogleAuthProvider.GOOGLE_SIGN_IN_METHOD,
|
5447 | idToken: idToken,
|
5448 | accessToken: accessToken
|
5449 | });
|
5450 | };
|
5451 | |
5452 |
|
5453 |
|
5454 |
|
5455 |
|
5456 | GoogleAuthProvider.credentialFromResult = function (userCredential) {
|
5457 | return GoogleAuthProvider.credentialFromTaggedObject(userCredential);
|
5458 | };
|
5459 | |
5460 |
|
5461 |
|
5462 |
|
5463 |
|
5464 |
|
5465 | GoogleAuthProvider.credentialFromError = function (error) {
|
5466 | return GoogleAuthProvider.credentialFromTaggedObject((error.customData || {}));
|
5467 | };
|
5468 | GoogleAuthProvider.credentialFromTaggedObject = function (_a) {
|
5469 | var tokenResponse = _a._tokenResponse;
|
5470 | if (!tokenResponse) {
|
5471 | return null;
|
5472 | }
|
5473 | var _b = tokenResponse, oauthIdToken = _b.oauthIdToken, oauthAccessToken = _b.oauthAccessToken;
|
5474 | if (!oauthIdToken && !oauthAccessToken) {
|
5475 |
|
5476 | return null;
|
5477 | }
|
5478 | try {
|
5479 | return GoogleAuthProvider.credential(oauthIdToken, oauthAccessToken);
|
5480 | }
|
5481 | catch (_c) {
|
5482 | return null;
|
5483 | }
|
5484 | };
|
5485 |
|
5486 | GoogleAuthProvider.GOOGLE_SIGN_IN_METHOD = "google.com" ;
|
5487 |
|
5488 | GoogleAuthProvider.PROVIDER_ID = "google.com" ;
|
5489 | return GoogleAuthProvider;
|
5490 | }(BaseOAuthProvider));
|
5491 |
|
5492 |
|
5493 |
|
5494 |
|
5495 |
|
5496 |
|
5497 |
|
5498 |
|
5499 |
|
5500 |
|
5501 |
|
5502 |
|
5503 |
|
5504 |
|
5505 |
|
5506 |
|
5507 |
|
5508 |
|
5509 |
|
5510 |
|
5511 |
|
5512 |
|
5513 |
|
5514 |
|
5515 |
|
5516 |
|
5517 |
|
5518 |
|
5519 |
|
5520 |
|
5521 |
|
5522 |
|
5523 |
|
5524 |
|
5525 |
|
5526 |
|
5527 |
|
5528 |
|
5529 |
|
5530 |
|
5531 |
|
5532 |
|
5533 |
|
5534 |
|
5535 |
|
5536 |
|
5537 |
|
5538 |
|
5539 |
|
5540 |
|
5541 |
|
5542 |
|
5543 |
|
5544 |
|
5545 |
|
5546 |
|
5547 |
|
5548 |
|
5549 |
|
5550 | var GithubAuthProvider = (function (_super) {
|
5551 | __extends(GithubAuthProvider, _super);
|
5552 | function GithubAuthProvider() {
|
5553 | return _super.call(this, "github.com" ) || this;
|
5554 | }
|
5555 | |
5556 |
|
5557 |
|
5558 |
|
5559 |
|
5560 | GithubAuthProvider.credential = function (accessToken) {
|
5561 | return OAuthCredential._fromParams({
|
5562 | providerId: GithubAuthProvider.PROVIDER_ID,
|
5563 | signInMethod: GithubAuthProvider.GITHUB_SIGN_IN_METHOD,
|
5564 | accessToken: accessToken
|
5565 | });
|
5566 | };
|
5567 | |
5568 |
|
5569 |
|
5570 |
|
5571 |
|
5572 | GithubAuthProvider.credentialFromResult = function (userCredential) {
|
5573 | return GithubAuthProvider.credentialFromTaggedObject(userCredential);
|
5574 | };
|
5575 | |
5576 |
|
5577 |
|
5578 |
|
5579 |
|
5580 |
|
5581 | GithubAuthProvider.credentialFromError = function (error) {
|
5582 | return GithubAuthProvider.credentialFromTaggedObject((error.customData || {}));
|
5583 | };
|
5584 | GithubAuthProvider.credentialFromTaggedObject = function (_a) {
|
5585 | var tokenResponse = _a._tokenResponse;
|
5586 | if (!tokenResponse || !('oauthAccessToken' in tokenResponse)) {
|
5587 | return null;
|
5588 | }
|
5589 | if (!tokenResponse.oauthAccessToken) {
|
5590 | return null;
|
5591 | }
|
5592 | try {
|
5593 | return GithubAuthProvider.credential(tokenResponse.oauthAccessToken);
|
5594 | }
|
5595 | catch (_b) {
|
5596 | return null;
|
5597 | }
|
5598 | };
|
5599 |
|
5600 | GithubAuthProvider.GITHUB_SIGN_IN_METHOD = "github.com" ;
|
5601 |
|
5602 | GithubAuthProvider.PROVIDER_ID = "github.com" ;
|
5603 | return GithubAuthProvider;
|
5604 | }(BaseOAuthProvider));
|
5605 |
|
5606 |
|
5607 |
|
5608 |
|
5609 |
|
5610 |
|
5611 |
|
5612 |
|
5613 |
|
5614 |
|
5615 |
|
5616 |
|
5617 |
|
5618 |
|
5619 |
|
5620 |
|
5621 |
|
5622 | var IDP_REQUEST_URI = 'http://localhost';
|
5623 |
|
5624 |
|
5625 |
|
5626 | var SAMLAuthCredential = (function (_super) {
|
5627 | __extends(SAMLAuthCredential, _super);
|
5628 |
|
5629 | function SAMLAuthCredential(providerId, pendingToken) {
|
5630 | var _this = _super.call(this, providerId, providerId) || this;
|
5631 | _this.pendingToken = pendingToken;
|
5632 | return _this;
|
5633 | }
|
5634 |
|
5635 | SAMLAuthCredential.prototype._getIdTokenResponse = function (auth) {
|
5636 | var request = this.buildRequest();
|
5637 | return signInWithIdp(auth, request);
|
5638 | };
|
5639 |
|
5640 | SAMLAuthCredential.prototype._linkToIdToken = function (auth, idToken) {
|
5641 | var request = this.buildRequest();
|
5642 | request.idToken = idToken;
|
5643 | return signInWithIdp(auth, request);
|
5644 | };
|
5645 |
|
5646 | SAMLAuthCredential.prototype._getReauthenticationResolver = function (auth) {
|
5647 | var request = this.buildRequest();
|
5648 | request.autoCreate = false;
|
5649 | return signInWithIdp(auth, request);
|
5650 | };
|
5651 |
|
5652 | SAMLAuthCredential.prototype.toJSON = function () {
|
5653 | return {
|
5654 | signInMethod: this.signInMethod,
|
5655 | providerId: this.providerId,
|
5656 | pendingToken: this.pendingToken
|
5657 | };
|
5658 | };
|
5659 | |
5660 |
|
5661 |
|
5662 |
|
5663 |
|
5664 |
|
5665 |
|
5666 |
|
5667 |
|
5668 | SAMLAuthCredential.fromJSON = function (json) {
|
5669 | var obj = typeof json === 'string' ? JSON.parse(json) : json;
|
5670 | var providerId = obj.providerId, signInMethod = obj.signInMethod, pendingToken = obj.pendingToken;
|
5671 | if (!providerId ||
|
5672 | !signInMethod ||
|
5673 | !pendingToken ||
|
5674 | providerId !== signInMethod) {
|
5675 | return null;
|
5676 | }
|
5677 | return new SAMLAuthCredential(providerId, pendingToken);
|
5678 | };
|
5679 | |
5680 |
|
5681 |
|
5682 |
|
5683 |
|
5684 | SAMLAuthCredential._create = function (providerId, pendingToken) {
|
5685 | return new SAMLAuthCredential(providerId, pendingToken);
|
5686 | };
|
5687 | SAMLAuthCredential.prototype.buildRequest = function () {
|
5688 | return {
|
5689 | requestUri: IDP_REQUEST_URI,
|
5690 | returnSecureToken: true,
|
5691 | pendingToken: this.pendingToken
|
5692 | };
|
5693 | };
|
5694 | return SAMLAuthCredential;
|
5695 | }(AuthCredential));
|
5696 |
|
5697 |
|
5698 |
|
5699 |
|
5700 |
|
5701 |
|
5702 |
|
5703 |
|
5704 |
|
5705 |
|
5706 |
|
5707 |
|
5708 |
|
5709 |
|
5710 |
|
5711 |
|
5712 |
|
5713 | var SAML_PROVIDER_PREFIX = 'saml.';
|
5714 |
|
5715 |
|
5716 |
|
5717 |
|
5718 |
|
5719 | var SAMLAuthProvider = (function (_super) {
|
5720 | __extends(SAMLAuthProvider, _super);
|
5721 | |
5722 |
|
5723 |
|
5724 |
|
5725 | function SAMLAuthProvider(providerId) {
|
5726 | var _this = this;
|
5727 | _assert(providerId.startsWith(SAML_PROVIDER_PREFIX), "argument-error" );
|
5728 | _this = _super.call(this, providerId) || this;
|
5729 | return _this;
|
5730 | }
|
5731 | |
5732 |
|
5733 |
|
5734 |
|
5735 |
|
5736 |
|
5737 |
|
5738 |
|
5739 |
|
5740 |
|
5741 |
|
5742 |
|
5743 |
|
5744 |
|
5745 |
|
5746 |
|
5747 | SAMLAuthProvider.credentialFromResult = function (userCredential) {
|
5748 | return SAMLAuthProvider.samlCredentialFromTaggedObject(userCredential);
|
5749 | };
|
5750 | |
5751 |
|
5752 |
|
5753 |
|
5754 |
|
5755 |
|
5756 | SAMLAuthProvider.credentialFromError = function (error) {
|
5757 | return SAMLAuthProvider.samlCredentialFromTaggedObject((error.customData || {}));
|
5758 | };
|
5759 | |
5760 |
|
5761 |
|
5762 |
|
5763 | SAMLAuthProvider.credentialFromJSON = function (json) {
|
5764 | var credential = SAMLAuthCredential.fromJSON(json);
|
5765 | _assert(credential, "argument-error" );
|
5766 | return credential;
|
5767 | };
|
5768 | SAMLAuthProvider.samlCredentialFromTaggedObject = function (_a) {
|
5769 | var tokenResponse = _a._tokenResponse;
|
5770 | if (!tokenResponse) {
|
5771 | return null;
|
5772 | }
|
5773 | var _b = tokenResponse, pendingToken = _b.pendingToken, providerId = _b.providerId;
|
5774 | if (!pendingToken || !providerId) {
|
5775 | return null;
|
5776 | }
|
5777 | try {
|
5778 | return SAMLAuthCredential._create(providerId, pendingToken);
|
5779 | }
|
5780 | catch (e) {
|
5781 | return null;
|
5782 | }
|
5783 | };
|
5784 | return SAMLAuthProvider;
|
5785 | }(FederatedAuthProvider));
|
5786 |
|
5787 |
|
5788 |
|
5789 |
|
5790 |
|
5791 |
|
5792 |
|
5793 |
|
5794 |
|
5795 |
|
5796 |
|
5797 |
|
5798 |
|
5799 |
|
5800 |
|
5801 |
|
5802 |
|
5803 |
|
5804 |
|
5805 |
|
5806 |
|
5807 |
|
5808 |
|
5809 |
|
5810 |
|
5811 |
|
5812 |
|
5813 |
|
5814 |
|
5815 |
|
5816 |
|
5817 |
|
5818 |
|
5819 |
|
5820 |
|
5821 |
|
5822 |
|
5823 |
|
5824 |
|
5825 |
|
5826 |
|
5827 |
|
5828 |
|
5829 |
|
5830 |
|
5831 |
|
5832 |
|
5833 |
|
5834 |
|
5835 |
|
5836 |
|
5837 |
|
5838 |
|
5839 |
|
5840 |
|
5841 |
|
5842 | var TwitterAuthProvider = (function (_super) {
|
5843 | __extends(TwitterAuthProvider, _super);
|
5844 | function TwitterAuthProvider() {
|
5845 | return _super.call(this, "twitter.com" ) || this;
|
5846 | }
|
5847 | |
5848 |
|
5849 |
|
5850 |
|
5851 |
|
5852 |
|
5853 | TwitterAuthProvider.credential = function (token, secret) {
|
5854 | return OAuthCredential._fromParams({
|
5855 | providerId: TwitterAuthProvider.PROVIDER_ID,
|
5856 | signInMethod: TwitterAuthProvider.TWITTER_SIGN_IN_METHOD,
|
5857 | oauthToken: token,
|
5858 | oauthTokenSecret: secret
|
5859 | });
|
5860 | };
|
5861 | |
5862 |
|
5863 |
|
5864 |
|
5865 |
|
5866 | TwitterAuthProvider.credentialFromResult = function (userCredential) {
|
5867 | return TwitterAuthProvider.credentialFromTaggedObject(userCredential);
|
5868 | };
|
5869 | |
5870 |
|
5871 |
|
5872 |
|
5873 |
|
5874 |
|
5875 | TwitterAuthProvider.credentialFromError = function (error) {
|
5876 | return TwitterAuthProvider.credentialFromTaggedObject((error.customData || {}));
|
5877 | };
|
5878 | TwitterAuthProvider.credentialFromTaggedObject = function (_a) {
|
5879 | var tokenResponse = _a._tokenResponse;
|
5880 | if (!tokenResponse) {
|
5881 | return null;
|
5882 | }
|
5883 | var _b = tokenResponse, oauthAccessToken = _b.oauthAccessToken, oauthTokenSecret = _b.oauthTokenSecret;
|
5884 | if (!oauthAccessToken || !oauthTokenSecret) {
|
5885 | return null;
|
5886 | }
|
5887 | try {
|
5888 | return TwitterAuthProvider.credential(oauthAccessToken, oauthTokenSecret);
|
5889 | }
|
5890 | catch (_c) {
|
5891 | return null;
|
5892 | }
|
5893 | };
|
5894 |
|
5895 | TwitterAuthProvider.TWITTER_SIGN_IN_METHOD = "twitter.com" ;
|
5896 |
|
5897 | TwitterAuthProvider.PROVIDER_ID = "twitter.com" ;
|
5898 | return TwitterAuthProvider;
|
5899 | }(BaseOAuthProvider));
|
5900 |
|
5901 |
|
5902 |
|
5903 |
|
5904 |
|
5905 |
|
5906 |
|
5907 |
|
5908 |
|
5909 |
|
5910 |
|
5911 |
|
5912 |
|
5913 |
|
5914 |
|
5915 |
|
5916 |
|
5917 | function signUp(auth, request) {
|
5918 | return __awaiter(this, void 0, void 0, function () {
|
5919 | return __generator(this, function (_a) {
|
5920 | return [2 , _performSignInRequest(auth, "POST" , "/v1/accounts:signUp" , _addTidIfNecessary(auth, request))];
|
5921 | });
|
5922 | });
|
5923 | }
|
5924 |
|
5925 |
|
5926 |
|
5927 |
|
5928 |
|
5929 |
|
5930 |
|
5931 |
|
5932 |
|
5933 |
|
5934 |
|
5935 |
|
5936 |
|
5937 |
|
5938 |
|
5939 |
|
5940 |
|
5941 | var UserCredentialImpl = (function () {
|
5942 | function UserCredentialImpl(params) {
|
5943 | this.user = params.user;
|
5944 | this.providerId = params.providerId;
|
5945 | this._tokenResponse = params._tokenResponse;
|
5946 | this.operationType = params.operationType;
|
5947 | }
|
5948 | UserCredentialImpl._fromIdTokenResponse = function (auth, operationType, idTokenResponse, isAnonymous) {
|
5949 | if (isAnonymous === void 0) { isAnonymous = false; }
|
5950 | return __awaiter(this, void 0, void 0, function () {
|
5951 | var user, providerId, userCred;
|
5952 | return __generator(this, function (_a) {
|
5953 | switch (_a.label) {
|
5954 | case 0: return [4 , UserImpl._fromIdTokenResponse(auth, idTokenResponse, isAnonymous)];
|
5955 | case 1:
|
5956 | user = _a.sent();
|
5957 | providerId = providerIdForResponse(idTokenResponse);
|
5958 | userCred = new UserCredentialImpl({
|
5959 | user: user,
|
5960 | providerId: providerId,
|
5961 | _tokenResponse: idTokenResponse,
|
5962 | operationType: operationType
|
5963 | });
|
5964 | return [2 , userCred];
|
5965 | }
|
5966 | });
|
5967 | });
|
5968 | };
|
5969 | UserCredentialImpl._forOperation = function (user, operationType, response) {
|
5970 | return __awaiter(this, void 0, void 0, function () {
|
5971 | var providerId;
|
5972 | return __generator(this, function (_a) {
|
5973 | switch (_a.label) {
|
5974 | case 0: return [4 , user._updateTokensIfNecessary(response, true)];
|
5975 | case 1:
|
5976 | _a.sent();
|
5977 | providerId = providerIdForResponse(response);
|
5978 | return [2 , new UserCredentialImpl({
|
5979 | user: user,
|
5980 | providerId: providerId,
|
5981 | _tokenResponse: response,
|
5982 | operationType: operationType
|
5983 | })];
|
5984 | }
|
5985 | });
|
5986 | });
|
5987 | };
|
5988 | return UserCredentialImpl;
|
5989 | }());
|
5990 | function providerIdForResponse(response) {
|
5991 | if (response.providerId) {
|
5992 | return response.providerId;
|
5993 | }
|
5994 | if ('phoneNumber' in response) {
|
5995 | return "phone" ;
|
5996 | }
|
5997 | return null;
|
5998 | }
|
5999 |
|
6000 |
|
6001 |
|
6002 |
|
6003 |
|
6004 |
|
6005 |
|
6006 |
|
6007 |
|
6008 |
|
6009 |
|
6010 |
|
6011 |
|
6012 |
|
6013 |
|
6014 |
|
6015 |
|
6016 |
|
6017 |
|
6018 |
|
6019 |
|
6020 |
|
6021 |
|
6022 |
|
6023 |
|
6024 |
|
6025 |
|
6026 |
|
6027 | function signInAnonymously(auth) {
|
6028 | var _a;
|
6029 | return __awaiter(this, void 0, void 0, function () {
|
6030 | var authInternal, response, userCredential;
|
6031 | return __generator(this, function (_b) {
|
6032 | switch (_b.label) {
|
6033 | case 0:
|
6034 | authInternal = _castAuth(auth);
|
6035 | return [4 , authInternal._initializationPromise];
|
6036 | case 1:
|
6037 | _b.sent();
|
6038 | if ((_a = authInternal.currentUser) === null || _a === void 0 ? void 0 : _a.isAnonymous) {
|
6039 |
|
6040 | return [2 , new UserCredentialImpl({
|
6041 | user: authInternal.currentUser,
|
6042 | providerId: null,
|
6043 | operationType: "signIn"
|
6044 | })];
|
6045 | }
|
6046 | return [4 , signUp(authInternal, {
|
6047 | returnSecureToken: true
|
6048 | })];
|
6049 | case 2:
|
6050 | response = _b.sent();
|
6051 | return [4 , UserCredentialImpl._fromIdTokenResponse(authInternal, "signIn" , response, true)];
|
6052 | case 3:
|
6053 | userCredential = _b.sent();
|
6054 | return [4 , authInternal._updateCurrentUser(userCredential.user)];
|
6055 | case 4:
|
6056 | _b.sent();
|
6057 | return [2 , userCredential];
|
6058 | }
|
6059 | });
|
6060 | });
|
6061 | }
|
6062 |
|
6063 |
|
6064 |
|
6065 |
|
6066 |
|
6067 |
|
6068 |
|
6069 |
|
6070 |
|
6071 |
|
6072 |
|
6073 |
|
6074 |
|
6075 |
|
6076 |
|
6077 |
|
6078 |
|
6079 | var MultiFactorError = (function (_super) {
|
6080 | __extends(MultiFactorError, _super);
|
6081 | function MultiFactorError(auth, error, operationType, user) {
|
6082 | var _a;
|
6083 | var _this = _super.call(this, error.code, error.message) || this;
|
6084 | _this.operationType = operationType;
|
6085 | _this.user = user;
|
6086 |
|
6087 | Object.setPrototypeOf(_this, MultiFactorError.prototype);
|
6088 | _this.customData = {
|
6089 | appName: auth.name,
|
6090 | tenantId: (_a = auth.tenantId) !== null && _a !== void 0 ? _a : undefined,
|
6091 | _serverResponse: error.customData._serverResponse,
|
6092 | operationType: operationType,
|
6093 | };
|
6094 | return _this;
|
6095 | }
|
6096 | MultiFactorError._fromErrorAndOperation = function (auth, error, operationType, user) {
|
6097 | return new MultiFactorError(auth, error, operationType, user);
|
6098 | };
|
6099 | return MultiFactorError;
|
6100 | }(FirebaseError));
|
6101 | function _processCredentialSavingMfaContextIfNecessary(auth, operationType, credential, user) {
|
6102 | var idTokenProvider = operationType === "reauthenticate"
|
6103 | ? credential._getReauthenticationResolver(auth)
|
6104 | : credential._getIdTokenResponse(auth);
|
6105 | return idTokenProvider.catch(function (error) {
|
6106 | if (error.code === "auth/" + "multi-factor-auth-required" ) {
|
6107 | throw MultiFactorError._fromErrorAndOperation(auth, error, operationType, user);
|
6108 | }
|
6109 | throw error;
|
6110 | });
|
6111 | }
|
6112 |
|
6113 |
|
6114 |
|
6115 |
|
6116 |
|
6117 |
|
6118 |
|
6119 |
|
6120 |
|
6121 |
|
6122 |
|
6123 |
|
6124 |
|
6125 |
|
6126 |
|
6127 |
|
6128 |
|
6129 |
|
6130 |
|
6131 |
|
6132 | function providerDataAsNames(providerData) {
|
6133 | return new Set(providerData
|
6134 | .map(function (_a) {
|
6135 | var providerId = _a.providerId;
|
6136 | return providerId;
|
6137 | })
|
6138 | .filter(function (pid) { return !!pid; }));
|
6139 | }
|
6140 |
|
6141 |
|
6142 |
|
6143 |
|
6144 |
|
6145 |
|
6146 |
|
6147 |
|
6148 |
|
6149 |
|
6150 |
|
6151 |
|
6152 |
|
6153 |
|
6154 |
|
6155 |
|
6156 |
|
6157 |
|
6158 |
|
6159 |
|
6160 |
|
6161 |
|
6162 |
|
6163 |
|
6164 |
|
6165 | function unlink(user, providerId) {
|
6166 | return __awaiter(this, void 0, void 0, function () {
|
6167 | var userInternal, providerUserInfo, _a, _b, providersLeft;
|
6168 | var _c;
|
6169 | return __generator(this, function (_d) {
|
6170 | switch (_d.label) {
|
6171 | case 0:
|
6172 | userInternal = getModularInstance(user);
|
6173 | return [4 , _assertLinkedStatus(true, userInternal, providerId)];
|
6174 | case 1:
|
6175 | _d.sent();
|
6176 | _a = deleteLinkedAccounts;
|
6177 | _b = [userInternal.auth];
|
6178 | _c = {};
|
6179 | return [4 , userInternal.getIdToken()];
|
6180 | case 2: return [4 , _a.apply(void 0, _b.concat([(_c.idToken = _d.sent(),
|
6181 | _c.deleteProvider = [providerId],
|
6182 | _c)]))];
|
6183 | case 3:
|
6184 | providerUserInfo = (_d.sent()).providerUserInfo;
|
6185 | providersLeft = providerDataAsNames(providerUserInfo || []);
|
6186 | userInternal.providerData = userInternal.providerData.filter(function (pd) {
|
6187 | return providersLeft.has(pd.providerId);
|
6188 | });
|
6189 | if (!providersLeft.has("phone" )) {
|
6190 | userInternal.phoneNumber = null;
|
6191 | }
|
6192 | return [4 , userInternal.auth._persistUserIfCurrent(userInternal)];
|
6193 | case 4:
|
6194 | _d.sent();
|
6195 | return [2 , userInternal];
|
6196 | }
|
6197 | });
|
6198 | });
|
6199 | }
|
6200 | function _link$1(user, credential, bypassAuthState) {
|
6201 | if (bypassAuthState === void 0) { bypassAuthState = false; }
|
6202 | return __awaiter(this, void 0, void 0, function () {
|
6203 | var response, _a, _b, _c, _d, _e;
|
6204 | return __generator(this, function (_f) {
|
6205 | switch (_f.label) {
|
6206 | case 0:
|
6207 | _a = _logoutIfInvalidated;
|
6208 | _b = [user];
|
6209 | _d = (_c = credential)._linkToIdToken;
|
6210 | _e = [user.auth];
|
6211 | return [4 , user.getIdToken()];
|
6212 | case 1: return [4 , _a.apply(void 0, _b.concat([_d.apply(_c, _e.concat([_f.sent()])), bypassAuthState]))];
|
6213 | case 2:
|
6214 | response = _f.sent();
|
6215 | return [2 , UserCredentialImpl._forOperation(user, "link" , response)];
|
6216 | }
|
6217 | });
|
6218 | });
|
6219 | }
|
6220 | function _assertLinkedStatus(expected, user, provider) {
|
6221 | return __awaiter(this, void 0, void 0, function () {
|
6222 | var providerIds, code;
|
6223 | return __generator(this, function (_a) {
|
6224 | switch (_a.label) {
|
6225 | case 0: return [4 , _reloadWithoutSaving(user)];
|
6226 | case 1:
|
6227 | _a.sent();
|
6228 | providerIds = providerDataAsNames(user.providerData);
|
6229 | code = expected === false
|
6230 | ? "provider-already-linked"
|
6231 | : "no-such-provider" ;
|
6232 | _assert(providerIds.has(provider) === expected, user.auth, code);
|
6233 | return [2 ];
|
6234 | }
|
6235 | });
|
6236 | });
|
6237 | }
|
6238 |
|
6239 |
|
6240 |
|
6241 |
|
6242 |
|
6243 |
|
6244 |
|
6245 |
|
6246 |
|
6247 |
|
6248 |
|
6249 |
|
6250 |
|
6251 |
|
6252 |
|
6253 |
|
6254 |
|
6255 | function _reauthenticate(user, credential, bypassAuthState) {
|
6256 | if (bypassAuthState === void 0) { bypassAuthState = false; }
|
6257 | return __awaiter(this, void 0, void 0, function () {
|
6258 | var auth, operationType, response, parsed, localId, e_1;
|
6259 | return __generator(this, function (_a) {
|
6260 | switch (_a.label) {
|
6261 | case 0:
|
6262 | auth = user.auth;
|
6263 | operationType = "reauthenticate" ;
|
6264 | _a.label = 1;
|
6265 | case 1:
|
6266 | _a.trys.push([1, 3, , 4]);
|
6267 | return [4 , _logoutIfInvalidated(user, _processCredentialSavingMfaContextIfNecessary(auth, operationType, credential, user), bypassAuthState)];
|
6268 | case 2:
|
6269 | response = _a.sent();
|
6270 | _assert(response.idToken, auth, "internal-error" );
|
6271 | parsed = _parseToken(response.idToken);
|
6272 | _assert(parsed, auth, "internal-error" );
|
6273 | localId = parsed.sub;
|
6274 | _assert(user.uid === localId, auth, "user-mismatch" );
|
6275 | return [2 , UserCredentialImpl._forOperation(user, operationType, response)];
|
6276 | case 3:
|
6277 | e_1 = _a.sent();
|
6278 |
|
6279 | if ((e_1 === null || e_1 === void 0 ? void 0 : e_1.code) === "auth/" + "user-not-found" ) {
|
6280 | _fail(auth, "user-mismatch" );
|
6281 | }
|
6282 | throw e_1;
|
6283 | case 4: return [2 ];
|
6284 | }
|
6285 | });
|
6286 | });
|
6287 | }
|
6288 |
|
6289 |
|
6290 |
|
6291 |
|
6292 |
|
6293 |
|
6294 |
|
6295 |
|
6296 |
|
6297 |
|
6298 |
|
6299 |
|
6300 |
|
6301 |
|
6302 |
|
6303 |
|
6304 |
|
6305 | function _signInWithCredential(auth, credential, bypassAuthState) {
|
6306 | if (bypassAuthState === void 0) { bypassAuthState = false; }
|
6307 | return __awaiter(this, void 0, void 0, function () {
|
6308 | var operationType, response, userCredential;
|
6309 | return __generator(this, function (_a) {
|
6310 | switch (_a.label) {
|
6311 | case 0:
|
6312 | operationType = "signIn" ;
|
6313 | return [4 , _processCredentialSavingMfaContextIfNecessary(auth, operationType, credential)];
|
6314 | case 1:
|
6315 | response = _a.sent();
|
6316 | return [4 , UserCredentialImpl._fromIdTokenResponse(auth, operationType, response)];
|
6317 | case 2:
|
6318 | userCredential = _a.sent();
|
6319 | if (!!bypassAuthState) return [3 , 4];
|
6320 | return [4 , auth._updateCurrentUser(userCredential.user)];
|
6321 | case 3:
|
6322 | _a.sent();
|
6323 | _a.label = 4;
|
6324 | case 4: return [2 , userCredential];
|
6325 | }
|
6326 | });
|
6327 | });
|
6328 | }
|
6329 |
|
6330 |
|
6331 |
|
6332 |
|
6333 |
|
6334 |
|
6335 |
|
6336 |
|
6337 |
|
6338 |
|
6339 |
|
6340 | function signInWithCredential(auth, credential) {
|
6341 | return __awaiter(this, void 0, void 0, function () {
|
6342 | return __generator(this, function (_a) {
|
6343 | return [2 , _signInWithCredential(_castAuth(auth), credential)];
|
6344 | });
|
6345 | });
|
6346 | }
|
6347 |
|
6348 |
|
6349 |
|
6350 |
|
6351 |
|
6352 |
|
6353 |
|
6354 |
|
6355 |
|
6356 |
|
6357 |
|
6358 | function linkWithCredential(user, credential) {
|
6359 | return __awaiter(this, void 0, void 0, function () {
|
6360 | var userInternal;
|
6361 | return __generator(this, function (_a) {
|
6362 | switch (_a.label) {
|
6363 | case 0:
|
6364 | userInternal = getModularInstance(user);
|
6365 | return [4 , _assertLinkedStatus(false, userInternal, credential.providerId)];
|
6366 | case 1:
|
6367 | _a.sent();
|
6368 | return [2 , _link$1(userInternal, credential)];
|
6369 | }
|
6370 | });
|
6371 | });
|
6372 | }
|
6373 |
|
6374 |
|
6375 |
|
6376 |
|
6377 |
|
6378 |
|
6379 |
|
6380 |
|
6381 |
|
6382 |
|
6383 |
|
6384 |
|
6385 | function reauthenticateWithCredential(user, credential) {
|
6386 | return __awaiter(this, void 0, void 0, function () {
|
6387 | return __generator(this, function (_a) {
|
6388 | return [2 , _reauthenticate(getModularInstance(user), credential)];
|
6389 | });
|
6390 | });
|
6391 | }
|
6392 |
|
6393 |
|
6394 |
|
6395 |
|
6396 |
|
6397 |
|
6398 |
|
6399 |
|
6400 |
|
6401 |
|
6402 |
|
6403 |
|
6404 |
|
6405 |
|
6406 |
|
6407 |
|
6408 |
|
6409 | function signInWithCustomToken$1(auth, request) {
|
6410 | return __awaiter(this, void 0, void 0, function () {
|
6411 | return __generator(this, function (_a) {
|
6412 | return [2 , _performSignInRequest(auth, "POST" , "/v1/accounts:signInWithCustomToken" , _addTidIfNecessary(auth, request))];
|
6413 | });
|
6414 | });
|
6415 | }
|
6416 |
|
6417 |
|
6418 |
|
6419 |
|
6420 |
|
6421 |
|
6422 |
|
6423 |
|
6424 |
|
6425 |
|
6426 |
|
6427 |
|
6428 |
|
6429 |
|
6430 |
|
6431 |
|
6432 |
|
6433 |
|
6434 |
|
6435 |
|
6436 |
|
6437 |
|
6438 |
|
6439 |
|
6440 |
|
6441 |
|
6442 |
|
6443 |
|
6444 |
|
6445 |
|
6446 |
|
6447 |
|
6448 |
|
6449 | function signInWithCustomToken(auth, customToken) {
|
6450 | return __awaiter(this, void 0, void 0, function () {
|
6451 | var authInternal, response, cred;
|
6452 | return __generator(this, function (_a) {
|
6453 | switch (_a.label) {
|
6454 | case 0:
|
6455 | authInternal = _castAuth(auth);
|
6456 | return [4 , signInWithCustomToken$1(authInternal, {
|
6457 | token: customToken,
|
6458 | returnSecureToken: true
|
6459 | })];
|
6460 | case 1:
|
6461 | response = _a.sent();
|
6462 | return [4 , UserCredentialImpl._fromIdTokenResponse(authInternal, "signIn" , response)];
|
6463 | case 2:
|
6464 | cred = _a.sent();
|
6465 | return [4 , authInternal._updateCurrentUser(cred.user)];
|
6466 | case 3:
|
6467 | _a.sent();
|
6468 | return [2 , cred];
|
6469 | }
|
6470 | });
|
6471 | });
|
6472 | }
|
6473 |
|
6474 |
|
6475 |
|
6476 |
|
6477 |
|
6478 |
|
6479 |
|
6480 |
|
6481 |
|
6482 |
|
6483 |
|
6484 |
|
6485 |
|
6486 |
|
6487 |
|
6488 |
|
6489 |
|
6490 | var MultiFactorInfoImpl = (function () {
|
6491 | function MultiFactorInfoImpl(factorId, response) {
|
6492 | this.factorId = factorId;
|
6493 | this.uid = response.mfaEnrollmentId;
|
6494 | this.enrollmentTime = new Date(response.enrolledAt).toUTCString();
|
6495 | this.displayName = response.displayName;
|
6496 | }
|
6497 | MultiFactorInfoImpl._fromServerResponse = function (auth, enrollment) {
|
6498 | if ('phoneInfo' in enrollment) {
|
6499 | return PhoneMultiFactorInfoImpl._fromServerResponse(auth, enrollment);
|
6500 | }
|
6501 | return _fail(auth, "internal-error" );
|
6502 | };
|
6503 | return MultiFactorInfoImpl;
|
6504 | }());
|
6505 | var PhoneMultiFactorInfoImpl = (function (_super) {
|
6506 | __extends(PhoneMultiFactorInfoImpl, _super);
|
6507 | function PhoneMultiFactorInfoImpl(response) {
|
6508 | var _this = _super.call(this, "phone" , response) || this;
|
6509 | _this.phoneNumber = response.phoneInfo;
|
6510 | return _this;
|
6511 | }
|
6512 | PhoneMultiFactorInfoImpl._fromServerResponse = function (_auth, enrollment) {
|
6513 | return new PhoneMultiFactorInfoImpl(enrollment);
|
6514 | };
|
6515 | return PhoneMultiFactorInfoImpl;
|
6516 | }(MultiFactorInfoImpl));
|
6517 |
|
6518 |
|
6519 |
|
6520 |
|
6521 |
|
6522 |
|
6523 |
|
6524 |
|
6525 |
|
6526 |
|
6527 |
|
6528 |
|
6529 |
|
6530 |
|
6531 |
|
6532 |
|
6533 |
|
6534 | function _setActionCodeSettingsOnRequest(auth, request, actionCodeSettings) {
|
6535 | var _a;
|
6536 | _assert(((_a = actionCodeSettings.url) === null || _a === void 0 ? void 0 : _a.length) > 0, auth, "invalid-continue-uri" );
|
6537 | _assert(typeof actionCodeSettings.dynamicLinkDomain === 'undefined' ||
|
6538 | actionCodeSettings.dynamicLinkDomain.length > 0, auth, "invalid-dynamic-link-domain" );
|
6539 | request.continueUrl = actionCodeSettings.url;
|
6540 | request.dynamicLinkDomain = actionCodeSettings.dynamicLinkDomain;
|
6541 | request.canHandleCodeInApp = actionCodeSettings.handleCodeInApp;
|
6542 | if (actionCodeSettings.iOS) {
|
6543 | _assert(actionCodeSettings.iOS.bundleId.length > 0, auth, "missing-ios-bundle-id" );
|
6544 | request.iOSBundleId = actionCodeSettings.iOS.bundleId;
|
6545 | }
|
6546 | if (actionCodeSettings.android) {
|
6547 | _assert(actionCodeSettings.android.packageName.length > 0, auth, "missing-android-pkg-name" );
|
6548 | request.androidInstallApp = actionCodeSettings.android.installApp;
|
6549 | request.androidMinimumVersionCode =
|
6550 | actionCodeSettings.android.minimumVersion;
|
6551 | request.androidPackageName = actionCodeSettings.android.packageName;
|
6552 | }
|
6553 | }
|
6554 |
|
6555 |
|
6556 |
|
6557 |
|
6558 |
|
6559 |
|
6560 |
|
6561 |
|
6562 |
|
6563 |
|
6564 |
|
6565 |
|
6566 |
|
6567 |
|
6568 |
|
6569 |
|
6570 |
|
6571 |
|
6572 |
|
6573 |
|
6574 |
|
6575 |
|
6576 |
|
6577 |
|
6578 |
|
6579 |
|
6580 |
|
6581 |
|
6582 |
|
6583 |
|
6584 |
|
6585 |
|
6586 |
|
6587 |
|
6588 |
|
6589 |
|
6590 |
|
6591 |
|
6592 |
|
6593 |
|
6594 |
|
6595 |
|
6596 |
|
6597 |
|
6598 |
|
6599 |
|
6600 |
|
6601 |
|
6602 |
|
6603 | function sendPasswordResetEmail(auth, email, actionCodeSettings) {
|
6604 | return __awaiter(this, void 0, void 0, function () {
|
6605 | var authModular, request;
|
6606 | return __generator(this, function (_a) {
|
6607 | switch (_a.label) {
|
6608 | case 0:
|
6609 | authModular = getModularInstance(auth);
|
6610 | request = {
|
6611 | requestType: "PASSWORD_RESET" ,
|
6612 | email: email
|
6613 | };
|
6614 | if (actionCodeSettings) {
|
6615 | _setActionCodeSettingsOnRequest(authModular, request, actionCodeSettings);
|
6616 | }
|
6617 | return [4 , sendPasswordResetEmail$1(authModular, request)];
|
6618 | case 1:
|
6619 | _a.sent();
|
6620 | return [2 ];
|
6621 | }
|
6622 | });
|
6623 | });
|
6624 | }
|
6625 |
|
6626 |
|
6627 |
|
6628 |
|
6629 |
|
6630 |
|
6631 |
|
6632 |
|
6633 |
|
6634 | function confirmPasswordReset(auth, oobCode, newPassword) {
|
6635 | return __awaiter(this, void 0, void 0, function () {
|
6636 | return __generator(this, function (_a) {
|
6637 | switch (_a.label) {
|
6638 | case 0: return [4 , resetPassword(getModularInstance(auth), {
|
6639 | oobCode: oobCode,
|
6640 | newPassword: newPassword
|
6641 | })];
|
6642 | case 1:
|
6643 | _a.sent();
|
6644 | return [2 ];
|
6645 | }
|
6646 | });
|
6647 | });
|
6648 | }
|
6649 |
|
6650 |
|
6651 |
|
6652 |
|
6653 |
|
6654 |
|
6655 |
|
6656 |
|
6657 | function applyActionCode(auth, oobCode) {
|
6658 | return __awaiter(this, void 0, void 0, function () {
|
6659 | return __generator(this, function (_a) {
|
6660 | switch (_a.label) {
|
6661 | case 0: return [4 , applyActionCode$1(getModularInstance(auth), { oobCode: oobCode })];
|
6662 | case 1:
|
6663 | _a.sent();
|
6664 | return [2 ];
|
6665 | }
|
6666 | });
|
6667 | });
|
6668 | }
|
6669 |
|
6670 |
|
6671 |
|
6672 |
|
6673 |
|
6674 |
|
6675 |
|
6676 |
|
6677 |
|
6678 |
|
6679 | function checkActionCode(auth, oobCode) {
|
6680 | return __awaiter(this, void 0, void 0, function () {
|
6681 | var authModular, response, operation, multiFactorInfo;
|
6682 | return __generator(this, function (_a) {
|
6683 | switch (_a.label) {
|
6684 | case 0:
|
6685 | authModular = getModularInstance(auth);
|
6686 | return [4 , resetPassword(authModular, { oobCode: oobCode })];
|
6687 | case 1:
|
6688 | response = _a.sent();
|
6689 | operation = response.requestType;
|
6690 | _assert(operation, authModular, "internal-error" );
|
6691 | switch (operation) {
|
6692 | case "EMAIL_SIGNIN" :
|
6693 | break;
|
6694 | case "VERIFY_AND_CHANGE_EMAIL" :
|
6695 | _assert(response.newEmail, authModular, "internal-error" );
|
6696 | break;
|
6697 | case "REVERT_SECOND_FACTOR_ADDITION" :
|
6698 | _assert(response.mfaInfo, authModular, "internal-error" );
|
6699 |
|
6700 | default:
|
6701 | _assert(response.email, authModular, "internal-error" );
|
6702 | }
|
6703 | multiFactorInfo = null;
|
6704 | if (response.mfaInfo) {
|
6705 | multiFactorInfo = MultiFactorInfoImpl._fromServerResponse(_castAuth(authModular), response.mfaInfo);
|
6706 | }
|
6707 | return [2 , {
|
6708 | data: {
|
6709 | email: (response.requestType === "VERIFY_AND_CHANGE_EMAIL"
|
6710 | ? response.newEmail
|
6711 | : response.email) || null,
|
6712 | previousEmail: (response.requestType === "VERIFY_AND_CHANGE_EMAIL"
|
6713 | ? response.email
|
6714 | : response.newEmail) || null,
|
6715 | multiFactorInfo: multiFactorInfo
|
6716 | },
|
6717 | operation: operation
|
6718 | }];
|
6719 | }
|
6720 | });
|
6721 | });
|
6722 | }
|
6723 |
|
6724 |
|
6725 |
|
6726 |
|
6727 |
|
6728 |
|
6729 |
|
6730 |
|
6731 |
|
6732 |
|
6733 | function verifyPasswordResetCode(auth, code) {
|
6734 | return __awaiter(this, void 0, void 0, function () {
|
6735 | var data;
|
6736 | return __generator(this, function (_a) {
|
6737 | switch (_a.label) {
|
6738 | case 0: return [4 , checkActionCode(getModularInstance(auth), code)];
|
6739 | case 1:
|
6740 | data = (_a.sent()).data;
|
6741 |
|
6742 | return [2 , data.email];
|
6743 | }
|
6744 | });
|
6745 | });
|
6746 | }
|
6747 |
|
6748 |
|
6749 |
|
6750 |
|
6751 |
|
6752 |
|
6753 |
|
6754 |
|
6755 |
|
6756 |
|
6757 |
|
6758 |
|
6759 |
|
6760 |
|
6761 |
|
6762 |
|
6763 |
|
6764 | function createUserWithEmailAndPassword(auth, email, password) {
|
6765 | return __awaiter(this, void 0, void 0, function () {
|
6766 | var authInternal, response, userCredential;
|
6767 | return __generator(this, function (_a) {
|
6768 | switch (_a.label) {
|
6769 | case 0:
|
6770 | authInternal = _castAuth(auth);
|
6771 | return [4 , signUp(authInternal, {
|
6772 | returnSecureToken: true,
|
6773 | email: email,
|
6774 | password: password
|
6775 | })];
|
6776 | case 1:
|
6777 | response = _a.sent();
|
6778 | return [4 , UserCredentialImpl._fromIdTokenResponse(authInternal, "signIn" , response)];
|
6779 | case 2:
|
6780 | userCredential = _a.sent();
|
6781 | return [4 , authInternal._updateCurrentUser(userCredential.user)];
|
6782 | case 3:
|
6783 | _a.sent();
|
6784 | return [2 , userCredential];
|
6785 | }
|
6786 | });
|
6787 | });
|
6788 | }
|
6789 |
|
6790 |
|
6791 |
|
6792 |
|
6793 |
|
6794 |
|
6795 |
|
6796 |
|
6797 |
|
6798 |
|
6799 |
|
6800 |
|
6801 |
|
6802 |
|
6803 |
|
6804 |
|
6805 | function signInWithEmailAndPassword(auth, email, password) {
|
6806 | return signInWithCredential(getModularInstance(auth), EmailAuthProvider.credential(email, password));
|
6807 | }
|
6808 |
|
6809 |
|
6810 |
|
6811 |
|
6812 |
|
6813 |
|
6814 |
|
6815 |
|
6816 |
|
6817 |
|
6818 |
|
6819 |
|
6820 |
|
6821 |
|
6822 |
|
6823 |
|
6824 |
|
6825 |
|
6826 |
|
6827 |
|
6828 |
|
6829 |
|
6830 |
|
6831 |
|
6832 |
|
6833 |
|
6834 |
|
6835 |
|
6836 |
|
6837 |
|
6838 |
|
6839 |
|
6840 |
|
6841 |
|
6842 |
|
6843 |
|
6844 |
|
6845 |
|
6846 |
|
6847 |
|
6848 |
|
6849 |
|
6850 |
|
6851 |
|
6852 |
|
6853 |
|
6854 |
|
6855 |
|
6856 |
|
6857 |
|
6858 |
|
6859 |
|
6860 |
|
6861 |
|
6862 |
|
6863 | function sendSignInLinkToEmail(auth, email, actionCodeSettings) {
|
6864 | return __awaiter(this, void 0, void 0, function () {
|
6865 | var authModular, request;
|
6866 | return __generator(this, function (_a) {
|
6867 | switch (_a.label) {
|
6868 | case 0:
|
6869 | authModular = getModularInstance(auth);
|
6870 | request = {
|
6871 | requestType: "EMAIL_SIGNIN" ,
|
6872 | email: email
|
6873 | };
|
6874 | _assert(actionCodeSettings.handleCodeInApp, authModular, "argument-error" );
|
6875 | if (actionCodeSettings) {
|
6876 | _setActionCodeSettingsOnRequest(authModular, request, actionCodeSettings);
|
6877 | }
|
6878 | return [4 , sendSignInLinkToEmail$1(authModular, request)];
|
6879 | case 1:
|
6880 | _a.sent();
|
6881 | return [2 ];
|
6882 | }
|
6883 | });
|
6884 | });
|
6885 | }
|
6886 |
|
6887 |
|
6888 |
|
6889 |
|
6890 |
|
6891 |
|
6892 |
|
6893 |
|
6894 | function isSignInWithEmailLink(auth, emailLink) {
|
6895 | var actionCodeUrl = ActionCodeURL.parseLink(emailLink);
|
6896 | return (actionCodeUrl === null || actionCodeUrl === void 0 ? void 0 : actionCodeUrl.operation) === "EMAIL_SIGNIN" ;
|
6897 | }
|
6898 |
|
6899 |
|
6900 |
|
6901 |
|
6902 |
|
6903 |
|
6904 |
|
6905 |
|
6906 |
|
6907 |
|
6908 |
|
6909 |
|
6910 |
|
6911 |
|
6912 |
|
6913 |
|
6914 |
|
6915 |
|
6916 |
|
6917 |
|
6918 |
|
6919 |
|
6920 |
|
6921 |
|
6922 |
|
6923 |
|
6924 |
|
6925 |
|
6926 |
|
6927 |
|
6928 |
|
6929 |
|
6930 |
|
6931 |
|
6932 |
|
6933 |
|
6934 |
|
6935 | function signInWithEmailLink(auth, email, emailLink) {
|
6936 | return __awaiter(this, void 0, void 0, function () {
|
6937 | var authModular, credential;
|
6938 | return __generator(this, function (_a) {
|
6939 | authModular = getModularInstance(auth);
|
6940 | credential = EmailAuthProvider.credentialWithLink(email, emailLink || _getCurrentUrl());
|
6941 |
|
6942 |
|
6943 | _assert(credential._tenantId === (authModular.tenantId || null), authModular, "tenant-id-mismatch" );
|
6944 | return [2 , signInWithCredential(authModular, credential)];
|
6945 | });
|
6946 | });
|
6947 | }
|
6948 |
|
6949 |
|
6950 |
|
6951 |
|
6952 |
|
6953 |
|
6954 |
|
6955 |
|
6956 |
|
6957 |
|
6958 |
|
6959 |
|
6960 |
|
6961 |
|
6962 |
|
6963 |
|
6964 |
|
6965 | function createAuthUri(auth, request) {
|
6966 | return __awaiter(this, void 0, void 0, function () {
|
6967 | return __generator(this, function (_a) {
|
6968 | return [2 , _performApiRequest(auth, "POST" , "/v1/accounts:createAuthUri" , _addTidIfNecessary(auth, request))];
|
6969 | });
|
6970 | });
|
6971 | }
|
6972 |
|
6973 |
|
6974 |
|
6975 |
|
6976 |
|
6977 |
|
6978 |
|
6979 |
|
6980 |
|
6981 |
|
6982 |
|
6983 |
|
6984 |
|
6985 |
|
6986 |
|
6987 |
|
6988 |
|
6989 |
|
6990 |
|
6991 |
|
6992 |
|
6993 |
|
6994 |
|
6995 |
|
6996 |
|
6997 |
|
6998 |
|
6999 |
|
7000 |
|
7001 |
|
7002 |
|
7003 | function fetchSignInMethodsForEmail(auth, email) {
|
7004 | return __awaiter(this, void 0, void 0, function () {
|
7005 | var continueUri, request, signinMethods;
|
7006 | return __generator(this, function (_a) {
|
7007 | switch (_a.label) {
|
7008 | case 0:
|
7009 | continueUri = _isHttpOrHttps() ? _getCurrentUrl() : 'http://localhost';
|
7010 | request = {
|
7011 | identifier: email,
|
7012 | continueUri: continueUri
|
7013 | };
|
7014 | return [4 , createAuthUri(getModularInstance(auth), request)];
|
7015 | case 1:
|
7016 | signinMethods = (_a.sent()).signinMethods;
|
7017 | return [2 , signinMethods || []];
|
7018 | }
|
7019 | });
|
7020 | });
|
7021 | }
|
7022 |
|
7023 |
|
7024 |
|
7025 |
|
7026 |
|
7027 |
|
7028 |
|
7029 |
|
7030 |
|
7031 |
|
7032 |
|
7033 |
|
7034 |
|
7035 |
|
7036 |
|
7037 |
|
7038 |
|
7039 |
|
7040 |
|
7041 |
|
7042 |
|
7043 |
|
7044 |
|
7045 |
|
7046 |
|
7047 |
|
7048 |
|
7049 |
|
7050 |
|
7051 |
|
7052 | function sendEmailVerification(user, actionCodeSettings) {
|
7053 | return __awaiter(this, void 0, void 0, function () {
|
7054 | var userInternal, idToken, request, email;
|
7055 | return __generator(this, function (_a) {
|
7056 | switch (_a.label) {
|
7057 | case 0:
|
7058 | userInternal = getModularInstance(user);
|
7059 | return [4 , user.getIdToken()];
|
7060 | case 1:
|
7061 | idToken = _a.sent();
|
7062 | request = {
|
7063 | requestType: "VERIFY_EMAIL" ,
|
7064 | idToken: idToken
|
7065 | };
|
7066 | if (actionCodeSettings) {
|
7067 | _setActionCodeSettingsOnRequest(userInternal.auth, request, actionCodeSettings);
|
7068 | }
|
7069 | return [4 , sendEmailVerification$1(userInternal.auth, request)];
|
7070 | case 2:
|
7071 | email = (_a.sent()).email;
|
7072 | if (!(email !== user.email)) return [3 , 4];
|
7073 | return [4 , user.reload()];
|
7074 | case 3:
|
7075 | _a.sent();
|
7076 | _a.label = 4;
|
7077 | case 4: return [2 ];
|
7078 | }
|
7079 | });
|
7080 | });
|
7081 | }
|
7082 |
|
7083 |
|
7084 |
|
7085 |
|
7086 |
|
7087 |
|
7088 |
|
7089 |
|
7090 |
|
7091 |
|
7092 |
|
7093 |
|
7094 |
|
7095 |
|
7096 |
|
7097 |
|
7098 |
|
7099 |
|
7100 |
|
7101 |
|
7102 |
|
7103 |
|
7104 |
|
7105 |
|
7106 |
|
7107 |
|
7108 |
|
7109 |
|
7110 |
|
7111 |
|
7112 |
|
7113 |
|
7114 |
|
7115 |
|
7116 | function verifyBeforeUpdateEmail(user, newEmail, actionCodeSettings) {
|
7117 | return __awaiter(this, void 0, void 0, function () {
|
7118 | var userInternal, idToken, request, email;
|
7119 | return __generator(this, function (_a) {
|
7120 | switch (_a.label) {
|
7121 | case 0:
|
7122 | userInternal = getModularInstance(user);
|
7123 | return [4 , user.getIdToken()];
|
7124 | case 1:
|
7125 | idToken = _a.sent();
|
7126 | request = {
|
7127 | requestType: "VERIFY_AND_CHANGE_EMAIL" ,
|
7128 | idToken: idToken,
|
7129 | newEmail: newEmail
|
7130 | };
|
7131 | if (actionCodeSettings) {
|
7132 | _setActionCodeSettingsOnRequest(userInternal.auth, request, actionCodeSettings);
|
7133 | }
|
7134 | return [4 , verifyAndChangeEmail(userInternal.auth, request)];
|
7135 | case 2:
|
7136 | email = (_a.sent()).email;
|
7137 | if (!(email !== user.email)) return [3 , 4];
|
7138 |
|
7139 |
|
7140 | return [4 , user.reload()];
|
7141 | case 3:
|
7142 |
|
7143 |
|
7144 | _a.sent();
|
7145 | _a.label = 4;
|
7146 | case 4: return [2 ];
|
7147 | }
|
7148 | });
|
7149 | });
|
7150 | }
|
7151 |
|
7152 |
|
7153 |
|
7154 |
|
7155 |
|
7156 |
|
7157 |
|
7158 |
|
7159 |
|
7160 |
|
7161 |
|
7162 |
|
7163 |
|
7164 |
|
7165 |
|
7166 |
|
7167 |
|
7168 | function updateProfile$1(auth, request) {
|
7169 | return __awaiter(this, void 0, void 0, function () {
|
7170 | return __generator(this, function (_a) {
|
7171 | return [2 , _performApiRequest(auth, "POST" , "/v1/accounts:update" , request)];
|
7172 | });
|
7173 | });
|
7174 | }
|
7175 |
|
7176 |
|
7177 |
|
7178 |
|
7179 |
|
7180 |
|
7181 |
|
7182 |
|
7183 |
|
7184 |
|
7185 |
|
7186 |
|
7187 |
|
7188 |
|
7189 |
|
7190 |
|
7191 |
|
7192 |
|
7193 |
|
7194 |
|
7195 |
|
7196 |
|
7197 |
|
7198 |
|
7199 |
|
7200 | function updateProfile(user, _a) {
|
7201 | var displayName = _a.displayName, photoUrl = _a.photoURL;
|
7202 | return __awaiter(this, void 0, void 0, function () {
|
7203 | var userInternal, idToken, profileRequest, response, passwordProvider;
|
7204 | return __generator(this, function (_b) {
|
7205 | switch (_b.label) {
|
7206 | case 0:
|
7207 | if (displayName === undefined && photoUrl === undefined) {
|
7208 | return [2 ];
|
7209 | }
|
7210 | userInternal = getModularInstance(user);
|
7211 | return [4 , userInternal.getIdToken()];
|
7212 | case 1:
|
7213 | idToken = _b.sent();
|
7214 | profileRequest = {
|
7215 | idToken: idToken,
|
7216 | displayName: displayName,
|
7217 | photoUrl: photoUrl,
|
7218 | returnSecureToken: true
|
7219 | };
|
7220 | return [4 , _logoutIfInvalidated(userInternal, updateProfile$1(userInternal.auth, profileRequest))];
|
7221 | case 2:
|
7222 | response = _b.sent();
|
7223 | userInternal.displayName = response.displayName || null;
|
7224 | userInternal.photoURL = response.photoUrl || null;
|
7225 | passwordProvider = userInternal.providerData.find(function (_a) {
|
7226 | var providerId = _a.providerId;
|
7227 | return providerId === "password" ;
|
7228 | });
|
7229 | if (passwordProvider) {
|
7230 | passwordProvider.displayName = userInternal.displayName;
|
7231 | passwordProvider.photoURL = userInternal.photoURL;
|
7232 | }
|
7233 | return [4 , userInternal._updateTokensIfNecessary(response)];
|
7234 | case 3:
|
7235 | _b.sent();
|
7236 | return [2 ];
|
7237 | }
|
7238 | });
|
7239 | });
|
7240 | }
|
7241 |
|
7242 |
|
7243 |
|
7244 |
|
7245 |
|
7246 |
|
7247 |
|
7248 |
|
7249 |
|
7250 |
|
7251 |
|
7252 |
|
7253 |
|
7254 |
|
7255 |
|
7256 |
|
7257 | function updateEmail(user, newEmail) {
|
7258 | return updateEmailOrPassword(getModularInstance(user), newEmail, null);
|
7259 | }
|
7260 |
|
7261 |
|
7262 |
|
7263 |
|
7264 |
|
7265 |
|
7266 |
|
7267 |
|
7268 |
|
7269 |
|
7270 |
|
7271 |
|
7272 |
|
7273 | function updatePassword(user, newPassword) {
|
7274 | return updateEmailOrPassword(getModularInstance(user), null, newPassword);
|
7275 | }
|
7276 | function updateEmailOrPassword(user, email, password) {
|
7277 | return __awaiter(this, void 0, void 0, function () {
|
7278 | var auth, idToken, request, response;
|
7279 | return __generator(this, function (_a) {
|
7280 | switch (_a.label) {
|
7281 | case 0:
|
7282 | auth = user.auth;
|
7283 | return [4 , user.getIdToken()];
|
7284 | case 1:
|
7285 | idToken = _a.sent();
|
7286 | request = {
|
7287 | idToken: idToken,
|
7288 | returnSecureToken: true
|
7289 | };
|
7290 | if (email) {
|
7291 | request.email = email;
|
7292 | }
|
7293 | if (password) {
|
7294 | request.password = password;
|
7295 | }
|
7296 | return [4 , _logoutIfInvalidated(user, updateEmailPassword(auth, request))];
|
7297 | case 2:
|
7298 | response = _a.sent();
|
7299 | return [4 , user._updateTokensIfNecessary(response, true)];
|
7300 | case 3:
|
7301 | _a.sent();
|
7302 | return [2 ];
|
7303 | }
|
7304 | });
|
7305 | });
|
7306 | }
|
7307 |
|
7308 |
|
7309 |
|
7310 |
|
7311 |
|
7312 |
|
7313 |
|
7314 |
|
7315 |
|
7316 |
|
7317 |
|
7318 |
|
7319 |
|
7320 |
|
7321 |
|
7322 |
|
7323 |
|
7324 |
|
7325 |
|
7326 |
|
7327 |
|
7328 | function _fromIdTokenResponse(idTokenResponse) {
|
7329 | var _a, _b;
|
7330 | if (!idTokenResponse) {
|
7331 | return null;
|
7332 | }
|
7333 | var providerId = idTokenResponse.providerId;
|
7334 | var profile = idTokenResponse.rawUserInfo
|
7335 | ? JSON.parse(idTokenResponse.rawUserInfo)
|
7336 | : {};
|
7337 | var isNewUser = idTokenResponse.isNewUser ||
|
7338 | idTokenResponse.kind === "identitytoolkit#SignupNewUserResponse" ;
|
7339 | if (!providerId && (idTokenResponse === null || idTokenResponse === void 0 ? void 0 : idTokenResponse.idToken)) {
|
7340 | var signInProvider = (_b = (_a = _parseToken(idTokenResponse.idToken)) === null || _a === void 0 ? void 0 : _a.firebase) === null || _b === void 0 ? void 0 : _b['sign_in_provider'];
|
7341 | if (signInProvider) {
|
7342 | var filteredProviderId = signInProvider !== "anonymous" &&
|
7343 | signInProvider !== "custom"
|
7344 | ? signInProvider
|
7345 | : null;
|
7346 |
|
7347 | return new GenericAdditionalUserInfo(isNewUser, filteredProviderId);
|
7348 | }
|
7349 | }
|
7350 | if (!providerId) {
|
7351 | return null;
|
7352 | }
|
7353 | switch (providerId) {
|
7354 | case "facebook.com" :
|
7355 | return new FacebookAdditionalUserInfo(isNewUser, profile);
|
7356 | case "github.com" :
|
7357 | return new GithubAdditionalUserInfo(isNewUser, profile);
|
7358 | case "google.com" :
|
7359 | return new GoogleAdditionalUserInfo(isNewUser, profile);
|
7360 | case "twitter.com" :
|
7361 | return new TwitterAdditionalUserInfo(isNewUser, profile, idTokenResponse.screenName || null);
|
7362 | case "custom" :
|
7363 | case "anonymous" :
|
7364 | return new GenericAdditionalUserInfo(isNewUser, null);
|
7365 | default:
|
7366 | return new GenericAdditionalUserInfo(isNewUser, providerId, profile);
|
7367 | }
|
7368 | }
|
7369 | var GenericAdditionalUserInfo = (function () {
|
7370 | function GenericAdditionalUserInfo(isNewUser, providerId, profile) {
|
7371 | if (profile === void 0) { profile = {}; }
|
7372 | this.isNewUser = isNewUser;
|
7373 | this.providerId = providerId;
|
7374 | this.profile = profile;
|
7375 | }
|
7376 | return GenericAdditionalUserInfo;
|
7377 | }());
|
7378 | var FederatedAdditionalUserInfoWithUsername = (function (_super) {
|
7379 | __extends(FederatedAdditionalUserInfoWithUsername, _super);
|
7380 | function FederatedAdditionalUserInfoWithUsername(isNewUser, providerId, profile, username) {
|
7381 | var _this = _super.call(this, isNewUser, providerId, profile) || this;
|
7382 | _this.username = username;
|
7383 | return _this;
|
7384 | }
|
7385 | return FederatedAdditionalUserInfoWithUsername;
|
7386 | }(GenericAdditionalUserInfo));
|
7387 | var FacebookAdditionalUserInfo = (function (_super) {
|
7388 | __extends(FacebookAdditionalUserInfo, _super);
|
7389 | function FacebookAdditionalUserInfo(isNewUser, profile) {
|
7390 | return _super.call(this, isNewUser, "facebook.com" , profile) || this;
|
7391 | }
|
7392 | return FacebookAdditionalUserInfo;
|
7393 | }(GenericAdditionalUserInfo));
|
7394 | var GithubAdditionalUserInfo = (function (_super) {
|
7395 | __extends(GithubAdditionalUserInfo, _super);
|
7396 | function GithubAdditionalUserInfo(isNewUser, profile) {
|
7397 | return _super.call(this, isNewUser, "github.com" , profile, typeof (profile === null || profile === void 0 ? void 0 : profile.login) === 'string' ? profile === null || profile === void 0 ? void 0 : profile.login : null) || this;
|
7398 | }
|
7399 | return GithubAdditionalUserInfo;
|
7400 | }(FederatedAdditionalUserInfoWithUsername));
|
7401 | var GoogleAdditionalUserInfo = (function (_super) {
|
7402 | __extends(GoogleAdditionalUserInfo, _super);
|
7403 | function GoogleAdditionalUserInfo(isNewUser, profile) {
|
7404 | return _super.call(this, isNewUser, "google.com" , profile) || this;
|
7405 | }
|
7406 | return GoogleAdditionalUserInfo;
|
7407 | }(GenericAdditionalUserInfo));
|
7408 | var TwitterAdditionalUserInfo = (function (_super) {
|
7409 | __extends(TwitterAdditionalUserInfo, _super);
|
7410 | function TwitterAdditionalUserInfo(isNewUser, profile, screenName) {
|
7411 | return _super.call(this, isNewUser, "twitter.com" , profile, screenName) || this;
|
7412 | }
|
7413 | return TwitterAdditionalUserInfo;
|
7414 | }(FederatedAdditionalUserInfoWithUsername));
|
7415 |
|
7416 |
|
7417 |
|
7418 |
|
7419 |
|
7420 |
|
7421 |
|
7422 | function getAdditionalUserInfo(userCredential) {
|
7423 | var _a = userCredential, user = _a.user, _tokenResponse = _a._tokenResponse;
|
7424 | if (user.isAnonymous && !_tokenResponse) {
|
7425 |
|
7426 |
|
7427 | return {
|
7428 | providerId: null,
|
7429 | isNewUser: false,
|
7430 | profile: null
|
7431 | };
|
7432 | }
|
7433 | return _fromIdTokenResponse(_tokenResponse);
|
7434 | }
|
7435 |
|
7436 |
|
7437 |
|
7438 |
|
7439 |
|
7440 |
|
7441 |
|
7442 |
|
7443 |
|
7444 |
|
7445 |
|
7446 |
|
7447 |
|
7448 |
|
7449 |
|
7450 |
|
7451 |
|
7452 |
|
7453 |
|
7454 |
|
7455 |
|
7456 |
|
7457 |
|
7458 |
|
7459 |
|
7460 |
|
7461 |
|
7462 |
|
7463 |
|
7464 |
|
7465 |
|
7466 |
|
7467 |
|
7468 |
|
7469 |
|
7470 |
|
7471 |
|
7472 |
|
7473 |
|
7474 | function setPersistence(auth, persistence) {
|
7475 | return getModularInstance(auth).setPersistence(persistence);
|
7476 | }
|
7477 |
|
7478 |
|
7479 |
|
7480 |
|
7481 |
|
7482 |
|
7483 |
|
7484 |
|
7485 |
|
7486 |
|
7487 |
|
7488 | function onIdTokenChanged(auth, nextOrObserver, error, completed) {
|
7489 | return getModularInstance(auth).onIdTokenChanged(nextOrObserver, error, completed);
|
7490 | }
|
7491 |
|
7492 |
|
7493 |
|
7494 |
|
7495 |
|
7496 |
|
7497 |
|
7498 |
|
7499 |
|
7500 |
|
7501 | function beforeAuthStateChanged(auth, callback, onAbort) {
|
7502 | return getModularInstance(auth).beforeAuthStateChanged(callback, onAbort);
|
7503 | }
|
7504 |
|
7505 |
|
7506 |
|
7507 |
|
7508 |
|
7509 |
|
7510 |
|
7511 |
|
7512 |
|
7513 |
|
7514 |
|
7515 |
|
7516 |
|
7517 | function onAuthStateChanged(auth, nextOrObserver, error, completed) {
|
7518 | return getModularInstance(auth).onAuthStateChanged(nextOrObserver, error, completed);
|
7519 | }
|
7520 |
|
7521 |
|
7522 |
|
7523 |
|
7524 |
|
7525 |
|
7526 |
|
7527 | function useDeviceLanguage(auth) {
|
7528 | getModularInstance(auth).useDeviceLanguage();
|
7529 | }
|
7530 |
|
7531 |
|
7532 |
|
7533 |
|
7534 |
|
7535 |
|
7536 |
|
7537 |
|
7538 |
|
7539 |
|
7540 |
|
7541 |
|
7542 |
|
7543 |
|
7544 |
|
7545 |
|
7546 |
|
7547 |
|
7548 | function updateCurrentUser(auth, user) {
|
7549 | return getModularInstance(auth).updateCurrentUser(user);
|
7550 | }
|
7551 |
|
7552 |
|
7553 |
|
7554 |
|
7555 |
|
7556 |
|
7557 |
|
7558 | function signOut(auth) {
|
7559 | return getModularInstance(auth).signOut();
|
7560 | }
|
7561 |
|
7562 |
|
7563 |
|
7564 |
|
7565 |
|
7566 |
|
7567 |
|
7568 |
|
7569 |
|
7570 |
|
7571 |
|
7572 |
|
7573 | function deleteUser(user) {
|
7574 | return __awaiter(this, void 0, void 0, function () {
|
7575 | return __generator(this, function (_a) {
|
7576 | return [2 , getModularInstance(user).delete()];
|
7577 | });
|
7578 | });
|
7579 | }
|
7580 |
|
7581 | var MultiFactorSessionImpl = (function () {
|
7582 | function MultiFactorSessionImpl(type, credential) {
|
7583 | this.type = type;
|
7584 | this.credential = credential;
|
7585 | }
|
7586 | MultiFactorSessionImpl._fromIdtoken = function (idToken) {
|
7587 | return new MultiFactorSessionImpl("enroll" , idToken);
|
7588 | };
|
7589 | MultiFactorSessionImpl._fromMfaPendingCredential = function (mfaPendingCredential) {
|
7590 | return new MultiFactorSessionImpl("signin" , mfaPendingCredential);
|
7591 | };
|
7592 | MultiFactorSessionImpl.prototype.toJSON = function () {
|
7593 | var _a;
|
7594 | var key = this.type === "enroll"
|
7595 | ? 'idToken'
|
7596 | : 'pendingCredential';
|
7597 | return {
|
7598 | multiFactorSession: (_a = {},
|
7599 | _a[key] = this.credential,
|
7600 | _a)
|
7601 | };
|
7602 | };
|
7603 | MultiFactorSessionImpl.fromJSON = function (obj) {
|
7604 | var _a, _b;
|
7605 | if (obj === null || obj === void 0 ? void 0 : obj.multiFactorSession) {
|
7606 | if ((_a = obj.multiFactorSession) === null || _a === void 0 ? void 0 : _a.pendingCredential) {
|
7607 | return MultiFactorSessionImpl._fromMfaPendingCredential(obj.multiFactorSession.pendingCredential);
|
7608 | }
|
7609 | else if ((_b = obj.multiFactorSession) === null || _b === void 0 ? void 0 : _b.idToken) {
|
7610 | return MultiFactorSessionImpl._fromIdtoken(obj.multiFactorSession.idToken);
|
7611 | }
|
7612 | }
|
7613 | return null;
|
7614 | };
|
7615 | return MultiFactorSessionImpl;
|
7616 | }());
|
7617 |
|
7618 |
|
7619 |
|
7620 |
|
7621 |
|
7622 |
|
7623 |
|
7624 |
|
7625 |
|
7626 |
|
7627 |
|
7628 |
|
7629 |
|
7630 |
|
7631 |
|
7632 |
|
7633 |
|
7634 | var MultiFactorResolverImpl = (function () {
|
7635 | function MultiFactorResolverImpl(session, hints, signInResolver) {
|
7636 | this.session = session;
|
7637 | this.hints = hints;
|
7638 | this.signInResolver = signInResolver;
|
7639 | }
|
7640 |
|
7641 | MultiFactorResolverImpl._fromError = function (authExtern, error) {
|
7642 | var _this = this;
|
7643 | var auth = _castAuth(authExtern);
|
7644 | var serverResponse = error.customData._serverResponse;
|
7645 | var hints = (serverResponse.mfaInfo || []).map(function (enrollment) {
|
7646 | return MultiFactorInfoImpl._fromServerResponse(auth, enrollment);
|
7647 | });
|
7648 | _assert(serverResponse.mfaPendingCredential, auth, "internal-error" );
|
7649 | var session = MultiFactorSessionImpl._fromMfaPendingCredential(serverResponse.mfaPendingCredential);
|
7650 | return new MultiFactorResolverImpl(session, hints, function (assertion) { return __awaiter(_this, void 0, void 0, function () {
|
7651 | var mfaResponse, idTokenResponse, _a, userCredential;
|
7652 | return __generator(this, function (_b) {
|
7653 | switch (_b.label) {
|
7654 | case 0: return [4 , assertion._process(auth, session)];
|
7655 | case 1:
|
7656 | mfaResponse = _b.sent();
|
7657 |
|
7658 | delete serverResponse.mfaInfo;
|
7659 | delete serverResponse.mfaPendingCredential;
|
7660 | idTokenResponse = __assign(__assign({}, serverResponse), { idToken: mfaResponse.idToken, refreshToken: mfaResponse.refreshToken });
|
7661 | _a = error.operationType;
|
7662 | switch (_a) {
|
7663 | case "signIn" : return [3 , 2];
|
7664 | case "reauthenticate" : return [3 , 5];
|
7665 | }
|
7666 | return [3 , 6];
|
7667 | case 2: return [4 , UserCredentialImpl._fromIdTokenResponse(auth, error.operationType, idTokenResponse)];
|
7668 | case 3:
|
7669 | userCredential = _b.sent();
|
7670 | return [4 , auth._updateCurrentUser(userCredential.user)];
|
7671 | case 4:
|
7672 | _b.sent();
|
7673 | return [2 , userCredential];
|
7674 | case 5:
|
7675 | _assert(error.user, auth, "internal-error" );
|
7676 | return [2 , UserCredentialImpl._forOperation(error.user, error.operationType, idTokenResponse)];
|
7677 | case 6:
|
7678 | _fail(auth, "internal-error" );
|
7679 | _b.label = 7;
|
7680 | case 7: return [2 ];
|
7681 | }
|
7682 | });
|
7683 | }); });
|
7684 | };
|
7685 | MultiFactorResolverImpl.prototype.resolveSignIn = function (assertionExtern) {
|
7686 | return __awaiter(this, void 0, void 0, function () {
|
7687 | var assertion;
|
7688 | return __generator(this, function (_a) {
|
7689 | assertion = assertionExtern;
|
7690 | return [2 , this.signInResolver(assertion)];
|
7691 | });
|
7692 | });
|
7693 | };
|
7694 | return MultiFactorResolverImpl;
|
7695 | }());
|
7696 |
|
7697 |
|
7698 |
|
7699 |
|
7700 |
|
7701 |
|
7702 |
|
7703 |
|
7704 |
|
7705 |
|
7706 | function getMultiFactorResolver(auth, error) {
|
7707 | var _a;
|
7708 | var authModular = getModularInstance(auth);
|
7709 | var errorInternal = error;
|
7710 | _assert(error.customData.operationType, authModular, "argument-error" );
|
7711 | _assert((_a = errorInternal.customData._serverResponse) === null || _a === void 0 ? void 0 : _a.mfaPendingCredential, authModular, "argument-error" );
|
7712 | return MultiFactorResolverImpl._fromError(authModular, errorInternal);
|
7713 | }
|
7714 |
|
7715 |
|
7716 |
|
7717 |
|
7718 |
|
7719 |
|
7720 |
|
7721 |
|
7722 |
|
7723 |
|
7724 |
|
7725 |
|
7726 |
|
7727 |
|
7728 |
|
7729 |
|
7730 |
|
7731 | function startEnrollPhoneMfa(auth, request) {
|
7732 | return _performApiRequest(auth, "POST" , "/v2/accounts/mfaEnrollment:start" , _addTidIfNecessary(auth, request));
|
7733 | }
|
7734 | function finalizeEnrollPhoneMfa(auth, request) {
|
7735 | return _performApiRequest(auth, "POST" , "/v2/accounts/mfaEnrollment:finalize" , _addTidIfNecessary(auth, request));
|
7736 | }
|
7737 | function withdrawMfa(auth, request) {
|
7738 | return _performApiRequest(auth, "POST" , "/v2/accounts/mfaEnrollment:withdraw" , _addTidIfNecessary(auth, request));
|
7739 | }
|
7740 |
|
7741 | var MultiFactorUserImpl = (function () {
|
7742 | function MultiFactorUserImpl(user) {
|
7743 | var _this = this;
|
7744 | this.user = user;
|
7745 | this.enrolledFactors = [];
|
7746 | user._onReload(function (userInfo) {
|
7747 | if (userInfo.mfaInfo) {
|
7748 | _this.enrolledFactors = userInfo.mfaInfo.map(function (enrollment) {
|
7749 | return MultiFactorInfoImpl._fromServerResponse(user.auth, enrollment);
|
7750 | });
|
7751 | }
|
7752 | });
|
7753 | }
|
7754 | MultiFactorUserImpl._fromUser = function (user) {
|
7755 | return new MultiFactorUserImpl(user);
|
7756 | };
|
7757 | MultiFactorUserImpl.prototype.getSession = function () {
|
7758 | return __awaiter(this, void 0, void 0, function () {
|
7759 | var _a, _b;
|
7760 | return __generator(this, function (_c) {
|
7761 | switch (_c.label) {
|
7762 | case 0:
|
7763 | _b = (_a = MultiFactorSessionImpl)._fromIdtoken;
|
7764 | return [4 , this.user.getIdToken()];
|
7765 | case 1: return [2 , _b.apply(_a, [_c.sent()])];
|
7766 | }
|
7767 | });
|
7768 | });
|
7769 | };
|
7770 | MultiFactorUserImpl.prototype.enroll = function (assertionExtern, displayName) {
|
7771 | return __awaiter(this, void 0, void 0, function () {
|
7772 | var assertion, session, finalizeMfaResponse;
|
7773 | return __generator(this, function (_a) {
|
7774 | switch (_a.label) {
|
7775 | case 0:
|
7776 | assertion = assertionExtern;
|
7777 | return [4 , this.getSession()];
|
7778 | case 1:
|
7779 | session = (_a.sent());
|
7780 | return [4 , _logoutIfInvalidated(this.user, assertion._process(this.user.auth, session, displayName))];
|
7781 | case 2:
|
7782 | finalizeMfaResponse = _a.sent();
|
7783 |
|
7784 |
|
7785 | return [4 , this.user._updateTokensIfNecessary(finalizeMfaResponse)];
|
7786 | case 3:
|
7787 |
|
7788 |
|
7789 | _a.sent();
|
7790 |
|
7791 |
|
7792 |
|
7793 | return [2 , this.user.reload()];
|
7794 | }
|
7795 | });
|
7796 | });
|
7797 | };
|
7798 | MultiFactorUserImpl.prototype.unenroll = function (infoOrUid) {
|
7799 | return __awaiter(this, void 0, void 0, function () {
|
7800 | var mfaEnrollmentId, idToken, idTokenResponse, e_1;
|
7801 | return __generator(this, function (_a) {
|
7802 | switch (_a.label) {
|
7803 | case 0:
|
7804 | mfaEnrollmentId = typeof infoOrUid === 'string' ? infoOrUid : infoOrUid.uid;
|
7805 | return [4 , this.user.getIdToken()];
|
7806 | case 1:
|
7807 | idToken = _a.sent();
|
7808 | return [4 , _logoutIfInvalidated(this.user, withdrawMfa(this.user.auth, {
|
7809 | idToken: idToken,
|
7810 | mfaEnrollmentId: mfaEnrollmentId
|
7811 | }))];
|
7812 | case 2:
|
7813 | idTokenResponse = _a.sent();
|
7814 |
|
7815 | this.enrolledFactors = this.enrolledFactors.filter(function (_a) {
|
7816 | var uid = _a.uid;
|
7817 | return uid !== mfaEnrollmentId;
|
7818 | });
|
7819 |
|
7820 |
|
7821 |
|
7822 |
|
7823 | return [4 , this.user._updateTokensIfNecessary(idTokenResponse)];
|
7824 | case 3:
|
7825 |
|
7826 |
|
7827 |
|
7828 |
|
7829 | _a.sent();
|
7830 | _a.label = 4;
|
7831 | case 4:
|
7832 | _a.trys.push([4, 6, , 7]);
|
7833 | return [4 , this.user.reload()];
|
7834 | case 5:
|
7835 | _a.sent();
|
7836 | return [3 , 7];
|
7837 | case 6:
|
7838 | e_1 = _a.sent();
|
7839 | if (e_1.code !== "auth/" + "user-token-expired" ) {
|
7840 | throw e_1;
|
7841 | }
|
7842 | return [3 , 7];
|
7843 | case 7: return [2 ];
|
7844 | }
|
7845 | });
|
7846 | });
|
7847 | };
|
7848 | return MultiFactorUserImpl;
|
7849 | }());
|
7850 | var multiFactorUserCache = new WeakMap();
|
7851 |
|
7852 |
|
7853 |
|
7854 |
|
7855 |
|
7856 |
|
7857 |
|
7858 |
|
7859 |
|
7860 |
|
7861 | function multiFactor(user) {
|
7862 | var userModular = getModularInstance(user);
|
7863 | if (!multiFactorUserCache.has(userModular)) {
|
7864 | multiFactorUserCache.set(userModular, MultiFactorUserImpl._fromUser(userModular));
|
7865 | }
|
7866 | return multiFactorUserCache.get(userModular);
|
7867 | }
|
7868 |
|
7869 | var name = "@firebase/auth";
|
7870 | var version = "0.20.1";
|
7871 |
|
7872 |
|
7873 |
|
7874 |
|
7875 |
|
7876 |
|
7877 |
|
7878 |
|
7879 |
|
7880 |
|
7881 |
|
7882 |
|
7883 |
|
7884 |
|
7885 |
|
7886 |
|
7887 |
|
7888 | var AuthInterop = (function () {
|
7889 | function AuthInterop(auth) {
|
7890 | this.auth = auth;
|
7891 | this.internalListeners = new Map();
|
7892 | }
|
7893 | AuthInterop.prototype.getUid = function () {
|
7894 | var _a;
|
7895 | this.assertAuthConfigured();
|
7896 | return ((_a = this.auth.currentUser) === null || _a === void 0 ? void 0 : _a.uid) || null;
|
7897 | };
|
7898 | AuthInterop.prototype.getToken = function (forceRefresh) {
|
7899 | return __awaiter(this, void 0, void 0, function () {
|
7900 | var accessToken;
|
7901 | return __generator(this, function (_a) {
|
7902 | switch (_a.label) {
|
7903 | case 0:
|
7904 | this.assertAuthConfigured();
|
7905 | return [4 , this.auth._initializationPromise];
|
7906 | case 1:
|
7907 | _a.sent();
|
7908 | if (!this.auth.currentUser) {
|
7909 | return [2 , null];
|
7910 | }
|
7911 | return [4 , this.auth.currentUser.getIdToken(forceRefresh)];
|
7912 | case 2:
|
7913 | accessToken = _a.sent();
|
7914 | return [2 , { accessToken: accessToken }];
|
7915 | }
|
7916 | });
|
7917 | });
|
7918 | };
|
7919 | AuthInterop.prototype.addAuthTokenListener = function (listener) {
|
7920 | this.assertAuthConfigured();
|
7921 | if (this.internalListeners.has(listener)) {
|
7922 | return;
|
7923 | }
|
7924 | var unsubscribe = this.auth.onIdTokenChanged(function (user) {
|
7925 | var _a;
|
7926 | listener(((_a = user) === null || _a === void 0 ? void 0 : _a.stsTokenManager.accessToken) || null);
|
7927 | });
|
7928 | this.internalListeners.set(listener, unsubscribe);
|
7929 | this.updateProactiveRefresh();
|
7930 | };
|
7931 | AuthInterop.prototype.removeAuthTokenListener = function (listener) {
|
7932 | this.assertAuthConfigured();
|
7933 | var unsubscribe = this.internalListeners.get(listener);
|
7934 | if (!unsubscribe) {
|
7935 | return;
|
7936 | }
|
7937 | this.internalListeners.delete(listener);
|
7938 | unsubscribe();
|
7939 | this.updateProactiveRefresh();
|
7940 | };
|
7941 | AuthInterop.prototype.assertAuthConfigured = function () {
|
7942 | _assert(this.auth._initializationPromise, "dependent-sdk-initialized-before-auth" );
|
7943 | };
|
7944 | AuthInterop.prototype.updateProactiveRefresh = function () {
|
7945 | if (this.internalListeners.size > 0) {
|
7946 | this.auth._startProactiveRefresh();
|
7947 | }
|
7948 | else {
|
7949 | this.auth._stopProactiveRefresh();
|
7950 | }
|
7951 | };
|
7952 | return AuthInterop;
|
7953 | }());
|
7954 |
|
7955 |
|
7956 |
|
7957 |
|
7958 |
|
7959 |
|
7960 |
|
7961 |
|
7962 |
|
7963 |
|
7964 |
|
7965 |
|
7966 |
|
7967 |
|
7968 |
|
7969 |
|
7970 |
|
7971 | function getVersionForPlatform(clientPlatform) {
|
7972 | switch (clientPlatform) {
|
7973 | case "Node" :
|
7974 | return 'node';
|
7975 | case "ReactNative" :
|
7976 | return 'rn';
|
7977 | case "Worker" :
|
7978 | return 'webworker';
|
7979 | case "Cordova" :
|
7980 | return 'cordova';
|
7981 | default:
|
7982 | return undefined;
|
7983 | }
|
7984 | }
|
7985 |
|
7986 | function registerAuth(clientPlatform) {
|
7987 | _registerComponent(new Component("auth" , function (container, _a) {
|
7988 | var deps = _a.options;
|
7989 | var app = container.getProvider('app').getImmediate();
|
7990 | var heartbeatServiceProvider = container.getProvider('heartbeat');
|
7991 | var _b = app.options, apiKey = _b.apiKey, authDomain = _b.authDomain;
|
7992 | return (function (app, heartbeatServiceProvider) {
|
7993 | _assert(apiKey && !apiKey.includes(':'), "invalid-api-key" , { appName: app.name });
|
7994 |
|
7995 | _assert(!(authDomain === null || authDomain === void 0 ? void 0 : authDomain.includes(':')), "argument-error" , {
|
7996 | appName: app.name
|
7997 | });
|
7998 | var config = {
|
7999 | apiKey: apiKey,
|
8000 | authDomain: authDomain,
|
8001 | clientPlatform: clientPlatform,
|
8002 | apiHost: "identitytoolkit.googleapis.com" ,
|
8003 | tokenApiHost: "securetoken.googleapis.com" ,
|
8004 | apiScheme: "https" ,
|
8005 | sdkClientVersion: _getClientVersion(clientPlatform)
|
8006 | };
|
8007 | var authInstance = new AuthImpl(app, heartbeatServiceProvider, config);
|
8008 | _initializeAuthInstance(authInstance, deps);
|
8009 | return authInstance;
|
8010 | })(app, heartbeatServiceProvider);
|
8011 | }, "PUBLIC" )
|
8012 | |
8013 |
|
8014 |
|
8015 |
|
8016 | .setInstantiationMode("EXPLICIT" )
|
8017 | |
8018 |
|
8019 |
|
8020 |
|
8021 | .setInstanceCreatedCallback(function (container, _instanceIdentifier, _instance) {
|
8022 | var authInternalProvider = container.getProvider("auth-internal" );
|
8023 | authInternalProvider.initialize();
|
8024 | }));
|
8025 | _registerComponent(new Component("auth-internal" , function (container) {
|
8026 | var auth = _castAuth(container.getProvider("auth" ).getImmediate());
|
8027 | return (function (auth) { return new AuthInterop(auth); })(auth);
|
8028 | }, "PRIVATE" ).setInstantiationMode("EXPLICIT" ));
|
8029 | registerVersion(name, version, getVersionForPlatform(clientPlatform));
|
8030 |
|
8031 | registerVersion(name, version, 'esm5');
|
8032 | }
|
8033 |
|
8034 |
|
8035 |
|
8036 |
|
8037 |
|
8038 |
|
8039 |
|
8040 |
|
8041 |
|
8042 |
|
8043 |
|
8044 |
|
8045 |
|
8046 |
|
8047 |
|
8048 |
|
8049 |
|
8050 |
|
8051 |
|
8052 |
|
8053 |
|
8054 |
|
8055 | var FactorId = {
|
8056 |
|
8057 | PHONE: 'phone'
|
8058 | };
|
8059 |
|
8060 |
|
8061 |
|
8062 |
|
8063 |
|
8064 | var ProviderId = {
|
8065 |
|
8066 | FACEBOOK: 'facebook.com',
|
8067 |
|
8068 | GITHUB: 'github.com',
|
8069 |
|
8070 | GOOGLE: 'google.com',
|
8071 |
|
8072 | PASSWORD: 'password',
|
8073 |
|
8074 | PHONE: 'phone',
|
8075 |
|
8076 | TWITTER: 'twitter.com'
|
8077 | };
|
8078 |
|
8079 |
|
8080 |
|
8081 |
|
8082 |
|
8083 | var SignInMethod = {
|
8084 |
|
8085 | EMAIL_LINK: 'emailLink',
|
8086 |
|
8087 | EMAIL_PASSWORD: 'password',
|
8088 |
|
8089 | FACEBOOK: 'facebook.com',
|
8090 |
|
8091 | GITHUB: 'github.com',
|
8092 |
|
8093 | GOOGLE: 'google.com',
|
8094 |
|
8095 | PHONE: 'phone',
|
8096 |
|
8097 | TWITTER: 'twitter.com'
|
8098 | };
|
8099 |
|
8100 |
|
8101 |
|
8102 |
|
8103 |
|
8104 | var OperationType = {
|
8105 |
|
8106 | LINK: 'link',
|
8107 |
|
8108 | REAUTHENTICATE: 'reauthenticate',
|
8109 |
|
8110 | SIGN_IN: 'signIn'
|
8111 | };
|
8112 |
|
8113 |
|
8114 |
|
8115 |
|
8116 |
|
8117 | var ActionCodeOperation = {
|
8118 |
|
8119 | EMAIL_SIGNIN: 'EMAIL_SIGNIN',
|
8120 |
|
8121 | PASSWORD_RESET: 'PASSWORD_RESET',
|
8122 |
|
8123 | RECOVER_EMAIL: 'RECOVER_EMAIL',
|
8124 |
|
8125 | REVERT_SECOND_FACTOR_ADDITION: 'REVERT_SECOND_FACTOR_ADDITION',
|
8126 |
|
8127 | VERIFY_AND_CHANGE_EMAIL: 'VERIFY_AND_CHANGE_EMAIL',
|
8128 |
|
8129 | VERIFY_EMAIL: 'VERIFY_EMAIL'
|
8130 | };
|
8131 |
|
8132 |
|
8133 |
|
8134 |
|
8135 |
|
8136 |
|
8137 |
|
8138 |
|
8139 |
|
8140 |
|
8141 |
|
8142 |
|
8143 |
|
8144 |
|
8145 |
|
8146 |
|
8147 |
|
8148 |
|
8149 |
|
8150 |
|
8151 | var BrowserPersistenceClass = (function () {
|
8152 | function BrowserPersistenceClass(storageRetriever, type) {
|
8153 | this.storageRetriever = storageRetriever;
|
8154 | this.type = type;
|
8155 | }
|
8156 | BrowserPersistenceClass.prototype._isAvailable = function () {
|
8157 | try {
|
8158 | if (!this.storage) {
|
8159 | return Promise.resolve(false);
|
8160 | }
|
8161 | this.storage.setItem(STORAGE_AVAILABLE_KEY, '1');
|
8162 | this.storage.removeItem(STORAGE_AVAILABLE_KEY);
|
8163 | return Promise.resolve(true);
|
8164 | }
|
8165 | catch (_a) {
|
8166 | return Promise.resolve(false);
|
8167 | }
|
8168 | };
|
8169 | BrowserPersistenceClass.prototype._set = function (key, value) {
|
8170 | this.storage.setItem(key, JSON.stringify(value));
|
8171 | return Promise.resolve();
|
8172 | };
|
8173 | BrowserPersistenceClass.prototype._get = function (key) {
|
8174 | var json = this.storage.getItem(key);
|
8175 | return Promise.resolve(json ? JSON.parse(json) : null);
|
8176 | };
|
8177 | BrowserPersistenceClass.prototype._remove = function (key) {
|
8178 | this.storage.removeItem(key);
|
8179 | return Promise.resolve();
|
8180 | };
|
8181 | Object.defineProperty(BrowserPersistenceClass.prototype, "storage", {
|
8182 | get: function () {
|
8183 | return this.storageRetriever();
|
8184 | },
|
8185 | enumerable: false,
|
8186 | configurable: true
|
8187 | });
|
8188 | return BrowserPersistenceClass;
|
8189 | }());
|
8190 |
|
8191 |
|
8192 |
|
8193 |
|
8194 |
|
8195 |
|
8196 |
|
8197 |
|
8198 |
|
8199 |
|
8200 |
|
8201 |
|
8202 |
|
8203 |
|
8204 |
|
8205 |
|
8206 |
|
8207 | function _iframeCannotSyncWebStorage() {
|
8208 | var ua = getUA();
|
8209 | return _isSafari(ua) || _isIOS(ua);
|
8210 | }
|
8211 |
|
8212 | var _POLLING_INTERVAL_MS = 1000;
|
8213 |
|
8214 | var IE10_LOCAL_STORAGE_SYNC_DELAY = 10;
|
8215 | var BrowserLocalPersistence = (function (_super) {
|
8216 | __extends(BrowserLocalPersistence, _super);
|
8217 | function BrowserLocalPersistence() {
|
8218 | var _this = _super.call(this, function () { return window.localStorage; }, "LOCAL" ) || this;
|
8219 | _this.boundEventHandler = function (event, poll) { return _this.onStorageEvent(event, poll); };
|
8220 | _this.listeners = {};
|
8221 | _this.localCache = {};
|
8222 |
|
8223 |
|
8224 | _this.pollTimer = null;
|
8225 |
|
8226 | _this.safariLocalStorageNotSynced = _iframeCannotSyncWebStorage() && _isIframe();
|
8227 |
|
8228 | _this.fallbackToPolling = _isMobileBrowser();
|
8229 | _this._shouldAllowMigration = true;
|
8230 | return _this;
|
8231 | }
|
8232 | BrowserLocalPersistence.prototype.forAllChangedKeys = function (cb) {
|
8233 |
|
8234 | for (var _i = 0, _a = Object.keys(this.listeners); _i < _a.length; _i++) {
|
8235 | var key = _a[_i];
|
8236 |
|
8237 | var newValue = this.storage.getItem(key);
|
8238 | var oldValue = this.localCache[key];
|
8239 |
|
8240 |
|
8241 | if (newValue !== oldValue) {
|
8242 | cb(key, oldValue, newValue);
|
8243 | }
|
8244 | }
|
8245 | };
|
8246 | BrowserLocalPersistence.prototype.onStorageEvent = function (event, poll) {
|
8247 | var _this = this;
|
8248 | if (poll === void 0) { poll = false; }
|
8249 |
|
8250 | if (!event.key) {
|
8251 | this.forAllChangedKeys(function (key, _oldValue, newValue) {
|
8252 | _this.notifyListeners(key, newValue);
|
8253 | });
|
8254 | return;
|
8255 | }
|
8256 | var key = event.key;
|
8257 |
|
8258 |
|
8259 | if (poll) {
|
8260 |
|
8261 |
|
8262 | this.detachListener();
|
8263 | }
|
8264 | else {
|
8265 |
|
8266 |
|
8267 | this.stopPolling();
|
8268 | }
|
8269 |
|
8270 |
|
8271 | if (this.safariLocalStorageNotSynced) {
|
8272 |
|
8273 | var storedValue_1 = this.storage.getItem(key);
|
8274 |
|
8275 | if (event.newValue !== storedValue_1) {
|
8276 | if (event.newValue !== null) {
|
8277 |
|
8278 | this.storage.setItem(key, event.newValue);
|
8279 | }
|
8280 | else {
|
8281 |
|
8282 | this.storage.removeItem(key);
|
8283 | }
|
8284 | }
|
8285 | else if (this.localCache[key] === event.newValue && !poll) {
|
8286 |
|
8287 | return;
|
8288 | }
|
8289 | }
|
8290 | var triggerListeners = function () {
|
8291 |
|
8292 |
|
8293 | var storedValue = _this.storage.getItem(key);
|
8294 | if (!poll && _this.localCache[key] === storedValue) {
|
8295 |
|
8296 |
|
8297 | return;
|
8298 | }
|
8299 | _this.notifyListeners(key, storedValue);
|
8300 | };
|
8301 | var storedValue = this.storage.getItem(key);
|
8302 | if (_isIE10() &&
|
8303 | storedValue !== event.newValue &&
|
8304 | event.newValue !== event.oldValue) {
|
8305 |
|
8306 |
|
8307 |
|
8308 |
|
8309 | setTimeout(triggerListeners, IE10_LOCAL_STORAGE_SYNC_DELAY);
|
8310 | }
|
8311 | else {
|
8312 | triggerListeners();
|
8313 | }
|
8314 | };
|
8315 | BrowserLocalPersistence.prototype.notifyListeners = function (key, value) {
|
8316 | this.localCache[key] = value;
|
8317 | var listeners = this.listeners[key];
|
8318 | if (listeners) {
|
8319 | for (var _i = 0, _a = Array.from(listeners); _i < _a.length; _i++) {
|
8320 | var listener = _a[_i];
|
8321 | listener(value ? JSON.parse(value) : value);
|
8322 | }
|
8323 | }
|
8324 | };
|
8325 | BrowserLocalPersistence.prototype.startPolling = function () {
|
8326 | var _this = this;
|
8327 | this.stopPolling();
|
8328 | this.pollTimer = setInterval(function () {
|
8329 | _this.forAllChangedKeys(function (key, oldValue, newValue) {
|
8330 | _this.onStorageEvent(new StorageEvent('storage', {
|
8331 | key: key,
|
8332 | oldValue: oldValue,
|
8333 | newValue: newValue
|
8334 | }),
|
8335 | true);
|
8336 | });
|
8337 | }, _POLLING_INTERVAL_MS);
|
8338 | };
|
8339 | BrowserLocalPersistence.prototype.stopPolling = function () {
|
8340 | if (this.pollTimer) {
|
8341 | clearInterval(this.pollTimer);
|
8342 | this.pollTimer = null;
|
8343 | }
|
8344 | };
|
8345 | BrowserLocalPersistence.prototype.attachListener = function () {
|
8346 | window.addEventListener('storage', this.boundEventHandler);
|
8347 | };
|
8348 | BrowserLocalPersistence.prototype.detachListener = function () {
|
8349 | window.removeEventListener('storage', this.boundEventHandler);
|
8350 | };
|
8351 | BrowserLocalPersistence.prototype._addListener = function (key, listener) {
|
8352 | if (Object.keys(this.listeners).length === 0) {
|
8353 |
|
8354 |
|
8355 |
|
8356 |
|
8357 | if (this.fallbackToPolling) {
|
8358 | this.startPolling();
|
8359 | }
|
8360 | else {
|
8361 | this.attachListener();
|
8362 | }
|
8363 | }
|
8364 | if (!this.listeners[key]) {
|
8365 | this.listeners[key] = new Set();
|
8366 |
|
8367 | this.localCache[key] = this.storage.getItem(key);
|
8368 | }
|
8369 | this.listeners[key].add(listener);
|
8370 | };
|
8371 | BrowserLocalPersistence.prototype._removeListener = function (key, listener) {
|
8372 | if (this.listeners[key]) {
|
8373 | this.listeners[key].delete(listener);
|
8374 | if (this.listeners[key].size === 0) {
|
8375 | delete this.listeners[key];
|
8376 | }
|
8377 | }
|
8378 | if (Object.keys(this.listeners).length === 0) {
|
8379 | this.detachListener();
|
8380 | this.stopPolling();
|
8381 | }
|
8382 | };
|
8383 |
|
8384 | BrowserLocalPersistence.prototype._set = function (key, value) {
|
8385 | return __awaiter(this, void 0, void 0, function () {
|
8386 | return __generator(this, function (_a) {
|
8387 | switch (_a.label) {
|
8388 | case 0: return [4 , _super.prototype._set.call(this, key, value)];
|
8389 | case 1:
|
8390 | _a.sent();
|
8391 | this.localCache[key] = JSON.stringify(value);
|
8392 | return [2 ];
|
8393 | }
|
8394 | });
|
8395 | });
|
8396 | };
|
8397 | BrowserLocalPersistence.prototype._get = function (key) {
|
8398 | return __awaiter(this, void 0, void 0, function () {
|
8399 | var value;
|
8400 | return __generator(this, function (_a) {
|
8401 | switch (_a.label) {
|
8402 | case 0: return [4 , _super.prototype._get.call(this, key)];
|
8403 | case 1:
|
8404 | value = _a.sent();
|
8405 | this.localCache[key] = JSON.stringify(value);
|
8406 | return [2 , value];
|
8407 | }
|
8408 | });
|
8409 | });
|
8410 | };
|
8411 | BrowserLocalPersistence.prototype._remove = function (key) {
|
8412 | return __awaiter(this, void 0, void 0, function () {
|
8413 | return __generator(this, function (_a) {
|
8414 | switch (_a.label) {
|
8415 | case 0: return [4 , _super.prototype._remove.call(this, key)];
|
8416 | case 1:
|
8417 | _a.sent();
|
8418 | delete this.localCache[key];
|
8419 | return [2 ];
|
8420 | }
|
8421 | });
|
8422 | });
|
8423 | };
|
8424 | BrowserLocalPersistence.type = 'LOCAL';
|
8425 | return BrowserLocalPersistence;
|
8426 | }(BrowserPersistenceClass));
|
8427 |
|
8428 |
|
8429 |
|
8430 |
|
8431 |
|
8432 |
|
8433 | var browserLocalPersistence = BrowserLocalPersistence;
|
8434 |
|
8435 |
|
8436 |
|
8437 |
|
8438 |
|
8439 |
|
8440 |
|
8441 |
|
8442 |
|
8443 |
|
8444 |
|
8445 |
|
8446 |
|
8447 |
|
8448 |
|
8449 |
|
8450 |
|
8451 | var BrowserSessionPersistence = (function (_super) {
|
8452 | __extends(BrowserSessionPersistence, _super);
|
8453 | function BrowserSessionPersistence() {
|
8454 | return _super.call(this, function () { return window.sessionStorage; }, "SESSION" ) || this;
|
8455 | }
|
8456 | BrowserSessionPersistence.prototype._addListener = function (_key, _listener) {
|
8457 |
|
8458 | return;
|
8459 | };
|
8460 | BrowserSessionPersistence.prototype._removeListener = function (_key, _listener) {
|
8461 |
|
8462 | return;
|
8463 | };
|
8464 | BrowserSessionPersistence.type = 'SESSION';
|
8465 | return BrowserSessionPersistence;
|
8466 | }(BrowserPersistenceClass));
|
8467 |
|
8468 |
|
8469 |
|
8470 |
|
8471 |
|
8472 |
|
8473 | var browserSessionPersistence = BrowserSessionPersistence;
|
8474 |
|
8475 |
|
8476 |
|
8477 |
|
8478 |
|
8479 |
|
8480 |
|
8481 |
|
8482 |
|
8483 |
|
8484 |
|
8485 |
|
8486 |
|
8487 |
|
8488 |
|
8489 |
|
8490 |
|
8491 |
|
8492 |
|
8493 |
|
8494 |
|
8495 |
|
8496 | function _withDefaultResolver(auth, resolverOverride) {
|
8497 | if (resolverOverride) {
|
8498 | return _getInstance(resolverOverride);
|
8499 | }
|
8500 | _assert(auth._popupRedirectResolver, auth, "argument-error" );
|
8501 | return auth._popupRedirectResolver;
|
8502 | }
|
8503 |
|
8504 |
|
8505 |
|
8506 |
|
8507 |
|
8508 |
|
8509 |
|
8510 |
|
8511 |
|
8512 |
|
8513 |
|
8514 |
|
8515 |
|
8516 |
|
8517 |
|
8518 |
|
8519 |
|
8520 | var IdpCredential = (function (_super) {
|
8521 | __extends(IdpCredential, _super);
|
8522 | function IdpCredential(params) {
|
8523 | var _this = _super.call(this, "custom" , "custom" ) || this;
|
8524 | _this.params = params;
|
8525 | return _this;
|
8526 | }
|
8527 | IdpCredential.prototype._getIdTokenResponse = function (auth) {
|
8528 | return signInWithIdp(auth, this._buildIdpRequest());
|
8529 | };
|
8530 | IdpCredential.prototype._linkToIdToken = function (auth, idToken) {
|
8531 | return signInWithIdp(auth, this._buildIdpRequest(idToken));
|
8532 | };
|
8533 | IdpCredential.prototype._getReauthenticationResolver = function (auth) {
|
8534 | return signInWithIdp(auth, this._buildIdpRequest());
|
8535 | };
|
8536 | IdpCredential.prototype._buildIdpRequest = function (idToken) {
|
8537 | var request = {
|
8538 | requestUri: this.params.requestUri,
|
8539 | sessionId: this.params.sessionId,
|
8540 | postBody: this.params.postBody,
|
8541 | tenantId: this.params.tenantId,
|
8542 | pendingToken: this.params.pendingToken,
|
8543 | returnSecureToken: true,
|
8544 | returnIdpCredential: true
|
8545 | };
|
8546 | if (idToken) {
|
8547 | request.idToken = idToken;
|
8548 | }
|
8549 | return request;
|
8550 | };
|
8551 | return IdpCredential;
|
8552 | }(AuthCredential));
|
8553 | function _signIn(params) {
|
8554 | return _signInWithCredential(params.auth, new IdpCredential(params), params.bypassAuthState);
|
8555 | }
|
8556 | function _reauth(params) {
|
8557 | var auth = params.auth, user = params.user;
|
8558 | _assert(user, auth, "internal-error" );
|
8559 | return _reauthenticate(user, new IdpCredential(params), params.bypassAuthState);
|
8560 | }
|
8561 | function _link(params) {
|
8562 | return __awaiter(this, void 0, void 0, function () {
|
8563 | var auth, user;
|
8564 | return __generator(this, function (_a) {
|
8565 | auth = params.auth, user = params.user;
|
8566 | _assert(user, auth, "internal-error" );
|
8567 | return [2 , _link$1(user, new IdpCredential(params), params.bypassAuthState)];
|
8568 | });
|
8569 | });
|
8570 | }
|
8571 |
|
8572 |
|
8573 |
|
8574 |
|
8575 |
|
8576 |
|
8577 |
|
8578 |
|
8579 |
|
8580 |
|
8581 |
|
8582 |
|
8583 |
|
8584 |
|
8585 |
|
8586 |
|
8587 |
|
8588 |
|
8589 |
|
8590 |
|
8591 |
|
8592 | var AbstractPopupRedirectOperation = (function () {
|
8593 | function AbstractPopupRedirectOperation(auth, filter, resolver, user, bypassAuthState) {
|
8594 | if (bypassAuthState === void 0) { bypassAuthState = false; }
|
8595 | this.auth = auth;
|
8596 | this.resolver = resolver;
|
8597 | this.user = user;
|
8598 | this.bypassAuthState = bypassAuthState;
|
8599 | this.pendingPromise = null;
|
8600 | this.eventManager = null;
|
8601 | this.filter = Array.isArray(filter) ? filter : [filter];
|
8602 | }
|
8603 | AbstractPopupRedirectOperation.prototype.execute = function () {
|
8604 | var _this = this;
|
8605 | return new Promise(function (resolve, reject) { return __awaiter(_this, void 0, void 0, function () {
|
8606 | var _a, e_1;
|
8607 | return __generator(this, function (_b) {
|
8608 | switch (_b.label) {
|
8609 | case 0:
|
8610 | this.pendingPromise = { resolve: resolve, reject: reject };
|
8611 | _b.label = 1;
|
8612 | case 1:
|
8613 | _b.trys.push([1, 4, , 5]);
|
8614 | _a = this;
|
8615 | return [4 , this.resolver._initialize(this.auth)];
|
8616 | case 2:
|
8617 | _a.eventManager = _b.sent();
|
8618 | return [4 , this.onExecution()];
|
8619 | case 3:
|
8620 | _b.sent();
|
8621 | this.eventManager.registerConsumer(this);
|
8622 | return [3 , 5];
|
8623 | case 4:
|
8624 | e_1 = _b.sent();
|
8625 | this.reject(e_1);
|
8626 | return [3 , 5];
|
8627 | case 5: return [2 ];
|
8628 | }
|
8629 | });
|
8630 | }); });
|
8631 | };
|
8632 | AbstractPopupRedirectOperation.prototype.onAuthEvent = function (event) {
|
8633 | return __awaiter(this, void 0, void 0, function () {
|
8634 | var urlResponse, sessionId, postBody, tenantId, error, type, params, _a, e_2;
|
8635 | return __generator(this, function (_b) {
|
8636 | switch (_b.label) {
|
8637 | case 0:
|
8638 | urlResponse = event.urlResponse, sessionId = event.sessionId, postBody = event.postBody, tenantId = event.tenantId, error = event.error, type = event.type;
|
8639 | if (error) {
|
8640 | this.reject(error);
|
8641 | return [2 ];
|
8642 | }
|
8643 | params = {
|
8644 | auth: this.auth,
|
8645 | requestUri: urlResponse,
|
8646 | sessionId: sessionId,
|
8647 | tenantId: tenantId || undefined,
|
8648 | postBody: postBody || undefined,
|
8649 | user: this.user,
|
8650 | bypassAuthState: this.bypassAuthState
|
8651 | };
|
8652 | _b.label = 1;
|
8653 | case 1:
|
8654 | _b.trys.push([1, 3, , 4]);
|
8655 | _a = this.resolve;
|
8656 | return [4 , this.getIdpTask(type)(params)];
|
8657 | case 2:
|
8658 | _a.apply(this, [_b.sent()]);
|
8659 | return [3 , 4];
|
8660 | case 3:
|
8661 | e_2 = _b.sent();
|
8662 | this.reject(e_2);
|
8663 | return [3 , 4];
|
8664 | case 4: return [2 ];
|
8665 | }
|
8666 | });
|
8667 | });
|
8668 | };
|
8669 | AbstractPopupRedirectOperation.prototype.onError = function (error) {
|
8670 | this.reject(error);
|
8671 | };
|
8672 | AbstractPopupRedirectOperation.prototype.getIdpTask = function (type) {
|
8673 | switch (type) {
|
8674 | case "signInViaPopup" :
|
8675 | case "signInViaRedirect" :
|
8676 | return _signIn;
|
8677 | case "linkViaPopup" :
|
8678 | case "linkViaRedirect" :
|
8679 | return _link;
|
8680 | case "reauthViaPopup" :
|
8681 | case "reauthViaRedirect" :
|
8682 | return _reauth;
|
8683 | default:
|
8684 | _fail(this.auth, "internal-error" );
|
8685 | }
|
8686 | };
|
8687 | AbstractPopupRedirectOperation.prototype.resolve = function (cred) {
|
8688 | debugAssert(this.pendingPromise, 'Pending promise was never set');
|
8689 | this.pendingPromise.resolve(cred);
|
8690 | this.unregisterAndCleanUp();
|
8691 | };
|
8692 | AbstractPopupRedirectOperation.prototype.reject = function (error) {
|
8693 | debugAssert(this.pendingPromise, 'Pending promise was never set');
|
8694 | this.pendingPromise.reject(error);
|
8695 | this.unregisterAndCleanUp();
|
8696 | };
|
8697 | AbstractPopupRedirectOperation.prototype.unregisterAndCleanUp = function () {
|
8698 | if (this.eventManager) {
|
8699 | this.eventManager.unregisterConsumer(this);
|
8700 | }
|
8701 | this.pendingPromise = null;
|
8702 | this.cleanUp();
|
8703 | };
|
8704 | return AbstractPopupRedirectOperation;
|
8705 | }());
|
8706 |
|
8707 |
|
8708 |
|
8709 |
|
8710 |
|
8711 |
|
8712 |
|
8713 |
|
8714 |
|
8715 |
|
8716 |
|
8717 |
|
8718 |
|
8719 |
|
8720 |
|
8721 |
|
8722 |
|
8723 | var PENDING_REDIRECT_KEY = 'pendingRedirect';
|
8724 |
|
8725 |
|
8726 | var redirectOutcomeMap = new Map();
|
8727 | var RedirectAction = (function (_super) {
|
8728 | __extends(RedirectAction, _super);
|
8729 | function RedirectAction(auth, resolver, bypassAuthState) {
|
8730 | if (bypassAuthState === void 0) { bypassAuthState = false; }
|
8731 | var _this = _super.call(this, auth, [
|
8732 | "signInViaRedirect" ,
|
8733 | "linkViaRedirect" ,
|
8734 | "reauthViaRedirect" ,
|
8735 | "unknown"
|
8736 | ], resolver, undefined, bypassAuthState) || this;
|
8737 | _this.eventId = null;
|
8738 | return _this;
|
8739 | }
|
8740 | |
8741 |
|
8742 |
|
8743 |
|
8744 | RedirectAction.prototype.execute = function () {
|
8745 | return __awaiter(this, void 0, void 0, function () {
|
8746 | var readyOutcome, hasPendingRedirect, result_1, _a, e_1;
|
8747 | return __generator(this, function (_b) {
|
8748 | switch (_b.label) {
|
8749 | case 0:
|
8750 | readyOutcome = redirectOutcomeMap.get(this.auth._key());
|
8751 | if (!!readyOutcome) return [3 , 8];
|
8752 | _b.label = 1;
|
8753 | case 1:
|
8754 | _b.trys.push([1, 6, , 7]);
|
8755 | return [4 , _getAndClearPendingRedirectStatus(this.resolver, this.auth)];
|
8756 | case 2:
|
8757 | hasPendingRedirect = _b.sent();
|
8758 | if (!hasPendingRedirect) return [3 , 4];
|
8759 | return [4 , _super.prototype.execute.call(this)];
|
8760 | case 3:
|
8761 | _a = _b.sent();
|
8762 | return [3 , 5];
|
8763 | case 4:
|
8764 | _a = null;
|
8765 | _b.label = 5;
|
8766 | case 5:
|
8767 | result_1 = _a;
|
8768 | readyOutcome = function () { return Promise.resolve(result_1); };
|
8769 | return [3 , 7];
|
8770 | case 6:
|
8771 | e_1 = _b.sent();
|
8772 | readyOutcome = function () { return Promise.reject(e_1); };
|
8773 | return [3 , 7];
|
8774 | case 7:
|
8775 | redirectOutcomeMap.set(this.auth._key(), readyOutcome);
|
8776 | _b.label = 8;
|
8777 | case 8:
|
8778 |
|
8779 |
|
8780 | if (!this.bypassAuthState) {
|
8781 | redirectOutcomeMap.set(this.auth._key(), function () { return Promise.resolve(null); });
|
8782 | }
|
8783 | return [2 , readyOutcome()];
|
8784 | }
|
8785 | });
|
8786 | });
|
8787 | };
|
8788 | RedirectAction.prototype.onAuthEvent = function (event) {
|
8789 | return __awaiter(this, void 0, void 0, function () {
|
8790 | var user;
|
8791 | return __generator(this, function (_a) {
|
8792 | switch (_a.label) {
|
8793 | case 0:
|
8794 | if (event.type === "signInViaRedirect" ) {
|
8795 | return [2 , _super.prototype.onAuthEvent.call(this, event)];
|
8796 | }
|
8797 | else if (event.type === "unknown" ) {
|
8798 |
|
8799 | this.resolve(null);
|
8800 | return [2 ];
|
8801 | }
|
8802 | if (!event.eventId) return [3 , 2];
|
8803 | return [4 , this.auth._redirectUserForId(event.eventId)];
|
8804 | case 1:
|
8805 | user = _a.sent();
|
8806 | if (user) {
|
8807 | this.user = user;
|
8808 | return [2 , _super.prototype.onAuthEvent.call(this, event)];
|
8809 | }
|
8810 | else {
|
8811 | this.resolve(null);
|
8812 | }
|
8813 | _a.label = 2;
|
8814 | case 2: return [2 ];
|
8815 | }
|
8816 | });
|
8817 | });
|
8818 | };
|
8819 | RedirectAction.prototype.onExecution = function () {
|
8820 | return __awaiter(this, void 0, void 0, function () { return __generator(this, function (_a) {
|
8821 | return [2 ];
|
8822 | }); });
|
8823 | };
|
8824 | RedirectAction.prototype.cleanUp = function () { };
|
8825 | return RedirectAction;
|
8826 | }(AbstractPopupRedirectOperation));
|
8827 | function _getAndClearPendingRedirectStatus(resolver, auth) {
|
8828 | return __awaiter(this, void 0, void 0, function () {
|
8829 | var key, persistence, hasPendingRedirect;
|
8830 | return __generator(this, function (_a) {
|
8831 | switch (_a.label) {
|
8832 | case 0:
|
8833 | key = pendingRedirectKey(auth);
|
8834 | persistence = resolverPersistence(resolver);
|
8835 | return [4 , persistence._isAvailable()];
|
8836 | case 1:
|
8837 | if (!(_a.sent())) {
|
8838 | return [2 , false];
|
8839 | }
|
8840 | return [4 , persistence._get(key)];
|
8841 | case 2:
|
8842 | hasPendingRedirect = (_a.sent()) === 'true';
|
8843 | return [4 , persistence._remove(key)];
|
8844 | case 3:
|
8845 | _a.sent();
|
8846 | return [2 , hasPendingRedirect];
|
8847 | }
|
8848 | });
|
8849 | });
|
8850 | }
|
8851 | function _setPendingRedirectStatus(resolver, auth) {
|
8852 | return __awaiter(this, void 0, void 0, function () {
|
8853 | return __generator(this, function (_a) {
|
8854 | return [2 , resolverPersistence(resolver)._set(pendingRedirectKey(auth), 'true')];
|
8855 | });
|
8856 | });
|
8857 | }
|
8858 | function _clearRedirectOutcomes() {
|
8859 | redirectOutcomeMap.clear();
|
8860 | }
|
8861 | function _overrideRedirectResult(auth, result) {
|
8862 | redirectOutcomeMap.set(auth._key(), result);
|
8863 | }
|
8864 | function resolverPersistence(resolver) {
|
8865 | return _getInstance(resolver._redirectPersistence);
|
8866 | }
|
8867 | function pendingRedirectKey(auth) {
|
8868 | return _persistenceKeyName(PENDING_REDIRECT_KEY, auth.config.apiKey, auth.name);
|
8869 | }
|
8870 |
|
8871 |
|
8872 |
|
8873 |
|
8874 |
|
8875 |
|
8876 |
|
8877 |
|
8878 |
|
8879 |
|
8880 |
|
8881 |
|
8882 |
|
8883 |
|
8884 |
|
8885 |
|
8886 |
|
8887 |
|
8888 |
|
8889 |
|
8890 |
|
8891 |
|
8892 |
|
8893 |
|
8894 |
|
8895 |
|
8896 |
|
8897 |
|
8898 |
|
8899 |
|
8900 |
|
8901 |
|
8902 |
|
8903 |
|
8904 |
|
8905 |
|
8906 |
|
8907 |
|
8908 |
|
8909 |
|
8910 |
|
8911 |
|
8912 |
|
8913 |
|
8914 |
|
8915 |
|
8916 |
|
8917 |
|
8918 |
|
8919 |
|
8920 |
|
8921 |
|
8922 |
|
8923 |
|
8924 |
|
8925 |
|
8926 | function signInWithRedirect(auth, provider, resolver) {
|
8927 | return _signInWithRedirect(auth, provider, resolver);
|
8928 | }
|
8929 | function _signInWithRedirect(auth, provider, resolver) {
|
8930 | return __awaiter(this, void 0, void 0, function () {
|
8931 | var authInternal, resolverInternal;
|
8932 | return __generator(this, function (_a) {
|
8933 | switch (_a.label) {
|
8934 | case 0:
|
8935 | authInternal = _castAuth(auth);
|
8936 | _assertInstanceOf(auth, provider, FederatedAuthProvider);
|
8937 | resolverInternal = _withDefaultResolver(authInternal, resolver);
|
8938 | return [4 , _setPendingRedirectStatus(resolverInternal, authInternal)];
|
8939 | case 1:
|
8940 | _a.sent();
|
8941 | return [2 , resolverInternal._openRedirect(authInternal, provider, "signInViaRedirect" )];
|
8942 | }
|
8943 | });
|
8944 | });
|
8945 | }
|
8946 |
|
8947 |
|
8948 |
|
8949 |
|
8950 |
|
8951 |
|
8952 |
|
8953 |
|
8954 |
|
8955 |
|
8956 |
|
8957 |
|
8958 |
|
8959 |
|
8960 |
|
8961 |
|
8962 |
|
8963 |
|
8964 |
|
8965 |
|
8966 |
|
8967 |
|
8968 |
|
8969 |
|
8970 |
|
8971 |
|
8972 |
|
8973 |
|
8974 | function reauthenticateWithRedirect(user, provider, resolver) {
|
8975 | return _reauthenticateWithRedirect(user, provider, resolver);
|
8976 | }
|
8977 | function _reauthenticateWithRedirect(user, provider, resolver) {
|
8978 | return __awaiter(this, void 0, void 0, function () {
|
8979 | var userInternal, resolverInternal, eventId;
|
8980 | return __generator(this, function (_a) {
|
8981 | switch (_a.label) {
|
8982 | case 0:
|
8983 | userInternal = getModularInstance(user);
|
8984 | _assertInstanceOf(userInternal.auth, provider, FederatedAuthProvider);
|
8985 | resolverInternal = _withDefaultResolver(userInternal.auth, resolver);
|
8986 | return [4 , _setPendingRedirectStatus(resolverInternal, userInternal.auth)];
|
8987 | case 1:
|
8988 | _a.sent();
|
8989 | return [4 , prepareUserForRedirect(userInternal)];
|
8990 | case 2:
|
8991 | eventId = _a.sent();
|
8992 | return [2 , resolverInternal._openRedirect(userInternal.auth, provider, "reauthViaRedirect" , eventId)];
|
8993 | }
|
8994 | });
|
8995 | });
|
8996 | }
|
8997 |
|
8998 |
|
8999 |
|
9000 |
|
9001 |
|
9002 |
|
9003 |
|
9004 |
|
9005 |
|
9006 |
|
9007 |
|
9008 |
|
9009 |
|
9010 |
|
9011 |
|
9012 |
|
9013 |
|
9014 |
|
9015 |
|
9016 |
|
9017 |
|
9018 |
|
9019 |
|
9020 |
|
9021 |
|
9022 | function linkWithRedirect(user, provider, resolver) {
|
9023 | return _linkWithRedirect(user, provider, resolver);
|
9024 | }
|
9025 | function _linkWithRedirect(user, provider, resolver) {
|
9026 | return __awaiter(this, void 0, void 0, function () {
|
9027 | var userInternal, resolverInternal, eventId;
|
9028 | return __generator(this, function (_a) {
|
9029 | switch (_a.label) {
|
9030 | case 0:
|
9031 | userInternal = getModularInstance(user);
|
9032 | _assertInstanceOf(userInternal.auth, provider, FederatedAuthProvider);
|
9033 | resolverInternal = _withDefaultResolver(userInternal.auth, resolver);
|
9034 | return [4 , _assertLinkedStatus(false, userInternal, provider.providerId)];
|
9035 | case 1:
|
9036 | _a.sent();
|
9037 | return [4 , _setPendingRedirectStatus(resolverInternal, userInternal.auth)];
|
9038 | case 2:
|
9039 | _a.sent();
|
9040 | return [4 , prepareUserForRedirect(userInternal)];
|
9041 | case 3:
|
9042 | eventId = _a.sent();
|
9043 | return [2 , resolverInternal._openRedirect(userInternal.auth, provider, "linkViaRedirect" , eventId)];
|
9044 | }
|
9045 | });
|
9046 | });
|
9047 | }
|
9048 |
|
9049 |
|
9050 |
|
9051 |
|
9052 |
|
9053 |
|
9054 |
|
9055 |
|
9056 |
|
9057 |
|
9058 |
|
9059 |
|
9060 |
|
9061 |
|
9062 |
|
9063 |
|
9064 |
|
9065 |
|
9066 |
|
9067 |
|
9068 |
|
9069 |
|
9070 |
|
9071 |
|
9072 |
|
9073 |
|
9074 |
|
9075 |
|
9076 |
|
9077 |
|
9078 |
|
9079 |
|
9080 |
|
9081 |
|
9082 |
|
9083 |
|
9084 |
|
9085 |
|
9086 |
|
9087 | function getRedirectResult(auth, resolver) {
|
9088 | return __awaiter(this, void 0, void 0, function () {
|
9089 | return __generator(this, function (_a) {
|
9090 | switch (_a.label) {
|
9091 | case 0: return [4 , _castAuth(auth)._initializationPromise];
|
9092 | case 1:
|
9093 | _a.sent();
|
9094 | return [2 , _getRedirectResult(auth, resolver, false)];
|
9095 | }
|
9096 | });
|
9097 | });
|
9098 | }
|
9099 | function _getRedirectResult(auth, resolverExtern, bypassAuthState) {
|
9100 | if (bypassAuthState === void 0) { bypassAuthState = false; }
|
9101 | return __awaiter(this, void 0, void 0, function () {
|
9102 | var authInternal, resolver, action, result;
|
9103 | return __generator(this, function (_a) {
|
9104 | switch (_a.label) {
|
9105 | case 0:
|
9106 | authInternal = _castAuth(auth);
|
9107 | resolver = _withDefaultResolver(authInternal, resolverExtern);
|
9108 | action = new RedirectAction(authInternal, resolver, bypassAuthState);
|
9109 | return [4 , action.execute()];
|
9110 | case 1:
|
9111 | result = _a.sent();
|
9112 | if (!(result && !bypassAuthState)) return [3 , 4];
|
9113 | delete result.user._redirectEventId;
|
9114 | return [4 , authInternal._persistUserIfCurrent(result.user)];
|
9115 | case 2:
|
9116 | _a.sent();
|
9117 | return [4 , authInternal._setRedirectUser(null, resolverExtern)];
|
9118 | case 3:
|
9119 | _a.sent();
|
9120 | _a.label = 4;
|
9121 | case 4: return [2 , result];
|
9122 | }
|
9123 | });
|
9124 | });
|
9125 | }
|
9126 | function prepareUserForRedirect(user) {
|
9127 | return __awaiter(this, void 0, void 0, function () {
|
9128 | var eventId;
|
9129 | return __generator(this, function (_a) {
|
9130 | switch (_a.label) {
|
9131 | case 0:
|
9132 | eventId = _generateEventId(user.uid + ":::");
|
9133 | user._redirectEventId = eventId;
|
9134 | return [4 , user.auth._setRedirectUser(user)];
|
9135 | case 1:
|
9136 | _a.sent();
|
9137 | return [4 , user.auth._persistUserIfCurrent(user)];
|
9138 | case 2:
|
9139 | _a.sent();
|
9140 | return [2 , eventId];
|
9141 | }
|
9142 | });
|
9143 | });
|
9144 | }
|
9145 |
|
9146 |
|
9147 |
|
9148 |
|
9149 |
|
9150 |
|
9151 |
|
9152 |
|
9153 |
|
9154 |
|
9155 |
|
9156 |
|
9157 |
|
9158 |
|
9159 |
|
9160 |
|
9161 |
|
9162 |
|
9163 |
|
9164 |
|
9165 |
|
9166 |
|
9167 | var WIDGET_PATH = '__/auth/handler';
|
9168 |
|
9169 |
|
9170 |
|
9171 |
|
9172 |
|
9173 | var EMULATOR_WIDGET_PATH = 'emulator/auth/handler';
|
9174 | function _getRedirectUrl(auth, provider, authType, redirectUrl, eventId, additionalParams) {
|
9175 | _assert(auth.config.authDomain, auth, "auth-domain-config-required" );
|
9176 | _assert(auth.config.apiKey, auth, "invalid-api-key" );
|
9177 | var params = {
|
9178 | apiKey: auth.config.apiKey,
|
9179 | appName: auth.name,
|
9180 | authType: authType,
|
9181 | redirectUrl: redirectUrl,
|
9182 | v: SDK_VERSION,
|
9183 | eventId: eventId
|
9184 | };
|
9185 | if (provider instanceof FederatedAuthProvider) {
|
9186 | provider.setDefaultLanguage(auth.languageCode);
|
9187 | params.providerId = provider.providerId || '';
|
9188 | if (!isEmpty(provider.getCustomParameters())) {
|
9189 | params.customParameters = JSON.stringify(provider.getCustomParameters());
|
9190 | }
|
9191 |
|
9192 | for (var _i = 0, _a = Object.entries(additionalParams || {}); _i < _a.length; _i++) {
|
9193 | var _b = _a[_i], key = _b[0], value = _b[1];
|
9194 | params[key] = value;
|
9195 | }
|
9196 | }
|
9197 | if (provider instanceof BaseOAuthProvider) {
|
9198 | var scopes = provider.getScopes().filter(function (scope) { return scope !== ''; });
|
9199 | if (scopes.length > 0) {
|
9200 | params.scopes = scopes.join(',');
|
9201 | }
|
9202 | }
|
9203 | if (auth.tenantId) {
|
9204 | params.tid = auth.tenantId;
|
9205 | }
|
9206 |
|
9207 |
|
9208 | var paramsDict = params;
|
9209 | for (var _c = 0, _d = Object.keys(paramsDict); _c < _d.length; _c++) {
|
9210 | var key = _d[_c];
|
9211 | if (paramsDict[key] === undefined) {
|
9212 | delete paramsDict[key];
|
9213 | }
|
9214 | }
|
9215 | return getHandlerBase(auth) + "?" + querystring(paramsDict).slice(1);
|
9216 | }
|
9217 | function getHandlerBase(_a) {
|
9218 | var config = _a.config;
|
9219 | if (!config.emulator) {
|
9220 | return "https://" + config.authDomain + "/" + WIDGET_PATH;
|
9221 | }
|
9222 | return _emulatorUrl(config, EMULATOR_WIDGET_PATH);
|
9223 | }
|
9224 |
|
9225 |
|
9226 |
|
9227 |
|
9228 |
|
9229 |
|
9230 |
|
9231 |
|
9232 |
|
9233 |
|
9234 |
|
9235 |
|
9236 |
|
9237 |
|
9238 |
|
9239 |
|
9240 |
|
9241 | function _cordovaWindow() {
|
9242 | return window;
|
9243 | }
|
9244 |
|
9245 |
|
9246 |
|
9247 |
|
9248 |
|
9249 |
|
9250 |
|
9251 |
|
9252 |
|
9253 |
|
9254 |
|
9255 |
|
9256 |
|
9257 |
|
9258 |
|
9259 |
|
9260 |
|
9261 | function _getProjectConfig(auth, request) {
|
9262 | if (request === void 0) { request = {}; }
|
9263 | return __awaiter(this, void 0, void 0, function () {
|
9264 | return __generator(this, function (_a) {
|
9265 | return [2 , _performApiRequest(auth, "GET" , "/v1/projects" , request)];
|
9266 | });
|
9267 | });
|
9268 | }
|
9269 |
|
9270 |
|
9271 |
|
9272 |
|
9273 |
|
9274 |
|
9275 |
|
9276 |
|
9277 |
|
9278 |
|
9279 |
|
9280 |
|
9281 |
|
9282 |
|
9283 |
|
9284 |
|
9285 |
|
9286 |
|
9287 |
|
9288 |
|
9289 |
|
9290 | var REDIRECT_TIMEOUT_MS = 2000;
|
9291 |
|
9292 |
|
9293 |
|
9294 | function _generateHandlerUrl(auth, event, provider) {
|
9295 | var _a;
|
9296 | return __awaiter(this, void 0, void 0, function () {
|
9297 | var BuildInfo, sessionDigest, additionalParams;
|
9298 | return __generator(this, function (_b) {
|
9299 | switch (_b.label) {
|
9300 | case 0:
|
9301 | BuildInfo = _cordovaWindow().BuildInfo;
|
9302 | debugAssert(event.sessionId, 'AuthEvent did not contain a session ID');
|
9303 | return [4 , computeSha256(event.sessionId)];
|
9304 | case 1:
|
9305 | sessionDigest = _b.sent();
|
9306 | additionalParams = {};
|
9307 | if (_isIOS()) {
|
9308 |
|
9309 | additionalParams['ibi'] = BuildInfo.packageName;
|
9310 | }
|
9311 | else if (_isAndroid()) {
|
9312 |
|
9313 | additionalParams['apn'] = BuildInfo.packageName;
|
9314 | }
|
9315 | else {
|
9316 | _fail(auth, "operation-not-supported-in-this-environment" );
|
9317 | }
|
9318 |
|
9319 | if (BuildInfo.displayName) {
|
9320 | additionalParams['appDisplayName'] = BuildInfo.displayName;
|
9321 | }
|
9322 |
|
9323 | additionalParams['sessionId'] = sessionDigest;
|
9324 | return [2 , _getRedirectUrl(auth, provider, event.type, undefined, (_a = event.eventId) !== null && _a !== void 0 ? _a : undefined, additionalParams)];
|
9325 | }
|
9326 | });
|
9327 | });
|
9328 | }
|
9329 |
|
9330 |
|
9331 |
|
9332 | function _validateOrigin(auth) {
|
9333 | return __awaiter(this, void 0, void 0, function () {
|
9334 | var BuildInfo, request;
|
9335 | return __generator(this, function (_a) {
|
9336 | switch (_a.label) {
|
9337 | case 0:
|
9338 | BuildInfo = _cordovaWindow().BuildInfo;
|
9339 | request = {};
|
9340 | if (_isIOS()) {
|
9341 | request.iosBundleId = BuildInfo.packageName;
|
9342 | }
|
9343 | else if (_isAndroid()) {
|
9344 | request.androidPackageName = BuildInfo.packageName;
|
9345 | }
|
9346 | else {
|
9347 | _fail(auth, "operation-not-supported-in-this-environment" );
|
9348 | }
|
9349 |
|
9350 | return [4 , _getProjectConfig(auth, request)];
|
9351 | case 1:
|
9352 |
|
9353 | _a.sent();
|
9354 | return [2 ];
|
9355 | }
|
9356 | });
|
9357 | });
|
9358 | }
|
9359 | function _performRedirect(handlerUrl) {
|
9360 |
|
9361 | var cordova = _cordovaWindow().cordova;
|
9362 | return new Promise(function (resolve) {
|
9363 | cordova.plugins.browsertab.isAvailable(function (browserTabIsAvailable) {
|
9364 | var iabRef = null;
|
9365 | if (browserTabIsAvailable) {
|
9366 | cordova.plugins.browsertab.openUrl(handlerUrl);
|
9367 | }
|
9368 | else {
|
9369 |
|
9370 | iabRef = cordova.InAppBrowser.open(handlerUrl, _isIOS7Or8() ? '_blank' : '_system', 'location=yes');
|
9371 | }
|
9372 | resolve(iabRef);
|
9373 | });
|
9374 | });
|
9375 | }
|
9376 |
|
9377 |
|
9378 |
|
9379 |
|
9380 |
|
9381 |
|
9382 | function _waitForAppResume(auth, eventListener, iabRef) {
|
9383 | return __awaiter(this, void 0, void 0, function () {
|
9384 | var cordova, cleanup;
|
9385 | return __generator(this, function (_a) {
|
9386 | switch (_a.label) {
|
9387 | case 0:
|
9388 | cordova = _cordovaWindow().cordova;
|
9389 | cleanup = function () { };
|
9390 | _a.label = 1;
|
9391 | case 1:
|
9392 | _a.trys.push([1, , 3, 4]);
|
9393 | return [4 , new Promise(function (resolve, reject) {
|
9394 | var onCloseTimer = null;
|
9395 |
|
9396 | function authEventSeen() {
|
9397 | var _a;
|
9398 |
|
9399 |
|
9400 | resolve();
|
9401 | var closeBrowserTab = (_a = cordova.plugins.browsertab) === null || _a === void 0 ? void 0 : _a.close;
|
9402 | if (typeof closeBrowserTab === 'function') {
|
9403 | closeBrowserTab();
|
9404 | }
|
9405 |
|
9406 |
|
9407 | if (typeof (iabRef === null || iabRef === void 0 ? void 0 : iabRef.close) === 'function') {
|
9408 | iabRef.close();
|
9409 | }
|
9410 | }
|
9411 | function resumed() {
|
9412 | if (onCloseTimer) {
|
9413 |
|
9414 | return;
|
9415 | }
|
9416 | onCloseTimer = window.setTimeout(function () {
|
9417 |
|
9418 | reject(_createError(auth, "redirect-cancelled-by-user" ));
|
9419 | }, REDIRECT_TIMEOUT_MS);
|
9420 | }
|
9421 | function visibilityChanged() {
|
9422 | if ((document === null || document === void 0 ? void 0 : document.visibilityState) === 'visible') {
|
9423 | resumed();
|
9424 | }
|
9425 | }
|
9426 |
|
9427 |
|
9428 | eventListener.addPassiveListener(authEventSeen);
|
9429 |
|
9430 | document.addEventListener('resume', resumed, false);
|
9431 | if (_isAndroid()) {
|
9432 | document.addEventListener('visibilitychange', visibilityChanged, false);
|
9433 | }
|
9434 |
|
9435 | cleanup = function () {
|
9436 | eventListener.removePassiveListener(authEventSeen);
|
9437 | document.removeEventListener('resume', resumed, false);
|
9438 | document.removeEventListener('visibilitychange', visibilityChanged, false);
|
9439 | if (onCloseTimer) {
|
9440 | window.clearTimeout(onCloseTimer);
|
9441 | }
|
9442 | };
|
9443 | })];
|
9444 | case 2:
|
9445 | _a.sent();
|
9446 | return [3 , 4];
|
9447 | case 3:
|
9448 | cleanup();
|
9449 | return [7 ];
|
9450 | case 4: return [2 ];
|
9451 | }
|
9452 | });
|
9453 | });
|
9454 | }
|
9455 |
|
9456 |
|
9457 |
|
9458 |
|
9459 |
|
9460 | function _checkCordovaConfiguration(auth) {
|
9461 | var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
|
9462 | var win = _cordovaWindow();
|
9463 |
|
9464 |
|
9465 |
|
9466 |
|
9467 |
|
9468 | _assert(typeof ((_a = win === null || win === void 0 ? void 0 : win.universalLinks) === null || _a === void 0 ? void 0 : _a.subscribe) === 'function', auth, "invalid-cordova-configuration" , {
|
9469 | missingPlugin: 'cordova-universal-links-plugin-fix'
|
9470 | });
|
9471 |
|
9472 | _assert(typeof ((_b = win === null || win === void 0 ? void 0 : win.BuildInfo) === null || _b === void 0 ? void 0 : _b.packageName) !== 'undefined', auth, "invalid-cordova-configuration" , {
|
9473 | missingPlugin: 'cordova-plugin-buildInfo'
|
9474 | });
|
9475 |
|
9476 | _assert(typeof ((_e = (_d = (_c = win === null || win === void 0 ? void 0 : win.cordova) === null || _c === void 0 ? void 0 : _c.plugins) === null || _d === void 0 ? void 0 : _d.browsertab) === null || _e === void 0 ? void 0 : _e.openUrl) === 'function', auth, "invalid-cordova-configuration" , {
|
9477 | missingPlugin: 'cordova-plugin-browsertab'
|
9478 | });
|
9479 | _assert(typeof ((_h = (_g = (_f = win === null || win === void 0 ? void 0 : win.cordova) === null || _f === void 0 ? void 0 : _f.plugins) === null || _g === void 0 ? void 0 : _g.browsertab) === null || _h === void 0 ? void 0 : _h.isAvailable) === 'function', auth, "invalid-cordova-configuration" , {
|
9480 | missingPlugin: 'cordova-plugin-browsertab'
|
9481 | });
|
9482 |
|
9483 | _assert(typeof ((_k = (_j = win === null || win === void 0 ? void 0 : win.cordova) === null || _j === void 0 ? void 0 : _j.InAppBrowser) === null || _k === void 0 ? void 0 : _k.open) === 'function', auth, "invalid-cordova-configuration" , {
|
9484 | missingPlugin: 'cordova-plugin-inappbrowser'
|
9485 | });
|
9486 | }
|
9487 |
|
9488 |
|
9489 |
|
9490 |
|
9491 |
|
9492 | function computeSha256(sessionId) {
|
9493 | return __awaiter(this, void 0, void 0, function () {
|
9494 | var bytes, buf, arr;
|
9495 | return __generator(this, function (_a) {
|
9496 | switch (_a.label) {
|
9497 | case 0:
|
9498 | bytes = stringToArrayBuffer(sessionId);
|
9499 | return [4 , crypto.subtle.digest('SHA-256', bytes)];
|
9500 | case 1:
|
9501 | buf = _a.sent();
|
9502 | arr = Array.from(new Uint8Array(buf));
|
9503 | return [2 , arr.map(function (num) { return num.toString(16).padStart(2, '0'); }).join('')];
|
9504 | }
|
9505 | });
|
9506 | });
|
9507 | }
|
9508 | function stringToArrayBuffer(str) {
|
9509 |
|
9510 |
|
9511 | debugAssert(/[0-9a-zA-Z]+/.test(str), 'Can only convert alpha-numeric strings');
|
9512 | if (typeof TextEncoder !== 'undefined') {
|
9513 | return new TextEncoder().encode(str);
|
9514 | }
|
9515 | var buff = new ArrayBuffer(str.length);
|
9516 | var view = new Uint8Array(buff);
|
9517 | for (var i = 0; i < str.length; i++) {
|
9518 | view[i] = str.charCodeAt(i);
|
9519 | }
|
9520 | return view;
|
9521 | }
|
9522 |
|
9523 |
|
9524 |
|
9525 |
|
9526 |
|
9527 |
|
9528 |
|
9529 |
|
9530 |
|
9531 |
|
9532 |
|
9533 |
|
9534 |
|
9535 |
|
9536 |
|
9537 |
|
9538 |
|
9539 |
|
9540 |
|
9541 | var EVENT_DUPLICATION_CACHE_DURATION_MS = 10 * 60 * 1000;
|
9542 | var AuthEventManager = (function () {
|
9543 | function AuthEventManager(auth) {
|
9544 | this.auth = auth;
|
9545 | this.cachedEventUids = new Set();
|
9546 | this.consumers = new Set();
|
9547 | this.queuedRedirectEvent = null;
|
9548 | this.hasHandledPotentialRedirect = false;
|
9549 | this.lastProcessedEventTime = Date.now();
|
9550 | }
|
9551 | AuthEventManager.prototype.registerConsumer = function (authEventConsumer) {
|
9552 | this.consumers.add(authEventConsumer);
|
9553 | if (this.queuedRedirectEvent &&
|
9554 | this.isEventForConsumer(this.queuedRedirectEvent, authEventConsumer)) {
|
9555 | this.sendToConsumer(this.queuedRedirectEvent, authEventConsumer);
|
9556 | this.saveEventToCache(this.queuedRedirectEvent);
|
9557 | this.queuedRedirectEvent = null;
|
9558 | }
|
9559 | };
|
9560 | AuthEventManager.prototype.unregisterConsumer = function (authEventConsumer) {
|
9561 | this.consumers.delete(authEventConsumer);
|
9562 | };
|
9563 | AuthEventManager.prototype.onEvent = function (event) {
|
9564 | var _this = this;
|
9565 |
|
9566 | if (this.hasEventBeenHandled(event)) {
|
9567 | return false;
|
9568 | }
|
9569 | var handled = false;
|
9570 | this.consumers.forEach(function (consumer) {
|
9571 | if (_this.isEventForConsumer(event, consumer)) {
|
9572 | handled = true;
|
9573 | _this.sendToConsumer(event, consumer);
|
9574 | _this.saveEventToCache(event);
|
9575 | }
|
9576 | });
|
9577 | if (this.hasHandledPotentialRedirect || !isRedirectEvent(event)) {
|
9578 |
|
9579 |
|
9580 | return handled;
|
9581 | }
|
9582 | this.hasHandledPotentialRedirect = true;
|
9583 |
|
9584 | if (!handled) {
|
9585 | this.queuedRedirectEvent = event;
|
9586 | handled = true;
|
9587 | }
|
9588 | return handled;
|
9589 | };
|
9590 | AuthEventManager.prototype.sendToConsumer = function (event, consumer) {
|
9591 | var _a;
|
9592 | if (event.error && !isNullRedirectEvent(event)) {
|
9593 | var code = ((_a = event.error.code) === null || _a === void 0 ? void 0 : _a.split('auth/')[1]) ||
|
9594 | "internal-error" ;
|
9595 | consumer.onError(_createError(this.auth, code));
|
9596 | }
|
9597 | else {
|
9598 | consumer.onAuthEvent(event);
|
9599 | }
|
9600 | };
|
9601 | AuthEventManager.prototype.isEventForConsumer = function (event, consumer) {
|
9602 | var eventIdMatches = consumer.eventId === null ||
|
9603 | (!!event.eventId && event.eventId === consumer.eventId);
|
9604 | return consumer.filter.includes(event.type) && eventIdMatches;
|
9605 | };
|
9606 | AuthEventManager.prototype.hasEventBeenHandled = function (event) {
|
9607 | if (Date.now() - this.lastProcessedEventTime >=
|
9608 | EVENT_DUPLICATION_CACHE_DURATION_MS) {
|
9609 | this.cachedEventUids.clear();
|
9610 | }
|
9611 | return this.cachedEventUids.has(eventUid(event));
|
9612 | };
|
9613 | AuthEventManager.prototype.saveEventToCache = function (event) {
|
9614 | this.cachedEventUids.add(eventUid(event));
|
9615 | this.lastProcessedEventTime = Date.now();
|
9616 | };
|
9617 | return AuthEventManager;
|
9618 | }());
|
9619 | function eventUid(e) {
|
9620 | return [e.type, e.eventId, e.sessionId, e.tenantId].filter(function (v) { return v; }).join('-');
|
9621 | }
|
9622 | function isNullRedirectEvent(_a) {
|
9623 | var type = _a.type, error = _a.error;
|
9624 | return (type === "unknown" &&
|
9625 | (error === null || error === void 0 ? void 0 : error.code) === "auth/" + "no-auth-event" );
|
9626 | }
|
9627 | function isRedirectEvent(event) {
|
9628 | switch (event.type) {
|
9629 | case "signInViaRedirect" :
|
9630 | case "linkViaRedirect" :
|
9631 | case "reauthViaRedirect" :
|
9632 | return true;
|
9633 | case "unknown" :
|
9634 | return isNullRedirectEvent(event);
|
9635 | default:
|
9636 | return false;
|
9637 | }
|
9638 | }
|
9639 |
|
9640 |
|
9641 |
|
9642 |
|
9643 |
|
9644 |
|
9645 |
|
9646 |
|
9647 |
|
9648 |
|
9649 |
|
9650 |
|
9651 |
|
9652 |
|
9653 |
|
9654 |
|
9655 |
|
9656 | var SESSION_ID_LENGTH = 20;
|
9657 |
|
9658 | var CordovaAuthEventManager = (function (_super) {
|
9659 | __extends(CordovaAuthEventManager, _super);
|
9660 | function CordovaAuthEventManager() {
|
9661 | var _this = _super !== null && _super.apply(this, arguments) || this;
|
9662 | _this.passiveListeners = new Set();
|
9663 | _this.initPromise = new Promise(function (resolve) {
|
9664 | _this.resolveInialized = resolve;
|
9665 | });
|
9666 | return _this;
|
9667 | }
|
9668 | CordovaAuthEventManager.prototype.addPassiveListener = function (cb) {
|
9669 | this.passiveListeners.add(cb);
|
9670 | };
|
9671 | CordovaAuthEventManager.prototype.removePassiveListener = function (cb) {
|
9672 | this.passiveListeners.delete(cb);
|
9673 | };
|
9674 |
|
9675 |
|
9676 | CordovaAuthEventManager.prototype.resetRedirect = function () {
|
9677 | this.queuedRedirectEvent = null;
|
9678 | this.hasHandledPotentialRedirect = false;
|
9679 | };
|
9680 |
|
9681 | CordovaAuthEventManager.prototype.onEvent = function (event) {
|
9682 | this.resolveInialized();
|
9683 | this.passiveListeners.forEach(function (cb) { return cb(event); });
|
9684 | return _super.prototype.onEvent.call(this, event);
|
9685 | };
|
9686 | CordovaAuthEventManager.prototype.initialized = function () {
|
9687 | return __awaiter(this, void 0, void 0, function () {
|
9688 | return __generator(this, function (_a) {
|
9689 | switch (_a.label) {
|
9690 | case 0: return [4 , this.initPromise];
|
9691 | case 1:
|
9692 | _a.sent();
|
9693 | return [2 ];
|
9694 | }
|
9695 | });
|
9696 | });
|
9697 | };
|
9698 | return CordovaAuthEventManager;
|
9699 | }(AuthEventManager));
|
9700 |
|
9701 |
|
9702 |
|
9703 | function _generateNewEvent(auth, type, eventId) {
|
9704 | if (eventId === void 0) { eventId = null; }
|
9705 | return {
|
9706 | type: type,
|
9707 | eventId: eventId,
|
9708 | urlResponse: null,
|
9709 | sessionId: generateSessionId(),
|
9710 | postBody: null,
|
9711 | tenantId: auth.tenantId,
|
9712 | error: _createError(auth, "no-auth-event" )
|
9713 | };
|
9714 | }
|
9715 | function _savePartialEvent(auth, event) {
|
9716 | return storage()._set(persistenceKey(auth), event);
|
9717 | }
|
9718 | function _getAndRemoveEvent(auth) {
|
9719 | return __awaiter(this, void 0, void 0, function () {
|
9720 | var event;
|
9721 | return __generator(this, function (_a) {
|
9722 | switch (_a.label) {
|
9723 | case 0: return [4 , storage()._get(persistenceKey(auth))];
|
9724 | case 1:
|
9725 | event = (_a.sent());
|
9726 | if (!event) return [3 , 3];
|
9727 | return [4 , storage()._remove(persistenceKey(auth))];
|
9728 | case 2:
|
9729 | _a.sent();
|
9730 | _a.label = 3;
|
9731 | case 3: return [2 , event];
|
9732 | }
|
9733 | });
|
9734 | });
|
9735 | }
|
9736 | function _eventFromPartialAndUrl(partialEvent, url) {
|
9737 | var _a, _b;
|
9738 |
|
9739 | var callbackUrl = _getDeepLinkFromCallback(url);
|
9740 |
|
9741 |
|
9742 |
|
9743 |
|
9744 |
|
9745 | if (callbackUrl.includes('/__/auth/callback')) {
|
9746 |
|
9747 |
|
9748 |
|
9749 | var params = searchParamsOrEmpty(callbackUrl);
|
9750 |
|
9751 | var errorObject = params['firebaseError']
|
9752 | ? parseJsonOrNull(decodeURIComponent(params['firebaseError']))
|
9753 | : null;
|
9754 | var code = (_b = (_a = errorObject === null || errorObject === void 0 ? void 0 : errorObject['code']) === null || _a === void 0 ? void 0 : _a.split('auth/')) === null || _b === void 0 ? void 0 : _b[1];
|
9755 | var error = code ? _createError(code) : null;
|
9756 | if (error) {
|
9757 | return {
|
9758 | type: partialEvent.type,
|
9759 | eventId: partialEvent.eventId,
|
9760 | tenantId: partialEvent.tenantId,
|
9761 | error: error,
|
9762 | urlResponse: null,
|
9763 | sessionId: null,
|
9764 | postBody: null
|
9765 | };
|
9766 | }
|
9767 | else {
|
9768 | return {
|
9769 | type: partialEvent.type,
|
9770 | eventId: partialEvent.eventId,
|
9771 | tenantId: partialEvent.tenantId,
|
9772 | sessionId: partialEvent.sessionId,
|
9773 | urlResponse: callbackUrl,
|
9774 | postBody: null
|
9775 | };
|
9776 | }
|
9777 | }
|
9778 | return null;
|
9779 | }
|
9780 | function generateSessionId() {
|
9781 | var chars = [];
|
9782 | var allowedChars = '1234567890abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
|
9783 | for (var i = 0; i < SESSION_ID_LENGTH; i++) {
|
9784 | var idx = Math.floor(Math.random() * allowedChars.length);
|
9785 | chars.push(allowedChars.charAt(idx));
|
9786 | }
|
9787 | return chars.join('');
|
9788 | }
|
9789 | function storage() {
|
9790 | return _getInstance(browserLocalPersistence);
|
9791 | }
|
9792 | function persistenceKey(auth) {
|
9793 | return _persistenceKeyName("authEvent" , auth.config.apiKey, auth.name);
|
9794 | }
|
9795 | function parseJsonOrNull(json) {
|
9796 | try {
|
9797 | return JSON.parse(json);
|
9798 | }
|
9799 | catch (e) {
|
9800 | return null;
|
9801 | }
|
9802 | }
|
9803 |
|
9804 | function _getDeepLinkFromCallback(url) {
|
9805 | var params = searchParamsOrEmpty(url);
|
9806 | var link = params['link'] ? decodeURIComponent(params['link']) : undefined;
|
9807 |
|
9808 | var doubleDeepLink = searchParamsOrEmpty(link)['link'];
|
9809 |
|
9810 | var iOSDeepLink = params['deep_link_id']
|
9811 | ? decodeURIComponent(params['deep_link_id'])
|
9812 | : undefined;
|
9813 | var iOSDoubleDeepLink = searchParamsOrEmpty(iOSDeepLink)['link'];
|
9814 | return iOSDoubleDeepLink || iOSDeepLink || doubleDeepLink || link || url;
|
9815 | }
|
9816 |
|
9817 |
|
9818 |
|
9819 |
|
9820 | function searchParamsOrEmpty(url) {
|
9821 | if (!(url === null || url === void 0 ? void 0 : url.includes('?'))) {
|
9822 | return {};
|
9823 | }
|
9824 | var _a = url.split('?'); _a[0]; var rest = _a.slice(1);
|
9825 | return querystringDecode(rest.join('?'));
|
9826 | }
|
9827 |
|
9828 |
|
9829 |
|
9830 |
|
9831 |
|
9832 |
|
9833 |
|
9834 |
|
9835 |
|
9836 |
|
9837 |
|
9838 |
|
9839 |
|
9840 |
|
9841 |
|
9842 |
|
9843 |
|
9844 |
|
9845 |
|
9846 |
|
9847 |
|
9848 | var INITIAL_EVENT_TIMEOUT_MS = 500;
|
9849 | var CordovaPopupRedirectResolver = (function () {
|
9850 | function CordovaPopupRedirectResolver() {
|
9851 | this._redirectPersistence = browserSessionPersistence;
|
9852 | this._shouldInitProactively = true;
|
9853 | this.eventManagers = new Map();
|
9854 | this.originValidationPromises = {};
|
9855 | this._completeRedirectFn = _getRedirectResult;
|
9856 | this._overrideRedirectResult = _overrideRedirectResult;
|
9857 | }
|
9858 | CordovaPopupRedirectResolver.prototype._initialize = function (auth) {
|
9859 | return __awaiter(this, void 0, void 0, function () {
|
9860 | var key, manager;
|
9861 | return __generator(this, function (_a) {
|
9862 | key = auth._key();
|
9863 | manager = this.eventManagers.get(key);
|
9864 | if (!manager) {
|
9865 | manager = new CordovaAuthEventManager(auth);
|
9866 | this.eventManagers.set(key, manager);
|
9867 | this.attachCallbackListeners(auth, manager);
|
9868 | }
|
9869 | return [2 , manager];
|
9870 | });
|
9871 | });
|
9872 | };
|
9873 | CordovaPopupRedirectResolver.prototype._openPopup = function (auth) {
|
9874 | _fail(auth, "operation-not-supported-in-this-environment" );
|
9875 | };
|
9876 | CordovaPopupRedirectResolver.prototype._openRedirect = function (auth, provider, authType, eventId) {
|
9877 | return __awaiter(this, void 0, void 0, function () {
|
9878 | var manager, event, url, iabRef;
|
9879 | return __generator(this, function (_a) {
|
9880 | switch (_a.label) {
|
9881 | case 0:
|
9882 | _checkCordovaConfiguration(auth);
|
9883 | return [4 , this._initialize(auth)];
|
9884 | case 1:
|
9885 | manager = _a.sent();
|
9886 | return [4 , manager.initialized()];
|
9887 | case 2:
|
9888 | _a.sent();
|
9889 |
|
9890 |
|
9891 |
|
9892 | manager.resetRedirect();
|
9893 | _clearRedirectOutcomes();
|
9894 | return [4 , this._originValidation(auth)];
|
9895 | case 3:
|
9896 | _a.sent();
|
9897 | event = _generateNewEvent(auth, authType, eventId);
|
9898 | return [4 , _savePartialEvent(auth, event)];
|
9899 | case 4:
|
9900 | _a.sent();
|
9901 | return [4 , _generateHandlerUrl(auth, event, provider)];
|
9902 | case 5:
|
9903 | url = _a.sent();
|
9904 | return [4 , _performRedirect(url)];
|
9905 | case 6:
|
9906 | iabRef = _a.sent();
|
9907 | return [2 , _waitForAppResume(auth, manager, iabRef)];
|
9908 | }
|
9909 | });
|
9910 | });
|
9911 | };
|
9912 | CordovaPopupRedirectResolver.prototype._isIframeWebStorageSupported = function (_auth, _cb) {
|
9913 | throw new Error('Method not implemented.');
|
9914 | };
|
9915 | CordovaPopupRedirectResolver.prototype._originValidation = function (auth) {
|
9916 | var key = auth._key();
|
9917 | if (!this.originValidationPromises[key]) {
|
9918 | this.originValidationPromises[key] = _validateOrigin(auth);
|
9919 | }
|
9920 | return this.originValidationPromises[key];
|
9921 | };
|
9922 | CordovaPopupRedirectResolver.prototype.attachCallbackListeners = function (auth, manager) {
|
9923 | var _this = this;
|
9924 |
|
9925 | var _a = _cordovaWindow(), universalLinks = _a.universalLinks, handleOpenURL = _a.handleOpenURL, BuildInfo = _a.BuildInfo;
|
9926 | var noEventTimeout = setTimeout(function () { return __awaiter(_this, void 0, void 0, function () {
|
9927 | return __generator(this, function (_a) {
|
9928 | switch (_a.label) {
|
9929 | case 0:
|
9930 |
|
9931 |
|
9932 | return [4 , _getAndRemoveEvent(auth)];
|
9933 | case 1:
|
9934 |
|
9935 |
|
9936 | _a.sent();
|
9937 | manager.onEvent(generateNoEvent());
|
9938 | return [2 ];
|
9939 | }
|
9940 | });
|
9941 | }); }, INITIAL_EVENT_TIMEOUT_MS);
|
9942 | var universalLinksCb = function (eventData) { return __awaiter(_this, void 0, void 0, function () {
|
9943 | var partialEvent, finalEvent;
|
9944 | return __generator(this, function (_a) {
|
9945 | switch (_a.label) {
|
9946 | case 0:
|
9947 |
|
9948 | clearTimeout(noEventTimeout);
|
9949 | return [4 , _getAndRemoveEvent(auth)];
|
9950 | case 1:
|
9951 | partialEvent = _a.sent();
|
9952 | finalEvent = null;
|
9953 | if (partialEvent && (eventData === null || eventData === void 0 ? void 0 : eventData['url'])) {
|
9954 | finalEvent = _eventFromPartialAndUrl(partialEvent, eventData['url']);
|
9955 | }
|
9956 |
|
9957 | manager.onEvent(finalEvent || generateNoEvent());
|
9958 | return [2 ];
|
9959 | }
|
9960 | });
|
9961 | }); };
|
9962 |
|
9963 | if (typeof universalLinks !== 'undefined' &&
|
9964 | typeof universalLinks.subscribe === 'function') {
|
9965 | universalLinks.subscribe(null, universalLinksCb);
|
9966 | }
|
9967 |
|
9968 |
|
9969 |
|
9970 |
|
9971 |
|
9972 | var existingHandleOpenURL = handleOpenURL;
|
9973 | var packagePrefix = BuildInfo.packageName.toLowerCase() + "://";
|
9974 | _cordovaWindow().handleOpenURL = function (url) { return __awaiter(_this, void 0, void 0, function () {
|
9975 | return __generator(this, function (_a) {
|
9976 | if (url.toLowerCase().startsWith(packagePrefix)) {
|
9977 |
|
9978 |
|
9979 | universalLinksCb({ url: url });
|
9980 | }
|
9981 |
|
9982 | if (typeof existingHandleOpenURL === 'function') {
|
9983 | try {
|
9984 | existingHandleOpenURL(url);
|
9985 | }
|
9986 | catch (e) {
|
9987 |
|
9988 | console.error(e);
|
9989 | }
|
9990 | }
|
9991 | return [2 ];
|
9992 | });
|
9993 | }); };
|
9994 | };
|
9995 | return CordovaPopupRedirectResolver;
|
9996 | }());
|
9997 |
|
9998 |
|
9999 |
|
10000 |
|
10001 |
|
10002 |
|
10003 | var cordovaPopupRedirectResolver = CordovaPopupRedirectResolver;
|
10004 | function generateNoEvent() {
|
10005 | return {
|
10006 | type: "unknown" ,
|
10007 | eventId: null,
|
10008 | sessionId: null,
|
10009 | urlResponse: null,
|
10010 | postBody: null,
|
10011 | tenantId: null,
|
10012 | error: _createError("no-auth-event" )
|
10013 | };
|
10014 | }
|
10015 |
|
10016 | export { signInWithEmailLink as $, ActionCodeOperation as A, FacebookAuthProvider as B, GithubAuthProvider as C, OAuthProvider as D, EmailAuthCredential as E, FactorId as F, GoogleAuthProvider as G, SAMLAuthProvider as H, signInAnonymously as I, signInWithCredential as J, linkWithCredential as K, reauthenticateWithCredential as L, signInWithCustomToken as M, sendPasswordResetEmail as N, OperationType as O, ProviderId as P, confirmPasswordReset as Q, applyActionCode as R, SignInMethod as S, TwitterAuthProvider as T, checkActionCode as U, verifyPasswordResetCode as V, createUserWithEmailAndPassword as W, signInWithEmailAndPassword as X, sendSignInLinkToEmail as Y, isSignInWithEmailLink as Z, _signInWithRedirect as _, _reauthenticateWithRedirect as a, fetchSignInMethodsForEmail as a0, sendEmailVerification as a1, verifyBeforeUpdateEmail as a2, ActionCodeURL as a3, parseActionCodeURL as a4, updateProfile as a5, updateEmail as a6, updatePassword as a7, getIdToken as a8, getIdTokenResult as a9, _getCurrentUrl as aA, _emulatorUrl as aB, _isChromeIOS as aC, _isFirefox as aD, _isIOSStandalone as aE, _isMobileBrowser as aF, _isSafari as aG, _isIOS as aH, _getRedirectResult as aI, _overrideRedirectResult as aJ, _getRedirectUrl as aK, _setWindowLocation as aL, AuthEventManager as aM, debugFail as aN, finalizeEnrollPhoneMfa as aO, _persistenceKeyName as aP, UserImpl as aQ, _getInstance as aR, AuthImpl as aS, _getClientVersion as aT, FetchProvider as aU, SAMLAuthCredential as aV, signInWithRedirect as aW, linkWithRedirect as aX, reauthenticateWithRedirect as aY, unlink as aa, getAdditionalUserInfo as ab, reload as ac, getMultiFactorResolver as ad, multiFactor as ae, _performApiRequest as af, _addTidIfNecessary as ag, _createError as ah, _assert as ai, Delay as aj, _window as ak, _isHttpOrHttps as al, _isWorker as am, _castAuth as an, sendPhoneVerificationCode as ao, startEnrollPhoneMfa as ap, _assertLinkedStatus as aq, _link$1 as ar, debugAssert as as, _generateEventId as at, AbstractPopupRedirectOperation as au, _assertInstanceOf as av, _withDefaultResolver as aw, FederatedAuthProvider as ax, _fail as ay, _getProjectConfig as az, _linkWithRedirect as b, indexedDBLocalPersistence as c, cordovaPopupRedirectResolver as d, browserLocalPersistence as e, browserSessionPersistence as f, getRedirectResult as g, beforeAuthStateChanged as h, initializeAuth as i, onAuthStateChanged as j, updateCurrentUser as k, signOut as l, deleteUser as m, debugErrorMap as n, onIdTokenChanged as o, prodErrorMap as p, AUTH_ERROR_CODES_MAP_DO_NOT_USE_INTERNALLY as q, registerAuth as r, setPersistence as s, connectAuthEmulator as t, useDeviceLanguage as u, AuthCredential as v, OAuthCredential as w, PhoneAuthCredential as x, inMemoryPersistence as y, EmailAuthProvider as z };
|
10017 |
|