geoblacklight 6.0.0.pre.alpha.7 → 6.0.0.pre.beta.2

data/app/components/geoblacklight/relations_component.html.erb

@@ -1,23 +0,0 @@
-<div class="card relations relationship-<%= relationship_type.downcase %>">
-  <div class="card-header">
-    <h2 class="mb-0 h6"><%= t("#{rel_type_info.label}") %></h2>
-  </div>
-
-  <ul class="list-group list-group-flush">
-    <% relationship_type_results['docs'][0..2].map { |hash| SolrDocument.new(hash) }.each do |doc| %>
-      <li class="list-group-item">
-        <%= link_to solr_document_path(doc) do %>
-          <%= helpers.geoblacklight_icon(rel_type_info.icon) unless rel_type_info.icon.nil? %>
-          <%= doc.title %>
-        <% end %>
-      </li>
-    <% end %>
-    <% unless (relationship_type_results['numFound'].to_i <= 3) %>
-      <li class="list-group-item">
-        <%= link_to search_catalog_path({f: {"#{Geoblacklight.configuration.relationships_shown.public_send(relationship_type).field}" => [relations.link_id]}}) do %>
-          <%= t('geoblacklight.relations.browse_all', count: relationship_type_results['numFound']) %>
-        <% end %>
-      </li>
-    <% end %>
-  </ul>
-</div>

data/app/components/geoblacklight/relations_component.rb

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-module Geoblacklight
-  # Display expandable file download links in sidebar
-  class RelationsComponent < ViewComponent::Base
-    attr_reader :relations, :relationship_type, :rel_type_info
-
-    def initialize(relations:, relationship_type:, rel_type_info:)
-      @relations = relations
-      @relationship_type = relationship_type
-      @rel_type_info = rel_type_info
-      super()
-    end
-
-    def render?
-      relationship_type_results["numFound"].to_i.positive?
-    end
-
-    private
-
-    def relationship_type_results
-      @relationship_type_results ||= relations.public_send(relationship_type)
-    end
-  end
-end

data/app/components/geoblacklight/viewer_help_text_component.html.erb

@@ -1 +0,0 @@
-<%= display_text %>

data/app/components/geoblacklight/viewer_help_text_component.rb

@@ -1,46 +0,0 @@
-# frozen_string_literal: true
-
-module Geoblacklight
-  ##
-  # A component for rendering the help text for the viewer container
-  #
-  class ViewerHelpTextComponent < ViewComponent::Base
-    def initialize(feature, key)
-      @feature = feature
-      @key = key
-      super()
-    end
-
-    # Retrieve i18n value
-    def help_text_exists?
-      I18n.exists?("geoblacklight.help_text.#{@feature}.#{@key}", helpers.locale)
-    end
-
-    def help_text_value
-      I18n.t("geoblacklight.help_text.#{@feature}.#{@key}")
-    end
-
-    def help_text_tag
-      help_text = help_text_value
-      tag.h2 class: "help-text viewer_protocol h6" do
-        tag.a data: {bs_toggle: "popover", bs_title: help_text[:title], bs_content: help_text[:content]} do
-          help_text[:title]
-        end
-      end
-    end
-
-    def help_text_missing_tag
-      tag.span class: "help-text translation-missing"
-    end
-
-    def display_text
-      return help_text_tag if help_text_exists?
-
-      help_text_missing_tag
-    end
-
-    def render?
-      Geoblacklight.configuration.help_text.fetch(@feature.to_sym, []).include?(@key)
-    end
-  end
-end

data/app/controllers/wms_controller.rb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-class WmsController < ApplicationController
-  def handle
-    response = Geoblacklight::WmsLayer.new(wms_params).feature_info
-
-    respond_to do |format|
-      format.json { render json: response }
-    end
-  end
-
-  private
-
-  def wms_params
-    params.permit(Geoblacklight.configuration.gbl_params)
-  end
-end

data/app/javascript/geoblacklight/controllers/leaflet_viewer_controller.js

@@ -1,240 +0,0 @@
-import { Icon, Control } from "leaflet"
-import { FullScreen } from "leaflet.fullscreen"
-import { layerGroup, polygon, map, tileLayer } from "leaflet"
-import { imageMapLayer } from "esri-leaflet"
-import { Controller } from "@hotwired/stimulus"
-import basemaps from "geoblacklight/leaflet/basemaps"
-import LayerOpacityControl from "geoblacklight/leaflet/controls/layer_opacity"
-import GeoSearchControl from "geoblacklight/leaflet/controls/geosearch"
-import Sleep from "geoblacklight/leaflet/controls/sleep"
-import {
-  wmsInspection,
-  tiledMapLayerInspection,
-  featureLayerInspection,
-  dynamicMapLayerInspection,
-} from "geoblacklight/leaflet/inspection"
-import {
-  esriDynamicMapLayer,
-  esriFeatureLayer,
-  esriTiledMapLayer,
-  tileJsonLayer,
-  wmsLayer,
-  wmtsLayer,
-  indexMapLayer,
-} from "geoblacklight/leaflet/layers"
-import { geoJSONToBounds } from "geoblacklight/leaflet/utils"
-import { DEFAULT_BOUNDS, DEFAULT_OPACITY, DEFAULT_GEOM_OVERLAY_OPTIONS } from "geoblacklight/leaflet/constants"
-import sidebarControl from "geoblacklight/leaflet/controls/sidebar"
-
-export default class LeafletViewerController extends Controller {
-  static values = {
-    url: String,
-    catalogBaseUrl: String,
-    protocol: String,
-    available: Boolean,
-    options: Object,
-    basemap: String,
-    darkBasemap: String,
-    mapGeom: Object,
-    page: String,
-    layerId: String,
-    drawInitialBounds: Boolean,
-  }
-
-  connect() {
-    // Use leaflet icon images from CDN
-    Icon.Default.imagePath = "https://cdnjs.cloudflare.com/ajax/libs/leaflet/1.9.4/images/"
-
-    // The map can be turbo-permanent; if we're reconnected but the map already
-    // exists, no need to destroy and recreate the layers and controls.
-    if (this.map) return
-
-    // Set up layers
-    this.basemap = this.getBasemap()
-    this.overlay = layerGroup()
-
-    // Calculate bounds
-    this.bounds = DEFAULT_BOUNDS
-    if (this.hasMapGeomValue) this.bounds = geoJSONToBounds(this.mapGeomValue)
-
-    // Load the map
-    this.loadMap()
-
-    // Check for changes to dark/light mode and update the basemap accordingly
-    const observer = new MutationObserver(() => {
-      this.map.removeLayer(this.basemap)
-      this.map.addLayer(this.getBasemap())
-    })
-    observer.observe(document.documentElement, { attributes: true, attributeFilter: ["data-bs-theme"] })
-  }
-
-  // Create the map, add layers, fit the bounds
-  async loadMap() {
-    if (this.map) return
-
-    // Set up the map and fit to bounds
-    const sleepSettings = this.optionsValue.sleep || { sleep: false }
-    this.map = map(this.element, sleepSettings)
-    if (sleepSettings.sleep) this.map.addHandler("SLEEP", Sleep)
-
-    this.map.addLayer(this.basemap)
-    this.map.addLayer(this.overlay)
-    this.fitBounds(this.bounds)
-    this.map.options.selected_color = this.optionsValue.selected_color || "blue"
-
-    // If the data is available, add the preview and set up inspection
-    // Otherwise just draw the bounds, if configured to do so
-    if (this.availableValue && this.protocolValue) {
-      await this.addPreviewOverlay()
-      this.addInspection()
-    } else if (this.drawInitialBoundsValue && this.bounds) {
-      this.addBoundsOverlay(this.bounds)
-    }
-
-    // Add configured controls
-    this.addControls()
-
-    if (this.protocolValue == "IndexMap") {
-      this.fitBounds(this.previewOverlay.getBounds())
-    }
-
-    // Enable geosearch handler, if available
-    if (this.map.geosearch) this.map.geosearch.enable()
-
-    // Emit an event for other controllers to listen to
-    this.dispatch("loaded")
-  }
-
-  // Set the bounds of the map to an L.LatLngBounds object
-  fitBounds(bounds) {
-    // prevent map from moving when setting bounds, if relevant
-    if (this.map.geosearch) this.map.geosearch.disable()
-    this.map.fitBounds(bounds, { animate: false, noMoveStart: true })
-    this.bounds = bounds
-    if (this.map.geosearch) this.map.geosearch.enable()
-    this.element.dataset.bounds = this.bounds.toBBoxString()
-  }
-
-  // Select the configured basemaps to use
-  getBasemap() {
-    if (document.documentElement.getAttribute("data-bs-theme") === "dark")
-      this.basemapName = this.darkBasemapValue || "dark_matter"
-    else this.basemapName = this.basemapValue || "positron"
-
-    return tileLayer(basemaps[this.basemapName].url, {
-      ...basemaps[this.basemapName],
-      detectRetina: this.optionsValue.layers.detect_retina || false,
-    })
-  }
-
-  // Add the configured controls to the map
-  addControls() {
-    // Add any top-level controls (e.g. geosearch) first
-    const globalControls = this.optionsValue.controls || {}
-    Object.entries(globalControls).forEach(([controlName, controlOptions]) => {
-      const control = this.getControl(controlName, controlOptions)
-      if (control) this.addControl(control)
-    })
-
-    // Add opacity and fullscreen controls for all layers
-    if (this.hasProtocolValue) {
-      if (this.availableValue) {
-        const opacityControl = this.getControl("Opacity")
-        this.addControl(opacityControl)
-      }
-      const fullscreenControl = this.getControl("Fullscreen")
-      this.addControl(fullscreenControl)
-    }
-  }
-
-  // Add a pre-configured L.Control instance to the map
-  addControl(control) {
-    this.map.addControl(control)
-  }
-
-  // Look up the control name and return the corresponding L.Control instance
-  getControl(controlName, controlOptions) {
-    if (controlName == "Opacity") return new LayerOpacityControl(this.previewOverlay)
-    if (controlName == "Fullscreen") return new FullScreen({ position: "bottomleft", ...controlOptions })
-    if (controlName == "Geosearch")
-      return new GeoSearchControl({
-        baseUrl: this.catalogBaseUrlValue,
-        ...controlOptions,
-      })
-    console.error(`Unsupported control name: "${controlName}"`)
-  }
-
-  // Add the bounding box to the map
-  addBoundsOverlay(bounds) {
-    const hasMapGeomValue = Object.keys(this.mapGeomValue).length > 0 && !this.map.geosearch
-    var defaultOptions = hasMapGeomValue ? DEFAULT_GEOM_OVERLAY_OPTIONS : {}
-    const overlayOptions = this.optionsValue.bounds_overlay || {}
-    const options = { ...defaultOptions, ...overlayOptions[this.pageValue] }
-    const boundsOverlay = polygon(
-      [bounds.getSouthWest(), bounds.getSouthEast(), bounds.getNorthEast(), bounds.getNorthWest()],
-      options,
-    )
-
-    // Render geometry layer if available
-    if (hasMapGeomValue) this.map.addLayer(L.geoJSON(this.mapGeomValue, overlayOptions[this.pageValue]))
-
-    // Render the bounds overlay
-    this.boundsOverlay = boundsOverlay
-    this.overlay.addLayer(boundsOverlay)
-  }
-
-  // Remove the bounding box overlay
-  removeBoundsOverlay() {
-    if (this.boundsOverlay) this.overlay.removeLayer(this.boundsOverlay)
-  }
-
-  setUpSidebar() {
-    const sidebar = document.querySelector("[data-sidebar]")
-    if (!sidebar || sidebar.dataset.sidebar != "true") return
-    const control = new sidebarControl({
-      position: "topright",
-      sidebar,
-    })
-    this.map.addControl(control)
-  }
-
-  addInspection() {
-    const inspectionProtocols = ["Wms", "FeatureLayer", "DynamicMapLayer", "IndexMap"]
-    if (!inspectionProtocols.includes(this.protocolValue)) return
-    this.setUpSidebar()
-    if (this.protocolValue == "Wms")
-      return wmsInspection(this.map, this.urlValue, this.layerIdValue, this.previewOverlay)
-    if (this.protocolValue == "FeatureLayer") return featureLayerInspection(this.map, this.previewOverlay)
-    if (this.protocolValue == "DynamicMapLayer")
-      return dynamicMapLayerInspection(this.map, this.previewOverlay, this.layerIdValue)
-    // TODO: TiledMapLayer is converted but seems busted -- see layers.js. Don't know what to test it with, need a fixture.
-    // if (this.protocolValue == "TiledMapLayer") return tiledMapLayerInspection(this.map, this.previewOverlay);
-  }
-
-  // Add the actual data to the map as a layer
-  async addPreviewOverlay() {
-    this.previewOverlay = await this.getPreviewOverlay(this.protocolValue, this.urlValue, {
-      layerId: this.layerIdValue,
-      opacity: this.optionsValue.opacity || DEFAULT_OPACITY,
-      detectRetina: this.optionsValue.layers.detect_retina || false,
-    })
-    if (this.previewOverlay) this.overlay.addLayer(this.previewOverlay)
-  }
-
-  // Generate a layer based on the protocol
-  async getPreviewOverlay(protocol, url, options) {
-    if (protocol == "DynamicMapLayer") return esriDynamicMapLayer(url, options)
-    if (protocol == "FeatureLayer") return esriFeatureLayer(url, options)
-    // imageMapLayer is a built-in method from esri-leaflet
-    if (protocol == "ImageMapLayer") return imageMapLayer({ url, ...options })
-    if (protocol == "IndexMap") return await indexMapLayer(url, this.optionsValue)
-    if (protocol == "TiledMapLayer") return await esriTiledMapLayer(url, options)
-    if (protocol == "Tilejson") return await tileJsonLayer(url, options)
-    // tileLayer is a built-in method from leaflet
-    if (protocol == "Tms") return tileLayer(url, { tms: true, ...options })
-    if (protocol == "Wms") return wmsLayer(url, options)
-    if (protocol == "Wmts") return await wmtsLayer(url, options)
-    if (protocol == "Xyz") return tileLayer(url, options)
-    console.error(`Unsupported protocol name: "${protocol}"`)
-  }
-}

data/app/javascript/geoblacklight/controllers/openlayers_viewer_controller.js

@@ -1,74 +0,0 @@
-import { Map } from "ol"
-import TileLayer from "ol/layer/Tile"
-import XYZ from "ol/source/XYZ"
-import GeoJSON from "ol/format/GeoJSON"
-import { FullScreen, defaults as defaultControls } from "ol/control"
-import { pmTilesLayer, cogLayer } from "geoblacklight/openlayers/layers"
-import basemaps from "geoblacklight/openlayers/basemaps"
-import { Controller } from "@hotwired/stimulus"
-import { pmTilesInspection } from "geoblacklight/openlayers/inspection"
-
-export default class OpenlayersViewerController extends Controller {
-  static values = {
-    url: String,
-    protocol: String,
-    basemap: String,
-    darkBasemap: String,
-    mapGeom: String,
-  }
-
-  async connect() {
-    // Set up layers
-    this.basemap = this.getBasemap()
-    this.overlay = this.getPreviewOverlay(this.protocolValue, this.urlValue)
-
-    await this.getBounds()
-    // Load the map
-    this.loadMap()
-
-    // Check for changes to dark/light mode and update the basemap accordingly
-    const observer = new MutationObserver(() => this.map.getLayers().setAt(0, this.getBasemap()))
-    observer.observe(document.documentElement, { attributes: true, attributeFilter: ["data-bs-theme"] })
-  }
-
-  // Create the map, add layers, and fit the bounds
-  loadMap() {
-    this.map = new Map({
-      target: this.element,
-      controls: defaultControls().extend([new FullScreen()]),
-      layers: [this.basemap, this.overlay],
-    })
-    this.map.getView().fit(this.extent, this.map.getSize())
-    this.addInspection()
-  }
-
-  addInspection() {
-    if (this.protocolValue == "Pmtiles") return pmTilesInspection(this.map)
-  }
-
-  async getBounds() {
-    if (this.protocolValue == "Cog") {
-      const view = await this.overlay.getSource().getView()
-      this.extent = view.extent
-    } else {
-      this.extent = new GeoJSON().readFeatures(this.mapGeomValue)[0].getGeometry().getExtent()
-    }
-  }
-
-  // Select the configured basemap to use
-  getBasemap() {
-    if (document.documentElement.getAttribute("data-bs-theme") === "dark")
-      this.basemapName = this.darkBasemapValue || "dark_matter"
-    else this.basemapName = this.basemapValue || "positron"
-
-    const layer = new TileLayer({ source: new XYZ(basemaps[this.basemapName]) })
-    return layer
-  }
-
-  // Generate a layer based on the protocol
-  getPreviewOverlay(protocol, url) {
-    if (protocol === "Pmtiles") return pmTilesLayer(url)
-    if (protocol === "Cog") return cogLayer(url)
-    console.error(`Unsupported protocol name: "${protocol}"`)
-  }
-}

data/app/javascript/geoblacklight/controllers/search_results_controller.js

@@ -1,50 +0,0 @@
-import { Controller } from "@hotwired/stimulus"
-import { geoJSONToBounds } from "geoblacklight/leaflet/utils"
-import { DEFAULT_BOUNDS } from "geoblacklight/leaflet/constants"
-
-export default class SearchResultsController extends Controller {
-  static targets = ["result"]
-  static outlets = ["leaflet-viewer"]
-
-  // Fit the map to the combined bounding box of all search results
-  // If a bounding box query is already active, do not override it
-  fitResultBounds() {
-    if (new URL(window.location).searchParams.get("bbox")) return
-    this.leafletViewerOutlet.fitBounds(this.getMaximalBounds())
-  }
-
-  // Get the bounding box of a search result from its data attributes
-  getResultBounds(resultElement) {
-    const geomElement = resultElement.querySelector("[data-geom]")
-    if (geomElement && geomElement.dataset.geom) {
-      return geoJSONToBounds(JSON.parse(geomElement.dataset.geom))
-    }
-  }
-
-  // Find the combined bounding box of all search results
-  getMaximalBounds() {
-    const bounds = this.resultTargets.map(this.getResultBounds)
-    const nonNullBounds = bounds.filter((b) => b)
-
-    if (nonNullBounds.length > 0) {
-      return nonNullBounds.reduce((max, b) => max.extend(b))
-    }
-
-    return DEFAULT_BOUNDS
-  }
-
-  // Preview the selected search result's bounding box on the map
-  previewResultOnMap(event) {
-    const geomElement = event.target.querySelector("[data-geom]")
-    if (geomElement && geomElement.dataset.geom !== "") {
-      const geom = JSON.parse(geomElement.dataset.geom)
-      const bbox = geoJSONToBounds(geom)
-      this.leafletViewerOutlet.addBoundsOverlay(bbox)
-    }
-  }
-
-  // Remove the previewed bounding box
-  clearPreview() {
-    this.leafletViewerOutlet.removeBoundsOverlay()
-  }
-}

data/app/javascript/geoblacklight/initializers/popovers.js

@@ -1,11 +0,0 @@
-import { Popover } from "bootstrap"
-
-// Initialize popovers
-export default function initializePopovers() {
-  const popoverElements = document.querySelectorAll('[data-bs-toggle="popover"]') // Bootstrap 5 uses 'data-bs-toggle'
-  popoverElements.forEach((element) => {
-    const popover = new Popover(element, {
-      trigger: "hover",
-    })
-  })
-}

data/app/javascript/geoblacklight/initializers/tooltips.js

@@ -1,51 +0,0 @@
-import { Tooltip } from "bootstrap"
-
-export default function initializeTooltips() {
-  document.body.addEventListener(
-    "mouseenter",
-    (event) => {
-      if (event.target.closest(".blacklight-icons.svg_tooltip svg")) {
-        const svgElement = event.target.closest(".blacklight-icons.svg_tooltip svg")
-        const svgTitleElement = svgElement.querySelector("title")
-        const titleText = svgTitleElement ? svgTitleElement.textContent : ""
-
-        if (titleText !== undefined && titleText !== "") {
-          // Initialize Bootstrap tooltip with native JavaScript
-          const tooltip = new Tooltip(svgElement, {
-            placement: "bottom",
-            title: titleText,
-          })
-          tooltip.show()
-
-          // Store the original title in the data-original-title attribute
-          // and remove the title element to prevent it from interfering with Bootstrap's tooltip.
-          svgElement.setAttribute("data-original-title", titleText)
-          svgTitleElement.remove()
-        }
-      }
-    },
-    true,
-  ) // Use capture to ensure the event is caught as it bubbles up
-
-  document.body.addEventListener(
-    "mouseleave",
-    (event) => {
-      if (event.target.closest(".blacklight-icons.svg_tooltip svg")) {
-        const svgElement = event.target.closest(".blacklight-icons.svg_tooltip svg")
-        const originalTitle = svgElement.getAttribute("data-original-title")
-
-        if (originalTitle !== undefined && originalTitle !== "") {
-          // Restore the SVG title element from data-original-title
-          const newTitleElement = document.createElement("title")
-          newTitleElement.textContent = originalTitle
-          svgElement.prepend(newTitleElement)
-          svgElement.setAttribute("data-original-title", "")
-        }
-      }
-
-      // Remove tooltips
-      document.querySelectorAll(".tooltip").forEach((elem) => elem.remove())
-    },
-    true,
-  ) // Use capture to ensure the event is caught as it bubbles up
-}

data/app/javascript/geoblacklight/leaflet/basemaps.js

@@ -1,73 +0,0 @@
-export default {
-  dark_matter: {
-    url: "https://{s}.basemaps.cartocdn.com/dark_all/{z}/{x}/{y}{retina}.png",
-    attribution:
-      '&copy; <a href="http://www.openstreetmap.org/copyright">OpenStreetMap</a> contributors, &copy; <a href="http://carto.com/attributions">Carto</a>',
-    maxZoom: 18,
-    worldCopyJump: true,
-    retina: "@2x",
-  },
-  positron: {
-    url: "https://{s}.basemaps.cartocdn.com/light_all/{z}/{x}/{y}{retina}.png",
-    attribution:
-      '&copy; <a href="http://www.openstreetmap.org/copyright">OpenStreetMap</a> contributors, &copy; <a href="http://carto.com/attributions">Carto</a>',
-    maxZoom: 18,
-    worldCopyJump: true,
-    retina: "@2x",
-  },
-  positron_lite: {
-    url: "https://{s}.basemaps.cartocdn.com/light_nolabels/{z}/{x}/{y}{retina}.png",
-    attribution:
-      '&copy; <a href="http://www.openstreetmap.org/copyright">OpenStreetMap</a> contributors, &copy; <a href="http://carto.com/attributions">Carto</a>',
-    maxZoom: 18,
-    worldCopyJump: true,
-    retina: "@2x",
-  },
-  world_antique: {
-    url: "https://cartocdn_{s}.global.ssl.fastly.net/base-antique/{z}/{x}/{y}{retina}.png",
-    attribution:
-      '&copy; <a href="http://www.openstreetmap.org/copyright">OpenStreetMap</a> contributors, &copy; <a href="http://carto.com/attributions">Carto</a>',
-    maxZoom: 18,
-    worldCopyJump: true,
-    retina: "@2x",
-  },
-  world_eco: {
-    url: "https://cartocdn_{s}.global.ssl.fastly.net/base-eco/{z}/{x}/{y}{retina}.png",
-    attribution:
-      '&copy; <a href="http://www.openstreetmap.org/copyright">OpenStreetMap</a> contributors, &copy; <a href="http://carto.com/attributions">Carto</a>',
-    maxZoom: 18,
-    worldCopyJump: true,
-    retina: "@2x",
-  },
-  flat_blue: {
-    url: "https://cartocdn_{s}.global.ssl.fastly.net/base-flatblue/{z}/{x}/{y}{retina}.png",
-    attribution:
-      '&copy; <a href="http://www.openstreetmap.org/copyright">OpenStreetMap</a> contributors, &copy; <a href="http://carto.com/attributions">Carto</a>',
-    maxZoom: 18,
-    worldCopyJump: true,
-    retina: "@2x",
-  },
-  midnight_commander: {
-    url: "https://cartocdn_{s}.global.ssl.fastly.net/base-midnight/{z}/{x}/{y}{retina}.png",
-    attribution:
-      '&copy; <a href="http://www.openstreetmap.org/copyright">OpenStreetMap</a> contributors, &copy; <a href="http://carto.com/attributions">Carto</a>',
-    maxZoom: 18,
-    worldCopyJump: true,
-    retina: "@2x",
-  },
-  openstreetmap_hot: {
-    url: "https://{s}.tile.openstreetmap.fr/hot/{z}/{x}/{y}.png",
-    attribution:
-      '&copy; <a href="http://www.openstreetmap.org/copyright">OpenStreetMap</a>, Tiles courtesy of <a href="http://hot.openstreetmap.org/" target="_blank">Humanitarian OpenStreetMap Team</a>',
-    maxZoom: 19,
-    worldCopyJump: true,
-    retina: "@2x",
-  },
-  openstreetmap_standard: {
-    url: "https://tile.openstreetmap.org/{z}/{x}/{y}.png",
-    attribution: '&copy; <a href="http://www.openstreetmap.org/copyright">OpenStreetMap</a> contributors',
-    maxZoom: 19,
-    worldCopyJump: true,
-    retina: "@2x",
-  },
-}

data/app/javascript/geoblacklight/leaflet/constants.js

@@ -1,18 +0,0 @@
-import { LatLngBounds } from "leaflet"
-
-export const DEFAULT_BOUNDS = new LatLngBounds([
-  [-30, -100],
-  [30, 100],
-])
-
-export const DEFAULT_OPACITY = 0.75
-
-export const DEFAULT_BASEMAP = "positron"
-
-export const DEFAULT_GEOM_OVERLAY_OPTIONS = {
-  color: "#3388ff",
-  dashArray: "5 5",
-  weight: 2,
-  opacity: 1,
-  fillOpacity: 0,
-}