@splunk/visualizations 24.2.0 → 24.3.0

package/Map.config.js

@@ -0,0 +1,740 @@
+/*!
+ * Copyright © 2018 Splunk Inc.
+ * SPLUNK CONFIDENTIAL – Use or disclosure of this material in whole or
+ * in part without a valid written license from Splunk Inc. is PROHIBITED.
+ */
+module.exports =
+/******/ (function(modules) { // webpackBootstrap
+/******/ 	// The module cache
+/******/ 	var installedModules = {};
+/******/
+/******/ 	// The require function
+/******/ 	function __webpack_require__(moduleId) {
+/******/
+/******/ 		// Check if module is in cache
+/******/ 		if(installedModules[moduleId]) {
+/******/ 			return installedModules[moduleId].exports;
+/******/ 		}
+/******/ 		// Create a new module (and put it into the cache)
+/******/ 		var module = installedModules[moduleId] = {
+/******/ 			i: moduleId,
+/******/ 			l: false,
+/******/ 			exports: {}
+/******/ 		};
+/******/
+/******/ 		// Execute the module function
+/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
+/******/
+/******/ 		// Flag the module as loaded
+/******/ 		module.l = true;
+/******/
+/******/ 		// Return the exports of the module
+/******/ 		return module.exports;
+/******/ 	}
+/******/
+/******/
+/******/ 	// expose the modules object (__webpack_modules__)
+/******/ 	__webpack_require__.m = modules;
+/******/
+/******/ 	// expose the module cache
+/******/ 	__webpack_require__.c = installedModules;
+/******/
+/******/ 	// define getter function for harmony exports
+/******/ 	__webpack_require__.d = function(exports, name, getter) {
+/******/ 		if(!__webpack_require__.o(exports, name)) {
+/******/ 			Object.defineProperty(exports, name, { enumerable: true, get: getter });
+/******/ 		}
+/******/ 	};
+/******/
+/******/ 	// define __esModule on exports
+/******/ 	__webpack_require__.r = function(exports) {
+/******/ 		if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
+/******/ 			Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+/******/ 		}
+/******/ 		Object.defineProperty(exports, '__esModule', { value: true });
+/******/ 	};
+/******/
+/******/ 	// create a fake namespace object
+/******/ 	// mode & 1: value is a module id, require it
+/******/ 	// mode & 2: merge all properties of value into the ns
+/******/ 	// mode & 4: return value when already ns object
+/******/ 	// mode & 8|1: behave like require
+/******/ 	__webpack_require__.t = function(value, mode) {
+/******/ 		if(mode & 1) value = __webpack_require__(value);
+/******/ 		if(mode & 8) return value;
+/******/ 		if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;
+/******/ 		var ns = Object.create(null);
+/******/ 		__webpack_require__.r(ns);
+/******/ 		Object.defineProperty(ns, 'default', { enumerable: true, value: value });
+/******/ 		if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));
+/******/ 		return ns;
+/******/ 	};
+/******/
+/******/ 	// getDefaultExport function for compatibility with non-harmony modules
+/******/ 	__webpack_require__.n = function(module) {
+/******/ 		var getter = module && module.__esModule ?
+/******/ 			function getDefault() { return module['default']; } :
+/******/ 			function getModuleExports() { return module; };
+/******/ 		__webpack_require__.d(getter, 'a', getter);
+/******/ 		return getter;
+/******/ 	};
+/******/
+/******/ 	// Object.prototype.hasOwnProperty.call
+/******/ 	__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
+/******/
+/******/ 	// __webpack_public_path__
+/******/ 	__webpack_require__.p = "";
+/******/
+/******/
+/******/ 	// Load entry module and return exports
+/******/ 	return __webpack_require__(__webpack_require__.s = 50);
+/******/ })
+/************************************************************************/
+/******/ ({
+
+/***/ 0:
+/***/ (function(module, exports) {
+
+module.exports = require("@splunk/ui-utils/i18n");
+
+/***/ }),
+
+/***/ 1:
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+var _defineProperty = __webpack_require__(6);
+
+var __rest = this && this.__rest || function (s, e) {
+  var t = {};
+
+  for (var p in s) {
+    if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
+  }
+
+  if (s != null && typeof Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+    if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]];
+  }
+  return t;
+};
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.generatePrecisionValues = exports.getInitialPreset = exports.isDynamicOption = exports.enhanceOptionsSchemaWithDynamicOptions = exports.enhanceConfig = void 0;
+
+var lodash_1 = __webpack_require__(4);
+
+var schemaUtils_1 = __webpack_require__(3);
+
+var VizBehavior_1 = __webpack_require__(2);
+
+var dynamicOptionsDSLType = {
+  type: 'string',
+  pattern: schemaUtils_1.DYNAMIC_OPTIONS_DSL_PATTERN
+};
+/**
+ * Helper function to extend an options schema with dynamic options DSL
+ * @param optionsSchema a visualization's options schema
+ * @returns an updated options schema that additionally allows strings starting with > for each option
+ */
+
+function enhanceOptionsSchemaWithDynamicOptions(optionsSchema) {
+  var enhancedOptionsSchema = {};
+  Object.keys(optionsSchema).forEach(function (key) {
+    var _a = optionsSchema[key],
+        title = _a.title,
+        description = _a.description,
+        readOnly = _a.readOnly,
+        writeOnly = _a.writeOnly,
+        examples = _a.examples,
+        defaultValue = _a.default,
+        type = _a.type,
+        properties = _a.properties,
+        patternProperties = _a.patternProperties,
+        remainingSchemaEntry = __rest(_a, ["title", "description", "readOnly", "writeOnly", "examples", "default", "type", "properties", "patternProperties"]);
+
+    var annotations = Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, title !== undefined && {
+      title: title
+    }), description !== undefined && {
+      description: description
+    }), readOnly !== undefined && {
+      readOnly: readOnly
+    }), writeOnly !== undefined && {
+      writeOnly: writeOnly
+    }), examples !== undefined && {
+      examples: examples
+    }), defaultValue !== undefined && {
+      default: defaultValue
+    });
+
+    if (type === 'object') {
+      enhancedOptionsSchema[key] = Object.assign(Object.assign(Object.assign(Object.assign({}, remainingSchemaEntry), annotations), {
+        type: type
+      }), properties && {
+        properties: enhanceOptionsSchemaWithDynamicOptions(properties)
+      });
+
+      if (patternProperties) {
+        var enhancedPatternProperties = {};
+        Object.keys(patternProperties).forEach(function (opt) {
+          enhancedPatternProperties = Object.assign(Object.assign({}, enhancedPatternProperties), enhanceOptionsSchemaWithDynamicOptions(_defineProperty({}, opt, patternProperties[opt])));
+        });
+        enhancedOptionsSchema[key].patternProperties = enhancedPatternProperties;
+      }
+    } else {
+      enhancedOptionsSchema[key] = Object.assign(Object.assign({}, annotations), {
+        anyOf: [Object.assign(Object.assign({}, type !== undefined && {
+          type: type
+        }), remainingSchemaEntry), dynamicOptionsDSLType]
+      });
+    }
+  });
+  return enhancedOptionsSchema;
+}
+
+exports.enhanceOptionsSchemaWithDynamicOptions = enhanceOptionsSchemaWithDynamicOptions;
+/**
+ * Helper function to enhance a Visualization Config as needed based on behaviors specified in supports block
+ * @param vizConfig a Visualization Config
+ * @returns an enhanced Visualization Config containing updated config entries based on behaviors it supports
+ */
+
+function enhanceConfig(vizConfig) {
+  var enhancedConfig = vizConfig;
+
+  if (vizConfig.supports.indexOf(VizBehavior_1.VizBehavior.DYNAMIC_OPTIONS) !== -1) {
+    enhancedConfig.optionsSchema = enhanceOptionsSchemaWithDynamicOptions(vizConfig.optionsSchema);
+  }
+
+  return enhancedConfig;
+}
+
+exports.enhanceConfig = enhanceConfig;
+
+function isDynamicOption(option) {
+  return option && typeof option === 'string' && option.trim().startsWith('>') || false;
+}
+
+exports.isDynamicOption = isDynamicOption; // private helpers to improve readability of getInitialPreset
+// this shouldn't be tested since this util isn't something that we expect to use outside of getInitialPreset
+
+/**
+ * this checks to make sure that all values within vizContext are compatible with the given preset's context to determine the initialPreset
+ * if a preset has explicitly specified a key as being undefined, the vizContext must also has that key as undefined, or else this CANNOT be the initialPreset
+ * the inverse is true; if a preset has key is NOT undefined, it must also be NOT undefined in the corresponding vizContext
+ * the internal config contents are irrelevant (as the user could customize them in source), just as long as the presence of `undefined`s match up
+ *
+ * Since the presetConfigs have explicit undefined keys to override the existing config, we need to explicitly check the undefined values
+ */
+
+function hasCompatibleContexts(vizContext, presetContext) {
+  var presetContextKeys = Object.keys(presetContext);
+  return presetContextKeys.every(function (contextKey) {
+    return presetContext[contextKey] === undefined && vizContext[contextKey] === undefined || presetContext[contextKey] !== undefined && vizContext[contextKey] !== undefined;
+  });
+}
+/**
+ * Checks to make sure that dynamic (non-dynamic) options in a given preset are also dynamic (non-dynamic) in the vizOptions
+ */
+
+
+function hasCompatibleOptions(vizOptions, presetOptions) {
+  var presetOptionKeys = Object.keys(presetOptions);
+  return presetOptionKeys.every(function (optionKey) {
+    return isDynamicOption(presetOptions[optionKey]) === isDynamicOption(vizOptions[optionKey]);
+  });
+}
+/**
+ * Evaluates whether there is an initialPreset that fits the current state of vizContext + vizOptions
+ * This function ignores extraneous vizOptions or vizContext keys, as they could be outside the scope of what the preset is intended to configure
+ *
+ * @param {Object} vizContext - the current vizContext definition
+ * @param {Object} vizOptions - the current vizOptions definition
+ * @param {PresetEntry[]} presets - the list of presets, one of which can be considered an initialPreset
+ */
+
+
+function getInitialPreset(vizContext, vizOptions, presets) {
+  return presets.find(function (preset) {
+    var presetContext = lodash_1.get(preset, ['value', 'context'], {});
+    var presetOptions = lodash_1.get(preset, ['value', 'options'], {});
+    var presetContextKeys = Object.keys(presetContext);
+    var presetOptionKeys = Object.keys(presetOptions); // all presets have to explicitly specify which options to reset (i.e. need explicitly undefined keys)
+    // if not, then the preset is invalid in config.ts
+
+    if (presetContextKeys.length === 0 || presetOptionKeys.length === 0) return false;
+    return hasCompatibleContexts(vizContext, presetContext) && hasCompatibleOptions(vizOptions, presetOptions);
+  });
+}
+
+exports.getInitialPreset = getInitialPreset;
+/**
+ * generates number precision values for a Select editor
+ *
+ * @param {Number} numPrecisionValues - number of integer precision values to generate
+ * @returns {{ label: string; value; string  }[]} array of { label, value } tuples
+ */
+
+function generatePrecisionValues(numPrecisionValues) {
+  return lodash_1.range(0, numPrecisionValues + 1).map(function (i) {
+    return {
+      label: "".concat(i, " (0").concat(i > 0 ? '.' : '').concat('0'.repeat(i), ")"),
+      value: i
+    };
+  });
+}
+
+exports.generatePrecisionValues = generatePrecisionValues;
+
+/***/ }),
+
+/***/ 10:
+/***/ (function(module, exports) {
+
+module.exports = require("@splunk/visualization-color-palettes");
+
+/***/ }),
+
+/***/ 17:
+/***/ (function(module, exports) {
+
+module.exports = require("@splunk/themes");
+
+/***/ }),
+
+/***/ 2:
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.VizBehavior = void 0;
+var VizBehavior;
+
+(function (VizBehavior) {
+  /**
+   * Dynamic Options Behavior.
+   * This allows visualization options to be powered by data
+   *
+   * **Example**
+   *
+   * sparklineValues: ">primary|seriesByIndex(0)"
+   * would configure sparklineValues with an array of data points
+   * coming from the first series in the primary datasource
+   *
+   */
+  VizBehavior["DYNAMIC_OPTIONS"] = "dynamic-options";
+  VizBehavior["EVENTS"] = "events";
+  /**
+   * Placeholder behavior: visualization will display a placeholder rather than fail if any of the `requiredProps` is
+   * missing.
+   * @type {string}
+   */
+
+  VizBehavior["PLACEHOLDER"] = "placeholder";
+  VizBehavior["PAGE_AND_SORT"] = "page-and-sort";
+})(VizBehavior = exports.VizBehavior || (exports.VizBehavior = {}));
+
+/***/ }),
+
+/***/ 3:
+/***/ (function(module, exports) {
+
+module.exports = require("@splunk/visualizations-shared/schemaUtils");
+
+/***/ }),
+
+/***/ 4:
+/***/ (function(module, exports) {
+
+module.exports = require("lodash");
+
+/***/ }),
+
+/***/ 5:
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.VizCategory = void 0;
+var VizCategory;
+
+(function (VizCategory) {
+  VizCategory["SINGLE_VALUE"] = "Single Value";
+  VizCategory["TRENDS"] = "Trends";
+  VizCategory["COMPARISONS"] = "Comparisons";
+  VizCategory["TABLE"] = "Table";
+  VizCategory["GAUGE"] = "Gauge";
+  VizCategory["DISTRIBUTIONS"] = "Distributions";
+  VizCategory["CHOROPLETH"] = "Choropleth Maps";
+  VizCategory["SHAPES"] = "Shapes";
+  VizCategory["MISC"] = "misc";
+  VizCategory["FLOW"] = "Flow";
+  VizCategory["CORRELATION"] = "Correlation";
+  VizCategory["SPATIAL"] = "Spatial";
+})(VizCategory = exports.VizCategory || (exports.VizCategory = {}));
+
+/***/ }),
+
+/***/ 50:
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var visualization_icons_1 = __webpack_require__(9);
+
+var schemaUtils_1 = __webpack_require__(3);
+
+var visualization_color_palettes_1 = __webpack_require__(10);
+
+var themes_1 = __webpack_require__(17);
+
+var i18n_1 = __webpack_require__(0);
+
+var VizBehavior_1 = __webpack_require__(2);
+
+var VizCategory_1 = __webpack_require__(5);
+
+var configUtils_1 = __webpack_require__(1);
+
+var defaultContext = {
+  colorRangeConfig: [{
+    to: 20,
+    value: '#D41F1F'
+  }, {
+    from: 20,
+    to: 40,
+    value: '#D94E17'
+  }, {
+    from: 40,
+    to: 60,
+    value: '#CBA700'
+  }, {
+    from: 60,
+    to: 80,
+    value: '#669922'
+  }, {
+    from: 80,
+    value: '#118832'
+  }]
+};
+var dataContract = {
+  requiredDataSources: [],
+  optionalDataSources: [{
+    name: 'primary',
+    description: 'DataSource that powers the visualization.'
+  }],
+  initialRequestParams: {
+    primary: {
+      offset: 0,
+      count: 10000
+    }
+  }
+};
+var size = {
+  initialWidth: 800,
+  initialHeight: 600
+};
+var optionsSchema = {
+  backgroundColor: {
+    default: '> themes.defaultBackgroundColor',
+    description: 'Specify the color for the background. You may use a dataSource to apply the color. The default for enterprise light is "#ffffff". The default for enterprise dark is "#000000". The default for prisma dark is "#0b0c0e".',
+    pattern: schemaUtils_1.COLOR_OR_TOKEN_PATTERN_WITH_RGBA,
+    type: 'string'
+  },
+  center: {
+    default: [37.7749, -122.4194],
+    type: 'array',
+    description: 'Specify the center of the map in coordinates, in the form of [latitude, longitude]. When not provided, will automatically calculate map center based on available location data. When no location data available will fall back to [37.7749, -122.4194].',
+    items: {
+      type: 'number'
+    }
+  },
+  layers: {
+    default: [{
+      type: 'bubble',
+      latitude: '> primary | seriesByName("latitude")',
+      longitude: '> primary | seriesByName("longitude")',
+      seriesColors: visualization_color_palettes_1.VIZ_CATEGORICAL,
+      bubbleSize: '> primary | frameWithoutSeriesNames("geobin", "latitude", "longitude") | frameBySeriesTypes("number")',
+      tooltipFields: []
+    }],
+    type: 'array',
+    description: 'Specify the data visualization layers on top of the base map. Can be empty to only show the base map.',
+    items: {
+      anyOf: [{
+        type: 'object',
+        properties: {
+          type: {
+            description: 'Specify the type of data layer method to display points on the map. For example, “bubble” or “marker”.',
+            type: 'string',
+            pattern: schemaUtils_1.getPattern(['marker']),
+            default: 'marker'
+          },
+          latitude: {
+            description: 'Specify a dataSource series to apply latitude coordinates for data points displayed on the map.',
+            type: ['string', 'array'],
+            default: '> primary | seriesByName("latitude")'
+          },
+          longitude: {
+            description: 'Specify a dataSource series to apply longitude coordinates for data points displayed on the map.',
+            type: ['string', 'array'],
+            default: '> primary | seriesByName("longitude")'
+          },
+          dataColors: {
+            description: 'Specify the colors used for data points. You may use an array of colors to be picked from, or you may use a dataSource to apply dynamic coloring. For example, “> primary | seriesByName("status") | matchValue(colorMatchConfig)”. ',
+            type: ['string', 'array']
+          },
+          seriesColors: {
+            default: visualization_color_palettes_1.VIZ_CATEGORICAL,
+            description: 'Specify the colors used for data points.',
+            type: 'array',
+            items: {
+              type: 'string',
+              pattern: schemaUtils_1.COLOR_OR_TOKEN_PATTERN_WITH_RGBA
+            }
+          },
+          tooltipFields: {
+            description: 'Specify the fields to add to tooltips shown while hovering over data points. These fields and their corresponding values will be shown in addition to the ones displayed by default.',
+            type: 'array',
+            items: {
+              type: 'string'
+            },
+            default: []
+          },
+          resultLimit: {
+            description: 'Specify the maximum number of data points rendered on the map to improve performance.',
+            type: 'number',
+            default: 1000
+          }
+        }
+      }, {
+        type: 'object',
+        properties: {
+          type: {
+            description: 'Specify the type of data layer method to display points on the map. For example, “bubble” or “marker”.',
+            type: 'string',
+            pattern: schemaUtils_1.getPattern(['bubble']),
+            default: 'bubble'
+          },
+          bubbleSize: {
+            description: 'Specify the data column to encode bubble size',
+            type: ['string', 'array'],
+            default: '> primary | frameWithoutSeriesNames("geobin", "latitude", "longitude") | frameBySeriesTypes("number")'
+          },
+          latitude: {
+            description: 'Specify a dataSource series to apply latitude coordinates for data points displayed on the map.',
+            type: ['string', 'array'],
+            items: {
+              type: 'number'
+            },
+            default: '> primary | seriesByName("latitude")'
+          },
+          longitude: {
+            description: 'Specify a dataSource series to apply longitude coordinates for data points displayed on the map.',
+            type: ['string', 'array'],
+            items: {
+              type: 'number'
+            },
+            default: '> primary | seriesByName("longitude")'
+          },
+          dataColors: {
+            description: 'Specify the colors used for data points. You may use an array of colors to be picked from, or you may use a dataSource to apply dynamic coloring. For example, “> primary | seriesByName("status") | matchValue(colorMatchConfig)”. ',
+            type: ['string', 'array']
+          },
+          seriesColors: {
+            default: visualization_color_palettes_1.VIZ_CATEGORICAL,
+            description: "Specify the colors used for data points. For example, [\"#FF0000\", \"#0000FF\", \"#008000\"].",
+            type: 'array',
+            items: {
+              type: 'string',
+              pattern: schemaUtils_1.COLOR_OR_TOKEN_PATTERN_WITH_RGBA
+            }
+          },
+          tooltipFields: {
+            description: 'Specify the fields to add to tooltips shown while hovering over data points. These fields and their corresponding values will be shown in addition to the ones displayed by default.',
+            type: 'array',
+            items: {
+              type: 'string'
+            },
+            default: []
+          },
+          resultLimit: {
+            description: 'Specify the maximum number of data points rendered on the map to improve performance.',
+            type: 'number',
+            default: 1000
+          }
+        }
+      }]
+    }
+  },
+  scaleUnit: {
+    default: 'metric',
+    type: 'string',
+    description: 'Specify which scale unit to use.',
+    pattern: schemaUtils_1.getPattern(['metric', 'imperial'])
+  },
+  // TODO: choropleth map retain old design
+  // showBaseLayer: {
+  //     default: true,
+  //     type: 'boolean',
+  //     description: 'Specify if showing the base map.',
+  // },
+  showScale: {
+    default: true,
+    type: 'boolean',
+    description: 'Specify whether the scale on the bottom left is shown.'
+  },
+  baseLayerTileServer: {
+    type: 'string',
+    description: 'Specify the tile set URL for the base map.'
+  },
+  baseLayerTileServerType: {
+    type: 'string',
+    description: 'Specify the type of tile set for the base map.',
+    pattern: schemaUtils_1.getPattern(['vector', 'raster'])
+  },
+  zoom: {
+    default: 5,
+    description: 'Specify the zoom level of the map.',
+    type: 'number'
+  }
+};
+var themes = {
+  defaultBackgroundColor: function defaultBackgroundColor(props) {
+    return themes_1.pick({
+      enterprise: {
+        dark: themes_1.variables.black(props),
+        light: themes_1.variables.backgroundColor(props)
+      },
+      prisma: themes_1.variables.backgroundColorSidebar(props)
+    })(props);
+  },
+  controlBackgroundColor: function controlBackgroundColor(props) {
+    return themes_1.pick({
+      enterprise: {
+        dark: themes_1.variables.gray22(props),
+        light: themes_1.variables.white(props)
+      },
+      prisma: themes_1.variables.backgroundColorPopup(props)
+    })(props);
+  },
+  controlForegroundColor: function controlForegroundColor(props) {
+    return themes_1.pick({
+      enterprise: themes_1.variables.textColor(props),
+      prisma: themes_1.variables.contentColorDefault(props)
+    })(props);
+  }
+};
+var editorConfig = [{
+  label: i18n_1._('Data Layer Formatting'),
+  layout: [[{
+    label: i18n_1._('Layer Type'),
+    option: 'layers[0].type',
+    editor: 'editor.select',
+    editorProps: {
+      values: [{
+        label: i18n_1._('Marker'),
+        value: 'marker'
+      }, {
+        label: i18n_1._('Bubble'),
+        value: 'bubble'
+      }]
+    }
+  }], [{
+    label: i18n_1._('Latitude'),
+    option: 'layers[0].latitude',
+    editor: 'editor.columnSelector',
+    editorProps: {
+      dataSourceKey: 'primary'
+    }
+  }], [{
+    label: i18n_1._('Longitude'),
+    option: 'layers[0].longitude',
+    editor: 'editor.columnSelector',
+    editorProps: {
+      dataSourceKey: 'primary'
+    }
+  }], [{
+    label: i18n_1._('Size'),
+    option: 'layers[0].bubbleSize',
+    editor: 'editor.columnSelector',
+    showEditor: function showEditor(_ref) {
+      var options = _ref.options;
+      return options.layers && options.layers.length && options.layers[0].type === 'bubble';
+    },
+    editorProps: {
+      dataSourceKey: 'primary'
+    }
+  }]]
+}];
+/**
+ * visualization configuration
+ */
+
+var config = {
+  /**
+   * unique viz key
+   */
+  key: 'splunk.map',
+
+  /**
+   * viz name
+   */
+  name: 'Map',
+  category: VizCategory_1.VizCategory.CHOROPLETH,
+  status: 'preview',
+
+  /**
+   * viz icon
+   */
+  icon: visualization_icons_1.Map,
+  dataContract: dataContract,
+  size: size,
+  defaultContext: defaultContext,
+  optionsSchema: optionsSchema,
+  editorConfig: editorConfig,
+  events: {
+    'map.load': {
+      description: 'triggered when map is fully loaded'
+    }
+  },
+  supports: [VizBehavior_1.VizBehavior.DYNAMIC_OPTIONS, VizBehavior_1.VizBehavior.EVENTS, VizBehavior_1.VizBehavior.PLACEHOLDER],
+  themes: themes,
+  requiredProps: []
+};
+exports.default = configUtils_1.enhanceConfig(config);
+
+/***/ }),
+
+/***/ 6:
+/***/ (function(module, exports) {
+
+module.exports = require("@babel/runtime/helpers/defineProperty");
+
+/***/ }),
+
+/***/ 9:
+/***/ (function(module, exports) {
+
+module.exports = require("@splunk/visualization-icons");
+
+/***/ })
+
+/******/ });
+//# sourceMappingURL=Map.config.js.map