@flowmap.gl/data 8.0.0-alpha.9 → 8.0.1

package/src/FlowmapState.ts

@@ -1,16 +1,24 @@
+/*
+ * Copyright (c) Flowmap.gl contributors
+ * Copyright (c) 2018-2020 Teralytics
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
 import {LocationFilterMode, ViewportProps} from './types';
 
 export interface FilterState {
-  selectedLocations: string[] | undefined;
-  selectedTimeRange: [Date, Date] | undefined;
-  locationFilterMode: LocationFilterMode;
+  selectedLocations?: (string | number)[];
+  locationFilterMode?: LocationFilterMode;
+  selectedTimeRange?: [Date, Date];
 }
 
 export interface SettingsState {
   animationEnabled: boolean;
   fadeEnabled: boolean;
   fadeOpacityEnabled: boolean;
+  locationsEnabled: boolean;
   locationTotalsEnabled: boolean;
+  locationLabelsEnabled: boolean;
   adaptiveScalesEnabled: boolean;
   clusteringEnabled: boolean;
   clusteringAuto: boolean;
@@ -23,7 +31,7 @@ export interface SettingsState {
 }
 
 export interface FlowmapState {
-  filterState: FilterState;
-  settingsState: SettingsState;
+  filter?: FilterState;
+  settings: SettingsState;
   viewport: ViewportProps;
 }

package/src/cluster/ClusterIndex.ts

@@ -1,19 +1,7 @@
 /*
- * Copyright 2022 FlowmapBlue
- * Copyright 2018-2020 Teralytics, modified by FlowmapBlue
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
+ * Copyright (c) Flowmap.gl contributors
+ * Copyright (c) 2018-2020 Teralytics
+ * SPDX-License-Identifier: Apache-2.0
  */
 
 import {
@@ -27,14 +15,14 @@ import {
 } from './../types';
 import {ascending, bisectLeft, extent} from 'd3-array';
 
-export type LocationWeightGetter = (id: string) => number;
+export type LocationWeightGetter = (id: string | number) => number;
 
 /**
  * A data structure representing the cluster levels for efficient flow aggregation.
  */
 export interface ClusterIndex<F> {
   availableZoomLevels: number[];
-  getClusterById: (clusterId: string) => Cluster | undefined;
+  getClusterById: (clusterId: string | number) => Cluster | undefined;
   /**
    * List the nodes on the given zoom level.
    */
@@ -42,7 +30,7 @@ export interface ClusterIndex<F> {
   /**
    * Get the min zoom level on which the location is not clustered.
    */
-  getMinZoomForLocation: (locationId: string) => number;
+  getMinZoomForLocation: (locationId: string | number) => number;
   /**
    * List the IDs of all locations in the cluster (leaves of the subtree starting in the cluster).
    */
@@ -50,7 +38,10 @@ export interface ClusterIndex<F> {
   /**
    * Find the cluster the given location is residing in on the specified zoom level.
    */
-  findClusterFor: (locationId: string, zoom: number) => string | undefined;
+  findClusterFor: (
+    locationId: string | number,
+    zoom: number,
+  ) => string | number | undefined;
   /**
    * Aggregate flows for the specified zoom level.
    */
@@ -69,8 +60,8 @@ export interface ClusterIndex<F> {
  */
 export function buildIndex<F>(clusterLevels: ClusterLevels): ClusterIndex<F> {
   const nodesByZoom = new Map<number, ClusterNode[]>();
-  const clustersById = new Map<string, Cluster>();
-  const minZoomByLocationId = new Map<string, number>();
+  const clustersById = new Map<string | number, Cluster>();
+  const minZoomByLocationId = new Map<string | number, number>();
   for (const {zoom, nodes} of clusterLevels) {
     nodesByZoom.set(zoom, nodes);
     for (const node of nodes) {
@@ -91,7 +82,10 @@ export function buildIndex<F>(clusterLevels: ClusterLevels): ClusterIndex<F> {
     throw new Error('Could not determine minZoom or maxZoom');
   }
 
-  const leavesToClustersByZoom = new Map<number, Map<string, Cluster>>();
+  const leavesToClustersByZoom = new Map<
+    number,
+    Map<string | number, Cluster>
+  >();
 
   for (const cluster of clustersById.values()) {
     const {zoom} = cluster;
@@ -118,7 +112,7 @@ export function buildIndex<F>(clusterLevels: ClusterLevels): ClusterIndex<F> {
 
   const expandCluster = (cluster: Cluster, targetZoom: number = maxZoom) => {
     const ids: string[] = [];
-    const visit = (c: Cluster, expandedIds: string[]) => {
+    const visit = (c: Cluster, expandedIds: (string | number)[]) => {
       if (targetZoom > c.zoom) {
         for (const childId of c.children) {
           const child = clustersById.get(childId);
@@ -136,7 +130,7 @@ export function buildIndex<F>(clusterLevels: ClusterLevels): ClusterIndex<F> {
     return ids;
   };
 
-  function findClusterFor(locationId: string, zoom: number) {
+  function findClusterFor(locationId: string | number, zoom: number) {
     const leavesToClusters = leavesToClustersByZoom.get(zoom);
     if (!leavesToClusters) {
       return undefined;
@@ -179,7 +173,8 @@ export function buildIndex<F>(clusterLevels: ClusterLevels): ClusterIndex<F> {
       }
       const result: (F | AggregateFlow)[] = [];
       const aggFlowsByKey = new Map<string, AggregateFlow>();
-      const makeKey = (origin: string, dest: string) => `${origin}:${dest}`;
+      const makeKey = (origin: string | number, dest: string | number) =>
+        `${origin}:${dest}`;
       const {
         flowCountsMapReduce = {
           map: getFlowMagnitude,
@@ -223,8 +218,8 @@ export function makeLocationWeightGetter<F>(
   {getFlowOriginId, getFlowDestId, getFlowMagnitude}: FlowAccessors<F>,
 ): LocationWeightGetter {
   const locationTotals = {
-    incoming: new Map<string, number>(),
-    outgoing: new Map<string, number>(),
+    incoming: new Map<string | number, number>(),
+    outgoing: new Map<string | number, number>(),
   };
   for (const flow of flows) {
     const origin = getFlowOriginId(flow);
@@ -239,7 +234,7 @@ export function makeLocationWeightGetter<F>(
       (locationTotals.outgoing.get(origin) || 0) + count,
     );
   }
-  return (id: string) =>
+  return (id: string | number) =>
     Math.max(
       Math.abs(locationTotals.incoming.get(id) || 0),
       Math.abs(locationTotals.outgoing.get(id) || 0),

package/src/cluster/cluster.ts

@@ -1,46 +1,34 @@
 /*
- * Copyright 2022 FlowmapBlue
- * Copyright 2018-2020 Teralytics, modified by FlowmapBlue
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-/**
- * The code in this file is a based on https://github.com/mapbox/supercluster
+ * Copyright (c) Flowmap.gl contributors
+ * Copyright (c) 2018-2020 Teralytics
+ * SPDX-License-Identifier: Apache-2.0
  */
 
-// ISC License
-//
-// Copyright (c) 2016, Mapbox
-//
-// Permission to use, copy, modify, and/or distribute this software for any purpose
-// with or without fee is hereby granted, provided that the above copyright notice
-// and this permission notice appear in all copies.
-//
-// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-// REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
-// FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-// INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
-// OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
-// TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
-// THIS SOFTWARE.
-
-import {rollup} from 'd3-array';
+import {min, rollup} from 'd3-array';
 import KDBush from 'kdbush';
 import {LocationWeightGetter} from './ClusterIndex';
 import {Cluster, ClusterLevel, ClusterNode, LocationAccessors} from '../types';
 
+/**
+ * The code in this file is a based on https://github.com/mapbox/supercluster
+ *
+ *  ISC License
+ *
+ *  Copyright (c) 2016, Mapbox
+ *
+ *  Permission to use, copy, modify, and/or distribute this software for any purpose
+ *  with or without fee is hereby granted, provided that the above copyright notice
+ *  and this permission notice appear in all copies.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+ *  REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+ *  FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+ *  INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
+ *  OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+ *  TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
+ *  THIS SOFTWARE.
+ */
+
 export interface Options {
   minZoom: number; // min zoom to generate clusters on
   maxZoom: number; // max zoom level to cluster the points on
@@ -69,8 +57,9 @@ interface BasePoint {
   parentId: number; // parent cluster id
 }
 
-interface LeafPoint extends BasePoint {
+interface LeafPoint<L> extends BasePoint {
   index: number; // index of the source feature in the original input array,
+  location: L;
 }
 
 interface ClusterPoint extends BasePoint {
@@ -78,14 +67,14 @@ interface ClusterPoint extends BasePoint {
   numPoints: number;
 }
 
-type Point = LeafPoint | ClusterPoint;
+type Point<L> = LeafPoint<L> | ClusterPoint;
 
-export function isLeafPoint(p: Point): p is LeafPoint {
-  const {index} = p as LeafPoint;
+export function isLeafPoint<L>(p: Point<L>): p is LeafPoint<L> {
+  const {index} = p as LeafPoint<L>;
   return index != null;
 }
 
-export function isClusterPoint(p: Point): p is ClusterPoint {
+export function isClusterPoint<L>(p: Point<L>): p is ClusterPoint {
   const {id} = p as ClusterPoint;
   return id != null;
 }
@@ -93,7 +82,7 @@ export function isClusterPoint(p: Point): p is ClusterPoint {
 type ZoomLevelKDBush = any;
 
 export function clusterLocations<L>(
-  locations: L[],
+  locations: Iterable<L>,
   locationAccessors: LocationAccessors<L>,
   getLocationWeight: LocationWeightGetter,
   options?: Partial<Options>,
@@ -108,51 +97,101 @@ export function clusterLocations<L>(
   const trees = new Array<ZoomLevelKDBush>(maxZoom + 1);
 
   // generate a cluster object for each point and index input points into a KD-tree
-  let clusters = new Array<Point>();
-  for (let i = 0; i < locations.length; i++) {
-    const x = getLocationLon(locations[i]);
-    const y = getLocationLat(locations[i]);
+  let clusters = new Array<Point<L>>();
+  let locationsCount = 0;
+  for (const location of locations) {
+    const x = getLocationLon(location);
+    const y = getLocationLat(location);
     clusters.push({
       x: lngX(x), // projected point coordinates
       y: latY(y),
-      weight: getLocationWeight(getLocationId(locations[i])),
+      weight: getLocationWeight(getLocationId(location)),
       zoom: Infinity, // the last zoom the point was processed at
-      index: i, // index of the source feature in the original input array,
+      index: locationsCount, // index of the source feature in the original input array,
       parentId: -1, // parent cluster id
+      location,
     });
+    locationsCount++;
   }
-  trees[maxZoom + 1] = new KDBush(clusters, getX, getY, nodeSize, Float32Array);
+
+  const makeBush = (points: Point<L>[]) => {
+    const bush = new KDBush(points.length, nodeSize, Float32Array);
+    for (let i = 0; i < points.length; i++) {
+      bush.add(points[i].x, points[i].y);
+    }
+    bush.finish();
+    bush.points = points;
+    return bush;
+  };
 
   // cluster points on max zoom, then cluster the results on previous zoom, etc.;
   // results in a cluster hierarchy across zoom levels
+  trees[maxZoom + 1] = makeBush(clusters);
+  let prevZoom = maxZoom + 1;
+
   for (let z = maxZoom; z >= minZoom; z--) {
     // create a new set of clusters for the zoom and index them with a KD-tree
-    clusters = cluster(clusters, z, trees[z + 1], opts);
-    trees[z] = new KDBush(clusters, getX, getY, nodeSize, Float32Array);
+    const _clusters = cluster(clusters, z, trees[prevZoom], opts);
+    if (_clusters.length === clusters.length) {
+      // same number of clusters => move the higher level clusters up
+      // no need to keep the same data on multiple levels
+      trees[z] = trees[prevZoom];
+      trees[prevZoom] = undefined;
+      prevZoom = z;
+      clusters = _clusters;
+    } else {
+      prevZoom = z;
+      clusters = _clusters;
+      trees[z] = makeBush(clusters);
+    }
   }
 
   if (trees.length === 0) {
     return [];
   }
-  const numbersOfClusters = trees.map((d) => d.points.length);
-  const maxAvailZoom = numbersOfClusters.indexOf(
-    numbersOfClusters[numbersOfClusters.length - 1],
-  );
+
+  const numbersOfClusters: number[] = trees.map((d) => d?.points.length);
+  const minClusters = min(numbersOfClusters.filter((d) => d > 0));
+
+  let maxAvailZoom =
+    findIndexOfMax(numbersOfClusters) ?? numbersOfClusters.length - 1;
+
+  const numUniqueLocations = countUniqueLocations(locations, locationAccessors);
+  if (numUniqueLocations < locationsCount) {
+    // Duplicate locations would be clustered together at any zoom level which can lead to having too many zooms.
+    // To avoid that, we need to find the max zoom level that has less or equal clusters than unique locations
+    // and drop all zoom levels beyond that (except the unclustered level).
+    const maxClustersZoom = findLastIndex(
+      numbersOfClusters,
+      (d) => d <= numUniqueLocations,
+    );
+    if (maxClustersZoom >= 0) {
+      // Now, move the unclustered points to the next zoom level to avoid having a gap
+      if (maxClustersZoom < maxAvailZoom) {
+        trees[maxClustersZoom + 1] = trees[maxAvailZoom];
+        trees.splice(maxClustersZoom + 2); // Remove all zoom levels beyond maxClustersZoom
+      }
+      maxAvailZoom = maxClustersZoom + 1;
+    }
+  }
+
   const minAvailZoom = Math.min(
     maxAvailZoom,
-    numbersOfClusters.lastIndexOf(numbersOfClusters[0]),
+    minClusters ? numbersOfClusters.lastIndexOf(minClusters) : maxAvailZoom,
   );
 
   const clusterLevels = new Array<ClusterLevel>();
-  for (let zoom = minAvailZoom; zoom <= maxAvailZoom; zoom++) {
-    let childrenByParent: Map<number, string[]> | undefined;
+  prevZoom = NaN;
+  for (let zoom = maxAvailZoom; zoom >= minAvailZoom; zoom--) {
+    let childrenByParent: Map<number, (string | number)[]> | undefined;
     const tree = trees[zoom];
-    if (zoom < maxAvailZoom) {
-      childrenByParent = rollup<Point, string[], number>(
-        trees[zoom + 1].points,
+    if (!tree) continue;
+    if (trees[prevZoom] && zoom < maxAvailZoom) {
+      childrenByParent = rollup(
+        trees[prevZoom].points,
         (points: any[]) =>
           points.map((p: any) =>
-            p.id ? makeClusterId(p.id) : getLocationId(locations[p.index]),
+            p.id ? makeClusterId(p.id) : getLocationId(p.location),
           ),
         (point: any) => point.parentId,
       );
@@ -160,9 +199,8 @@ export function clusterLocations<L>(
 
     const nodes: ClusterNode[] = [];
     for (const point of tree.points) {
-      const {x, y, numPoints} = point;
+      const {x, y, numPoints, location} = point;
       if (isLeafPoint(point)) {
-        const location = locations[point.index];
         nodes.push({
           id: getLocationId(location),
           zoom,
@@ -173,22 +211,26 @@ export function clusterLocations<L>(
         const {id} = point;
         const children = childrenByParent && childrenByParent.get(id);
         if (!children) {
-          throw new Error(`Cluster ${id} doesn't have children`);
+          // Might happen if there are multiple locations with same coordinates
+          console.warn(`Omitting cluster with no children, point:`, point);
+          continue;
         }
-        nodes.push({
+        const cluster = {
           id: makeClusterId(id),
           name: makeClusterName(id, numPoints),
           zoom,
           lat: yLat(y),
           lon: xLng(x),
-          children,
-        } as Cluster);
+          children: children ?? [],
+        } as Cluster;
+        nodes.push(cluster);
       }
     }
     clusterLevels.push({
       zoom,
       nodes,
     });
+    prevZoom = zoom;
   }
   return clusterLevels;
 }
@@ -211,13 +253,13 @@ function createCluster(
   };
 }
 
-function cluster(
-  points: Point[],
+function cluster<L>(
+  points: Point<L>[],
   zoom: number,
   tree: ZoomLevelKDBush,
   options: Options,
 ) {
-  const clusters: Point[] = [];
+  const clusters: Point<L>[] = [];
   const {radius, extent} = options;
   const r = radius / (extent * Math.pow(2, zoom));
 
@@ -293,10 +335,60 @@ function latY(lat: number) {
   return y < 0 ? 0 : y > 1 ? 1 : y;
 }
 
-function getX(p: Point) {
+function getX<L>(p: Point<L>) {
   return p.x;
 }
 
-function getY(p: Point) {
+function getY<L>(p: Point<L>) {
   return p.y;
 }
+
+function countUniqueLocations<L>(
+  locations: Iterable<L>,
+  locationAccessors: LocationAccessors<L>,
+) {
+  const {getLocationLon, getLocationLat} = locationAccessors;
+  const countByLatLon = new Map<string, number>();
+  let uniqueCnt = 0;
+  for (const loc of locations) {
+    const lon = getLocationLon(loc);
+    const lat = getLocationLat(loc);
+    const key = `${lon},${lat}`;
+    const prev = countByLatLon.get(key);
+    if (!prev) {
+      uniqueCnt++;
+    }
+    countByLatLon.set(key, prev ? prev + 1 : 1);
+  }
+  return uniqueCnt;
+}
+
+function findIndexOfMax(arr: (number | undefined)[]): number | undefined {
+  let max = -Infinity;
+  let maxIndex: number | undefined = undefined;
+
+  for (let i = 0; i < arr.length; i++) {
+    const value = arr[i];
+
+    if (typeof value === 'number') {
+      if (value > max) {
+        max = value;
+        maxIndex = i;
+      }
+    }
+  }
+
+  return maxIndex;
+}
+
+function findLastIndex<T>(
+  arr: T[],
+  predicate: (value: T, index: number, array: T[]) => boolean,
+): number {
+  for (let i = arr.length - 1; i >= 0; i--) {
+    if (predicate(arr[i], i, arr)) {
+      return i;
+    }
+  }
+  return -1;
+}

package/src/colors.ts

@@ -1,3 +1,9 @@
+/*
+ * Copyright (c) Flowmap.gl contributors
+ * Copyright (c) 2018-2020 Teralytics
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
 import {
   interpolateCool,
   interpolateInferno,
@@ -333,17 +339,15 @@ const diffColors: DiffColors = {
   outlineColor: 'rgb(230,233,237)',
 };
 
-export function getFlowmapColors(
-  settingsState: SettingsState,
-): Colors | DiffColors {
+export function getFlowmapColors(settings: SettingsState): Colors | DiffColors {
   return getColors(
     false, // TODO: diffMode
-    settingsState.colorScheme,
-    settingsState.darkMode,
-    settingsState.fadeEnabled,
-    settingsState.fadeOpacityEnabled,
-    settingsState.fadeAmount,
-    settingsState.animationEnabled,
+    settings.colorScheme,
+    settings.darkMode,
+    settings.fadeEnabled,
+    settings.fadeOpacityEnabled,
+    settings.fadeAmount,
+    settings.animationEnabled,
   );
 }
 

package/src/getViewStateForLocations.ts

@@ -1,3 +1,9 @@
+/*
+ * Copyright (c) Flowmap.gl contributors
+ * Copyright (c) 2018-2020 Teralytics
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
 import {geoBounds} from 'd3-geo';
 import {fitBounds} from '@math.gl/web-mercator';
 import type {
@@ -50,19 +56,29 @@ export function getViewStateForFeatures(
   };
 }
 
-export function getViewStateForLocations(
-  locations: any[],
-  getLocationCoords: (location: any) => [number, number],
+export function getViewStateForLocations<L>(
+  locations: Iterable<L>,
+  getLocationCoords: (location: L) => [number, number],
   size: [number, number],
   opts?: GetViewStateOptions,
 ): ViewState & {width: number; height: number} {
+  const asGeometry = (location: L) => ({
+    type: 'Point',
+    coordinates: getLocationCoords(location),
+  });
+  let geometries;
+  if (Array.isArray(locations)) {
+    geometries = locations.map(asGeometry);
+  } else {
+    geometries = [];
+    for (const location of locations) {
+      geometries.push(asGeometry(location));
+    }
+  }
   return getViewStateForFeatures(
     {
       type: 'GeometryCollection',
-      geometries: locations.map((location) => ({
-        type: 'Point',
-        coordinates: getLocationCoords(location),
-      })),
+      geometries,
     } as any,
     size,
     opts,

package/src/index.ts

@@ -1,13 +1,19 @@
+/*
+ * Copyright (c) Flowmap.gl contributors
+ * Copyright (c) 2018-2020 Teralytics
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
 export * from './types';
 export * from './colors';
 export * from './FlowmapState';
 export * from './FlowmapSelectors';
+export * from './selector-functions';
 export * from './time';
 export * from './getViewStateForLocations';
 export * from './provider/FlowmapDataProvider';
+export * from './cluster/cluster';
+export * from './cluster/ClusterIndex';
 export {default as FlowmapAggregateAccessors} from './FlowmapAggregateAccessors';
 export type {default as FlowmapDataProvider} from './provider/FlowmapDataProvider';
 export {default as LocalFlowmapDataProvider} from './provider/LocalFlowmapDataProvider';
-export {default as createWorkerDataProvider} from './provider/createWorkerDataProvider';
-export {default as WorkerFlowmapDataProvider} from './provider/WorkerFlowmapDataProvider';
-export * from './provider/WorkerFlowmapDataProvider';

package/src/provider/FlowmapDataProvider.ts

@@ -1,3 +1,9 @@
+/*
+ * Copyright (c) Flowmap.gl contributors
+ * Copyright (c) 2018-2020 Teralytics
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
 import {AggregateFlow, Cluster, LocationAccessors, LocationTotals} from '..';
 import {FlowmapState} from '../FlowmapState';
 import {
@@ -23,11 +29,13 @@ export default interface FlowmapDataProvider<L, F> {
 
   getFlowByIndex(index: number): Promise<F | AggregateFlow | undefined>;
 
-  getLocationById(id: string): Promise<L | Cluster | undefined>;
+  getLocationById(id: string | number): Promise<L | Cluster | undefined>;
 
   getLocationByIndex(idx: number): Promise<L | ClusterNode | undefined>;
 
-  getTotalsForLocation(id: string): Promise<LocationTotals | undefined>;
+  getTotalsForLocation(
+    id: string | number,
+  ): Promise<LocationTotals | undefined>;
 
   // getLocationsInBbox(
   //   bbox: [number, number, number, number],
@@ -36,17 +44,25 @@ export default interface FlowmapDataProvider<L, F> {
   // getLocationsForSearchBox(): Promise<(FlowLocation | ClusterNode)[] | undefined>;
 
   getLayersData(): Promise<LayersData | undefined>;
+
+  /**
+   * This is to give the data provider control over when/how often layersData
+   * is updated which leads to the flowmap being redrawn.
+   */
+  updateLayersData(
+    setLayersData: (layersData: LayersData | undefined) => void,
+    changeFlags: Record<string, boolean>,
+  ): Promise<void>;
 }
 
 export function isFlowmapData<L, F>(
   data: Record<string, any>,
 ): data is FlowmapData<L, F> {
   return (
-    data &&
-    data.locations &&
-    data.flows &&
-    Array.isArray(data.locations) &&
-    Array.isArray(data.flows)
+    data && data.locations && data.flows
+    // TODO: test that they are iterable
+    // Array.isArray(data.locations) &&
+    // Array.isArray(data.flows)
   );
 }