@kepler.gl/components 3.3.0-alpha.1 → 3.3.0-alpha.10

package/dist/esm/modals/tilesets-modals/tileset-raster-form.js

@@ -0,0 +1,279 @@
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import _taggedTemplateLiteral from "@babel/runtime/helpers/esm/taggedTemplateLiteral";
+var _templateObject, _templateObject2, _templateObject3, _templateObject4, _templateObject5, _templateObject6, _templateObject7, _templateObject8;
+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; }
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+import React, { useCallback, useEffect, useState } from 'react';
+import styled from 'styled-components';
+import { isPMTilesUrl, validateUrl } from '@kepler.gl/common-utils';
+import { DatasetType, RasterTileType, PMTilesType } from '@kepler.gl/constants';
+import { parseRasterMetadata, parseVectorMetadata } from '@kepler.gl/table';
+import { getApplicationConfig } from '@kepler.gl/utils';
+import { default as useFetchJson } from '../../hooks/use-fetch-raster-tile-metadata';
+import { InputLight } from '../../common';
+import { Help } from '../../common/icons';
+var TilesetInputContainer = styled.div(_templateObject || (_templateObject = _taggedTemplateLiteral(["\n  display: grid;\n  grid-template-rows: repeat(3, 1fr);\n  row-gap: 0px;\n  font-size: 12px;\n"])));
+var TilesetInputDescription = styled.div(_templateObject2 || (_templateObject2 = _taggedTemplateLiteral(["\n  text-align: center;\n  color: ", ";\n  font-size: 11px;\n"])), function (props) {
+  return props.theme.AZURE200;
+});
+var ExampleUrlsContainer = styled.div(_templateObject3 || (_templateObject3 = _taggedTemplateLiteral(["\n  text-align: left;\n  color: ", ";\n  font-size: 11px;\n"])), function (props) {
+  return props.theme.AZURE200;
+});
+var ExampleTabs = styled.div(_templateObject4 || (_templateObject4 = _taggedTemplateLiteral(["\n  display: flex;\n  gap: 6px;\n  margin-top: 6px;\n  margin-bottom: 6px;\n  flex-wrap: wrap;\n"])));
+var ExampleTab = styled.div(_templateObject5 || (_templateObject5 = _taggedTemplateLiteral(["\n  padding: 3px 8px;\n  border-radius: 3px;\n  cursor: pointer;\n  font-size: 11px;\n  white-space: nowrap;\n  background: ", ";\n  color: ", ";\n  border: 1px solid ", ";\n\n  &:hover {\n    background: ", ";\n  }\n"])), function (props) {
+  return props.active ? props.theme.AZURE400 : 'transparent';
+}, function (props) {
+  return props.active ? props.theme.WHITE : props.theme.AZURE200;
+}, function (props) {
+  return props.theme.AZURE400;
+}, function (props) {
+  return props.active ? props.theme.AZURE400 : props.theme.AZURE500;
+});
+var ExampleUrl = styled.div(_templateObject6 || (_templateObject6 = _taggedTemplateLiteral(["\n  word-break: break-all;\n  cursor: pointer;\n  color: ", ";\n  font-size: 11px;\n\n  &:hover {\n    color: ", ";\n  }\n"])), function (props) {
+  return props.theme.AZURE200;
+}, function (props) {
+  return props.theme.AZURE100;
+});
+var LabelRow = styled.div(_templateObject7 || (_templateObject7 = _taggedTemplateLiteral(["\n  display: flex;\n  align-items: center;\n"])));
+export function getDatasetAttributesFromRasterTile(_ref) {
+  var name = _ref.name,
+    metadataUrl = _ref.metadataUrl,
+    rasterTileServerUrls = _ref.rasterTileServerUrls;
+  var appConfig = getApplicationConfig();
+  return {
+    name: name,
+    type: DatasetType.RASTER_TILE,
+    metadata: _objectSpread(_objectSpread({
+      metadataUrl: metadataUrl
+    }, rasterTileServerUrls ? {
+      rasterTileServerUrls: rasterTileServerUrls
+    } : {}), {}, {
+      // Persist raster server-related application config with the layer
+      rasterServerUseLatestTitiler: appConfig.rasterServerUseLatestTitiler,
+      rasterServerSupportsElevation: appConfig.rasterServerSupportsElevation,
+      rasterServerMaxRetries: appConfig.rasterServerMaxRetries,
+      rasterServerRetryDelay: appConfig.rasterServerRetryDelay,
+      rasterServerServerErrorsToRetry: appConfig.rasterServerServerErrorsToRetry,
+      rasterServerMaxPerServerRequests: appConfig.rasterServerMaxPerServerRequests
+    })
+  };
+}
+var InfoIconLink = styled.a(_templateObject8 || (_templateObject8 = _taggedTemplateLiteral(["\n  margin-left: 4px;\n  color: ", ";\n  text-decoration: none;\n  display: inline-flex;\n  align-items: center;\n  line-height: 0;\n  vertical-align: middle;\n  opacity: 0.7;\n\n  &:hover {\n    opacity: 1;\n  }\n\n  svg {\n    display: block;\n  }\n"])), function (props) {
+  return props.theme.labelColor;
+});
+var RASTER_TILE_DOCUMENTATION_URL = 'https://docs.kepler.gl/docs/user-guides/c-types-of-layers/n-raster-tile-layer';
+var TITILER_BASE_URL = 'https://titiler.xyz';
+function isCOGUrl(url) {
+  if (!url) return false;
+  try {
+    var pathname = new URL(url).pathname.toLowerCase().replace(/\/+$/, '');
+    return pathname.endsWith('.tif') || pathname.endsWith('.tiff');
+  } catch (_unused) {
+    var cleaned = url.trim().toLowerCase().split(/[?#]/)[0].replace(/\/+$/, '');
+    return cleaned.endsWith('.tif') || cleaned.endsWith('.tiff');
+  }
+}
+function getCOGMetadataUrl(cogUrl) {
+  return "".concat(TITILER_BASE_URL, "/cog/stac?url=").concat(encodeURIComponent(cogUrl));
+}
+var RASTER_TILE_EXAMPLES = [{
+  label: 'COG',
+  name: 'Africa Farms',
+  url: 'https://sentinel-cogs.s3.us-west-2.amazonaws.com/sentinel-s2-l2a-cogs/36/Q/WD/2020/7/S2A_36QWD_20200701_0_L2A/TCI.tif'
+}, {
+  label: 'PMTiles',
+  name: 'Swiss Historical',
+  url: 'https://public-bucket-for-tests.s3.us-east-1.amazonaws.com/historic-swis-18xx.pmtiles'
+}, {
+  label: 'STAC Collection',
+  name: 'Sentinel-2 L1C',
+  url: 'https://earth-search.aws.element84.com/v1/collections/sentinel-2-l1c'
+}];
+var parseMetadataAllowCollections = function parseMetadataAllowCollections(metadata, _ref2) {
+  var metadataUrl = _ref2.metadataUrl,
+    rasterTileType = _ref2.rasterTileType;
+  return rasterTileType === RasterTileType.PMTILES ? parseVectorMetadata(metadata, {
+    tileUrl: metadataUrl
+  }) : parseRasterMetadata(metadata, {
+    allowCollections: true
+  });
+};
+var RasterTileForm = function RasterTileForm(_ref3) {
+  var setResponse = _ref3.setResponse;
+  var _useState = useState(''),
+    _useState2 = _slicedToArray(_useState, 2),
+    tileName = _useState2[0],
+    setTileName = _useState2[1];
+  var _useState3 = useState(false),
+    _useState4 = _slicedToArray(_useState3, 2),
+    tileNameWasModified = _useState4[0],
+    setTileNameWasModified = _useState4[1];
+  var _useState5 = useState(''),
+    _useState6 = _slicedToArray(_useState5, 2),
+    metadataUrl = _useState6[0],
+    setMetadataUrl = _useState6[1];
+  var _useState7 = useState((getApplicationConfig().rasterServerUrls || []).join(',')),
+    _useState8 = _slicedToArray(_useState7, 2),
+    rasterTileServerUrls = _useState8[0],
+    setRasterTileServerUrls = _useState8[1];
+  var _useState9 = useState(0),
+    _useState0 = _slicedToArray(_useState9, 2),
+    exampleTab = _useState0[0],
+    setExampleTab = _useState0[1];
+
+  // Remove trailing slash to prevent issues with raster tile servers
+  var clearedMetadataUrl = metadataUrl.endsWith('/') ? metadataUrl.slice(0, -1) : metadataUrl;
+  var isCOG = isCOGUrl(clearedMetadataUrl);
+  var effectiveMetadataUrl = isCOG ? getCOGMetadataUrl(clearedMetadataUrl) : clearedMetadataUrl;
+  var effectiveRasterTileServerUrls = isCOG ? TITILER_BASE_URL : rasterTileServerUrls;
+  var defaultServerUrls = (getApplicationConfig().rasterServerUrls || []).join(',');
+  var onExampleClick = useCallback(function (url, name) {
+    setMetadataUrl(url);
+    setTileName(name);
+    setTileNameWasModified(false);
+    if (isCOGUrl(url)) {
+      setRasterTileServerUrls(TITILER_BASE_URL);
+    } else {
+      setRasterTileServerUrls(defaultServerUrls);
+    }
+  }, [defaultServerUrls]);
+  var onTileNameChange = useCallback(function (event) {
+    event.preventDefault();
+    setTileNameWasModified(true);
+    setTileName(event.target.value);
+  }, [setTileName]);
+  var onMetadataUrlChange = useCallback(function (event) {
+    event.preventDefault();
+    var value = event.target.value;
+    setMetadataUrl(value);
+    if (isCOGUrl(value) && !rasterTileServerUrls.trim()) {
+      setRasterTileServerUrls(TITILER_BASE_URL);
+    }
+    if (!tileNameWasModified) {
+      setTileName(value.split('/').filter(Boolean).pop() || '');
+    }
+  }, [tileNameWasModified, rasterTileServerUrls]);
+  var onRasterTileServerUrlsChange = useCallback(function (event) {
+    event.preventDefault();
+    setRasterTileServerUrls(event.target.value);
+  }, [setRasterTileServerUrls]);
+  var _useFetchJson = useFetchJson({
+      url: effectiveMetadataUrl,
+      rasterTileType: isPMTilesUrl(clearedMetadataUrl) ? RasterTileType.PMTILES : RasterTileType.STAC,
+      process: parseMetadataAllowCollections
+    }),
+    metadata = _useFetchJson.data,
+    loading = _useFetchJson.loading,
+    metaError = _useFetchJson.error;
+  useEffect(function () {
+    if (tileName && clearedMetadataUrl) {
+      var pmtilesType = metadata === null || metadata === void 0 ? void 0 : metadata.pmtilesType;
+      if (pmtilesType === PMTilesType.MVT) {
+        return setResponse({
+          metadata: metadata,
+          dataset: null,
+          loading: loading,
+          error: new Error('For .pmtiles in mvt format, please use the Vector Tile form.')
+        });
+      }
+      var error = metaError;
+
+      // check for raster tile servers for STAC items and collections
+      var rasterTileServers;
+      if (!error
+      // We still need raster tile servers for PMTiles when we plan to use elevation
+      ) {
+        rasterTileServers = effectiveRasterTileServerUrls.split(',').map(function (server) {
+          return server.trim();
+        }).filter(function (server) {
+          return server;
+        });
+        if (rasterTileServers.length < 1 || !rasterTileServers.every(function (server) {
+          return validateUrl(server);
+        })) {
+          if (pmtilesType) {
+            // For raster tiles elevation support is optional
+            // TODO display a warning, but not a blocking error
+            rasterTileServers = [];
+          } else {
+            error = new Error('Provide valid raster tile server urls to support STAC and elevations.');
+          }
+        }
+      }
+      var dataset = getDatasetAttributesFromRasterTile({
+        name: tileName,
+        metadataUrl: effectiveMetadataUrl,
+        rasterTileServerUrls: rasterTileServers
+      });
+      setResponse({
+        metadata: metadata,
+        dataset: dataset,
+        loading: loading,
+        error: error
+      });
+    } else {
+      setResponse({
+        metadata: metadata,
+        dataset: null,
+        loading: loading,
+        error: metaError
+      });
+    }
+  }, [metadata, loading, metaError, tileName, clearedMetadataUrl, effectiveMetadataUrl, effectiveRasterTileServerUrls, setResponse]);
+  var showServerInput = getApplicationConfig().rasterServerShowServerInput;
+  return /*#__PURE__*/React.createElement(TilesetInputContainer, null, /*#__PURE__*/React.createElement("div", null, /*#__PURE__*/React.createElement("label", {
+    htmlFor: "tileset-name"
+  }, "Name"), /*#__PURE__*/React.createElement(InputLight, {
+    id: "tileset-name",
+    placeholder: "Name your tileset",
+    value: tileName,
+    onChange: onTileNameChange
+  })), /*#__PURE__*/React.createElement("div", null, /*#__PURE__*/React.createElement(LabelRow, null, /*#__PURE__*/React.createElement("label", {
+    htmlFor: "tile-metadata"
+  }, "Tileset metadata URL"), /*#__PURE__*/React.createElement(InfoIconLink, {
+    href: RASTER_TILE_DOCUMENTATION_URL,
+    target: "_blank",
+    rel: "noopener noreferrer",
+    "aria-label": "Open Raster Tile Layer documentation"
+  }, /*#__PURE__*/React.createElement(Help, {
+    height: "16px"
+  }))), /*#__PURE__*/React.createElement(InputLight, {
+    id: "tile-metadata",
+    placeholder: "Tileset metadata URL",
+    value: metadataUrl !== null && metadataUrl !== void 0 ? metadataUrl : undefined,
+    onChange: onMetadataUrlChange
+  }), /*#__PURE__*/React.createElement(TilesetInputDescription, null, "Supports raster .pmtiles, COG (.tif) URLs, STAC Items and Collections.")), showServerInput && /*#__PURE__*/React.createElement("div", null, /*#__PURE__*/React.createElement(LabelRow, null, /*#__PURE__*/React.createElement("label", {
+    htmlFor: "tileset-raster-servers"
+  }, "Raster tile servers"), /*#__PURE__*/React.createElement(InfoIconLink, {
+    href: RASTER_TILE_DOCUMENTATION_URL,
+    target: "_blank",
+    rel: "noopener noreferrer",
+    "aria-label": "Open Raster Tile Layer documentation"
+  }, /*#__PURE__*/React.createElement(Help, {
+    height: "16px"
+  }))), /*#__PURE__*/React.createElement(InputLight, {
+    id: "tileset-raster-servers",
+    placeholder: "Raster tile servers (separated by commas)",
+    value: rasterTileServerUrls,
+    onChange: onRasterTileServerUrlsChange
+  }), /*#__PURE__*/React.createElement(TilesetInputDescription, null, "Raster tile server URLs for Cloud Optimized GeoTIFF tilesets and elevation.")), getApplicationConfig().showInlineTilesetExamples && /*#__PURE__*/React.createElement("div", null, /*#__PURE__*/React.createElement(TilesetInputDescription, null, "For example, try a public raster tileset:"), /*#__PURE__*/React.createElement(ExampleUrlsContainer, null, /*#__PURE__*/React.createElement(ExampleTabs, null, RASTER_TILE_EXAMPLES.map(function (ex, i) {
+    return /*#__PURE__*/React.createElement(ExampleTab, {
+      key: "".concat(ex.label, "-").concat(ex.name),
+      active: exampleTab === i,
+      onClick: function onClick() {
+        setExampleTab(i);
+        onExampleClick(ex.url, ex.name);
+      }
+    }, ex.name);
+  })), /*#__PURE__*/React.createElement(ExampleUrl, {
+    onClick: function onClick() {
+      return onExampleClick(RASTER_TILE_EXAMPLES[exampleTab].url, RASTER_TILE_EXAMPLES[exampleTab].name);
+    }
+  }, RASTER_TILE_EXAMPLES[exampleTab].url))));
+};
+export default RasterTileForm;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","useCallback","useEffect","useState","styled","isPMTilesUrl","validateUrl","DatasetType","RasterTileType","PMTilesType","parseRasterMetadata","parseVectorMetadata","getApplicationConfig","default","useFetchJson","InputLight","Help","TilesetInputContainer","div","_templateObject","_taggedTemplateLiteral","TilesetInputDescription","_templateObject2","props","theme","AZURE200","ExampleUrlsContainer","_templateObject3","ExampleTabs","_templateObject4","ExampleTab","_templateObject5","active","AZURE400","WHITE","AZURE500","ExampleUrl","_templateObject6","AZURE100","LabelRow","_templateObject7","getDatasetAttributesFromRasterTile","_ref","name","metadataUrl","rasterTileServerUrls","appConfig","type","RASTER_TILE","metadata","_objectSpread","rasterServerUseLatestTitiler","rasterServerSupportsElevation","rasterServerMaxRetries","rasterServerRetryDelay","rasterServerServerErrorsToRetry","rasterServerMaxPerServerRequests","InfoIconLink","a","_templateObject8","labelColor","RASTER_TILE_DOCUMENTATION_URL","TITILER_BASE_URL","isCOGUrl","url","pathname","URL","toLowerCase","replace","endsWith","_unused","cleaned","trim","split","getCOGMetadataUrl","cogUrl","concat","encodeURIComponent","RASTER_TILE_EXAMPLES","label","parseMetadataAllowCollections","_ref2","rasterTileType","PMTILES","tileUrl","allowCollections","RasterTileForm","_ref3","setResponse","_useState","_useState2","_slicedToArray","tileName","setTileName","_useState3","_useState4","tileNameWasModified","setTileNameWasModified","_useState5","_useState6","setMetadataUrl","_useState7","rasterServerUrls","join","_useState8","setRasterTileServerUrls","_useState9","_useState0","exampleTab","setExampleTab","clearedMetadataUrl","slice","isCOG","effectiveMetadataUrl","effectiveRasterTileServerUrls","defaultServerUrls","onExampleClick","onTileNameChange","event","preventDefault","target","value","onMetadataUrlChange","filter","Boolean","pop","onRasterTileServerUrlsChange","_useFetchJson","STAC","process","data","loading","metaError","error","pmtilesType","MVT","dataset","Error","rasterTileServers","map","server","length","every","showServerInput","rasterServerShowServerInput","createElement","htmlFor","id","placeholder","onChange","href","rel","height","undefined","showInlineTilesetExamples","ex","i","key","onClick"],"sources":["../../../../src/modals/tilesets-modals/tileset-raster-form.tsx"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\nimport React, {useCallback, useEffect, useState} from 'react';\nimport styled from 'styled-components';\n\nimport {PMTilesMetadata} from '@loaders.gl/pmtiles';\n\nimport {isPMTilesUrl, validateUrl} from '@kepler.gl/common-utils';\nimport {DatasetType, RasterTileType, PMTilesType} from '@kepler.gl/constants';\nimport {JsonObjectOrArray} from '@kepler.gl/types';\nimport {parseRasterMetadata, parseVectorMetadata} from '@kepler.gl/table';\nimport {getApplicationConfig} from '@kepler.gl/utils';\n\nimport {default as useFetchJson} from '../../hooks/use-fetch-raster-tile-metadata';\nimport {DatasetCreationAttributes, MetaResponse} from './common';\nimport {InputLight} from '../../common';\nimport {Help} from '../../common/icons';\n\nconst TilesetInputContainer = styled.div`\n  display: grid;\n  grid-template-rows: repeat(3, 1fr);\n  row-gap: 0px;\n  font-size: 12px;\n`;\n\nconst TilesetInputDescription = styled.div`\n  text-align: center;\n  color: ${props => props.theme.AZURE200};\n  font-size: 11px;\n`;\n\nconst ExampleUrlsContainer = styled.div`\n  text-align: left;\n  color: ${props => props.theme.AZURE200};\n  font-size: 11px;\n`;\n\nconst ExampleTabs = styled.div`\n  display: flex;\n  gap: 6px;\n  margin-top: 6px;\n  margin-bottom: 6px;\n  flex-wrap: wrap;\n`;\n\nconst ExampleTab = styled.div<{active: boolean}>`\n  padding: 3px 8px;\n  border-radius: 3px;\n  cursor: pointer;\n  font-size: 11px;\n  white-space: nowrap;\n  background: ${props => (props.active ? props.theme.AZURE400 : 'transparent')};\n  color: ${props => (props.active ? props.theme.WHITE : props.theme.AZURE200)};\n  border: 1px solid ${props => props.theme.AZURE400};\n\n  &:hover {\n    background: ${props => (props.active ? props.theme.AZURE400 : props.theme.AZURE500)};\n  }\n`;\n\nconst ExampleUrl = styled.div`\n  word-break: break-all;\n  cursor: pointer;\n  color: ${props => props.theme.AZURE200};\n  font-size: 11px;\n\n  &:hover {\n    color: ${props => props.theme.AZURE100};\n  }\n`;\n\nconst LabelRow = styled.div`\n  display: flex;\n  align-items: center;\n`;\n\nexport type RasterTilesetMeta = {\n  name: string;\n  metadataUrl: string;\n  rasterTileServerUrls?: string[];\n};\n\nexport function getDatasetAttributesFromRasterTile({\n  name,\n  metadataUrl,\n  rasterTileServerUrls\n}: RasterTilesetMeta): DatasetCreationAttributes {\n  const appConfig = getApplicationConfig();\n  return {\n    name,\n    type: DatasetType.RASTER_TILE,\n    metadata: {\n      metadataUrl,\n      ...(rasterTileServerUrls ? {rasterTileServerUrls} : {}),\n      // Persist raster server-related application config with the layer\n      rasterServerUseLatestTitiler: appConfig.rasterServerUseLatestTitiler,\n      rasterServerSupportsElevation: appConfig.rasterServerSupportsElevation,\n      rasterServerMaxRetries: appConfig.rasterServerMaxRetries,\n      rasterServerRetryDelay: appConfig.rasterServerRetryDelay,\n      rasterServerServerErrorsToRetry: appConfig.rasterServerServerErrorsToRetry,\n      rasterServerMaxPerServerRequests: appConfig.rasterServerMaxPerServerRequests\n    }\n  };\n}\n\ntype RasterTileFormProps = {\n  setResponse: (response: MetaResponse) => void;\n};\n\nconst InfoIconLink = styled.a`\n  margin-left: 4px;\n  color: ${props => props.theme.labelColor};\n  text-decoration: none;\n  display: inline-flex;\n  align-items: center;\n  line-height: 0;\n  vertical-align: middle;\n  opacity: 0.7;\n\n  &:hover {\n    opacity: 1;\n  }\n\n  svg {\n    display: block;\n  }\n`;\n\nconst RASTER_TILE_DOCUMENTATION_URL =\n  'https://docs.kepler.gl/docs/user-guides/c-types-of-layers/n-raster-tile-layer';\n\nconst TITILER_BASE_URL = 'https://titiler.xyz';\n\nfunction isCOGUrl(url: string): boolean {\n  if (!url) return false;\n  try {\n    const pathname = new URL(url).pathname.toLowerCase().replace(/\\/+$/, '');\n    return pathname.endsWith('.tif') || pathname.endsWith('.tiff');\n  } catch {\n    const cleaned = url.trim().toLowerCase().split(/[?#]/)[0].replace(/\\/+$/, '');\n    return cleaned.endsWith('.tif') || cleaned.endsWith('.tiff');\n  }\n}\n\nfunction getCOGMetadataUrl(cogUrl: string): string {\n  return `${TITILER_BASE_URL}/cog/stac?url=${encodeURIComponent(cogUrl)}`;\n}\n\nconst RASTER_TILE_EXAMPLES = [\n  {\n    label: 'COG',\n    name: 'Africa Farms',\n    url: 'https://sentinel-cogs.s3.us-west-2.amazonaws.com/sentinel-s2-l2a-cogs/36/Q/WD/2020/7/S2A_36QWD_20200701_0_L2A/TCI.tif'\n  },\n  {\n    label: 'PMTiles',\n    name: 'Swiss Historical',\n    url: 'https://public-bucket-for-tests.s3.us-east-1.amazonaws.com/historic-swis-18xx.pmtiles'\n  },\n  {\n    label: 'STAC Collection',\n    name: 'Sentinel-2 L1C',\n    url: 'https://earth-search.aws.element84.com/v1/collections/sentinel-2-l1c'\n  }\n];\n\nconst parseMetadataAllowCollections = (\n  metadata: JsonObjectOrArray | PMTilesMetadata,\n  {metadataUrl, rasterTileType}: {metadataUrl: string; rasterTileType: RasterTileType}\n) => {\n  return rasterTileType === RasterTileType.PMTILES\n    ? parseVectorMetadata(metadata as PMTilesMetadata, {\n        tileUrl: metadataUrl\n      })\n    : parseRasterMetadata(metadata as JsonObjectOrArray, {allowCollections: true});\n};\n\nconst RasterTileForm: React.FC<RasterTileFormProps> = ({setResponse}) => {\n  const [tileName, setTileName] = useState<string>('');\n  const [tileNameWasModified, setTileNameWasModified] = useState<boolean>(false);\n  const [metadataUrl, setMetadataUrl] = useState<string>('');\n  const [rasterTileServerUrls, setRasterTileServerUrls] = useState<string>(\n    (getApplicationConfig().rasterServerUrls || []).join(',')\n  );\n  const [exampleTab, setExampleTab] = useState(0);\n\n  // Remove trailing slash to prevent issues with raster tile servers\n  const clearedMetadataUrl = metadataUrl.endsWith('/') ? metadataUrl.slice(0, -1) : metadataUrl;\n\n  const isCOG = isCOGUrl(clearedMetadataUrl);\n  const effectiveMetadataUrl = isCOG ? getCOGMetadataUrl(clearedMetadataUrl) : clearedMetadataUrl;\n  const effectiveRasterTileServerUrls = isCOG ? TITILER_BASE_URL : rasterTileServerUrls;\n\n  const defaultServerUrls = (getApplicationConfig().rasterServerUrls || []).join(',');\n\n  const onExampleClick = useCallback(\n    (url: string, name: string) => {\n      setMetadataUrl(url);\n      setTileName(name);\n      setTileNameWasModified(false);\n\n      if (isCOGUrl(url)) {\n        setRasterTileServerUrls(TITILER_BASE_URL);\n      } else {\n        setRasterTileServerUrls(defaultServerUrls);\n      }\n    },\n    [defaultServerUrls]\n  );\n\n  const onTileNameChange = useCallback(\n    (event: React.ChangeEvent<HTMLInputElement>) => {\n      event.preventDefault();\n      setTileNameWasModified(true);\n      setTileName(event.target.value);\n    },\n    [setTileName]\n  );\n\n  const onMetadataUrlChange = useCallback(\n    (event: React.ChangeEvent<HTMLInputElement>) => {\n      event.preventDefault();\n      const {value} = event.target;\n      setMetadataUrl(value);\n\n      if (isCOGUrl(value) && !rasterTileServerUrls.trim()) {\n        setRasterTileServerUrls(TITILER_BASE_URL);\n      }\n\n      if (!tileNameWasModified) {\n        setTileName(value.split('/').filter(Boolean).pop() || '');\n      }\n    },\n    [tileNameWasModified, rasterTileServerUrls]\n  );\n\n  const onRasterTileServerUrlsChange = useCallback(\n    (event: React.ChangeEvent<HTMLInputElement>) => {\n      event.preventDefault();\n      setRasterTileServerUrls(event.target.value);\n    },\n    [setRasterTileServerUrls]\n  );\n\n  const {\n    data: metadata,\n    loading,\n    error: metaError\n  } = useFetchJson({\n    url: effectiveMetadataUrl,\n    rasterTileType: isPMTilesUrl(clearedMetadataUrl) ? RasterTileType.PMTILES : RasterTileType.STAC,\n    process: parseMetadataAllowCollections\n  });\n\n  useEffect(() => {\n    if (tileName && clearedMetadataUrl) {\n      const pmtilesType = metadata?.pmtilesType;\n\n      if (pmtilesType === PMTilesType.MVT) {\n        return setResponse({\n          metadata,\n          dataset: null,\n          loading,\n          error: new Error('For .pmtiles in mvt format, please use the Vector Tile form.')\n        });\n      }\n\n      let error = metaError;\n\n      // check for raster tile servers for STAC items and collections\n      let rasterTileServers;\n      if (\n        !error\n        // We still need raster tile servers for PMTiles when we plan to use elevation\n      ) {\n        rasterTileServers = effectiveRasterTileServerUrls\n          .split(',')\n          .map(server => server.trim())\n          .filter(server => server);\n        if (\n          rasterTileServers.length < 1 ||\n          !rasterTileServers.every(server => validateUrl(server))\n        ) {\n          if (pmtilesType) {\n            // For raster tiles elevation support is optional\n            // TODO display a warning, but not a blocking error\n            rasterTileServers = [];\n          } else {\n            error = new Error(\n              'Provide valid raster tile server urls to support STAC and elevations.'\n            );\n          }\n        }\n      }\n\n      const dataset = getDatasetAttributesFromRasterTile({\n        name: tileName,\n        metadataUrl: effectiveMetadataUrl,\n        rasterTileServerUrls: rasterTileServers\n      });\n\n      setResponse({\n        metadata,\n        dataset,\n        loading,\n        error\n      });\n    } else {\n      setResponse({\n        metadata,\n        dataset: null,\n        loading,\n        error: metaError\n      });\n    }\n  }, [\n    metadata,\n    loading,\n    metaError,\n    tileName,\n    clearedMetadataUrl,\n    effectiveMetadataUrl,\n    effectiveRasterTileServerUrls,\n    setResponse\n  ]);\n\n  const showServerInput = getApplicationConfig().rasterServerShowServerInput;\n\n  return (\n    <TilesetInputContainer>\n      <div>\n        <label htmlFor=\"tileset-name\">Name</label>\n        <InputLight\n          id=\"tileset-name\"\n          placeholder=\"Name your tileset\"\n          value={tileName}\n          onChange={onTileNameChange}\n        />\n      </div>\n      <div>\n        <LabelRow>\n          <label htmlFor=\"tile-metadata\">Tileset metadata URL</label>\n          <InfoIconLink\n            href={RASTER_TILE_DOCUMENTATION_URL}\n            target=\"_blank\"\n            rel=\"noopener noreferrer\"\n            aria-label=\"Open Raster Tile Layer documentation\"\n          >\n            <Help height=\"16px\" />\n          </InfoIconLink>\n        </LabelRow>\n        <InputLight\n          id=\"tile-metadata\"\n          placeholder=\"Tileset metadata URL\"\n          value={metadataUrl ?? undefined}\n          onChange={onMetadataUrlChange}\n        />\n        <TilesetInputDescription>\n          Supports raster .pmtiles, COG (.tif) URLs, STAC Items and Collections.\n        </TilesetInputDescription>\n      </div>\n      {showServerInput && (\n        <div>\n          <LabelRow>\n            <label htmlFor=\"tileset-raster-servers\">Raster tile servers</label>\n            <InfoIconLink\n              href={RASTER_TILE_DOCUMENTATION_URL}\n              target=\"_blank\"\n              rel=\"noopener noreferrer\"\n              aria-label=\"Open Raster Tile Layer documentation\"\n            >\n              <Help height=\"16px\" />\n            </InfoIconLink>\n          </LabelRow>\n          <InputLight\n            id=\"tileset-raster-servers\"\n            placeholder=\"Raster tile servers (separated by commas)\"\n            value={rasterTileServerUrls}\n            onChange={onRasterTileServerUrlsChange}\n          />\n          <TilesetInputDescription>\n            Raster tile server URLs for Cloud Optimized GeoTIFF tilesets and elevation.\n          </TilesetInputDescription>\n        </div>\n      )}\n      {getApplicationConfig().showInlineTilesetExamples && (\n        <div>\n          <TilesetInputDescription>\n            For example, try a public raster tileset:\n          </TilesetInputDescription>\n          <ExampleUrlsContainer>\n            <ExampleTabs>\n              {RASTER_TILE_EXAMPLES.map((ex, i) => (\n                <ExampleTab\n                  key={`${ex.label}-${ex.name}`}\n                  active={exampleTab === i}\n                  onClick={() => {\n                    setExampleTab(i);\n                    onExampleClick(ex.url, ex.name);\n                  }}\n                >\n                  {ex.name}\n                </ExampleTab>\n              ))}\n            </ExampleTabs>\n            <ExampleUrl\n              onClick={() =>\n                onExampleClick(\n                  RASTER_TILE_EXAMPLES[exampleTab].url,\n                  RASTER_TILE_EXAMPLES[exampleTab].name\n                )\n              }\n            >\n              {RASTER_TILE_EXAMPLES[exampleTab].url}\n            </ExampleUrl>\n          </ExampleUrlsContainer>\n        </div>\n      )}\n    </TilesetInputContainer>\n  );\n};\n\nexport default RasterTileForm;\n"],"mappings":"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","ignoreList":[]}