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

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

@@ -1,128 +0,0 @@
-const indexMapInfoTemplate = (data, labels) => `
-  <div class="index-map-info">
-    ${
-      data.title
-        ? `
-      <div class="col-sm-12">
-        <h3>${data.title}</h3>
-      </div>`
-        : ""
-    }
-    <div class="col-sm-12">
-      ${
-        data.thumbnailUrl
-          ? `
-        ${
-          data.websiteUrl
-            ? `
-          <a href="${data.websiteUrl}">
-            <img src="${data.thumbnailUrl}" class="img-responsive">
-          </a>`
-            : `
-          <img src="${data.thumbnailUrl}">`
-        }`
-          : ""
-      }
-      <dl class="row dl-invert document-metadata">
-        ${
-          data.websiteUrl
-            ? `
-          <dt class="col-sm-3">${labels.websiteLabel}</dt>
-          <dd class="col-sm-9"><a href="${data.websiteUrl}">${data.websiteUrl}</a></dd>`
-            : ""
-        }
-        ${
-          data.downloadUrl
-            ? `
-          <dt class="col-sm-3">${labels.downloadLabel}</dt>
-          <dd class="col-sm-9"><a href="${data.downloadUrl}">${data.downloadUrl}</a></dd>`
-            : ""
-        }
-        ${
-          data.recordIdentifier
-            ? `
-          <dt class="col-sm-3">${labels.recordIdentifierLabel}</dt>
-          <dd class="col-sm-9">${data.recordIdentifier}</dd>`
-            : ""
-        }
-        ${
-          data.label
-            ? `
-          <dt class="col-sm-3">${labels.labelLabel}</dt>
-          <dd class="col-sm-9">${data.label}</dd>`
-            : ""
-        }
-        ${
-          data.note
-            ? `
-          <dt class="col-sm-3">${labels.noteLabel}</dt>
-          <dd class="col-sm-9">${data.note}</dd>`
-            : ""
-        }
-      </dl>
-    </div>
-  </div>`
-
-const indexMapDownloadTemplate = (data, labels) =>
-  data.downloadUrl
-    ? `
-  <li class="list-group-item download js-index-map-feature">
-    <h3 class="card-subtitle">${labels.selectedFeature}</h3>
-    <ul class="list-group list-group-flush list-group-nested">
-      <li class="list-group-item download">
-        <div class="download-link-container">
-          <a class="btn btn-default download download-original" href="${data.downloadUrl}">
-            ${data.label ? data.label : labels.downloadText}
-          </a>
-        </div>
-      </li>
-    </ul>
-  </li>
-`
-    : ""
-
-const indexMapTemplate = (data) => {
-  return new Promise((resolve) => {
-    if (data.iiifUrl && !data.thumbnailUrl) {
-      fetch(data.iiifUrl)
-        .then((response) => response.json())
-        .then((manifestResponse) => {
-          if (manifestResponse.thumbnail["@id"] !== null) {
-            data.thumbnailUrl = manifestResponse.thumbnail["@id"]
-          }
-          resolve(data) // Resolve the modified data
-        })
-        .catch(() => resolve(data)) // In case of error, resolve with original data
-    } else {
-      resolve(data) // Immediately resolve if no iiifUrl
-    }
-  })
-}
-
-export const availabilityStyle = (availability, leafletOptions) => {
-  var style =
-    availability || typeof availability === "undefined"
-      ? leafletOptions.layers.index.DEFAULT
-      : leafletOptions.layers.index.UNAVAILABLE
-  style["fillOpacity"] = leafletOptions.opacity || 0.65
-  style["opacity"] = leafletOptions.opacity || 0.65
-  return style
-}
-
-export const updateInformation = (properties) => {
-  const informationContainer = document.querySelector(".viewer-information")
-  const labels = informationContainer.dataset
-
-  indexMapTemplate(properties).then((updatedProperties) => {
-    const indexMapHtml = indexMapInfoTemplate(updatedProperties, labels)
-    informationContainer.innerHTML = indexMapHtml
-
-    const indexMapDownloadHtml = indexMapDownloadTemplate(updatedProperties, labels)
-    const downloadElement = document.querySelector(".js-download-list")
-
-    if (Boolean(downloadElement)) {
-      downloadElement.innerHTML += indexMapDownloadHtml // Appends new download template
-      downloadElement.querySelectorAll(".js-index-map-feature").forEach((elem) => elem.remove())
-    }
-  })
-}

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

@@ -1,57 +0,0 @@
-import { latLng, latLngBounds } from "leaflet"
-
-export const parseWmtsCapabilities = (wmtsCapabilities, layerId) => {
-  const parser = new DOMParser(),
-    doc = parser.parseFromString(wmtsCapabilities, "application/xml"),
-    layers = doc.getElementsByTagName("Layer"),
-    selectedLayer = findLayer(layers, layerId),
-    resourceElement = selectedLayer.getElementsByTagName("ResourceURL")[0]
-
-  // Generate URL with Leaflet.TileLayer URL template formatting
-  const tileURL = resourceElement
-    .getAttribute("template")
-    .replace("{Style}", getStyle(selectedLayer))
-    .replace("{TileMatrixSet}", getTileMatrixSet(selectedLayer))
-    .replace("TileMatrix", "z")
-    .replace("TileCol", "x")
-    .replace("TileRow", "y")
-
-  return { url: tileURL, bounds: getBounds(selectedLayer) }
-}
-
-const findLayer = (layers, layerId) => {
-  if (layers.length === 1) {
-    return layers[0]
-  } else {
-    for (let i = 0; i < layers.length; i++) {
-      const ids = layers[i].getElementsByTagName("ows:Identifier")
-      for (let x = 0; x < ids.length; x++) {
-        if (ids[x].textContent === layerId) {
-          return layers[i]
-        }
-      }
-    }
-  }
-}
-
-const getStyle = (layer) => {
-  const styleElement = layer.getElementsByTagName("Style")[0]
-  return styleElement ? styleElement.getElementsByTagName("ows:Identifier")[0].textContent : undefined
-}
-
-const getTileMatrixSet = (layer) => {
-  const tileMatrixElement = layer.getElementsByTagName("TileMatrixSet")[0]
-  return tileMatrixElement ? tileMatrixElement.textContent : undefined
-}
-
-const getBounds = (layer) => {
-  const lcElement = layer.getElementsByTagName("ows:LowerCorner")[0],
-    ucElement = layer.getElementsByTagName("ows:UpperCorner")[0]
-  if (lcElement && ucElement) {
-    const lc = lcElement.textContent.split(" "),
-      uc = ucElement.textContent.split(" "),
-      corner1 = latLng(lc[1], lc[0]),
-      corner2 = latLng(uc[1], uc[0])
-    return latLngBounds(corner1, corner2)
-  }
-}

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

@@ -1,146 +0,0 @@
-/** This file contains methods for creating the various types of leaflet and esri-leaflet layers required in leaflet_viewer_controller.
- * If complex logic is needed for a certain layer type, it is broken out into its own file,
- * such as layer_wmts.js for WMTS layers and layer_index_map.js for index map layers, at the same directory level as this file.
- */
-import { tileLayer, geoJson, circleMarker } from "leaflet"
-import { dynamicMapLayer, featureLayer, tiledMapLayer } from "esri-leaflet"
-import { parseWmtsCapabilities } from "geoblacklight/leaflet/layer_wmts"
-import { availabilityStyle, updateInformation } from "geoblacklight/leaflet/layer_index_map"
-import { getTileJsonBounds } from "geoblacklight/leaflet/utils"
-
-// Create a leaflet tile layer for WMS
-export const wmsLayer = (url, { layerId, opacity, detectRetina }) => {
-  return tileLayer.wms(url, {
-    layers: layerId,
-    format: "image/png",
-    transparent: true,
-    tiled: true,
-    CRS: "EPSG:3857",
-    opacity,
-    detectRetina,
-  })
-}
-
-// Fetch a WMTSCapabilities document and create a leaflet tileLayer using it
-export const wmtsLayer = async (url, { opacity, detectRetina, layerId }) => {
-  const response = await fetch(url)
-  if (!response.ok) throw new Error("Unable to fetch WMTSCapabilities document", url)
-
-  const wmtsCapabilities = await response.text()
-  if (!wmtsCapabilities) throw new Error("Unable to parse WMTSCapabilities document", url)
-
-  const tileInfo = parseWmtsCapabilities(wmtsCapabilities, layerId)
-  const options = tileInfo.bounds ? { bounds: tileInfo.bounds } : {}
-  return tileLayer(tileInfo.url, {
-    opacity,
-    detectRetina,
-    ...options,
-  })
-}
-
-// Create an ESRI-leaflet dynamic map layer
-export const esriDynamicMapLayer = (url, { opacity, detectRetina }) => {
-  // Remove any trailing slash and get the last segment from the URL
-  url = url.replace(/\/$/, "")
-  const pathArray = url.split("/")
-  const lastSegment = pathArray[pathArray.length - 1]
-
-  // If the last segment is an integer it's the layer ID
-  let layerId
-  if (Number(lastSegment) === parseInt(lastSegment, 10)) {
-    layerId = lastSegment
-    url = url.slice(0, -(lastSegment.length + 1))
-  }
-
-  const options = layerId ? { layers: [layerId] } : {}
-  return dynamicMapLayer({
-    url,
-    opacity,
-    detectRetina,
-    ...options,
-  })
-}
-
-// Create an ESRI-leaflet feature layer
-export const esriFeatureLayer = (url, { opacity, detectRetina }) => {
-  return featureLayer({
-    url,
-    opacity,
-    detectRetina,
-  })
-}
-
-// Create an ESRI tiled map layer
-export const esriTiledMapLayer = async (url, options) => {
-  const response = await fetch(url)
-
-  if (!response.ok) throw new Error("Unable to fetch EsriTiledMapLayer document", url)
-
-  let layerInfo
-  try {
-    layerInfo = await response.json()
-  } catch (error) {
-    throw new Error("Unable to parse TiledMapLayer document", response)
-  }
-
-  // For an example of tiledMapLayer data see nyu-test-soil-survey-map
-  // We aren't sure what the json structure looks like
-  // This is not rendering anything (and wasn't before we made changes) and the keys are not even present
-  // Check out this json: https://dnrmaps.wi.gov/arcgis2/rest/services/TS_AGOL_STAGING_SERVICES/EN_AGOL_STAGING_SurfaceWater_WTM/MapServer/2?f=pjson -- wrong protocol, now a feature map??
-  if (layerInfo.singleFusedMapCache === true && layerInfo.spatialReference.wkid === 102100) {
-    return tiledMapLayer({ url, ...options })
-  }
-}
-
-// Create a leaflet tile layer
-export const tileJsonLayer = async (url, options) => {
-  const response = await fetch(url)
-
-  if (!response.ok) {
-    throw new Error("Unable to fetch TiledJson document", url)
-  }
-
-  const layerInfo = await response.json()
-
-  const bounds = getTileJsonBounds(layerInfo)
-  if (bounds) options.bounds = bounds
-  const tileUrl = layerInfo.tiles[0]
-  return tileLayer(tileUrl, options)
-}
-
-// Fetch an indexMapLayer document and create a leaflet geoJSON layer
-export const indexMapLayer = async (url, leafletOptions) => {
-  let prevLayer = null
-
-  const response = await fetch(url)
-
-  if (!response.ok) {
-    throw new Error("Unable to fetch indexMapLayer document", url)
-  }
-
-  const data = await response.json()
-
-  // name the const geoJSONLayer; we access it self-referentially within the method
-  const geoJSONLayer = geoJson(data, {
-    style: (feature) => availabilityStyle(feature.properties.available, leafletOptions),
-    onEachFeature: (feature, layer) => {
-      if (feature.properties.label !== null) {
-        layer.bindTooltip(feature.properties.label)
-      }
-      if (feature.properties.available !== null) {
-        layer.on("click", (e) => {
-          layer.setStyle(leafletOptions.layers.index.SELECTED)
-          if (prevLayer !== null) {
-            leafletOptions.opacity = layer.options.fillOpacity
-            geoJSONLayer.resetStyle(prevLayer)
-          }
-          prevLayer = layer
-          updateInformation(feature.properties)
-        })
-      }
-    },
-    pointToLayer: (feature, latlng) => circleMarker(latlng),
-  })
-
-  return geoJSONLayer
-}

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

@@ -1,83 +0,0 @@
-import { latLngBounds, Util, geoJSON, latLng } from "leaflet"
-
-export const bboxToBounds = (bbox) => {
-  bbox = bbox.split(" ")
-  if (bbox.length === 4) {
-    return latLngBounds([
-      [parseFloat(bbox[1]), parseFloat(bbox[0])],
-      [parseFloat(bbox[3]), parseFloat(bbox[2])],
-    ])
-  } else {
-    throw new Error("Invalid bounding box string")
-  }
-}
-
-export const boundsToBbox = (bounds) => {
-  let sw = bounds.getSouthWest(),
-    ne = bounds.getNorthEast()
-
-  if (ne.lng - sw.lng >= 360) {
-    sw.lng = -180
-    ne.lng = 180
-  }
-  sw = sw.wrap()
-  ne = ne.wrap()
-  return [Util.formatNum(sw.lng, 6), Util.formatNum(sw.lat, 6), Util.formatNum(ne.lng, 6), Util.formatNum(ne.lat, 6)]
-}
-
-export const geoJSONToBounds = (geojson) => {
-  const layer = geoJSON(geojson)
-  return layer.getBounds()
-}
-
-export const debounce = (fn, delay) => {
-  let timeout = null
-  return function (...args) {
-    clearTimeout(timeout)
-    timeout = setTimeout(() => {
-      fn.apply(this, args)
-    }, delay)
-  }
-}
-
-export const getTileJsonBounds = (doc) => {
-  const bounds = doc.bounds
-  if (bounds) {
-    const corner1 = latLng(bounds[1], bounds[0]),
-      corner2 = latLng(bounds[3], bounds[2])
-    return latLngBounds(corner1, corner2)
-  }
-}
-
-export const getInspectingText = () =>
-  document.getElementById("attribute-table")?.dataset.inspectingText || "Inspecting"
-
-export const getNotFoundText = () =>
-  document.getElementById("attribute-table")?.dataset.notFoundText || "Could not find that feature"
-
-export const appendLoadingMessage = () => {
-  const spinner = `<tbody class="attribute-table-body"><tr><td colspan="2">
-    <span id="attribute-table">
-    <div class="spinner-border" role="status"><span class="visually-hidden">${getInspectingText()}</span></div>
-    </span>
-    </td></tr></tbody>`
-
-  document.querySelector(".attribute-table-body").innerHTML = spinner
-}
-
-export const appendErrorMessage = () => {
-  document.querySelector(".attribute-table-body").innerHTML = `<tbody class="attribute-table-body">
-    <tr><td colspan="2">${getNotFoundText()}</td></tr></tbody>`
-}
-
-// Looks for strings that could be URLs and wraps them in <a> tags
-export const linkify = (str) => {
-  if (!str) return ""
-  const urlRegEx =
-    /((([A-Za-z]{3,9}:(?:\/\/)?)(?:[\-;:&=\+\$,\w]+@)?[A-Za-z0-9\.\-]+|(?:www\.|[\-;:&=\+\$,\w]+@)[A-Za-z0-9\.\-]+)((?:\/[\+~%\/\.\w\-]*)?\??(?:[\-\+=&;%@\.\w]*)#?(?:[\.\!\/\\\w]*))?)/g
-  return str.toString().replace(urlRegEx, "<a href='$1'>$1</a>")
-}
-
-export const getLayerOpacity = (layer) => {
-  return layer.options.fillOpacity ? layer.options.fillOpacity : layer.options.opacity
-}

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

@@ -1,55 +0,0 @@
-export default {
-  dark_matter: {
-    url: "https://{a-d}.basemaps.cartocdn.com/dark_all/{z}/{x}/{y}.png",
-    attributions:
-      '&copy; <a href="http://www.openstreetmap.org/copyright">OpenStreetMap</a> contributors, &copy; <a href="http://carto.com/attributionss">Carto</a>',
-    maxZoom: 18,
-  },
-  positron: {
-    url: "https://{a-d}.basemaps.cartocdn.com/light_all/{z}/{x}/{y}.png",
-    attributions:
-      '&copy; <a href="http://www.openstreetmap.org/copyright">OpenStreetMap</a> contributors, &copy; <a href="http://carto.com/attributionss">Carto</a>',
-    maxZoom: 18,
-  },
-  positron_lite: {
-    url: "https://{a-d}.basemaps.cartocdn.com/light_nolabels/{z}/{x}/{y}.png",
-    attributions:
-      '&copy; <a href="http://www.openstreetmap.org/copyright">OpenStreetMap</a> contributors, &copy; <a href="http://carto.com/attributionss">Carto</a>',
-    maxZoom: 18,
-  },
-  world_antique: {
-    url: "https://cartocdn_{a-d}.global.ssl.fastly.net/base-antique/{z}/{x}/{y}.png",
-    attributions:
-      '&copy; <a href="http://www.openstreetmap.org/copyright">OpenStreetMap</a> contributors, &copy; <a href="http://carto.com/attributionss">Carto</a>',
-    maxZoom: 18,
-  },
-  world_eco: {
-    url: "https://cartocdn_{a-d}.global.ssl.fastly.net/base-eco/{z}/{x}/{y}.png",
-    attributions:
-      '&copy; <a href="http://www.openstreetmap.org/copyright">OpenStreetMap</a> contributors, &copy; <a href="http://carto.com/attributionss">Carto</a>',
-    maxZoom: 18,
-  },
-  flat_blue: {
-    url: "https://cartocdn_{a-d}.global.ssl.fastly.net/base-flatblue/{z}/{x}/{y}.png",
-    attributions:
-      '&copy; <a href="http://www.openstreetmap.org/copyright">OpenStreetMap</a> contributors, &copy; <a href="http://carto.com/attributionss">Carto</a>',
-    maxZoom: 18,
-  },
-  midnight_commander: {
-    url: "https://cartocdn_{a-d}.global.ssl.fastly.net/base-midnight/{z}/{x}/{y}.png",
-    attributions:
-      '&copy; <a href="http://www.openstreetmap.org/copyright">OpenStreetMap</a> contributors, &copy; <a href="http://carto.com/attributionss">Carto</a>',
-    maxZoom: 18,
-  },
-  openstreetmap_hot: {
-    url: "https://{a-c}.tile.openstreetmap.fr/hot/{z}/{x}/{y}.png",
-    attributions:
-      '&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,
-  },
-  openstreetmap_standard: {
-    url: "https://tile.openstreetmap.org/{z}/{x}/{y}.png",
-    attributions: '&copy; <a href="http://www.openstreetmap.org/copyright">OpenStreetMap</a> contributors',
-    maxZoom: 19,
-  },
-}

data/app/javascript/geoblacklight/openlayers/inspection.js

@@ -1,42 +0,0 @@
-import { getInspectingText, getNotFoundText, linkify } from "geoblacklight/leaflet/utils"
-
-export const pmTilesInspection = (map) => {
-  // add crosshair class for map items
-  map.on("pointermove", function (e) {
-    var pixel = map.getEventPixel(e.originalEvent)
-    var hit = map.hasFeatureAtPixel(pixel)
-    map.getViewport().style.cursor = hit ? "crosshair" : ""
-  })
-
-  map.on("click", (event) => {
-    const spinner = document.createElement("tbody")
-    spinner.className = "attribute-table-body"
-    spinner.innerHTML = `<tr><td colspan="2"><div class="spinner-border" role="status"><span class="visually-hidden">${getInspectingText()}</span></div></td></tr>`
-    document.querySelector(".attribute-table-body").replaceWith(spinner)
-
-    const features = map.getFeaturesAtPixel(event.pixel)
-    if (features.length == 0) {
-      document.querySelector(".attribute-table-body").innerHTML = `<tr><td colspan="2">${getNotFoundText()}</td></tr>`
-      return
-    }
-
-    const properties = features[0].getProperties()
-    populateAttributeTable(properties)
-  })
-}
-
-const populateAttributeTable = (properties) => {
-  let html = '<tbody class="attribute-table-body">'
-
-  // Step through properties and append to table
-  Object.keys(properties).forEach((property) => {
-    html += `<tr><td>${property}</td>
-               <td>${linkify(properties[property])}</td></tr>`
-  })
-  html += "</tbody>"
-
-  const tableBody = document.querySelector(".attribute-table-body")
-  if (tableBody) {
-    tableBody.outerHTML = html // Replace existing table body with new content
-  }
-}

data/app/javascript/geoblacklight/openlayers/layers.js

@@ -1,44 +0,0 @@
-import VectorTile from "ol/layer/VectorTile"
-import { Style, Stroke, Fill, Circle } from "ol/style"
-import { PMTilesVectorSource } from "ol-pmtiles"
-import { useGeographic } from "ol/proj"
-import GeoTIFF from "ol/source/GeoTIFF"
-import WebGLTileLayer from "ol/layer/WebGLTile"
-
-// Create a new PMTiles layer
-export const pmTilesLayer = (url) => {
-  useGeographic()
-  return new VectorTile({
-    declutter: true,
-    source: new PMTilesVectorSource({ url }),
-    style: new Style({
-      stroke: new Stroke({
-        color: "#7070B3",
-        width: 1,
-      }),
-      fill: new Fill({
-        color: "#FFFFFF",
-      }),
-      image: new Circle({
-        radius: 7,
-        fill: new Fill({
-          color: "#7070B3",
-        }),
-        stroke: new Stroke({
-          color: "#FFFFFF",
-          width: 2,
-        }),
-      }),
-    }),
-  })
-}
-
-// Create a new cloud-optimized GeoTIFF (COG) layer
-export const cogLayer = (url) => {
-  return new WebGLTileLayer({
-    source: new GeoTIFF({
-      sources: [{ url }],
-      convertToRGB: true,
-    }),
-  })
-}

data/app/views/relation/index.json.jbuilder

@@ -1,8 +0,0 @@
-# frozen_string_literal: true
-
-json.current_doc @relations.search_id
-json.relations do
-  Geoblacklight.configuration.relationships_shown.each do |key, _value|
-    json.set! key.downcase.to_s, @relations.public_send(key) unless @relations.public_send(key)["numFound"].to_i.zero?
-  end
-end

data/lib/geoblacklight/configuration/layer_config.rb

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-module Geoblacklight
-  class Configuration
-    # Configuration for Leaflet map layer styles.
-    class LayerConfig
-      include ActiveModel::Model
-      include ActiveModel::Attributes
-
-      attribute :color, :string
-      attribute :weight, :integer, default: 1
-      attribute :radius, :integer, default: 4
-      attribute :sr_color_name, :string
-
-      # Supports Hash-like access for backward compatibility
-      # @param [Symbol, String] key
-      def [](key)
-        respond_to?(key) ? send(key) : nil
-      end
-
-      # Returns the attributes as a symbolized hash
-      # @return [Hash]
-      def to_h
-        attributes.symbolize_keys
-      end
-    end
-  end
-end

data/lib/geoblacklight/configuration/leaflet_config.rb

@@ -1,73 +0,0 @@
-# frozen_string_literal: true
-
-module Geoblacklight
-  class Configuration
-    class LeafletConfig
-      include ActiveModel::Model
-      include ActiveModel::Attributes
-
-      attr_accessor :bounds_overlay, :controls
-
-      attr_reader :sleep, :layers
-
-      # set to false to display attribute table as a separate panel below the map
-      attribute :sidebar, :boolean, default: true
-      attribute :selected_color, :string, default: "#2C7FB8"
-
-      DEFAULT_SLEEP_CONFIG = {
-        sleep: true, # set to false to disable
-        margin_distance: 100, # set to zero / false if you want to disable this check
-        sleeptime: 750,
-        waketime: 750,
-        hovertowake: false,
-        background: "rgba(214, 214, 214, .7)"
-      }.freeze
-
-      # Built lazily (rather than as a frozen constant) so the sr_color_name
-      # values pick up the current I18n locale each time a config is built.
-      def self.default_layers_config
-        {
-          index: {
-            DEFAULT: LayerConfig.new(
-              color: "#7FCDBB",
-              sr_color_name: I18n.t("geoblacklight.map.legend.colors.default")
-            ),
-            UNAVAILABLE: LayerConfig.new(
-              color: "#EDF8B1",
-              sr_color_name: I18n.t("geoblacklight.map.legend.colors.unavailable")
-            ),
-            SELECTED: LayerConfig.new(
-              color: "#2C7FB8",
-              sr_color_name: I18n.t("geoblacklight.map.legend.colors.selected")
-            )
-          }
-        }
-      end
-
-      def initialize
-        super
-        @sleep = LeafletSleepConfig.new(DEFAULT_SLEEP_CONFIG)
-        @layers = LeafletLayersConfig.new(self.class.default_layers_config)
-      end
-
-      def sleep=(attributes)
-        @sleep = LeafletSleepConfig.new(attributes)
-      end
-
-      def layers=(attributes)
-        @layers = LeafletLayersConfig.new(attributes)
-      end
-
-      def to_h
-        {
-          bounds_overlay: bounds_overlay,
-          selected_color: selected_color,
-          sleep: sleep.to_h,
-          sidebar: sidebar,
-          layers: layers.to_h,
-          controls: controls
-        }.compact
-      end
-    end
-  end
-end