@flowmap.gl/data 8.0.0-alpha.2 → 8.0.0-alpha.22

package/src/getViewStateForLocations.ts

@@ -1,62 +1,78 @@
-import {BoundingBox, viewport} from '@mapbox/geo-viewport';
 import {geoBounds} from 'd3-geo';
-import {FeatureCollection, GeometryCollection, GeometryObject} from 'geojson';
-import {ViewState} from './types';
+import {fitBounds} from '@math.gl/web-mercator';
+import type {
+  FeatureCollection,
+  GeometryCollection,
+  GeometryObject,
+} from 'geojson';
+import type {ViewState} from './types';
 
 export type LocationProperties = any;
 
+export type GetViewStateOptions = {
+  pad?: number; // size ratio
+  padding?: {top: number; bottom: number; left: number; right: number};
+  tileSize?: number;
+  // minZoom?: number;  // not supported by fitBounds
+  maxZoom?: number;
+};
+
 export function getViewStateForFeatures(
   featureCollection:
     | FeatureCollection<GeometryObject, LocationProperties>
     | GeometryCollection,
   size: [number, number],
-  opts?: {
-    pad?: number;
-    tileSize?: number;
-    minZoom?: number;
-    maxZoom?: number;
-  },
-): ViewState {
-  const {pad = 0.05, tileSize = 512, minZoom = 0, maxZoom = 100} = opts || {};
-  const [[x1, y1], [x2, y2]] = geoBounds(featureCollection as any);
-  const bounds: BoundingBox = [
-    x1 - pad * (x2 - x1),
-    y1 - pad * (y2 - y1),
-    x2 + pad * (x2 - x1),
-    y2 + pad * (y2 - y1),
-  ];
-  const {
-    center: [longitude, latitude],
-    zoom,
-  } = viewport(bounds, size, undefined, undefined, tileSize, true);
-
+  opts?: GetViewStateOptions,
+): ViewState & {width: number; height: number} {
+  const {pad = 0.05, maxZoom = 100} = opts || {};
+  const bounds = geoBounds(featureCollection as any);
+  const [[x1, y1], [x2, y2]] = bounds;
+  const paddedBounds: [[number, number], [number, number]] = pad
+    ? [
+        [x1 - pad * (x2 - x1), y1 - pad * (y2 - y1)],
+        [x2 + pad * (x2 - x1), y2 + pad * (y2 - y1)],
+      ]
+    : bounds;
+  const [width, height] = size;
   return {
-    longitude,
-    latitude,
-    zoom: Math.max(Math.min(maxZoom, zoom), minZoom),
+    ...fitBounds({
+      width,
+      height,
+      bounds: paddedBounds,
+      padding: opts?.padding,
+      // minZoom,
+      maxZoom,
+    }),
+    width,
+    height,
     bearing: 0,
     pitch: 0,
   };
 }
 
-export function getViewStateForLocations(
-  locations: any[],
-  getLocationCentroid: (location: any) => [number, number],
+export function getViewStateForLocations<L>(
+  locations: Iterable<L>,
+  getLocationCoords: (location: L) => [number, number],
   size: [number, number],
-  opts?: {
-    pad?: number;
-    tileSize?: number;
-    minZoom?: number;
-    maxZoom?: number;
-  },
-): ViewState {
+  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: getLocationCentroid(location),
-      })),
+      geometries,
     } as any,
     size,
     opts,

package/src/index.ts

@@ -1,10 +1,13 @@
 export * from './types';
 export * from './colors';
-export * from './FlowMapState';
-export * from './FlowMapSelectors';
+export * from './FlowmapState';
+export * from './FlowmapSelectors';
+export * from './selector-functions';
 export * from './time';
 export * from './getViewStateForLocations';
-export * from './provider/FlowMapDataProvider';
-export {default as FlowMapAggregateAccessors} from './FlowMapAggregateAccessors';
-export type {default as FlowMapDataProvider} from './provider/FlowMapDataProvider';
-export {default as LocalFlowMapDataProvider} from './provider/LocalFlowMapDataProvider';
+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';

package/src/provider/FlowmapDataProvider.ts

@@ -0,0 +1,75 @@
+import {AggregateFlow, Cluster, LocationAccessors, LocationTotals} from '..';
+import {FlowmapState} from '../FlowmapState';
+import {
+  ClusterNode,
+  FlowmapData,
+  FlowmapDataAccessors,
+  LayersData,
+  ViewportProps,
+} from '../types';
+
+export default interface FlowmapDataProvider<L, F> {
+  setAccessors(accessors: FlowmapDataAccessors<L, F>): void;
+
+  setFlowmapState(flowmapState: FlowmapState): Promise<void>;
+
+  // clearData(): void;
+
+  getViewportForLocations(
+    dims: [number, number],
+  ): Promise<ViewportProps | undefined>;
+
+  // getFlowTotals(): Promise<FlowTotals>;
+
+  getFlowByIndex(index: number): Promise<F | AggregateFlow | undefined>;
+
+  getLocationById(id: string | number): Promise<L | Cluster | undefined>;
+
+  getLocationByIndex(idx: number): Promise<L | ClusterNode | undefined>;
+
+  getTotalsForLocation(
+    id: string | number,
+  ): Promise<LocationTotals | undefined>;
+
+  // getLocationsInBbox(
+  //   bbox: [number, number, number, number],
+  // ): Promise<Array<FlowLocation | ClusterNode> | undefined>;
+
+  // 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
+    // TODO: test that they are iterable
+    // Array.isArray(data.locations) &&
+    // Array.isArray(data.flows)
+  );
+}
+
+export function isFlowmapDataProvider<L, F>(
+  dataProvider: Record<string, any>,
+): dataProvider is FlowmapDataProvider<L, F> {
+  return (
+    dataProvider &&
+    typeof dataProvider.setFlowmapState === 'function' &&
+    typeof dataProvider.getViewportForLocations === 'function' &&
+    typeof dataProvider.getFlowByIndex === 'function' &&
+    typeof dataProvider.getLocationById === 'function' &&
+    typeof dataProvider.getLocationByIndex === 'function' &&
+    typeof dataProvider.getLayersData === 'function'
+  );
+}

package/src/provider/LocalFlowmapDataProvider.ts

@@ -0,0 +1,143 @@
+import type FlowmapDataProvider from './FlowmapDataProvider';
+import type {
+  Cluster,
+  ClusterNode,
+  FlowmapData,
+  FlowmapDataAccessors,
+  LayersData,
+  LocationTotals,
+  ViewportProps,
+  AggregateFlow,
+} from '../types';
+import {FlowmapState} from '../FlowmapState';
+import FlowmapSelectors from '../FlowmapSelectors';
+import {
+  GetViewStateOptions,
+  getViewStateForLocations,
+} from '../getViewStateForLocations';
+
+export default class LocalFlowmapDataProvider<L, F>
+  implements FlowmapDataProvider<L, F>
+{
+  private selectors: FlowmapSelectors<L, F>;
+  private flowmapData: FlowmapData<L, F> | undefined;
+  private flowmapState: FlowmapState | undefined;
+
+  constructor(accessors: FlowmapDataAccessors<L, F>) {
+    // scope selectors to the concrete instance of FlowmapDataProvider
+    this.selectors = new FlowmapSelectors<L, F>(accessors);
+    this.flowmapData = undefined;
+    this.flowmapState = undefined;
+  }
+
+  setAccessors(accessors: FlowmapDataAccessors<L, F>) {
+    this.selectors.setAccessors(accessors);
+  }
+
+  setFlowmapData(flowmapData: FlowmapData<L, F>): void {
+    this.flowmapData = flowmapData;
+  }
+
+  getSelectors(): FlowmapSelectors<L, F> {
+    return this.selectors;
+  }
+
+  getFlowmapData(): FlowmapData<L, F> | undefined {
+    return this.flowmapData;
+  }
+
+  async setFlowmapState(flowmapState: FlowmapState): Promise<void> {
+    this.flowmapState = flowmapState;
+  }
+
+  getFlowmapState(): FlowmapState | undefined {
+    return this.flowmapState;
+  }
+
+  async getFlowByIndex(idx: number): Promise<F | AggregateFlow | undefined> {
+    if (!this.flowmapState || !this.flowmapData) {
+      return undefined;
+    }
+    const flows = this.selectors.getFlowsForFlowmapLayer(
+      this.flowmapState,
+      this.flowmapData,
+    );
+    return flows?.[idx];
+  }
+
+  // TODO: this is unreliable, should replace by unqiue ID
+  async getLocationByIndex(idx: number): Promise<L | ClusterNode | undefined> {
+    if (!this.flowmapState || !this.flowmapData) {
+      return undefined;
+    }
+    const locations = this.selectors.getLocationsForFlowmapLayer(
+      this.flowmapState,
+      this.flowmapData,
+    );
+    return locations?.[idx];
+  }
+
+  async getLayersData(): Promise<LayersData | undefined> {
+    if (!this.flowmapState || !this.flowmapData) {
+      return undefined;
+    }
+    return this.selectors.getLayersData(this.flowmapState, this.flowmapData);
+  }
+
+  async getLocationById(id: string | number): Promise<L | Cluster | undefined> {
+    if (!this.flowmapState || !this.flowmapData) {
+      return undefined;
+    }
+    const clusterIndex = this.selectors.getClusterIndex(
+      this.flowmapState,
+      this.flowmapData,
+    );
+    if (clusterIndex) {
+      const cluster = clusterIndex.getClusterById(id);
+      if (cluster) {
+        return cluster;
+      }
+    }
+    const locationsById = this.selectors.getLocationsById(
+      this.flowmapState,
+      this.flowmapData,
+    );
+    return locationsById?.get(id);
+  }
+
+  async getTotalsForLocation(
+    id: string | number,
+  ): Promise<LocationTotals | undefined> {
+    if (!this.flowmapState || !this.flowmapData) {
+      return undefined;
+    }
+    return this.selectors
+      .getLocationTotals(this.flowmapState, this.flowmapData)
+      ?.get(id);
+  }
+
+  async getViewportForLocations(
+    dims: [number, number],
+    opts?: GetViewStateOptions,
+  ): Promise<ViewportProps | undefined> {
+    if (!this.flowmapData?.locations) {
+      return undefined;
+    }
+    // @ts-ignore
+    return getViewStateForLocations(
+      this.flowmapData.locations,
+      (loc) => [
+        this.selectors.accessors.getLocationLon(loc),
+        this.selectors.accessors.getLocationLat(loc),
+      ],
+      dims,
+      opts,
+    );
+  }
+
+  async updateLayersData(
+    setLayersData: (layersData: LayersData | undefined) => void,
+  ) {
+    setLayersData(await this.getLayersData());
+  }
+}

package/src/selector-functions.ts

@@ -0,0 +1,87 @@
+import {WebMercatorViewport} from '@math.gl/web-mercator';
+import {
+  ClusterLevel,
+  isCluster,
+  LocationAccessors,
+  ViewportProps,
+} from './types';
+import {scaleLinear} from 'd3-scale';
+import {ClusterIndex, LocationWeightGetter} from './cluster/ClusterIndex';
+import {descending} from 'd3-array';
+
+// TODO: use re-reselect
+
+export const getViewportBoundingBox = (
+  viewport: ViewportProps,
+  maxLocationCircleSize = 0,
+): [number, number, number, number] => {
+  const pad = maxLocationCircleSize;
+  const bounds = new WebMercatorViewport({
+    ...viewport,
+    width: viewport.width + pad * 2,
+    height: viewport.height + pad * 2,
+  }).getBounds();
+  return [bounds[0][0], bounds[0][1], bounds[1][0], bounds[1][1]];
+};
+
+export const getFlowThicknessScale = (
+  magnitudeExtent: [number, number] | undefined,
+) => {
+  if (!magnitudeExtent) return undefined;
+  return scaleLinear()
+    .range([0.025, 0.5])
+    .domain([
+      0,
+      // should support diff mode too
+      Math.max.apply(
+        null,
+        magnitudeExtent.map((x: number | undefined) => Math.abs(x || 0)),
+      ),
+    ]);
+};
+
+/**
+ * Adding meaningful cluster names.
+ * NOTE: this will mutate the nodes in clusterIndex
+ */
+export function addClusterNames<L, F>(
+  clusterIndex: ClusterIndex<F>,
+  clusterLevels: ClusterLevel[],
+  locationsById: Map<string | number, L>,
+  locationAccessors: LocationAccessors<L>,
+  getLocationWeight: LocationWeightGetter,
+): void {
+  const {getLocationId, getLocationName, getLocationClusterName} =
+    locationAccessors;
+  const getName = (id: string | number) => {
+    const loc = locationsById.get(id);
+    if (loc) {
+      return getLocationName ? getLocationName(loc) : getLocationId(loc) || id;
+    }
+    return `"${id}"`;
+  };
+  for (const level of clusterLevels) {
+    for (const node of level.nodes) {
+      // Here mutating the nodes (adding names)
+      if (isCluster(node)) {
+        const leaves = clusterIndex.expandCluster(node);
+
+        leaves.sort((a, b) =>
+          descending(getLocationWeight(a), getLocationWeight(b)),
+        );
+
+        if (getLocationClusterName) {
+          node.name = getLocationClusterName(leaves);
+        } else {
+          const topId = leaves[0];
+          const otherId = leaves.length === 2 ? leaves[1] : undefined;
+          node.name = `"${getName(topId)}" and ${
+            otherId ? `"${getName(otherId)}"` : `${leaves.length - 1} others`
+          }`;
+        }
+      } else {
+        (node as any).name = getName(node.id);
+      }
+    }
+  }
+}

package/src/types.ts

@@ -1,6 +1,7 @@
-export type FlowMapData<L, F> = {
-  locations: L[] | undefined;
-  flows: F[] | undefined;
+export type FlowmapData<L, F> = {
+  locations: Iterable<L> | undefined;
+  flows: Iterable<F> | undefined;
+  clusterLevels?: ClusterLevels;
 };
 
 export interface ViewState {
@@ -16,24 +17,25 @@ export type FlowAccessor<F, T> = (flow: F) => T; // objectInfo?: AccessorObjectI
 export type LocationAccessor<L, T> = (location: L) => T;
 
 export interface FlowAccessors<F> {
-  getFlowOriginId: FlowAccessor<F, string>;
-  getFlowDestId: FlowAccessor<F, string>;
+  getFlowOriginId: FlowAccessor<F, string | number>;
+  getFlowDestId: FlowAccessor<F, string | number>;
   getFlowMagnitude: FlowAccessor<F, number>;
   getFlowTime?: FlowAccessor<F, Date>; // TODO: use number instead of Date
   // getFlowColor?: FlowAccessor<string | undefined>;
 }
 
 export interface LocationAccessors<L> {
-  getLocationId: LocationAccessor<L, string>;
+  getLocationId: LocationAccessor<L, string | number>;
   getLocationName?: LocationAccessor<L, string>;
-  getLocationCentroid: LocationAccessor<L, [number, number]>;
-  getLocationClusterName?: (locationIds: string[]) => string;
+  getLocationLat: LocationAccessor<L, number>;
+  getLocationLon: LocationAccessor<L, number>;
+  getLocationClusterName?: (locationIds: (string | number)[]) => string;
   // getLocationTotalIn?: LocationAccessor<number>;
   // getLocationTotalOut?: LocationAccessor<number>;
   // getLocationTotalInternal?: LocationAccessor<number>;
 }
 
-export type FlowMapDataAccessors<L, F> = LocationAccessors<L> &
+export type FlowmapDataAccessors<L, F> = LocationAccessors<L> &
   FlowAccessors<F>;
 
 export interface LocationTotals {
@@ -58,9 +60,9 @@ export interface ViewportProps {
   height: number;
   latitude: number;
   longitude: number;
-  zoom: number;
-  bearing: number;
-  pitch: number;
+  zoom?: number;
+  bearing?: number;
+  pitch?: number;
   altitude?: number;
   maxZoom?: number;
   minZoom?: number;
@@ -73,9 +75,10 @@ export interface ViewportProps {
 }
 
 export interface ClusterNode {
-  id: string;
+  id: string | number;
   zoom: number;
-  centroid: [number, number];
+  lat: number;
+  lon: number;
 }
 
 export interface ClusterLevel {
@@ -102,8 +105,8 @@ export function isLocationClusterNode<L>(l: L | ClusterNode): l is ClusterNode {
 }
 
 export interface AggregateFlow {
-  origin: string;
-  dest: string;
+  origin: string | number;
+  dest: string | number;
   count: number;
   aggregate: true;
 }
@@ -113,9 +116,9 @@ export function isAggregateFlow(
 ): flow is AggregateFlow {
   return (
     flow &&
-    flow.origin !== undefined &&
-    flow.dest !== undefined &&
-    flow.count !== undefined &&
+    // flow.origin !== undefined &&
+    // flow.dest !== undefined &&
+    // flow.count !== undefined &&
     (flow.aggregate ? true : false)
   );
 }
@@ -157,6 +160,7 @@ export interface FlowLinesLayerAttributes {
 export interface LayersData {
   circleAttributes: FlowCirclesLayerAttributes;
   lineAttributes: FlowLinesLayerAttributes;
+  locationLabels?: string[];
 }
 
 export type LayersDataAttrValues<T> = {value: T; size: number};

package/src/util.ts

@@ -1,9 +1,5 @@
 import {createSelectorCreator, defaultMemoize} from 'reselect';
 
-export function flatMap<S, T>(xs: S[], f: (item: S) => T | T[]): T[] {
-  return xs.reduce((acc: T[], x: S) => acc.concat(f(x)), []);
-}
-
 export const createDebugSelector = createSelectorCreator(defaultMemoize, {
   equalityCheck: (previousVal: any, currentVal: any) => {
     const rv = currentVal === previousVal;

package/dist/FlowMapAggregateAccessors.d.ts

@@ -1,15 +0,0 @@
-import { AggregateFlow, ClusterNode, FlowMapDataAccessors } from './types';
-export default class FlowMapAggregateAccessors<L, F> {
-    private accessors;
-    constructor(accessors: FlowMapDataAccessors<L, F>);
-    setAccessors(accessors: FlowMapDataAccessors<L, F>): void;
-    getFlowMapDataAccessors(): FlowMapDataAccessors<L, F>;
-    getLocationId: (location: L | ClusterNode) => string;
-    getLocationName: (location: L | ClusterNode) => string;
-    getLocationCentroid: (location: L | ClusterNode) => [number, number];
-    getFlowOriginId: (f: F | AggregateFlow) => string;
-    getFlowDestId: (f: F | AggregateFlow) => string;
-    getFlowMagnitude: (f: F | AggregateFlow) => number;
-    getFlowTime: (f: F) => Date | undefined;
-}
-//# sourceMappingURL=FlowMapAggregateAccessors.d.ts.map

package/dist/FlowMapAggregateAccessors.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"FlowMapAggregateAccessors.d.ts","sourceRoot":"","sources":["../src/FlowMapAggregateAccessors.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,aAAa,EACb,WAAW,EACX,oBAAoB,EAIrB,MAAM,SAAS,CAAC;AAEjB,MAAM,CAAC,OAAO,OAAO,yBAAyB,CAAC,CAAC,EAAE,CAAC;IACjD,OAAO,CAAC,SAAS,CAA6B;gBAClC,SAAS,EAAE,oBAAoB,CAAC,CAAC,EAAE,CAAC,CAAC;IAIjD,YAAY,CAAC,SAAS,EAAE,oBAAoB,CAAC,CAAC,EAAE,CAAC,CAAC;IAIlD,uBAAuB;IAIvB,aAAa,aAAc,CAAC,GAAG,WAAW,KAAG,MAAM,CAGN;IAE7C,eAAe,aAAc,CAAC,GAAG,WAAW,KAAG,MAAM,CAGJ;IAMjD,mBAAmB,aAAc,CAAC,GAAG,WAAW,KAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAGhB;IAEnD,eAAe,MAAO,CAAC,GAAG,aAAa,YAErC;IAEF,aAAa,MAAO,CAAC,GAAG,aAAa,YAEnC;IAEF,gBAAgB,MAAO,CAAC,GAAG,aAAa,YAEtC;IAGF,WAAW,MAAO,CAAC,sBAGjB;CACH"}

package/dist/FlowMapAggregateAccessors.js

@@ -1,43 +0,0 @@
-import { isAggregateFlow, isCluster, isLocationClusterNode, } from './types';
-export default class FlowMapAggregateAccessors {
-    constructor(accessors) {
-        this.getLocationId = (location) => isLocationClusterNode(location)
-            ? location.id
-            : this.accessors.getLocationId(location);
-        this.getLocationName = (location) => {
-            var _a;
-            return (_a = (isLocationClusterNode(location) && isCluster(location)
-                ? location.name
-                : undefined)) !== null && _a !== void 0 ? _a : this.getLocationId(location);
-        };
-        // ? location.name // TODO getLocationName for locations and clusters
-        // : this.accessors.getLocationName
-        // ? this.accessors.getLocationName(location)
-        // : this.getLocationId(location);
-        this.getLocationCentroid = (location) => isLocationClusterNode(location)
-            ? location.centroid
-            : this.accessors.getLocationCentroid(location);
-        this.getFlowOriginId = (f) => {
-            return isAggregateFlow(f) ? f.origin : this.accessors.getFlowOriginId(f);
-        };
-        this.getFlowDestId = (f) => {
-            return isAggregateFlow(f) ? f.dest : this.accessors.getFlowDestId(f);
-        };
-        this.getFlowMagnitude = (f) => {
-            return isAggregateFlow(f) ? f.count : this.accessors.getFlowMagnitude(f);
-        };
-        // Note: Aggregate flows have no time
-        this.getFlowTime = (f) => {
-            const { getFlowTime } = this.accessors;
-            return getFlowTime ? getFlowTime(f) : undefined;
-        };
-        this.accessors = accessors;
-    }
-    setAccessors(accessors) {
-        this.accessors = accessors;
-    }
-    getFlowMapDataAccessors() {
-        return this.accessors;
-    }
-}
-//# sourceMappingURL=data:application/json;base64,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