text: "use strict";
  /* Copyright (c) 2021, VRAI Labs and/or its affiliates. All rights reserved.
   *
   * This software is licensed under the Apache License, Version 2.0 (the
   * "License") as published by the Apache Software Foundation.
   *
   * You may not use this file except in compliance with the License. You may
   * obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
   * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
   * License for the specific language governing permissions and limitations
   * under the License.
   */
  var __awaiter =
      (this && this.__awaiter) ||
      function (thisArg, _arguments, P, generator) {
          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)
                      : new P(function (resolve) {
                            resolve(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 constants_1 = require("./constants");
  var normalisedURLDomain_1 = __importDefault(require("./normalisedURLDomain"));
  var normalisedURLPath_1 = __importDefault(require("./normalisedURLPath"));
  /*
   * NormalisedRecipeModuleHooks
   */
  function normalisedRecipeModuleHooks(config) {
      var _this = this;
      var preAPIHook = config.preAPIHook,
          onHandleEvent = config.onHandleEvent,
          getRedirectionURL = config.getRedirectionURL;
      if (preAPIHook === undefined) {
          // eslint-disable-next-line @typescript-eslint/no-unused-vars
          preAPIHook = function (context) {
              return __awaiter(_this, void 0, void 0, function () {
                  return __generator(this, function (_a) {
                      return [2 /*return*/, context.requestInit];
                  });
              });
          };
      }
      if (onHandleEvent === undefined) {
          // eslint-disable-next-line @typescript-eslint/no-unused-vars, @typescript-eslint/no-empty-function
          onHandleEvent = function (_) {};
      }
      if (getRedirectionURL === undefined) {
          // eslint-disable-next-line @typescript-eslint/no-unused-vars
          getRedirectionURL = function (_) {
              return __awaiter(_this, void 0, void 0, function () {
                  return __generator(this, function (_a) {
                      return [2 /*return*/, undefined];
                  });
              });
          };
      }
      return {
          preAPIHook: preAPIHook,
          getRedirectionURL: getRedirectionURL,
          onHandleEvent: onHandleEvent,
      };
  }
  exports.normalisedRecipeModuleHooks = normalisedRecipeModuleHooks;
  /*
   * getRecipeIdFromPath
   * Input:
   * Output: The "rid" query param if present, null otherwise.
   */
  function getRecipeIdFromSearch(search) {
      var urlParams = new URLSearchParams(search);
      return urlParams.get(constants_1.RECIPE_ID_QUERY_PARAM);
  }
  exports.getRecipeIdFromSearch = getRecipeIdFromSearch;
  function getQueryParams(param) {
      var urlParams = new URLSearchParams(getWindowOrThrow().location.search);
      return urlParams.get(param);
  }
  exports.getQueryParams = getQueryParams;
  function getRedirectToPathFromURL() {
      var param = getQueryParams("redirectToPath");
      if (param === null) {
          return undefined;
      } else {
          // Prevent Open redirects by normalising path.
          try {
              return new normalisedURLPath_1.default(param).getAsStringDangerous();
          } catch (_a) {
              return undefined;
          }
      }
  }
  exports.getRedirectToPathFromURL = getRedirectToPathFromURL;
  /*
   * isTest
   */
  function isTest() {
      return process.env.TEST_MODE === "testing";
  }
  exports.isTest = isTest;
  function normaliseInputAppInfoOrThrowError(appInfo) {
      if (appInfo === undefined) {
          throw new Error("Please provide the appInfo object when calling supertokens.init");
      }
      if (appInfo.apiDomain === undefined) {
          throw new Error("Please provide your apiDomain inside the appInfo object when calling supertokens.init");
      }
      if (appInfo.appName === undefined) {
          throw new Error("Please provide your appName inside the appInfo object when calling supertokens.init");
      }
      if (appInfo.websiteDomain === undefined) {
          throw new Error("Please provide your websiteDomain inside the appInfo object when calling supertokens.init");
      }
      var apiGatewayPath = new normalisedURLPath_1.default("");
      if (appInfo.apiGatewayPath !== undefined) {
          apiGatewayPath = new normalisedURLPath_1.default(appInfo.apiGatewayPath);
      }
      return {
          appName: appInfo.appName,
          apiDomain: new normalisedURLDomain_1.default(appInfo.apiDomain),
          websiteDomain: new normalisedURLDomain_1.default(appInfo.websiteDomain),
          apiBasePath: apiGatewayPath.appendPath(
              getNormalisedURLPathOrDefault(constants_1.DEFAULT_API_BASE_PATH, appInfo.apiBasePath)
          ),
          websiteBasePath: getNormalisedURLPathOrDefault(constants_1.DEFAULT_WEBSITE_BASE_PATH, appInfo.websiteBasePath),
      };
  }
  exports.normaliseInputAppInfoOrThrowError = normaliseInputAppInfoOrThrowError;
  function getNormalisedURLPathOrDefault(defaultPath, path) {
      if (path !== undefined) {
          return new normalisedURLPath_1.default(path);
      } else {
          return new normalisedURLPath_1.default(defaultPath);
      }
  }
  /*
   * validateForm
   */
  // We check that the number of fields in input and config form field is the same.
  // We check that each item in the config form field is also present in the input form field
  function validateForm(inputs, configFormFields) {
      return __awaiter(this, void 0, void 0, function () {
          var validationErrors, _loop_1, i;
          return __generator(this, function (_a) {
              switch (_a.label) {
                  case 0:
                      validationErrors = [];
                      if (configFormFields.length !== inputs.length) {
                          throw Error("Are you sending too many / too few formFields?");
                      }
                      _loop_1 = function (i) {
                          var field, input, value, error;
                          return __generator(this, function (_a) {
                              switch (_a.label) {
                                  case 0:
                                      field = configFormFields[i];
                                      input = inputs.find(function (i) {
                                          return i.id === field.id;
                                      });
                                      value = input.value;
                                      if (input.id === "email") {
                                          value = value.trim();
                                      }
                                      return [4 /*yield*/, field.validate(value)];
                                  case 1:
                                      error = _a.sent();
                                      // If error, add it.
                                      if (error !== undefined) {
                                          validationErrors.push({
                                              error: error,
                                              id: field.id,
                                          });
                                      }
                                      return [2 /*return*/];
                              }
                          });
                      };
                      i = 0;
                      _a.label = 1;
                  case 1:
                      if (!(i < configFormFields.length)) return [3 /*break*/, 4];
                      return [5 /*yield**/, _loop_1(i)];
                  case 2:
                      _a.sent();
                      _a.label = 3;
                  case 3:
                      i++;
                      return [3 /*break*/, 1];
                  case 4:
                      return [2 /*return*/, validationErrors];
              }
          });
      });
  }
  exports.validateForm = validateForm;
  /*
   * getCurrentNormalisedUrlPath
   */
  function getCurrentNormalisedUrlPath() {
      return new normalisedURLPath_1.default(getWindowOrThrow().location.pathname);
  }
  exports.getCurrentNormalisedUrlPath = getCurrentNormalisedUrlPath;
  function appendQueryParamsToURL(stringUrl, queryParams) {
      if (queryParams === undefined) {
          return stringUrl;
      }
      try {
          var url_1 = new URL(stringUrl);
          Object.entries(queryParams).forEach(function (_a) {
              var key = _a[0],
                  value = _a[1];
              url_1.searchParams.set(key, value);
          });
          return url_1.href;
      } catch (e) {
          var fakeDomain = stringUrl.startsWith("/") ? "http:localhost" : "http://localhost/";
          var url_2 = new URL("" + fakeDomain + stringUrl);
          Object.entries(queryParams).forEach(function (_a) {
              var key = _a[0],
                  value = _a[1];
              url_2.searchParams.set(key, value);
          });
          return "" + url_2.pathname + url_2.search;
      }
  }
  exports.appendQueryParamsToURL = appendQueryParamsToURL;
  function getWindowOrThrow() {
      // eslint-disable-next-line supertokens-auth-react/no-direct-window-object
      if (typeof window === "undefined") {
          throw new Error(constants_1.WINDOW_UNDEFINED_ERROR);
      }
      // eslint-disable-next-line supertokens-auth-react/no-direct-window-object
      return window;
  }
  exports.getWindowOrThrow = getWindowOrThrow;
  function getShouldUseShadowDom(useShadowDom) {
      /*
       * Detect if browser is IE
       * In order to disable unsupported shadowDom
       * https://github.com/supertokens/supertokens-auth-react/issues/99
       */
      var isIE = getWindowOrThrow().document.documentMode !== undefined;
      // If browser is Internet Explorer, always disable shadow dom.
      if (isIE === true) {
          return false;
      }
      // Otherwise, use provided config or default to true.
      return useShadowDom !== undefined ? useShadowDom : true;
  }
  exports.getShouldUseShadowDom = getShouldUseShadowDom;
  /*
   * Default method for matching recipe route based on query params.
   */
  function matchRecipeIdUsingQueryParams(recipeId) {
      return function () {
          var recipeIdFromSearch = getRecipeIdFromSearch(getWindowOrThrow().location.search);
          return recipeIdFromSearch === recipeId;
      };
  }
  exports.matchRecipeIdUsingQueryParams = matchRecipeIdUsingQueryParams;
  function isRequestInit(x) {
      return x.requestInit === undefined;
  }
  exports.isRequestInit = isRequestInit;
  //# sourceMappingURL=utils.js.map
  