@buildcanada/charts 0.1.0

package/src/grapher/mapCharts/d3-bboxCollide.js

@@ -0,0 +1,204 @@
+// From https://github.com/emeeks/d3-bboxCollide
+// Copy-pasted instead of relying on the distribution since the code hasn't
+// been touched in years and relies on an old version of d3-quadtree
+
+import { quadtree } from "d3-quadtree"
+
+export default function (bbox) {
+    function x(d) {
+        return d.x + d.vx
+    }
+
+    function y(d) {
+        return d.y + d.vy
+    }
+
+    function constant(x) {
+        return function () {
+            return x
+        }
+    }
+
+    var nodes,
+        boundingBoxes,
+        strength = 1,
+        iterations = 1
+
+    if (typeof bbox !== "function") {
+        bbox = constant(bbox === null ? [[0, 0][(1, 1)]] : bbox)
+    }
+
+    function force() {
+        var i, tree, node, xi, yi, bbi, nx1, ny1, nx2, ny2
+
+        var cornerNodes = []
+        nodes.forEach(function (d, i) {
+            cornerNodes.push({
+                node: d,
+                vx: d.vx,
+                vy: d.vy,
+                x: d.x + (boundingBoxes[i][1][0] + boundingBoxes[i][0][0]) / 2,
+                y: d.y + (boundingBoxes[i][0][1] + boundingBoxes[i][1][1]) / 2,
+            })
+            cornerNodes.push({
+                node: d,
+                vx: d.vx,
+                vy: d.vy,
+                x: d.x + boundingBoxes[i][0][0],
+                y: d.y + boundingBoxes[i][0][1],
+            })
+            cornerNodes.push({
+                node: d,
+                vx: d.vx,
+                vy: d.vy,
+                x: d.x + boundingBoxes[i][0][0],
+                y: d.y + boundingBoxes[i][1][1],
+            })
+            cornerNodes.push({
+                node: d,
+                vx: d.vx,
+                vy: d.vy,
+                x: d.x + boundingBoxes[i][1][0],
+                y: d.y + boundingBoxes[i][0][1],
+            })
+            cornerNodes.push({
+                node: d,
+                vx: d.vx,
+                vy: d.vy,
+                x: d.x + boundingBoxes[i][1][0],
+                y: d.y + boundingBoxes[i][1][1],
+            })
+        })
+        var cn = cornerNodes.length
+
+        for (var k = 0; k < iterations; ++k) {
+            tree = quadtree(cornerNodes, x, y).visitAfter(prepareCorners)
+
+            for (i = 0; i < cn; ++i) {
+                var nodeI = ~~(i / 5)
+                node = nodes[nodeI]
+                bbi = boundingBoxes[nodeI]
+                xi = node.x + node.vx
+                yi = node.y + node.vy
+                nx1 = xi + bbi[0][0]
+                ny1 = yi + bbi[0][1]
+                nx2 = xi + bbi[1][0]
+                ny2 = yi + bbi[1][1]
+                tree.visit(apply)
+            }
+        }
+
+        function apply(quad, x0, y0, x1, y1) {
+            var data = quad.data
+            if (data) {
+                var bWidth = bbLength(bbi, 0),
+                    bHeight = bbLength(bbi, 1)
+
+                if (data.node.index !== nodeI) {
+                    var dataNode = data.node
+                    var bbj = boundingBoxes[dataNode.index],
+                        dnx1 = dataNode.x + dataNode.vx + bbj[0][0],
+                        dny1 = dataNode.y + dataNode.vy + bbj[0][1],
+                        dnx2 = dataNode.x + dataNode.vx + bbj[1][0],
+                        dny2 = dataNode.y + dataNode.vy + bbj[1][1],
+                        dWidth = bbLength(bbj, 0),
+                        dHeight = bbLength(bbj, 1)
+
+                    if (
+                        nx1 <= dnx2 &&
+                        dnx1 <= nx2 &&
+                        ny1 <= dny2 &&
+                        dny1 <= ny2
+                    ) {
+                        var xSize = [
+                            Math.min.apply(null, [dnx1, dnx2, nx1, nx2]),
+                            Math.max.apply(null, [dnx1, dnx2, nx1, nx2]),
+                        ]
+                        var ySize = [
+                            Math.min.apply(null, [dny1, dny2, ny1, ny2]),
+                            Math.max.apply(null, [dny1, dny2, ny1, ny2]),
+                        ]
+
+                        var xOverlap = bWidth + dWidth - (xSize[1] - xSize[0])
+                        var yOverlap = bHeight + dHeight - (ySize[1] - ySize[0])
+
+                        var xBPush = xOverlap * strength * (yOverlap / bHeight)
+                        var yBPush = yOverlap * strength * (xOverlap / bWidth)
+
+                        var xDPush = xOverlap * strength * (yOverlap / dHeight)
+                        var yDPush = yOverlap * strength * (xOverlap / dWidth)
+
+                        if ((nx1 + nx2) / 2 < (dnx1 + dnx2) / 2) {
+                            node.vx -= xBPush
+                            dataNode.vx += xDPush
+                        } else {
+                            node.vx += xBPush
+                            dataNode.vx -= xDPush
+                        }
+                        if ((ny1 + ny2) / 2 < (dny1 + dny2) / 2) {
+                            node.vy -= yBPush
+                            dataNode.vy += yDPush
+                        } else {
+                            node.vy += yBPush
+                            dataNode.vy -= yDPush
+                        }
+                    }
+                }
+                return
+            }
+
+            return x0 > nx2 || x1 < nx1 || y0 > ny2 || y1 < ny1
+        }
+    }
+
+    function prepareCorners(quad) {
+        if (quad.data) {
+            return (quad.bb = boundingBoxes[quad.data.node.index])
+        }
+        quad.bb = [
+            [0, 0],
+            [0, 0],
+        ]
+        for (var i = 0; i < 4; ++i) {
+            if (quad[i] && quad[i].bb[0][0] < quad.bb[0][0]) {
+                quad.bb[0][0] = quad[i].bb[0][0]
+            }
+            if (quad[i] && quad[i].bb[0][1] < quad.bb[0][1]) {
+                quad.bb[0][1] = quad[i].bb[0][1]
+            }
+            if (quad[i] && quad[i].bb[1][0] > quad.bb[1][0]) {
+                quad.bb[1][0] = quad[i].bb[1][0]
+            }
+            if (quad[i] && quad[i].bb[1][1] > quad.bb[1][1]) {
+                quad.bb[1][1] = quad[i].bb[1][1]
+            }
+        }
+    }
+
+    function bbLength(bbox, heightWidth) {
+        return bbox[1][heightWidth] - bbox[0][heightWidth]
+    }
+
+    force.initialize = function (_) {
+        var i,
+            n = (nodes = _).length
+        boundingBoxes = new Array(n)
+        for (i = 0; i < n; ++i) boundingBoxes[i] = bbox(nodes[i], i, nodes)
+    }
+
+    force.iterations = function (_) {
+        return arguments.length ? ((iterations = +_), force) : iterations
+    }
+
+    force.strength = function (_) {
+        return arguments.length ? ((strength = +_), force) : strength
+    }
+
+    force.bbox = function (_) {
+        return arguments.length
+            ? ((bbox = typeof _ === "function" ? _ : constant(+_)), force)
+            : bbox
+    }
+
+    return force
+}

package/src/grapher/mapCharts/d3-geo-projection.ts

@@ -0,0 +1,198 @@
+/* eslint-disable */
+/*
+Duplication of d3-geo-projection.geoPatterson and d3-geo-projection.geoRobinson
+for webpack bundlesize purposes, as the original module wasn't tree-shakeable
+
+Copyright 2013-2021 Mike Bostock
+
+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.
+
+MIT License for https://github.com/scijs/integrate-adaptive-simpson
+
+The MIT License (MIT)
+
+Copyright 2015 Ricky Reusser
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+*/
+
+import { geoProjection, GeoProjection } from "d3-geo"
+
+const epsilon = 1e-6
+const epsilon2 = 1e-12
+const pi = Math.PI
+const halfPi = pi / 2
+const degrees = 180 / pi
+const radians = pi / 180
+
+// https://github.com/d3/d3-geo-projection/blob/main/src/patterson.js
+const pattersonK1 = 1.0148,
+    pattersonK2 = 0.23185,
+    pattersonK3 = -0.14499,
+    pattersonK4 = 0.02406,
+    pattersonC1 = pattersonK1,
+    pattersonC2 = 5 * pattersonK2,
+    pattersonC3 = 7 * pattersonK3,
+    pattersonC4 = 9 * pattersonK4,
+    pattersonYmax = 1.790857183
+
+export function pattersonRaw(lambda: number, phi: number): [number, number] {
+    const phi2 = phi * phi
+    return [
+        lambda,
+        phi *
+            (pattersonK1 +
+                phi2 *
+                    phi2 *
+                    (pattersonK2 + phi2 * (pattersonK3 + pattersonK4 * phi2))),
+    ]
+}
+
+pattersonRaw.invert = function (x: number, y: number): [number, number] {
+    if (y > pattersonYmax) y = pattersonYmax
+    else if (y < -pattersonYmax) y = -pattersonYmax
+    let yc = y,
+        delta
+
+    do {
+        // Newton-Raphson
+        const y2 = yc * yc
+        yc -= delta =
+            (yc *
+                (pattersonK1 +
+                    y2 *
+                        y2 *
+                        (pattersonK2 + y2 * (pattersonK3 + pattersonK4 * y2))) -
+                y) /
+            (pattersonC1 +
+                y2 * y2 * (pattersonC2 + y2 * (pattersonC3 + pattersonC4 * y2)))
+    } while (Math.abs(delta) > epsilon)
+
+    return [x, yc]
+}
+
+export function geoPatterson(): GeoProjection {
+    return geoProjection(pattersonRaw).scale(139.319)
+}
+
+// https://github.com/d3/d3-geo-projection/blob/main/src/robinson.js
+const K = [
+    [0.9986, -0.062],
+    [1.0, 0.0],
+    [0.9986, 0.062],
+    [0.9954, 0.124],
+    [0.99, 0.186],
+    [0.9822, 0.248],
+    [0.973, 0.31],
+    [0.96, 0.372],
+    [0.9427, 0.434],
+    [0.9216, 0.4958],
+    [0.8962, 0.5571],
+    [0.8679, 0.6176],
+    [0.835, 0.6769],
+    [0.7986, 0.7346],
+    [0.7597, 0.7903],
+    [0.7186, 0.8435],
+    [0.6732, 0.8936],
+    [0.6213, 0.9394],
+    [0.5722, 0.9761],
+    [0.5322, 1.0],
+]
+
+K.forEach(function (d) {
+    d[1] *= 1.0144
+})
+
+export function robinsonRaw(lambda: number, phi: number): [number, number] {
+    let k
+    let i = Math.min(18, (Math.abs(phi) * 36) / pi),
+        i0 = Math.floor(i),
+        di = i - i0,
+        ax = (k = K[i0])[0],
+        ay = k[1],
+        bx = (k = K[++i0])[0],
+        by = k[1],
+        cx = (k = K[Math.min(19, ++i0)])[0],
+        cy = k[1]
+    return [
+        lambda *
+            (bx + (di * (cx - ax)) / 2 + (di * di * (cx - 2 * bx + ax)) / 2),
+        (phi > 0 ? halfPi : -halfPi) *
+            (by + (di * (cy - ay)) / 2 + (di * di * (cy - 2 * by + ay)) / 2),
+    ]
+}
+
+robinsonRaw.invert = function (x: number, y: number): [number, number] {
+    let yy = y / halfPi,
+        phi = yy * 90,
+        i = Math.min(18, Math.abs(phi / 5)),
+        i0 = Math.max(0, Math.floor(i))
+    do {
+        var ay = K[i0][1],
+            by = K[i0 + 1][1],
+            cy = K[Math.min(19, i0 + 2)][1],
+            u = cy - ay,
+            v = cy - 2 * by + ay,
+            t = (2 * (Math.abs(yy) - by)) / u,
+            c = v / u,
+            di = t * (1 - c * t * (1 - 2 * c * t))
+        if (di >= 0 || i0 === 1) {
+            phi = (y >= 0 ? 5 : -5) * (di + i)
+            var j = 50,
+                delta
+            do {
+                i = Math.min(18, Math.abs(phi) / 5)
+                i0 = Math.floor(i)
+                di = i - i0
+                ay = K[i0][1]
+                by = K[i0 + 1][1]
+                cy = K[Math.min(19, i0 + 2)][1]
+                phi -=
+                    (delta =
+                        (y >= 0 ? halfPi : -halfPi) *
+                            (by +
+                                (di * (cy - ay)) / 2 +
+                                (di * di * (cy - 2 * by + ay)) / 2) -
+                        y) * degrees
+            } while (Math.abs(delta) > epsilon2 && --j > 0)
+            break
+        }
+    } while (--i0 >= 0)
+    const ax = K[i0][0],
+        bx = K[i0 + 1][0],
+        cx = K[Math.min(19, i0 + 2)][0]
+    return [
+        x / (bx + (di * (cx - ax)) / 2 + (di * di * (cx - 2 * bx + ax)) / 2),
+        phi * radians,
+    ]
+}
+
+export function geoRobinson(): GeoProjection {
+    return geoProjection(robinsonRaw).scale(152.63)
+}

package/src/grapher/modal/DownloadIcons.tsx

@@ -0,0 +1,39 @@
+export const DownloadIconFullDataset = () => (
+    <svg
+        width="34"
+        height="24"
+        viewBox="0 0 34 24"
+        fill="none"
+        xmlns="http://www.w3.org/2000/svg"
+    >
+        <rect y="1" width="10" height="6" rx="3" fill="#577291" />
+        <rect x="12" y="1" width="10" height="6" rx="3" fill="#577291" />
+        <rect x="24" y="1" width="10" height="6" rx="3" fill="#577291" />
+        <rect y="9" width="10" height="6" rx="3" fill="#577291" />
+        <rect x="12" y="9" width="10" height="6" rx="3" fill="#577291" />
+        <rect x="24" y="9" width="10" height="6" rx="3" fill="#577291" />
+        <rect y="17" width="10" height="6" rx="3" fill="#577291" />
+        <rect x="12" y="17" width="10" height="6" rx="3" fill="#577291" />
+        <rect x="24" y="17" width="10" height="6" rx="3" fill="#577291" />
+    </svg>
+)
+
+export const DownloadIconSelected = () => (
+    <svg
+        width="34"
+        height="24"
+        viewBox="0 0 34 24"
+        fill="none"
+        xmlns="http://www.w3.org/2000/svg"
+    >
+        <rect y="1" width="10" height="6" rx="3" fill="#577291" />
+        <rect x="12" y="1" width="10" height="6" rx="3" fill="#577291" />
+        <rect x="24" y="1" width="10" height="6" rx="3" fill="#A4B6CA" />
+        <rect y="9" width="10" height="6" rx="3" fill="#577291" />
+        <rect x="12" y="9" width="10" height="6" rx="3" fill="#577291" />
+        <rect x="24" y="9" width="10" height="6" rx="3" fill="#A4B6CA" />
+        <rect y="17" width="10" height="6" rx="3" fill="#A4B6CA" />
+        <rect x="12" y="17" width="10" height="6" rx="3" fill="#A4B6CA" />
+        <rect x="24" y="17" width="10" height="6" rx="3" fill="#A4B6CA" />
+    </svg>
+)