Skip to content

Kepler.gl is a powerful open source geospatial analysis tool for large-scale data sets.

33.6 KB
Raw Blame
// SPDX-License-Identifier: MIT
// Copyright contributors to the kepler.gl project

// @ts-nocheck

import cloneDeep from 'es-toolkit/compat/cloneDeep';
import {colorPaletteToColorRange} from '@kepler.gl/constants';
import {
  getInitialInputStyle,
  keplerGlReducerCore as keplerGlReducer,
  syncTimeFilterWithLayerTimelineUpdater
} from '@kepler.gl/reducers';
import {
  KEPLER_COLOR_PALETTES,
  COMPARE_TYPES,
  DEFAULT_LAYER_OPACITY,
  DEFAULT_TEXT_LABEL,
  DEFAULT_COLOR_RANGE,
  DEFAULT_HIGHLIGHT_COLOR,
  DEFAULT_LAYER_LABEL
} from '@kepler.gl/constants';
import {DEFAULT_KEPLER_GL_PROPS, getUpdateVisDataPayload} from '@kepler.gl/components';
import {
  addDataToMap,
  VisStateActions,
  MapStateActions,
  MapStyleActions,
  UIStateActions,
  ProviderActions
} from '@kepler.gl/actions';

// fixtures
import {
  dataId as csvDataId,
  testFields,
  testAllData,
  testCsvDataSlice1,
  testCsvDataSlice1Id,
  testCsvDataSlice2,
  testCsvDataSlice2Id,
  syncTimeFilterValue
} from '../fixtures/test-csv-data';
import testLayerData from '../fixtures/test-layer-data';

import {fields, rows, geoJsonDataId} from '../fixtures/geojson';
import {
  fields as tripFields,
  rows as tripRows,
  config as tripConfig,
  dataId as tripDataId
} from '../fixtures/test-trip-data';
import tripCsvData, {
  tripCsvDataInfo,
  expectedTripLayerConfig
} from '../fixtures/test-trip-csv-data';
import testArcData, {arcDataInfo, config as arcDataConfig} from '../fixtures/test-arc-data';
import tripGeojson, {tripDataInfo} from '../fixtures/trip-geojson';
import {processCsvData, processGeojson, processRowObject} from '@kepler.gl/processors';
import {MOCK_MAP_STYLE} from './mock-map-styles';
import {
  applyActions,
  applyCreateTableTasks,
  applyExistingDatasetTasks,
  mockCreateNewDataEntry
} from './mock-state-utils';

export {applyActions, applyCreateTableTasks, applyExistingDatasetTasks, mockCreateNewDataEntry};

const geojsonFields = cloneDeep(fields);
const geojsonRows = cloneDeep(rows);
export const testCsvDataId = csvDataId;
export const testGeoJsonDataId = geoJsonDataId;

export const csvInfo = {
  id: testCsvDataId,
  label: 'hello.csv',
  queryType: 'file',
  queryOption: 'csv',
  params: {file: null}
};

export const geojsonInfo = {
  id: testGeoJsonDataId,
  label: 'zip.geojson',
  queryType: 'file',
  queryOption: 'geojson',
  params: {file: null}
};

export const mockColorRange = {
  colors: ['#FF000', '#00FF00', '#0000FF'],
  colorMap: [
    [1, '#FF0000'],
    [3, '#00FF00'],
    [5, '#0000FF']
  ],
  colorLegends: {
    '#FF0000': 'hello'
  }
};

// TODO: need to be deleted and imported from raw-states
export const InitialState = keplerGlReducer(undefined, {});

/**
 * Mock app state with uploaded geojson and csv file
 * @returns {Immutable} appState
 */
export function mockStateWithFileUpload() {
  const initialState = cloneDeep(InitialState);

  // load csv and geojson
  const updatedState = applyActions(keplerGlReducer, initialState, [
    {
      action: MapStyleActions.loadMapStyles,
      payload: [{dark: MOCK_MAP_STYLE}]
    },
    {
      action: VisStateActions.updateVisData,
      payload: [[{info: csvInfo, data: {fields: testFields, rows: testAllData}}]]
    },
    {
      action: VisStateActions.updateVisData,
      payload: [[{info: geojsonInfo, data: {fields: geojsonFields, rows: geojsonRows}}]]
    }
  ]);

  // replace layer id and color with controlled value for testing
  updatedState.visState.layers.forEach((l, i) => {
    const oldLayerId = l.id;
    l.id = `${l.type}-${i}`;
    l.config.color = [i, i, i];
    if (l.config.visConfig.strokeColor) {
      l.config.visConfig.strokeColor = [i + 10, i + 10, i + 10];
    }
    // update layerOrder with newly created IDs
    updatedState.visState.layerOrder = updatedState.visState.layerOrder.map(layerId =>
      layerId === oldLayerId ? l.id : layerId
    );
  });

  // Saved-map fixtures deliberately use a uniform GeoJSON fill, independent of defaults.
  return applyActions(keplerGlReducer, updatedState, [
    {
      action: VisStateActions.layerVisualChannelConfigChange,
      payload: [
        updatedState.visState.layers.find(layer => layer.type === 'geojson'),
        {colorField: null},
        'color'
      ]
    }
  ]);
}

function mockStateWithLayerCustomColorBreaksLegends() {
  const initialState = cloneDeep(InitialState);

  // load csv and geojson
  const updatedState = applyActions(keplerGlReducer, initialState, [
    {
      action: MapStyleActions.loadMapStyles,
      payload: [{dark: MOCK_MAP_STYLE}]
    },
    {
      action: addDataToMap,
      payload: [
        {
          datasets: [
            {
              info: csvInfo,
              data: {fields: testFields, rows: testAllData}
            }
          ],
          config: {
            version: 'v1',
            config: {
              visState: {
                layers: [
                  {
                    type: 'point',
                    id: 'point-layer-0',
                    config: {
                      dataId: csvInfo.id,
                      columns: {
                        lat: 'gps_data.lat',
                        lng: 'gps_data.lng'
                      },
                      color: [255, 0, 0],
                      label: 'pickup',
                      isVisible: true,
                      visConfig: {
                        colorRange: mockColorRange
                      }
                    },
                    visualChannels: {
                      colorField: {
                        name: 'uid',
                        type: 'integer'
                      },
                      colorScale: 'custom'
                    }
                  }
                ]
              }
            }
          }
        }
      ]
    }
  ]);

  return updatedState;
}

function mockStateWithSyncedTimeFilter() {
  const initialState = cloneDeep(InitialState);
  // load 2 csv data
  const updatedState = applyActions(keplerGlReducer, initialState, [
    {
      action: MapStyleActions.loadMapStyles,
      payload: [{dark: MOCK_MAP_STYLE}]
    },
    {
      action: VisStateActions.updateVisData,
      payload: [
        [
          {
            info: {
              id: testCsvDataSlice1Id,
              label: 'hello.csv',
              color: [255, 0, 0]
            },
            data: {fields: testFields, rows: testCsvDataSlice1}
          }
        ]
      ]
    },
    {
      action: VisStateActions.updateVisData,
      payload: [
        [
          {
            info: {
              id: testCsvDataSlice2Id,
              label: 'world.csv',
              color: [0, 255, 0]
            },
            data: {fields: testFields, rows: testCsvDataSlice2}
          }
        ]
      ]
    },
    // add 1 filter
    {action: VisStateActions.addFilter, payload: ['test-csv-data-1']},

    // set filter name to 'time', and value
    {
      action: VisStateActions.setFilter,
      // ['2016-09-17 00:11:56', '2016-09-17 00:21:17']
      payload: [0, ['name', 'value'], ['gps_data.utc_timestamp', [1474071116000, 1474071677000]]]
    },

    // set filter name and dataId and index 1
    {
      action: VisStateActions.setFilter,
      payload: [0, ['dataId', 'name'], ['test-csv-data-2', 'gps_data.utc_timestamp'], 1]
    },

    // set filter name to 'time', and value
    {
      action: VisStateActions.setFilter,
      // ['2016-09-17 00:11:56', '2016-09-17 00:21:17']
      payload: [0, ['value'], [syncTimeFilterValue]]
    }
  ]);

  return updatedState;
}

export function mockStateWithTripGeojson(state) {
  const initialState = cloneDeep(state || InitialState);

  // load csv and geojson
  const updatedState = applyActions(keplerGlReducer, initialState, [
    {
      action: VisStateActions.updateVisData,
      payload: [[{info: tripDataInfo, data: processGeojson(cloneDeep(tripGeojson))}]]
    }
  ]);

  // replace layer id and color with controlled value for testing
  updatedState.visState.layers.forEach((l, i) => {
    const oldLayerId = l.id;
    l.id = `${l.type}-${i}`;
    l.config.color = [i, i, i];
    // update layerOrder with newly created IDs
    updatedState.visState.layerOrder = updatedState.visState.layerOrder.map(layerId =>
      layerId === oldLayerId ? l.id : layerId
    );
  });

  return updatedState;
}

export function mockStateWithTripTable(state) {
  const initialState = cloneDeep(state || InitialState);
  const updatedState = applyActions(keplerGlReducer, initialState, [
    {
      action: addDataToMap,
      payload: [
        {
          datasets: {info: tripCsvDataInfo, data: processCsvData(tripCsvData)},
          config: {
            version: 'v1',
            config: {
              visState: {
                layers: [expectedTripLayerConfig]
              }
            }
          }
        }
      ]
    }
  ]);

  return updatedState;
}

export function mockStateWithArcNeighbors(state) {
  const initialState = cloneDeep(state || InitialState);
  const updatedState = applyActions(keplerGlReducer, initialState, [
    {
      action: addDataToMap,
      payload: [
        {
          datasets: {info: arcDataInfo, data: processRowObject(testArcData)},
          config: arcDataConfig
        }
      ]
    }
  ]);

  return updatedState;
}

// export function mockStateWith

export function mockStateWithFilters(state) {
  const initialState = state || mockStateWithFileUpload();

  const prepareState = applyActions(keplerGlReducer, initialState, [
    // add filter
    {action: VisStateActions.addFilter, payload: [testCsvDataId]},

    // set filter name to 'time', and value
    {
      action: VisStateActions.setFilter,
      payload: [0, ['name', 'value'], ['time', [1474606800000, 1474617600000]]]
    },

    // set filter animation speed
    {
      action: VisStateActions.updateFilterAnimationSpeed,
      payload: [0, 4]
    },

    // add another filter
    {action: VisStateActions.addFilter, payload: [testGeoJsonDataId]},

    // set filter to 'RATE'
    {action: VisStateActions.setFilter, payload: [1, ['name', 'value'], ['RATE', ['a']]]}
  ]);

  // replace filter id with controlled value for easy testing
  prepareState.visState.filters.forEach((f, i) => {
    f.id = `${f.name}-${i}`;
  });

  return prepareState;
}

function mockStateWithMultiFilters() {
  const initialState = mockStateWithFilters();

  const prepareState = applyActions(keplerGlReducer, initialState, [
    // add filter
    {action: VisStateActions.addFilter, payload: [testCsvDataId]},

    // set filter to 'time'
    {action: VisStateActions.setFilter, payload: [2, 'name', 'date']},

    // set filter value
    {
      action: VisStateActions.setFilter,
      payload: [2, 'value', ['2016-09-24', '2016-09-23']]
    },

    // add another filter
    {action: VisStateActions.addFilter, payload: [testGeoJsonDataId]},

    // set filter to 'TRIPS'
    {action: VisStateActions.setFilter, payload: [3, 'name', 'TRIPS']},

    // set filter value
    {action: VisStateActions.setFilter, payload: [3, 'value', [4, 12]]},

    // add another gpu filter
    {action: VisStateActions.addFilter, payload: [testCsvDataId]},

    // set filter to 'time'
    {action: VisStateActions.setFilter, payload: [4, 'name', 'epoch']},

    // set filter value
    {
      action: VisStateActions.setFilter,
      payload: [4, 'value', [1472700000000, 1472760000000]]
    }
  ]);

  // replace filter id with controlled value for easy testing
  prepareState.visState.filters.forEach((f, i) => {
    f.id = `${f.name}-${i}`;
  });

  return prepareState;
}

function mockStateWithEffects() {
  const initialState = cloneDeep(InitialState);

  const prepareState = applyActions(keplerGlReducer, initialState, [
    {
      action: VisStateActions.addEffect,
      payload: [{id: 'e_1'}]
    },
    {
      action: VisStateActions.addEffect,
      payload: [{id: 'e_2', type: 'sepia'}]
    },
    {
      action: VisStateActions.addEffect,
      payload: [{id: 'e_3', type: 'magnify'}]
    },
    {
      action: VisStateActions.addEffect,
      payload: [{id: 'e_4', type: 'lightAndShadow', parameters: {timestamp: 100, timezone: 'UTC'}}]
    }
  ]);
  return prepareState;
}

function mockStateWithH3Layer() {
  const initialState = cloneDeep(InitialState);

  const prepareState = applyActions(keplerGlReducer, initialState, [
    {
      action: addDataToMap,
      payload: [
        {
          datasets: {
            info: {id: csvDataId},
            data: processCsvData(testLayerData)
          },
          config: {
            version: 'v1',
            config: {
              visState: {
                layers: [
                  {
                    id: 'h3-layer',
                    type: 'hexagonId',
                    config: {
                      dataId: csvDataId,
                      label: 'H3 Hexagon',
                      color: [255, 153, 31],
                      columns: {hex_id: 'hex_id'},
                      isVisible: true
                    }
                  }
                ]
              }
            }
          }
        }
      ]
    }
  ]);
  return prepareState;
}

export function mockStateWithMultipleH3Layers() {
  const initialState = cloneDeep(InitialState);

  const prepareState = applyActions(keplerGlReducer, initialState, [
    {
      action: addDataToMap,
      payload: [
        {
          datasets: {
            info: {id: csvDataId},
            data: processCsvData(testLayerData)
          },
          config: {
            version: 'v1',
            config: {
              visState: {
                layers: [
                  {
                    id: 'h3-layer-1',
                    type: 'hexagonId',
                    config: {
                      dataId: csvDataId,
                      label: 'H3 Hexagon 1',
                      color: [255, 153, 31],
                      columns: {hex_id: 'hex_id'},
                      isVisible: true
                    }
                  },
                  {
                    id: 'h3-layer-2',
                    type: 'hexagonId',
                    config: {
                      dataId: csvDataId,
                      label: 'H3 Hexagon 2',
                      color: [255, 153, 31],
                      columns: {hex_id: 'hex_id'},
                      isVisible: true
                    }
                  }
                ]
              }
            }
          }
        }
      ]
    }
  ]);
  return prepareState;
}

/**
 * Mock state will contain 1 heatmap, 1 point and 1 arc layer, 1 hexbin layer and 1 time filter
 * @param {*} state
 */
function mockStateWithTripData() {
  const initialState = cloneDeep(InitialState);

  const addDataPayload = {
    datasets: {
      info: {
        label: 'Sample Trips',
        id: tripDataId
      },
      data: {fields: tripFields, rows: tripRows}
    },
    config: tripConfig
  };
  return applyActions(keplerGlReducer, initialState, [
    {
      action: addDataToMap,
      payload: [addDataPayload]
    }
  ]);
}

export function mockStateWithLayerDimensions(state) {
  const initialState = state || mockStateWithFileUpload();

  const layer0 = initialState.visState.layers.find(
    l => l.config.dataId === testCsvDataId && l.type === 'point'
  );

  const colorField = initialState.visState.datasets[testCsvDataId].fields.find(
    f => f.name === 'gps_data.types'
  );

  const colorFieldPayload = [layer0, {colorField}, 'color'];
  const colorRange = colorPaletteToColorRange(
    KEPLER_COLOR_PALETTES.find(({name}) => name === 'Uber Viz Sequential'),
    {steps: 4}
  );
  const colorRangePayload = [layer0, {colorRange}, 'color'];

  const textLabelField = initialState.visState.datasets[testCsvDataId].fields.find(
    f => f.name === 'date'
  );

  const textLabelPayload1 = [layer0, 0, 'field', textLabelField];
  const textLabelPayload2 = [layer0, 0, 'color', [255, 0, 0]];

  const prepareState = applyActions(keplerGlReducer, initialState, [
    // change colorField
    {
      action: VisStateActions.layerVisualChannelConfigChange,
      payload: colorFieldPayload
    },

    // change colorRange
    {action: VisStateActions.layerVisConfigChange, payload: colorRangePayload},

    // change textLabel
    {action: VisStateActions.layerTextLabelChange, payload: textLabelPayload1},
    {action: VisStateActions.layerTextLabelChange, payload: textLabelPayload2},

    // add layer from config
    {
      action: VisStateActions.addLayer,
      payload: [
        {
          id: 'hexagon-2',
          type: 'hexagon',
          config: {
            color: [2, 2, 2],
            isVisible: true,
            dataId: testCsvDataId,
            columns: {
              lat: 'gps_data.lat',
              lng: 'gps_data.lng'
            }
          }
        }
      ]
    }
  ]);

  const reorderPayload = [['hexagon-2', 'point-0', 'geojson-1']];

  const resultState = applyActions(keplerGlReducer, prepareState, [
    // reorder Layer
    {action: VisStateActions.reorderLayer, payload: reorderPayload}
  ]);

  return resultState;
}

function mockStateWithCustomMapStyle(customType = 'LOCAL') {
  const initialState = cloneDeep(InitialState);
  const testCustomMapStyle = {
    ...getInitialInputStyle(),
    id: 'smoothie_the_cat',
    accessToken: 'secret_token',
    isValid: true,
    label: 'Smoothie the Cat',
    style: {
      version: 'v8',
      id: 'smoothie_the_cat',
      layers: [{id: 'background'}, {id: 'road'}, {id: 'label'}],
      name: 'Smoothie the Cat'
    },
    url: 'mapbox://styles/shanhe/smoothie.the.cat',
    icon: 'https://api.mapbox.com/styles/v1/shanhe/smoothie.the.cat/static/-122.3391,37.7922,9,0,0/400x300?access_token=secret_token&logo=false&attribution=false',
    custom: customType
  };

  // add custom map style
  const updatedState = applyActions(keplerGlReducer, initialState, [
    {
      action: MapStyleActions.inputMapStyle,
      payload: [testCustomMapStyle]
    },
    {
      action: MapStyleActions.loadCustomMapStyle,
      payload: [
        {
          style: testCustomMapStyle.style
        }
      ]
    },
    {
      action: MapStyleActions.addCustomMapStyle,
      payload: [{}]
    },
    {
      action: MapStyleActions.set3dBuildingColor,
      payload: [[1, 2, 3]]
    }
  ]);

  return updatedState;
}

function mockStateWithSplitMaps(state) {
  const initialState = state || mockStateWithFileUpload();

  const firstLayer = initialState.visState.layers[0];
  const secondLayer = initialState.visState.layers[1];
  const prepareState = applyActions(keplerGlReducer, initialState, [
    // toggle splitMaps
    {action: MapStateActions.toggleSplitMap, payload: []},

    // toggleLayerForMap
    {action: VisStateActions.toggleLayerForMap, payload: [0, firstLayer.id]},

    // open geojson layer
    {action: VisStateActions.toggleLayerForMap, payload: [1, secondLayer.id]},

    {action: VisStateActions.toggleLayerForMap, payload: [1, firstLayer.id]}
  ]);

  return prepareState;
}

function mockStateWithTooltipFormat() {
  const initialState = mockStateWithFileUpload();

  const oldConfig = initialState.visState.interactionConfig.tooltip;
  const newConfig = {
    ...oldConfig,
    config: {
      ...oldConfig.config,
      compareMode: true,
      compareType: COMPARE_TYPES.RELATIVE,
      fieldsToShow: {
        ...oldConfig.config.fieldsToShow,
        [testCsvDataId]: [{name: 'gps_data.utc_timestamp', format: 'LL'}],
        [testGeoJsonDataId]: [
          {name: 'OBJECTID', format: null},
          {name: 'ZIP_CODE', format: null},
          {name: 'ID', format: null},
          {name: 'TRIPS', format: '.3f'},
          {name: 'RATE', format: null}
        ]
      }
    }
  };

  const prepareState = applyActions(keplerGlReducer, initialState, [
    {action: VisStateActions.interactionConfigChange, payload: [newConfig]}
  ]);

  return prepareState;
}

function mockStateWithGeocoderDataset() {
  const initialState = cloneDeep(InitialState);

  const oldInteractionConfig = initialState.visState.interactionConfig.tooltip;
  const newInteractionConfig = {
    ...oldInteractionConfig,
    config: {
      ...oldInteractionConfig.config,
      fieldsToShow: {
        ...oldInteractionConfig.config.fieldsToShow,
        geocoder_dataset: [
          {
            name: 'lt',
            format: null
          },
          {
            name: 'ln',
            format: null
          },
          {
            name: 'icon',
            format: null
          },
          {
            name: 'text',
            format: null
          }
        ]
      },
      compareMode: false,
      compareType: COMPARE_TYPES.ABSOLUTE
    }
  };
  const geocoderDataset = getUpdateVisDataPayload(48.85658, 2.35183, 'Paris');

  const prepareState = applyActions(keplerGlReducer, initialState, [
    {
      action: VisStateActions.updateVisData,
      payload: geocoderDataset
    },
    {action: VisStateActions.interactionConfigChange, payload: [newInteractionConfig]}
  ]);

  return prepareState;
}

function mockStateWithLayerStyling() {
  const initialState = mockStateWithFileUpload();
  const layer0 = initialState.visState.layers.find(
    l => l.config.dataId === testCsvDataId && l.type === 'point'
  );
  const mapCenter = {
    longitude: 31.2369645,
    latitude: 30.0242098,
    zoom: 13
  };

  const prepareState = applyActions(keplerGlReducer, initialState, [
    // make radius bigger
    {
      action: VisStateActions.layerVisConfigChange,
      payload: [layer0, {radius: 100}]
    },
    // center map
    {
      action: MapStateActions.updateMap,
      payload: [mapCenter]
    }
  ]);

  return prepareState;
}

// Schema stores the label field as {name, type}. New hexagon layers label point counts.
const SAVED_AGGREGATION_COUNT_TEXT_LABEL = {
  ...DEFAULT_TEXT_LABEL,
  field: {name: 'pointCount', type: 'integer'},
  anchor: 'middle',
  alignment: 'center',
  collisionEnabled: true,
  outlineWidth: 1,
  outlineColor: [0, 0, 0, 255]
};

// saved hexagon layer
export const expectedSavedLayer0 = {
  id: 'hexagon-2',
  type: 'hexagon',
  config: {
    dataId: testCsvDataId,
    label: DEFAULT_LAYER_LABEL,
    highlightColor: DEFAULT_HIGHLIGHT_COLOR,
    color: [2, 2, 2],
    columnMode: 'points',
    columns: {
      lat: 'gps_data.lat',
      lng: 'gps_data.lng'
    },
    hidden: false,
    isVisible: true,
    visConfig: {
      opacity: DEFAULT_LAYER_OPACITY,
      worldUnitSize: 1,
      resolution: 8,
      colorRange: DEFAULT_COLOR_RANGE,
      coverage: 1,
      sizeRange: [0, 500],
      percentile: [0, 100],
      elevationPercentile: [0, 100],
      elevationScale: 5,
      enableElevationZoomFactor: true,
      fixedHeight: false,
      colorAggregation: 'count',
      sizeAggregation: 'count',
      enable3d: false
    },
    textLabel: [SAVED_AGGREGATION_COUNT_TEXT_LABEL]
  },
  visualChannels: {
    colorField: null,
    colorScale: 'quantile',
    sizeField: null,
    sizeScale: 'linear'
  }
};

export const expectedLoadedLayer0 = {
  id: 'hexagon-2',
  type: 'hexagon',
  config: {
    dataId: testCsvDataId,
    label: DEFAULT_LAYER_LABEL,
    highlightColor: DEFAULT_HIGHLIGHT_COLOR,
    color: [2, 2, 2],
    columnMode: 'points',
    columns: {
      lat: 'gps_data.lat',
      lng: 'gps_data.lng'
    },
    hidden: false,
    isVisible: true,
    visConfig: {
      opacity: DEFAULT_LAYER_OPACITY,
      worldUnitSize: 1,
      resolution: 8,
      colorRange: DEFAULT_COLOR_RANGE,
      coverage: 1,
      sizeRange: [0, 500],
      percentile: [0, 100],
      elevationPercentile: [0, 100],
      elevationScale: 5,
      enableElevationZoomFactor: true,
      fixedHeight: false,
      // LAYER_VIS_CONFIGS.aggregation.defaultValue is AGGREGATION_TYPES.average,
      colorAggregation: 'count',
      sizeAggregation: 'count',
      enable3d: false
    },
    colorField: null,
    colorScale: 'quantile',
    sizeField: null,
    sizeScale: 'linear',
    textLabel: [SAVED_AGGREGATION_COUNT_TEXT_LABEL]
  }
};

// result of Uber Viz Sequential step 4
export const expectedColorRangeInLayer = {
  name: 'Uber Viz Sequential',
  type: 'sequential',
  category: 'Uber',
  colors: ['#00939C', '#6BB5B9', '#AAD7D9', '#E6FAFA']
};

export const expectedSavedLayer1 = {
  id: 'point-0',
  type: 'point',
  config: {
    dataId: testCsvDataId,
    label: 'gps_data',
    columnMode: 'points',
    highlightColor: DEFAULT_HIGHLIGHT_COLOR,
    color: [0, 0, 0],
    columns: {
      lat: 'gps_data.lat',
      lng: 'gps_data.lng'
    },
    textLabel: [
      {
        ...DEFAULT_TEXT_LABEL,
        field: {
          name: 'date',
          type: 'date'
        },
        color: [255, 0, 0]
      }
    ],
    hidden: false,
    isVisible: true,
    visConfig: {
      radius: 10,
      billboard: false,
      fixedRadius: false,
      opacity: DEFAULT_LAYER_OPACITY,
      outline: false,
      filled: true,
      thickness: 2,
      colorRange: expectedColorRangeInLayer,
      strokeColorRange: DEFAULT_COLOR_RANGE,
      strokeColor: null,
      radiusRange: [0, 50],
      allowHover: true,
      showNeighborOnHover: false,
      showHighlightColor: true,
      glowEnabled: false,
      glowExtent: 2,
      glowStrength: 0.5,
      pulseEnabled: false,
      pulseMode: 'pulse',
      pulseSpeed: 1,
      pulseExpansion: 2,
      pulseTrigger: 'continuous',
      pulseTimeField: '',
      pulseDurationMs: 1000
    }
  },
  visualChannels: {
    colorField: {
      name: 'gps_data.types',
      type: 'string'
    },
    colorScale: 'ordinal',
    sizeField: null,
    sizeScale: 'linear',
    strokeColorField: null,
    strokeColorScale: 'quantile'
  }
};

export const expectedLoadedLayer1 = {
  id: 'point-0',
  type: 'point',
  config: {
    dataId: testCsvDataId,
    label: 'gps_data',
    columnMode: 'points',
    highlightColor: DEFAULT_HIGHLIGHT_COLOR,
    color: [0, 0, 0],
    columns: {
      lat: 'gps_data.lat',
      lng: 'gps_data.lng'
    },
    hidden: false,
    isVisible: true,
    visConfig: {
      radius: 10,
      billboard: false,
      fixedRadius: false,
      opacity: DEFAULT_LAYER_OPACITY,
      outline: false,
      thickness: 2,
      colorRange: expectedColorRangeInLayer,
      strokeColorRange: DEFAULT_COLOR_RANGE,
      filled: true,
      strokeColor: null,
      radiusRange: [0, 50],
      allowHover: true,
      showNeighborOnHover: false,
      showHighlightColor: true,
      glowEnabled: false,
      glowExtent: 2,
      glowStrength: 0.5,
      pulseEnabled: false,
      pulseMode: 'pulse',
      pulseSpeed: 1,
      pulseExpansion: 2,
      pulseTrigger: 'continuous',
      pulseTimeField: '',
      pulseDurationMs: 1000
    },
    colorField: {
      name: 'gps_data.types',
      type: 'string'
    },
    colorScale: 'ordinal',
    strokeColorField: null,
    strokeColorScale: 'quantile',
    sizeField: null,
    sizeScale: 'linear',
    textLabel: [
      {
        ...DEFAULT_TEXT_LABEL,
        field: {
          name: 'date',
          type: 'date'
        },
        color: [255, 0, 0]
      }
    ]
  }
};

export const expectedSavedLayer2 = {
  id: 'geojson-1',
  type: 'geojson',
  config: {
    dataId: testGeoJsonDataId,
    label: 'zip',
    highlightColor: DEFAULT_HIGHLIGHT_COLOR,
    color: [1, 1, 1],
    columns: {
      geojson: '_geojson'
    },
    columnMode: 'geojson',
    hidden: false,
    isVisible: true,
    visConfig: {
      opacity: DEFAULT_LAYER_OPACITY,
      thickness: 0.5,
      colorRange: DEFAULT_COLOR_RANGE,
      strokeColorRange: DEFAULT_COLOR_RANGE,
      strokeColor: [11, 11, 11],
      radius: 10,
      sizeRange: [0, 10],
      radiusRange: [0, 50],
      heightRange: [0, 500],
      elevationScale: 1,
      fixedHeight: false,
      invertHeight: false,
      elevationOffset: 0,
      elevationOffsetRange: [0, 500],
      fixedElevation: true,
      stroked: true,
      filled: true,
      enable3d: false,
      wireframe: false,
      strokeOpacity: 0.8,
      allowHover: true
    },
    textLabel: [DEFAULT_TEXT_LABEL]
  },
  visualChannels: {
    colorField: null,
    colorScale: 'quantile',
    strokeColorField: null,
    strokeColorScale: 'quantile',
    sizeField: null,
    sizeScale: 'linear',
    heightField: null,
    heightScale: 'linear',
    elevationOffsetField: null,
    elevationOffsetScale: 'linear',
    radiusField: null,
    radiusScale: 'linear'
  }
};

export const expectedLoadedLayer2 = {
  id: 'geojson-1',
  type: 'geojson',
  config: {
    dataId: testGeoJsonDataId,
    label: 'zip',
    highlightColor: DEFAULT_HIGHLIGHT_COLOR,
    color: [1, 1, 1],
    columns: {
      geojson: '_geojson'
    },
    columnMode: 'geojson',
    hidden: false,
    isVisible: true,
    visConfig: {
      opacity: DEFAULT_LAYER_OPACITY,
      thickness: 0.5,
      colorRange: DEFAULT_COLOR_RANGE,
      strokeColorRange: DEFAULT_COLOR_RANGE,
      strokeColor: [11, 11, 11],
      strokeOpacity: 0.8,
      radius: 10,
      sizeRange: [0, 10],
      radiusRange: [0, 50],
      heightRange: [0, 500],
      elevationScale: 1,
      fixedHeight: false,
      invertHeight: false,
      elevationOffset: 0,
      elevationOffsetRange: [0, 500],
      fixedElevation: true,
      stroked: true,
      filled: true,
      enable3d: false,
      wireframe: false,
      allowHover: true
    },
    colorField: null,
    colorScale: 'quantile',
    strokeColorField: null,
    strokeColorScale: 'quantile',
    sizeField: null,
    sizeScale: 'linear',
    heightField: null,
    heightScale: 'linear',
    elevationOffsetField: null,
    elevationOffsetScale: 'linear',
    radiusField: null,
    radiusScale: 'linear',
    textLabel: [DEFAULT_TEXT_LABEL]
  }
};

export const StateWFiles = mockStateWithFileUpload();
export const StateWFilters = mockStateWithFilters();
export const StateWEffects = mockStateWithEffects();
export const StateWFilesFiltersLayerColor = mockStateWithLayerDimensions(StateWFilters);
export const StateWMultiFilters = mockStateWithMultiFilters();

export const StateWCustomMapStyleLegacy = mockStateWithCustomMapStyle(true);
export const StateWCustomMapStyleLocal = mockStateWithCustomMapStyle('LOCAL');
export const StateWCustomMapStyleManaged = mockStateWithCustomMapStyle('MANAGED');
export const StateWSplitMaps = mockStateWithSplitMaps();
export const StateWTrips = mockStateWithTripData();
export const StateWTripGeojson = mockStateWithTripGeojson();
export const StateWTooltipFormat = mockStateWithTooltipFormat();
export const StateWH3Layer = mockStateWithH3Layer();
export const StateWMultiH3Layers = mockStateWithMultipleH3Layers();
export const StateWithGeocoderDataset = mockStateWithGeocoderDataset();
export const StateWLayerStyle = mockStateWithLayerStyling();
export const StateWLayerCustomColorBreaks = mockStateWithLayerCustomColorBreaksLegends();
export const StateWTripTable = mockStateWithTripTable();
export const StateWArcNeighbors = mockStateWithArcNeighbors();
export const StateWSyncedTimeFilter = mockStateWithSyncedTimeFilter();

export const expectedSavedTripLayer = {
  id: 'trip-0',
  type: 'trip',
  config: {
    dataId: 'trip_data',
    label: 'Trip Data',
    highlightColor: DEFAULT_HIGHLIGHT_COLOR,
    color: [0, 0, 0],
    columnMode: 'geojson',
    columns: {
      geojson: '_geojson'
    },
    hidden: false,
    isVisible: true,
    visConfig: {
      opacity: DEFAULT_LAYER_OPACITY,
      thickness: 0.5,
      colorRange: DEFAULT_COLOR_RANGE,
      trailLength: 180,
      fadeTrail: true,
      billboard: false,
      sizeRange: [0, 10],
      sizeScale: 1,
      scenegraph: null,
      scenegraphEnabled: false,
      scenegraphColorEnabled: false,
      scenegraphUseTrailColor: false,
      scenegraphColor: null,
      scenegraphCustomModelUrl: '',
      adjustRoll: 0,
      adjustPitch: 0,
      adjustYaw: 0,
      invertRoll: false,
      invertPitch: false,
      invertYaw: false,
      fixedRoll: true,
      fixedPitch: true,
      fixedYaw: true
    },
    textLabel: [{...DEFAULT_TEXT_LABEL, backgroundColor: null}]
  },
  visualChannels: {
    colorField: null,
    colorScale: 'quantile',
    sizeField: null,
    sizeScale: 'linear',
    rollField: null,
    rollScale: 'linear',
    pitchField: null,
    pitchScale: 'linear',
    yawField: null,
    yawScale: 'linear'
  }
};

export function mockKeplerPropsWithState({
  state,
  keplerProps = DEFAULT_KEPLER_GL_PROPS,
  visStateActions = {},
  mapStateActions = {},
  mapStyleActions = {},
  uiStateActions = {},
  providerActions = {}
}) {
  return {
    ...state,
    ...keplerProps,
    visStateActions: {
      ...VisStateActions,
      ...visStateActions
    },
    mapStateActions: {
      ...MapStateActions,
      ...mapStateActions
    },
    mapStyleActions: {
      ...MapStyleActions,
      ...mapStyleActions
    },
    uiStateActions: {
      ...UIStateActions,
      ...uiStateActions
    },
    providerActions: {
      ...ProviderActions,
      ...providerActions
    }
  };
}

export const mockKeplerProps = mockKeplerPropsWithState({state: StateWLayerStyle});

// mount map with mockKeplerProps
// hover over data index 15
// tested in map-container-test
export const expectedLayerHoverProp = {
  currentTime: null,
  data: mockKeplerProps.visState.datasets[testCsvDataId].dataContainer.row(15),
  fields: mockKeplerProps.visState.datasets[testCsvDataId].fields,
  fieldsToShow:
    mockKeplerProps.visState.interactionConfig.tooltip.config.fieldsToShow[testCsvDataId],
  layer: mockKeplerProps.visState.layers[0]
};

export const expectedGeojsonLayerHoverProp = {
  data: mockKeplerProps.visState.datasets[testGeoJsonDataId].dataContainer.row(0),
  fields: mockKeplerProps.visState.datasets[testGeoJsonDataId].fields,
  fieldsToShow:
    mockKeplerProps.visState.interactionConfig.tooltip.config.fieldsToShow[testGeoJsonDataId],
  layer: mockKeplerProps.visState.layers[1]
};

export function stateWithTimeFilterAndTripLayer() {
  const initialState = mockStateWithTripData();

  return mockStateWithTripGeojson(initialState);
}

export function stateWithTimeFilterSyncedWithTripLayer() {
  const initialState = stateWithTimeFilterAndTripLayer();
  return {
    ...initialState,
    visState: syncTimeFilterWithLayerTimelineUpdater(initialState.visState, {
      idx: 0,
      enable: true
    })
  };
}