@retter/sdk 0.7.1-development → 0.7.1-development-2

package/dist/index.js

@@ -0,0 +1,704 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var firestore_1 = require("firebase/firestore");
+var app_1 = require("firebase/app");
+var firestore_2 = require("firebase/firestore");
+var auth_1 = require("firebase/auth");
+var rxjs_1 = require("rxjs");
+var operators_1 = require("rxjs/operators");
+var Auth_1 = __importDefault(require("./Auth"));
+var Request_1 = __importDefault(require("./Request"));
+var types_1 = require("./types");
+__exportStar(require("./types"), exports);
+var DEFAULT_RETRY_DELAY = 50; // in ms
+var DEFAULT_RETRY_COUNT = 3;
+var DEFAULT_RETRY_RATE = 1.5;
+var Retter = /** @class */ (function () {
+    function Retter() {
+        this.initialized = false;
+        this.authQueue = new rxjs_1.Subject();
+        this.actionQueue = new rxjs_1.Subject();
+        this.authStatusSubject = new rxjs_1.ReplaySubject(1);
+        this.cloudObjects = [];
+        this.listeners = {};
+    }
+    Retter.getInstance = function (config) {
+        var instance = Retter.instances.find(function (instance) { var _a; return ((_a = instance.clientConfig) === null || _a === void 0 ? void 0 : _a.projectId) === config.projectId; });
+        if (instance)
+            return instance;
+        var newInstance = new Retter();
+        newInstance.init(config);
+        Retter.instances.push(newInstance);
+        return newInstance;
+    };
+    Retter.prototype.init = function (config) {
+        var _this = this;
+        if (this.initialized)
+            throw new Error('SDK already initialized.');
+        this.initialized = true;
+        if (!config.retryConfig)
+            config.retryConfig = {};
+        if (!config.retryConfig.delay)
+            config.retryConfig.delay = DEFAULT_RETRY_DELAY;
+        if (!config.retryConfig.count)
+            config.retryConfig.count = DEFAULT_RETRY_COUNT;
+        if (!config.retryConfig.rate)
+            config.retryConfig.rate = DEFAULT_RETRY_RATE;
+        this.clientConfig = config;
+        this.auth = new Auth_1.default(config);
+        this.http = new Request_1.default(config);
+        this.auth.setHttp(this.http);
+        this.processAuthQueue();
+        this.processActionQueue();
+        setTimeout(function () { return __awaiter(_this, void 0, void 0, function () {
+            var tokenData;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.auth.getCurrentTokenData()];
+                    case 1:
+                        tokenData = _a.sent();
+                        this.fireAuthStatus({ tokenData: tokenData });
+                        return [2 /*return*/];
+                }
+            });
+        }); }, 1);
+    };
+    Retter.prototype.processAuthQueue = function () {
+        var _this = this;
+        var authResult = this.authQueue.pipe((0, operators_1.concatMap)(function (action) {
+            return (0, rxjs_1.defer)(function () { return __awaiter(_this, void 0, void 0, function () {
+                var response, error_1;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            _a.trys.push([0, 2, , 3]);
+                            return [4 /*yield*/, this.auth.signIn(action.data)];
+                        case 1:
+                            response = _a.sent();
+                            return [2 /*return*/, { action: action, response: response }];
+                        case 2:
+                            error_1 = _a.sent();
+                            throw { action: action, responseError: error_1 };
+                        case 3: return [2 /*return*/];
+                    }
+                });
+            }); }).pipe((0, operators_1.materialize)());
+        }), (0, operators_1.share)());
+        // on success
+        authResult
+            .pipe((0, operators_1.filter)(function (r) { return r.hasValue && r.kind === 'N'; }), (0, operators_1.map)(function (e) { var _a; return (__assign(__assign({}, e.value), { tokenData: (_a = e.value) === null || _a === void 0 ? void 0 : _a.response })); }), (0, operators_1.switchMap)(function (ev) { return __awaiter(_this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.storeTokenData(ev)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/, ev];
+                }
+            });
+        }); }), (0, operators_1.switchMap)(function (ev) { return __awaiter(_this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!this.firebaseAuth) return [3 /*break*/, 2];
+                        return [4 /*yield*/, (0, auth_1.signOut)(this.firebaseAuth)];
+                    case 1:
+                        _a.sent();
+                        _a.label = 2;
+                    case 2:
+                        this.clearFirebase();
+                        if (!ev.tokenData) return [3 /*break*/, 4];
+                        return [4 /*yield*/, this.initFirebase(ev)];
+                    case 3:
+                        _a.sent();
+                        _a.label = 4;
+                    case 4:
+                        this.fireAuthStatus(ev);
+                        return [2 /*return*/, ev];
+                }
+            });
+        }); }))
+            .subscribe(function (ev) {
+            var _a, _b;
+            if ((_a = ev.action) === null || _a === void 0 ? void 0 : _a.resolve) {
+                ev.action.resolve((_b = _this.auth) === null || _b === void 0 ? void 0 : _b.getAuthStatus(ev.tokenData));
+            }
+        });
+        // on error
+        authResult.pipe((0, operators_1.filter)(function (r) { return r.hasValue === false && r.kind === 'E'; })).subscribe(function (e) {
+            var _a;
+            if (e.error && e.error.action && e.error.action.resolve) {
+                var response = {
+                    authStatus: types_1.RetterAuthStatus.AUTH_FAILED,
+                    message: (_a = e.error.responseError.response) === null || _a === void 0 ? void 0 : _a.data,
+                };
+                e.error.action.resolve(response);
+            }
+        });
+        this.authStatus.subscribe();
+    };
+    Retter.prototype.processActionQueue = function () {
+        var _this = this;
+        var actionResult = this.actionQueue.asObservable().pipe(
+        // Get current token data if exists and store it in action
+        (0, operators_1.concatMap)(this.getActionWithTokenData.bind(this)), 
+        // Fire auth status event
+        (0, operators_1.tap)(this.fireAuthStatus.bind(this)), 
+        // Make sure we have a token
+        (0, operators_1.filter)(function (ev) { return ev.tokenData !== null; }), 
+        // Store token data
+        (0, operators_1.switchMap)(function (ev) { return __awaiter(_this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.storeTokenData(ev)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/, ev];
+                }
+            });
+        }); }), 
+        // Process action
+        (0, operators_1.mergeMap)(this.processAction.bind(this)), (0, operators_1.share)());
+        actionResult.pipe((0, operators_1.filter)(function (r) { return r.hasValue && r.kind === 'N'; })).subscribe(function (e) {
+            if (e.value && e.value.action && e.value.action.resolve && e.value.response) {
+                e.value.action.resolve(e.value.response);
+            }
+        });
+        actionResult.pipe((0, operators_1.filter)(function (r) { return r.hasValue === false && r.kind === 'E'; })).subscribe(function (e) {
+            if (e.error && e.error.action && e.error.action.reject && e.error.responseError) {
+                e.error.action.reject(e.error.responseError);
+            }
+        });
+    };
+    //
+    Retter.prototype.sendToAuthQueue = function (action) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                return [2 /*return*/, new Promise(function (resolve, reject) {
+                        _this.authQueue.next(__assign(__assign({}, action), { reject: reject, resolve: resolve }));
+                    })];
+            });
+        });
+    };
+    Retter.prototype.sendToActionQueue = function (action) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                return [2 /*return*/, new Promise(function (resolve, reject) {
+                        _this.actionQueue.next(__assign(__assign({}, action), { reject: reject, resolve: resolve }));
+                    })];
+            });
+        });
+    };
+    //
+    Retter.prototype.getActionWithTokenData = function (action) {
+        return __awaiter(this, void 0, void 0, function () {
+            var ev, error_2;
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _b.trys.push([0, 3, , 5]);
+                        _a = { action: action };
+                        return [4 /*yield*/, this.auth.getTokenData()];
+                    case 1:
+                        ev = (_a.tokenData = _b.sent(), _a);
+                        return [4 /*yield*/, this.initFirebase(ev)];
+                    case 2:
+                        _b.sent();
+                        return [2 /*return*/, ev];
+                    case 3:
+                        error_2 = _b.sent();
+                        return [4 /*yield*/, this.signOut()];
+                    case 4:
+                        _b.sent();
+                        return [2 /*return*/, { action: action }];
+                    case 5: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    Retter.prototype.fireAuthStatus = function (actionWrapper) {
+        var event = this.auth.getAuthStatus(actionWrapper.tokenData);
+        this.authStatusSubject.next(event);
+    };
+    Retter.prototype.storeTokenData = function (actionWrapper) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.auth.storeTokenData(actionWrapper.tokenData)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    Retter.prototype.processAction = function (actionWrapper) {
+        var _this = this;
+        var _a;
+        if (((_a = actionWrapper.action) === null || _a === void 0 ? void 0 : _a.action) === types_1.RetterActions.EMPTY) {
+            return (0, rxjs_1.defer)(function () { return (0, rxjs_1.of)(__assign(__assign({}, actionWrapper), { response: true })); }).pipe((0, operators_1.materialize)());
+        }
+        return (0, rxjs_1.defer)(function () { return __awaiter(_this, void 0, void 0, function () {
+            var endpoint, response, error_3;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, , 3]);
+                        endpoint = this.getCosEndpoint(actionWrapper);
+                        return [4 /*yield*/, this.http.call(this.clientConfig.projectId, endpoint.path, endpoint.params)];
+                    case 1:
+                        response = _a.sent();
+                        return [2 /*return*/, __assign(__assign({}, actionWrapper), { response: response })];
+                    case 2:
+                        error_3 = _a.sent();
+                        if (error_3.response &&
+                            error_3.response.status === 403 &&
+                            error_3.response.data &&
+                            error_3.response.data.code === 'ACCESS_DENIED') {
+                            this.signOut();
+                        }
+                        throw __assign(__assign({}, actionWrapper), { responseError: error_3 });
+                    case 3: return [2 /*return*/];
+                }
+            });
+        }); }).pipe((0, operators_1.materialize)());
+    };
+    // Firebase
+    Retter.prototype.initFirebase = function (actionWrapper) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function () {
+            var firebaseConfig;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        firebaseConfig = (_a = actionWrapper.tokenData) === null || _a === void 0 ? void 0 : _a.firebase;
+                        if (!firebaseConfig || this.firebase)
+                            return [2 /*return*/, actionWrapper];
+                        this.firebase = (0, app_1.initializeApp)({
+                            apiKey: firebaseConfig.apiKey,
+                            authDomain: firebaseConfig.projectId + '.firebaseapp.com',
+                            projectId: firebaseConfig.projectId,
+                        }, this.clientConfig.projectId);
+                        this.firestore = (0, firestore_1.getFirestore)(this.firebase);
+                        this.firebaseAuth = (0, auth_1.getAuth)(this.firebase);
+                        return [4 /*yield*/, (0, auth_1.signInWithCustomToken)(this.firebaseAuth, firebaseConfig.customToken)];
+                    case 1:
+                        _b.sent();
+                        return [2 /*return*/, actionWrapper];
+                }
+            });
+        });
+    };
+    Retter.prototype.clearFirebase = function () {
+        this.firebase = undefined;
+        this.firestore = undefined;
+        this.firebaseAuth = undefined;
+    };
+    // Cloud Objects
+    Retter.prototype.getCosEndpoint = function (ev) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+        var action = ev.action;
+        var data = action.data;
+        var queryParams = {};
+        for (var key in data.queryStringParams || []) {
+            queryParams[key] = data.queryStringParams[key];
+        }
+        queryParams['__culture'] = (_a = data.culture) !== null && _a !== void 0 ? _a : (((_b = this.clientConfig) === null || _b === void 0 ? void 0 : _b.culture) || 'en-us');
+        if (data.platform || ((_c = this.clientConfig) === null || _c === void 0 ? void 0 : _c.platform)) {
+            queryParams['__platform'] = (_d = data.platform) !== null && _d !== void 0 ? _d : (_e = this.clientConfig) === null || _e === void 0 ? void 0 : _e.platform;
+        }
+        var params = {
+            params: queryParams,
+            method: (_f = data.httpMethod) !== null && _f !== void 0 ? _f : 'post',
+            data: data.body,
+            base64Encode: (_g = data.base64Encode) !== null && _g !== void 0 ? _g : true,
+            headers: __assign({}, data.headers),
+        };
+        var accessToken = (_h = data.token) !== null && _h !== void 0 ? _h : (_j = ev.tokenData) === null || _j === void 0 ? void 0 : _j.accessToken;
+        if (accessToken) {
+            params.headers['Authorization'] = "Bearer ".concat(accessToken);
+        }
+        if (action.action === types_1.RetterActions.COS_INSTANCE) {
+            var instanceId = data.key ? "".concat(data.key.name, "!").concat(data.key.value) : data.instanceId;
+            return {
+                path: "INSTANCE/".concat(data.classId).concat(instanceId ? "/".concat(instanceId) : ''),
+                params: params,
+            };
+        }
+        else if (action.action === types_1.RetterActions.COS_STATE) {
+            return {
+                path: "STATE/".concat(data.classId, "/").concat(data.instanceId),
+                params: params,
+            };
+        }
+        else if (action.action === types_1.RetterActions.COS_LIST) {
+            return {
+                path: "LIST/".concat(data.classId),
+                params: params,
+            };
+        }
+        else if (action.action === types_1.RetterActions.COS_STATIC_CALL) {
+            return {
+                path: "CALL/".concat(data.classId, "/").concat(data.method).concat(data.pathParams ? "/".concat(data.pathParams) : ''),
+                params: params,
+            };
+        }
+        else {
+            return {
+                path: "CALL/".concat(data.classId, "/").concat(data.method, "/").concat(data.instanceId).concat(data.pathParams ? "/".concat(data.pathParams) : ''),
+                params: params,
+            };
+        }
+    };
+    Retter.prototype.getFirebaseListener = function (queue, collection, documentId) {
+        var document = (0, firestore_2.doc)(this.firestore, collection, documentId);
+        return (0, firestore_2.onSnapshot)(document, function (doc) {
+            var data = Object.assign({}, doc.data());
+            for (var _i = 0, _a = Object.keys(data); _i < _a.length; _i++) {
+                var key = _a[_i];
+                if (key.startsWith('__'))
+                    delete data[key];
+            }
+            queue.next(data);
+        });
+    };
+    Retter.prototype.getFirebaseState = function (config) {
+        return __awaiter(this, void 0, void 0, function () {
+            var projectId, user, unsubscribers, queues, state;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        projectId = this.clientConfig.projectId;
+                        return [4 /*yield*/, this.auth.getCurrentUser()];
+                    case 1:
+                        user = _a.sent();
+                        unsubscribers = [];
+                        queues = {
+                            role: new rxjs_1.ReplaySubject(1),
+                            user: new rxjs_1.ReplaySubject(1),
+                            public: new rxjs_1.ReplaySubject(1),
+                        };
+                        state = {
+                            role: {
+                                queue: queues.role,
+                                subscribe: function (observer) {
+                                    if (!_this.listeners["".concat(projectId, "_").concat(config.classId, "_").concat(config.instanceId, "_role")]) {
+                                        var listener = _this.getFirebaseListener(queues.role, "/projects/".concat(projectId, "/classes/").concat(config.classId, "/instances/").concat(config.instanceId, "/roleState"), user.identity);
+                                        unsubscribers.push(listener);
+                                        _this.listeners["".concat(projectId, "_").concat(config.classId, "_").concat(config.instanceId, "_role")] = listener;
+                                    }
+                                    return queues.role.subscribe(observer);
+                                },
+                            },
+                            user: {
+                                queue: queues.user,
+                                subscribe: function (observer) {
+                                    if (!_this.listeners["".concat(projectId, "_").concat(config.classId, "_").concat(config.instanceId, "_user")]) {
+                                        var listener = _this.getFirebaseListener(queues.user, "/projects/".concat(projectId, "/classes/").concat(config.classId, "/instances/").concat(config.instanceId, "/userState"), user.userId);
+                                        unsubscribers.push(listener);
+                                        _this.listeners["".concat(projectId, "_").concat(config.classId, "_").concat(config.instanceId, "_user")] = listener;
+                                    }
+                                    return queues.user.subscribe(observer);
+                                },
+                            },
+                            public: {
+                                queue: queues.public,
+                                subscribe: function (observer) {
+                                    if (!_this.listeners["".concat(projectId, "_").concat(config.classId, "_").concat(config.instanceId, "_public")]) {
+                                        var listener = _this.getFirebaseListener(queues.public, "/projects/".concat(projectId, "/classes/").concat(config.classId, "/instances"), config.instanceId);
+                                        unsubscribers.push(listener);
+                                        _this.listeners["".concat(projectId, "_").concat(config.classId, "_").concat(config.instanceId, "_public")] = listener;
+                                    }
+                                    return queues.public.subscribe(observer);
+                                },
+                            },
+                        };
+                        return [2 /*return*/, { state: state, unsubscribers: unsubscribers }];
+                }
+            });
+        });
+    };
+    Retter.prototype.clearCloudObjects = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var listeners;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        listeners = Object.values(this.listeners);
+                        if (listeners.length > 0) {
+                            listeners.map(function (i) { return i(); });
+                            this.cloudObjects.map(function (i) {
+                                var _a, _b, _c, _d, _e, _f;
+                                (_b = (_a = i.state) === null || _a === void 0 ? void 0 : _a.role.queue) === null || _b === void 0 ? void 0 : _b.complete();
+                                (_d = (_c = i.state) === null || _c === void 0 ? void 0 : _c.user.queue) === null || _d === void 0 ? void 0 : _d.complete();
+                                (_f = (_e = i.state) === null || _e === void 0 ? void 0 : _e.public.queue) === null || _f === void 0 ? void 0 : _f.complete();
+                            });
+                        }
+                        this.listeners = {};
+                        this.cloudObjects.map(function (i) { return i.unsubscribers.map(function (u) { return u(); }); });
+                        this.cloudObjects = [];
+                        if (!this.firebaseAuth) return [3 /*break*/, 2];
+                        return [4 /*yield*/, (0, auth_1.signOut)(this.firebaseAuth)];
+                    case 1:
+                        _a.sent();
+                        _a.label = 2;
+                    case 2:
+                        this.clearFirebase();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    // Public Methods
+    Retter.prototype.authenticateWithCustomToken = function (token) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!this.initialized)
+                            throw new Error('Retter SDK not initialized.');
+                        return [4 /*yield*/, this.sendToAuthQueue({ action: types_1.RetterActions.SIGN_IN, data: token })];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    Retter.prototype.signOut = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!this.initialized)
+                            throw new Error('Retter SDK not initialized.');
+                        return [4 /*yield*/, this.clearCloudObjects()];
+                    case 1:
+                        _a.sent();
+                        return [4 /*yield*/, this.auth.signOut()];
+                    case 2:
+                        _a.sent();
+                        return [4 /*yield*/, this.auth.clearTokenData()
+                            // Fire auth status after all tokens cleared
+                        ];
+                    case 3:
+                        _a.sent();
+                        // Fire auth status after all tokens cleared
+                        this.fireAuthStatus({});
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    Retter.prototype.getCurrentUser = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.auth.getCurrentUser()];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    Retter.prototype.getCloudObject = function (config) {
+        var _a, _b, _c, _d;
+        return __awaiter(this, void 0, void 0, function () {
+            var instance, data, seekedObject, _e, state, unsubscribers, call, getState, listInstances, retVal;
+            var _this = this;
+            return __generator(this, function (_f) {
+                switch (_f.label) {
+                    case 0:
+                        if (!this.initialized)
+                            throw new Error('Retter SDK not initialized.');
+                        if (!(config.instanceId && config.useLocal)) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.sendToActionQueue({ action: types_1.RetterActions.EMPTY })];
+                    case 1:
+                        _f.sent();
+                        return [3 /*break*/, 4];
+                    case 2: return [4 /*yield*/, this.sendToActionQueue({ action: types_1.RetterActions.COS_INSTANCE, data: config })];
+                    case 3:
+                        data = (_f.sent()).data;
+                        instance = data;
+                        config.instanceId = instance.instanceId;
+                        _f.label = 4;
+                    case 4:
+                        seekedObject = this.cloudObjects.find(function (r) { return r.config.classId === config.classId && r.config.instanceId === config.instanceId; });
+                        if (seekedObject) {
+                            return [2 /*return*/, {
+                                    call: seekedObject.call,
+                                    state: seekedObject.state,
+                                    listInstances: seekedObject.listInstances,
+                                    getState: seekedObject.getState,
+                                    methods: (_a = instance === null || instance === void 0 ? void 0 : instance.methods) !== null && _a !== void 0 ? _a : [],
+                                    instanceId: config.instanceId,
+                                    response: seekedObject.response,
+                                    isNewInstance: false,
+                                }];
+                        }
+                        return [4 /*yield*/, this.getFirebaseState(config)];
+                    case 5:
+                        _e = _f.sent(), state = _e.state, unsubscribers = _e.unsubscribers;
+                        call = function (params) { return __awaiter(_this, void 0, void 0, function () {
+                            var error_4;
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0:
+                                        params.retryConfig = __assign(__assign({}, this.clientConfig.retryConfig), params.retryConfig);
+                                        _a.label = 1;
+                                    case 1:
+                                        _a.trys.push([1, 3, , 8]);
+                                        return [4 /*yield*/, this.sendToActionQueue({
+                                                action: types_1.RetterActions.COS_CALL,
+                                                data: __assign(__assign({}, params), { classId: config.classId, instanceId: config.instanceId }),
+                                            })];
+                                    case 2: return [2 /*return*/, _a.sent()];
+                                    case 3:
+                                        error_4 = _a.sent();
+                                        --params.retryConfig.count;
+                                        params.retryConfig.delay *= params.retryConfig.rate;
+                                        if (!(error_4.response && error_4.response.status === 570 && params.retryConfig.count > 0)) return [3 /*break*/, 6];
+                                        return [4 /*yield*/, new Promise(function (r) { return setTimeout(r, params.retryConfig.delay); })];
+                                    case 4:
+                                        _a.sent();
+                                        return [4 /*yield*/, call(params)];
+                                    case 5: return [2 /*return*/, _a.sent()];
+                                    case 6: throw error_4;
+                                    case 7: return [3 /*break*/, 8];
+                                    case 8: return [2 /*return*/];
+                                }
+                            });
+                        }); };
+                        getState = function (params) { return __awaiter(_this, void 0, void 0, function () {
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0: return [4 /*yield*/, this.sendToActionQueue({
+                                            action: types_1.RetterActions.COS_STATE,
+                                            data: __assign(__assign({}, params), { classId: config.classId, instanceId: config.instanceId }),
+                                        })];
+                                    case 1: return [2 /*return*/, _a.sent()];
+                                }
+                            });
+                        }); };
+                        listInstances = function (params) { return __awaiter(_this, void 0, void 0, function () {
+                            var data;
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0: return [4 /*yield*/, this.sendToActionQueue({
+                                            action: types_1.RetterActions.COS_LIST,
+                                            data: __assign(__assign({}, params), { classId: config.classId }),
+                                        })];
+                                    case 1:
+                                        data = (_a.sent()).data;
+                                        return [2 /*return*/, data.instanceIds];
+                                }
+                            });
+                        }); };
+                        retVal = {
+                            call: call,
+                            state: state,
+                            getState: getState,
+                            listInstances: listInstances,
+                            methods: (_b = instance === null || instance === void 0 ? void 0 : instance.methods) !== null && _b !== void 0 ? _b : [],
+                            response: (_c = instance === null || instance === void 0 ? void 0 : instance.response) !== null && _c !== void 0 ? _c : null,
+                            instanceId: config.instanceId,
+                            isNewInstance: (_d = instance === null || instance === void 0 ? void 0 : instance.newInstance) !== null && _d !== void 0 ? _d : false,
+                        };
+                        this.cloudObjects.push(__assign(__assign({}, retVal), { config: config, unsubscribers: unsubscribers }));
+                        return [2 /*return*/, retVal];
+                }
+            });
+        });
+    };
+    Retter.prototype.makeStaticCall = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!this.initialized)
+                            throw new Error('Retter SDK not initialized.');
+                        return [4 /*yield*/, this.sendToActionQueue({
+                                action: types_1.RetterActions.COS_STATIC_CALL,
+                                data: __assign(__assign({}, params), { classId: params.classId }),
+                            })];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    Object.defineProperty(Retter.prototype, "authStatus", {
+        get: function () {
+            return this.authStatusSubject.asObservable().pipe((0, operators_1.distinctUntilChanged)(function (a, b) { return a.authStatus === b.authStatus && a.identity === b.identity && a.uid === b.uid; }));
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Retter.instances = [];
+    return Retter;
+}());
+exports.default = Retter;
+//# sourceMappingURL=index.js.map