@dra2020/dra-types 1.8.88 → 1.8.89

package/dist/dra-types.js

@@ -12,10 +12,10 @@ return /******/ (() => { // webpackBootstrap
 /******/ 	"use strict";
 /******/ 	var __webpack_modules__ = ({
 
-/***/ "./lib/all.ts":
-/*!********************!*\
-  !*** ./lib/all.ts ***!
-  \********************/
+/***/ "./lib/alldt.ts":
+/*!**********************!*\
+  !*** ./lib/alldt.ts ***!
+  \**********************/
 /***/ (function(__unused_webpack_module, exports, __webpack_require__) {
 
 
@@ -94,6 +94,512 @@ exports.BucketMap = {
 };
 
 
+/***/ }),
+
+/***/ "./lib/colormgr.ts":
+/*!*************************!*\
+  !*** ./lib/colormgr.ts ***!
+  \*************************/
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.computeDistrictColors = exports.allGroups16Colors = exports.colorsFromStopsPartisan = exports.colorsFromStops = exports.PaletteNames = exports.ColorFromRGBPcts = exports.AggregatePartisanColorStr = exports.AggregatePartisanColor = exports.AggregateEthnicColor = exports.ToEthnicColorStr = exports.ToPartisanShiftColor = exports.ToPartisanDistrictColor = exports.ToPartisanColorStr = exports.ToAllEthnicColor = exports.ethnicBackgroundColor = exports.makeStops = exports.DefaultPaletteDefaults = exports.EthnicFewStops = exports.PartisanPrecinctStops = exports.PartisanDistrictStops = exports.ColorByGreatD = exports.ColorByGoodD = exports.ColorByFairD = exports.ColorByEven = exports.ColorByFairR = exports.ColorByGoodR = exports.ColorByGreatR = exports.EthnicTextColor = exports.ColorByBlackAsian = exports.ColorByAsianHispanic = exports.ColorByAsianWhite = exports.ColorByHispanicBlack = exports.ColorByBlackWhite = exports.ColorByHispanicWhite = exports.ColorByMix = exports.ColorByMostlyNative = exports.ColorByMostlyAsian = exports.ColorByMostlyHispanic = exports.ColorByMostlyBlack = exports.ColorByMostlyWhite = exports.ColorBySolidAsian = exports.ColorBySolidHispanic = exports.ColorBySolidBlack = exports.ColorBySolidWhite = void 0;
+// App libraries
+const PF = __webpack_require__(/*! ./packedfields */ "./lib/packedfields.ts");
+const baseclient_1 = __webpack_require__(/*! @dra2020/baseclient */ "@dra2020/baseclient");
+// All Groups Mosaic has 16 colors
+// Index values into the 16 colors
+exports.ColorBySolidWhite = 0;
+exports.ColorBySolidBlack = 1;
+exports.ColorBySolidHispanic = 2;
+exports.ColorBySolidAsian = 3;
+exports.ColorByMostlyWhite = 4;
+exports.ColorByMostlyBlack = 5;
+exports.ColorByMostlyHispanic = 6;
+exports.ColorByMostlyAsian = 7;
+exports.ColorByMostlyNative = 8;
+exports.ColorByMix = 9;
+exports.ColorByHispanicWhite = 10;
+exports.ColorByBlackWhite = 11;
+exports.ColorByHispanicBlack = 12;
+exports.ColorByAsianWhite = 13;
+exports.ColorByAsianHispanic = 14;
+exports.ColorByBlackAsian = 15;
+// Text color for All Groups Mosaic (Legend)
+exports.EthnicTextColor = [
+    '#ffffff',
+    '#ffffff',
+    '#ffffff',
+    '#ffffff',
+    '#000000',
+    '#000000',
+    '#000000',
+    '#000000',
+    '#000000',
+    '#000000',
+    '#000000',
+    '#000000',
+    '#ffffff',
+    '#000000',
+    '#000000',
+    '#ffffff',
+];
+exports.ColorByGreatR = 0;
+exports.ColorByGoodR = 1;
+exports.ColorByFairR = 2;
+exports.ColorByEven = 3;
+exports.ColorByFairD = 4;
+exports.ColorByGoodD = 5;
+exports.ColorByGreatD = 6;
+// ****************** Colors, Color Stops and Color Functions for "classic" palettes *******************
+const PartisanFewStops = [
+    0.00,
+    0.20,
+    0.30,
+    0.40,
+    0.45,
+    0.50,
+    0.50,
+    0.55,
+    0.60,
+    0.70,
+    0.80,
+    1.00, // Dark blue
+];
+// Like PartisanFewStops, but lose the gradient at two buckets at each edge to focus on competitive district differentiation
+exports.PartisanDistrictStops = [
+    // Dark red
+    //{ stop: 0.00,  color: '#8B0000' },  // Dark red
+    //{ stop: 0.40,  color: '#8B0000' },  // .00 <= .40
+    // Crimson
+    //{ stop: 0.00,  color: '#DC143C' },  // Crimson
+    //{ stop: 0.40,  color: '#DC143C' },  // .00 <= .40
+    // Chilli Red
+    //{ stop: 0.00,  color: '#C21807' },  // Chilli Red
+    //{ stop: 0.40,  color: '#C21807' },  // .00 <= .40
+    // Carmine
+    0.00,
+    0.40,
+    0.40,
+    0.45,
+    0.45,
+    0.50,
+    0.50,
+    0.55,
+    0.55,
+    0.60,
+    0.60,
+    1.00, // .60 <= 1.0
+];
+/*export let PartisanCustomStops = [
+  { stop: 0.00,  color: '#FF0000' },  // Dark red
+  { stop: 0.20,  color: '#FF0000' },  //
+  { stop: 0.30,  color: '#FF0000' },  //
+  { stop: 0.40,  color: '#CD5C5C' },  // Indian red
+  { stop: 0.45,  color: '#DB7093' },  // Pale Violet Red
+  { stop: 0.499, color: '#DB7093' },  // Light Pink
+  { stop: 0.50,  color: '#FFFFFF' },  // white
+  { stop: 0.501, color: '#87CEFA' },  // Light Sky Blue
+  { stop: 0.55,  color: '#00bFFF' },  // Deep Sky Blue
+  { stop: 0.60,  color: '#002366' },  // Royal Blue
+  { stop: 0.70,  color: '#0000CD' },  // Medium Blue
+  { stop: 0.80,  color: '#191970' },  //
+  { stop: 1.00,  color: '#191970' },  // Midnight Blue
+];*/
+exports.PartisanPrecinctStops = PartisanFewStops;
+exports.EthnicFewStops = [
+    0.00,
+    0.40,
+    0.50,
+    1.00, // 
+];
+exports.DefaultPaletteDefaults = {
+    partisanScale: 'partisanclassic',
+    partisanDistrictsScale: 'partisandistrictsclassic',
+    demographicsScale: 'demographicsclassic',
+    demographicsAllGroups: 'allgroupsclassic',
+};
+function makeStops(stops, colors) {
+    // Lengths should be equal
+    const len = stops.length <= colors.length ? stops.length : colors.length;
+    let result = [];
+    for (let i = 0; i < len; i++)
+        result.push({ stop: stops[i], color: colors[i] });
+    return result;
+}
+exports.makeStops = makeStops;
+function partisanStops(stops, pd) {
+    const palette = pd['partisanScale'];
+    return makeStops(stops, colorsFromStopsPartisan(palette, 'partisanScale', stops));
+}
+function partisanDistrictStops(stops, pd) {
+    const palette = pd['partisanDistrictsScale'];
+    return makeStops(stops, colorsFromStopsPartisan(palette, 'partisanDistrictsScale', stops));
+}
+function ethnicStops(stops, pd) {
+    const palette = pd['demographicsScale'];
+    if (palette === 'demographicsclassic')
+        return makeStops(stops, baseclient_1.Colors.EthnicFewClassicColors);
+    return makeStops(stops, colorsFromStops(palette, stops, baseclient_1.Colors.EthnicFewClassicColors));
+}
+function ethnicBackgroundColor(index, pd) {
+    const palette = pd['demographicsAllGroups'];
+    const colors = allGroups16Colors(palette, baseclient_1.Colors.getPalette(palette));
+    if (index < colors.length)
+        return colors[index];
+    return '#ffffff';
+}
+exports.ethnicBackgroundColor = ethnicBackgroundColor;
+function ToAllEthnicColor(agg, dc, pd) {
+    // Use VAP/CVAP if it exists
+    const dataset = dc.primeVDS ? dc.primeVDS : dc.primeDDS;
+    return AggregateEthnicColor(PF.ToGetter(agg, dc, dataset), pd, dataset.endsWith('NH'));
+}
+exports.ToAllEthnicColor = ToAllEthnicColor;
+function ToPartisanColorStr(agg, dc, pd) {
+    return ToPartisanColor(agg, dc, partisanStops(exports.PartisanPrecinctStops, pd));
+}
+exports.ToPartisanColorStr = ToPartisanColorStr;
+function ToPartisanDistrictColor(agg, dc, pd) {
+    return ToPartisanColor(agg, dc, partisanDistrictStops(exports.PartisanDistrictStops, pd));
+}
+exports.ToPartisanDistrictColor = ToPartisanDistrictColor;
+function ToPartisanColor(agg, dc, stops) {
+    if (dc.primeEDS === PF.DS_PVI2020) {
+        const getter16 = PF.ToGetter(agg, dc, PF.DS_PRES2016);
+        const getter20 = PF.ToGetter(agg, dc, PF.DS_PRES2020);
+        const pviRaw = PF.calcRaw2020Pvi(getter16, getter20);
+        const color = ColorFromRGBPcts((1 - pviRaw / 100), 0, pviRaw / 100, stops);
+        //console.log('Pvi (r, d, color): (' + (1 - pviRaw/100) + ', ' + pviRaw/100 + ', ' + color + ')');
+        return color;
+    }
+    else if (dc.primeEDS === PF.DS_PVI2016) {
+        const getter = PF.ToGetter(agg, dc, dc.primeEDS);
+        const pviRaw = PF.calcRawPvi(getter);
+        const color = ColorFromRGBPcts((1 - pviRaw / 100), 0, pviRaw / 100, stops);
+        return color;
+    }
+    else {
+        const getter = PF.ToGetter(agg, dc, dc.primeEDS);
+        return AggregatePartisanColorStr(getter, stops);
+    }
+}
+function ToPartisanShiftColor(agg, dc, datasets, pd) {
+    if (!datasets || datasets.length < 2)
+        return '';
+    const shift = PF.calcShift(agg, dc, datasets[0], datasets[1]);
+    if (shift == null)
+        return null;
+    const rep = 0.5 - (shift / 2);
+    const dem = 0.5 + (shift / 2);
+    const stops = partisanStops(exports.PartisanPrecinctStops, pd);
+    const color = ColorFromRGBPcts(rep, 0, dem, stops);
+    //console.log('Shift (r, d, color): (' + rep + ', ' + dem + ', ' + color + ')');
+    return color;
+}
+exports.ToPartisanShiftColor = ToPartisanShiftColor;
+function ToEthnicColorStr(agg, dc, pd, detail) {
+    let ethnic = 'Wh';
+    let total = 'Tot';
+    let bInvert = false;
+    const dataset = dc.primeVDS ? dc.primeVDS : dc.primeDDS;
+    switch (detail) {
+        case null:
+        case '':
+        case 'all':
+            let c = ToAllEthnicColor(agg, dc, pd); // special case 
+            return c >= 0 ? ethnicBackgroundColor(c, pd) : '#ffffff';
+        case 'white':
+            ethnic = 'Wh';
+            break;
+        case 'nonwhite':
+            ethnic = 'Wh';
+            bInvert = true;
+            break;
+        case 'black':
+            ethnic = dataset.endsWith('NH') ? 'Bl' : 'BlC';
+            break;
+        case 'hisp':
+            ethnic = 'His';
+            break;
+        case 'native':
+            ethnic = dataset.endsWith('NH') ? 'Nat' : 'NatC';
+            break;
+        case 'asianpi':
+            ethnic = 'AsnPI';
+            break;
+        case 'asian':
+            ethnic = dataset.endsWith('NH') ? 'Asn' : 'AsnC';
+            break;
+        case 'pac':
+            ethnic = dataset.endsWith('NH') ? 'Pac' : 'PacC';
+            break;
+        case 'other':
+            ethnic = 'OthAl';
+            break;
+        case 'mix':
+            ethnic = 'Mix';
+            break;
+        default: break;
+    }
+    const getter = PF.ToGetter(agg, dc, dataset);
+    let den = getter(total);
+    let num = getter(ethnic);
+    if (den === undefined || isNaN(den) || num === undefined || isNaN(num))
+        return '#ffffff';
+    if (den == 0)
+        return '#ffffff';
+    const pct = bInvert ? 1 - (num / den) : num / den;
+    return baseclient_1.Util.execGradient(ethnicStops(exports.EthnicFewStops, pd), pct);
+}
+exports.ToEthnicColorStr = ToEthnicColorStr;
+// All Groups Mosaic
+function AggregateEthnicColor(getter, pd, nhAlone) {
+    // Dataset should have 'Tot' field
+    let totField = 'Tot';
+    let totalPop = getter(totField);
+    if (totalPop == 0)
+        return -1;
+    // Field names hard-coded
+    let white = getter('Wh') / totalPop;
+    let hisp = getter('His') / totalPop;
+    let black = 0;
+    let native = 0;
+    let asianPI = 0;
+    if (nhAlone) {
+        black = getter('Bl') / totalPop;
+        native = getter('Nat') / totalPop;
+        asianPI = (getter('Asn') + getter('Pac')) / totalPop;
+    }
+    else {
+        black = getter('BlC') / totalPop;
+        native = getter('NatC') / totalPop;
+        asianPI = (getter('AsnC') + getter('PacC')) / totalPop;
+    }
+    if (white >= 0.75)
+        return exports.ColorBySolidWhite;
+    if (black >= 0.75)
+        return exports.ColorBySolidBlack;
+    if (hisp >= 0.75)
+        return exports.ColorBySolidHispanic;
+    if (asianPI >= 0.75)
+        return exports.ColorBySolidAsian;
+    if (white >= 0.5 && black < 0.3 && hisp < 0.3 && native < 0.3 && asianPI < 0.3)
+        return exports.ColorByMostlyWhite;
+    if (black >= 0.5 && white < 0.3 && hisp < 0.3 && native < 0.3 && asianPI < 0.3)
+        return exports.ColorByMostlyBlack;
+    if (hisp >= 0.5 && white < 0.3 && black < 0.3 && native < 0.3 && asianPI < 0.3)
+        return exports.ColorByMostlyHispanic;
+    if (asianPI >= 0.5 && white < 0.3 && black < 0.3 && native < 0.3 && hisp < 0.3)
+        return exports.ColorByMostlyAsian;
+    if (native > 0.5)
+        return exports.ColorByMostlyNative;
+    if (hisp >= 0.3 && white >= 0.3 && hisp + white > 0.75)
+        return exports.ColorByHispanicWhite;
+    if (black >= 0.3 && white >= 0.3 && black + white > 0.75)
+        return exports.ColorByBlackWhite;
+    if (hisp >= 0.3 && black >= 0.3 && hisp + black > 0.75)
+        return exports.ColorByHispanicBlack;
+    if (asianPI >= 0.3 && white >= 0.3 && asianPI + white > 0.75)
+        return exports.ColorByAsianWhite;
+    if (asianPI >= 0.3 && hisp >= 0.3 && asianPI + hisp > 0.75)
+        return exports.ColorByAsianHispanic;
+    if (black >= 0.3 && asianPI >= 0.3 && black + asianPI > 0.75)
+        return exports.ColorByBlackAsian;
+    return exports.ColorByMix;
+}
+exports.AggregateEthnicColor = AggregateEthnicColor;
+// This is used only for 2016_BG analytics, seemingly only for values, not colors (dave 12/9/21)
+function AggregatePartisanColor(getter) {
+    // Dataset should have 'Tot' field
+    let totField = 'Tot';
+    let presTot = getter(totField);
+    if (presTot == 0)
+        return -1;
+    // TODO: Field names hard-coded
+    let presR = getter('R');
+    let presD = getter(' D');
+    if (presTot === undefined || presD === undefined || presR === undefined || presTot <= 0)
+        return -1;
+    let pctD = presD / presTot;
+    let pctR = presR / presTot;
+    let diff = pctD - pctR;
+    if (diff < -0.20)
+        return exports.ColorByGreatR;
+    if (diff < -0.10)
+        return exports.ColorByGoodR;
+    if (diff < -0.02)
+        return exports.ColorByFairR;
+    if (diff > 0.20)
+        return exports.ColorByGreatD;
+    if (diff > 0.10)
+        return exports.ColorByGoodD;
+    if (diff > 0.02)
+        return exports.ColorByFairD;
+    return exports.ColorByEven;
+}
+exports.AggregatePartisanColor = AggregatePartisanColor;
+function AggregatePartisanColorStr(getter, stops) {
+    // Dataset should have 'Tot' field
+    let totField = 'Tot';
+    let presTot = getter(totField);
+    if (presTot == 0)
+        return '';
+    // TODO: Field names hard-coded
+    let presR = getter('R');
+    let presD = getter('D');
+    if (presTot === undefined || presD === undefined || presR === undefined || presTot <= 0)
+        return '';
+    let pctD = presD / presTot;
+    let pctR = presR / presTot;
+    let pctOth = (presTot - presD - presR) / presTot;
+    const color = ColorFromRGBPcts(pctR, pctOth, pctD, stops);
+    //console.log('Agg (r, d, color): (' + pctR + ', ' + pctD + ', ' + color + ')');
+    return color;
+}
+exports.AggregatePartisanColorStr = AggregatePartisanColorStr;
+// This is the new gradient code
+function ColorFromRGBPcts(pctRed, pctGreen, pctBlue, stops) {
+    let pctTot = pctRed + pctBlue;
+    if (pctTot == 0)
+        return '#ffffff';
+    pctBlue /= pctTot;
+    return baseclient_1.Util.execGradient(stops, pctBlue);
+}
+exports.ColorFromRGBPcts = ColorFromRGBPcts;
+// Currently supported palettes
+exports.PaletteNames = ['jet_r', 'turbo_r', 'inferno_r', 'viridis_r', 'magma_r', 'plasma_r', 'Greys', 'bone_r',
+    'draclassic', 'demographicsclassic', 'partisanclassic', 'allgroupsclassic', 'partisandistrictsclassic'];
+function colorsFromStops(palette, stops, classicColors) {
+    // Use classicColors to see where there are duplicate colors
+    const allColors = baseclient_1.Colors.getPalette(palette);
+    let colors = [];
+    for (let i = 0; i < stops.length; i++) {
+        const stop = (i + 1 < classicColors.length && classicColors[i] == classicColors[i + 1]) ? (stops[i] + stops[i + 1]) / 2 :
+            (i > 0 && i < classicColors.length && classicColors[i - 1] == classicColors[i]) ? (stops[i - 1] + stops[i]) / 2 : stops[i];
+        let inx = Math.floor(allColors.length * stop);
+        if (inx >= allColors.length)
+            inx = allColors.length - 1;
+        colors.push(allColors[inx]);
+    }
+    return colors;
+}
+exports.colorsFromStops = colorsFromStops;
+function colorsFromStopsPartisan(palette, colorUse, stops) {
+    if (palette === 'partisanclassic')
+        return baseclient_1.Colors.PartisanPrecinctClassicColors;
+    if (palette === 'partisandistrictsclassic')
+        return baseclient_1.Colors.PartisanDistrictClassicColors;
+    // For partisanScale and partisanDistrictsScale; indexes match classic color pattern
+    const allColors = baseclient_1.Colors.getPalette(palette);
+    if (allColors.length < baseclient_1.Colors.MaxColors)
+        return baseclient_1.Colors.PartisanPrecinctClassicColors; // Safety check; shouldn't happen
+    let colors = [];
+    const indexes = colorUse === 'partisanScale' ?
+        [15, 27, 37, 47, 57, 67, 82, 92, 102, 112, 122, 134] : [15, 15, 37, 37, 47, 67, 82, 102, 122, 122, 134, 134];
+    for (let i = 0; i < stops.length; i++) {
+        colors.push(allColors[indexes[i]]);
+    }
+    return colors;
+}
+exports.colorsFromStopsPartisan = colorsFromStopsPartisan;
+function allGroups16Colors(palette, colors) {
+    let modColors = [];
+    //if (palette === 'allgroupsclassic')     // Only support classic for now
+    {
+        modColors.push(baseclient_1.Colors.EthnicBackgroundColor[exports.ColorBySolidWhite]); // pos 0
+        modColors.push(baseclient_1.Colors.EthnicBackgroundColor[exports.ColorBySolidBlack]); // pos 1
+        modColors.push(baseclient_1.Colors.EthnicBackgroundColor[exports.ColorBySolidHispanic]); // pos 2
+        modColors.push(baseclient_1.Colors.EthnicBackgroundColor[exports.ColorBySolidAsian]); // pos 3
+        modColors.push(baseclient_1.Colors.EthnicBackgroundColor[exports.ColorByMostlyWhite]); // pos 4
+        modColors.push(baseclient_1.Colors.EthnicBackgroundColor[exports.ColorByMostlyBlack]); // pos 5
+        modColors.push(baseclient_1.Colors.EthnicBackgroundColor[exports.ColorByMostlyHispanic]); // pos 6
+        modColors.push(baseclient_1.Colors.EthnicBackgroundColor[exports.ColorByMostlyAsian]); // pos 7
+        modColors.push(baseclient_1.Colors.EthnicBackgroundColor[exports.ColorByMostlyNative]); // pos 8
+        modColors.push(baseclient_1.Colors.EthnicBackgroundColor[exports.ColorByMix]); // pos 9
+        modColors.push(baseclient_1.Colors.EthnicBackgroundColor[exports.ColorByHispanicWhite]); // pos 10
+        modColors.push(baseclient_1.Colors.EthnicBackgroundColor[exports.ColorByBlackWhite]); // pos 11
+        modColors.push(baseclient_1.Colors.EthnicBackgroundColor[exports.ColorByHispanicBlack]); // pos 12
+        modColors.push(baseclient_1.Colors.EthnicBackgroundColor[exports.ColorByAsianWhite]); // pos 13
+        modColors.push(baseclient_1.Colors.EthnicBackgroundColor[exports.ColorByAsianHispanic]); // pos 14
+        modColors.push(baseclient_1.Colors.EthnicBackgroundColor[exports.ColorByBlackAsian]); // pos 15
+    }
+    /*else if (palette === 'viridis_r' || palette === 'plasma_r')
+    {
+      modColors.push(colors[149]);
+      modColors.push(colors[129]);
+      modColors.push(colors[109]);
+      modColors.push(colors[89]);
+      modColors.push(colors[139]);
+      modColors.push(colors[119]);
+      modColors.push(colors[99]);
+      modColors.push(colors[79]);
+      modColors.push(colors[0]);
+      modColors.push(colors[9]);
+      modColors.push(colors[29]);
+      modColors.push(colors[19]);
+      modColors.push(colors[49]);
+      modColors.push(colors[39]);
+      modColors.push(colors[69]);
+      modColors.push(colors[59]);
+    }
+    else if (palette === 'magma_r')
+    {
+      modColors.push(colors[134]);
+      modColors.push(colors[116]);
+      modColors.push(colors[98]);
+      modColors.push(colors[80]);
+      modColors.push(colors[125]);
+      modColors.push(colors[107]);
+      modColors.push(colors[89]);
+      modColors.push(colors[71]);
+      modColors.push(colors[0]);
+      modColors.push(colors[8]);
+      modColors.push(colors[26]);
+      modColors.push(colors[17]);
+      modColors.push(colors[44]);
+      modColors.push(colors[35]);
+      modColors.push(colors[62]);
+      modColors.push(colors[53]);
+    }*/
+    return modColors;
+}
+exports.allGroups16Colors = allGroups16Colors;
+function computeDistrictColors(params) {
+    let dcNew = [];
+    for (let i = 0; i < params.aggregates.length; i++) {
+        let agg = params.aggregates[i];
+        let mapColor = i < params.mapColors.length ? params.mapColors[i].color : baseclient_1.Colors.genColor(i, params.useFirstColor, params.usePalette);
+        let dc = {};
+        // Compute election color and partisan color
+        dc.colorEthnic = mapColor;
+        dc.colorElection = ToPartisanDistrictColor(agg, params.datasetContext, params.paletteDefaults);
+        switch (params.colorDistrictsBy) {
+            case 'election':
+                dc.colorSolid = dc.colorElection;
+                break;
+            case 'nonwhite':
+            case 'hisp':
+            case 'black':
+            case 'native':
+            case 'asian':
+            case 'pac':
+            case 'all':
+                dc.colorEthnic = ToEthnicColorStr(agg, params.datasetContext, params.paletteDefaults, params.colorDistrictsBy);
+                dc.colorSolid = dc.colorEthnic;
+                break;
+            default:
+                dc.colorSolid = mapColor;
+                break;
+        }
+        dcNew.push(dc);
+    }
+    return dcNew;
+}
+exports.computeDistrictColors = computeDistrictColors;
+
+
 /***/ }),
 
 /***/ "./lib/csv.ts":
@@ -847,22 +1353,177 @@ Object.defineProperty(exports, "__esModule", ({ value: true }));
 /*!*****************************!*\
   !*** ./lib/packedfields.ts ***!
   \*****************************/
-/***/ ((__unused_webpack_module, exports) => {
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.aggregatePackedFields = exports.packedCopy = exports.zeroPackedCopy = exports.allocPackedFields = void 0;
+exports.pvi2020Str = exports.calcRaw2020Pvi = exports.pviStr = exports.calcRawPvi = exports.calcShift = exports.ToGetterPvi20 = exports.ToGetterPvi16 = exports.ToGetter = exports.findPackedField = exports.getPackedField = exports.diffPackedFields = exports.aggregatePackedFields = exports.packedCopy = exports.zeroPackedCopy = exports.zeroPackedFields = exports.retrievePackedFields = exports.setPackedFields = exports.hasPackedFields = exports.computePackedFields = exports.computeMetaIndex = exports.fGet = exports.fGetJoined = exports.fieldGetterNotLoaded = exports.DS_PRES2016 = exports.DS_PRES2020 = exports.DS_PVI2016 = exports.PVI2020_Title = exports.DS_PVI2020 = exports.DATASET_TYPE_PVI = exports.DATASET_TYPE_ELECTION = exports.DATASET_TYPE_DEMOGRAPHIC = exports.AGG_pvi = exports.AGG_pres2016 = exports.AGG_pres2008 = exports.AGG_DEMOGRAPHIC18 = exports.AGG_DEMOGRAPHIC = void 0;
+const baseclient_1 = __webpack_require__(/*! @dra2020/baseclient */ "@dra2020/baseclient");
+// **** Dataset Codes Explained ****
+// Elections:
+//  EYYGCC, where YY = year and CC = contest [PR, SE, GO, AG]
+//  C16GCO = composite (spans number of years)
+//  PYYGPR = PVI, where YY is year [16, 20]
+// Census/ACS:
+//  DYYF = Census/ACS Total Pop, where YY = year [10, 18, 19, 20]
+//  DYYT = Census/ACS VAP/CVAP, where YY = year [10, 18, 19, 20]
+//  D20FA = Census 2020 Total Prisoner-Adjusted Pop
+//  D20TNH = Census 2020 VAP with Non-Hispanic Alone Race fields
+// **** Dataset Fields Explained ****
+// Elections:
+//  D: Democratic
+//  R: Republican
+//  Tot (Total R + D + Other)
+// Census/ACS/VAP/CVAP:
+//  Tot: total
+//  Wh: White alone, not Hispanic
+//  His: All Hispanics
+//  Bl: Black alone, not Hispanic;              BlC: Black combo, incl Hispanic
+//  Asn: Asian alone, not Hispanic;             AsnC: Asian combo, incl Hispanic
+//  Nat: Native alone, not Hispanic;            NatC: Native combo, incl Hispanic
+//  Pac (also PI): Pacific alone, not Hispanic; PacC: Pacific combo, incl Hispanic
+//  OthAl: Other alone, not Hispanic;           Oth: Other + Two or more races, incl Hispanic
+//  Mix: Two or more races, not Hispanic
+//  AsnPI: Asian + Pacific, not Hispanic
+exports.AGG_DEMOGRAPHIC = 'demographic';
+exports.AGG_DEMOGRAPHIC18 = 'demographic18';
+exports.AGG_pres2008 = 'pres2008';
+exports.AGG_pres2016 = 'pres2016';
+exports.AGG_pvi = 'pvi';
+exports.DATASET_TYPE_DEMOGRAPHIC = 'demographic';
+exports.DATASET_TYPE_ELECTION = 'election';
+exports.DATASET_TYPE_PVI = 'pvi';
+exports.DS_PVI2020 = 'P20GPR';
+exports.PVI2020_Title = 'PVI 2016/2020';
+exports.DS_PVI2016 = 'P16GPR';
+exports.DS_PRES2020 = 'E20GPR';
+exports.DS_PRES2016 = 'E16GPR';
+function fieldGetterNotLoaded(f) { return undefined; }
+exports.fieldGetterNotLoaded = fieldGetterNotLoaded;
+function fGetJoined(f) {
+    return (f.properties && f.properties.joined) ? f.properties.joined : undefined;
+}
+exports.fGetJoined = fGetJoined;
+function fGet(f, p) {
+    return fGetW(f, null, p);
+}
+exports.fGet = fGet;
+// Note f is a direct GeoJSON feature
+// Called when building packedFields; after that f.properties.datasets is deleted, so then it's only useful for non-dataset properties.
+function fGetW(f, datasetKey, p) {
+    // pBackup helps support 2016_BG, which don't have the 'C' fields
+    const pBackup = (p === 'BlC') ? 'Bl' : (p === 'AsnC' || p === 'PacC') ? 'AsnPI' : (p === 'NatC') ? 'Nat' : null;
+    // Direct property?
+    if (f.properties && f.properties[p] !== undefined)
+        return f.properties[p];
+    else if (datasetKey && f.properties && f.properties.datasets && f.properties.datasets[datasetKey]) {
+        if (f.properties.datasets[datasetKey][p] != null)
+            return f.properties.datasets[datasetKey][p];
+        else if (pBackup && f.properties.datasets[datasetKey][pBackup] != null)
+            return f.properties.datasets[datasetKey][pBackup];
+    }
+    // Joined property?
+    let a = fGetJoined(f);
+    if (a) {
+        for (let i = 0; i < a.length; i++) {
+            let o = a[i];
+            if (!datasetKey) {
+                if (o[p] !== undefined)
+                    return o[p];
+            }
+            else {
+                if (o['datasets'] && o['datasets'][datasetKey] != null) {
+                    if (o['datasets'][datasetKey][p] != null)
+                        return o['datasets'][datasetKey][p];
+                    else if (pBackup && o['datasets'][datasetKey][pBackup] != null)
+                        return o['datasets'][datasetKey][pBackup];
+                }
+            }
+        }
+    }
+    return undefined;
+}
+function computeMetaIndex(meta) {
+    if (meta == null)
+        return null;
+    let offset = 1; // first entry is count of aggregates
+    let index = { length: 0, fields: {}, getDatasetField: null };
+    Object.keys(meta).forEach((datasetKey) => {
+        let dataset = meta[datasetKey];
+        let fieldsIndex = {};
+        Object.keys(dataset.fields).forEach((field) => {
+            fieldsIndex[field] = offset++;
+        });
+        index.fields[datasetKey] = fieldsIndex;
+    });
+    index.length = offset;
+    index.getDatasetField = (f, dataset, field) => {
+        let pf = retrievePackedFields(f);
+        return getPackedField(index, pf, dataset, field);
+    };
+    return index;
+}
+exports.computeMetaIndex = computeMetaIndex;
+let nAlloc = 0;
 function allocPackedFields(length) {
     let ab = new ArrayBuffer(8 * length);
     let af = new Float64Array(ab);
+    nAlloc++;
+    //if ((nAlloc % 10000) == 0) console.log(`allocPackedFields: ${nAlloc} allocs`);
     return af;
 }
-exports.allocPackedFields = allocPackedFields;
+function computePackedFields(f, index) {
+    if (f.properties.packedFields)
+        return f.properties.packedFields;
+    let af = allocPackedFields(index.length);
+    af[0] = 0; // count of number of aggregates
+    Object.keys(index.fields).forEach((dataset) => {
+        let fields = index.fields[dataset];
+        Object.keys(fields).forEach((field) => {
+            let n = fGetW(f, dataset, field);
+            if (isNaN(n))
+                n = 0;
+            af[fields[field]] = n;
+        });
+    });
+    f.properties.packedFields = af; // cache here
+    f.properties.getDatasetField = index.getDatasetField;
+    // Major memory savings to delete this after packing
+    delete f.properties.datasets;
+    return af;
+}
+exports.computePackedFields = computePackedFields;
+function hasPackedFields(f) {
+    return f.properties.packedFields !== undefined;
+}
+exports.hasPackedFields = hasPackedFields;
+function setPackedFields(f, pf, fIndex) {
+    if (f.properties.packedFields !== undefined)
+        throw 'Packed fields already set';
+    f.properties.packedFields = pf;
+    f.properties.getDatasetField = fIndex.properties.getDatasetField;
+}
+exports.setPackedFields = setPackedFields;
+function retrievePackedFields(f) {
+    if (f.properties.packedFields === undefined)
+        throw 'Feature should have pre-computed packed fields';
+    return f.properties.packedFields;
+}
+exports.retrievePackedFields = retrievePackedFields;
 // The first entry in the PackedFields aggregate is the count of items aggregated.
 // Treat a null instance as just a single entry with no aggregates.
 let abZero = new ArrayBuffer(8);
 let afZero = new Float64Array(abZero);
 afZero[0] = 0;
+function zeroPackedFields(index) {
+    if (index == null)
+        return afZero;
+    let af = allocPackedFields(index.length);
+    for (let i = 0; i < af.length; i++)
+        af[i] = 0;
+    return af;
+}
+exports.zeroPackedFields = zeroPackedFields;
 function zeroPackedCopy(pf) {
     if (pf == null)
         return afZero;
@@ -895,6 +1556,120 @@ function aggregatePackedFields(agg, pf) {
     return agg;
 }
 exports.aggregatePackedFields = aggregatePackedFields;
+function diffPackedFields(main, parts) {
+    main = packedCopy(retrievePackedFields(main));
+    if (main == null || parts == null || parts.length == 0)
+        return null;
+    parts = parts.map(retrievePackedFields);
+    parts.forEach((pf) => {
+        for (let i = 0; i < main.length; i++)
+            main[i] -= pf[i];
+    });
+    return main;
+}
+exports.diffPackedFields = diffPackedFields;
+function getPackedField(index, pf, dataset, field) {
+    if (index == null || pf == null)
+        return 0;
+    let fields = index.fields[dataset];
+    return fields ? (fields[field] !== undefined ? pf[fields[field]] : 0) : 0;
+}
+exports.getPackedField = getPackedField;
+function findPackedField(index, pf, dataset, field) {
+    let fields = index.fields[dataset];
+    return fields ? (fields[field] !== undefined ? fields[field] : -1) : -1;
+}
+exports.findPackedField = findPackedField;
+function ToGetter(agg, dc, datasetKey) {
+    return (field) => { return getPackedField(dc.dsIndex, agg, datasetKey, field); };
+}
+exports.ToGetter = ToGetter;
+function ToGetterPvi16(agg, dc, datasetKey) {
+    return (field) => {
+        if (field === 'R')
+            return Math.round((getPackedField(dc.dsIndex, agg, datasetKey, 'R12') + getPackedField(dc.dsIndex, agg, datasetKey, 'R16')) / 2);
+        if (field === 'D')
+            return Math.round((getPackedField(dc.dsIndex, agg, datasetKey, 'D12') + getPackedField(dc.dsIndex, agg, datasetKey, 'D16')) / 2);
+        if (field === 'Tot')
+            return Math.round((getPackedField(dc.dsIndex, agg, datasetKey, 'R12') + getPackedField(dc.dsIndex, agg, datasetKey, 'R16') +
+                getPackedField(dc.dsIndex, agg, datasetKey, 'D12') + getPackedField(dc.dsIndex, agg, datasetKey, 'D16')) / 2);
+        return 0;
+    };
+}
+exports.ToGetterPvi16 = ToGetterPvi16;
+function ToGetterPvi20(agg, dc) {
+    return (field) => {
+        if (field === 'R')
+            return Math.round((getPackedField(dc.dsIndex, agg, exports.DS_PRES2016, 'R') + getPackedField(dc.dsIndex, agg, exports.DS_PRES2020, 'R')) / 2);
+        if (field === 'D')
+            return Math.round((getPackedField(dc.dsIndex, agg, exports.DS_PRES2016, 'D') + getPackedField(dc.dsIndex, agg, exports.DS_PRES2020, 'D')) / 2);
+        if (field === 'Tot')
+            return Math.round((getPackedField(dc.dsIndex, agg, exports.DS_PRES2016, 'R') + getPackedField(dc.dsIndex, agg, exports.DS_PRES2020, 'R') +
+                getPackedField(dc.dsIndex, agg, exports.DS_PRES2016, 'D') + getPackedField(dc.dsIndex, agg, exports.DS_PRES2020, 'D')) / 2);
+        return 0;
+    };
+}
+exports.ToGetterPvi20 = ToGetterPvi20;
+function calcShift(agg, dc, datasetOld, datasetNew) {
+    const getterOld = datasetOld === exports.DS_PVI2016 ?
+        ToGetterPvi16(agg, dc, datasetOld) :
+        datasetOld === exports.DS_PVI2020 ?
+            ToGetterPvi20(agg, dc) :
+            ToGetter(agg, dc, datasetOld);
+    const getterNew = datasetNew === exports.DS_PVI2016 ?
+        ToGetterPvi16(agg, dc, datasetNew) :
+        datasetNew === exports.DS_PVI2020 ?
+            ToGetterPvi20(agg, dc) :
+            ToGetter(agg, dc, datasetNew);
+    // Calc two-party Swing
+    const repOld = getterOld('R');
+    const demOld = getterOld('D');
+    const repNew = getterNew('R');
+    const demNew = getterNew('D');
+    if (repOld === undefined || demOld === undefined || repNew === undefined || demNew === undefined)
+        return null;
+    const totOld = demOld + repOld;
+    const totNew = demNew + repNew;
+    if (totOld <= 0 || totNew <= 0)
+        return null;
+    const pctDemOld = demOld / totOld;
+    const pctRepOld = repOld / totOld;
+    const pctDemNew = demNew / totNew;
+    const pctRepNew = repNew / totNew;
+    const shift = Math.max(Math.min((pctDemNew - pctDemOld) - (pctRepNew - pctRepOld), 1.0), -1.0);
+    return shift;
+}
+exports.calcShift = calcShift;
+function calcRawPvi(getter) {
+    // ((((sum(d_2016) / (sum(d_2016) + sum(r_2016))) * 100) +  ((sum(d_2012) / (sum(d_2012) + sum(r_2012))) * 100)) / 2) - 51.54
+    // Fields hard coded
+    let total2012 = getter('D12') + getter('R12');
+    let total2016 = getter('D16') + getter('R16');
+    let pct2012 = total2012 != 0 ? (getter('D12') / total2012) * 100 : 0;
+    let pct2016 = total2016 != 0 ? (getter('D16') / total2016) * 100 : 0;
+    return (pct2012 + pct2016) / ((total2012 != 0 && total2016 != 0) ? 2 : 1);
+}
+exports.calcRawPvi = calcRawPvi;
+function pviStr(getter) {
+    const pviRaw = calcRawPvi(getter);
+    const pvi = baseclient_1.Util.precisionRound(pviRaw != 0 ? pviRaw - 51.54 : 0, 2);
+    return pvi >= 0 ? 'D+' + pvi : 'R+' + (-pvi);
+}
+exports.pviStr = pviStr;
+function calcRaw2020Pvi(getter16, getter20) {
+    let total2016 = getter16('D') + getter16('R');
+    let total2020 = getter20('D') + getter20('R');
+    let pct2016 = total2016 != 0 ? (getter16('D') / total2016) * 100 : 0;
+    let pct2020 = total2020 != 0 ? (getter20('D') / total2020) * 100 : 0;
+    return (pct2020 + pct2016) / ((total2020 != 0 && total2016 != 0) ? 2 : 1);
+}
+exports.calcRaw2020Pvi = calcRaw2020Pvi;
+function pvi2020Str(getter16, getter20) {
+    const pviRaw = calcRaw2020Pvi(getter16, getter20);
+    const pvi = baseclient_1.Util.precisionRound(pviRaw != 0 ? pviRaw - 51.54 : 0, 2);
+    return pvi >= 0 ? 'D+' + pvi : 'R+' + (-pvi);
+}
+exports.pvi2020Str = pvi2020Str;
 
 
 /***/ }),
@@ -1791,12 +2566,25 @@ module.exports = require("object-hash");
 /******/ 	}
 /******/ 	
 /************************************************************************/
-/******/ 	
-/******/ 	// startup
-/******/ 	// Load entry module and return exports
-/******/ 	// This entry module is referenced by other modules so it can't be inlined
-/******/ 	var __webpack_exports__ = __webpack_require__("./lib/all.ts");
-/******/ 	
+var __webpack_exports__ = {};
+// This entry need to be wrapped in an IIFE because it need to be isolated against other modules in the chunk.
+(() => {
+var exports = __webpack_exports__;
+/*!********************!*\
+  !*** ./lib/all.ts ***!
+  \********************/
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.CM = exports.PF = exports.DT = void 0;
+const DT = __webpack_require__(/*! ./alldt */ "./lib/alldt.ts");
+exports.DT = DT;
+const PF = __webpack_require__(/*! ./packedfields */ "./lib/packedfields.ts");
+exports.PF = PF;
+const CM = __webpack_require__(/*! ./colormgr */ "./lib/colormgr.ts");
+exports.CM = CM;
+
+})();
+
 /******/ 	return __webpack_exports__;
 /******/ })()
 ;