@defra/interactive-map 0.0.30-alpha → 0.0.32-alpha

package/plugins/beta/datasets/src/adapters/maplibre/layerIds.js

@@ -1,75 +0,0 @@
-import { hasPattern } from '../../../../../../src/utils/patternUtils.js'
-
-// ─── Internal helpers ─────────────────────────────────────────────────────────
-
-const hasSymbol = (dataset) => !!dataset.symbol
-
-export const isDynamicSource = (dataset) =>
-  typeof dataset.geojson === 'string' &&
-  !!dataset.idProperty &&
-  typeof dataset.transformRequest === 'function'
-
-const HASH_BASE = 36
-const MAX_TILE_ZOOM = 22
-
-export { MAX_TILE_ZOOM }
-
-export const hashString = (str) => {
-  let hash = 0
-  for (const ch of str) {
-    hash = Math.trunc(((hash << 5) - hash) + ch.codePointAt(0))
-  }
-  return Math.abs(hash).toString(HASH_BASE)
-}
-
-// ─── Source ID ────────────────────────────────────────────────────────────────
-
-export const getSourceId = (dataset) => {
-  if (dataset.tiles) {
-    const tilesKey = Array.isArray(dataset.tiles) ? dataset.tiles.join(',') : dataset.tiles
-    return `tiles-${hashString(tilesKey)}`
-  }
-  if (dataset.geojson) {
-    if (isDynamicSource(dataset)) {
-      return `geojson-dynamic-${dataset.id}`
-    }
-    if (typeof dataset.geojson === 'string') {
-      return `geojson-${hashString(dataset.geojson)}`
-    }
-    return `geojson-${dataset.id}`
-  }
-  return `source-${dataset.id}`
-}
-
-// ─── Layer IDs ────────────────────────────────────────────────────────────────
-
-export const getLayerIds = (dataset) => {
-  if (hasSymbol(dataset)) {
-    return { fillLayerId: null, strokeLayerId: null, symbolLayerId: dataset.id }
-  }
-  const hasFill = (!!dataset.fill && dataset.fill !== 'transparent') || hasPattern(dataset)
-  const hasStroke = !!dataset.stroke
-  const fillLayerId = hasFill ? dataset.id : null
-  let strokeLayerId = null
-  if (hasStroke) {
-    strokeLayerId = hasFill ? `${dataset.id}-stroke` : dataset.id
-  }
-  return { fillLayerId, strokeLayerId, symbolLayerId: null }
-}
-
-export const getSublayerLayerIds = (datasetId, sublayerId) => ({
-  fillLayerId: `${datasetId}-${sublayerId}`,
-  strokeLayerId: `${datasetId}-${sublayerId}-stroke`,
-  symbolLayerId: `${datasetId}-${sublayerId}-symbol`
-})
-
-export const getAllLayerIds = (dataset) => {
-  if (dataset.sublayers?.length) {
-    return dataset.sublayers.flatMap(sublayer => {
-      const { fillLayerId, strokeLayerId, symbolLayerId } = getSublayerLayerIds(dataset.id, sublayer.id)
-      return [strokeLayerId, fillLayerId, symbolLayerId]
-    })
-  }
-  const { fillLayerId, strokeLayerId, symbolLayerId } = getLayerIds(dataset)
-  return [strokeLayerId, fillLayerId, symbolLayerId].filter(Boolean)
-}

package/plugins/beta/datasets/src/adapters/maplibre/patternImages.js

@@ -1,27 +0,0 @@
-// Re-export pure pattern utilities from core — no map engine dependency.
-import { hasPattern } from '../../../../../../src/utils/patternUtils.js'
-import { mergeSublayer } from '../../utils/mergeSublayer.js'
-
-export { hasPattern } from '../../../../../../src/utils/patternUtils.js'
-
-/**
- * Returns a flat list of datasets and merged sublayers that require pattern images.
- * Handles sublayer merging so callers (e.g. mapProvider.addPatternsToMap) receive ready-to-use configs.
- *
- * @param {Object[]} datasets
- * @param {Object} patternRegistry
- * @returns {Object[]}
- */
-export const getPatternConfigs = (datasets, patternRegistry) =>
-  datasets.flatMap(dataset => {
-    const configs = hasPattern(dataset) ? [dataset] : []
-    if (dataset.sublayers?.length) {
-      dataset.sublayers.forEach(sublayer => {
-        const merged = mergeSublayer(dataset, sublayer)
-        if (hasPattern(merged)) {
-          configs.push(merged)
-        }
-      })
-    }
-    return configs
-  })

package/plugins/beta/datasets/src/adapters/maplibre/symbolImages.js

@@ -1,31 +0,0 @@
-// Re-export pure symbol resolution utilities from core — no map engine dependency.
-import { hasSymbol } from '../../../../../../src/utils/symbolUtils.js'
-import { mergeSublayer } from '../../utils/mergeSublayer.js'
-
-export { hasSymbol, getSymbolStyleColors, getSymbolViewBox, getSymbolAnchor } from '../../../../../../src/utils/symbolUtils.js'
-
-// Re-export MapLibre-specific symbol utilities from the provider.
-// This is the single cross-boundary import in the adapter; in a separate-package
-// setup this would be: '@interactive-map/maplibre-provider/utils/symbolImages'
-export { anchorToMaplibre } from '../../../../../../providers/maplibre/src/utils/symbolImages.js'
-
-/**
- * Returns a flat list of datasets and merged sublayers that require symbol images.
- * Handles sublayer merging so callers (e.g. mapProvider.addSymbolsToMap) receive ready-to-use configs.
- *
- * @param {Object[]} datasets
- * @returns {Object[]}
- */
-export const getSymbolConfigs = (datasets) =>
-  datasets.flatMap(dataset => {
-    const configs = hasSymbol(dataset) ? [dataset] : []
-    if (dataset.sublayers?.length) {
-      dataset.sublayers.forEach(sublayer => {
-        const merged = mergeSublayer(dataset, sublayer)
-        if (hasSymbol(merged)) {
-          configs.push(merged)
-        }
-      })
-    }
-    return configs
-  })

package/plugins/beta/datasets/src/components/KeySvg.jsx

@@ -1,24 +0,0 @@
-import { hasSymbol } from '../../../../../src/utils/symbolUtils.js'
-import { hasPattern } from '../../../../../src/utils/patternUtils.js'
-import { KeySvgPattern } from './KeySvgPattern.jsx'
-import { KeySvgSymbol } from './KeySvgSymbol.jsx'
-import { KeySvgLine } from './KeySvgLine.jsx'
-import { KeySvgRect } from './KeySvgRect.jsx'
-
-export const KeySvg = (props) => {
-  const { symbolRegistry } = props
-  const symbolDef = hasSymbol(props) && symbolRegistry.getSymbolDef(props)
-  if (symbolDef) {
-    return <KeySvgSymbol {...props} symbolDef={symbolDef} />
-  }
-
-  if (hasPattern(props)) {
-    return <KeySvgPattern {...props} />
-  }
-
-  if (props.keySymbolShape === 'line') {
-    return <KeySvgLine {...props} />
-  }
-
-  return <KeySvgRect {...props} />
-}

package/plugins/beta/datasets/src/components/KeySvgLine.jsx

@@ -1,19 +0,0 @@
-import { svgProps, SVG_SIZE, SVG_CENTER } from './svgProperties.js'
-import { getValueForStyle } from '../../../../../src/utils/getValueForStyle'
-
-export const KeySvgLine = (props) => {
-  const { mapStyle } = props
-  return (
-    <svg {...svgProps}>
-      <line
-        x1={props.strokeWidth / 2}
-        y1={SVG_CENTER}
-        x2={SVG_SIZE - props.strokeWidth / 2}
-        y2={SVG_CENTER}
-        stroke={getValueForStyle(props.stroke, mapStyle.id)}
-        strokeWidth={props.strokeWidth}
-        strokeLinecap='round'
-      />
-    </svg>
-  )
-}

package/plugins/beta/datasets/src/components/KeySvgRect.jsx

@@ -1,22 +0,0 @@
-import { getValueForStyle } from '../../../../../src/utils/getValueForStyle'
-import { svgProps, SVG_SIZE } from './svgProperties.js'
-
-export const KeySvgRect = (props) => {
-  const { mapStyle } = props
-  return (
-    <svg {...svgProps}>
-      <rect
-        x={props.strokeWidth / 2}
-        y={props.strokeWidth / 2}
-        width={SVG_SIZE - props.strokeWidth}
-        height={SVG_SIZE - props.strokeWidth}
-        rx={props.strokeWidth}
-        ry={props.strokeWidth}
-        fill={getValueForStyle(props.fill, mapStyle.id)}
-        stroke={getValueForStyle(props.stroke, mapStyle.id)}
-        strokeWidth={props.strokeWidth}
-        strokeLinejoin='round'
-      />
-    </svg>
-  )
-}

package/plugins/beta/datasets/src/index.maplibre.umd.js

@@ -1,23 +0,0 @@
-import createDatasetsPlugin from './index.js'
-
-/**
- * Combined datasets plugin + MapLibre layer adapter for UMD consumers.
- *
- * Bakes the MapLibre adapter in so UMD users need a single script tag and no
- * layerAdapter config. The adapter is still loaded lazily — it is only fetched
- * when the datasets plugin initialises, not on page load.
- *
- * Both the manifest and adapter chunks are in the same webpack compilation so
- * cross-runtime module resolution issues are avoided.
- *
- * @example
- * const plugin = defra.datasetsMaplibrePlugin({ datasets: [...] })
- */
-export default function createDatasetsMaplibrePlugin (options = {}) {
-  return createDatasetsPlugin({
-    ...options,
-    layerAdapter: {
-      load: () => import(/* webpackChunkName: "im-datasets-maplibre-adapter" */ './adapters/maplibre/maplibreLayerAdapter.js')
-    }
-  })
-}

package/plugins/beta/datasets/src/panels/Key.jsx

@@ -1,62 +0,0 @@
-import React from 'react'
-import { getValueForStyle } from '../../../../../src/utils/getValueForStyle'
-import { mergeSublayer } from '../utils/mergeSublayer.js'
-import { EmptyKey } from '../components/EmptyKey.jsx'
-import { KeySvg } from '../components/KeySvg.jsx'
-
-export const Key = ({ pluginConfig, mapState, pluginState, services }) => {
-  if (!pluginState?.key?.items?.length) {
-    return (<EmptyKey text={pluginConfig.noKeyItemText} />)
-  }
-  const { mapStyle } = mapState
-  const { symbolRegistry, patternRegistry } = services
-
-  const renderEntry = (key, config) => (
-    <dl key={key} className='im-c-datasets-key__item'>
-      <dt className='im-c-datasets-key__item-symbol'>
-        <KeySvg {...config} symbolRegistry={symbolRegistry} patternRegistry={patternRegistry} mapStyle={mapStyle} />
-      </dt>
-      <dd className='im-c-datasets-key__item-label'>
-        {config.label}
-        {config.symbolDescription && (
-          <span className='govuk-visually-hidden'>
-            ({getValueForStyle(config.symbolDescription, mapStyle.id)})
-          </span>
-        )}
-      </dd>
-    </dl>
-  )
-
-  const { items: keyGroups, hasGroups } = pluginState.key
-  const containerClass = `im-c-datasets-key${hasGroups ? ' im-c-datasets-key--has-groups' : ''}`
-
-  return (
-    <div className={containerClass}>
-      {keyGroups.map(item => {
-        if (item.type === 'sublayers') {
-          const headingId = `key-heading-${item.dataset.id}`
-          return (
-            <section key={item.dataset.id} className='im-c-datasets-key__group' aria-labelledby={headingId}>
-              <h3 id={headingId} className='im-c-datasets-key__group-heading'>{item.dataset.label}</h3>
-              {item.dataset.sublayers
-                .filter(sublayer => item.dataset.sublayerVisibility?.[sublayer.id] !== 'hidden')
-                .map(sublayer => renderEntry(`${item.dataset.id}-${sublayer.id}`, mergeSublayer(item.dataset, sublayer)))}
-            </section>
-          )
-        }
-
-        if (item.type === 'group') {
-          const headingId = `key-heading-${item.groupLabel.toLowerCase().replaceAll(/\s+/g, '-')}`
-          return (
-            <section key={item.groupLabel} className='im-c-datasets-key__group' aria-labelledby={headingId}>
-              <h3 id={headingId} className='im-c-datasets-key__group-heading'>{item.groupLabel}</h3>
-              {item.datasets.map(dataset => renderEntry(dataset.id, dataset))}
-            </section>
-          )
-        }
-
-        return renderEntry(item.dataset.id, item.dataset)
-      })}
-    </div>
-  )
-}

package/plugins/beta/datasets/src/panels/Layers.jsx

@@ -1,141 +0,0 @@
-import React from 'react'
-import { setDatasetVisibility } from '../api/setDatasetVisibility'
-
-const CHECKBOX_LABEL_CLASS = 'im-c-datasets-layers__item-label govuk-label govuk-checkboxes__label'
-
-const hasToggleableSublayers = (dataset) => dataset.sublayers?.some(sublayer => sublayer.showInMenu)
-
-/**
- * Collapse the filtered dataset list into ordered render items:
- *   { type: 'sublayers', dataset }              — dataset with sublayers (takes precedence)
- *   { type: 'group', groupLabel, datasets } — datasets sharing a groupLabel
- *   { type: 'flat', dataset }               — standalone dataset
- */
-const buildRenderItems = (datasets) => {
-  const seenGroups = new Set()
-  const items = []
-  datasets.forEach(dataset => {
-    if (hasToggleableSublayers(dataset)) {
-      items.push({ type: 'sublayers', dataset })
-      return
-    }
-    if (dataset.groupLabel) {
-      if (seenGroups.has(dataset.groupLabel)) {
-        return
-      }
-      seenGroups.add(dataset.groupLabel)
-      items.push({
-        type: 'group',
-        groupLabel: dataset.groupLabel,
-        datasets: datasets.filter(d => !hasToggleableSublayers(d) && d.groupLabel === dataset.groupLabel)
-      })
-      return
-    }
-    items.push({ type: 'flat', dataset })
-  })
-  return items
-}
-
-export const Layers = ({ pluginState }) => {
-  const handleDatasetChange = (e) => {
-    const { value, checked } = e.target
-    setDatasetVisibility({ pluginState }, checked, { datasetId: value })
-  }
-
-  const handleSublayerChange = (e) => {
-    const { checked } = e.target
-    const datasetId = e.target.dataset.datasetId
-    const sublayerId = e.target.dataset.sublayerId
-    setDatasetVisibility({ pluginState }, checked, { datasetId, sublayerId })
-  }
-
-  const renderDatasetItem = (dataset) => {
-    const itemClass = `im-c-datasets-layers__item govuk-checkboxes govuk-checkboxes--small${dataset.visibility === 'hidden' ? '' : ' im-c-datasets-layers__item--checked'}`
-    return (
-      <div key={dataset.id} className={itemClass} data-module='govuk-checkboxes'>
-        <div className='govuk-checkboxes__item'>
-          <input
-            className='govuk-checkboxes__input'
-            id={dataset.id}
-            name='layers'
-            type='checkbox'
-            value={dataset.id}
-            checked={dataset.visibility !== 'hidden'}
-            onChange={handleDatasetChange}
-          />
-          <label className={CHECKBOX_LABEL_CLASS} htmlFor={dataset.id}>
-            {dataset.label}
-          </label>
-        </div>
-      </div>
-    )
-  }
-
-  const visibleDatasets = (pluginState.datasets || [])
-    .filter(dataset => dataset.showInMenu || hasToggleableSublayers(dataset))
-
-  const renderItems = buildRenderItems(visibleDatasets)
-  const hasGroups = renderItems.some(item => item.type === 'sublayers' || item.type === 'group')
-  const containerClass = `im-c-datasets-layers${hasGroups ? ' im-c-datasets-layers--has-groups' : ''}`
-
-  return (
-    <div className={containerClass}>
-      {renderItems.map(item => {
-        if (item.type === 'sublayers') {
-          const { dataset } = item
-          const anySublayerChecked = dataset.sublayers
-            .filter(sublayer => sublayer.showInMenu)
-            .some(sublayer => dataset.sublayerVisibility?.[sublayer.id] !== 'hidden')
-          const wrapperClass = `govuk-form-group im-c-datasets-layers-group${anySublayerChecked ? ' im-c-datasets-layers-group--items-checked' : ''}`
-          return (
-            <div key={dataset.id} className={wrapperClass}>
-              <fieldset className='im-c-datasets-layers-group__fieldset'>
-                <legend className='im-c-datasets-layers-group__legend'>{dataset.label}</legend>
-                {dataset.sublayers
-                  .filter(sublayer => sublayer.showInMenu)
-                  .map(sublayer => {
-                    const sublayerVisible = dataset.sublayerVisibility?.[sublayer.id] !== 'hidden'
-                    const inputId = `${dataset.id}-${sublayer.id}`
-                    const itemClass = `im-c-datasets-layers__item govuk-checkboxes govuk-checkboxes--small${sublayerVisible ? ' im-c-datasets-layers__item--checked' : ''}`
-                    return (
-                      <div key={sublayer.id} className={itemClass} data-module='govuk-checkboxes'>
-                        <div className='govuk-checkboxes__item'>
-                          <input
-                            className='govuk-checkboxes__input'
-                            id={inputId}
-                            type='checkbox'
-                            checked={sublayerVisible}
-                            data-dataset-id={dataset.id}
-                            data-sublayer-id={sublayer.id}
-                            onChange={handleSublayerChange}
-                          />
-                          <label className={CHECKBOX_LABEL_CLASS} htmlFor={inputId}>
-                            {sublayer.label}
-                          </label>
-                        </div>
-                      </div>
-                    )
-                  })}
-              </fieldset>
-            </div>
-          )
-        }
-
-        if (item.type === 'group') {
-          const anyDatasetChecked = item.datasets.some(d => d.visibility !== 'hidden')
-          const wrapperClass = `govuk-form-group im-c-datasets-layers-group${anyDatasetChecked ? ' im-c-datasets-layers-group--items-checked' : ''}`
-          return (
-            <div key={item.groupLabel} className={wrapperClass}>
-              <fieldset className='im-c-datasets-layers-group__fieldset'>
-                <legend className='im-c-datasets-layers-group__legend'>{item.groupLabel}</legend>
-                {item.datasets.map(dataset => renderDatasetItem(dataset))}
-              </fieldset>
-            </div>
-          )
-        }
-
-        return renderDatasetItem(item.dataset)
-      })}
-    </div>
-  )
-}

package/plugins/beta/datasets/src/reducer.js

@@ -1,219 +0,0 @@
-import { applyDatasetDefaults } from './defaults.js'
-import { keyReducer } from './reducers/keyReducer.js'
-
-const initialState = {
-  datasets: null,
-  key: {
-    items: [],
-    hasGroups: false
-  },
-  hiddenFeatures: {}, // { [layerId]: { idProperty: string, ids: string[] } }
-  layerAdapter: null
-}
-
-const initSublayerVisibility = (dataset) => {
-  if (!dataset.sublayers?.length) {
-    return dataset
-  }
-  const sublayerVisibility = {}
-  dataset.sublayers.forEach(sublayer => {
-    sublayerVisibility[sublayer.id] = 'visible'
-  })
-  return { ...dataset, sublayerVisibility }
-}
-
-const setDatasets = (state, payload) => {
-  const { datasets, datasetDefaults } = payload
-  return {
-    ...state,
-    datasets: datasets.map(dataset => initSublayerVisibility(applyDatasetDefaults(dataset, datasetDefaults)))
-  }
-}
-
-const addDataset = (state, payload) => {
-  const { dataset, datasetDefaults } = payload
-  return {
-    ...state,
-    datasets: [
-      ...(state.datasets || []),
-      initSublayerVisibility(applyDatasetDefaults(dataset, datasetDefaults))
-    ]
-  }
-}
-
-const removeDataset = (state, payload) => {
-  const { id } = payload
-  return {
-    ...state,
-    datasets: state.datasets?.filter(dataset => dataset.id !== id) || []
-  }
-}
-
-const setDatasetVisibility = (state, payload) => {
-  const { id, visibility } = payload
-  return {
-    ...state,
-    datasets: state.datasets?.map(dataset =>
-      dataset.id === id ? { ...dataset, visibility } : dataset
-    )
-  }
-}
-
-const setGlobalVisibility = (state, payload) => {
-  const { visibility } = payload
-  return {
-    ...state,
-    datasets: state.datasets?.map(dataset => ({ ...dataset, visibility }))
-  }
-}
-
-const hideFeatures = (state, payload) => {
-  const { layerId, idProperty, featureIds } = payload
-  const existing = state.hiddenFeatures[layerId]
-  const existingIds = existing?.ids || []
-  const newIds = [...new Set([...existingIds, ...featureIds])]
-
-  return {
-    ...state,
-    hiddenFeatures: {
-      ...state.hiddenFeatures,
-      [layerId]: { idProperty, ids: newIds }
-    }
-  }
-}
-
-const showFeatures = (state, payload) => {
-  const { layerId, featureIds } = payload
-  const existing = state.hiddenFeatures[layerId]
-  if (!existing) {
-    return state
-  }
-
-  const newIds = existing.ids.filter(id => !featureIds.includes(id))
-
-  if (newIds.length === 0) {
-    const rest = { ...state.hiddenFeatures }
-    delete rest[layerId]
-    return { ...state, hiddenFeatures: rest }
-  }
-
-  return {
-    ...state,
-    hiddenFeatures: {
-      ...state.hiddenFeatures,
-      [layerId]: { ...existing, ids: newIds }
-    }
-  }
-}
-
-const setSublayerVisibility = (state, payload) => {
-  const { datasetId, sublayerId, visibility } = payload
-  return {
-    ...state,
-    datasets: state.datasets?.map(dataset => {
-      if (dataset.id !== datasetId) {
-        return dataset
-      }
-      return {
-        ...dataset,
-        sublayerVisibility: {
-          ...dataset.sublayerVisibility,
-          [sublayerId]: visibility
-        }
-      }
-    })
-  }
-}
-
-const setDatasetStyle = (state, payload) => {
-  const { datasetId, styleChanges } = payload
-  return {
-    ...state,
-    datasets: state.datasets?.map(dataset =>
-      dataset.id === datasetId ? { ...dataset, ...styleChanges } : dataset
-    )
-  }
-}
-
-const setSublayerStyle = (state, payload) => {
-  const { datasetId, sublayerId, styleChanges } = payload
-  return {
-    ...state,
-    datasets: state.datasets?.map(dataset => {
-      if (dataset.id !== datasetId) {
-        return dataset
-      }
-      return {
-        ...dataset,
-        sublayers: dataset.sublayers?.map(sublayer =>
-          sublayer.id === sublayerId
-            ? { ...sublayer, style: { ...sublayer.style, ...styleChanges } }
-            : sublayer
-        )
-      }
-    })
-  }
-}
-
-const setOpacity = (state, payload) => {
-  const { datasetId, opacity } = payload
-  return {
-    ...state,
-    datasets: state.datasets?.map(dataset =>
-      dataset.id === datasetId ? { ...dataset, opacity } : dataset
-    )
-  }
-}
-
-const setGlobalOpacity = (state, payload) => {
-  const { opacity } = payload
-  return {
-    ...state,
-    datasets: state.datasets?.map(dataset => ({ ...dataset, opacity }))
-  }
-}
-
-const setSublayerOpacity = (state, payload) => {
-  const { datasetId, sublayerId, opacity } = payload
-  return {
-    ...state,
-    datasets: state.datasets?.map(dataset => {
-      if (dataset.id !== datasetId) {
-        return dataset
-      }
-      return {
-        ...dataset,
-        sublayers: dataset.sublayers?.map(sublayer =>
-          sublayer.id === sublayerId
-            ? { ...sublayer, style: { ...sublayer.style, opacity } }
-            : sublayer
-        )
-      }
-    })
-  }
-}
-
-const setLayerAdapter = (state, payload) => ({ ...state, layerAdapter: payload })
-
-const actions = {
-  BUILD_KEY_GROUPS: keyReducer,
-  SET_DATASETS: setDatasets,
-  ADD_DATASET: addDataset,
-  REMOVE_DATASET: removeDataset,
-  SET_DATASET_VISIBILITY: setDatasetVisibility,
-  SET_GLOBAL_VISIBILITY: setGlobalVisibility,
-  SET_SUBLAYER_VISIBILITY: setSublayerVisibility,
-  SET_DATASET_STYLE: setDatasetStyle,
-  SET_SUBLAYER_STYLE: setSublayerStyle,
-  SET_OPACITY: setOpacity,
-  SET_GLOBAL_OPACITY: setGlobalOpacity,
-  SET_SUBLAYER_OPACITY: setSublayerOpacity,
-  HIDE_FEATURES: hideFeatures,
-  SHOW_FEATURES: showFeatures,
-  SET_LAYER_ADAPTER: setLayerAdapter
-}
-
-export {
-  initialState,
-  actions
-}

package/plugins/beta/datasets/src/reducers/keyReducer.js

@@ -1,34 +0,0 @@
-export const keyReducer = (state) => {
-  const datasets = state.datasets || []
-  const seenGroups = new Set()
-  const items = []
-  let hasGroups = false
-  datasets.forEach(dataset => {
-    if (!dataset.showInKey || dataset.visibility === 'hidden') {
-      return
-    }
-    if (dataset.sublayers?.length) {
-      const { sublayerVisibility = [] } = dataset
-      if (Object.values(sublayerVisibility).some((value) => value !== 'hidden')) {
-        hasGroups = true
-        items.push({ type: 'sublayers', dataset })
-      }
-      return
-    }
-    if (dataset.groupLabel) {
-      if (seenGroups.has(dataset.groupLabel)) {
-        return
-      }
-      seenGroups.add(dataset.groupLabel)
-      hasGroups = true
-      items.push({
-        type: 'group',
-        groupLabel: dataset.groupLabel,
-        datasets: datasets.filter(d => !d.sublayers?.length && d.groupLabel === dataset.groupLabel)
-      })
-      return
-    }
-    items.push({ type: 'flat', dataset })
-  })
-  return { ...state, key: { items, hasGroups } }
-}