core-native/lib/platform/bootstrap.js

A lightweight framework based on React Native + Redux + Redux Saga, in strict TypeScript.

import { __awaiter, __extends, __generator, __values } from "tslib";
import React from "react";
import { AppRegistry, AppState } from "react-native";
import { Provider } from "react-redux";
import { app } from "../app";
import {} from "../Logger";
import {} from "../module";
import { call, delay } from "../typed-saga";
import { ErrorBoundary } from "../util/ErrorBoundary";
import { ajax } from "../util/network";
import { APIException } from "../Exception";
import { captureError } from "../util/error-util";
var LOGGER_ACTION = "@@framework/logger";
export function startApp(config) {
    setupGlobalErrorHandler(config.errorListener);
    runBackgroundLoop(config.loggerConfig);
    renderRoot(config.registeredAppName, config.componentType, config.beforeRendering);
}
function setupGlobalErrorHandler(errorListener) {
    app.errorHandler = errorListener.onError.bind(errorListener);
    ErrorUtils.setGlobalHandler(function (error, isFatal) { return captureError(error, "@@framework/global", isFatal ? { severity: "fatal" } : undefined); });
}
function renderRoot(registeredAppName, EntryComponent, beforeRendering) {
    var WrappedAppComponent = /** @class */ (function (_super) {
        __extends(WrappedAppComponent, _super);
        function WrappedAppComponent(props) {
            var _this = _super.call(this, props) || this;
            _this.onAppStateChange = function (nextAppState) {
                var appState = _this.state.appState;
                if (["inactive", "background"].includes(appState) && nextAppState === "active") {
                    app.logger.info({ action: "@@ACTIVE", info: { prevState: appState } });
                }
                else if (appState === "active" && ["inactive", "background"].includes(nextAppState)) {
                    app.logger.info({ action: "@@INACTIVE", info: { nextState: nextAppState } });
                    sendEventLogs();
                }
                _this.setState({ appState: nextAppState });
            };
            _this.state = { initialized: false, appState: AppState.currentState };
            return _this;
        }
        WrappedAppComponent.prototype.componentDidMount = function () {
            return __awaiter(this, void 0, void 0, function () {
                return __generator(this, function (_a) {
                    switch (_a.label) {
                        case 0:
                            if (!beforeRendering) return [3 /*break*/, 2];
                            return [4 /*yield*/, beforeRendering()];
                        case 1:
                            _a.sent();
                            _a.label = 2;
                        case 2:
                            this.setState({ initialized: true });
                            this.appStateListener = AppState.addEventListener("change", this.onAppStateChange);
                            return [2 /*return*/];
                    }
                });
            });
        };
        WrappedAppComponent.prototype.componentWillUnmount = function () {
            var _a;
            (_a = this.appStateListener) === null || _a === void 0 ? void 0 : _a.remove();
        };
        WrappedAppComponent.prototype.render = function () {
            return (this.state.initialized && (<Provider store={app.store}>
                        <ErrorBoundary>
                            <EntryComponent />
                        </ErrorBoundary>
                    </Provider>));
        };
        return WrappedAppComponent;
    }(React.PureComponent));
    AppRegistry.registerComponent(registeredAppName, function () { return WrappedAppComponent; });
}
function runBackgroundLoop(loggerConfig) {
    app.logger.info({ action: "@@ENTER" });
    app.loggerConfig = loggerConfig || null;
    app.sagaMiddleware.run(function () {
        return __generator(this, function (_a) {
            switch (_a.label) {
                case 0:
                    if (!true) return [3 /*break*/, 3];
                    // Loop on every 15 second
                    return [4 /*yield*/, delay(15000)];
                case 1:
                    // Loop on every 15 second
                    _a.sent();
                    // Send collected log to event server
                    return [5 /*yield**/, __values(call(sendEventLogs))];
                case 2:
                    // Send collected log to event server
                    _a.sent();
                    return [3 /*break*/, 0];
                case 3: return [2 /*return*/];
            }
        });
    });
}
export function sendEventLogs() {
    return __awaiter(this, void 0, void 0, function () {
        var logs, logLength, e_1;
        return __generator(this, function (_a) {
            switch (_a.label) {
                case 0:
                    if (!app.loggerConfig) return [3 /*break*/, 4];
                    logs = app.logger.collect(200);
                    logLength = logs.length;
                    if (!(logLength > 0)) return [3 /*break*/, 4];
                    _a.label = 1;
                case 1:
                    _a.trys.push([1, 3, , 4]);
                    return [4 /*yield*/, ajax("POST", app.loggerConfig.serverURL, {}, { events: logs }, true)];
                case 2:
                    _a.sent();
                    app.logger.emptyLastCollection();
                    return [3 /*break*/, 4];
                case 3:
                    e_1 = _a.sent();
                    if (e_1 instanceof APIException) {
                        // For APIException, retry always leads to same error, so have to give up
                        // Do not log network exceptions
                        app.logger.emptyLastCollection();
                        app.logger.exception(e_1, { dropped_logs: logLength.toString() }, LOGGER_ACTION);
                    }
                    return [3 /*break*/, 4];
                case 4: return [2 /*return*/];
            }
        });
    });
}
//# sourceMappingURL=bootstrap.js.map