@kepler.gl/utils 3.1.0-alpha.1 → 3.1.0-alpha.3

package/dist/color-utils.d.ts

@@ -0,0 +1,108 @@
+import { CategoricalPalette, ColorPalette } from '@kepler.gl/constants';
+import { ColorMap, ColorRange, ColorRangeConfig, HexColor, RGBColor } from '@kepler.gl/types';
+/**
+ * get r g b from hex code
+ *
+ * @param hex
+ * @returns array of r g bs
+ */
+export declare function hexToRgb(hex: string): RGBColor;
+export declare function isHexColor(hex: string): RegExpExecArray | null;
+/**
+ * get hex from r g b
+ *
+ * @param rgb
+ * @returns hex string
+ */
+export declare function rgbToHex([r, g, b]: RGBColor): HexColor;
+/**
+ * Whether color range has custom color map
+ */
+export declare function hasColorMap(colorRange: ColorRange): boolean;
+/**
+ * given a list of rgb arrays it will generate a linear gradient css rule
+ * @param direction
+ * @param colors
+ * @return
+ */
+export declare function createLinearGradient(direction: string, colors: RGBColor[]): string;
+/**
+ * Convert color to RGB
+ */
+export declare function colorMaybeToRGB(color: unknown): RGBColor | null;
+/**
+ * Whether color is rgb
+ * @returns
+ */
+export declare function isRgbColor(color: unknown): boolean;
+/**
+ * Take color values in 0-255 range and map to [0, 1]
+ */
+export declare function normalizeColor(color: number[]): number[];
+/**
+ * Convert color to Hex
+ */
+export declare function colorMaybeToHex(color: unknown): HexColor;
+/**
+ * Convert color to Hex
+ */
+export declare function interpolateHex(hex1: HexColor, hex2: HexColor): HexColor;
+export declare function addNewQuantativeColorBreakAtIndex(colorMap: any, index: any, newColors: any): any;
+/**
+ * Add a new color to custom palette
+ */
+export declare function addCustomPaletteColor(customPalette: ColorRange, index: number): ColorRange;
+/**
+ * Sort custom palette
+ */
+export declare function sortCustomPaletteColor(customPalette: ColorRange, oldIndex: number, newIndex: number): ColorRange;
+/**
+ * remove a color in custom palette at index
+ */
+export declare function removeCustomPaletteColor(customPalette: ColorRange, index: number): ColorRange;
+/**
+ * Update a color in custom palette at index
+ */
+export declare function updateCustomPaletteColor(customPalette: ColorRange, index: number, newValue: HexColor): ColorRange;
+/**
+ * Get a reversed colorRange
+ */
+export declare function reverseColorRange(reversed: boolean, colorRange: ColorRange): ColorRange;
+/**
+ * Whether palette matches current ColorBlindSafe config
+ */
+export declare function paletteIsColorBlindSafe(palette: ColorPalette, colorBlindSafe: boolean): boolean;
+/**
+ * Whether palette matches current steps config
+ */
+export declare function isQuaPalette(palette: ColorPalette): palette is CategoricalPalette;
+/**
+ * Whether palette matches current steps config
+ */
+export declare function paletteIsSteps(palette: ColorPalette, steps: number): boolean;
+/**
+ * Whether palette matches current type config
+ */
+export declare function paletteIsType(palette: ColorPalette, type: string): boolean;
+/**
+ * Find best match palette based on config, update color range by it
+ */
+export declare function updateColorRangeByMatchingPalette(currentColorRange: ColorRange, config: ColorRangeConfig): ColorRange;
+/**
+ * Update custom palette when reverse the colors in custom palette, since changing 'steps',
+ * 'colorBindSafe', 'type' should fall back to predefined palette.
+ */
+export declare function updateCustomColorRangeByColorUI(oldColorRange: ColorRange, colorConfig: ColorRangeConfig): ColorRange;
+/**
+ * Update color range after selecting a palette from color range selectoer
+ * Copy over colorMap and colorLegends
+ */
+export declare function updateColorRangeBySelectedPalette(oldColorRange: any, colorPalette: any, colorConfig: any): any;
+/**
+ * convert saved colorRange to colorPalette objevt type/name/category/isColorBlind
+ */
+export declare function colorRangeBackwardCompatibility(colorRange: ColorRange): ColorRange;
+/**
+ * Initialize custom palette from current standard color range object
+ */
+export declare function initializeCustomPalette(colorRange: ColorRange, colorMap?: ColorMap): ColorRange;

package/dist/color-utils.js

@@ -0,0 +1,443 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.addCustomPaletteColor = addCustomPaletteColor;
+exports.addNewQuantativeColorBreakAtIndex = addNewQuantativeColorBreakAtIndex;
+exports.colorMaybeToHex = colorMaybeToHex;
+exports.colorMaybeToRGB = colorMaybeToRGB;
+exports.colorRangeBackwardCompatibility = colorRangeBackwardCompatibility;
+exports.createLinearGradient = createLinearGradient;
+exports.hasColorMap = hasColorMap;
+exports.hexToRgb = hexToRgb;
+exports.initializeCustomPalette = initializeCustomPalette;
+exports.interpolateHex = interpolateHex;
+exports.isHexColor = isHexColor;
+exports.isQuaPalette = isQuaPalette;
+exports.isRgbColor = isRgbColor;
+exports.normalizeColor = normalizeColor;
+exports.paletteIsColorBlindSafe = paletteIsColorBlindSafe;
+exports.paletteIsSteps = paletteIsSteps;
+exports.paletteIsType = paletteIsType;
+exports.removeCustomPaletteColor = removeCustomPaletteColor;
+exports.reverseColorRange = reverseColorRange;
+exports.rgbToHex = rgbToHex;
+exports.sortCustomPaletteColor = sortCustomPaletteColor;
+exports.updateColorRangeByMatchingPalette = updateColorRangeByMatchingPalette;
+exports.updateColorRangeBySelectedPalette = updateColorRangeBySelectedPalette;
+exports.updateCustomColorRangeByColorUI = updateCustomColorRangeByColorUI;
+exports.updateCustomPaletteColor = updateCustomPaletteColor;
+var _objectWithoutProperties2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutProperties"));
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _constants = require("@kepler.gl/constants");
+var _d3Color = require("d3-color");
+var _d3Interpolate = require("d3-interpolate");
+var _utils = require("./utils");
+var _console = _interopRequireDefault(require("global/console"));
+var _excluded = ["colors"];
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0, _defineProperty2["default"])(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; } // SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+/**
+ * get r g b from hex code
+ *
+ * @param hex
+ * @returns array of r g bs
+ */
+function hexToRgb(hex) {
+  var result = isHexColor(hex);
+  if (!result) {
+    return [0, 0, 0];
+  }
+  var r = parseInt(result[1], 16);
+  var g = parseInt(result[2], 16);
+  var b = parseInt(result[3], 16);
+  return [r, g, b];
+}
+function isHexColor(hex) {
+  var result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex);
+  return result;
+}
+function PadNum(c) {
+  var hex = c.toString(16);
+  return hex.length === 1 ? "0".concat(hex) : hex;
+}
+
+/**
+ * get hex from r g b
+ *
+ * @param rgb
+ * @returns hex string
+ */
+function rgbToHex(_ref) {
+  var _ref2 = (0, _slicedToArray2["default"])(_ref, 3),
+    r = _ref2[0],
+    g = _ref2[1],
+    b = _ref2[2];
+  return "#".concat([r, g, b].map(function (n) {
+    return PadNum(n);
+  }).join('')).toUpperCase();
+}
+
+/**
+ * Whether color range has custom color map
+ */
+function hasColorMap(colorRange) {
+  return Array.isArray(colorRange.colorMap) && Boolean(colorRange.colorMap.length);
+}
+
+/**
+ * given a list of rgb arrays it will generate a linear gradient css rule
+ * @param direction
+ * @param colors
+ * @return
+ */
+function createLinearGradient(direction, colors) {
+  var step = parseFloat((100.0 / colors.length).toFixed(2));
+  var bands = colors.map(function (rgb, index) {
+    return "rgba(".concat(rgb.join(','), ", 1) ").concat(step * index, "%, rgba(").concat(rgb.join(','), ", 1) ").concat(step * (index + 1), "%");
+  });
+  return "linear-gradient(to ".concat(direction, ", ").concat(bands.join(','), ")");
+}
+
+/**
+ * Convert color to RGB
+ */
+function colorMaybeToRGB(color) {
+  if (isRgbColor(color)) {
+    return color;
+  }
+  if (typeof color === 'string') {
+    var rgbObj = (0, _d3Color.rgb)(color);
+    if (Number.isFinite(rgbObj === null || rgbObj === void 0 ? void 0 : rgbObj.r) && Number.isFinite(rgbObj === null || rgbObj === void 0 ? void 0 : rgbObj.g) && Number.isFinite(rgbObj === null || rgbObj === void 0 ? void 0 : rgbObj.b)) {
+      return [rgbObj.r, rgbObj.g, rgbObj.b];
+    }
+  }
+  return null;
+}
+
+/**
+ * Whether color is rgb
+ * @returns
+ */
+function isRgbColor(color) {
+  return Boolean(color && Array.isArray(color) && color.length === 3 && color.every(function (n) {
+    return Number.isFinite(n) && n <= 255 && n >= 0;
+  }));
+}
+
+/**
+ * Take color values in 0-255 range and map to [0, 1]
+ */
+function normalizeColor(color) {
+  return color.map(function (component) {
+    return component / 255.0;
+  });
+}
+
+/**
+ * Convert color to Hex
+ */
+function colorMaybeToHex(color) {
+  var rgbColor = colorMaybeToRGB(color);
+  if (rgbColor) return rgbToHex(rgbColor);
+  return '#000000';
+}
+
+/**
+ * Convert color to Hex
+ */
+
+function interpolateHex(hex1, hex2) {
+  return (0, _d3Color.rgb)((0, _d3Interpolate.interpolate)(hex1, hex2)(0.5)).hex().toUpperCase();
+}
+function addNewQuantativeColorBreakAtIndex(colorMap, index, newColors) {
+  if (!Array.isArray(colorMap) || !colorMap.length) {
+    return colorMap;
+  }
+  if (colorMap.length < 2) {
+    // less then 2, add 1 at end
+    // however shouldn't allow delete when there are 2
+    return newColors.map(function (c, i) {
+      return i === 0 ? colorMap[i] : [null, c];
+    });
+  }
+
+  // breaks should be 1 less than colors
+  var breaks = colorMap.map(function (cm) {
+    return cm[0];
+  }).slice(0, colorMap.length - 1);
+
+  // insert new break
+  var newValue = index >= breaks.length - 1 ? breaks[breaks.length - 1] + (breaks.length > 1 ? breaks[breaks.length - 1] - breaks[breaks.length - 2] : 0) : (breaks[index] + breaks[index + 1]) / 2;
+  var newBreaks = (0, _utils.arrayInsert)(breaks, index + 1, newValue);
+
+  // asign breaks to color
+  return newColors.map(function (c, i) {
+    return i === newColors.length - 1 ? [null, c] : [newBreaks[i] === undefined ? null : newBreaks[i], c];
+  });
+}
+
+/**
+ * Add a new color to custom palette
+ */
+function addCustomPaletteColor(customPalette, index) {
+  var colors = customPalette.colors,
+    colorMap = customPalette.colorMap;
+  var update = {};
+  var newColor = index === colors.length - 1 ? colors[index] : interpolateHex(colors[index], colors[index + 1]);
+  update.colors = (0, _utils.arrayInsert)(colors, index + 1, newColor);
+
+  // add color to colorMap
+  if (colorMap) {
+    update.colorMap = addNewQuantativeColorBreakAtIndex(colorMap, index, update.colors);
+  }
+  return _objectSpread(_objectSpread({}, customPalette), update);
+}
+function replaceColorsInColorRange(colorRange, newColors) {
+  var oldColors = colorRange.colors;
+  var updated = _objectSpread(_objectSpread({}, colorRange), {}, {
+    colors: newColors
+  });
+
+  // update color map
+  // keep value, replace color
+  if (Array.isArray(updated.colorMap)) {
+    updated.colorMap = updated.colorMap.map(function (cm, i) {
+      return [cm[0], newColors[i]];
+    });
+  }
+  // update colorlegends
+  // keep value, replace color
+  if (updated.colorLegends) {
+    updated.colorLegends = Object.keys(updated.colorLegends).reduce(function (accu, key) {
+      var colorIdx = oldColors.findIndex(function (c) {
+        return c === key;
+      });
+      var newColor = newColors[colorIdx];
+      return newColor ? _objectSpread(_objectSpread({}, accu), {}, (0, _defineProperty2["default"])({}, newColor, updated.colorLegends[key])) : accu;
+    }, {});
+  }
+  return updated;
+}
+
+/**
+ * Sort custom palette
+ */
+function sortCustomPaletteColor(customPalette, oldIndex, newIndex) {
+  var colors = customPalette.colors;
+  var newColors = (0, _utils.arrayMove)(colors, oldIndex, newIndex);
+  var update = replaceColorsInColorRange(customPalette, newColors);
+
+  // @ts-ignore
+  return _objectSpread(_objectSpread({}, customPalette), update);
+}
+
+/**
+ * remove a color in custom palette at index
+ */
+function removeCustomPaletteColor(customPalette, index) {
+  var colors = customPalette.colors,
+    colorMap = customPalette.colorMap,
+    colorLegends = customPalette.colorLegends;
+  var oldValue = colors[index];
+  var update = {};
+  update.colors = (0, _toConsumableArray2["default"])(colors);
+  if (update.colors.length > 1) {
+    update.colors.splice(index, 1);
+  }
+  // update color map
+  if (Array.isArray(colorMap)) {
+    // find colorMap index
+    var colorMapIndex = colorMap.findIndex(function (cm) {
+      return cm[1] === oldValue;
+    });
+    if (colorMapIndex >= 0) {
+      update.colorMap = (0, _toConsumableArray2["default"])(colorMap);
+      update.colorMap.splice(colorMapIndex, 1);
+    }
+  }
+  // update color legend
+  if (colorLegends !== null && colorLegends !== void 0 && colorLegends[oldValue]) {
+    update.colorLegends = _objectSpread({}, colorLegends);
+    delete update.colorLegends[oldValue];
+  }
+  return _objectSpread(_objectSpread({}, customPalette), update);
+}
+
+/**
+ * Update a color in custom palette at index
+ */
+function updateCustomPaletteColor(customPalette, index, newValue) {
+  var colors = customPalette.colors;
+  var hex = newValue.toUpperCase();
+  var newColors = (0, _toConsumableArray2["default"])(colors);
+  newColors[index] = hex;
+  var update = replaceColorsInColorRange(customPalette, newColors);
+
+  // @ts-ignore
+  return _objectSpread(_objectSpread({}, customPalette), update);
+}
+
+/**
+ * Get a reversed colorRange
+ */
+function reverseColorRange(reversed, colorRange) {
+  var newColors = colorRange === null || colorRange === void 0 ? void 0 : colorRange.colors.slice().reverse();
+  var updated = replaceColorsInColorRange(colorRange, newColors);
+  updated.reversed = reversed;
+  return updated;
+}
+
+/**
+ * Whether palette matches current ColorBlindSafe config
+ */
+function paletteIsColorBlindSafe(palette, colorBlindSafe) {
+  return !colorBlindSafe || colorBlindSafe && palette.colorBlindSafe;
+}
+
+/**
+ * Whether palette matches current steps config
+ */
+function isQuaPalette(palette) {
+  return palette.type === _constants.PALETTE_TYPES.QUA;
+}
+
+/**
+ * Whether palette matches current steps config
+ */
+function paletteIsSteps(palette, steps) {
+  return !isQuaPalette(palette) || palette.maxStep >= steps;
+}
+
+/**
+ * Whether palette matches current type config
+ */
+function paletteIsType(palette, type) {
+  return type === 'all' || type === palette.type;
+}
+/**
+ * Find best match palette based on config, update color range by it
+ */
+function updateColorRangeByMatchingPalette(currentColorRange, config) {
+  var steps = config.steps,
+    colorBlindSafe = config.colorBlindSafe,
+    type = config.type;
+  var matchingPalette = _constants.KEPLER_COLOR_PALETTES.filter(function (palette) {
+    return (
+      // palette match type
+      paletteIsType(palette, type) &&
+      // palette has same step
+      paletteIsSteps(palette, steps) &&
+      // palette is colorBlindSafe
+      paletteIsColorBlindSafe(palette, colorBlindSafe)
+    );
+  });
+  var bestMatch = matchingPalette.length ? matchingPalette.find(function (p) {
+    return p.name === currentColorRange.name;
+  }) || matchingPalette[0] : null;
+  if (bestMatch) {
+    return updateColorRangeBySelectedPalette(currentColorRange, bestMatch, config);
+  }
+  // we do nothing
+  _console["default"].warn("we cant find any preset palette matches requirments: steps=".concat(steps, " && colorBlindSafe=").concat(colorBlindSafe));
+  return currentColorRange;
+}
+
+/**
+ * Update custom palette when reverse the colors in custom palette, since changing 'steps',
+ * 'colorBindSafe', 'type' should fall back to predefined palette.
+ */
+function updateCustomColorRangeByColorUI(oldColorRange, colorConfig) {
+  var reversed = colorConfig.reversed;
+  var colors = oldColorRange.colors;
+  // for custom palette, one can only 'reverse' the colors in custom palette.
+  colors.reverse();
+  var colorRange = _objectSpread(_objectSpread(_objectSpread({
+    name: oldColorRange.name,
+    type: oldColorRange.type,
+    category: oldColorRange.category,
+    colors: colors
+  }, reversed ? {
+    reversed: reversed
+  } : {}), oldColorRange.colorMap ? {
+    colorMap: oldColorRange.colorMap
+  } : {}), oldColorRange.colorLegends ? {
+    colorLegends: oldColorRange.colorLegends
+  } : {});
+  return replaceColorsInColorRange(colorRange, colorRange.colors);
+}
+
+/**
+ * Update color range after selecting a palette from color range selectoer
+ * Copy over colorMap and colorLegends
+ */
+function updateColorRangeBySelectedPalette(oldColorRange, colorPalette, colorConfig) {
+  var _colorPaletteToColorR = (0, _constants.colorPaletteToColorRange)(colorPalette, colorConfig),
+    newColors = _colorPaletteToColorR.colors,
+    newColorRange = (0, _objectWithoutProperties2["default"])(_colorPaletteToColorR, _excluded);
+  var colorRange = _objectSpread(_objectSpread(_objectSpread({
+    colors: oldColorRange.colors
+  }, newColorRange), oldColorRange.colorMap ? {
+    colorMap: oldColorRange.colorMap
+  } : {}), oldColorRange.colorLegends ? {
+    colorLegends: oldColorRange.colorLegends
+  } : {});
+  return replaceColorsInColorRange(colorRange, newColors);
+}
+var UberNameRegex = new RegExp(/^([A-Za-z ])+/g);
+var ColorBrewerRegex = new RegExp(/^ColorBrewer ([A-Za-z1-9])+/g);
+
+/**
+ * convert saved colorRange to colorPalette objevt type/name/category/isColorBlind
+ */
+function colorRangeBackwardCompatibility(colorRange) {
+  if (!colorRange || colorRange.type === 'custom' || colorRange.colorMap) {
+    // don't do anything to custom color palette, or palette with custom breaks
+    return colorRange;
+  }
+  var trimName;
+  if (colorRange.category === 'Uber') {
+    var _colorRange$name;
+    var matchName = ((_colorRange$name = colorRange.name) !== null && _colorRange$name !== void 0 ? _colorRange$name : '').match(UberNameRegex);
+    trimName = matchName ? matchName[0].trim() : null;
+    // match Uber Viz Qualitative 1.4 -> Uber Viz Qualitative
+  } else if (colorRange.category === 'ColorBrewer') {
+    var _colorRange$name2;
+    var _matchName = ((_colorRange$name2 = colorRange.name) !== null && _colorRange$name2 !== void 0 ? _colorRange$name2 : '').match(ColorBrewerRegex);
+    trimName = _matchName ? _matchName[0].replace('ColorBrewer ', '').trim() : null;
+  }
+  if (trimName) {
+    var matchingPalette = _constants.KEPLER_COLOR_PALETTES.find(function (p) {
+      return p.name === trimName;
+    });
+    if (matchingPalette) {
+      return _objectSpread(_objectSpread({}, colorRange), {}, {
+        name: trimName,
+        type: matchingPalette === null || matchingPalette === void 0 ? void 0 : matchingPalette.type,
+        category: matchingPalette.category
+      });
+    }
+  }
+  return colorRange;
+}
+
+/**
+ * Initialize custom palette from current standard color range object
+ */
+function initializeCustomPalette(colorRange, colorMap) {
+  // TODO: check on `isReversed` key, whether we can remove it here
+  var customPalette = _objectSpread(_objectSpread({}, colorRange), {}, {
+    name: _constants.DEFAULT_CUSTOM_PALETTE.name,
+    type: _constants.DEFAULT_CUSTOM_PALETTE.type,
+    category: _constants.DEFAULT_CUSTOM_PALETTE.category
+  }, colorMap ? {
+    colorMap: colorMap
+  } : {});
+  return customPalette;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_constants","require","_d3Color","_d3Interpolate","_utils","_console","_interopRequireDefault","_excluded","ownKeys","e","r","t","Object","keys","getOwnPropertySymbols","o","filter","getOwnPropertyDescriptor","enumerable","push","apply","_objectSpread","arguments","length","forEach","_defineProperty2","getOwnPropertyDescriptors","defineProperties","defineProperty","hexToRgb","hex","result","isHexColor","parseInt","g","b","exec","PadNum","c","toString","concat","rgbToHex","_ref","_ref2","_slicedToArray2","map","n","join","toUpperCase","hasColorMap","colorRange","Array","isArray","colorMap","Boolean","createLinearGradient","direction","colors","step","parseFloat","toFixed","bands","rgb","index","colorMaybeToRGB","color","isRgbColor","rgbObj","d3Rgb","Number","isFinite","every","normalizeColor","component","colorMaybeToHex","rgbColor","interpolateHex","hex1","hex2","interpolate","addNewQuantativeColorBreakAtIndex","newColors","i","breaks","cm","slice","newValue","newBreaks","arrayInsert","undefined","addCustomPaletteColor","customPalette","update","newColor","replaceColorsInColorRange","oldColors","updated","colorLegends","reduce","accu","key","colorIdx","findIndex","sortCustomPaletteColor","oldIndex","newIndex","arrayMove","removeCustomPaletteColor","oldValue","_toConsumableArray2","splice","colorMapIndex","updateCustomPaletteColor","reverseColorRange","reversed","reverse","paletteIsColorBlindSafe","palette","colorBlindSafe","isQuaPalette","type","PALETTE_TYPES","QUA","paletteIsSteps","steps","maxStep","paletteIsType","updateColorRangeByMatchingPalette","currentColorRange","config","matchingPalette","KEPLER_COLOR_PALETTES","bestMatch","find","p","name","updateColorRangeBySelectedPalette","Console","warn","updateCustomColorRangeByColorUI","oldColorRange","colorConfig","category","colorPalette","_colorPaletteToColorR","colorPaletteToColorRange","newColorRange","_objectWithoutProperties2","UberNameRegex","RegExp","ColorBrewerRegex","colorRangeBackwardCompatibility","trimName","_colorRange$name","matchName","match","trim","_colorRange$name2","replace","initializeCustomPalette","DEFAULT_CUSTOM_PALETTE"],"sources":["../src/color-utils.ts"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\nimport {\n  CategoricalPalette,\n  ColorPalette,\n  DEFAULT_CUSTOM_PALETTE,\n  colorPaletteToColorRange\n} from '@kepler.gl/constants';\nimport {ColorMap, ColorRange, ColorRangeConfig, HexColor, RGBColor} from '@kepler.gl/types';\nimport {rgb as d3Rgb} from 'd3-color';\nimport {interpolate} from 'd3-interpolate';\nimport {arrayInsert, arrayMove} from './utils';\nimport Console from 'global/console';\nimport {KEPLER_COLOR_PALETTES, PALETTE_TYPES} from '@kepler.gl/constants';\n\n/**\n * get r g b from hex code\n *\n * @param hex\n * @returns array of r g bs\n */\nexport function hexToRgb(hex: string): RGBColor {\n  const result = isHexColor(hex);\n\n  if (!result) {\n    return [0, 0, 0];\n  }\n\n  const r = parseInt(result[1], 16);\n  const g = parseInt(result[2], 16);\n  const b = parseInt(result[3], 16);\n\n  return [r, g, b];\n}\n\nexport function isHexColor(hex: string): RegExpExecArray | null {\n  const result = /^#?([a-f\\d]{2})([a-f\\d]{2})([a-f\\d]{2})$/i.exec(hex);\n\n  return result;\n}\n\nfunction PadNum(c) {\n  const hex = c.toString(16);\n  return hex.length === 1 ? `0${hex}` : hex;\n}\n\n/**\n * get hex from r g b\n *\n * @param rgb\n * @returns hex string\n */\nexport function rgbToHex([r, g, b]: RGBColor): HexColor {\n  return `#${[r, g, b].map(n => PadNum(n)).join('')}`.toUpperCase();\n}\n\n/**\n * Whether color range has custom color map\n */\nexport function hasColorMap(colorRange: ColorRange): boolean {\n  return Array.isArray(colorRange.colorMap) && Boolean(colorRange.colorMap.length);\n}\n\n/**\n * given a list of rgb arrays it will generate a linear gradient css rule\n * @param direction\n * @param colors\n * @return\n */\nexport function createLinearGradient(direction: string, colors: RGBColor[]): string {\n  const step = parseFloat((100.0 / colors.length).toFixed(2));\n  const bands = colors.map((rgb, index) => {\n    return `rgba(${rgb.join(',')}, 1) ${step * index}%, rgba(${rgb.join(',')}, 1) ${\n      step * (index + 1)\n    }%`;\n  });\n\n  return `linear-gradient(to ${direction}, ${bands.join(',')})`;\n}\n\n/**\n * Convert color to RGB\n */\nexport function colorMaybeToRGB(color: unknown): RGBColor | null {\n  if (isRgbColor(color)) {\n    return color as RGBColor;\n  }\n\n  if (typeof color === 'string') {\n    const rgbObj = d3Rgb(color);\n    if (Number.isFinite(rgbObj?.r) && Number.isFinite(rgbObj?.g) && Number.isFinite(rgbObj?.b)) {\n      return [rgbObj.r, rgbObj.g, rgbObj.b];\n    }\n  }\n\n  return null;\n}\n\n/**\n * Whether color is rgb\n * @returns\n */\nexport function isRgbColor(color: unknown): boolean {\n  return Boolean(\n    color &&\n      Array.isArray(color) &&\n      color.length === 3 &&\n      color.every(n => Number.isFinite(n) && n <= 255 && n >= 0)\n  );\n}\n\n/**\n * Take color values in 0-255 range and map to [0, 1]\n */\nexport function normalizeColor(color: number[]): number[] {\n  return color.map(component => component / 255.0);\n}\n\n/**\n * Convert color to Hex\n */\nexport function colorMaybeToHex(color: unknown): HexColor {\n  const rgbColor = colorMaybeToRGB(color);\n  if (rgbColor) return rgbToHex(rgbColor);\n  return '#000000';\n}\n\n/**\n * Convert color to Hex\n */\n\nexport function interpolateHex(hex1: HexColor, hex2: HexColor): HexColor {\n  return d3Rgb(interpolate(hex1, hex2)(0.5)).hex().toUpperCase();\n}\n\nexport function addNewQuantativeColorBreakAtIndex(colorMap, index, newColors) {\n  if (!Array.isArray(colorMap) || !colorMap.length) {\n    return colorMap;\n  }\n\n  if (colorMap.length < 2) {\n    // less then 2, add 1 at end\n    // however shouldn't allow delete when there are 2\n    return newColors.map((c, i) => (i === 0 ? colorMap[i] : [null, c]));\n  }\n\n  // breaks should be 1 less than colors\n  const breaks = colorMap.map(cm => cm[0]).slice(0, colorMap.length - 1);\n\n  // insert new break\n  const newValue =\n    index >= breaks.length - 1\n      ? breaks[breaks.length - 1] +\n        (breaks.length > 1 ? breaks[breaks.length - 1] - breaks[breaks.length - 2] : 0)\n      : (breaks[index] + breaks[index + 1]) / 2;\n\n  const newBreaks = arrayInsert(breaks, index + 1, newValue);\n\n  // asign breaks to color\n  return newColors.map((c, i) =>\n    i === newColors.length - 1 ? [null, c] : [newBreaks[i] === undefined ? null : newBreaks[i], c]\n  );\n}\n\n/**\n * Add a new color to custom palette\n */\nexport function addCustomPaletteColor(customPalette: ColorRange, index: number): ColorRange {\n  const {colors, colorMap} = customPalette;\n  const update: Partial<ColorRange> = {};\n\n  const newColor =\n    index === colors.length - 1 ? colors[index] : interpolateHex(colors[index], colors[index + 1]);\n\n  update.colors = arrayInsert(colors, index + 1, newColor);\n\n  // add color to colorMap\n  if (colorMap) {\n    update.colorMap = addNewQuantativeColorBreakAtIndex(colorMap, index, update.colors);\n  }\n\n  return {\n    ...customPalette,\n    ...update\n  };\n}\n\nfunction replaceColorsInColorRange(colorRange, newColors) {\n  const oldColors = colorRange.colors;\n  const updated = {\n    ...colorRange,\n    colors: newColors\n  };\n\n  // update color map\n  // keep value, replace color\n  if (Array.isArray(updated.colorMap)) {\n    updated.colorMap = updated.colorMap.map((cm, i) => [cm[0], newColors[i]]);\n  }\n  // update colorlegends\n  // keep value, replace color\n  if (updated.colorLegends) {\n    updated.colorLegends = Object.keys(updated.colorLegends).reduce((accu, key) => {\n      const colorIdx = oldColors.findIndex(c => c === key);\n      const newColor = newColors[colorIdx];\n\n      return newColor\n        ? {\n            ...accu,\n            [newColor]: updated.colorLegends[key]\n          }\n        : accu;\n    }, {});\n  }\n\n  return updated;\n}\n\n/**\n * Sort custom palette\n */\nexport function sortCustomPaletteColor(\n  customPalette: ColorRange,\n  oldIndex: number,\n  newIndex: number\n): ColorRange {\n  const {colors} = customPalette;\n\n  const newColors = arrayMove(colors, oldIndex, newIndex);\n  const update = replaceColorsInColorRange(customPalette, newColors);\n\n  // @ts-ignore\n  return {\n    ...customPalette,\n    ...update\n  };\n}\n\n/**\n * remove a color in custom palette at index\n */\nexport function removeCustomPaletteColor(customPalette: ColorRange, index: number): ColorRange {\n  const {colors, colorMap, colorLegends} = customPalette;\n  const oldValue = colors[index];\n  const update: Partial<ColorRange> = {};\n  update.colors = [...colors];\n\n  if (update.colors.length > 1) {\n    update.colors.splice(index, 1);\n  }\n  // update color map\n  if (Array.isArray(colorMap)) {\n    // find colorMap index\n    const colorMapIndex = colorMap.findIndex(cm => cm[1] === oldValue);\n    if (colorMapIndex >= 0) {\n      update.colorMap = [...colorMap];\n      update.colorMap.splice(colorMapIndex, 1);\n    }\n  }\n  // update color legend\n  if (colorLegends?.[oldValue]) {\n    update.colorLegends = {...colorLegends};\n    delete update.colorLegends[oldValue];\n  }\n\n  return {\n    ...customPalette,\n    ...update\n  };\n}\n\n/**\n * Update a color in custom palette at index\n */\nexport function updateCustomPaletteColor(\n  customPalette: ColorRange,\n  index: number,\n  newValue: HexColor\n): ColorRange {\n  const {colors} = customPalette;\n  const hex = newValue.toUpperCase();\n  const newColors = [...colors];\n  newColors[index] = hex;\n\n  const update = replaceColorsInColorRange(customPalette, newColors);\n\n  // @ts-ignore\n  return {\n    ...customPalette,\n    ...update\n  };\n}\n\n/**\n * Get a reversed colorRange\n */\nexport function reverseColorRange(reversed: boolean, colorRange: ColorRange): ColorRange {\n  const newColors = colorRange?.colors.slice().reverse();\n  const updated = replaceColorsInColorRange(colorRange, newColors);\n  updated.reversed = reversed;\n\n  return updated;\n}\n\n/**\n * Whether palette matches current ColorBlindSafe config\n */\nexport function paletteIsColorBlindSafe(palette: ColorPalette, colorBlindSafe: boolean) {\n  return !colorBlindSafe || (colorBlindSafe && palette.colorBlindSafe);\n}\n\n/**\n * Whether palette matches current steps config\n */\nexport function isQuaPalette(palette: ColorPalette): palette is CategoricalPalette {\n  return palette.type === PALETTE_TYPES.QUA;\n}\n\n/**\n * Whether palette matches current steps config\n */\nexport function paletteIsSteps(palette: ColorPalette, steps: number): boolean {\n  return !isQuaPalette(palette) || palette.maxStep >= steps;\n}\n\n/**\n * Whether palette matches current type config\n */\nexport function paletteIsType(palette: ColorPalette, type: string): boolean {\n  return type === 'all' || type === palette.type;\n}\n/**\n * Find best match palette based on config, update color range by it\n */\nexport function updateColorRangeByMatchingPalette(\n  currentColorRange: ColorRange,\n  config: ColorRangeConfig\n): ColorRange {\n  const {steps, colorBlindSafe, type} = config;\n\n  const matchingPalette = KEPLER_COLOR_PALETTES.filter(\n    palette =>\n      // palette match type\n      paletteIsType(palette, type) &&\n      // palette has same step\n      paletteIsSteps(palette, steps) &&\n      // palette is colorBlindSafe\n      paletteIsColorBlindSafe(palette, colorBlindSafe)\n  );\n\n  const bestMatch = matchingPalette.length\n    ? matchingPalette.find(p => p.name === currentColorRange.name) || matchingPalette[0]\n    : null;\n\n  if (bestMatch) {\n    return updateColorRangeBySelectedPalette(currentColorRange, bestMatch, config);\n  }\n  // we do nothing\n  Console.warn(\n    `we cant find any preset palette matches requirments: steps=${steps} && colorBlindSafe=${colorBlindSafe}`\n  );\n\n  return currentColorRange;\n}\n\n/**\n * Update custom palette when reverse the colors in custom palette, since changing 'steps',\n * 'colorBindSafe', 'type' should fall back to predefined palette.\n */\nexport function updateCustomColorRangeByColorUI(\n  oldColorRange: ColorRange,\n  colorConfig: ColorRangeConfig\n): ColorRange {\n  const {reversed} = colorConfig;\n  const colors = oldColorRange.colors;\n  // for custom palette, one can only 'reverse' the colors in custom palette.\n  colors.reverse();\n\n  const colorRange = {\n    name: oldColorRange.name,\n    type: oldColorRange.type,\n    category: oldColorRange.category,\n    colors,\n    ...(reversed ? {reversed} : {}),\n    ...(oldColorRange.colorMap ? {colorMap: oldColorRange.colorMap} : {}),\n    ...(oldColorRange.colorLegends ? {colorLegends: oldColorRange.colorLegends} : {})\n  };\n\n  return replaceColorsInColorRange(colorRange, colorRange.colors);\n}\n\n/**\n * Update color range after selecting a palette from color range selectoer\n * Copy over colorMap and colorLegends\n */\nexport function updateColorRangeBySelectedPalette(oldColorRange, colorPalette, colorConfig) {\n  const {colors: newColors, ...newColorRange} = colorPaletteToColorRange(colorPalette, colorConfig);\n\n  const colorRange = {\n    colors: oldColorRange.colors,\n    ...newColorRange,\n    ...(oldColorRange.colorMap ? {colorMap: oldColorRange.colorMap} : {}),\n    ...(oldColorRange.colorLegends ? {colorLegends: oldColorRange.colorLegends} : {})\n  };\n\n  return replaceColorsInColorRange(colorRange, newColors);\n}\n\nconst UberNameRegex = new RegExp(/^([A-Za-z ])+/g);\nconst ColorBrewerRegex = new RegExp(/^ColorBrewer ([A-Za-z1-9])+/g);\n\n/**\n * convert saved colorRange to colorPalette objevt type/name/category/isColorBlind\n */\nexport function colorRangeBackwardCompatibility(colorRange: ColorRange): ColorRange {\n  if (!colorRange || colorRange.type === 'custom' || colorRange.colorMap) {\n    // don't do anything to custom color palette, or palette with custom breaks\n    return colorRange;\n  }\n  let trimName;\n  if (colorRange.category === 'Uber') {\n    const matchName = (colorRange.name ?? '').match(UberNameRegex);\n    trimName = matchName ? matchName[0].trim() : null;\n    // match Uber Viz Qualitative 1.4 -> Uber Viz Qualitative\n  } else if (colorRange.category === 'ColorBrewer') {\n    const matchName = (colorRange.name ?? '').match(ColorBrewerRegex);\n    trimName = matchName ? matchName[0].replace('ColorBrewer ', '').trim() : null;\n  }\n\n  if (trimName) {\n    const matchingPalette = KEPLER_COLOR_PALETTES.find(p => p.name === trimName);\n    if (matchingPalette) {\n      return {\n        ...colorRange,\n        name: trimName,\n        type: matchingPalette?.type,\n        category: matchingPalette.category\n      };\n    }\n  }\n\n  return colorRange;\n}\n\n/**\n * Initialize custom palette from current standard color range object\n */\nexport function initializeCustomPalette(colorRange: ColorRange, colorMap?: ColorMap): ColorRange {\n  // TODO: check on `isReversed` key, whether we can remove it here\n  const customPalette = {\n    ...colorRange,\n    name: DEFAULT_CUSTOM_PALETTE.name,\n    type: DEFAULT_CUSTOM_PALETTE.type,\n    category: DEFAULT_CUSTOM_PALETTE.category,\n    ...(colorMap ? {colorMap} : {})\n  };\n\n  return customPalette;\n}\n"],"mappings":"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","ignoreList":[]}