@fscharter/flowmap-data 8.0.2-fsc.1

package/dist/cluster/cluster.js

@@ -0,0 +1,267 @@
+/*
+ * Copyright (c) Flowmap.gl contributors
+ * Copyright (c) 2018-2020 Teralytics
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { min, 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 { getLocationLon, getLocationLat, getLocationId } = locationAccessors;
+    const opts = {
+        ...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();
+    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(location)),
+            zoom: Infinity, // the last zoom the point was processed at
+            index: locationsCount, // index of the source feature in the original input array,
+            parentId: -1, // parent cluster id
+            location,
+        });
+        locationsCount++;
+    }
+    const makeBush = (points) => {
+        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
+        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 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, minClusters ? numbersOfClusters.lastIndexOf(minClusters) : maxAvailZoom);
+    const clusterLevels = new Array();
+    prevZoom = NaN;
+    for (let zoom = maxAvailZoom; zoom >= minAvailZoom; zoom--) {
+        let childrenByParent;
+        const tree = trees[zoom];
+        if (!tree)
+            continue;
+        if (trees[prevZoom] && zoom < maxAvailZoom) {
+            childrenByParent = rollup(trees[prevZoom].points, (points) => points.map((p) => p.id ? makeClusterId(p.id) : getLocationId(p.location)), (point) => point.parentId);
+        }
+        const nodes = [];
+        for (const point of tree.points) {
+            const { x, y, numPoints, location } = point;
+            if (isLeafPoint(point)) {
+                nodes.push({
+                    id: getLocationId(location),
+                    zoom,
+                    lat: getLocationLat(location),
+                    lon: getLocationLon(location),
+                });
+            }
+            else if (isClusterPoint(point)) {
+                const { id } = point;
+                const children = childrenByParent && childrenByParent.get(id);
+                if (!children) {
+                    // Might happen if there are multiple locations with same coordinates
+                    console.warn(`Omitting cluster with no children, point:`, point);
+                    continue;
+                }
+                const cluster = {
+                    id: makeClusterId(id),
+                    name: makeClusterName(id, numPoints),
+                    zoom,
+                    lat: yLat(y),
+                    lon: xLng(x),
+                    children: children ?? [],
+                };
+                nodes.push(cluster);
+            }
+        }
+        clusterLevels.push({
+            zoom,
+            nodes,
+        });
+        prevZoom = zoom;
+    }
+    return clusterLevels;
+}
+function createCluster(x, y, id, numPoints, weight) {
+    return {
+        x, // weighted cluster center
+        y,
+        zoom: Infinity, // the last zoom the cluster was processed at
+        id, // encodes index of the first child of the cluster and its zoom level
+        parentId: -1, // parent cluster id
+        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;
+}
+function countUniqueLocations(locations, locationAccessors) {
+    const { getLocationLon, getLocationLat } = locationAccessors;
+    const countByLatLon = new Map();
+    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) {
+    let max = -Infinity;
+    let maxIndex = 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(arr, predicate) {
+    for (let i = arr.length - 1; i >= 0; i--) {
+        if (predicate(arr[i], i, arr)) {
+            return i;
+        }
+    }
+    return -1;
+}
+//# 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 (c) Flowmap.gl contributors\n * Copyright (c) 2018-2020 Teralytics\n * SPDX-License-Identifier: Apache-2.0\n */\n\nimport {min, rollup} from 'd3-array';\nimport KDBush from 'kdbush';\nimport {LocationWeightGetter} from './ClusterIndex';\nimport {Cluster, ClusterLevel, ClusterNode, LocationAccessors} from '../types';\n\n/**\n * The code in this file is a based on https://github.com/mapbox/supercluster\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 */\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<L> extends BasePoint {\n  index: number; // index of the source feature in the original input array,\n  location: L;\n}\n\ninterface ClusterPoint extends BasePoint {\n  id: number;\n  numPoints: number;\n}\n\ntype Point<L> = LeafPoint<L> | ClusterPoint;\n\nexport function isLeafPoint<L>(p: Point<L>): p is LeafPoint<L> {\n  const {index} = p as LeafPoint<L>;\n  return index != null;\n}\n\nexport function isClusterPoint<L>(p: Point<L>): 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: Iterable<L>,\n  locationAccessors: LocationAccessors<L>,\n  getLocationWeight: LocationWeightGetter,\n  options?: Partial<Options>,\n): ClusterLevel[] {\n  const {getLocationLon, getLocationLat, 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<L>>();\n  let locationsCount = 0;\n  for (const location of locations) {\n    const x = getLocationLon(location);\n    const y = getLocationLat(location);\n    clusters.push({\n      x: lngX(x), // projected point coordinates\n      y: latY(y),\n      weight: getLocationWeight(getLocationId(location)),\n      zoom: Infinity, // the last zoom the point was processed at\n      index: locationsCount, // index of the source feature in the original input array,\n      parentId: -1, // parent cluster id\n      location,\n    });\n    locationsCount++;\n  }\n\n  const makeBush = (points: Point<L>[]) => {\n    const bush = new KDBush(points.length, nodeSize, Float32Array);\n    for (let i = 0; i < points.length; i++) {\n      bush.add(points[i].x, points[i].y);\n    }\n    bush.finish();\n    bush.points = points;\n    return bush;\n  };\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  trees[maxZoom + 1] = makeBush(clusters);\n  let prevZoom = maxZoom + 1;\n\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    const _clusters = cluster(clusters, z, trees[prevZoom], opts);\n    if (_clusters.length === clusters.length) {\n      // same number of clusters => move the higher level clusters up\n      // no need to keep the same data on multiple levels\n      trees[z] = trees[prevZoom];\n      trees[prevZoom] = undefined;\n      prevZoom = z;\n      clusters = _clusters;\n    } else {\n      prevZoom = z;\n      clusters = _clusters;\n      trees[z] = makeBush(clusters);\n    }\n  }\n\n  if (trees.length === 0) {\n    return [];\n  }\n\n  const numbersOfClusters: number[] = trees.map((d) => d?.points.length);\n  const minClusters = min(numbersOfClusters.filter((d) => d > 0));\n\n  let maxAvailZoom =\n    findIndexOfMax(numbersOfClusters) ?? numbersOfClusters.length - 1;\n\n  const numUniqueLocations = countUniqueLocations(locations, locationAccessors);\n  if (numUniqueLocations < locationsCount) {\n    // Duplicate locations would be clustered together at any zoom level which can lead to having too many zooms.\n    // To avoid that, we need to find the max zoom level that has less or equal clusters than unique locations\n    // and drop all zoom levels beyond that (except the unclustered level).\n    const maxClustersZoom = findLastIndex(\n      numbersOfClusters,\n      (d) => d <= numUniqueLocations,\n    );\n    if (maxClustersZoom >= 0) {\n      // Now, move the unclustered points to the next zoom level to avoid having a gap\n      if (maxClustersZoom < maxAvailZoom) {\n        trees[maxClustersZoom + 1] = trees[maxAvailZoom];\n        trees.splice(maxClustersZoom + 2); // Remove all zoom levels beyond maxClustersZoom\n      }\n      maxAvailZoom = maxClustersZoom + 1;\n    }\n  }\n\n  const minAvailZoom = Math.min(\n    maxAvailZoom,\n    minClusters ? numbersOfClusters.lastIndexOf(minClusters) : maxAvailZoom,\n  );\n\n  const clusterLevels = new Array<ClusterLevel>();\n  prevZoom = NaN;\n  for (let zoom = maxAvailZoom; zoom >= minAvailZoom; zoom--) {\n    let childrenByParent: Map<number, (string | number)[]> | undefined;\n    const tree = trees[zoom];\n    if (!tree) continue;\n    if (trees[prevZoom] && zoom < maxAvailZoom) {\n      childrenByParent = rollup(\n        trees[prevZoom].points,\n        (points: any[]) =>\n          points.map((p: any) =>\n            p.id ? makeClusterId(p.id) : getLocationId(p.location),\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, location} = point;\n      if (isLeafPoint(point)) {\n        nodes.push({\n          id: getLocationId(location),\n          zoom,\n          lat: getLocationLat(location),\n          lon: getLocationLon(location),\n        });\n      } else if (isClusterPoint(point)) {\n        const {id} = point;\n        const children = childrenByParent && childrenByParent.get(id);\n        if (!children) {\n          // Might happen if there are multiple locations with same coordinates\n          console.warn(`Omitting cluster with no children, point:`, point);\n          continue;\n        }\n        const cluster = {\n          id: makeClusterId(id),\n          name: makeClusterName(id, numPoints),\n          zoom,\n          lat: yLat(y),\n          lon: xLng(x),\n          children: children ?? [],\n        } as Cluster;\n        nodes.push(cluster);\n      }\n    }\n    clusterLevels.push({\n      zoom,\n      nodes,\n    });\n    prevZoom = zoom;\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<L>(\n  points: Point<L>[],\n  zoom: number,\n  tree: ZoomLevelKDBush,\n  options: Options,\n) {\n  const clusters: Point<L>[] = [];\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<L>(p: Point<L>) {\n  return p.x;\n}\n\nfunction getY<L>(p: Point<L>) {\n  return p.y;\n}\n\nfunction countUniqueLocations<L>(\n  locations: Iterable<L>,\n  locationAccessors: LocationAccessors<L>,\n) {\n  const {getLocationLon, getLocationLat} = locationAccessors;\n  const countByLatLon = new Map<string, number>();\n  let uniqueCnt = 0;\n  for (const loc of locations) {\n    const lon = getLocationLon(loc);\n    const lat = getLocationLat(loc);\n    const key = `${lon},${lat}`;\n    const prev = countByLatLon.get(key);\n    if (!prev) {\n      uniqueCnt++;\n    }\n    countByLatLon.set(key, prev ? prev + 1 : 1);\n  }\n  return uniqueCnt;\n}\n\nfunction findIndexOfMax(arr: (number | undefined)[]): number | undefined {\n  let max = -Infinity;\n  let maxIndex: number | undefined = undefined;\n\n  for (let i = 0; i < arr.length; i++) {\n    const value = arr[i];\n\n    if (typeof value === 'number') {\n      if (value > max) {\n        max = value;\n        maxIndex = i;\n      }\n    }\n  }\n\n  return maxIndex;\n}\n\nfunction findLastIndex<T>(\n  arr: T[],\n  predicate: (value: T, index: number, array: T[]) => boolean,\n): number {\n  for (let i = arr.length - 1; i >= 0; i--) {\n    if (predicate(arr[i], i, arr)) {\n      return i;\n    }\n  }\n  return -1;\n}\n"]}

package/dist/colors.d.ts

@@ -0,0 +1,103 @@
+import { SettingsState } from './FlowmapState';
+export type ColorScale = (value: number) => RGBA;
+export type RGBA = [number, number, number, number];
+export declare function opacityFloatToInteger(opacity: number): number;
+export declare function opacifyHex(hexCode: string, opacity: number): string;
+export declare function colorAsRgba(color: string | number[]): RGBA;
+export declare enum ColorScheme {
+    primary = "#162d3c"
+}
+export declare const GRAYISH: string[];
+export declare const schemeTeal: string[];
+export declare const DEFAULT_COLOR_SCHEME: string[];
+export declare const COLOR_SCHEMES: {
+    [key: string]: string[];
+};
+export declare const COLOR_SCHEME_KEYS: string[];
+export declare function getFlowmapColors(settings: SettingsState): Colors | DiffColors;
+export declare function getColors(diffMode: boolean, colorScheme: string | string[] | undefined, darkMode: boolean, fadeEnabled: boolean, fadeOpacityEnabled: boolean, fadeAmount: number, animate: boolean): Colors | DiffColors;
+export declare function createFlowColorScale(domain: [number, number], scheme: string[], animate: boolean | undefined): ColorScale;
+export declare function getFlowColorScale(colors: ColorsRGBA | DiffColorsRGBA, magnitudeExtent: [number, number] | undefined, animate: boolean | undefined): (magnitude: number) => [number, number, number, number];
+export declare function isDiffColors(colors: DiffColors | Colors): colors is DiffColors;
+export declare function isDiffColorsRGBA(colors: DiffColorsRGBA | ColorsRGBA): colors is DiffColorsRGBA;
+export interface FlowColors {
+    scheme?: string[];
+    highlighted?: string;
+}
+export interface LocationCircleColors {
+    inner?: string;
+    outgoing?: string;
+    incoming?: string;
+    highlighted?: string;
+    empty?: string;
+    outlineEmptyMix?: number;
+}
+export interface LocationAreaColors {
+    outline?: string;
+    normal?: string;
+    selected?: string;
+    highlighted?: string;
+    connected?: string;
+}
+export interface BaseColors {
+    darkMode?: boolean;
+    locationAreas?: LocationAreaColors;
+    dimmedOpacity?: number;
+    outlineColor?: string;
+}
+export interface Colors extends BaseColors {
+    flows?: FlowColors;
+    locationCircles?: LocationCircleColors;
+}
+export interface FlowAndCircleColors {
+    flows?: FlowColors;
+    locationCircles?: LocationCircleColors;
+}
+export interface DiffColors extends BaseColors {
+    positive?: FlowAndCircleColors;
+    negative?: FlowAndCircleColors;
+}
+export interface FlowColorsRGBA {
+    scheme: string[];
+    highlighted: RGBA;
+}
+export interface LocationCircleColorsRGBA {
+    inner: RGBA;
+    outgoing: RGBA;
+    incoming: RGBA;
+    highlighted: RGBA;
+    empty: RGBA;
+    outlineEmptyMix: number;
+}
+export interface LocationAreaColorsRGBA {
+    outline: RGBA;
+    normal: RGBA;
+    selected: RGBA;
+    highlighted: RGBA;
+    connected: RGBA;
+}
+export interface BaseColorsRGBA {
+    darkMode: boolean;
+    locationAreas: LocationAreaColorsRGBA;
+    dimmedOpacity: number;
+    outlineColor: RGBA;
+}
+export interface ColorsRGBA extends BaseColorsRGBA {
+    flows: FlowColorsRGBA;
+    locationCircles: LocationCircleColorsRGBA;
+}
+export interface FlowAndCircleColorsRGBA {
+    flows: FlowColorsRGBA;
+    locationCircles: LocationCircleColorsRGBA;
+}
+export interface DiffColorsRGBA extends BaseColorsRGBA {
+    positive: FlowAndCircleColorsRGBA;
+    negative: FlowAndCircleColorsRGBA;
+}
+export declare function getColorsRGBA(colors: Colors | undefined): ColorsRGBA;
+export declare function getDiffColorsRGBA(colors: DiffColors | undefined): DiffColorsRGBA;
+export declare function rgbaAsString(color: RGBA): string;
+export declare function midpoint(a: number, b: number, zeroToOne: number): number;
+export declare function mixColorsRGBA(color1: RGBA, color2: RGBA, zeroToOne: number): RGBA;
+export default getColors;
+//# sourceMappingURL=colors.d.ts.map

package/dist/colors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"colors.d.ts","sourceRoot":"","sources":["../src/colors.ts"],"names":[],"mappings":"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"}