@opengeoweb/api 4.10.0

package/index.esm.js

@@ -0,0 +1,544 @@
+import * as React from 'react';
+import axios from 'axios';
+import { useIsMounted } from '@opengeoweb/shared';
+
+function _slicedToArray(arr, i) {
+  return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
+}
+
+function _arrayWithHoles(arr) {
+  if (Array.isArray(arr)) return arr;
+}
+
+function _iterableToArrayLimit(arr, i) {
+  if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return;
+  var _arr = [];
+  var _n = true;
+  var _d = false;
+  var _e = undefined;
+
+  try {
+    for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {
+      _arr.push(_s.value);
+
+      if (i && _arr.length === i) break;
+    }
+  } catch (err) {
+    _d = true;
+    _e = err;
+  } finally {
+    try {
+      if (!_n && _i["return"] != null) _i["return"]();
+    } finally {
+      if (_d) throw _e;
+    }
+  }
+
+  return _arr;
+}
+
+function _unsupportedIterableToArray(o, minLen) {
+  if (!o) return;
+  if (typeof o === "string") return _arrayLikeToArray(o, minLen);
+  var n = Object.prototype.toString.call(o).slice(8, -1);
+  if (n === "Object" && o.constructor) n = o.constructor.name;
+  if (n === "Map" || n === "Set") return Array.from(o);
+  if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+}
+
+function _arrayLikeToArray(arr, len) {
+  if (len == null || len > arr.length) len = arr.length;
+
+  for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
+
+  return arr2;
+}
+
+function _nonIterableRest() {
+  throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+
+/*
+  Accepts a value and timeout and will debounce
+  
+  @param {string} value: value of element
+  @param {timeout} number: timer
+  @return {value: string}
+
+  @example:
+   const debouncedName = useDebounce('testing', 2000)
+*/
+
+var useDebounce = function useDebounce(value, timeout) {
+  var _React$useState = React.useState(value),
+      _React$useState2 = _slicedToArray(_React$useState, 2),
+      state = _React$useState2[0],
+      setState = _React$useState2[1];
+
+  React.useEffect(function () {
+    var handler = setTimeout(function () {
+      return setState(value);
+    }, timeout);
+    return function () {
+      return clearTimeout(handler);
+    };
+  }, [value, timeout]);
+  return state;
+};
+
+/*! *****************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+
+function __rest(s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+}
+
+function __awaiter(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 generateRandomId = function generateRandomId() {
+  return "-".concat(Math.random().toString(36).substr(2, 9));
+}; // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+
+
+var useApi = function useApi(apiCall) {
+  var params = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+
+  var _useIsMounted = useIsMounted(),
+      isMounted = _useIsMounted.isMounted;
+
+  var _React$useState = React.useState(generateRandomId()),
+      _React$useState2 = _slicedToArray(_React$useState, 1),
+      id = _React$useState2[0];
+
+  var _React$useState3 = React.useState(true),
+      _React$useState4 = _slicedToArray(_React$useState3, 2),
+      isLoading = _React$useState4[0],
+      setIsloading = _React$useState4[1];
+
+  var _React$useState5 = React.useState(null),
+      _React$useState6 = _slicedToArray(_React$useState5, 2),
+      error = _React$useState6[0],
+      setError = _React$useState6[1];
+
+  var _React$useState7 = React.useState(null),
+      _React$useState8 = _slicedToArray(_React$useState7, 2),
+      result = _React$useState8[0],
+      setResult = _React$useState8[1];
+
+  var debouncedParams = useDebounce(JSON.stringify(params), 300);
+
+  var fetchApiData = function fetchApiData() {
+    var _params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
+
+    return __awaiter(void 0, void 0, void 0, /*#__PURE__*/regeneratorRuntime.mark(function _callee() {
+      var response;
+      return regeneratorRuntime.wrap(function _callee$(_context) {
+        while (1) {
+          switch (_context.prev = _context.next) {
+            case 0:
+              _context.prev = 0;
+              setIsloading(true);
+              setError(null);
+              _context.next = 5;
+              return apiCall(_params, id);
+
+            case 5:
+              response = _context.sent;
+
+              if (isMounted.current) {
+                setResult(Array.isArray(response) ? response.map(function (d) {
+                  return d.data;
+                }) : response.data);
+                setIsloading(false);
+                setError(null);
+              }
+
+              _context.next = 12;
+              break;
+
+            case 9:
+              _context.prev = 9;
+              _context.t0 = _context["catch"](0);
+
+              if (isMounted.current) {
+                if (axios.isCancel(_context.t0)) {
+                  setIsloading(false);
+                } else {
+                  setError(_context.t0);
+                  setIsloading(false);
+                }
+              }
+
+            case 12:
+            case "end":
+              return _context.stop();
+          }
+        }
+      }, _callee, null, [[0, 9]]);
+    }));
+  };
+
+  React.useEffect(function () {
+    fetchApiData(params);
+  }, // eslint-disable-next-line react-hooks/exhaustive-deps
+  [debouncedParams]);
+
+  var clearResults = function clearResults() {
+    setIsloading(true);
+    setResult(null);
+  };
+
+  return {
+    isLoading: isLoading,
+    error: error,
+    result: result,
+    clearResults: clearResults,
+    fetchApiData: fetchApiData
+  };
+};
+
+var ApiContext = /*#__PURE__*/React.createContext({
+  api: null
+});
+var registeredApis = new Map();
+
+function registerApi(name, api) {
+  registeredApis.set(name, api);
+}
+
+function unRegisterApi(name) {
+  registeredApis["delete"](name);
+}
+
+function getApi(name) {
+  return registeredApis.get(name);
+}
+var ApiProvider = function ApiProvider(_a) {
+  var children = _a.children,
+      createApi = _a.createApi,
+      name = _a.name,
+      apiModuleProps = __rest(_a, ["children", "createApi", "name"]);
+
+  var handleNewApi = React.useCallback(function () {
+    var newApi = createApi(apiModuleProps);
+
+    if (name) {
+      registerApi(name, newApi);
+    }
+
+    return newApi; // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [createApi, name]);
+
+  var _React$useState = React.useState(handleNewApi),
+      _React$useState2 = _slicedToArray(_React$useState, 2),
+      api = _React$useState2[0],
+      setApi = _React$useState2[1];
+
+  React.useEffect(function () {
+    setApi(handleNewApi);
+    return function () {
+      if (name) {
+        unRegisterApi(name);
+      }
+    };
+  }, [handleNewApi, name]);
+  return /*#__PURE__*/React.createElement(ApiContext.Provider, {
+    value: {
+      api: api
+    }
+  }, children);
+};
+function useApiContext() {
+  return React.useContext(ApiContext);
+}
+
+var DEFAULT_TIMEOUT = 15000;
+var REFRESH_TOKEN_WHEN_PCT_EXPIRED = 75; // Refresh token when 75% expired. Set to (10 / 3600) * 100 = 0.2777778%  to test with 10 second interval.
+
+var DEFAULT_TOKEN_EXPIRES_IN = 3600; // Number of seconds a token expires by default
+
+var MILLISECOND_TO_SECOND = 1 / 1000;
+/**
+ * Creates a Credentials object based on the axios response from the token service.
+ *
+ * It will calculate the expires_at attribute based on the expires_in property found in the JWT.
+ *
+ * @param tokenResponse Response of the tokenservice as axios response object.
+ * @returns Credentials object.
+ */
+
+var makeCredentialsFromTokenResponse = function makeCredentialsFromTokenResponse(tokenResponse) {
+  var token = tokenResponse.data.body || tokenResponse.data; // eslint-disable-next-line @typescript-eslint/naming-convention
+
+  var access_token = token.access_token,
+      refresh_token = token.refresh_token,
+      id_token = token.id_token,
+      expires_in = token.expires_in;
+
+  if (!access_token || !id_token) {
+    throw new Error('Login failed');
+  }
+
+  var userInfoString = atob(id_token.split('.')[1]);
+  var userInfo = JSON.parse(userInfoString);
+  var tokenExpirationInSeconds = expires_in && expires_in > 0 ? expires_in : DEFAULT_TOKEN_EXPIRES_IN; // If not set or zero in the token, assume valid for 1 hour.
+
+  var pctTokenExpirationInSeconds = tokenExpirationInSeconds * (REFRESH_TOKEN_WHEN_PCT_EXPIRED / 100);
+  var epochTimeTokenExpirationInSeconds = pctTokenExpirationInSeconds + Date.now() * MILLISECOND_TO_SECOND;
+  var isAuthCognito = userInfo.iss.includes('cognito');
+  var newAuth = {
+    username: isAuthCognito ? userInfo['cognito:username'] : userInfo.email,
+    token: access_token,
+    refresh_token: refresh_token || '',
+    expires_at: epochTimeTokenExpirationInSeconds
+  };
+  return newAuth;
+};
+var createApiInstance = function createApiInstance(_ref) {
+  var auth = _ref.auth,
+      onSetAuth = _ref.onSetAuth,
+      _ref$config = _ref.config;
+  _ref$config = _ref$config === void 0 ? {} : _ref$config;
+  var baseURL = _ref$config.baseURL,
+      appURL = _ref$config.appURL,
+      authTokenURL = _ref$config.authTokenURL,
+      authClientId = _ref$config.authClientId,
+      _ref$timeout = _ref.timeout,
+      timeout = _ref$timeout === void 0 ? DEFAULT_TIMEOUT : _ref$timeout;
+  var axiosInstance = axios.create({
+    baseURL: baseURL,
+    headers: {},
+    timeout: timeout
+  });
+
+  var refreshAccessToken = function refreshAccessToken() {
+    // Refresh token request with a new axios instance
+    // without request interceptor
+    var tokenAxiosInstance = axios.create({
+      headers: {},
+      timeout: timeout
+    });
+    var refreshPayload = {
+      refresh_token: auth.refresh_token,
+      redirect_uri: "".concat(appURL, "/code"),
+      grant_type: 'refresh_token',
+      client_id: authClientId
+    };
+    /* Send data in the "application/x-www-form-urlencoded" format.
+      If only JSON is supported, use Axios' default content type ("application/x-www-form-urlencoded"). */
+
+    var useDefaultContentType = authTokenURL.includes('amazonaws.com');
+    var data = useDefaultContentType ? refreshPayload : new URLSearchParams(refreshPayload);
+    var config = {
+      headers: {
+        'Content-Type': useDefaultContentType ? 'application/json' : 'application/x-www-form-urlencoded'
+      }
+    };
+    return tokenAxiosInstance.post(authTokenURL, data, config);
+  }; // Request interceptor for API calls done BEFORE the request is made.
+
+
+  axiosInstance.interceptors.request.use(function (config) {
+    return __awaiter(void 0, void 0, void 0, /*#__PURE__*/regeneratorRuntime.mark(function _callee() {
+      var timeInSecondsLeftBeforeExpiration, refreshedToken, newAuth, newConfig;
+      return regeneratorRuntime.wrap(function _callee$(_context) {
+        while (1) {
+          switch (_context.prev = _context.next) {
+            case 0:
+              timeInSecondsLeftBeforeExpiration = auth && auth.expires_at ? auth.expires_at - Date.now() * MILLISECOND_TO_SECOND : 0; // If expires_at is not set, don't do anything. (set timeInSecondsLeftBeforeExpiration = 0 will skip refresh)
+
+              if (!(timeInSecondsLeftBeforeExpiration < 0)) {
+                _context.next = 9;
+                break;
+              }
+
+              _context.next = 4;
+              return refreshAccessToken();
+
+            case 4:
+              refreshedToken = _context.sent;
+              newAuth = makeCredentialsFromTokenResponse(refreshedToken);
+              /*
+                 Note: Should not use the spread operator here on the auth object to create a new object.
+                 Creating a new object and setting that via onSetAuth might change the auth object too late.
+                 Instead assign the new token directly to the property and then use the onSetAuth.
+              */
+              // eslint-disable-next-line no-param-reassign
+
+              auth.token = newAuth.token; // eslint-disable-next-line no-param-reassign
+
+              auth.expires_at = newAuth.expires_at;
+              onSetAuth(auth);
+
+            case 9:
+              newConfig = Object.assign(Object.assign({}, config), {
+                headers: Object.assign({
+                  'Content-Type': 'application/json',
+                  Authorization: "Bearer ".concat(auth.token),
+                  Accept: 'application/json'
+                }, config.headers)
+              });
+              return _context.abrupt("return", newConfig);
+
+            case 11:
+            case "end":
+              return _context.stop();
+          }
+        }
+      }, _callee);
+    }));
+  }, function (error) {
+    Promise.reject(error);
+  }); // Response interceptor for API calls done AFTER the request is made.
+
+  axiosInstance.interceptors.response.use(function (response) {
+    return response;
+  }, function (error) {
+    return __awaiter(void 0, void 0, void 0, /*#__PURE__*/regeneratorRuntime.mark(function _callee2() {
+      var originalRequest, refreshedToken, newAuth;
+      return regeneratorRuntime.wrap(function _callee2$(_context2) {
+        while (1) {
+          switch (_context2.prev = _context2.next) {
+            case 0:
+              originalRequest = error.config;
+
+              if (!(error.response && error.response.status && (error.response.status === 401 || error.response.status === 403) && !originalRequest.inRetry)) {
+                _context2.next = 10;
+                break;
+              }
+
+              originalRequest.inRetry = true;
+              _context2.next = 5;
+              return refreshAccessToken();
+
+            case 5:
+              refreshedToken = _context2.sent;
+              newAuth = makeCredentialsFromTokenResponse(refreshedToken);
+              /*
+                 Note: Should not use the spread operator here on the auth object to create a new object.
+                 Creating a new object and setting that via onSetAuth might change the auth object too late.
+                 Instead assign the new token directly to the property and then use the onSetAuth.
+              */
+              // eslint-disable-next-line no-param-reassign
+
+              auth.token = newAuth.token;
+              onSetAuth(auth);
+              return _context2.abrupt("return", axiosInstance(originalRequest));
+
+            case 10:
+              return _context2.abrupt("return", Promise.reject(error));
+
+            case 11:
+            case "end":
+              return _context2.stop();
+          }
+        }
+      }, _callee2);
+    }));
+  });
+  return axiosInstance;
+};
+var createNonAuthApiInstance = function createNonAuthApiInstance(_ref2) {
+  var _ref2$config = _ref2.config;
+  _ref2$config = _ref2$config === void 0 ? {} : _ref2$config;
+  var baseURL = _ref2$config.baseURL,
+      _ref2$timeout = _ref2.timeout,
+      timeout = _ref2$timeout === void 0 ? DEFAULT_TIMEOUT : _ref2$timeout;
+  var axiosInstance = axios.create({
+    baseURL: baseURL,
+    headers: {},
+    timeout: timeout
+  }); // Request interceptor for API calls
+
+  axiosInstance.interceptors.request.use(function (config) {
+    return __awaiter(void 0, void 0, void 0, /*#__PURE__*/regeneratorRuntime.mark(function _callee3() {
+      var newConfig;
+      return regeneratorRuntime.wrap(function _callee3$(_context3) {
+        while (1) {
+          switch (_context3.prev = _context3.next) {
+            case 0:
+              newConfig = Object.assign(Object.assign({}, config), {
+                headers: Object.assign({
+                  'Content-Type': 'application/json',
+                  Accept: 'application/json'
+                }, config.headers)
+              });
+              return _context3.abrupt("return", newConfig);
+
+            case 2:
+            case "end":
+              return _context3.stop();
+          }
+        }
+      }, _callee3);
+    }));
+  }, function (error) {
+    Promise.reject(error);
+  });
+  return axiosInstance;
+};
+var fakeApiRequest = function fakeApiRequest(signal) {
+  return new Promise(function (resolve, reject) {
+    var timer = setTimeout(function () {
+      resolve();
+    }, 300);
+    signal === null || signal === void 0 ? void 0 : signal.signal.addEventListener('abort', function () {
+      clearTimeout(timer);
+      reject(new Error('canceled'));
+    });
+  });
+};
+var createFakeApiInstance = function createFakeApiInstance() {
+  return {
+    // eslint-disable-next-line no-unused-vars, @typescript-eslint/no-unused-vars,
+    get: function get(_url, _params) {
+      return fakeApiRequest();
+    },
+    // eslint-disable-next-line no-unused-vars, @typescript-eslint/no-unused-vars,
+    put: function put(_url, _params) {
+      return fakeApiRequest();
+    },
+    // eslint-disable-next-line no-unused-vars, @typescript-eslint/no-unused-vars,
+    post: function post(_url, _params) {
+      return fakeApiRequest();
+    },
+    // eslint-disable-next-line no-unused-vars, @typescript-eslint/no-unused-vars
+    "delete": function _delete(_url, _params) {
+      return fakeApiRequest();
+    },
+    // eslint-disable-next-line no-unused-vars, @typescript-eslint/no-unused-vars, @typescript-eslint/explicit-module-boundary-types
+    patch: function patch(_url, _params, _signal) {
+      return fakeApiRequest(_signal);
+    }
+  };
+};
+
+export { ApiProvider, MILLISECOND_TO_SECOND, REFRESH_TOKEN_WHEN_PCT_EXPIRED, createApiInstance, createFakeApiInstance, createNonAuthApiInstance, fakeApiRequest, getApi, makeCredentialsFromTokenResponse, useApi, useApiContext, useDebounce };