@flowmap.gl/data 8.0.0-alpha.0

package/dist/FlowMapState.d.ts

@@ -0,0 +1,24 @@
+import { LocationFilterMode, ViewportProps } from './types';
+export interface FilterState {
+    selectedLocations: string[] | undefined;
+    selectedTimeRange: [Date, Date] | undefined;
+    locationFilterMode: LocationFilterMode;
+}
+export interface SettingsState {
+    animationEnabled: boolean;
+    fadeEnabled: boolean;
+    locationTotalsEnabled: boolean;
+    adaptiveScalesEnabled: boolean;
+    clusteringEnabled: boolean;
+    clusteringAuto: boolean;
+    clusteringLevel?: number;
+    darkMode: boolean;
+    fadeAmount: number;
+    colorScheme: string | undefined;
+}
+export interface FlowMapState {
+    filterState: FilterState;
+    settingsState: SettingsState;
+    viewport: ViewportProps;
+}
+//# sourceMappingURL=FlowMapState.d.ts.map

package/dist/FlowMapState.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FlowMapState.d.ts","sourceRoot":"","sources":["../src/FlowMapState.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,kBAAkB,EAAE,aAAa,EAAC,MAAM,SAAS,CAAC;AAE1D,MAAM,WAAW,WAAW;IAC1B,iBAAiB,EAAE,MAAM,EAAE,GAAG,SAAS,CAAC;IACxC,iBAAiB,EAAE,CAAC,IAAI,EAAE,IAAI,CAAC,GAAG,SAAS,CAAC;IAC5C,kBAAkB,EAAE,kBAAkB,CAAC;CACxC;AAED,MAAM,WAAW,aAAa;IAC5B,gBAAgB,EAAE,OAAO,CAAC;IAC1B,WAAW,EAAE,OAAO,CAAC;IACrB,qBAAqB,EAAE,OAAO,CAAC;IAC/B,qBAAqB,EAAE,OAAO,CAAC;IAC/B,iBAAiB,EAAE,OAAO,CAAC;IAC3B,cAAc,EAAE,OAAO,CAAC;IACxB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,QAAQ,EAAE,OAAO,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,GAAG,SAAS,CAAC;CACjC;AAED,MAAM,WAAW,YAAY;IAC3B,WAAW,EAAE,WAAW,CAAC;IACzB,aAAa,EAAE,aAAa,CAAC;IAC7B,QAAQ,EAAE,aAAa,CAAC;CACzB"}

package/dist/FlowMapState.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiRmxvd01hcFN0YXRlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL0Zsb3dNYXBTdGF0ZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtMb2NhdGlvbkZpbHRlck1vZGUsIFZpZXdwb3J0UHJvcHN9IGZyb20gJy4vdHlwZXMnO1xuXG5leHBvcnQgaW50ZXJmYWNlIEZpbHRlclN0YXRlIHtcbiAgc2VsZWN0ZWRMb2NhdGlvbnM6IHN0cmluZ1tdIHwgdW5kZWZpbmVkO1xuICBzZWxlY3RlZFRpbWVSYW5nZTogW0RhdGUsIERhdGVdIHwgdW5kZWZpbmVkO1xuICBsb2NhdGlvbkZpbHRlck1vZGU6IExvY2F0aW9uRmlsdGVyTW9kZTtcbn1cblxuZXhwb3J0IGludGVyZmFjZSBTZXR0aW5nc1N0YXRlIHtcbiAgYW5pbWF0aW9uRW5hYmxlZDogYm9vbGVhbjtcbiAgZmFkZUVuYWJsZWQ6IGJvb2xlYW47XG4gIGxvY2F0aW9uVG90YWxzRW5hYmxlZDogYm9vbGVhbjtcbiAgYWRhcHRpdmVTY2FsZXNFbmFibGVkOiBib29sZWFuO1xuICBjbHVzdGVyaW5nRW5hYmxlZDogYm9vbGVhbjtcbiAgY2x1c3RlcmluZ0F1dG86IGJvb2xlYW47XG4gIGNsdXN0ZXJpbmdMZXZlbD86IG51bWJlcjtcbiAgZGFya01vZGU6IGJvb2xlYW47XG4gIGZhZGVBbW91bnQ6IG51bWJlcjtcbiAgY29sb3JTY2hlbWU6IHN0cmluZyB8IHVuZGVmaW5lZDtcbn1cblxuZXhwb3J0IGludGVyZmFjZSBGbG93TWFwU3RhdGUge1xuICBmaWx0ZXJTdGF0ZTogRmlsdGVyU3RhdGU7XG4gIHNldHRpbmdzU3RhdGU6IFNldHRpbmdzU3RhdGU7XG4gIHZpZXdwb3J0OiBWaWV3cG9ydFByb3BzO1xufVxuIl19

package/dist/cluster/ClusterIndex.d.ts

@@ -0,0 +1,42 @@
+import { AggregateFlow, Cluster, ClusterLevels, ClusterNode, FlowAccessors, FlowCountsMapReduce } from './../types';
+export declare type LocationWeightGetter = (id: string) => number;
+/**
+ * A data structure representing the cluster levels for efficient flow aggregation.
+ */
+export interface ClusterIndex<F> {
+    availableZoomLevels: number[];
+    getClusterById: (clusterId: string) => Cluster | undefined;
+    /**
+     * List the nodes on the given zoom level.
+     */
+    getClusterNodesFor: (zoom: number | undefined) => ClusterNode[] | undefined;
+    /**
+     * Get the min zoom level on which the location is not clustered.
+     */
+    getMinZoomForLocation: (locationId: string) => number;
+    /**
+     * List the IDs of all locations in the cluster (leaves of the subtree starting in the cluster).
+     */
+    expandCluster: (cluster: Cluster, targetZoom?: number) => string[];
+    /**
+     * Find the cluster the given location is residing in on the specified zoom level.
+     */
+    findClusterFor: (locationId: string, zoom: number) => string | undefined;
+    /**
+     * Aggregate flows for the specified zoom level.
+     */
+    aggregateFlows: (flows: F[], zoom: number, { getFlowOriginId, getFlowDestId, getFlowMagnitude }: FlowAccessors<F>, options?: {
+        flowCountsMapReduce?: FlowCountsMapReduce<F>;
+    }) => (F | AggregateFlow)[];
+}
+/**
+ * Build ClusterIndex from the given cluster hierarchy
+ */
+export declare function buildIndex<F>(clusterLevels: ClusterLevels): ClusterIndex<F>;
+export declare function makeLocationWeightGetter<F>(flows: F[], { getFlowOriginId, getFlowDestId, getFlowMagnitude }: FlowAccessors<F>): LocationWeightGetter;
+/**
+ * @param availableZoomLevels Must be sorted in ascending order
+ * @param targetZoom
+ */
+export declare function findAppropriateZoomLevel(availableZoomLevels: number[], targetZoom: number): number;
+//# sourceMappingURL=ClusterIndex.d.ts.map

package/dist/cluster/ClusterIndex.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ClusterIndex.d.ts","sourceRoot":"","sources":["../../src/cluster/ClusterIndex.ts"],"names":[],"mappings":"AAkBA,OAAO,EACL,aAAa,EACb,OAAO,EACP,aAAa,EACb,WAAW,EACX,aAAa,EACb,mBAAmB,EAEpB,MAAM,YAAY,CAAC;AAGpB,oBAAY,oBAAoB,GAAG,CAAC,EAAE,EAAE,MAAM,KAAK,MAAM,CAAC;AAE1D;;GAEG;AACH,MAAM,WAAW,YAAY,CAAC,CAAC;IAC7B,mBAAmB,EAAE,MAAM,EAAE,CAAC;IAC9B,cAAc,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,OAAO,GAAG,SAAS,CAAC;IAC3D;;OAEG;IACH,kBAAkB,EAAE,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,KAAK,WAAW,EAAE,GAAG,SAAS,CAAC;IAC5E;;OAEG;IACH,qBAAqB,EAAE,CAAC,UAAU,EAAE,MAAM,KAAK,MAAM,CAAC;IACtD;;OAEG;IACH,aAAa,EAAE,CAAC,OAAO,EAAE,OAAO,EAAE,UAAU,CAAC,EAAE,MAAM,KAAK,MAAM,EAAE,CAAC;IACnE;;OAEG;IACH,cAAc,EAAE,CAAC,UAAU,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,KAAK,MAAM,GAAG,SAAS,CAAC;IACzE;;OAEG;IACH,cAAc,EAAE,CACd,KAAK,EAAE,CAAC,EAAE,EACV,IAAI,EAAE,MAAM,EACZ,EAAC,eAAe,EAAE,aAAa,EAAE,gBAAgB,EAAC,EAAE,aAAa,CAAC,CAAC,CAAC,EACpE,OAAO,CAAC,EAAE;QACR,mBAAmB,CAAC,EAAE,mBAAmB,CAAC,CAAC,CAAC,CAAC;KAC9C,KACE,CAAC,CAAC,GAAG,aAAa,CAAC,EAAE,CAAC;CAC5B;AAED;;GAEG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,aAAa,EAAE,aAAa,GAAG,YAAY,CAAC,CAAC,CAAC,CAqJ3E;AAED,wBAAgB,wBAAwB,CAAC,CAAC,EACxC,KAAK,EAAE,CAAC,EAAE,EACV,EAAC,eAAe,EAAE,aAAa,EAAE,gBAAgB,EAAC,EAAE,aAAa,CAAC,CAAC,CAAC,GACnE,oBAAoB,CAuBtB;AAED;;;GAGG;AACH,wBAAgB,wBAAwB,CACtC,mBAAmB,EAAE,MAAM,EAAE,EAC7B,UAAU,EAAE,MAAM,UAWnB"}

package/dist/cluster/ClusterIndex.js

@@ -0,0 +1,178 @@
+/*
+ * 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.
+ *
+ */
+import { isCluster, } from './../types';
+import { ascending, bisectLeft, extent } from 'd3-array';
+/**
+ * Build ClusterIndex from the given cluster hierarchy
+ */
+export function buildIndex(clusterLevels) {
+    const nodesByZoom = new Map();
+    const clustersById = new Map();
+    const minZoomByLocationId = new Map();
+    for (const { zoom, nodes } of clusterLevels) {
+        nodesByZoom.set(zoom, nodes);
+        for (const node of nodes) {
+            if (isCluster(node)) {
+                clustersById.set(node.id, node);
+            }
+            else {
+                const { id } = node;
+                const mz = minZoomByLocationId.get(id);
+                if (mz == null || mz > zoom) {
+                    minZoomByLocationId.set(id, zoom);
+                }
+            }
+        }
+    }
+    const [minZoom, maxZoom] = extent(clusterLevels, (cl) => cl.zoom);
+    if (minZoom == null || maxZoom == null) {
+        throw new Error('Could not determine minZoom or maxZoom');
+    }
+    const leavesToClustersByZoom = new Map();
+    for (const cluster of clustersById.values()) {
+        const { zoom } = cluster;
+        let leavesToClusters = leavesToClustersByZoom.get(zoom);
+        if (!leavesToClusters) {
+            leavesToClusters = new Map();
+            leavesToClustersByZoom.set(zoom, leavesToClusters);
+        }
+        visitClusterLeaves(cluster, (leafId) => {
+            leavesToClusters === null || leavesToClusters === void 0 ? void 0 : leavesToClusters.set(leafId, cluster);
+        });
+    }
+    function visitClusterLeaves(cluster, visit) {
+        for (const childId of cluster.children) {
+            const child = clustersById.get(childId);
+            if (child) {
+                visitClusterLeaves(child, visit);
+            }
+            else {
+                visit(childId);
+            }
+        }
+    }
+    const expandCluster = (cluster, targetZoom = maxZoom) => {
+        const ids = [];
+        const visit = (c, expandedIds) => {
+            if (targetZoom > c.zoom) {
+                for (const childId of c.children) {
+                    const child = clustersById.get(childId);
+                    if (child) {
+                        visit(child, expandedIds);
+                    }
+                    else {
+                        expandedIds.push(childId);
+                    }
+                }
+            }
+            else {
+                expandedIds.push(c.id);
+            }
+        };
+        visit(cluster, ids);
+        return ids;
+    };
+    function findClusterFor(locationId, zoom) {
+        const leavesToClusters = leavesToClustersByZoom.get(zoom);
+        if (!leavesToClusters) {
+            return undefined;
+        }
+        const cluster = leavesToClusters.get(locationId);
+        return cluster ? cluster.id : undefined;
+    }
+    const availableZoomLevels = clusterLevels
+        .map((cl) => +cl.zoom)
+        .sort((a, b) => ascending(a, b));
+    return {
+        availableZoomLevels,
+        getClusterNodesFor: (zoom) => {
+            if (zoom === undefined) {
+                return undefined;
+            }
+            return nodesByZoom.get(zoom);
+        },
+        getClusterById: (clusterId) => clustersById.get(clusterId),
+        getMinZoomForLocation: (locationId) => minZoomByLocationId.get(locationId) || minZoom,
+        expandCluster,
+        findClusterFor,
+        aggregateFlows: (flows, zoom, { getFlowOriginId, getFlowDestId, getFlowMagnitude }, options = {}) => {
+            if (zoom > maxZoom) {
+                return flows;
+            }
+            const result = [];
+            const aggFlowsByKey = new Map();
+            const makeKey = (origin, dest) => `${origin}:${dest}`;
+            const { flowCountsMapReduce = {
+                map: getFlowMagnitude,
+                reduce: (acc, count) => (acc || 0) + count,
+            }, } = options;
+            for (const flow of flows) {
+                const origin = getFlowOriginId(flow);
+                const dest = getFlowDestId(flow);
+                const originCluster = findClusterFor(origin, zoom) || origin;
+                const destCluster = findClusterFor(dest, zoom) || dest;
+                const key = makeKey(originCluster, destCluster);
+                if (originCluster === origin && destCluster === dest) {
+                    result.push(flow);
+                }
+                else {
+                    let aggregateFlow = aggFlowsByKey.get(key);
+                    if (!aggregateFlow) {
+                        aggregateFlow = {
+                            origin: originCluster,
+                            dest: destCluster,
+                            count: flowCountsMapReduce.map(flow),
+                            aggregate: true,
+                        };
+                        result.push(aggregateFlow);
+                        aggFlowsByKey.set(key, aggregateFlow);
+                    }
+                    else {
+                        aggregateFlow.count = flowCountsMapReduce.reduce(aggregateFlow.count, flowCountsMapReduce.map(flow));
+                    }
+                }
+            }
+            return result;
+        },
+    };
+}
+export function makeLocationWeightGetter(flows, { getFlowOriginId, getFlowDestId, getFlowMagnitude }) {
+    const locationTotals = {
+        incoming: new Map(),
+        outgoing: new Map(),
+    };
+    for (const flow of flows) {
+        const origin = getFlowOriginId(flow);
+        const dest = getFlowDestId(flow);
+        const count = getFlowMagnitude(flow);
+        locationTotals.incoming.set(dest, (locationTotals.incoming.get(dest) || 0) + count);
+        locationTotals.outgoing.set(origin, (locationTotals.outgoing.get(origin) || 0) + count);
+    }
+    return (id) => Math.max(Math.abs(locationTotals.incoming.get(id) || 0), Math.abs(locationTotals.outgoing.get(id) || 0));
+}
+/**
+ * @param availableZoomLevels Must be sorted in ascending order
+ * @param targetZoom
+ */
+export function findAppropriateZoomLevel(availableZoomLevels, targetZoom) {
+    if (!availableZoomLevels.length) {
+        throw new Error('No available zoom levels');
+    }
+    return availableZoomLevels[Math.min(bisectLeft(availableZoomLevels, Math.floor(targetZoom)), availableZoomLevels.length - 1)];
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ClusterIndex.js","sourceRoot":"","sources":["../../src/cluster/ClusterIndex.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * Copyright 2022 FlowmapBlue\n * Copyright 2018-2020 Teralytics, modified by FlowmapBlue\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n *\n */\n\nimport {\n  AggregateFlow,\n  Cluster,\n  ClusterLevels,\n  ClusterNode,\n  FlowAccessors,\n  FlowCountsMapReduce,\n  isCluster,\n} from './../types';\nimport {ascending, bisectLeft, extent} from 'd3-array';\n\nexport type LocationWeightGetter = (id: string) => number;\n\n/**\n * A data structure representing the cluster levels for efficient flow aggregation.\n */\nexport interface ClusterIndex<F> {\n  availableZoomLevels: number[];\n  getClusterById: (clusterId: string) => Cluster | undefined;\n  /**\n   * List the nodes on the given zoom level.\n   */\n  getClusterNodesFor: (zoom: number | undefined) => ClusterNode[] | undefined;\n  /**\n   * Get the min zoom level on which the location is not clustered.\n   */\n  getMinZoomForLocation: (locationId: string) => number;\n  /**\n   * List the IDs of all locations in the cluster (leaves of the subtree starting in the cluster).\n   */\n  expandCluster: (cluster: Cluster, targetZoom?: number) => string[];\n  /**\n   * Find the cluster the given location is residing in on the specified zoom level.\n   */\n  findClusterFor: (locationId: string, zoom: number) => string | undefined;\n  /**\n   * Aggregate flows for the specified zoom level.\n   */\n  aggregateFlows: (\n    flows: F[],\n    zoom: number,\n    {getFlowOriginId, getFlowDestId, getFlowMagnitude}: FlowAccessors<F>,\n    options?: {\n      flowCountsMapReduce?: FlowCountsMapReduce<F>;\n    },\n  ) => (F | AggregateFlow)[];\n}\n\n/**\n * Build ClusterIndex from the given cluster hierarchy\n */\nexport function buildIndex<F>(clusterLevels: ClusterLevels): ClusterIndex<F> {\n  const nodesByZoom = new Map<number, ClusterNode[]>();\n  const clustersById = new Map<string, Cluster>();\n  const minZoomByLocationId = new Map<string, number>();\n  for (const {zoom, nodes} of clusterLevels) {\n    nodesByZoom.set(zoom, nodes);\n    for (const node of nodes) {\n      if (isCluster(node)) {\n        clustersById.set(node.id, node);\n      } else {\n        const {id} = node;\n        const mz = minZoomByLocationId.get(id);\n        if (mz == null || mz > zoom) {\n          minZoomByLocationId.set(id, zoom);\n        }\n      }\n    }\n  }\n\n  const [minZoom, maxZoom] = extent(clusterLevels, (cl) => cl.zoom);\n  if (minZoom == null || maxZoom == null) {\n    throw new Error('Could not determine minZoom or maxZoom');\n  }\n\n  const leavesToClustersByZoom = new Map<number, Map<string, Cluster>>();\n\n  for (const cluster of clustersById.values()) {\n    const {zoom} = cluster;\n    let leavesToClusters = leavesToClustersByZoom.get(zoom);\n    if (!leavesToClusters) {\n      leavesToClusters = new Map<string, Cluster>();\n      leavesToClustersByZoom.set(zoom, leavesToClusters);\n    }\n    visitClusterLeaves(cluster, (leafId) => {\n      leavesToClusters?.set(leafId, cluster);\n    });\n  }\n\n  function visitClusterLeaves(cluster: Cluster, visit: (id: string) => void) {\n    for (const childId of cluster.children) {\n      const child = clustersById.get(childId);\n      if (child) {\n        visitClusterLeaves(child, visit);\n      } else {\n        visit(childId);\n      }\n    }\n  }\n\n  const expandCluster = (cluster: Cluster, targetZoom: number = maxZoom) => {\n    const ids: string[] = [];\n    const visit = (c: Cluster, expandedIds: string[]) => {\n      if (targetZoom > c.zoom) {\n        for (const childId of c.children) {\n          const child = clustersById.get(childId);\n          if (child) {\n            visit(child, expandedIds);\n          } else {\n            expandedIds.push(childId);\n          }\n        }\n      } else {\n        expandedIds.push(c.id);\n      }\n    };\n    visit(cluster, ids);\n    return ids;\n  };\n\n  function findClusterFor(locationId: string, zoom: number) {\n    const leavesToClusters = leavesToClustersByZoom.get(zoom);\n    if (!leavesToClusters) {\n      return undefined;\n    }\n    const cluster = leavesToClusters.get(locationId);\n    return cluster ? cluster.id : undefined;\n  }\n\n  const availableZoomLevels = clusterLevels\n    .map((cl) => +cl.zoom)\n    .sort((a, b) => ascending(a, b));\n\n  return {\n    availableZoomLevels,\n\n    getClusterNodesFor: (zoom) => {\n      if (zoom === undefined) {\n        return undefined;\n      }\n      return nodesByZoom.get(zoom);\n    },\n\n    getClusterById: (clusterId) => clustersById.get(clusterId),\n\n    getMinZoomForLocation: (locationId) =>\n      minZoomByLocationId.get(locationId) || minZoom,\n\n    expandCluster,\n\n    findClusterFor,\n\n    aggregateFlows: (\n      flows,\n      zoom,\n      {getFlowOriginId, getFlowDestId, getFlowMagnitude},\n      options = {},\n    ) => {\n      if (zoom > maxZoom) {\n        return flows;\n      }\n      const result: (F | AggregateFlow)[] = [];\n      const aggFlowsByKey = new Map<string, AggregateFlow>();\n      const makeKey = (origin: string, dest: string) => `${origin}:${dest}`;\n      const {\n        flowCountsMapReduce = {\n          map: getFlowMagnitude,\n          reduce: (acc: any, count: number) => (acc || 0) + count,\n        },\n      } = options;\n      for (const flow of flows) {\n        const origin = getFlowOriginId(flow);\n        const dest = getFlowDestId(flow);\n        const originCluster = findClusterFor(origin, zoom) || origin;\n        const destCluster = findClusterFor(dest, zoom) || dest;\n        const key = makeKey(originCluster, destCluster);\n        if (originCluster === origin && destCluster === dest) {\n          result.push(flow);\n        } else {\n          let aggregateFlow = aggFlowsByKey.get(key);\n          if (!aggregateFlow) {\n            aggregateFlow = {\n              origin: originCluster,\n              dest: destCluster,\n              count: flowCountsMapReduce.map(flow),\n              aggregate: true,\n            };\n            result.push(aggregateFlow);\n            aggFlowsByKey.set(key, aggregateFlow);\n          } else {\n            aggregateFlow.count = flowCountsMapReduce.reduce(\n              aggregateFlow.count,\n              flowCountsMapReduce.map(flow),\n            );\n          }\n        }\n      }\n      return result;\n    },\n  };\n}\n\nexport function makeLocationWeightGetter<F>(\n  flows: F[],\n  {getFlowOriginId, getFlowDestId, getFlowMagnitude}: FlowAccessors<F>,\n): LocationWeightGetter {\n  const locationTotals = {\n    incoming: new Map<string, number>(),\n    outgoing: new Map<string, number>(),\n  };\n  for (const flow of flows) {\n    const origin = getFlowOriginId(flow);\n    const dest = getFlowDestId(flow);\n    const count = getFlowMagnitude(flow);\n    locationTotals.incoming.set(\n      dest,\n      (locationTotals.incoming.get(dest) || 0) + count,\n    );\n    locationTotals.outgoing.set(\n      origin,\n      (locationTotals.outgoing.get(origin) || 0) + count,\n    );\n  }\n  return (id: string) =>\n    Math.max(\n      Math.abs(locationTotals.incoming.get(id) || 0),\n      Math.abs(locationTotals.outgoing.get(id) || 0),\n    );\n}\n\n/**\n * @param availableZoomLevels Must be sorted in ascending order\n * @param targetZoom\n */\nexport function findAppropriateZoomLevel(\n  availableZoomLevels: number[],\n  targetZoom: number,\n) {\n  if (!availableZoomLevels.length) {\n    throw new Error('No available zoom levels');\n  }\n  return availableZoomLevels[\n    Math.min(\n      bisectLeft(availableZoomLevels, Math.floor(targetZoom)),\n      availableZoomLevels.length - 1,\n    )\n  ];\n}\n"]}

package/dist/cluster/cluster.d.ts

@@ -0,0 +1,31 @@
+import { LocationWeightGetter } from './ClusterIndex';
+import { ClusterLevel, LocationAccessors } from '../types';
+export interface Options {
+    minZoom: number;
+    maxZoom: number;
+    radius: number;
+    extent: number;
+    nodeSize: number;
+    makeClusterName: (id: number, numPoints: number) => string | undefined;
+    makeClusterId: (id: number) => string;
+}
+interface BasePoint {
+    x: number;
+    y: number;
+    weight: number;
+    zoom: number;
+    parentId: number;
+}
+interface LeafPoint extends BasePoint {
+    index: number;
+}
+interface ClusterPoint extends BasePoint {
+    id: number;
+    numPoints: number;
+}
+declare type Point = LeafPoint | ClusterPoint;
+export declare function isLeafPoint(p: Point): p is LeafPoint;
+export declare function isClusterPoint(p: Point): p is ClusterPoint;
+export declare function clusterLocations<L>(locations: L[], locationAccessors: LocationAccessors<L>, getLocationWeight: LocationWeightGetter, options?: Partial<Options>): ClusterLevel[];
+export {};
+//# sourceMappingURL=cluster.d.ts.map

package/dist/cluster/cluster.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cluster.d.ts","sourceRoot":"","sources":["../../src/cluster/cluster.ts"],"names":[],"mappings":"AAwCA,OAAO,EAAC,oBAAoB,EAAC,MAAM,gBAAgB,CAAC;AACpD,OAAO,EAAU,YAAY,EAAe,iBAAiB,EAAC,MAAM,UAAU,CAAC;AAE/E,MAAM,WAAW,OAAO;IACtB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,eAAe,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,KAAK,MAAM,GAAG,SAAS,CAAC;IACvE,aAAa,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,MAAM,CAAC;CACvC;AAYD,UAAU,SAAS;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,UAAU,SAAU,SAAQ,SAAS;IACnC,KAAK,EAAE,MAAM,CAAC;CACf;AAED,UAAU,YAAa,SAAQ,SAAS;IACtC,EAAE,EAAE,MAAM,CAAC;IACX,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,aAAK,KAAK,GAAG,SAAS,GAAG,YAAY,CAAC;AAEtC,wBAAgB,WAAW,CAAC,CAAC,EAAE,KAAK,GAAG,CAAC,IAAI,SAAS,CAGpD;AAED,wBAAgB,cAAc,CAAC,CAAC,EAAE,KAAK,GAAG,CAAC,IAAI,YAAY,CAG1D;AAID,wBAAgB,gBAAgB,CAAC,CAAC,EAChC,SAAS,EAAE,CAAC,EAAE,EACd,iBAAiB,EAAE,iBAAiB,CAAC,CAAC,CAAC,EACvC,iBAAiB,EAAE,oBAAoB,EACvC,OAAO,CAAC,EAAE,OAAO,CAAC,OAAO,CAAC,GACzB,YAAY,EAAE,CA2FhB"}

package/dist/cluster/cluster.js

@@ -0,0 +1,206 @@
+/*
+ * 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
+ */
+// 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 KDBush from 'kdbush';
+const defaultOptions = {
+    minZoom: 0,
+    maxZoom: 16,
+    radius: 40,
+    extent: 512,
+    nodeSize: 64,
+    makeClusterName: (id, numPoints) => undefined,
+    makeClusterId: (id) => `{[${id}]}`,
+};
+export function isLeafPoint(p) {
+    const { index } = p;
+    return index != null;
+}
+export function isClusterPoint(p) {
+    const { id } = p;
+    return id != null;
+}
+export function clusterLocations(locations, locationAccessors, getLocationWeight, options) {
+    const { getLocationCentroid, getLocationId } = locationAccessors;
+    const opts = Object.assign(Object.assign({}, defaultOptions), options);
+    const { minZoom, maxZoom, nodeSize, makeClusterName, makeClusterId } = opts;
+    const trees = new Array(maxZoom + 1);
+    // generate a cluster object for each point and index input points into a KD-tree
+    let clusters = new Array();
+    for (let i = 0; i < locations.length; i++) {
+        const [x, y] = getLocationCentroid(locations[i]);
+        clusters.push({
+            x: lngX(x),
+            y: latY(y),
+            weight: getLocationWeight(getLocationId(locations[i])),
+            zoom: Infinity,
+            index: i,
+            parentId: -1, // parent cluster id
+        });
+    }
+    trees[maxZoom + 1] = new KDBush(clusters, getX, getY, nodeSize, Float32Array);
+    // cluster points on max zoom, then cluster the results on previous zoom, etc.;
+    // results in a cluster hierarchy across zoom levels
+    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);
+    }
+    if (trees.length === 0) {
+        return [];
+    }
+    const numbersOfClusters = trees.map((d) => d.points.length);
+    const maxAvailZoom = numbersOfClusters.indexOf(numbersOfClusters[numbersOfClusters.length - 1]);
+    const minAvailZoom = Math.min(maxAvailZoom, numbersOfClusters.lastIndexOf(numbersOfClusters[0]));
+    const clusterLevels = new Array();
+    for (let zoom = minAvailZoom; zoom <= maxAvailZoom; zoom++) {
+        let childrenByParent;
+        const tree = trees[zoom];
+        if (zoom < maxAvailZoom) {
+            childrenByParent = rollup(trees[zoom + 1].points, (points) => points.map((p) => p.id ? makeClusterId(p.id) : getLocationId(locations[p.index])), (point) => point.parentId);
+        }
+        const nodes = [];
+        for (const point of tree.points) {
+            const { x, y, numPoints } = point;
+            if (isLeafPoint(point)) {
+                const location = locations[point.index];
+                nodes.push({
+                    id: getLocationId(location),
+                    zoom,
+                    centroid: getLocationCentroid(location),
+                });
+            }
+            else if (isClusterPoint(point)) {
+                const { id } = point;
+                const children = childrenByParent && childrenByParent.get(id);
+                if (!children) {
+                    throw new Error(`Cluster ${id} doesn't have children`);
+                }
+                nodes.push({
+                    id: makeClusterId(id),
+                    name: makeClusterName(id, numPoints),
+                    zoom,
+                    centroid: [xLng(x), yLat(y)],
+                    children,
+                });
+            }
+        }
+        clusterLevels.push({
+            zoom,
+            nodes,
+        });
+    }
+    return clusterLevels;
+}
+function createCluster(x, y, id, numPoints, weight) {
+    return {
+        x,
+        y,
+        zoom: Infinity,
+        id,
+        parentId: -1,
+        numPoints,
+        weight,
+    };
+}
+function cluster(points, zoom, tree, options) {
+    const clusters = [];
+    const { radius, extent } = options;
+    const r = radius / (extent * Math.pow(2, zoom));
+    // loop through each point
+    for (let i = 0; i < points.length; i++) {
+        const p = points[i];
+        // if we've already visited the point at this zoom level, skip it
+        if (p.zoom <= zoom) {
+            continue;
+        }
+        p.zoom = zoom;
+        // find all nearby points
+        const neighborIds = tree.within(p.x, p.y, r);
+        let weight = p.weight || 1;
+        let numPoints = isClusterPoint(p) ? p.numPoints : 1;
+        let wx = p.x * weight;
+        let wy = p.y * weight;
+        // encode both zoom and point index on which the cluster originated
+        const id = (i << 5) + (zoom + 1);
+        for (const neighborId of neighborIds) {
+            const b = tree.points[neighborId];
+            // filter out neighbors that are already processed
+            if (b.zoom <= zoom) {
+                continue;
+            }
+            b.zoom = zoom; // save the zoom (so it doesn't get processed twice)
+            const weight2 = b.weight || 1;
+            const numPoints2 = b.numPoints || 1;
+            wx += b.x * weight2; // accumulate coordinates for calculating weighted center
+            wy += b.y * weight2;
+            weight += weight2;
+            numPoints += numPoints2;
+            b.parentId = id;
+        }
+        if (numPoints === 1) {
+            clusters.push(p);
+        }
+        else {
+            p.parentId = id;
+            clusters.push(createCluster(wx / weight, wy / weight, id, numPoints, weight));
+        }
+    }
+    return clusters;
+}
+// spherical mercator to longitude/latitude
+function xLng(x) {
+    return (x - 0.5) * 360;
+}
+function yLat(y) {
+    const y2 = ((180 - y * 360) * Math.PI) / 180;
+    return (360 * Math.atan(Math.exp(y2))) / Math.PI - 90;
+}
+// longitude/latitude to spherical mercator in [0..1] range
+function lngX(lng) {
+    return lng / 360 + 0.5;
+}
+function latY(lat) {
+    const sin = Math.sin((lat * Math.PI) / 180);
+    const y = 0.5 - (0.25 * Math.log((1 + sin) / (1 - sin))) / Math.PI;
+    return y < 0 ? 0 : y > 1 ? 1 : y;
+}
+function getX(p) {
+    return p.x;
+}
+function getY(p) {
+    return p.y;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cluster.js","sourceRoot":"","sources":["../../src/cluster/cluster.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * Copyright 2022 FlowmapBlue\n * Copyright 2018-2020 Teralytics, modified by FlowmapBlue\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n *\n */\n\n/**\n * The code in this file is a based on https://github.com/mapbox/supercluster\n */\n\n// ISC License\n//\n// Copyright (c) 2016, Mapbox\n//\n// Permission to use, copy, modify, and/or distribute this software for any purpose\n// with or without fee is hereby granted, provided that the above copyright notice\n// and this permission notice appear in all copies.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\n// REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND\n// FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\n// INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS\n// OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER\n// TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF\n// THIS SOFTWARE.\n\nimport {rollup} from 'd3-array';\nimport KDBush from 'kdbush';\nimport {LocationWeightGetter} from './ClusterIndex';\nimport {Cluster, ClusterLevel, ClusterNode, LocationAccessors} from '../types';\n\nexport interface Options {\n  minZoom: number; // min zoom to generate clusters on\n  maxZoom: number; // max zoom level to cluster the points on\n  radius: number; // cluster radius in pixels\n  extent: number; // tile extent (radius is calculated relative to it)\n  nodeSize: number; // size of the KD-tree leaf node, affects performance\n  makeClusterName: (id: number, numPoints: number) => string | undefined;\n  makeClusterId: (id: number) => string;\n}\n\nconst defaultOptions: Options = {\n  minZoom: 0,\n  maxZoom: 16,\n  radius: 40,\n  extent: 512,\n  nodeSize: 64,\n  makeClusterName: (id: number, numPoints: number) => undefined,\n  makeClusterId: (id: number) => `{[${id}]}`,\n};\n\ninterface BasePoint {\n  x: number; // projected point coordinates\n  y: number;\n  weight: number;\n  zoom: number; // the last zoom the point was processed at\n  parentId: number; // parent cluster id\n}\n\ninterface LeafPoint extends BasePoint {\n  index: number; // index of the source feature in the original input array,\n}\n\ninterface ClusterPoint extends BasePoint {\n  id: number;\n  numPoints: number;\n}\n\ntype Point = LeafPoint | ClusterPoint;\n\nexport function isLeafPoint(p: Point): p is LeafPoint {\n  const {index} = p as LeafPoint;\n  return index != null;\n}\n\nexport function isClusterPoint(p: Point): p is ClusterPoint {\n  const {id} = p as ClusterPoint;\n  return id != null;\n}\n\ntype ZoomLevelKDBush = any;\n\nexport function clusterLocations<L>(\n  locations: L[],\n  locationAccessors: LocationAccessors<L>,\n  getLocationWeight: LocationWeightGetter,\n  options?: Partial<Options>,\n): ClusterLevel[] {\n  const {getLocationCentroid, getLocationId} = locationAccessors;\n  const opts = {\n    ...defaultOptions,\n    ...options,\n  };\n  const {minZoom, maxZoom, nodeSize, makeClusterName, makeClusterId} = opts;\n\n  const trees = new Array<ZoomLevelKDBush>(maxZoom + 1);\n\n  // generate a cluster object for each point and index input points into a KD-tree\n  let clusters = new Array<Point>();\n  for (let i = 0; i < locations.length; i++) {\n    const [x, y] = getLocationCentroid(locations[i]);\n    clusters.push({\n      x: lngX(x), // projected point coordinates\n      y: latY(y),\n      weight: getLocationWeight(getLocationId(locations[i])),\n      zoom: Infinity, // the last zoom the point was processed at\n      index: i, // index of the source feature in the original input array,\n      parentId: -1, // parent cluster id\n    });\n  }\n  trees[maxZoom + 1] = new KDBush(clusters, getX, getY, nodeSize, Float32Array);\n\n  // cluster points on max zoom, then cluster the results on previous zoom, etc.;\n  // results in a cluster hierarchy across zoom levels\n  for (let z = maxZoom; z >= minZoom; z--) {\n    // create a new set of clusters for the zoom and index them with a KD-tree\n    clusters = cluster(clusters, z, trees[z + 1], opts);\n    trees[z] = new KDBush(clusters, getX, getY, nodeSize, Float32Array);\n  }\n\n  if (trees.length === 0) {\n    return [];\n  }\n  const numbersOfClusters = trees.map((d) => d.points.length);\n  const maxAvailZoom = numbersOfClusters.indexOf(\n    numbersOfClusters[numbersOfClusters.length - 1],\n  );\n  const minAvailZoom = Math.min(\n    maxAvailZoom,\n    numbersOfClusters.lastIndexOf(numbersOfClusters[0]),\n  );\n\n  const clusterLevels = new Array<ClusterLevel>();\n  for (let zoom = minAvailZoom; zoom <= maxAvailZoom; zoom++) {\n    let childrenByParent: Map<number, string[]> | undefined;\n    const tree = trees[zoom];\n    if (zoom < maxAvailZoom) {\n      childrenByParent = rollup<Point, string[], number>(\n        trees[zoom + 1].points,\n        (points: any[]) =>\n          points.map((p: any) =>\n            p.id ? makeClusterId(p.id) : getLocationId(locations[p.index]),\n          ),\n        (point: any) => point.parentId,\n      );\n    }\n\n    const nodes: ClusterNode[] = [];\n    for (const point of tree.points) {\n      const {x, y, numPoints} = point;\n      if (isLeafPoint(point)) {\n        const location = locations[point.index];\n        nodes.push({\n          id: getLocationId(location),\n          zoom,\n          centroid: getLocationCentroid(location),\n        });\n      } else if (isClusterPoint(point)) {\n        const {id} = point;\n        const children = childrenByParent && childrenByParent.get(id);\n        if (!children) {\n          throw new Error(`Cluster ${id} doesn't have children`);\n        }\n        nodes.push({\n          id: makeClusterId(id),\n          name: makeClusterName(id, numPoints),\n          zoom,\n          centroid: [xLng(x), yLat(y)] as [number, number],\n          children,\n        } as Cluster);\n      }\n    }\n    clusterLevels.push({\n      zoom,\n      nodes,\n    });\n  }\n  return clusterLevels;\n}\n\nfunction createCluster(\n  x: number,\n  y: number,\n  id: number,\n  numPoints: number,\n  weight: number,\n): ClusterPoint {\n  return {\n    x, // weighted cluster center\n    y,\n    zoom: Infinity, // the last zoom the cluster was processed at\n    id, // encodes index of the first child of the cluster and its zoom level\n    parentId: -1, // parent cluster id\n    numPoints,\n    weight,\n  };\n}\n\nfunction cluster(\n  points: Point[],\n  zoom: number,\n  tree: ZoomLevelKDBush,\n  options: Options,\n) {\n  const clusters: Point[] = [];\n  const {radius, extent} = options;\n  const r = radius / (extent * Math.pow(2, zoom));\n\n  // loop through each point\n  for (let i = 0; i < points.length; i++) {\n    const p = points[i];\n    // if we've already visited the point at this zoom level, skip it\n    if (p.zoom <= zoom) {\n      continue;\n    }\n    p.zoom = zoom;\n\n    // find all nearby points\n    const neighborIds = tree.within(p.x, p.y, r);\n\n    let weight = p.weight || 1;\n    let numPoints = isClusterPoint(p) ? p.numPoints : 1;\n    let wx = p.x * weight;\n    let wy = p.y * weight;\n\n    // encode both zoom and point index on which the cluster originated\n    const id = (i << 5) + (zoom + 1);\n\n    for (const neighborId of neighborIds) {\n      const b = tree.points[neighborId];\n      // filter out neighbors that are already processed\n      if (b.zoom <= zoom) {\n        continue;\n      }\n      b.zoom = zoom; // save the zoom (so it doesn't get processed twice)\n\n      const weight2 = b.weight || 1;\n      const numPoints2 = b.numPoints || 1;\n      wx += b.x * weight2; // accumulate coordinates for calculating weighted center\n      wy += b.y * weight2;\n\n      weight += weight2;\n      numPoints += numPoints2;\n      b.parentId = id;\n    }\n\n    if (numPoints === 1) {\n      clusters.push(p);\n    } else {\n      p.parentId = id;\n      clusters.push(\n        createCluster(wx / weight, wy / weight, id, numPoints, weight),\n      );\n    }\n  }\n\n  return clusters;\n}\n\n// spherical mercator to longitude/latitude\nfunction xLng(x: number) {\n  return (x - 0.5) * 360;\n}\n\nfunction yLat(y: number) {\n  const y2 = ((180 - y * 360) * Math.PI) / 180;\n  return (360 * Math.atan(Math.exp(y2))) / Math.PI - 90;\n}\n\n// longitude/latitude to spherical mercator in [0..1] range\nfunction lngX(lng: number) {\n  return lng / 360 + 0.5;\n}\n\nfunction latY(lat: number) {\n  const sin = Math.sin((lat * Math.PI) / 180);\n  const y = 0.5 - (0.25 * Math.log((1 + sin) / (1 - sin))) / Math.PI;\n  return y < 0 ? 0 : y > 1 ? 1 : y;\n}\n\nfunction getX(p: Point) {\n  return p.x;\n}\n\nfunction getY(p: Point) {\n  return p.y;\n}\n"]}