@esri/solutions-components 5.1.0-next.7 → 5.1.0-next.71

package/dist/chunks/get.js

@@ -0,0 +1,588 @@
+/* COPYRIGHT Esri - https://js.arcgis.com/5.1/LICENSE.txt */
+function getDefaultExportFromCjs(x) {
+  return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
+}
+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;
+}
+typeof SuppressedError === "function" ? SuppressedError : function(error, suppressed, message) {
+  var e = new Error(message);
+  return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+function requiresFormData(params) {
+  return Object.keys(params).some((key) => {
+    let value = params[key];
+    if (!value) {
+      return false;
+    }
+    if (value && value.toParam) {
+      value = value.toParam();
+    }
+    const type = value.constructor.name;
+    switch (type) {
+      case "Array":
+        return false;
+      case "Object":
+        return false;
+      case "Date":
+        return false;
+      case "Function":
+        return false;
+      case "Boolean":
+        return false;
+      case "String":
+        return false;
+      case "Number":
+        return false;
+      default:
+        return true;
+    }
+  });
+}
+function processParams(params) {
+  const newParams = {};
+  Object.keys(params).forEach((key) => {
+    var _a, _b;
+    let param = params[key];
+    if (param && param.toParam) {
+      param = param.toParam();
+    }
+    if (!param && param !== 0 && typeof param !== "boolean" && typeof param !== "string") {
+      return;
+    }
+    const type = param.constructor.name;
+    let value;
+    switch (type) {
+      case "Array":
+        const firstElementType = (_b = (_a = param[0]) === null || _a === void 0 ? void 0 : _a.constructor) === null || _b === void 0 ? void 0 : _b.name;
+        value = firstElementType === "Array" ? param : firstElementType === "Object" ? JSON.stringify(param) : param.join(",");
+        break;
+      case "Object":
+        value = JSON.stringify(param);
+        break;
+      case "Date":
+        value = param.valueOf();
+        break;
+      case "Function":
+        value = null;
+        break;
+      case "Boolean":
+        value = param + "";
+        break;
+      default:
+        value = param;
+        break;
+    }
+    if (value || value === 0 || typeof value === "string" || Array.isArray(value)) {
+      newParams[key] = value;
+    }
+  });
+  return newParams;
+}
+function encodeParam(key, value) {
+  if (Array.isArray(value) && value[0] && Array.isArray(value[0])) {
+    return value.map((arrayElem) => encodeParam(key, arrayElem)).join("&");
+  }
+  return encodeURIComponent(key) + "=" + encodeURIComponent(value);
+}
+function encodeQueryString(params) {
+  const newParams = processParams(params);
+  return Object.keys(newParams).map((key) => {
+    return encodeParam(key, newParams[key]);
+  }).join("&");
+}
+const FormData = globalThis.FormData;
+function encodeFormData(params, forceFormData) {
+  const useFormData = requiresFormData(params) || forceFormData;
+  const newParams = processParams(params);
+  if (useFormData) {
+    const formData = new FormData();
+    Object.keys(newParams).forEach((key) => {
+      if (typeof Blob !== "undefined" && newParams[key] instanceof Blob) {
+        const filename = newParams["fileName"] || newParams[key].name || key;
+        formData.append(key, newParams[key], filename);
+      } else {
+        formData.append(key, newParams[key]);
+      }
+    });
+    return formData;
+  } else {
+    return encodeQueryString(params);
+  }
+}
+class ArcGISRequestError extends Error {
+  /**
+   * Create a new `ArcGISRequestError`  object.
+   *
+   * @param message - The error message from the API
+   * @param code - The error code from the API
+   * @param response - The original response from the API that caused the error
+   * @param url - The original url of the request
+   * @param options - The original options and parameters of the request
+   */
+  constructor(message, code, response, url, options) {
+    super(message);
+    const actualProto = new.target.prototype;
+    Object.setPrototypeOf(this, actualProto);
+    message = message || "UNKNOWN_ERROR";
+    code = code || "UNKNOWN_ERROR_CODE";
+    this.name = "ArcGISRequestError";
+    this.message = code === "UNKNOWN_ERROR_CODE" ? message : `${code}: ${message}`;
+    this.originalMessage = message;
+    this.code = code;
+    this.response = response;
+    this.url = url;
+    this.options = options;
+  }
+}
+const DEFAULT_ARCGIS_REQUEST_CONFIG = {
+  noCorsDomains: [],
+  crossOriginNoCorsDomains: {},
+  pendingNoCorsRequests: {}
+};
+const GLOBAL_VARIABLE_NAME = "ARCGIS_REST_JS_NO_CORS";
+if (!globalThis[GLOBAL_VARIABLE_NAME]) {
+  globalThis[GLOBAL_VARIABLE_NAME] = Object.assign({}, DEFAULT_ARCGIS_REQUEST_CONFIG);
+}
+const requestConfig = globalThis[GLOBAL_VARIABLE_NAME];
+function sendNoCorsRequest(url) {
+  const urlObj = new URL(url);
+  url = urlObj.origin + urlObj.pathname;
+  if (urlObj.search.includes("f=json")) {
+    url += "?f=json";
+  }
+  const origin = urlObj.origin;
+  if (requestConfig.pendingNoCorsRequests[origin]) {
+    return requestConfig.pendingNoCorsRequests[origin];
+  }
+  requestConfig.pendingNoCorsRequests[origin] = fetch(url, {
+    mode: "no-cors",
+    credentials: "include",
+    cache: "no-store"
+  }).then((response) => {
+    if (requestConfig.noCorsDomains.indexOf(origin) === -1) {
+      requestConfig.noCorsDomains.push(origin);
+    }
+    requestConfig.crossOriginNoCorsDomains[origin.toLowerCase()] = Date.now();
+    delete requestConfig.pendingNoCorsRequests[origin];
+  }).catch((e) => {
+    delete requestConfig.pendingNoCorsRequests[origin];
+    return Promise.reject(new Error(`no-cors request to ${origin} failed`));
+  });
+  return requestConfig.pendingNoCorsRequests[origin];
+}
+function registerNoCorsDomains(authorizedCrossOriginNoCorsDomains) {
+  authorizedCrossOriginNoCorsDomains.forEach((domain) => {
+    domain = domain.toLowerCase();
+    if (/^https?:\/\//.test(domain)) {
+      addNoCorsDomain(domain);
+    } else {
+      addNoCorsDomain("http://" + domain);
+      addNoCorsDomain("https://" + domain);
+    }
+  });
+}
+function addNoCorsDomain(url) {
+  const uri = new URL(url);
+  const domain = uri.origin;
+  if (requestConfig.noCorsDomains.indexOf(domain) === -1) {
+    requestConfig.noCorsDomains.push(domain);
+  }
+}
+function isNoCorsDomain(url) {
+  let result = false;
+  if (requestConfig.noCorsDomains.length) {
+    const origin = new URL(url).origin.toLowerCase();
+    result = requestConfig.noCorsDomains.some((domain) => {
+      return origin.includes(domain);
+    });
+  }
+  return result;
+}
+function isNoCorsRequestRequired(url) {
+  let result = false;
+  if (isNoCorsDomain(url)) {
+    const origin = new URL(url).origin.toLowerCase();
+    const lastRequest = requestConfig.crossOriginNoCorsDomains[origin] || 0;
+    if (Date.now() - 60 * 6e4 > lastRequest) {
+      result = true;
+    }
+  }
+  return result;
+}
+function warn(message) {
+  if (console && console.warn) {
+    console.warn.apply(console, [message]);
+  }
+}
+function getFetch() {
+  return Promise.resolve({
+    fetch: globalThis.fetch,
+    Headers: globalThis.Headers,
+    Response: globalThis.Response,
+    Request: globalThis.Request
+  });
+}
+function isSameOrigin(url, win) {
+  var _a;
+  if (!win && !window || !url) {
+    return false;
+  } else {
+    win = win || window;
+    const origin = (_a = win.location) === null || _a === void 0 ? void 0 : _a.origin;
+    return url.startsWith(origin);
+  }
+}
+const NODEJS_DEFAULT_REFERER_HEADER = `@esri/arcgis-rest-js`;
+function getDefaultRequestOptions() {
+  return globalThis.DEFAULT_ARCGIS_REQUEST_OPTIONS || {
+    httpMethod: "POST",
+    params: {
+      f: "json"
+    }
+  };
+}
+class ArcGISAuthError extends ArcGISRequestError {
+  /**
+   * Create a new `ArcGISAuthError`  object.
+   *
+   * @param message - The error message from the API
+   * @param code - The error code from the API
+   * @param response - The original response from the API that caused the error
+   * @param url - The original url of the request
+   * @param options - The original options of the request
+   */
+  constructor(message = "AUTHENTICATION_ERROR", code = "AUTHENTICATION_ERROR_CODE", response, url, options) {
+    super(message, code, response, url, options);
+    this.name = "ArcGISAuthError";
+    this.message = code === "AUTHENTICATION_ERROR_CODE" ? message : `${code}: ${message}`;
+    const actualProto = new.target.prototype;
+    Object.setPrototypeOf(this, actualProto);
+  }
+  retry(getSession, retryLimit = 1) {
+    let tries = 0;
+    const retryRequest = (resolve, reject) => {
+      tries = tries + 1;
+      getSession(this.url, this.options).then((session) => {
+        const newOptions = Object.assign(Object.assign({}, this.options), { authentication: session });
+        return internalRequest(this.url, newOptions);
+      }).then((response) => {
+        resolve(response);
+      }).catch((e) => {
+        if (e.name === "ArcGISAuthError" && tries < retryLimit) {
+          retryRequest(resolve, reject);
+        } else if (e.name === this.name && e.message === this.message && tries >= retryLimit) {
+          reject(this);
+        } else {
+          reject(e);
+        }
+      });
+    };
+    return new Promise((resolve, reject) => {
+      retryRequest(resolve, reject);
+    });
+  }
+}
+function checkForErrors(response, url, params, options, originalAuthError) {
+  if (response.code >= 400) {
+    const { message, code } = response;
+    throw new ArcGISRequestError(message, code, response, url, options);
+  }
+  if (response.error) {
+    const { message, code, messageCode } = response.error;
+    const errorCode = messageCode || code || "UNKNOWN_ERROR_CODE";
+    if (code === 498 || code === 499) {
+      if (originalAuthError) {
+        throw originalAuthError;
+      } else {
+        throw new ArcGISAuthError(message, errorCode, response, url, options);
+      }
+    }
+    throw new ArcGISRequestError(message, errorCode, response, url, options);
+  }
+  if (response.status === "failed" || response.status === "failure") {
+    let message;
+    let code = "UNKNOWN_ERROR_CODE";
+    try {
+      message = JSON.parse(response.statusMessage).message;
+      code = JSON.parse(response.statusMessage).code;
+    } catch (e) {
+      message = response.statusMessage || response.message;
+    }
+    throw new ArcGISRequestError(message, code, response, url, options);
+  }
+  return response;
+}
+function internalRequest(url, requestOptions) {
+  const defaults = getDefaultRequestOptions();
+  const options = Object.assign(Object.assign(Object.assign({ httpMethod: "POST" }, defaults), requestOptions), {
+    params: Object.assign(Object.assign({}, defaults.params), requestOptions.params),
+    headers: Object.assign(Object.assign({}, defaults.headers), requestOptions.headers)
+  });
+  const { httpMethod, rawResponse } = options;
+  const params = Object.assign({ f: "json" }, options.params);
+  let originalAuthError = null;
+  const fetchOptions = {
+    method: httpMethod,
+    signal: options.signal,
+    /* ensures behavior mimics XMLHttpRequest.
+    needed to support sending IWA cookies */
+    credentials: options.credentials || "same-origin"
+  };
+  if (isNoCorsDomain(url)) {
+    fetchOptions.credentials = "include";
+  }
+  if (options.headers && options.headers["X-Esri-Auth-Client-Id"] && url.indexOf("/oauth2/platformSelf") > -1) {
+    fetchOptions.credentials = "include";
+  }
+  let authentication;
+  if (typeof options.authentication === "string") {
+    const rawToken = options.authentication;
+    authentication = {
+      portal: "https://www.arcgis.com/sharing/rest",
+      getToken: () => {
+        return Promise.resolve(rawToken);
+      }
+    };
+    if (!options.authentication.startsWith("AAPK") && !options.authentication.startsWith("AAPT") && !options.authentication.startsWith("AATK") && // doesn't look like an API Key
+    !options.authentication.startsWith("AAST") && // doesn't look like a session token
+    !options.suppressWarnings && // user doesn't want to suppress warnings for this request
+    !globalThis.ARCGIS_REST_JS_SUPPRESS_TOKEN_WARNING) {
+      warn(`Using an oAuth 2.0 access token directly in the token option is discouraged. Consider using ArcGISIdentityManager or Application session. See https://esriurl.com/arcgis-rest-js-direct-token-warning for more information.`);
+      globalThis.ARCGIS_REST_JS_SUPPRESS_TOKEN_WARNING = true;
+    }
+  } else {
+    authentication = options.authentication;
+  }
+  const originalUrl = url;
+  let sameOrigin = false;
+  if (typeof window !== "undefined") {
+    sameOrigin = isSameOrigin(url);
+  }
+  const requiresNoCors = !sameOrigin && isNoCorsRequestRequired(url);
+  if (options.headers && options.headers["X-Esri-Auth-Client-Id"] && url.indexOf("/oauth2/platformSelf") > -1) {
+    fetchOptions.credentials = "include";
+  }
+  let firstPromise = Promise.resolve();
+  if (requiresNoCors) {
+    fetchOptions.credentials = "include";
+    firstPromise = sendNoCorsRequest(url);
+  }
+  return firstPromise.then(() => authentication ? authentication.getToken(url).catch((err) => {
+    err.url = url;
+    err.options = options;
+    originalAuthError = err;
+    return Promise.resolve("");
+  }) : Promise.resolve("")).then((token) => {
+    if (token.length) {
+      params.token = token;
+    }
+    if (authentication && authentication.getDomainCredentials) {
+      fetchOptions.credentials = authentication.getDomainCredentials(url);
+    }
+    const requestHeaders = {};
+    if (fetchOptions.method === "GET") {
+      if (params.token && options.hideToken && // Sharing API does not support preflight check required by modern browsers https://developer.mozilla.org/en-US/docs/Glossary/Preflight_request
+      typeof window === "undefined") {
+        requestHeaders["X-Esri-Authorization"] = `Bearer ${params.token}`;
+        delete params.token;
+      }
+      const queryParams = encodeQueryString(params);
+      const urlWithQueryString = queryParams === "" ? (
+        /* istanbul ignore next -- @preserve */
+        url
+      ) : `${url}?${queryParams}`;
+      if (
+        // This would exceed the maximum length for URLs by 2000 as default or as specified by the consumer and requires POST
+        options.maxUrlLength && urlWithQueryString.length > options.maxUrlLength || !options.maxUrlLength && urlWithQueryString.length > 2e3 || // Or if the customer requires the token to be hidden and it has not already been hidden in the header (for browsers)
+        params.token && options.hideToken
+      ) {
+        fetchOptions.method = "POST";
+        if (token.length && options.hideToken) {
+          params.token = token;
+          delete requestHeaders["X-Esri-Authorization"];
+        }
+      } else {
+        url = urlWithQueryString;
+      }
+    }
+    const forceFormData = new RegExp("/items/.+/updateResources").test(url);
+    if (fetchOptions.method === "POST") {
+      fetchOptions.body = encodeFormData(params, forceFormData);
+    }
+    fetchOptions.headers = Object.assign(Object.assign({}, requestHeaders), options.headers);
+    if ((typeof window === "undefined" || window && typeof window.document === "undefined") && !fetchOptions.headers.referer) {
+      fetchOptions.headers.referer = NODEJS_DEFAULT_REFERER_HEADER;
+    }
+    if (!requiresFormData(params) && !forceFormData) {
+      fetchOptions.headers["Content-Type"] = "application/x-www-form-urlencoded";
+    }
+    return globalThis.fetch ? globalThis.fetch(url, fetchOptions) : getFetch().then(({ fetch: fetch2 }) => {
+      return fetch2(url, fetchOptions);
+    });
+  }).then((response) => {
+    if (!response.ok) {
+      return response.json().then((jsonError) => {
+        const { status, statusText } = response;
+        const { message, details } = jsonError.error;
+        const formattedMessage = `${message}. ${details ? details.join(" ") : ""}`.trim();
+        throw new ArcGISRequestError(formattedMessage, `HTTP ${status} ${statusText}`, jsonError, url, options);
+      }).catch((e) => {
+        if (e.name === "ArcGISRequestError") {
+          throw e;
+        }
+        const { status, statusText } = response;
+        throw new ArcGISRequestError(statusText, `HTTP ${status}`, response, url, options);
+      });
+    }
+    if (rawResponse) {
+      console.warn(`rawResponse option is deprecated and will be removed in ArcGIS REST JS v5.0.`);
+      return response;
+    }
+    switch (params.f) {
+      case "json":
+        return response.json();
+      case "geojson":
+        return response.json();
+      case "html":
+        return response.text();
+      case "text":
+        return response.text();
+      /* istanbul ignore next blob responses are difficult to make cross platform we will just have to trust that isomorphic fetch will do its job */
+      default:
+        return response.blob();
+    }
+  }).then((data) => {
+    if ((params.f === "json" || params.f === "geojson") && !rawResponse) {
+      const response = checkForErrors(data, originalUrl, params, options, originalAuthError);
+      if (data && /\/sharing\/rest\/(accounts|portals)\/self/i.test(url)) {
+        if (Array.isArray(data.authorizedCrossOriginNoCorsDomains)) {
+          registerNoCorsDomains(data.authorizedCrossOriginNoCorsDomains);
+        }
+      }
+      if (originalAuthError) {
+        const truncatedUrl = url.toLowerCase().split(/\/rest(\/admin)?\/services\//)[0];
+        options.authentication.federatedServers[truncatedUrl] = {
+          token: [],
+          // default to 24 hours
+          expires: new Date(Date.now() + 86400 * 1e3)
+        };
+        originalAuthError = null;
+      }
+      return response;
+    } else {
+      return data;
+    }
+  });
+}
+function request(url, requestOptions = { params: { f: "json" } }) {
+  const { request: request2 } = requestOptions, internalOptions = __rest(requestOptions, ["request"]);
+  return request2 ? request2(url, internalOptions) : internalRequest(url, internalOptions).catch((e) => {
+    if (e instanceof ArcGISAuthError && requestOptions.authentication && typeof requestOptions.authentication !== "string" && requestOptions.authentication.canRefresh && requestOptions.authentication.refreshCredentials) {
+      return e.retry(() => {
+        return requestOptions.authentication.refreshCredentials();
+      }, 1);
+    } else {
+      return Promise.reject(e);
+    }
+  });
+}
+function cleanUrl(url) {
+  if (typeof url !== "string") {
+    return url;
+  }
+  url = url.trim();
+  if (url[url.length - 1] === "/") {
+    url = url.slice(0, -1);
+  }
+  return url;
+}
+function getPortalUrl(requestOptions = {}) {
+  if (requestOptions.portal) {
+    return cleanUrl(requestOptions.portal);
+  }
+  if (requestOptions.authentication && typeof requestOptions.authentication !== "string") {
+    return requestOptions.authentication.portal;
+  }
+  return "https://www.arcgis.com/sharing/rest";
+}
+function determineOwner(requestOptions) {
+  if (requestOptions.owner) {
+    return Promise.resolve(requestOptions.owner);
+  } else if (requestOptions.item && requestOptions.item.owner) {
+    return Promise.resolve(requestOptions.item.owner);
+  } else if (requestOptions.authentication && requestOptions.authentication.getUsername) {
+    return requestOptions.authentication.getUsername();
+  } else {
+    return Promise.reject(new Error("Could not determine the owner of this item. Pass the `owner`, `item.owner`, or `authentication` option."));
+  }
+}
+function isBBox(extent) {
+  return Array.isArray(extent) && Array.isArray(extent[0]) && Array.isArray(extent[1]);
+}
+function bboxToString(extent) {
+  return extent.join(",");
+}
+function decorateThumbnail(item, portal, token) {
+  if (!item)
+    return item;
+  let thumbnailUrl = null;
+  if (typeof item.thumbnail === "string") {
+    thumbnailUrl = `${portal}/content/items/${item.id}/info/${item.thumbnail}`;
+    if (thumbnailUrl && item.access !== "public" && token) {
+      thumbnailUrl += `?${token}`;
+    }
+  }
+  return Object.assign(Object.assign({}, item), thumbnailUrl ? { thumbnailUrl } : {});
+}
+function getItem(id, requestOptions) {
+  const url = getItemBaseUrl(id, requestOptions);
+  const options = Object.assign({ httpMethod: "GET" }, requestOptions);
+  return request(url, options).then(async (item) => {
+    const portal = (requestOptions === null || requestOptions === void 0 ? void 0 : requestOptions.portal) || getPortalUrl(requestOptions);
+    let token;
+    if ((requestOptions === null || requestOptions === void 0 ? void 0 : requestOptions.authentication) && typeof requestOptions.authentication !== "string" && item.access !== "public") {
+      token = await requestOptions.authentication.getToken(url);
+    }
+    return decorateThumbnail(item, portal, token);
+  });
+}
+const getItemBaseUrl = (id, portalUrlOrRequestOptions) => {
+  const portalUrl = typeof portalUrlOrRequestOptions === "string" ? portalUrlOrRequestOptions : getPortalUrl(portalUrlOrRequestOptions);
+  return `${portalUrl}/content/items/${id}`;
+};
+function getItemData(id, requestOptions) {
+  const url = `${getItemBaseUrl(id, requestOptions)}/data`;
+  const options = Object.assign({ httpMethod: "GET", params: {} }, requestOptions);
+  if (options.file) {
+    options.params.f = null;
+  }
+  return request(url, options).catch((err) => {
+    const emptyResponseErr = RegExp(/The string did not match the expected pattern|(Unexpected end of (JSON input|data at line 1 column 1))/i);
+    if (emptyResponseErr.test(err.message)) {
+      return;
+    } else
+      throw err;
+  });
+}
+export {
+  __rest as _,
+  decorateThumbnail as a,
+  bboxToString as b,
+  getDefaultExportFromCjs as c,
+  determineOwner as d,
+  getItem as e,
+  getItemData as f,
+  getPortalUrl as g,
+  isBBox as i,
+  request as r,
+  warn as w
+};