catalyst-core 0.0.1-beta.2

package/server/mainServer.js

@@ -0,0 +1,70 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _path = require("path");
+var _path2 = _interopRequireDefault(_path);
+var _express = require("express");
+var _express2 = _interopRequireDefault(_express);
+var _bodyParser = require("body-parser");
+var _bodyParser2 = _interopRequireDefault(_bodyParser);
+var _compression = require("compression");
+var _compression2 = _interopRequireDefault(_compression);
+var _cookieParser = require("cookie-parser");
+var _cookieParser2 = _interopRequireDefault(_cookieParser);
+var _expressStaticGzip = require("express-static-gzip");
+var _expressStaticGzip2 = _interopRequireDefault(_expressStaticGzip);
+var _renderer = require("./renderer");
+var _renderer2 = _interopRequireDefault(_renderer);
+var _server = require("$server/server.js");
+var _validator = require("./utils/validator");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+const env = process.env.NODE_ENV || "development";
+const app = (0, _express2.default)();
+
+//Use-case: We are using body-parser here for widget-factory, 
+//we need to extract the body of request which Native will hit at our end.
+app.use(_bodyParser2.default.json());
+
+// This change is added to accommodate “byetstream array”
+// which is octet-stream format coming from android!
+app.use(_bodyParser2.default.raw({
+  type: "application/*"
+}));
+
+// parse cookies!
+app.use((0, _cookieParser2.default)());
+
+// Apply custom midlewares
+if ((0, _validator.validateMiddleware)(_server.addMiddlewares)) (0, _server.addMiddlewares)(app);
+
+// gzip
+app.use((0, _compression2.default)());
+
+// We upload the assets on our s3 bucket and serve them through our CDN. 
+// However if our CDN is down all we have to do is change the PUBLIC_ASSET_PATH in basecamp 
+// to "node_server_ip/assets" (Example: http://13.127.237.229:8443/assets) to serve the assets from our node server.
+//  When we make production builds on our local system we change the PUBLIC_ASSET_PATH to "http://localhost:3005/assets/". 
+// In this case all the asset requests are made to the node server running on our local system and are served locally.
+if (env === "production") {
+  app.use("/assets", (0, _expressStaticGzip2.default)(_path2.default.join(__dirname, "../" + process.env.PUBLIC_OUTPUT_PATH), {
+    enableBrotli: true,
+    orderPreference: ["br", "gzip", "deflate"]
+  }), (0, _expressStaticGzip2.default)(_path2.default.join(__dirname, "../src/static/images"), {
+    enableBrotli: true,
+    orderPreference: ["br", "gzip", "deflate"]
+  }), (0, _expressStaticGzip2.default)(_path2.default.join(__dirname, "../src/static/fonts"), {
+    enableBrotli: true,
+    orderPreference: ["br", "gzip", "deflate"]
+  }), (0, _expressStaticGzip2.default)(_path2.default.join(__dirname, "../src/js/lib"), {
+    enableBrotli: true,
+    orderPreference: ["br", "gzip", "deflate"]
+  }));
+} else {
+  app.use("/assets", _express2.default.static(_path2.default.join(__dirname, "../" + process.env.PUBLIC_OUTPUT_PATH)), _express2.default.static(_path2.default.join(__dirname, `../${process.env.APPLICATION}/src/static/images`)), _express2.default.static(_path2.default.join(__dirname, `../${process.env.APPLICATION}/src/static/fonts`)), _express2.default.static(_path2.default.join(__dirname, `../${process.env.APPLICATION}/src/js/lib`)));
+}
+
+// handles document request
+app.use("*", _renderer2.default);
+exports.default = app;

package/server/renderer/document/Body.js

@@ -0,0 +1,37 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Body = Body;
+var _react = require("react");
+var _react2 = _interopRequireDefault(_react);
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+/**
+ * Body component which will be used in page component
+ * @param {object} initialState - redux store state
+ * @param {object} statusCode - api config present in cache list
+ * @param {object} firstFoldCss - user defined components for meta tags input
+ * @param {object} firstFoldJS - user defined components for meta tags input
+ * @param {object} jsx - user defined components for meta tags input
+ * @param {object} fetcherData - router fetched data
+ */
+function Body(props) {
+  const {
+    initialState,
+    statusCode,
+    firstFoldCss,
+    firstFoldJS,
+    jsx,
+    fetcherData
+  } = props;
+  return /*#__PURE__*/_react2.default.createElement("body", null, firstFoldCss, firstFoldJS, jsx, /*#__PURE__*/_react2.default.createElement("script", {
+    dangerouslySetInnerHTML: {
+      __html: `
+                    window.__INITIAL_STATE__ = ${JSON.stringify(initialState)};
+                    window.__STATUS_CODE__ = ${statusCode};
+                    window.__ROUTER_INITIAL_DATA__ = ${JSON.stringify(fetcherData)};
+            `
+    }
+  }), props.children);
+}

package/server/renderer/document/Head.js

@@ -0,0 +1,44 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Head = Head;
+var _react = require("react");
+var _react2 = _interopRequireDefault(_react);
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+/**
+ * Head component which will be used in page rendering
+ * @param {string} pageCss - includes all styles for page css
+ * @param {object} pageJS - async scripts for loading chunks
+ * @param {function} metaTagFunction - user defined function which returns meta tags in array
+ * @param {boolean} isBot - checks if request is made by bot
+ * @param {string} publicAssetPath - public asset path for assets
+ * @param {object} fetcherData - router fetched data
+ */
+function Head(props) {
+  const {
+    pageCss,
+    pageJS,
+    metaTagFunction,
+    isBot,
+    publicAssetPath,
+    fetcherData
+  } = props;
+  return /*#__PURE__*/_react2.default.createElement("head", null, /*#__PURE__*/_react2.default.createElement("meta", {
+    charSet: "utf-8"
+  }), /*#__PURE__*/_react2.default.createElement("meta", {
+    name: "viewport",
+    content: "width=device-width, initial-scale=1"
+  }), publicAssetPath && /*#__PURE__*/_react2.default.createElement("link", {
+    rel: "preconnect",
+    href: publicAssetPath
+  }), publicAssetPath && /*#__PURE__*/_react2.default.createElement("link", {
+    rel: "dns-prefetch",
+    href: publicAssetPath
+  }), metaTagFunction && metaTagFunction(fetcherData), !isBot && pageJS, !isBot && /*#__PURE__*/_react2.default.createElement("style", {
+    dangerouslySetInnerHTML: {
+      __html: pageCss
+    }
+  }), props.children);
+}

package/server/renderer/document/index.js

@@ -0,0 +1,25 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _Head = require("./Head");
+Object.keys(_Head).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _Head[key];
+    }
+  });
+});
+var _Body = require("./Body");
+Object.keys(_Body).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _Body[key];
+    }
+  });
+});

package/server/renderer/extract.js

@@ -0,0 +1,86 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.cacheCSS = cacheCSS;
+exports.cacheJS = cacheJS;
+exports.default = function (res, route) {
+  try {
+    const requestPath = route.path;
+    const cachedCss = fetchCachedCSS(requestPath);
+    const cachedJS = fetchCachedJS(requestPath);
+    if (cachedCss || cachedJS) {
+      res.locals.pageJS = cachedJS;
+      res.locals.pageCss = cachedCss;
+      return;
+    }
+  } catch (error) {
+    console.log("Error while reading lodable stats:");
+  }
+};
+var _path = require("path");
+var _path2 = _interopRequireDefault(_path);
+var _fs = require("fs");
+var _fs2 = _interopRequireDefault(_fs);
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+/**
+ * Stores css chunks styles into cache in string format
+ * @param {string} key - router path
+ * @param {object} data - css elements array extracted through loadable chunk extracter
+ */
+function cacheCSS(key, data) {
+  if (!process.cssCache) {
+    process.cssCache = {};
+  }
+  let pageCss = "";
+  if (Array.isArray(data)) {
+    try {
+      data.map(assetChunk => {
+        const assetPathArr = assetChunk.key.split("/");
+        const assetName = assetPathArr[assetPathArr.length - 1];
+        const ext = _path2.default.extname(assetName);
+        if (ext === ".css") pageCss += _fs2.default.readFileSync(_path2.default.resolve(process.env.src_path, `${process.env.OUTPUT_PATH}/public/`, assetName));
+      });
+    } catch (error) {
+      console.log("=====> Error While Extracting The Chunk:");
+    }
+  }
+  process.cssCache[key] = pageCss;
+}
+
+/**
+ * Stores javascript into cache
+ * @param {string} key - router path
+ * @param {object} data - js elements array extracted through loadable chunk extracter
+ */
+function cacheJS(key, data) {
+  if (!process.jsCache) {
+    process.jsCache = {};
+  }
+  process.jsCache[key] = data;
+}
+
+/**
+ * returns cached css
+ * @param {string} key - router path
+ * @return {string} - cached css 
+ */
+function fetchCachedCSS(key) {
+  return process.cssCache && process.cssCache[key] ? process.cssCache[key] : null;
+}
+
+/**
+ * returns cached js
+ * @param {string} key - router path
+ * @return {string} - cached js 
+ */
+function fetchCachedJS(key) {
+  return process.jsCache && process.jsCache[key] ? process.jsCache[key] : null;
+}
+
+/**
+ * stores css and js in cache
+ * @param {object} res - response object
+ * @param {string} route - route path
+ */

package/server/renderer/handler.js

@@ -0,0 +1,228 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = async function (req, res) {
+  try {
+    let context = {};
+    let fetcherData = {};
+    const webExtractor = new _server3.ChunkExtractor({
+      statsFile: webStats,
+      entrypoints: ["app"]
+    });
+    const deviceDetails = (0, _userAgentUtil.getUserAgentDetails)(req.headers["user-agent"] || "");
+    const isBot = deviceDetails.googleBot || req.get("user-agent") === STATUS_CAKE_USER_AGENT_MOBILE ? true : false;
+
+    // FRAMEWORK COMMENT GENERALISE THIS
+    const store = (0, _validator.validateConfigureStore)(configureStore) ? configureStore({}, {}, req) : null;
+
+    //TODO: Currently passing 4th arguement as whole request to bypass x-authorization to BE
+    // Need to store the auth_token and user information locally too
+    // Create a new Redux store instance
+    // const store = configureStore({}, requestCookies, req, customHeaders)
+
+    //get csrf token from client request
+    // const csrf = typeof req.csrfToken === "function" && req.csrfToken()
+    // See react-router's Server Rendering section:
+    // https://reacttraining.com/react-router/web/guides/server-rendering
+    const matchRoutes = routes => {
+      return routes.reduce((matches, route) => {
+        const {
+          path
+        } = route;
+        const match = (0, _router.matchPath)({
+          path,
+          caseSensitive: false,
+          end: true
+        }, req.baseUrl || "/");
+        if (match) {
+          if (isProduction && !res.locals.pageCss && !res.locals.pageJS && !res.locals.routePath) {
+            (0, _extract2.default)(res, route);
+          }
+          if (!res.locals.pageCss && !res.locals.pageJS && !res.locals.routePath) {
+            res.locals.routePath = path;
+            //moving routing logic outside of the App and using ServerRoutes for creating routes on server instead
+            (0, _server2.renderToString)( /*#__PURE__*/_react2.default.createElement(_server3.ChunkExtractorManager, {
+              extractor: webExtractor
+            }, /*#__PURE__*/_react2.default.createElement(_reactRedux.Provider, {
+              store: store
+            }, /*#__PURE__*/_react2.default.createElement(_server.StaticRouter, {
+              context: context,
+              location: req.originalUrl
+            }, /*#__PURE__*/_react2.default.createElement(_ServerRouter2.default, {
+              store: store,
+              intialData: fetcherData
+            })))));
+          }
+          const wc = route.component;
+          matches.push({
+            route,
+            match,
+            serverSideFunction: wc && wc.serverSideFunction || (() => Promise.resolve()),
+            metaTagFunction: wc && wc.metaTagFunction || null,
+            serverFetcher: wc && wc.serverFetcher || (() => Promise.resolve()),
+            callServerFetcher: wc && wc.serverFetcher ? true : false
+          });
+        }
+        if (!match && route.routes) {
+          // recursively try to match nested routes
+          const nested = matchRoutes(route.routes);
+          if (nested.length) {
+            matches = matches.concat(nested);
+          }
+        }
+        return matches;
+      }, []);
+    };
+    const routes = (0, _validator.validateGetRoutes)(getRoutes) ? getRoutes() : [];
+    const matches = matchRoutes(routes);
+    // No matched route, send an error.
+    // if (!matches.length) {
+    //     // res.status(404)
+    //     return res.redirect(301, process.env.EXTERNAL_BASE_URL + "/404")
+    // }
+
+    const getComponent = () => {
+      //moving routing logic outside of the App and using ServerRouter for creating routes on server instead
+      return /*#__PURE__*/_react2.default.createElement("div", {
+        id: "app"
+      }, /*#__PURE__*/_react2.default.createElement(_reactRedux.Provider, {
+        store: store
+      }, /*#__PURE__*/_react2.default.createElement(_server.StaticRouter, {
+        context: context,
+        location: req.originalUrl
+      }, /*#__PURE__*/_react2.default.createElement(_ServerRouter2.default, {
+        store: store,
+        intialData: fetcherData
+      }))));
+    };
+    let metaTagFunction = null;
+    const renderMarkUp = async errorCode => {
+      const shellStart = await _render2.default.renderStart(res.locals.pageCss, res.locals.pageJS, metaTagFunction, isBot, fetcherData);
+      const jsx = webExtractor.collectChunks(getComponent());
+      let state = store.getState();
+      const shellEnd = _render2.default.renderEnd(webExtractor, state, res, jsx, errorCode, fetcherData);
+      const finalProps = _objectSpread(_objectSpread(_objectSpread({}, shellStart), shellEnd), {}, {
+        jsx: jsx,
+        req,
+        res
+      });
+      let CompleteDocument = () => {
+        if ((0, _validator.validateCustomDocument)(CustomDocument)) {
+          return CustomDocument(finalProps);
+        } else {
+          return /*#__PURE__*/_react2.default.createElement("html", {
+            lang: finalProps.lang
+          }, /*#__PURE__*/_react2.default.createElement(_document.Head, finalProps), /*#__PURE__*/_react2.default.createElement(_document.Body, finalProps));
+        }
+      };
+      try {
+        let status = matches.length && matches[0].match.path === "*" ? 404 : 200;
+        res.set({
+          "content-type": "text/html; charset=utf-8"
+        });
+        res.status(status);
+        const {
+          pipe
+        } = (0, _server2.renderToPipeableStream)( /*#__PURE__*/_react2.default.createElement(CompleteDocument, null), {
+          onShellReady() {
+            res.setHeader("content-type", "text/html");
+            pipe(res);
+            res.end();
+          },
+          onError(error) {
+            //transformed to new log format
+            logger.error({
+              message: `\n====> Error while renderToPipeableStream : ${error.toString()}`
+            });
+          }
+        });
+      } catch (error) {
+        logger.error("Error while rendering markup:" + error);
+      }
+    };
+
+    // Server side function calling
+    _App2.default.serverSideFunction({
+      store,
+      req
+    }).then(() => {
+      const serverSideFunction = matches.map(match => {
+        if (match?.metaTagFunction) {
+          metaTagFunction = match.metaTagFunction;
+        }
+        return match.serverSideFunction({
+          store
+        });
+      });
+
+      // Api calling to fetch data
+      Promise.all(serverSideFunction).then(() => {
+        (0, _router.serverDataFetcher)({
+          routes: routes,
+          req,
+          url: req.originalUrl
+        }, {
+          store
+        }).then(res => {
+          fetcherData = res;
+        }).then(async () => await renderMarkUp(null)).catch(async error => {
+          logger.error("error in calling server fetcher is ====>" + error);
+          await renderMarkUp(404);
+        });
+      });
+    }).catch(error => {
+      logger.error("error in server side function is ====>" + error);
+      renderMarkUp(error.status_code);
+    });
+  } catch (error) {
+    logger.error("Error on server outer" + error.toString());
+  }
+};
+var _react = require("react");
+var _react2 = _interopRequireDefault(_react);
+var _path = require("path");
+var _path2 = _interopRequireDefault(_path);
+var _reactRedux = require("react-redux");
+var _router = require("@tata1mg/router");
+var _server = require("react-router-dom/server");
+var _server2 = require("react-dom/server");
+var _server3 = require("@loadable/server");
+var _App = require("@containers/App");
+var _App2 = _interopRequireDefault(_App);
+var _render = require("./render");
+var _render2 = _interopRequireDefault(_render);
+var _extract = require("./extract");
+var _extract2 = _interopRequireDefault(_extract);
+var _userAgentUtil = require("./userAgentUtil.js");
+var _document = require("./document");
+var _validator = require("../utils/validator");
+var _ServerRouter = require("../../router/ServerRouter.js");
+var _ServerRouter2 = _interopRequireDefault(_ServerRouter);
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+const {
+  default: configureStore
+} = require(`${process.env.src_path}/src/js/store/index.js`);
+const {
+  default: getRoutes
+} = require(`${process.env.src_path}/src/js/routes/index.js`);
+const {
+  default: CustomDocument
+} = require(`${process.env.src_path}/server/document.js`);
+const STATUS_CAKE_USER_AGENT_MOBILE = "StatusCake/Pretest (statuscake.com)";
+const isProduction = process.env.NODE_ENV === "production";
+let webStats = null;
+webStats = _path2.default.join(__dirname, "../..", `loadable-stats.json`);
+if (isProduction) webStats = _path2.default.join(__dirname, "../..", process.env.PUBLIC_OUTPUT_PATH, `loadable-stats.json`);
+
+/**
+ * middleware for document handling
+ * @param {object} req - router path
+ * @param {object} res - css elements array extracted through loadable chunk extracter
+ */

package/server/renderer/index.js

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _express = require("express");
+var _express2 = _interopRequireDefault(_express);
+var _handler = require("./handler");
+var _handler2 = _interopRequireDefault(_handler);
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+const router = _express2.default.Router();
+router.use(_handler2.default);
+exports.default = router;

package/server/renderer/render.js

@@ -0,0 +1,71 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _extract = require("./extract");
+/**
+ * returns data which will be used in head component for page rendering
+ * @param {string} pageCss - includes all styles for page css
+ * @param {string} pageJS - async scripts for loading chunks
+ * @param {function} metaTagFunction - user defined function which returns meta tags in array
+ * @param {boolean} isBot - checks if request is made by bot
+ * @param {object} fetcherData - router fetched data
+ */
+const renderStart = (pageCss, pageJS, metaTagFunction, isBot, fetcherData) => {
+  let publicAssetPath = "/assets";
+  const isProd = process.env.NODE_ENV === "production";
+  if (isProd) {
+    publicAssetPath = `${process.env.CDN_ASSET_PATH}/${process.env.S3_FOLDER}/${process.env.BUILD_ENV}/${process.env.BUILD_NUMBER}/static/images`;
+  }
+  return {
+    pageCss,
+    pageJS,
+    metaTagFunction,
+    isBot,
+    publicAssetPath,
+    fetcherData
+  };
+};
+
+/**
+ * returns data which will be used in body component for page rendering
+ * @param {object} webExtractor - loadable object which holds chunking function
+ * @param {string} initialState - reducer initial state
+ * @param {function} res - response object
+ * @param {boolean} jsx - jsx which needs to be render on server side
+ * @param {string|number|null} errorCode - error code 
+ * @param {object} fetcherData - router fetched data
+ */
+const renderEnd = (webExtractor, initialState = {}, res, jsx, errorCode, fetcherData) => {
+  // For bot first fold css and js would become complete page css and js
+  let firstFoldCss = "",
+    firstFoldJS = "",
+    publicSWPath = "/assets";
+  const isProd = process.env.NODE_ENV === "production";
+  const {
+    routePath,
+    pageCss,
+    pageJS
+  } = res.locals;
+  if (!isProd || routePath && (!pageCss || !pageJS)) {
+    firstFoldCss = webExtractor.getStyleElements();
+    firstFoldJS = webExtractor.getScriptElements();
+    if (isProd) {
+      (0, _extract.cacheCSS)(routePath, webExtractor.getLinkElements());
+      (0, _extract.cacheJS)(routePath, firstFoldJS);
+    }
+  }
+  return {
+    initialState,
+    firstFoldCss,
+    firstFoldJS,
+    jsx,
+    errorCode,
+    fetcherData
+  };
+};
+exports.default = {
+  renderStart,
+  renderEnd
+};

package/server/renderer/userAgentUtil.js

@@ -0,0 +1,55 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getUserAgentDetails = undefined;
+var _uaParserJs = require("ua-parser-js");
+var _uaParserJs2 = _interopRequireDefault(_uaParserJs);
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+const googleBots = {
+  "APIs-Google": "APIs-Google",
+  AdSense: "Mediapartners-Google",
+  "AdsBot Mobile Web Android": "AdsBot-Google-Mobile",
+  "AdsBot Mobile Web": "AdsBot-Google-Mobile",
+  AdsBot: "AdsBot-Google",
+  "Mobile AdSense": "Mediapartners-Google",
+  "Mobile Apps Android": "AdsBot-Google-Mobile-Apps",
+  Feedfetcher: "FeedFetcher-Google",
+  "Google Read Aloud": "Google-Read-Aloud",
+  "Duplex on the Web": "DuplexWeb-Google",
+  "Google Favicon": "Google Favicon",
+  "Web Light": "googleweblight",
+  "Amp crawler": "Google-AMPHTM",
+  Googlebot: "Googlebot"
+};
+
+/**
+ * check if user agent contains bot data
+ * @param {string} ua - user agent
+ * @return {string|null}
+ */
+const getGoogleBot = ua => {
+  for (let key in googleBots) {
+    if (ua.includes(googleBots[key])) return key;
+  }
+  return null;
+};
+
+/**
+ * returns object which contains google bot and user-agent info 
+ * @param {string} ua - user agent
+ * @return {object} - returns user agent
+ */
+const getUserAgentDetails = exports.getUserAgentDetails = ua => {
+  const agentDetails = (0, _uaParserJs2.default)(ua);
+  const googleBot = getGoogleBot(ua);
+  return _objectSpread(_objectSpread({}, agentDetails), {}, {
+    googleBot
+  });
+};