@splunk/visualizations 27.1.0 → 27.2.0

package/Timeline.js

@@ -0,0 +1,3074 @@
+/* Copyright © 2020 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. */
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/Timeline/index.ts
+var Timeline_exports = {};
+__export(Timeline_exports, {
+  computeVizProps: () => computeVizProps,
+  config: () => config2,
+  default: () => Timeline_default,
+  themes: () => themes2
+});
+module.exports = __toCommonJS(Timeline_exports);
+
+// esm-externals:lodash
+var lodash_exports = {};
+__export(lodash_exports, {
+  default: () => lodash_default
+});
+var defaultImport = __toESM(require("lodash"));
+__reExport(lodash_exports, require("lodash"));
+var lodash_default = "default" in defaultImport ? defaultImport.default : defaultImport;
+
+// esm-externals:@splunk/visualization-schemas
+var visualization_schemas_exports = {};
+__export(visualization_schemas_exports, {
+  default: () => visualization_schemas_default
+});
+var defaultImport2 = __toESM(require("@splunk/visualization-schemas"));
+__reExport(visualization_schemas_exports, require("@splunk/visualization-schemas"));
+var visualization_schemas_default = "default" in defaultImport2 ? defaultImport2.default : defaultImport2;
+
+// esm-externals:@splunk/visualization-color-palettes
+var visualization_color_palettes_exports = {};
+__export(visualization_color_palettes_exports, {
+  default: () => visualization_color_palettes_default
+});
+var defaultImport3 = __toESM(require("@splunk/visualization-color-palettes"));
+__reExport(visualization_color_palettes_exports, require("@splunk/visualization-color-palettes"));
+var visualization_color_palettes_default = "default" in defaultImport3 ? defaultImport3.default : defaultImport3;
+
+// esm-externals:@splunk/visualizations-shared/colorUtils
+var colorUtils_exports = {};
+__export(colorUtils_exports, {
+  default: () => colorUtils_default
+});
+var defaultImport4 = __toESM(require("@splunk/visualizations-shared/colorUtils"));
+__reExport(colorUtils_exports, require("@splunk/visualizations-shared/colorUtils"));
+var colorUtils_default = "default" in defaultImport4 ? defaultImport4.default : defaultImport4;
+
+// esm-externals:@splunk/visualization-icons
+var visualization_icons_exports = {};
+__export(visualization_icons_exports, {
+  default: () => visualization_icons_default
+});
+var defaultImport5 = __toESM(require("@splunk/visualization-icons"));
+__reExport(visualization_icons_exports, require("@splunk/visualization-icons"));
+var visualization_icons_default = "default" in defaultImport5 ? defaultImport5.default : defaultImport5;
+
+// esm-externals:@splunk/visualization-color-palettes/editors/PresetPalettes
+var PresetPalettes_exports = {};
+__export(PresetPalettes_exports, {
+  default: () => PresetPalettes_default
+});
+var defaultImport6 = __toESM(require("@splunk/visualization-color-palettes/editors/PresetPalettes"));
+__reExport(PresetPalettes_exports, require("@splunk/visualization-color-palettes/editors/PresetPalettes"));
+var PresetPalettes_default = "default" in defaultImport6 ? defaultImport6.default : defaultImport6;
+
+// esm-externals:@splunk/ui-utils/i18n
+var i18n_exports = {};
+__export(i18n_exports, {
+  default: () => i18n_default
+});
+var defaultImport7 = __toESM(require("@splunk/ui-utils/i18n"));
+__reExport(i18n_exports, require("@splunk/ui-utils/i18n"));
+var i18n_default = "default" in defaultImport7 ? defaultImport7.default : defaultImport7;
+
+// esm-externals:@splunk/themes/pick
+var pick_exports = {};
+__export(pick_exports, {
+  default: () => pick_default
+});
+var defaultImport8 = __toESM(require("@splunk/themes/pick"));
+__reExport(pick_exports, require("@splunk/themes/pick"));
+var pick_default = "default" in defaultImport8 ? defaultImport8.default : defaultImport8;
+
+// esm-externals:@splunk/themes/variables
+var variables_exports = {};
+__export(variables_exports, {
+  default: () => variables_default
+});
+var defaultImport9 = __toESM(require("@splunk/themes/variables"));
+__reExport(variables_exports, require("@splunk/themes/variables"));
+var variables_default = "default" in defaultImport9 ? defaultImport9.default : defaultImport9;
+
+// esm-externals:@splunk/visualizations-shared/configUtils
+var configUtils_exports = {};
+__export(configUtils_exports, {
+  default: () => configUtils_default
+});
+var defaultImport10 = __toESM(require("@splunk/visualizations-shared/configUtils"));
+__reExport(configUtils_exports, require("@splunk/visualizations-shared/configUtils"));
+var configUtils_default = "default" in defaultImport10 ? defaultImport10.default : defaultImport10;
+
+// src/common/utils/configUtils.ts
+function enhanceConfig(vizConfig) {
+  const enhancedConfig = __spreadValues({}, vizConfig);
+  enhancedConfig.editorConfig = vizConfig.editorConfig.map(
+    (config3) => {
+      return __spreadProps(__spreadValues({}, config3), { open: config3.open || false });
+    }
+  );
+  return enhancedConfig;
+}
+
+// src/common/editorConfig/BackgroundColor.ts
+var background = ({
+  label,
+  themes: themes3,
+  labelPosition
+}) => [
+  {
+    label: (0, i18n_exports._)(label || "Background color"),
+    option: "backgroundColor",
+    editor: "editor.color",
+    editorProps: {
+      labelPosition: labelPosition || "top",
+      themes: themes3
+    }
+  }
+];
+var BackgroundColor_default = background;
+
+// src/Timeline/config.ts
+var dataContract = {
+  requiredDataSources: [],
+  optionalDataSources: [
+    {
+      name: "primary",
+      description: "DataSource that powers the visualization."
+    }
+  ],
+  initialRequestParams: {
+    primary: { offset: 0, count: 1e4 }
+  }
+};
+var size = {
+  initialWidth: 300,
+  initialHeight: 300
+};
+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" }
+  ],
+  colorMatchConfig: [{ match: "", value: "#5C33FF" }]
+};
+var themes = {
+  defaultBackgroundColor: (props) => pick_default({
+    enterprise: {
+      dark: variables_default.black(props),
+      light: variables_default.backgroundColor(props)
+    },
+    prisma: variables_default.backgroundColorSidebar(props)
+  })(props)
+};
+var editorConfig = [
+  {
+    label: (0, i18n_exports._)("Data configurations"),
+    layout: [
+      [
+        {
+          label: (0, i18n_exports._)("X"),
+          option: "x",
+          editor: "editor.columnSelector",
+          editorProps: {
+            dataSourceKey: "primary",
+            shouldShowInternalFields: false,
+            filterByTypes: ["time"]
+          }
+        }
+      ],
+      [
+        {
+          label: (0, i18n_exports._)("Y"),
+          option: "y",
+          editor: "editor.columnSelector",
+          editorProps: {
+            dataSourceKey: "primary",
+            shouldShowInternalFields: false,
+            filterByTypes: ["string", "number"]
+          }
+        }
+      ],
+      [
+        {
+          label: (0, i18n_exports._)("Duration"),
+          option: "duration",
+          editor: "editor.columnSelector",
+          editorProps: {
+            dataSourceKey: "primary",
+            shouldShowInternalFields: false,
+            filterByTypes: ["number"]
+          }
+        }
+      ],
+      [
+        {
+          label: (0, i18n_exports._)("Category"),
+          option: "category",
+          editor: "editor.columnSelector",
+          editorProps: {
+            dataSourceKey: "primary",
+            shouldShowInternalFields: false,
+            filterByTypes: ["string", "number"]
+          }
+        }
+      ],
+      [
+        {
+          label: (0, i18n_exports._)("Additional tooltip fields"),
+          option: "additionalTooltipFields",
+          editor: "editor.columnMultiSelectionByFieldNameEditor"
+        }
+      ],
+      [
+        {
+          label: (0, i18n_exports._)("Result limit"),
+          option: "resultLimit",
+          editor: "editor.number"
+        }
+      ]
+    ]
+  },
+  {
+    label: (0, i18n_exports._)("Data display"),
+    layout: [
+      [
+        {
+          label: (0, i18n_exports._)("Lane label width"),
+          option: "yAxisLabelWidth",
+          editor: "editor.number",
+          editorProps: {
+            min: 0
+          }
+        }
+      ]
+    ]
+  },
+  {
+    label: (0, i18n_exports._)("Color and style"),
+    layout: [
+      [
+        {
+          label: (0, i18n_exports._)("Data colors"),
+          option: "dataColors",
+          context: {
+            colorRangeConfig: "colorRangeConfig",
+            colorMatchConfig: "colorMatchConfig"
+          },
+          editor: "editor.dynamicColorWithPrecedence",
+          editorProps: {
+            labelPosition: "top",
+            flyoutTitle: (0, i18n_exports._)("Dynamic coloring: value"),
+            formatters: [
+              {
+                label: (0, i18n_exports._)("Ranges"),
+                value: "rangeValue",
+                isDefault: true,
+                defaults: {
+                  duration: defaultContext.colorRangeConfig
+                }
+              },
+              {
+                label: (0, i18n_exports._)("Matches"),
+                value: "matchValue",
+                defaults: {
+                  duration: defaultContext.colorMatchConfig
+                }
+              }
+            ],
+            dataSelectors: [
+              {
+                label: (0, i18n_exports._)("Data values"),
+                value: "duration"
+              }
+            ],
+            defaultPalettesConfig: PresetPalettes_exports.defaultPalettesConfig
+          }
+        }
+      ],
+      [
+        {
+          label: (0, i18n_exports._)("Data values"),
+          editor: "editor.columnSelector",
+          option: "duration",
+          showEditor: ({ options }) => options.dataColors,
+          editorProps: {
+            dataSourceKey: "primary",
+            filterByTypes: ["number"]
+          }
+        }
+      ],
+      [
+        {
+          label: (0, i18n_exports._)("Series colors"),
+          option: "seriesColors",
+          editor: "editor.seriesColors",
+          showEditor: ({ options }) => !options.dataColors
+        }
+      ],
+      BackgroundColor_default({ themes })
+    ]
+  },
+  {
+    label: (0, i18n_exports._)("Legend"),
+    layout: [
+      [
+        {
+          label: (0, i18n_exports._)("Legend display"),
+          option: "legendDisplay",
+          editor: "editor.select",
+          editorProps: {
+            values: [
+              { label: (0, i18n_exports._)("Right"), value: "right" },
+              { label: (0, i18n_exports._)("Bottom"), value: "bottom" },
+              { label: (0, i18n_exports._)("Off"), value: "off" }
+            ]
+          },
+          // disable legend if dataColors is on
+          isDisabled: ({ options }) => options.dataColors
+        }
+      ],
+      [
+        {
+          label: (0, i18n_exports._)("Truncation"),
+          option: "legendTruncation",
+          editor: "editor.radioBar",
+          default: "ellipsisOff",
+          editorProps: {
+            values: [
+              { label: (0, i18n_exports._)("A..."), value: "ellipsisEnd" },
+              { label: (0, i18n_exports._)("A...Z"), value: "ellipsisMiddle" },
+              { label: (0, i18n_exports._)("...Z"), value: "ellipsisStart" },
+              { label: (0, i18n_exports._)("Off"), value: "ellipsisOff" }
+            ]
+          },
+          isDisabled: ({ options }) => options.dataColors,
+          showEditor: ({ options }) => options.legendDisplay && options.legendDisplay !== "off"
+        }
+      ]
+    ]
+  }
+];
+var config = {
+  /**
+   * unique viz key
+   */
+  key: "splunk.timeline",
+  /**
+   * viz name
+   */
+  name: (0, i18n_exports._)("Timeline"),
+  category: "Timeline" /* TIMELINE */,
+  status: "preview",
+  /**
+   * viz icon
+   */
+  icon: visualization_icons_exports.Timeline,
+  // placeholderIcon: TimelinePlaceholderIcon, TBD
+  dataContract,
+  size,
+  defaultContext,
+  optionsSchema: visualization_schemas_exports.timelineOptionsSchema,
+  editorConfig,
+  events: {
+    "event.click": {
+      description: "triggered when user clicks on an event"
+    },
+    "lane.click": {
+      description: "triggered when user clicks on a lane label"
+    },
+    "legend.click": {
+      description: "triggered when user clicks on chart legend"
+    }
+  },
+  supports: ["dynamic-options" /* DYNAMIC_OPTIONS */, "placeholder" /* PLACEHOLDER */, "events" /* EVENTS */],
+  themes
+};
+var config_default = enhanceConfig(config);
+
+// esm-externals:react
+var react_exports = {};
+__export(react_exports, {
+  default: () => react_default
+});
+var defaultImport11 = __toESM(require("react"));
+__reExport(react_exports, require("react"));
+var react_default = "default" in defaultImport11 ? defaultImport11.default : defaultImport11;
+
+// esm-externals:@splunk/themes/getSettingsFromThemedProps
+var getSettingsFromThemedProps_exports = {};
+__export(getSettingsFromThemedProps_exports, {
+  default: () => getSettingsFromThemedProps_default
+});
+var defaultImport12 = __toESM(require("@splunk/themes/getSettingsFromThemedProps"));
+__reExport(getSettingsFromThemedProps_exports, require("@splunk/themes/getSettingsFromThemedProps"));
+var getSettingsFromThemedProps_default = "default" in defaultImport12 ? defaultImport12.default : defaultImport12;
+
+// esm-externals:@splunk/visualization-encoding/Options
+var Options_exports = {};
+__export(Options_exports, {
+  default: () => Options_default
+});
+var defaultImport13 = __toESM(require("@splunk/visualization-encoding/Options"));
+__reExport(Options_exports, require("@splunk/visualization-encoding/Options"));
+var Options_default = "default" in defaultImport13 ? defaultImport13.default : defaultImport13;
+
+// esm-externals:@splunk/visualizations-shared/SanitizeProps
+var SanitizeProps_exports = {};
+__export(SanitizeProps_exports, {
+  default: () => SanitizeProps_default
+});
+var defaultImport14 = __toESM(require("@splunk/visualizations-shared/SanitizeProps"));
+__reExport(SanitizeProps_exports, require("@splunk/visualizations-shared/SanitizeProps"));
+var SanitizeProps_default = "default" in defaultImport14 ? defaultImport14.default : defaultImport14;
+
+// esm-externals:@splunk/visualization-context/TimezoneContext
+var TimezoneContext_exports = {};
+__export(TimezoneContext_exports, {
+  default: () => TimezoneContext_default
+});
+var defaultImport15 = __toESM(require("@splunk/visualization-context/TimezoneContext"));
+__reExport(TimezoneContext_exports, require("@splunk/visualization-context/TimezoneContext"));
+var TimezoneContext_default = "default" in defaultImport15 ? defaultImport15.default : defaultImport15;
+
+// esm-externals:@splunk/moment
+var moment_exports = {};
+__export(moment_exports, {
+  default: () => moment_default
+});
+var defaultImport16 = __toESM(require("@splunk/moment"));
+__reExport(moment_exports, require("@splunk/moment"));
+var moment_default = "default" in defaultImport16 ? defaultImport16.default : defaultImport16;
+
+// esm-externals:@splunk/visualization-context/FeatureFlagContext
+var FeatureFlagContext_exports = {};
+__export(FeatureFlagContext_exports, {
+  default: () => FeatureFlagContext_default
+});
+var defaultImport17 = __toESM(require("@splunk/visualization-context/FeatureFlagContext"));
+__reExport(FeatureFlagContext_exports, require("@splunk/visualization-context/FeatureFlagContext"));
+var FeatureFlagContext_default = "default" in defaultImport17 ? defaultImport17.default : defaultImport17;
+
+// esm-externals:styled-components
+var styled_components_exports = {};
+__export(styled_components_exports, {
+  default: () => styled_components_default
+});
+var defaultImport18 = __toESM(require("styled-components"));
+__reExport(styled_components_exports, require("styled-components"));
+var styled_components_default = "default" in defaultImport18 ? defaultImport18.default : defaultImport18;
+
+// esm-externals:@splunk/visualizations-shared/hocUtils
+var hocUtils_exports = {};
+__export(hocUtils_exports, {
+  default: () => hocUtils_default
+});
+var defaultImport19 = __toESM(require("@splunk/visualizations-shared/hocUtils"));
+__reExport(hocUtils_exports, require("@splunk/visualizations-shared/hocUtils"));
+var hocUtils_default = "default" in defaultImport19 ? defaultImport19.default : defaultImport19;
+
+// esm-externals:@splunk/visualizations-shared/JSONSchemaUtils
+var JSONSchemaUtils_exports = {};
+__export(JSONSchemaUtils_exports, {
+  default: () => JSONSchemaUtils_default
+});
+var defaultImport20 = __toESM(require("@splunk/visualizations-shared/JSONSchemaUtils"));
+__reExport(JSONSchemaUtils_exports, require("@splunk/visualizations-shared/JSONSchemaUtils"));
+var JSONSchemaUtils_default = "default" in defaultImport20 ? defaultImport20.default : defaultImport20;
+
+// esm-externals:@splunk/async-dynamic-options-evaluator
+var async_dynamic_options_evaluator_exports = {};
+__export(async_dynamic_options_evaluator_exports, {
+  default: () => async_dynamic_options_evaluator_default
+});
+var defaultImport21 = __toESM(require("@splunk/async-dynamic-options-evaluator"));
+__reExport(async_dynamic_options_evaluator_exports, require("@splunk/async-dynamic-options-evaluator"));
+var async_dynamic_options_evaluator_default = "default" in defaultImport21 ? defaultImport21.default : defaultImport21;
+
+// esm-externals:@splunk/ui-utils/id
+var id_exports = {};
+__export(id_exports, {
+  default: () => id_default
+});
+var defaultImport22 = __toESM(require("@splunk/ui-utils/id"));
+__reExport(id_exports, require("@splunk/ui-utils/id"));
+var id_default = "default" in defaultImport22 ? defaultImport22.default : defaultImport22;
+
+// esm-externals:prop-types
+var prop_types_exports = {};
+__export(prop_types_exports, {
+  default: () => prop_types_default
+});
+var defaultImport23 = __toESM(require("prop-types"));
+__reExport(prop_types_exports, require("prop-types"));
+var prop_types_default = "default" in defaultImport23 ? defaultImport23.default : defaultImport23;
+
+// src/common/interfaces/VizActionHandler.ts
+var DefaultVizActionHandler = class {
+  focus() {
+  }
+  snapshot() {
+    return null;
+  }
+};
+
+// src/common/SplunkVisualization.tsx
+var INITIAL_HEIGHT = 250;
+var SplunkVisualization = class {
+};
+SplunkVisualization.propTypes = {
+  /**
+   * display mode
+   */
+  mode: prop_types_exports.oneOf(["view", "edit", "export"]).isRequired,
+  /**
+   * width in pixel or string, defaults to 100%
+   */
+  width: prop_types_exports.oneOfType([prop_types_exports.string, prop_types_exports.number]).isRequired,
+  /**
+   * height in pixel or string
+   */
+  height: prop_types_exports.oneOfType([prop_types_exports.string, prop_types_exports.number]).isRequired,
+  /**
+   * visualization context used for dynamic option evaluation
+   */
+  context: prop_types_exports.object,
+  /**
+   * visualization formatting options
+   */
+  options: prop_types_exports.object,
+  /**
+   * A callback to update formatting options
+   */
+  onOptionsChange: prop_types_exports.func,
+  /**
+   * datasource state which include data and request params, object key indicate the datasource type.
+   */
+  dataSources: prop_types_exports.objectOf(
+    prop_types_exports.shape({
+      /**
+       * current request params
+       */
+      requestParams: prop_types_exports.object,
+      /**
+       * current dataset
+       */
+      data: prop_types_exports.shape({
+        fields: prop_types_exports.array,
+        columns: prop_types_exports.array
+      }),
+      /**
+       * error
+       */
+      error: prop_types_exports.shape({
+        level: prop_types_exports.string,
+        message: prop_types_exports.string
+      }),
+      /**
+       * meta data that came with the dataset
+       */
+      meta: prop_types_exports.object
+    })
+  ),
+  /**
+   * A callback to trigger event
+   */
+  onEventTrigger: prop_types_exports.func,
+  /**
+   * Inform viz if there are handlers listening to events
+   */
+  hasEventHandlers: prop_types_exports.bool,
+  /**
+   * A callback to communicate computed props to a consumer
+   */
+  onComputedProps: prop_types_exports.func,
+  /**
+   * A callback to obtain visualization api
+   */
+  vizActionHandlerRef: prop_types_exports.func,
+  loading: prop_types_exports.bool,
+  theme: prop_types_exports.object,
+  /**
+   * A callback to request new data with updated request params
+   */
+  onRequestParamsChange: prop_types_exports.func
+};
+/**
+ *
+ */
+SplunkVisualization.defaultProps = {
+  // BaseVisualization in dashboard-visualizations uses 100% for width but 250 for height
+  width: "100%",
+  height: INITIAL_HEIGHT,
+  dataSources: {},
+  onEventTrigger: () => ({}),
+  mode: "view",
+  hasEventHandlers: false,
+  options: {},
+  context: {},
+  onOptionsChange: () => ({}),
+  vizActionHandlerRef: () => new DefaultVizActionHandler(),
+  onComputedProps: () => ({}),
+  loading: false,
+  onRequestParamsChange: lodash_exports.noop
+};
+var SplunkVisualization_default = SplunkVisualization;
+
+// src/common/interfaces/DataSource.ts
+var validSortDirs = ["asc", "desc", "none"];
+
+// src/common/hooks/getSorting.ts
+var SortParamsPropTypes = prop_types_exports.shape({
+  currentSortKey: prop_types_exports.string,
+  currentSortDir: prop_types_exports.oneOf(validSortDirs),
+  onSort: prop_types_exports.func
+});
+var getSortingParams = ({ requestParams, onRequestParamsChange }) => {
+  let currentSortKey;
+  let currentSortDir;
+  const nextSortDirMap = {
+    asc: "desc",
+    desc: "asc",
+    none: "asc"
+  };
+  let onSort;
+  if (typeof onRequestParamsChange === "function") {
+    if (requestParams && (0, lodash_exports.has)(requestParams, "sort")) {
+      currentSortKey = Object.keys(requestParams.sort).shift();
+      currentSortDir = requestParams.sort[currentSortKey];
+    }
+    onSort = (e, { sortKey, sortDir }) => {
+      if (typeof sortKey === "string") {
+        const nextSortDir = (0, lodash_exports.has)(nextSortDirMap, sortDir) ? nextSortDirMap[sortDir] : "none";
+        onRequestParamsChange(__spreadValues(__spreadValues({}, requestParams), { offset: 0, sort: { [sortKey]: nextSortDir } }));
+      } else {
+        onRequestParamsChange(requestParams);
+      }
+    };
+  }
+  return {
+    currentSortKey,
+    currentSortDir,
+    onSort
+  };
+};
+
+// src/common/hooks/getPagination.ts
+var PaginatorParamsPropTypes = prop_types_exports.shape({
+  isPaging: prop_types_exports.bool,
+  current: prop_types_exports.number,
+  totalPages: prop_types_exports.number,
+  onChange: prop_types_exports.func
+});
+var getPaginationParams = ({
+  requestParams,
+  meta,
+  onRequestParamsChange
+}) => {
+  const totalCount = meta && meta.totalCount || 0;
+  const offset = requestParams && requestParams.offset || 0;
+  const count = requestParams && requestParams.count;
+  const totalPages = typeof count === "number" && count > 0 ? Math.ceil(totalCount / count) : 0;
+  const current = typeof count === "number" && count > 0 ? Math.floor(offset / count) + 1 : 0;
+  const isPaging = totalPages > 1 && typeof onRequestParamsChange === "function";
+  const onChangeHandler = (e, { page, count: countArg }) => {
+    const newParams = (0, lodash_exports.cloneDeep)(requestParams);
+    if (typeof countArg === "number") {
+      newParams.count = countArg;
+      newParams.offset = 0;
+    }
+    const pageCount = typeof newParams.count === "number" ? newParams.count : 10;
+    if (typeof page === "number" && page > 0) {
+      newParams.count = pageCount;
+      newParams.offset = (page - 1) * pageCount;
+    }
+    onRequestParamsChange(newParams);
+  };
+  return {
+    isPaging,
+    current,
+    totalPages,
+    onChange: typeof onRequestParamsChange === "function" ? onChangeHandler : lodash_exports.noop
+  };
+};
+
+// src/common/hooks/useDeepMemo.ts
+var useDeepMemo = (fn, dependencies) => {
+  const ref = (0, react_exports.useRef)();
+  if (!ref.current || !(0, lodash_exports.isEqual)(dependencies, ref.current.dependencies)) {
+    ref.current = {
+      dependencies,
+      value: fn()
+    };
+  }
+  return ref.current.value;
+};
+
+// esm-externals:@splunk/visualizations-shared/Message
+var Message_exports = {};
+__export(Message_exports, {
+  default: () => Message_default
+});
+var defaultImport24 = __toESM(require("@splunk/visualizations-shared/Message"));
+__reExport(Message_exports, require("@splunk/visualizations-shared/Message"));
+var Message_default = "default" in defaultImport24 ? defaultImport24.default : defaultImport24;
+
+// esm-externals:@splunk/visualizations-shared/style
+var style_exports = {};
+__export(style_exports, {
+  default: () => style_default
+});
+var defaultImport25 = __toESM(require("@splunk/visualizations-shared/style"));
+__reExport(style_exports, require("@splunk/visualizations-shared/style"));
+var style_default = "default" in defaultImport25 ? defaultImport25.default : defaultImport25;
+
+// esm-externals:@splunk/visualizations-shared/SizeAwareWrapper
+var SizeAwareWrapper_exports = {};
+__export(SizeAwareWrapper_exports, {
+  default: () => SizeAwareWrapper_default
+});
+var defaultImport26 = __toESM(require("@splunk/visualizations-shared/SizeAwareWrapper"));
+__reExport(SizeAwareWrapper_exports, require("@splunk/visualizations-shared/SizeAwareWrapper"));
+var SizeAwareWrapper_default = "default" in defaultImport26 ? defaultImport26.default : defaultImport26;
+
+// src/common/hocs/FixedSizeContainer.tsx
+var Item = styled_components_default.div.attrs(({ width }) => ({
+  style: {
+    width: (0, style_exports.toPx)(width)
+  }
+}))`
+    position: relative;
+    background-color: ${(props) => (0, colorUtils_exports.isColor)(props.backgroundColor) && props.backgroundColor || props.theme.defaultBackgroundColor}};
+`;
+var FixSizeItem = styled_components_default.div.attrs(({ width, height }) => ({
+  style: __spreadValues(__spreadValues({}, width && { width: (0, style_exports.toPx)(width) }), height && { height: (0, style_exports.toPx)(height) })
+}))`
+    position: relative;
+    flex-direction: column;
+    flex: 1;
+    display: flex;
+    background-color: ${(props) => (0, colorUtils_exports.isColor)(props.backgroundColor) && props.backgroundColor || props.theme.defaultBackgroundColor}};
+`;
+var ItemContent = styled_components_default.div`
+    position: relative;
+    min-height: 100px;
+    width: 100%;
+`;
+var FixSizeItemContent = styled_components_default.div`
+    min-height: 0px;
+    flex: 1;
+    position: relative;
+    box-sizing: border-box;
+`;
+var withFixedSizeContainer = (Viz) => {
+  const FixedSizeContainer = (props) => {
+    const { width, height, backgroundColor } = props;
+    const cachedHandleResize = react_exports.useCallback((w, h) => {
+      setContainerWidth(w);
+      setContainerHeight(h);
+    }, []);
+    const [containerWidth, setContainerWidth] = react_exports.useState(Number(props.width));
+    const [containerHeight, setContainerHeight] = react_exports.useState(Number(props.height));
+    if (!height) {
+      return /* @__PURE__ */ react_exports.createElement(Item, { "data-test": "item", width, backgroundColor }, /* @__PURE__ */ react_exports.createElement(ItemContent, null, /* @__PURE__ */ react_exports.createElement(Viz, __spreadValues({}, props))));
+    }
+    return /* @__PURE__ */ react_exports.createElement(
+      FixSizeItem,
+      {
+        "data-test": "fix-size-item",
+        "data-splunk-visualization-version": "27.2.0 - 2e7eda8d4",
+        width,
+        height,
+        backgroundColor
+      },
+      /* @__PURE__ */ react_exports.createElement(FixSizeItemContent, null, /* @__PURE__ */ react_exports.createElement(SizeAwareWrapper_default, { width, height, onResize: cachedHandleResize }), /* @__PURE__ */ react_exports.createElement(Viz, __spreadProps(__spreadValues({}, props), { width: containerWidth, height: containerHeight })))
+    );
+  };
+  FixedSizeContainer.displayName = "withFixedSizeContainer";
+  return FixedSizeContainer;
+};
+var FixedSizeContainer_default = withFixedSizeContainer;
+
+// src/common/components/MissingPropsMessage.tsx
+var isMissing = (v) => {
+  return v === null || v === void 0;
+};
+var missingKeys = (keys, target) => keys.filter((k) => isMissing(target[k]));
+var propTypes = {
+  width: prop_types_exports.oneOfType([prop_types_exports.string, prop_types_exports.number]),
+  height: prop_types_exports.oneOfType([prop_types_exports.string, prop_types_exports.number]),
+  // eslint-disable-next-line react/no-unused-prop-types
+  backgroundColor: prop_types_exports.string,
+  missingProps: prop_types_exports.arrayOf(prop_types_exports.string)
+};
+var MissingPropsMessage = (props) => {
+  const { width, height, missingProps } = props;
+  return /* @__PURE__ */ react_exports.createElement(
+    Message_default,
+    {
+      "data-test": "message",
+      width,
+      height,
+      message: (0, i18n_exports._)(`Missing property: ${missingProps.join(", ")}`)
+    }
+  );
+};
+MissingPropsMessage.propTypes = propTypes;
+MissingPropsMessage.defaultProps = {
+  width: "100%",
+  height: 250
+};
+var MissingPropsMessage_default = FixedSizeContainer_default(MissingPropsMessage);
+
+// src/common/utils/hocUtils.ts
+var extendStaticWrapperProps = ({
+  Wrapper,
+  Visualization
+}) => {
+  const extendProperties = ["propTypes", "defaultProps", "config"];
+  extendProperties.forEach((prop) => {
+    if (Visualization[prop]) {
+      Wrapper[prop] = Visualization[prop];
+    }
+  });
+};
+
+// src/common/hocs/withEditModeCover.tsx
+var Cover = styled_components_default.div`
+    position: absolute;
+    left: 0;
+    right: 0;
+    top: 0;
+    bottom: 0;
+`;
+var Blocker = styled_components_default.div.attrs({
+  "data-splunk-visualization-version": "27.2.0 - 2e7eda8d4"
+})`
+    position: relative;
+    width: 100%;
+    height: 100%;
+`;
+var withEditModeCover = (Visualization, disableEditModeCover) => {
+  const Wrapper = (props) => {
+    const { mode } = props;
+    const showEditCover = mode === "edit" && !disableEditModeCover;
+    return /* @__PURE__ */ react_exports.createElement(Blocker, null, /* @__PURE__ */ react_exports.createElement(Visualization, __spreadValues({}, props)), showEditCover && /* @__PURE__ */ react_exports.createElement(Cover, { "data-test": "edit-mode-cover" }));
+  };
+  extendStaticWrapperProps({ Wrapper, Visualization });
+  return Wrapper;
+};
+var withEditModeCover_default = withEditModeCover;
+
+// src/common/components/IconPlaceholder.tsx
+var shouldShowIconPlaceholder = (dataSources, loading = false) => {
+  const data = (0, lodash_exports.get)(dataSources, "primary.data.columns[0]", void 0);
+  const noData = data === void 0;
+  const fields = (0, lodash_exports.get)(dataSources, "primary.data.fields[0]", void 0);
+  const noFields = fields === void 0;
+  return loading || noData || noFields;
+};
+var propTypes2 = {
+  icon: prop_types_exports.func,
+  width: prop_types_exports.oneOfType([prop_types_exports.string, prop_types_exports.number]),
+  height: prop_types_exports.oneOfType([prop_types_exports.string, prop_types_exports.number]),
+  // eslint-disable-next-line react/no-unused-prop-types
+  backgroundColor: prop_types_exports.string,
+  iconColor: prop_types_exports.string
+};
+var IconPlaceholder = (props) => {
+  const { width, height, icon, iconColor } = props;
+  if (icon) {
+    return react_exports.createElement(icon, {
+      style: {
+        left: "50%",
+        top: "50%",
+        color: iconColor,
+        opacity: 0.15,
+        position: "absolute",
+        transform: "translate(-50%, -50%)"
+      },
+      width: "50%",
+      height: "50%",
+      "data-test": "icon-placeholder"
+    });
+  }
+  return /* @__PURE__ */ react_exports.createElement(Message_default, { width, height, level: "warning", message: (0, i18n_exports._)("No DataSource Connected") });
+};
+IconPlaceholder.propTypes = propTypes2;
+IconPlaceholder.defaultProps = {
+  width: "100%",
+  height: 250
+};
+var IconPlaceholder_default = FixedSizeContainer_default(IconPlaceholder);
+
+// src/common/hocs/withPlaceholder.tsx
+var withPlaceholder = (Visualization, useIconPlaceholder = shouldShowIconPlaceholder) => {
+  const { config: config3 } = Visualization;
+  const { themes: themes3 } = config3;
+  const Wrapper = (props) => {
+    var _a, _b;
+    const { dataSources, loading, options, height, width } = props;
+    const showPlaceholder = useIconPlaceholder(dataSources, loading, options);
+    const bgColorFromTheme = (0, colorUtils_exports.isColor)(options == null ? void 0 : options.backgroundColor) ? options == null ? void 0 : options.backgroundColor : (_a = themes3 == null ? void 0 : themes3.defaultBackgroundColor) == null ? void 0 : _a.call(themes3, props);
+    const icon = (_b = config3.placeholderIcon) != null ? _b : config3.icon;
+    const iconColor = variables_default.contentColorActive(props);
+    if (config3.supports.includes("placeholder" /* PLACEHOLDER */) && showPlaceholder) {
+      return /* @__PURE__ */ react_exports.createElement(
+        IconPlaceholder_default,
+        {
+          "data-test": "icon-placeholder",
+          icon,
+          width,
+          height,
+          backgroundColor: bgColorFromTheme,
+          iconColor
+        }
+      );
+    }
+    return /* @__PURE__ */ react_exports.createElement(Visualization, __spreadValues({}, props));
+  };
+  extendStaticWrapperProps({ Wrapper, Visualization });
+  return Wrapper;
+};
+var withPlaceholder_default = withPlaceholder;
+
+// esm-externals:@splunk/visualizations-shared/numberUtils
+var numberUtils_exports = {};
+__export(numberUtils_exports, {
+  default: () => numberUtils_default
+});
+var defaultImport27 = __toESM(require("@splunk/visualizations-shared/numberUtils"));
+__reExport(numberUtils_exports, require("@splunk/visualizations-shared/numberUtils"));
+var numberUtils_default = "default" in defaultImport27 ? defaultImport27.default : defaultImport27;
+
+// src/common/utils/dataUtils.ts
+var largestTriangleThreeBuckets = (data, threshold, preferredDownsampleIndices) => {
+  const dataLength = data.length;
+  const downsampledIndices = [];
+  if (threshold >= dataLength || threshold === 0) {
+    const allIndices = data.map((values, index) => index);
+    return { downsampledData: data, downsampledIndices: allIndices };
+  }
+  const sampled = [];
+  let sampledIndex = 0;
+  const every = (dataLength - 2) / (threshold - 2);
+  let a = 0;
+  let maxAreaPoint;
+  let maxArea;
+  let area;
+  let nextA;
+  sampled.push(data[a]);
+  downsampledIndices.push(0);
+  for (let i = 0; i < threshold - 2; i++) {
+    let avgX = 0;
+    let avgY = 0;
+    let avgRangeStart = Math.floor((i + 1) * every) + 1;
+    let avgRangeEnd = Math.floor((i + 2) * every) + 1;
+    avgRangeEnd = avgRangeEnd < dataLength ? avgRangeEnd : dataLength;
+    const avgRangeLength = avgRangeEnd - avgRangeStart;
+    for (; avgRangeStart < avgRangeEnd; avgRangeStart++) {
+      avgX += Number(data[avgRangeStart][0]);
+      avgY += data[avgRangeStart][1] * 1;
+    }
+    avgX /= avgRangeLength;
+    avgY /= avgRangeLength;
+    let rangeOffs = Math.floor((i + 0) * every) + 1;
+    const rangeTo = Math.floor((i + 1) * every) + 1;
+    const pointAX = Number(data[a][0]);
+    const pointAY = data[a][1] * 1;
+    maxArea = area = -1;
+    let maxAreaIndex = rangeOffs;
+    for (; rangeOffs < rangeTo; rangeOffs++) {
+      area = Math.abs(
+        (pointAX - avgX) * (data[rangeOffs][1] - pointAY) - (pointAX - Number(data[rangeOffs][0])) * (avgY - pointAY)
+      ) * 0.5;
+      if (area > maxArea || area === maxArea && preferredDownsampleIndices.has(rangeOffs)) {
+        maxArea = area;
+        maxAreaPoint = data[rangeOffs];
+        nextA = rangeOffs;
+        maxAreaIndex = rangeOffs;
+      }
+    }
+    sampled[sampledIndex++] = maxAreaPoint;
+    downsampledIndices.push(maxAreaIndex);
+    a = nextA;
+  }
+  sampled[sampledIndex++] = data[dataLength - 1];
+  downsampledIndices.push(dataLength - 1);
+  return { downsampledData: sampled, downsampledIndices };
+};
+var strictlyCoerceYColumn = (column, options) => {
+  const isNullCoercionEnabled = options.nullValueDisplay === "zero";
+  const canLooselyCoerceSomeValues = column.findIndex(
+    (value) => (0, numberUtils_exports.startsWithNumber)(`${value}`) || isNullCoercionEnabled && value === null
+  ) >= 0;
+  const coercedColumn = [];
+  const canDownsampleColumn = !column.some((value) => {
+    const coercedValue = Number(value);
+    const coerceValueToZero = isNullCoercionEnabled && value === null;
+    if (Number.isNaN(coercedValue) || coercedValue <= Number.MIN_SAFE_INTEGER || coercedValue >= Number.MAX_SAFE_INTEGER || typeof value !== "string" && typeof value !== "number" && !coerceValueToZero) {
+      return true;
+    }
+    coercedColumn.push(coercedValue);
+    return false;
+  });
+  return {
+    canDownsampleColumn,
+    canLooselyCoerceSomeValues,
+    coercedColumn: canDownsampleColumn ? coercedColumn : []
+  };
+};
+var strictlyCoerceXColumn = (column, fieldType) => {
+  if (fieldType === "number") {
+    const coercedXColumn = column.map((xValue) => Number(xValue));
+    if (isColumnStrictlyIncreasing(coercedXColumn, fieldType)) {
+      return coercedXColumn;
+    }
+  } else if (fieldType === "time") {
+    const coercedXColumn = column.map((xValue) => new Date(xValue));
+    if (isColumnStrictlyIncreasing(coercedXColumn, fieldType)) {
+      return coercedXColumn;
+    }
+  }
+  return [];
+};
+var isDownsamplingEnabledForViz = ({ vizConfig }) => {
+  var _a;
+  return (_a = vizConfig.supports) == null ? void 0 : _a.includes("downsampling" /* DOWNSAMPLING */);
+};
+var isColumnStrictlyIncreasing = (column, fieldType) => {
+  return column.every((value, index) => {
+    if (fieldType === "number") {
+      if (Number.isNaN(value)) {
+        return false;
+      }
+    }
+    if (fieldType === "time") {
+      if (Number.isNaN(value.getTime())) {
+        return false;
+      }
+    }
+    if (index === 0) {
+      return true;
+    }
+    return value > column[index - 1];
+  });
+};
+var tryToCoerceAllDisplayedFields = (ds, xField, yFields, fieldTypes, options) => {
+  let xColumn = [];
+  const yColumns = [];
+  const canDownsample = !ds.data.fields.some((field, index) => {
+    var _a, _b;
+    const fieldName = (_a = field.name) != null ? _a : field;
+    const fieldType = (_b = fieldTypes[index]) != null ? _b : "unknown";
+    const column = ds.data.columns[index];
+    let hasDisplayedColumnThatCantBeDownsampled = false;
+    if (fieldName === xField) {
+      xColumn = strictlyCoerceXColumn(column, fieldType);
+    } else if (yFields.has(fieldName)) {
+      const { coercedColumn, canLooselyCoerceSomeValues, canDownsampleColumn } = strictlyCoerceYColumn(
+        ds.data.columns[index],
+        options
+      );
+      hasDisplayedColumnThatCantBeDownsampled = canLooselyCoerceSomeValues && !canDownsampleColumn;
+      if (hasDisplayedColumnThatCantBeDownsampled) {
+        return true;
+      }
+      if (canDownsampleColumn) {
+        yColumns.push(coercedColumn);
+      }
+    }
+    return false;
+  });
+  if (canDownsample) {
+    return { xColumn, yColumns };
+  }
+  return { xColumn: [], yColumns: [] };
+};
+var pickIndicesFromDataSource = (ds, indices) => {
+  const sortedIndices = Array.from(indices).sort((a, b) => a - b);
+  const slicedColumns = [];
+  ds.data.columns.forEach((column) => {
+    const slicedColumn = [];
+    sortedIndices.forEach((index) => {
+      slicedColumn.push(column[index]);
+    });
+    slicedColumns.push(slicedColumn);
+  });
+  return __spreadProps(__spreadValues({}, ds), {
+    data: __spreadProps(__spreadValues({}, ds.data), {
+      columns: slicedColumns
+    })
+  });
+};
+var downsampleDataSources = ({ dataSources, threshold, options }) => {
+  var _a, _b, _c;
+  const primaryDS = dataSources == null ? void 0 : dataSources.primary;
+  const numPoints = (_c = (_b = (_a = primaryDS == null ? void 0 : primaryDS.data) == null ? void 0 : _a.columns[0]) == null ? void 0 : _b.length) != null ? _c : 0;
+  if (Number.isNaN(threshold) || numPoints <= threshold || threshold < 2) {
+    return dataSources;
+  }
+  const { xField, yFields, fieldTypes } = options;
+  if (!xField || !(yFields == null ? void 0 : yFields.length) || !(fieldTypes == null ? void 0 : fieldTypes.length)) {
+    return dataSources;
+  }
+  const nonInternalYFields = new Set(yFields.filter((yField) => !yField.startsWith("_")));
+  const maxPointsInDownsample = Math.min(nonInternalYFields.size * threshold, numPoints);
+  if (maxPointsInDownsample >= numPoints) {
+    return dataSources;
+  }
+  const { xColumn, yColumns } = tryToCoerceAllDisplayedFields(
+    primaryDS,
+    xField,
+    nonInternalYFields,
+    fieldTypes,
+    options
+  );
+  if (!yColumns.length || !xColumn.length) {
+    return dataSources;
+  }
+  const downsampledDataSources = __spreadValues({}, dataSources);
+  const downsampledIndices = /* @__PURE__ */ new Set();
+  yColumns.forEach((yColumn, columnIndex) => {
+    const xyPair = yColumn.map((yValue, index) => {
+      return [xColumn[index], yValue];
+    });
+    try {
+      const { downsampledIndices: downsampledIndicesForSeries } = largestTriangleThreeBuckets(
+        xyPair,
+        threshold,
+        downsampledIndices
+      );
+      downsampledIndicesForSeries.forEach((downsampleIndex) => downsampledIndices.add(downsampleIndex));
+    } catch (e) {
+      console.error(`Error occurred while downsampling column ${columnIndex}`, e);
+    }
+  });
+  downsampledDataSources.primary = pickIndicesFromDataSource(primaryDS, downsampledIndices);
+  return downsampledDataSources;
+};
+
+// src/common/hooks/usePrevious.ts
+function usePrevious(value) {
+  const ref = (0, react_exports.useRef)();
+  (0, react_exports.useEffect)(() => {
+    ref.current = value;
+  });
+  return ref.current;
+}
+
+// src/common/hooks/useGetXAndYFields.tsx
+var useGetXAndYFields = ({
+  shouldEvaluateDSL,
+  options,
+  context,
+  dataSources
+}) => {
+  const { dataSourcesWithOnlyOnePoint, dataFrameWithOnlyOnePoint } = (0, react_exports.useMemo)(() => {
+    var _a, _b, _c;
+    if (!shouldEvaluateDSL) {
+      return {
+        dataSourcesWithOnlyOnePoint: null,
+        dataFrameWithOnlyOnePoint: null
+      };
+    }
+    if (!((_c = (_b = (_a = dataSources == null ? void 0 : dataSources.primary) == null ? void 0 : _a.data) == null ? void 0 : _b.columns) == null ? void 0 : _c.length)) {
+      return {
+        dataSourcesWithOnlyOnePoint: null,
+        dataFrameWithOnlyOnePoint: null
+      };
+    }
+    const { primary: primaryDS } = dataSources;
+    const columnsWithOnlyOnePoint = primaryDS.data.columns.map((column) => {
+      return [column[0]];
+    });
+    const filteredDataSources = {
+      primary: __spreadProps(__spreadValues({}, primaryDS), {
+        data: __spreadProps(__spreadValues({}, primaryDS.data), {
+          columns: columnsWithOnlyOnePoint
+        })
+      })
+    };
+    return {
+      dataSourcesWithOnlyOnePoint: filteredDataSources,
+      dataFrameWithOnlyOnePoint: Options_exports.Options.dataFrameFromDataSource(filteredDataSources)
+    };
+  }, [dataSources, shouldEvaluateDSL]);
+  const xAndYFieldsWithTypes = (0, react_exports.useMemo)(() => {
+    try {
+      if (!dataSourcesWithOnlyOnePoint || !dataFrameWithOnlyOnePoint) {
+        return options;
+      }
+      if (!(options == null ? void 0 : options.x) || !(options == null ? void 0 : options.y) && !(options == null ? void 0 : options.y2)) {
+        return options;
+      }
+      const optionsToEvaluate = {
+        x: options.x,
+        xField: "> x | getField()",
+        y: options.y,
+        yFields: options.y ? "> y | getField()" : void 0,
+        y2: options.y2,
+        y2Fields: options.y2 ? "> y2 | getField()" : void 0,
+        fieldTypes: "> primary | getType()"
+      };
+      const { xField = "", yFields = [], y2Fields = [], fieldTypes } = Options_exports.Options.evaluate(
+        { options: optionsToEvaluate, context },
+        dataSourcesWithOnlyOnePoint,
+        () => {
+        },
+        dataFrameWithOnlyOnePoint
+      );
+      return {
+        xField,
+        yFields: [...yFields, ...y2Fields],
+        fieldTypes
+      };
+    } catch (e) {
+      return {
+        xField: void 0,
+        yFields: [],
+        fieldTypes: []
+      };
+    }
+  }, [options, context, dataSourcesWithOnlyOnePoint, dataFrameWithOnlyOnePoint]);
+  return xAndYFieldsWithTypes;
+};
+var useGetXAndYFields_default = useGetXAndYFields;
+
+// src/common/hooks/useDownsampleDataSources.tsx
+var downsampleVizOptionProperties = ["nullValueDisplay"];
+var useDownsampleDataSources = ({
+  dataSources,
+  options,
+  context,
+  threshold,
+  isDownsamplingEnabled
+}) => {
+  const isFirstUseEffectCall = (0, react_exports.useRef)(true);
+  const xAndYFieldsWithTypes = useGetXAndYFields_default({
+    shouldEvaluateDSL: isDownsamplingEnabled,
+    options,
+    context,
+    dataSources
+  });
+  const downsampleVizOptions = (0, react_exports.useMemo)(() => (0, lodash_exports.pick)(options, downsampleVizOptionProperties), [options]);
+  const downsampleDSOptions = (0, react_exports.useMemo)(
+    () => __spreadValues(__spreadValues({}, downsampleVizOptions), xAndYFieldsWithTypes),
+    [xAndYFieldsWithTypes, downsampleVizOptions]
+  );
+  const previousDownsampleDSOptions = usePrevious(downsampleDSOptions);
+  const previousDataSources = usePrevious(dataSources);
+  const previousThreshold = usePrevious(threshold);
+  const [downsampledDataSources, setDownsampledDataSources] = (0, react_exports.useState)(() => {
+    return isDownsamplingEnabled ? downsampleDataSources({
+      dataSources,
+      threshold,
+      options: downsampleDSOptions
+    }) : dataSources;
+  });
+  const debouncedDownsampleDataSources = (0, react_exports.useMemo)(() => {
+    return (0, lodash_exports.debounce)(
+      (downsampleOptions) => {
+        const downsampledResult = downsampleDataSources(downsampleOptions);
+        setDownsampledDataSources(downsampledResult);
+      },
+      100,
+      { trailing: true }
+    );
+  }, []);
+  (0, react_exports.useEffect)(() => {
+    if (isFirstUseEffectCall.current) {
+      isFirstUseEffectCall.current = false;
+      return;
+    }
+    if (!isDownsamplingEnabled) {
+      setDownsampledDataSources(dataSources);
+      return;
+    }
+    if ((0, lodash_exports.isEqual)(previousDownsampleDSOptions, downsampleDSOptions) && previousDataSources === dataSources && previousThreshold === threshold) {
+      return;
+    }
+    debouncedDownsampleDataSources({
+      dataSources,
+      options: downsampleDSOptions,
+      // Dont want to re-downsample everytime the options change
+      threshold
+    });
+  }, [
+    dataSources,
+    downsampleDSOptions,
+    debouncedDownsampleDataSources,
+    xAndYFieldsWithTypes,
+    threshold,
+    isDownsamplingEnabled,
+    previousDataSources,
+    previousThreshold,
+    previousDownsampleDSOptions
+  ]);
+  return downsampledDataSources;
+};
+var useDownsampleDataSources_default = useDownsampleDataSources;
+
+// esm-externals:@splunk/visualization-context/FeatureFlags
+var FeatureFlags_exports = {};
+__export(FeatureFlags_exports, {
+  default: () => FeatureFlags_default
+});
+var defaultImport28 = __toESM(require("@splunk/visualization-context/FeatureFlags"));
+__reExport(FeatureFlags_exports, require("@splunk/visualization-context/FeatureFlags"));
+var FeatureFlags_default = "default" in defaultImport28 ? defaultImport28.default : defaultImport28;
+
+// src/common/utils/featureFlagUtils.ts
+var getFeatureFlag = (context, flagName) => {
+  if (context && Object.keys(context).find((key) => key === flagName)) {
+    return context[flagName];
+  }
+  if (Object.keys(FeatureFlags_default).find((key) => key === flagName)) {
+    return FeatureFlags_default[flagName];
+  }
+  return false;
+};
+
+// esm-externals:@splunk/visualizations-shared/trellisUtils
+var trellisUtils_exports = {};
+__export(trellisUtils_exports, {
+  default: () => trellisUtils_default
+});
+var defaultImport29 = __toESM(require("@splunk/visualizations-shared/trellisUtils"));
+__reExport(trellisUtils_exports, require("@splunk/visualizations-shared/trellisUtils"));
+var trellisUtils_default = "default" in defaultImport29 ? defaultImport29.default : defaultImport29;
+
+// src/common/utils/trellisUtils.ts
+var turnOffLegendDisplayWhenTrellisIsOn = (isTrellisOn, options) => {
+  if (isTrellisOn && !options.legendDisplay) {
+    return {
+      legendDisplay: "off"
+    };
+  }
+  return {};
+};
+
+// src/common/withDashboardViz.tsx
+var withDashboardViz = (opts) => {
+  const {
+    ReactViz,
+    vizConfig,
+    computeVizProps: computeVizProps2 = () => {
+    },
+    computeVizPropsBeforeEval = () => {
+    },
+    disableEditModeCover,
+    useIconPlaceholder
+  } = opts;
+  const SanitizedReactViz = (0, SanitizeProps_exports.withSanitizedProps)(ReactViz);
+  const defaultOptions = (0, JSONSchemaUtils_exports.pickFieldFromJSONSchema)(vizConfig.optionsSchema, "default");
+  const DashboardViz = (props) => {
+    var _a;
+    const {
+      mode,
+      hasEventHandlers,
+      dataSources,
+      // type of { [key: string]: DataSource }
+      options,
+      context = {},
+      width,
+      height,
+      onComputedProps,
+      onEventTrigger,
+      theme,
+      onRequestParamsChange
+    } = props;
+    const { serializedTimezone } = react_exports.useContext(TimezoneContext_default);
+    if (serializedTimezone) {
+      if (!moment_default.getDefaultSplunkTimezone()) {
+        moment_default.setDefaultSplunkTimezone(serializedTimezone);
+      }
+    }
+    const themeFunc = (themeVar) => {
+      var _a2, _b;
+      return (_b = (_a2 = vizConfig.themes)[themeVar]) == null ? void 0 : _b.call(_a2, props);
+    };
+    const bgColorFromTheme = themeFunc("defaultBackgroundColor");
+    const {
+      family: currentThemeFamily,
+      colorScheme: currentThemeColorScheme,
+      density: currentThemeDensity
+    } = getSettingsFromThemedProps_default({ theme });
+    let evaluatedOptions = {};
+    const [evaluatedOptionsAsync, setEvaluatedOptionsAsync] = react_exports.useState({});
+    const featureFlagContext = react_exports.useContext(FeatureFlagContext_default);
+    const [visualizationID] = react_exports.useState(`${vizConfig.name} - ${(0, id_exports.createGUID)()}`);
+    const [dataSourcesInState, setDataSourcesInState] = react_exports.useState({});
+    const [dataFramesInState, setDataFramesInState] = react_exports.useState();
+    const [useAsyncEvaluatedOptions, setUseAsyncEvaluatedOptions] = react_exports.useState(
+      Boolean(getFeatureFlag(featureFlagContext, "visualizations_useWebWorkersForDSL"))
+    );
+    const isDownsamplingEnabledByFeatureFlag = Boolean(
+      featureFlagContext == null ? void 0 : featureFlagContext.visualizations_enableDownsampling
+    );
+    const isTrellisFeatureFlagOn = Boolean(
+      featureFlagContext && featureFlagContext.visualizations_enableTrellis
+    );
+    const isTrellisOn = isTrellisFeatureFlagOn && ((_a = vizConfig == null ? void 0 : vizConfig.supports) == null ? void 0 : _a.includes("trellis" /* TRELLIS */)) && (options == null ? void 0 : options.splitByLayout) === "trellis" /* TRELLIS */;
+    const isMounted = react_exports.useRef(true);
+    const optionsToEvaluate = react_exports.useMemo(() => {
+      var _a2;
+      const legendDisplay = turnOffLegendDisplayWhenTrellisIsOn(isTrellisOn, options);
+      const computedOptions = (_a2 = computeVizPropsBeforeEval(options)) != null ? _a2 : {};
+      return {
+        context: (0, lodash_exports.defaultsDeep)({}, context, vizConfig.defaultContext),
+        options: (0, hocUtils_exports.deepMergeWithArrayPrimitiveOverrides)(
+          {},
+          legendDisplay,
+          computedOptions,
+          options,
+          defaultOptions
+        )
+      };
+    }, [isTrellisOn, options, context]);
+    const [threshold, setThreshold] = react_exports.useState(Number(width));
+    const onDownsamplingThresholdChange = react_exports.useCallback((newThreshold) => {
+      setThreshold(newThreshold);
+    }, []);
+    const isDownsamplingEnabled = react_exports.useMemo(() => {
+      return isDownsamplingEnabledByFeatureFlag && isDownsamplingEnabledForViz({ vizConfig });
+    }, [isDownsamplingEnabledByFeatureFlag]);
+    const downsamplingProps = react_exports.useMemo(() => {
+      if (!isDownsamplingEnabled) {
+        return {};
+      }
+      return {
+        onDownsamplingThresholdChange,
+        originalDataSources: dataSources
+      };
+    }, [dataSources, isDownsamplingEnabled, onDownsamplingThresholdChange]);
+    const downsampledDataSources = useDownsampleDataSources_default({
+      options: optionsToEvaluate.options,
+      context: optionsToEvaluate.context,
+      dataSources,
+      threshold,
+      isDownsamplingEnabled
+    });
+    evaluatedOptions = useDeepMemo(() => {
+      try {
+        if (useAsyncEvaluatedOptions) {
+          const asyncDynamicOptionsEvaluatorParams = {
+            visualizationID,
+            props,
+            options: optionsToEvaluate,
+            dataSources: downsampledDataSources,
+            theme: vizConfig.themes,
+            bypassCloneDeepOptionScope: Boolean(
+              getFeatureFlag(featureFlagContext, "visualizations_bypassCloneDeepOptionScope")
+            ),
+            lazyLoadingDataFrame: Boolean(
+              getFeatureFlag(featureFlagContext, "visualizations_lazyLoadingDataFrame")
+            )
+          };
+          async_dynamic_options_evaluator_default.evaluate(asyncDynamicOptionsEvaluatorParams).then((results) => {
+            setEvaluatedOptionsAsync(results.results);
+          }).catch(() => {
+            if (isMounted.current) {
+              setUseAsyncEvaluatedOptions(false);
+            }
+          });
+        } else {
+          let dataFrames = dataFramesInState;
+          if (downsampledDataSources !== dataSourcesInState) {
+            setDataSourcesInState(downsampledDataSources);
+            dataFrames = Options_exports.Options.dataFrameFromDataSource(
+              downsampledDataSources,
+              getFeatureFlag(featureFlagContext, "visualizations_lazyLoadingDataFrame")
+            );
+            setDataFramesInState(dataFrames);
+          }
+          const result = Options_exports.Options.evaluate(
+            optionsToEvaluate,
+            downsampledDataSources,
+            themeFunc,
+            dataFrames,
+            getFeatureFlag(featureFlagContext, "visualizations_bypassCloneDeepOptionScope")
+          );
+          return result;
+        }
+      } catch (e) {
+        console.error(`unexpected error evaluating options: ${e.message}`);
+        return {};
+      }
+      return {};
+    }, [
+      currentThemeFamily,
+      currentThemeColorScheme,
+      currentThemeDensity,
+      optionsToEvaluate,
+      downsampledDataSources,
+      serializedTimezone,
+      useAsyncEvaluatedOptions
+    ]);
+    const evaluatedOptionsToUse = !useAsyncEvaluatedOptions ? evaluatedOptions : evaluatedOptionsAsync;
+    let clonedEvaluatedOptions = evaluatedOptionsToUse;
+    if (isTrellisOn) {
+      clonedEvaluatedOptions = __spreadProps(__spreadValues({}, evaluatedOptionsToUse), {
+        backgroundColor: clonedEvaluatedOptions == null ? void 0 : clonedEvaluatedOptions.trellisBackgroundColor
+      });
+    }
+    react_exports.useEffect(() => {
+      onComputedProps(clonedEvaluatedOptions);
+    });
+    react_exports.useEffect(() => {
+      return () => {
+        if (useAsyncEvaluatedOptions) {
+          isMounted.current = false;
+          async_dynamic_options_evaluator_default.reset(visualizationID);
+        }
+      };
+    }, []);
+    const { requiredProps = [], supports } = vizConfig;
+    const missing = missingKeys(requiredProps, evaluatedOptionsToUse);
+    if (missing.length > 0 && supports.includes("placeholder" /* PLACEHOLDER */) && vizConfig.key !== "splunk.singlevalue") {
+      return /* @__PURE__ */ react_exports.createElement(
+        MissingPropsMessage_default,
+        {
+          "data-test": "missing-props-message",
+          width,
+          height,
+          missingProps: missing,
+          backgroundColor: bgColorFromTheme
+        }
+      );
+    }
+    const eventCallbackProps = {};
+    if (hasEventHandlers && mode === "view" && vizConfig.supports.indexOf("events" /* EVENTS */) > -1) {
+      const supportedEvents = vizConfig.events;
+      Object.keys(supportedEvents).forEach((eventName) => {
+        const { parentKeys, payloadKeys } = supportedEvents[eventName];
+        const eventCallbackPropName = (0, lodash_exports.camelCase)(`on.${eventName}`);
+        let payload = {};
+        if (Array.isArray(payloadKeys) && payloadKeys.length) {
+          payloadKeys.forEach((p) => {
+            payload[p] = evaluatedOptionsToUse[p];
+          });
+        }
+        eventCallbackProps[eventCallbackPropName] = (ev) => {
+          if (ev && ev.payload) {
+            payload = ev.payload;
+          }
+          return onEventTrigger({ originalEvent: ev, payload, type: eventName });
+        };
+        if (parentKeys) {
+          for (let i = parentKeys.length - 1; i >= 0; i -= 1) {
+            const newObject = {};
+            newObject[parentKeys[i]] = eventCallbackProps[eventCallbackPropName];
+            eventCallbackProps[eventCallbackPropName] = newObject;
+          }
+        }
+      });
+    }
+    const computedVizProps = computeVizProps2(__spreadProps(__spreadValues(__spreadValues(__spreadValues({}, props), evaluatedOptionsToUse), eventCallbackProps), {
+      themeFunc
+    }));
+    let dataSourceMetadata = {};
+    const OptionKey = "paginateDataSourceKey";
+    const paginateDataSourceKey = (0, lodash_exports.has)(evaluatedOptionsToUse, OptionKey) && evaluatedOptionsToUse[OptionKey] || "primary";
+    if (vizConfig.supports.indexOf("page-and-sort" /* PAGE_AND_SORT */) > -1 && (0, lodash_exports.has)(dataSources, paginateDataSourceKey)) {
+      const requestParams = (0, lodash_exports.get)(dataSources, [paginateDataSourceKey, "requestParams"], {});
+      const meta = (0, lodash_exports.get)(dataSources, [paginateDataSourceKey, "meta"], {});
+      const handleRequestParamsChange = (payload) => onRequestParamsChange(paginateDataSourceKey, payload);
+      const sortParams = getSortingParams({
+        requestParams,
+        meta,
+        onRequestParamsChange: handleRequestParamsChange
+      });
+      const paginatorParams = getPaginationParams({
+        requestParams,
+        meta,
+        onRequestParamsChange: handleRequestParamsChange
+      });
+      dataSourceMetadata = {
+        sortParams,
+        paginatorParams
+      };
+    }
+    if (useAsyncEvaluatedOptions && Object.keys(evaluatedOptionsToUse).length === 0) {
+      return null;
+    }
+    return /* @__PURE__ */ react_exports.createElement(
+      SanitizedReactViz,
+      __spreadValues(__spreadValues(__spreadValues(__spreadValues(__spreadValues({
+        mode,
+        width,
+        height
+      }, downsamplingProps), evaluatedOptionsToUse), computedVizProps), eventCallbackProps), dataSourceMetadata)
+    );
+  };
+  DashboardViz.propTypes = __spreadValues(__spreadValues({}, SplunkVisualization_default.propTypes), ReactViz.propTypes);
+  DashboardViz.defaultProps = __spreadProps(__spreadValues(__spreadValues({}, SplunkVisualization_default.defaultProps), ReactViz.defaultProps), {
+    // using withTheme requires component to receive theme prop. In case the consumer did not provide ThemeProvider, a default empty object will prevent warnings.
+    theme: {}
+  });
+  DashboardViz.config = vizConfig;
+  return (0, styled_components_exports.withTheme)(
+    withPlaceholder_default(withEditModeCover_default(DashboardViz, disableEditModeCover), useIconPlaceholder)
+  );
+};
+var withDashboardViz_default = withDashboardViz;
+
+// esm-externals:@splunk/themes
+var themes_exports = {};
+__export(themes_exports, {
+  default: () => themes_default
+});
+var defaultImport30 = __toESM(require("@splunk/themes"));
+__reExport(themes_exports, require("@splunk/themes"));
+var themes_default = "default" in defaultImport30 ? defaultImport30.default : defaultImport30;
+
+// src/Timeline/PureTimeline/src/utils/timelineUtils.ts
+function hexToRgba(hex, opacity = 1) {
+  const hexString = typeof hex === "string" ? hex.replace("#", "") : "#009CEB";
+  const r = parseInt(hexString.substring(0, 2), 16);
+  const g = parseInt(hexString.substring(2, 4), 16);
+  const b = parseInt(hexString.substring(4, 6), 16);
+  const alpha = Math.max(0, Math.min(opacity, 1));
+  return `rgba(${r}, ${g}, ${b}, ${alpha})`;
+}
+function getAlternateColor(hex, percent) {
+  const cleanedHex = typeof hex === "string" ? hex.replace("#", "") : "#009CEB";
+  const bigint = parseInt(cleanedHex, 16);
+  const r = bigint >> 16 & 255;
+  const g = bigint >> 8 & 255;
+  const b = bigint & 255;
+  const luminance = (0.2126 * r + 0.7152 * g + 0.0722 * b) / 255;
+  const darken = (channel, factor) => {
+    return Math.floor(channel * factor);
+  };
+  if (luminance > 0.8) {
+    const darkenFactor = 0.95;
+    const rDark = darken(r, darkenFactor);
+    const gDark = darken(g, darkenFactor);
+    const bDark = darken(b, darkenFactor);
+    return `rgba(${rDark}, ${gDark}, ${bDark}, 1)`;
+  }
+  const lighten = (channel) => Math.min(255, Math.floor(channel + (255 - channel) * percent));
+  const rLight = lighten(r);
+  const gLight = lighten(g);
+  const bLight = lighten(b);
+  return `rgba(${rLight}, ${gLight}, ${bLight}, 1)`;
+}
+var toTimestamp = (dateStr, timezone = {}) => {
+  try {
+    let dateTime;
+    if ("utcOffset" in timezone) {
+      dateTime = moment_default.utc(dateStr).utcOffset(timezone.utcOffset, true);
+    } else if ("ianaTimezone" in timezone) {
+      dateTime = moment_default.tz(dateStr, timezone.ianaTimezone);
+    } else if ("serializedTimezone" in timezone) {
+      const splunkSerializedTimezone = moment_default.addSplunkTimezone(timezone.serializedTimezone);
+      dateTime = moment_default.tz(dateStr, splunkSerializedTimezone);
+    } else {
+      dateTime = moment_default(dateStr);
+    }
+    if (!dateTime.isValid()) {
+      console.error("Invalid date:", dateStr);
+      return NaN;
+    }
+    return dateTime.toDate().getTime();
+  } catch (error) {
+    console.error("Invalid date or timezone:", dateStr, timezone, error);
+    return NaN;
+  }
+};
+function mapDataToTimeline(resultLimit, x, y, duration, category = [], dataColors = [], seriesColors = [], additionalTooltipValues = [], _timezone = {}, defaultColor = "#009CEB") {
+  var _a, _b;
+  const categoricalColors = /* @__PURE__ */ new Map();
+  const lanesSet = /* @__PURE__ */ new Set();
+  const laneSeriesMap = /* @__PURE__ */ new Map();
+  const timeDifferences = [];
+  for (let i = 0; i < Math.min(x.length, resultLimit); i += 1) {
+    const lane = y[i];
+    lanesSet.add(lane);
+    let color = defaultColor;
+    const categoryValue = ((_a = category[i]) == null ? void 0 : _a.toString()) || null;
+    if (categoryValue && !categoricalColors.has(categoryValue)) {
+      const colorIndex = categoricalColors.size;
+      const assignedColor = seriesColors[colorIndex % seriesColors.length] || defaultColor;
+      categoricalColors.set(categoryValue, assignedColor);
+    }
+    if (dataColors && (dataColors == null ? void 0 : dataColors.length) > 0) {
+      const assignedDataColor = dataColors[i];
+      color = assignedDataColor || defaultColor;
+    } else if (categoryValue) {
+      color = categoricalColors.get(categoryValue);
+    }
+    const start = toTimestamp(x[i].toString(), _timezone);
+    const durationValue = duration[i] || 0;
+    const end = start + durationValue;
+    const additionalTooltipValue = additionalTooltipValues ? additionalTooltipValues[i] : null;
+    if (!laneSeriesMap.has(lane)) {
+      laneSeriesMap.set(lane, []);
+    }
+    (_b = laneSeriesMap.get(lane)) == null ? void 0 : _b.push({
+      start,
+      end,
+      _time: x[i].toString(),
+      duration: durationValue,
+      category: categoryValue,
+      color,
+      additionalTooltipValue
+    });
+    if (i > 0) {
+      const prevStart = toTimestamp(x[i - 1].toString(), _timezone);
+      const timeDiff = start - prevStart;
+      timeDifferences.push(timeDiff);
+    }
+  }
+  const lanes = Array.from(lanesSet);
+  const laneSeries = lanes.map((lane) => {
+    const series = laneSeriesMap.get(lane) || [];
+    series.sort((a, b) => b.duration - a.duration);
+    return series;
+  });
+  let averageDiff = 0;
+  if (timeDifferences.length > 0) {
+    const sumOfDifferences = timeDifferences.reduce((acc, val) => acc + val, 0);
+    averageDiff = sumOfDifferences / timeDifferences.length;
+  }
+  const tickInterval = getTickInterval(averageDiff);
+  return { laneSeries, lanes, categoricalColors, tickInterval };
+}
+var drawRoundedRect = (ctx, x, y, width, height, radius) => {
+  ctx.beginPath();
+  ctx.moveTo(x + radius, y);
+  ctx.lineTo(x + width - radius, y);
+  ctx.quadraticCurveTo(x + width, y, x + width, y + radius);
+  ctx.lineTo(x + width, y + height - radius);
+  ctx.quadraticCurveTo(x + width, y + height, x + width - radius, y + height);
+  ctx.lineTo(x + radius, y + height);
+  ctx.quadraticCurveTo(x, y + height, x, y + height - radius);
+  ctx.lineTo(x, y + radius);
+  ctx.quadraticCurveTo(x, y, x + radius, y);
+  ctx.closePath();
+  ctx.fill();
+  ctx.stroke();
+};
+var truncateText = (text, maxWidth, truncationType, font = '10px "Splunk Data Sans"') => {
+  const canvas = document.createElement("canvas");
+  const context = canvas.getContext("2d");
+  if (!context) return text;
+  context.font = font;
+  const ellipsis = "...";
+  const ellipsisWidth = context.measureText(ellipsis).width;
+  const fullTextWidth = context.measureText(text).width;
+  if (fullTextWidth <= maxWidth) {
+    return text;
+  }
+  if (truncationType === "ellipsisEnd") {
+    for (let i = text.length - 1; i > 0; i -= 1) {
+      const truncatedText = text.slice(0, i) + ellipsis;
+      if (context.measureText(truncatedText).width <= maxWidth) {
+        return truncatedText;
+      }
+    }
+  } else if (truncationType === "ellipsisStart") {
+    for (let i = 0; i < text.length; i += 1) {
+      const truncatedText = ellipsis + text.slice(i);
+      if (context.measureText(truncatedText).width <= maxWidth) {
+        return truncatedText;
+      }
+    }
+  } else if (truncationType === "ellipsisMiddle") {
+    for (let i = 0; i < text.length / 2; i += 1) {
+      const left = text.slice(0, Math.floor(text.length / 2) - i);
+      const right = text.slice(Math.ceil(text.length / 2) + i);
+      const truncatedText = left + ellipsis + right;
+      if (context.measureText(left).width + ellipsisWidth + context.measureText(right).width <= maxWidth) {
+        return truncatedText;
+      }
+    }
+  }
+  return ellipsis;
+};
+var getTickInterval = (averageDiff) => {
+  if (averageDiff < 6e4) {
+    return "1s";
+  }
+  if (averageDiff < 36e5) {
+    return "1m";
+  }
+  if (averageDiff < 18e6) {
+    return "30m";
+  }
+  if (averageDiff < 432e5) {
+    return "1h";
+  }
+  if (averageDiff < 864e5) {
+    return "12h";
+  }
+  if (averageDiff < 6048e5) {
+    return "1d";
+  }
+  if (averageDiff < 2592e6) {
+    return "7d";
+  }
+  return "1mo";
+};
+function convertTickIntervalToMs(tickInterval) {
+  switch (tickInterval) {
+    case "1s":
+      return 1e3;
+    case "1m":
+      return 6e4;
+    case "30m":
+      return 18e5;
+    case "1h":
+      return 36e5;
+    case "12h":
+      return 432e5;
+    case "1d":
+      return 864e5;
+    case "7d":
+      return 6048e5;
+    case "1mo":
+      return 275e7;
+    default:
+      throw new Error("Unsupported tick interval");
+  }
+}
+function calculateMaxNumberOfTicks(availableWidth, pixelPerLabel, extraSpacing) {
+  const minSpacingPerLabel = pixelPerLabel + extraSpacing;
+  const effectiveWidth = availableWidth - 2 * minSpacingPerLabel;
+  const maxNumTicks = Math.floor(effectiveWidth / minSpacingPerLabel);
+  return Math.max(maxNumTicks, 0);
+}
+var isSafari = () => /^((?!chrome|android).)*safari/i.test(navigator.userAgent);
+var tooltipLocaleTimeFormat = (displaySeconds) => {
+  const seconds = displaySeconds ? { second: "2-digit" } : {};
+  return __spreadValues({
+    hour: "numeric",
+    minute: "2-digit",
+    day: "numeric",
+    month: "short",
+    year: "numeric"
+  }, seconds);
+};
+
+// esm-externals:uplot-react
+var uplot_react_exports = {};
+__export(uplot_react_exports, {
+  default: () => uplot_react_default
+});
+var defaultImport31 = __toESM(require("uplot-react"));
+__reExport(uplot_react_exports, require("uplot-react"));
+var uplot_react_default = "default" in defaultImport31 ? defaultImport31.default : defaultImport31;
+
+// src/Timeline/PureTimeline/src/CursorPlugin.tsx
+var currentScaleFactor = 1;
+var canvasScaleObserver = null;
+var updateScaleFactor = () => {
+  const canvasElement = document.querySelector('[data-test="canvas"]');
+  if (canvasElement) {
+    const computedStyle = window.getComputedStyle(canvasElement);
+    const transformMatrix = computedStyle.getPropertyValue("transform");
+    if (transformMatrix && transformMatrix !== "none") {
+      const matrixValues = transformMatrix.match(/matrix(?:3d)?\((.+)\)/);
+      if (matrixValues) {
+        const values = matrixValues[1].split(", ");
+        currentScaleFactor = parseFloat(values[0]);
+      }
+    } else {
+      currentScaleFactor = 1;
+    }
+  } else {
+    canvasScaleObserver == null ? void 0 : canvasScaleObserver.disconnect();
+  }
+};
+var resetScaleFactorOnFullscreen = () => {
+  document.addEventListener("fullscreenchange", () => {
+    if (document.fullscreenElement) {
+      currentScaleFactor = 1;
+    } else {
+      updateScaleFactor();
+    }
+  });
+};
+var initObserver = () => {
+  const canvasElement = document.querySelector('[data-test="canvas"]');
+  if (canvasElement) {
+    canvasScaleObserver = new MutationObserver((mutationsList) => {
+      mutationsList.forEach((mutation) => {
+        if (mutation.type === "attributes" && mutation.attributeName === "style") {
+          updateScaleFactor();
+        }
+      });
+    });
+    canvasScaleObserver.observe(canvasElement, { attributes: true, attributeFilter: ["style"] });
+  }
+};
+document.addEventListener("DOMContentLoaded", () => {
+  updateScaleFactor();
+  initObserver();
+  resetScaleFactorOnFullscreen();
+});
+var CursorPlugin = ({
+  laneSeries,
+  lanes,
+  numTicks,
+  durationPerTick,
+  setHighlightedCategory,
+  setHighlightedEvent,
+  setHighlightedLane,
+  handleEventClick,
+  tooltipRef
+}) => {
+  const FIXED_LANE_HEIGHT = 32;
+  const MIN_BAR_WIDTH = 20;
+  const CIRCLE_X_OFFSET = 10;
+  const CIRCLE_LANE_SCALE_FACTOR = 0.85;
+  let previousTooltipContent = null;
+  const dpr = window.devicePixelRatio || 1;
+  const handleMouseLeave = (u) => {
+    const xCursorLine = u.root.querySelector(".u-cursor-x");
+    xCursorLine.classList.add("u-off");
+    tooltipRef.current = {
+      visible: false,
+      overflow: false,
+      content: "",
+      meta: ""
+    };
+    setHighlightedLane(null);
+    setHighlightedEvent(null);
+    setHighlightedCategory(null);
+  };
+  const handleClick = () => {
+    if (tooltipRef.current.visible) {
+      const { content, meta } = tooltipRef.current;
+      if (!previousTooltipContent || JSON.stringify(previousTooltipContent) !== JSON.stringify(content)) {
+        handleEventClick(content.from, meta.duration, content.lane, content.category);
+        previousTooltipContent = __spreadValues({}, content);
+      }
+    }
+  };
+  return {
+    hooks: {
+      init: (u) => {
+        const chartContainer = u.root;
+        chartContainer.addEventListener("click", handleClick);
+        if (!isSafari()) {
+          chartContainer.addEventListener("mouseleave", () => handleMouseLeave(u));
+        }
+        return () => {
+          chartContainer.removeEventListener("mouseleave", () => handleMouseLeave(u));
+          chartContainer.removeEventListener("click", handleClick);
+        };
+      },
+      setCursor: (u) => {
+        const mouseEvent = u.cursor.event;
+        const xCursorLine = u.root.querySelector(".u-cursor-x");
+        if (!mouseEvent) {
+          tooltipRef.current.visible = false;
+          if (xCursorLine) {
+            xCursorLine.classList.add("u-off");
+          }
+          return;
+        }
+        const effectiveWidth = u.bbox.width * currentScaleFactor;
+        const effectiveHeight = u.bbox.height * currentScaleFactor;
+        const xPos = (mouseEvent.clientX - u.root.getBoundingClientRect().left) * (u.bbox.width / effectiveWidth);
+        const yPos = (mouseEvent.clientY - u.root.getBoundingClientRect().top) * (u.bbox.height / effectiveHeight);
+        u.cursor.left = xPos;
+        u.cursor.top = yPos;
+        if (xCursorLine) {
+          if (xPos < 0 || xPos > u.bbox.width || yPos < 0 || yPos > u.bbox.height) {
+            xCursorLine.classList.add("u-off");
+          } else {
+            xCursorLine.classList.remove("u-off");
+            xCursorLine.style.transform = `translateX(${xPos}px)`;
+          }
+        }
+        const cursorSeriesIndex = Math.ceil(yPos / FIXED_LANE_HEIGHT);
+        const events = laneSeries[cursorSeriesIndex - 1];
+        let showTooltip = false;
+        let tooltipContent = {};
+        let tooltipMeta = {};
+        let tooltipX = 0;
+        let tooltipY = 0;
+        let overflow = false;
+        if (events) {
+          const sortedEvents = [...events].sort((a, b) => {
+            if (a.duration === 0 && b.duration !== 0) return 1;
+            if (a.duration !== 0 && b.duration === 0) return -1;
+            return 0;
+          });
+          for (let i = sortedEvents.length - 1; i >= 0; i -= 1) {
+            const event = sortedEvents[i];
+            const xStartFraction = (event.start - u.scales.x.min) / durationPerTick;
+            const xStart = xStartFraction * (u.bbox.width / dpr / numTicks);
+            const circleDiameter = FIXED_LANE_HEIGHT * CIRCLE_LANE_SCALE_FACTOR;
+            const circleStart = xStart - CIRCLE_X_OFFSET;
+            if (event.duration === 0) {
+              if (xPos >= circleStart && xPos <= circleStart + circleDiameter) {
+                tooltipX = circleStart + (circleDiameter + CIRCLE_X_OFFSET) / 2;
+                tooltipY = cursorSeriesIndex * FIXED_LANE_HEIGHT;
+                showTooltip = true;
+              }
+            } else {
+              const durationWidth = event.duration / durationPerTick * (u.bbox.width / dpr / numTicks);
+              const barWidth = Math.max(durationWidth, MIN_BAR_WIDTH);
+              if (xPos >= xStart && xPos <= xStart + barWidth) {
+                tooltipX = xStart + CIRCLE_X_OFFSET;
+                tooltipY = cursorSeriesIndex * FIXED_LANE_HEIGHT;
+                showTooltip = true;
+              }
+            }
+            if (showTooltip) {
+              const displaySeconds = durationPerTick < 6e4 && event.duration !== 0;
+              const startTime = new Date(event.start).toLocaleTimeString(
+                [],
+                tooltipLocaleTimeFormat(displaySeconds)
+              );
+              const endTime = new Date(event.end).toLocaleTimeString(
+                [],
+                tooltipLocaleTimeFormat(displaySeconds)
+              );
+              const lane = lanes[cursorSeriesIndex - 1];
+              tooltipContent = __spreadValues({
+                from: startTime,
+                to: endTime,
+                lane,
+                category: (event == null ? void 0 : event.category) || void 0
+              }, event.additionalTooltipValue);
+              tooltipMeta = __spreadValues({
+                duration: event.duration
+              }, event.additionalTooltipValue);
+              const tooltipWidth = 85;
+              const plotRightEdge = u.bbox.width / dpr;
+              if (tooltipX + tooltipWidth > plotRightEdge) {
+                overflow = true;
+                tooltipY -= FIXED_LANE_HEIGHT / 2;
+                tooltipX -= event.duration === 0 ? FIXED_LANE_HEIGHT : MIN_BAR_WIDTH;
+              }
+              if (!tooltipRef.current.visible || tooltipRef.current.content !== tooltipContent) {
+                u.root.style.cursor = "pointer";
+                tooltipRef.current = {
+                  visible: true,
+                  x: tooltipX,
+                  y: tooltipY,
+                  overflow,
+                  content: tooltipContent,
+                  meta: tooltipMeta
+                };
+                setHighlightedLane(lane);
+                setHighlightedEvent(event);
+                setHighlightedCategory(event.category);
+              }
+              break;
+            }
+          }
+        }
+        if (!showTooltip && tooltipRef.current.visible) {
+          u.root.style.cursor = "default";
+          tooltipRef.current = {
+            visible: false,
+            overflow: false,
+            content: "",
+            meta: ""
+          };
+          setHighlightedLane(null);
+          setHighlightedEvent(null);
+          setHighlightedCategory(null);
+        }
+      }
+    }
+  };
+};
+var CursorPlugin_default = CursorPlugin;
+
+// src/Timeline/PureTimeline/src/TimelinePlugin.tsx
+var TimelinePlugin = ({
+  laneSeries,
+  lanes,
+  backgroundColor,
+  numTicks,
+  durationPerTick,
+  highlightedCategory = null,
+  highlightedEvent = null
+}) => {
+  const FIXED_LANE_HEIGHT = 32;
+  const AXIS_COLOR = backgroundColor;
+  const ALTERNATE_COLOR = getAlternateColor(backgroundColor, 0.1);
+  const MIN_BAR_WIDTH = 20;
+  const LANE_SCALE_FACTOR = 0.85;
+  const theme = (0, themes_exports.useSplunkTheme)();
+  let dpr = window.devicePixelRatio || 1;
+  const redrawChart = (u) => {
+    u.redraw();
+  };
+  return {
+    hooks: {
+      drawClear: (u) => {
+        const { ctx } = u;
+        const canvas = u.root.querySelector("canvas");
+        if (canvas) {
+          canvas.style.position = "absolute";
+        }
+        window.addEventListener("resize", () => {
+          const newDpr = window.devicePixelRatio || 1;
+          if (newDpr !== dpr) {
+            dpr = newDpr;
+            redrawChart(u);
+          }
+        });
+        ctx.save();
+        ctx.scale(dpr, dpr);
+        const chartTopY = u.bbox.top / dpr;
+        lanes.forEach((lane, sidx) => {
+          const y = chartTopY + sidx * FIXED_LANE_HEIGHT;
+          ctx.fillStyle = (lanes.length - sidx - 1) % 2 === 0 ? AXIS_COLOR : ALTERNATE_COLOR;
+          ctx.fillRect(u.bbox.left / dpr, y, u.bbox.width / dpr, FIXED_LANE_HEIGHT);
+        });
+        ctx.restore();
+      },
+      draw: (u) => {
+        const { ctx } = u;
+        const widthPerTick = u.bbox.width / dpr / numTicks;
+        const scaleMin = u.scales.x.min;
+        ctx.save();
+        ctx.scale(dpr, dpr);
+        lanes.forEach((lane, sidx) => {
+          const events = laneSeries[sidx];
+          const laneCenterY = u.bbox.top / dpr + sidx * FIXED_LANE_HEIGHT + FIXED_LANE_HEIGHT / 2;
+          events.forEach((event) => {
+            const isHighlighted = highlightedEvent ? highlightedEvent === event : highlightedCategory === null || event.category === highlightedCategory;
+            const fillColor = isHighlighted ? hexToRgba(event.color, 0.5) : hexToRgba(theme.contentColorMuted, 0.2);
+            const strokeColor = isHighlighted ? hexToRgba(event.color, 0.8) : hexToRgba(theme.contentColorMuted, 0.2);
+            const xStartFraction = (event.start - scaleMin) / durationPerTick;
+            const xStart = sidx === 0 ? xStartFraction * widthPerTick + 2 : xStartFraction * widthPerTick;
+            const durationWidth = event.duration / durationPerTick * widthPerTick;
+            const barWidth = Math.max(durationWidth, MIN_BAR_WIDTH);
+            const barHeight = FIXED_LANE_HEIGHT * LANE_SCALE_FACTOR;
+            const yBarTop = laneCenterY - barHeight / 2;
+            if (xStart >= 0) {
+              if (event.duration === null || event.duration === 0) {
+                const circleRadius = barHeight / 2;
+                ctx.beginPath();
+                ctx.arc(xStart, laneCenterY, circleRadius, 0, 2 * Math.PI);
+                ctx.fillStyle = fillColor;
+                ctx.fill();
+                ctx.strokeStyle = strokeColor;
+                ctx.lineWidth = 1;
+                ctx.stroke();
+              } else {
+                ctx.fillStyle = fillColor;
+                ctx.strokeStyle = strokeColor;
+                ctx.lineWidth = 1;
+                drawRoundedRect(ctx, xStart, yBarTop, barWidth, barHeight, 5);
+              }
+            }
+          });
+        });
+        ctx.restore();
+      }
+    }
+  };
+};
+var TimelinePlugin_default = TimelinePlugin;
+
+// src/Timeline/PureTimeline/src/XAxisPlugin.tsx
+var X_AXIS_HEIGHT = 60;
+var XAxisPlugin = ({
+  durationPerTick = 0,
+  numTicks = 0,
+  backgroundColor = "#0b0c0e",
+  tickInterval = "1d"
+} = {}) => {
+  const themes3 = (0, themes_exports.useSplunkTheme)();
+  return {
+    hooks: {
+      drawClear: (u) => {
+        const { ctx } = u;
+        const dpr = window.devicePixelRatio || 1;
+        ctx.save();
+        ctx.scale(dpr, dpr);
+        const xAxisY = (u.bbox.top + u.bbox.height - X_AXIS_HEIGHT * dpr) / dpr;
+        ctx.fillStyle = backgroundColor;
+        ctx.fillRect(0, xAxisY, u.bbox.width / dpr, X_AXIS_HEIGHT);
+        ctx.restore();
+      },
+      draw: (u) => {
+        const { ctx } = u;
+        const dpr = window.devicePixelRatio || 1;
+        const scaleMin = u.scales.x.min;
+        const maxLabelWidth = 50;
+        const ticks = [scaleMin];
+        for (let i = 1; i <= numTicks; i += 1) {
+          ticks.push(scaleMin + i * durationPerTick);
+        }
+        let lastDay = null;
+        let lastYear = null;
+        const labels = ticks.map((tick, index) => {
+          const labelParts = [];
+          const date = new Date(tick);
+          const time = tickInterval === "1s" ? date.toLocaleTimeString([], {
+            hour: "numeric",
+            minute: "2-digit",
+            second: "2-digit"
+          }) : date.toLocaleTimeString([], { hour: "numeric", minute: "2-digit" });
+          const day = date.toLocaleDateString([], {
+            weekday: "short",
+            month: "short",
+            day: "numeric"
+          });
+          const month = date.toLocaleDateString([], {
+            month: "long"
+          });
+          const year = date.getFullYear().toString();
+          if (tickInterval !== "1d" && tickInterval !== "7d" && tickInterval !== "1mo") {
+            labelParts.push(time);
+          }
+          if (tickInterval !== "1mo" && (index === 0 || day !== lastDay)) {
+            labelParts.push(day);
+            lastDay = day;
+          }
+          if (tickInterval === "1mo") {
+            labelParts.push(month);
+          }
+          if (index === 0 || year !== lastYear) {
+            labelParts.push(year);
+            lastYear = year;
+          }
+          return labelParts;
+        });
+        ctx.save();
+        ctx.scale(dpr, dpr);
+        ctx.font = "10px sans-serif";
+        ctx.fillStyle = themes3.contentColorMuted;
+        ctx.textAlign = "left";
+        ctx.textBaseline = "top";
+        const tickHeight = 5;
+        const labelOffset = 5;
+        const lineHeight = 12;
+        const xAxisY = (u.bbox.top + u.bbox.height - X_AXIS_HEIGHT * dpr) / dpr;
+        ticks.forEach((val, i) => {
+          let xTickPosition;
+          if (i === 0) {
+            xTickPosition = 0;
+          } else {
+            xTickPosition = i * (u.bbox.width / dpr / numTicks);
+          }
+          if (i === ticks.length - 1 && xTickPosition + maxLabelWidth > u.bbox.width / dpr) {
+            return;
+          }
+          const yLabelPosition = xAxisY + tickHeight + labelOffset;
+          ctx.beginPath();
+          ctx.moveTo(xTickPosition, xAxisY);
+          ctx.lineTo(xTickPosition, xAxisY + tickHeight);
+          ctx.strokeStyle = "rgba(144, 144, 144, 0.5)";
+          ctx.lineWidth = i === 0 ? 1 * dpr : 0.5 * dpr;
+          ctx.stroke();
+          const label = labels[i];
+          if (label) {
+            label.forEach((line, idx) => {
+              ctx.fillText(line, xTickPosition, yLabelPosition + idx * lineHeight);
+            });
+          }
+        });
+        ctx.restore();
+      }
+    }
+  };
+};
+var XAxisPlugin_default = XAxisPlugin;
+
+// src/Timeline/PureTimeline/src/TimelineYAxis.tsx
+var YAxisContainer = styled_components_default.div`
+    width: ${({ width }) => `${width}px`};
+    height: ${({ height }) => `${height}px`};
+    display: flex;
+    flex-direction: column;
+    align-items: flex-start;
+    flex-shrink: 0;
+    margin-right: -1px;
+    z-index: 100;
+`;
+var YAxisLane = styled_components_default.div`
+    overflow: hidden;
+    white-space: nowrap;
+    height: 32px;
+    padding: 6px 8px;
+    width: 100%;
+    display: flex;
+    align-items: center;
+    justify-content: flex-start;
+    text-align: left;
+    font-size: 14px;
+    border-right: 1px solid
+        ${(0, themes_exports.pick)({
+  enterprise: themes_exports.variables.borderColorWeak,
+  prisma: themes_exports.variables.interactiveColorBackgroundDisabled
+})};
+    background-color: ${({ isEven, backgroundColor }) => isEven ? hexToRgba(backgroundColor) : getAlternateColor(backgroundColor, 0.1)};
+    box-sizing: border-box;
+    color: ${({ color }) => `${color}`};
+`;
+var TimelineYAxis = ({
+  height,
+  lanes,
+  yAxisLabelWidth,
+  laneHeight,
+  backgroundColor,
+  highlightedLane,
+  handleLaneClick
+}) => {
+  const theme = (0, themes_exports.useSplunkTheme)();
+  const lanePadding = 16;
+  return /* @__PURE__ */ react_exports.createElement(YAxisContainer, { "data-test": "timeline-yaxis-container", height, width: yAxisLabelWidth }, lanes.map((lane, index) => {
+    let laneTextColor = theme.contentColorDefault;
+    const isHovering = highlightedLane !== null;
+    const isMuted = highlightedLane !== lane;
+    if (isHovering) {
+      if (isMuted) {
+        laneTextColor = theme.contentColorDisabled;
+      } else {
+        laneTextColor = theme.contentColorActive;
+      }
+    }
+    const truncatedText = truncateText(
+      lane.toString(),
+      yAxisLabelWidth - lanePadding,
+      "ellipsisMiddle",
+      '14px  "Splunk Data Sans"'
+    );
+    return /* @__PURE__ */ react_exports.createElement(
+      YAxisLane,
+      {
+        key: lane,
+        "data-test": "timeline-lane",
+        height: laneHeight,
+        color: laneTextColor,
+        isEven: (lanes.length - index - 1) % 2 === 0,
+        backgroundColor,
+        onClick: () => {
+          handleLaneClick(lane);
+        }
+      },
+      truncatedText
+    );
+  }));
+};
+TimelineYAxis.propTypes = {
+  lanes: prop_types_exports.arrayOf(prop_types_exports.oneOfType([prop_types_exports.string, prop_types_exports.number])).isRequired,
+  yAxisLabelWidth: prop_types_exports.number.isRequired,
+  laneHeight: prop_types_exports.number.isRequired
+};
+var TimelineYAxis_default = TimelineYAxis;
+
+// src/Timeline/PureTimeline/src/TimelineLegend.tsx
+var LEGEND_WIDTH = 92;
+var LEGEND_TEXT_WIDTH = 55;
+var LegendContainer = styled_components_default.div`
+    display: flex;
+    justify-content: center;
+    flex-direction: ${({ legendDisplay }) => legendDisplay === "bottom" ? "row" : "column"};
+    align-items: flex-start;
+    background-color: ${({ backgroundColor }) => backgroundColor};
+    color: #fafafa;
+    font-size: 10px;
+    ${({ legendDisplay, height, width, yAxisLabelWidth }) => legendDisplay === "right" ? `
+                width: ${LEGEND_WIDTH}px;
+                height: ${height}px;
+                margin-top: -30px;
+                margin-left: 10px;
+                margin-right: 12px;
+                overflow-x: hidden;
+            ` : `
+                flex-wrap: wrap;
+                height: 60px;
+                width: ${width}px;
+                margin-left: ${yAxisLabelWidth}px;
+                padding-bottom: 10px;
+            `}
+`;
+var LegendItem = styled_components_default.div`
+    display: flex;
+    align-items: center;
+    margin: ${({ legendDisplay }) => legendDisplay === "bottom" ? "10px 20px 10px 0px" : "4px"};
+    cursor: pointer;
+    opacity: ${({ isHighlighted }) => isHighlighted ? 1 : 0.5};
+    transition: opacity 0.2s ease;
+`;
+var LegendColor = styled_components_default.div`
+    width: 6px;
+    height: 11px;
+    margin-right: ${({ legendDisplay }) => legendDisplay === "bottom" ? "8px" : "4px"};
+    background-color: ${({ color }) => hexToRgba(color, 0.5)};
+    border: 1px solid ${({ color }) => color};
+    transform: ${({ legendDisplay }) => legendDisplay === "bottom" ? "rotate(90deg)" : "none"};
+    opacity: ${({ isHighlighted }) => isHighlighted ? 1 : 0.5};
+`;
+var LegendText = styled_components_default.div`
+    ${({ legendTruncation }) => legendTruncation !== "ellipsisOff" && `
+            white-space: nowrap;
+            overflow: hidden;
+            text-overflow: ellipsis;
+        `}
+    font-size: 10px;
+    color: ${themes_exports.variables.contentColorActive};
+`;
+var TimelineLegend = ({
+  backgroundColor,
+  categoryColors,
+  highlightedCategory = null,
+  setHighlightedCategory,
+  height,
+  width,
+  handleLegendClick,
+  legendDisplay = "right",
+  legendTruncation = "ellipsisEnd",
+  yAxisLabelWidth = 0
+}) => {
+  const handleMouseEnter = (category) => {
+    setHighlightedCategory == null ? void 0 : setHighlightedCategory(category);
+  };
+  const handleMouseLeave = (e) => {
+    if (!e.currentTarget.contains(e.relatedTarget)) {
+      setHighlightedCategory == null ? void 0 : setHighlightedCategory(null);
+    }
+  };
+  return /* @__PURE__ */ react_exports.createElement(
+    LegendContainer,
+    {
+      "data-test": "legend-container",
+      "data-test-position-value": legendDisplay,
+      "data-test-truncation-value": legendTruncation,
+      legendDisplay,
+      backgroundColor,
+      height,
+      width,
+      yAxisLabelWidth
+    },
+    Array.from(categoryColors.entries()).map(([category, color]) => {
+      const isHighlighted = !highlightedCategory || highlightedCategory === category;
+      const truncatedText = legendTruncation === "ellipsisOff" || legendDisplay === "bottom" ? category : truncateText(category, LEGEND_TEXT_WIDTH, legendTruncation);
+      return /* @__PURE__ */ react_exports.createElement(
+        LegendItem,
+        {
+          "data-test": "legend-item",
+          key: category,
+          color,
+          isHighlighted,
+          legendDisplay,
+          onMouseEnter: () => handleMouseEnter(category),
+          onMouseOut: (e) => handleMouseLeave(e),
+          onClick: () => {
+            handleLegendClick(category);
+          }
+        },
+        /* @__PURE__ */ react_exports.createElement(
+          LegendColor,
+          {
+            "data-test": "legend-color",
+            color,
+            isHighlighted,
+            legendDisplay
+          }
+        ),
+        /* @__PURE__ */ react_exports.createElement(LegendText, { legendTruncation, "data-test": "legend-text" }, truncatedText)
+      );
+    })
+  );
+};
+TimelineLegend.propTypes = {
+  backgroundColor: prop_types_exports.string.isRequired,
+  height: prop_types_exports.number.isRequired,
+  legendDisplay: prop_types_exports.oneOf(["right", "bottom"]),
+  legendTruncation: prop_types_exports.oneOf(["ellipsisEnd", "ellipsisMiddle", "ellipsisStart", "ellipsisOff"]),
+  categoryColors: prop_types_exports.any,
+  highlightedCategory: prop_types_exports.string,
+  setHighlightedCategory: prop_types_exports.func
+};
+var TimelineLegend_default = TimelineLegend;
+
+// esm-externals:@splunk/themes/useSplunkTheme
+var useSplunkTheme_exports = {};
+__export(useSplunkTheme_exports, {
+  default: () => useSplunkTheme_default
+});
+var defaultImport32 = __toESM(require("@splunk/themes/useSplunkTheme"));
+__reExport(useSplunkTheme_exports, require("@splunk/themes/useSplunkTheme"));
+var useSplunkTheme_default = "default" in defaultImport32 ? defaultImport32.default : defaultImport32;
+
+// src/Timeline/PureTimeline/src/TimelineTooltip.tsx
+var TooltipContainer = styled_components_default.div`
+    position: absolute;
+    background-color: ${({ backgroundColor }) => `${backgroundColor}`};
+    box-shadow: ${(0, themes_exports.pick)({
+  enterprise: themes_exports.variables.overlayShadow,
+  prisma: themes_exports.variables.overlayShadow
+})};
+    padding: 12px 16px;
+    border-radius: 3px;
+    pointer-events: none;
+    display: ${({ visible }) => visible ? "block" : "none"};
+    white-space: nowrap;
+    left: ${({ x }) => `${x}px`};
+    top: ${({ y, chartOverflow }) => `${chartOverflow ? y : y + 7}px`};
+    transform: ${({ chartOverflow }) => chartOverflow ? "translate(-100%, -50%);" : "translate(-55%, 0);"}
+    transition: left 0.1s ease-out, top 0.1s ease-out;
+    z-index: 1000;
+
+    ::after {
+        content: '';
+        position: absolute;
+        ${({ chartOverflow, backgroundColor }) => chartOverflow ? `
+            top: 50%;
+            left: 100%;
+            transform: translateY(-50%);
+            border-width: 5px;
+            border-style: solid;
+            border-bottom-color: transparent;
+            border-top-color: transparent;
+            border-right-color: transparent;
+            border-left-color: ${backgroundColor};
+        ` : `
+            bottom: 100%;
+            left: 50%;
+            transform: translateX(-50%);
+            border-width: 5px;
+            border-style: solid;
+            border-bottom-color: ${backgroundColor};
+            border-top-color: transparent;
+            border-right-color: transparent;
+            border-left-color: transparent;
+        `}
+    }
+`;
+var TooltipLabel = styled_components_default.div`
+    color: ${(0, themes_exports.pick)({
+  enterprise: themes_exports.variables.contentColorDefault,
+  prisma: themes_exports.variables.contentColorDefault
+})};
+`;
+var TooltipValue = styled_components_default.div`
+    color: ${(0, themes_exports.pick)({
+  enterprise: themes_exports.variables.contentColorActive,
+  prisma: themes_exports.variables.contentColorActive
+})};
+`;
+var TooltipContent = styled_components_default.div`
+    display: flex;
+    flex-direction: row;
+    justify-content: space-between;
+    align-items: center;
+    gap: 16px;
+    font-weight: 400;
+    font-size: 12px;
+    line-height: 16px;
+`;
+var TimelineTooltip = ({ visible, content, x, y, overflow }) => {
+  const theme = useSplunkTheme_default();
+  let popoverBackground = "#33343b";
+  if (theme.isPrisma) {
+    popoverBackground = theme.backgroundColorPopup;
+  } else if (theme.isEnterprise && theme.isLight) {
+    popoverBackground = theme.white;
+  }
+  return /* @__PURE__ */ react_default.createElement(
+    TooltipContainer,
+    {
+      "data-test": "timeline-tooltip",
+      backgroundColor: popoverBackground,
+      visible,
+      x,
+      y,
+      chartOverflow: overflow
+    },
+    Object.entries(content).map(
+      ([key, value]) => value !== void 0 && value !== null && /* @__PURE__ */ react_default.createElement(TooltipContent, { key }, /* @__PURE__ */ react_default.createElement(TooltipLabel, null, key.charAt(0).toUpperCase() + key.slice(1)), /* @__PURE__ */ react_default.createElement(TooltipValue, null, value))
+    )
+  );
+};
+var TimelineTooltip_default = TimelineTooltip;
+
+// esm-externals:uplot/dist/uPlot.min.css
+var uPlot_min_exports = {};
+__export(uPlot_min_exports, {
+  default: () => uPlot_min_default
+});
+var defaultImport33 = __toESM(require("uplot/dist/uPlot.min.css"));
+__reExport(uPlot_min_exports, require("uplot/dist/uPlot.min.css"));
+var uPlot_min_default = "default" in defaultImport33 ? defaultImport33.default : defaultImport33;
+
+// src/Timeline/PureTimeline/src/TimelineUplot.tsx
+var TimelineUplotContainer = styled_components_default.div`
+    display: flex;
+    flex-direction: ${({ legendDisplay }) => legendDisplay === "bottom" ? "column" : "row"};
+    width: 100%;
+    height: 100%;
+    padding: 10px 10px;
+    overflow-y: scroll;
+    overflow-x: hidden;
+`;
+var TimelineUplotWrapper = styled_components_default.div`
+    width: ${({ width }) => `${width}px`};
+    position: relative;
+`;
+var TimelineChartContainer = styled_components_default.div`
+    display: flex;
+    flex-direction: row;
+    width: 100%;
+`;
+var TimelineUplot = ({
+  backgroundColor,
+  width,
+  yAxisLabelWidth,
+  laneSeries,
+  lanes,
+  showLegend = false,
+  legendDisplay,
+  categoryColors,
+  legendTruncation,
+  tickInterval,
+  handleEventClick,
+  handleLaneClick,
+  handleLegendClick
+}) => {
+  const [highlightedCategory, setHighlightedCategory] = react_exports.useState(null);
+  const [highlightedEvent, setHighlightedEvent] = react_exports.useState(null);
+  const [highlightedLane, setHighlightedLane] = react_exports.useState(null);
+  const tooltipRef = react_exports.useRef({
+    visible: false,
+    x: 0,
+    y: 0,
+    overflow: false,
+    content: {},
+    meta: {}
+  });
+  const xMin = Math.min(...laneSeries.flatMap((lane) => lane.map((dp) => dp.start))) || 0;
+  const xMax = Math.max(...laneSeries.flatMap((lane) => lane.map((dp) => dp.end))) || 1;
+  const xAxisHeight = 60;
+  const laneHeight = 32;
+  const padding = 20;
+  const legendWidth = showLegend && legendDisplay === "right" ? 88 : 0;
+  const containerWidth = typeof width === "string" ? window.innerWidth : width;
+  const chartWidth = containerWidth - yAxisLabelWidth - legendWidth - padding;
+  const chartHeight = laneHeight * lanes.length + xAxisHeight;
+  const granularityMultiplier = convertTickIntervalToMs(tickInterval);
+  const totalRange = xMax + granularityMultiplier - xMin;
+  const totalNumberOfTicks = totalRange / granularityMultiplier;
+  const maxNumOfTicks = calculateMaxNumberOfTicks(chartWidth, 50, 10);
+  const unitsPerTick = Math.ceil(totalNumberOfTicks / maxNumOfTicks);
+  const numTicks = totalNumberOfTicks / unitsPerTick;
+  const durationPerTick = granularityMultiplier * unitsPerTick;
+  const opts = {
+    width: chartWidth,
+    height: chartHeight,
+    series: [],
+    axes: [
+      { scale: "x", show: false },
+      { scale: "y", show: false }
+    ],
+    cursor: {
+      x: true,
+      y: false,
+      hover: {
+        prox: 1e3,
+        bias: 0
+      },
+      drag: {
+        setScale: false,
+        x: false,
+        y: false
+      }
+    },
+    padding: [0, 0, 0, 0],
+    legend: { show: false },
+    plugins: [
+      TimelinePlugin_default({
+        laneSeries,
+        lanes,
+        backgroundColor,
+        numTicks,
+        durationPerTick,
+        highlightedCategory,
+        highlightedEvent
+      }),
+      XAxisPlugin_default({ durationPerTick, numTicks, backgroundColor, tickInterval }),
+      CursorPlugin_default({
+        laneSeries,
+        lanes,
+        numTicks,
+        durationPerTick,
+        setHighlightedCategory,
+        setHighlightedEvent,
+        setHighlightedLane,
+        handleEventClick,
+        tooltipRef
+      })
+    ]
+  };
+  return /* @__PURE__ */ react_exports.createElement(TimelineUplotContainer, { legendDisplay }, /* @__PURE__ */ react_exports.createElement(TimelineChartContainer, { "data-test": "timeline-chart-container" }, /* @__PURE__ */ react_exports.createElement(
+    TimelineYAxis_default,
+    {
+      height: chartHeight,
+      laneHeight,
+      lanes,
+      yAxisLabelWidth,
+      backgroundColor,
+      highlightedLane,
+      handleLaneClick
+    }
+  ), /* @__PURE__ */ react_exports.createElement(TimelineUplotWrapper, { width: chartWidth }, /* @__PURE__ */ react_exports.createElement(uplot_react_default, { options: opts, data: [[xMin], ...lanes.map(() => [])] }), /* @__PURE__ */ react_exports.createElement(TimelineTooltip_default, __spreadValues({}, tooltipRef.current)))), showLegend && /* @__PURE__ */ react_exports.createElement(
+    TimelineLegend_default,
+    {
+      height: chartHeight,
+      width: chartWidth,
+      yAxisLabelWidth,
+      backgroundColor,
+      legendDisplay,
+      categoryColors,
+      highlightedCategory,
+      setHighlightedCategory,
+      legendTruncation,
+      handleLegendClick
+    }
+  ));
+};
+var TimelineUplot_default = TimelineUplot;
+
+// src/Timeline/PureTimeline/PureTimeline.tsx
+var TimelineContainer = styled_components_default.div`
+    overflow: hidden;
+    position: relative;
+    background-color: ${(props) => props.backgroundColor};
+    ${(props) => (0, style_exports.toDimension)((0, lodash_exports.pick)(props, ["width", "height"]))};
+`;
+var PureTimeline = (_a) => {
+  var props = __objRest(_a, []);
+  const {
+    x,
+    xField,
+    y,
+    yField,
+    duration,
+    durationField,
+    category,
+    categoryField,
+    width,
+    height,
+    backgroundColor,
+    seriesColors,
+    dataColors,
+    additionalTooltipValues,
+    resultLimit,
+    yAxisLabelWidth,
+    legendDisplay,
+    legendTruncation,
+    onEventClick,
+    onLaneClick,
+    onLegendClick
+  } = props;
+  const showLegend = (!dataColors || (dataColors == null ? void 0 : dataColors.length) === 0) && (category == null ? void 0 : category.length) > 0 && (legendDisplay === "right" || legendDisplay === "bottom");
+  const timezone = react_exports.useContext(TimezoneContext_default);
+  const theme = (0, themes_exports.useSplunkTheme)();
+  const { laneSeries, lanes, categoricalColors, tickInterval } = mapDataToTimeline(
+    resultLimit,
+    x,
+    y,
+    duration,
+    category,
+    dataColors,
+    seriesColors,
+    additionalTooltipValues,
+    timezone
+  );
+  const handleLaneClick = (laneValue) => {
+    onLaneClick({
+      type: "lane.click",
+      payload: {
+        name: yField,
+        value: laneValue
+      }
+    });
+  };
+  const handleLegendClick = (categoryValue) => {
+    onLegendClick({
+      type: "legend.click",
+      payload: {
+        name: categoryField,
+        value: categoryValue
+      }
+    });
+  };
+  const handleEventClick = (xValue, durationValue, laneValue, categoryValue) => {
+    const payload = {
+      name: durationField,
+      value: durationValue,
+      [`row.${xField}.value`]: xValue,
+      [`row.${yField}.value`]: laneValue
+    };
+    if (categoryValue !== void 0 && categoryValue) {
+      payload[`row.${categoryField}.value`] = categoryValue;
+    }
+    onEventClick({
+      type: "event.click",
+      payload
+    });
+  };
+  return /* @__PURE__ */ react_exports.createElement(
+    TimelineContainer,
+    {
+      "data-test": "timeline-container",
+      backgroundColor: backgroundColor || theme.backgroundColorPage,
+      width,
+      height,
+      "data-test-data-colors": JSON.stringify(dataColors)
+    },
+    /* @__PURE__ */ react_exports.createElement(
+      TimelineUplot_default,
+      {
+        backgroundColor: backgroundColor || theme.backgroundColorPage,
+        width,
+        lanes,
+        laneSeries,
+        yAxisLabelWidth,
+        categoryColors: categoricalColors,
+        showLegend,
+        legendDisplay,
+        legendTruncation,
+        tickInterval,
+        handleEventClick,
+        handleLaneClick,
+        handleLegendClick
+      }
+    )
+  );
+};
+PureTimeline.propTypes = {
+  x: prop_types_exports.arrayOf(prop_types_exports.oneOfType([prop_types_exports.string, prop_types_exports.number])),
+  y: prop_types_exports.arrayOf(prop_types_exports.oneOfType([prop_types_exports.string, prop_types_exports.number])),
+  duration: prop_types_exports.arrayOf(prop_types_exports.oneOfType([prop_types_exports.string, prop_types_exports.number])),
+  category: prop_types_exports.arrayOf(prop_types_exports.oneOfType([prop_types_exports.string, prop_types_exports.number])),
+  backgroundColor: prop_types_exports.string,
+  width: prop_types_exports.number,
+  height: prop_types_exports.number,
+  xField: prop_types_exports.string,
+  yField: prop_types_exports.string,
+  durationField: prop_types_exports.string,
+  categoryField: prop_types_exports.string,
+  fields: prop_types_exports.array,
+  columns: prop_types_exports.array,
+  yAxisLabelWidth: prop_types_exports.number,
+  seriesColors: prop_types_exports.oneOfType([prop_types_exports.arrayOf(prop_types_exports.string), prop_types_exports.string]),
+  dataColors: prop_types_exports.oneOfType([prop_types_exports.arrayOf(prop_types_exports.string), prop_types_exports.string]),
+  resultLimit: prop_types_exports.number,
+  legendDisplay: prop_types_exports.oneOf(["right", "bottom", "off"]),
+  legendTruncation: prop_types_exports.oneOf(["ellipsisEnd", "ellipsisMiddle", "ellipsisStart", "ellipsisOff"]),
+  onEventClick: prop_types_exports.func,
+  onLegendClick: prop_types_exports.func,
+  onLaneClick: prop_types_exports.func,
+  onRangeSelect: prop_types_exports.func
+};
+PureTimeline.defaultProps = {
+  backgroundColor: null,
+  width: 850,
+  height: 395,
+  xField: "_time",
+  yField: "lane",
+  durationField: "duration",
+  categoryField: "category",
+  fields: null,
+  columns: [],
+  yAxisLabelWidth: 100,
+  seriesColors: [
+    "#7B56DB",
+    "#009CEB",
+    "#00CDAF",
+    "#DD9900",
+    "#FF677B",
+    "#CB2196",
+    "#813193",
+    "#0051B5",
+    "#008C80",
+    "#99B100",
+    "#FFA476",
+    "#FF6ACE",
+    "#AE8CFF",
+    "#00689D",
+    "#00490A",
+    "#465D00",
+    "#9D6300",
+    "#F6540B",
+    "#FF969E",
+    "#E47BFE"
+  ],
+  dataColors: [],
+  resultLimit: 1e4,
+  legendDisplay: "off",
+  legendTruncation: "ellipsisEnd",
+  onEventClick: lodash_exports.noop,
+  onLaneClick: lodash_exports.noop,
+  onLegendClick: lodash_exports.noop,
+  onRangeSelect: lodash_exports.noop
+};
+var PureTimeline_default = PureTimeline;
+
+// src/Timeline/Timeline.tsx
+var validOptions = Object.keys(visualization_schemas_exports.timelineOptionsSchema);
+var computeVizProps = (_a) => {
+  var props = __objRest(_a, []);
+  var _b, _c, _d, _e;
+  const _a2 = props, {
+    x,
+    y,
+    duration,
+    category,
+    dataSources,
+    dataColors,
+    seriesColors,
+    onEventClick,
+    onLegendClick,
+    onLaneClick
+  } = _a2, otherOptions = __objRest(_a2, [
+    "x",
+    "y",
+    "duration",
+    "category",
+    "dataSources",
+    "dataColors",
+    "seriesColors",
+    "onEventClick",
+    "onLegendClick",
+    "onLaneClick"
+  ]);
+  let timelineDataColors = dataColors;
+  let timelineSeriesColors = seriesColors;
+  const pickedOptions = (0, lodash_exports.chain)(otherOptions).pick(validOptions).value();
+  const columns = ((_c = (_b = dataSources == null ? void 0 : dataSources.primary) == null ? void 0 : _b.data) == null ? void 0 : _c.columns) || [];
+  const fields = ((_e = (_d = dataSources == null ? void 0 : dataSources.primary) == null ? void 0 : _d.data) == null ? void 0 : _e.fields) || [];
+  const additionalTooltipValues = (pickedOptions == null ? void 0 : pickedOptions.additionalTooltipFields) ? extractAdditionalTooltipValues(columns, fields, pickedOptions == null ? void 0 : pickedOptions.additionalTooltipFields) : [];
+  if (seriesColors && typeof seriesColors === "string") {
+    try {
+      timelineSeriesColors = JSON.parse(seriesColors);
+    } catch (e) {
+      timelineSeriesColors = visualization_color_palettes_exports.VIZ_CATEGORICAL;
+    }
+  } else if (!seriesColors) {
+    timelineSeriesColors = visualization_color_palettes_exports.VIZ_CATEGORICAL;
+  } else if (seriesColors && Array.isArray(seriesColors)) {
+    timelineSeriesColors = (0, colorUtils_exports.sanitizeArrayOfColors)(seriesColors);
+  }
+  if (Array.isArray(dataColors) && (dataColors == null ? void 0 : dataColors.length)) {
+    timelineDataColors = (0, colorUtils_exports.sanitizeArrayOfColors)(dataColors);
+  } else if (dataColors && typeof dataColors === "string") {
+    try {
+      timelineDataColors = JSON.parse(dataColors);
+    } catch (e) {
+      timelineDataColors = visualization_color_palettes_exports.VIZ_CATEGORICAL;
+    }
+  }
+  return __spreadValues({
+    x,
+    y,
+    duration,
+    category,
+    additionalTooltipValues,
+    onEventClick,
+    onLegendClick,
+    onLaneClick,
+    dataColors: timelineDataColors,
+    seriesColors: timelineSeriesColors
+  }, pickedOptions);
+};
+function extractAdditionalTooltipValues(columns, fields, additionalTooltipFields) {
+  var _a;
+  const fieldIndexMap = fields.reduce((acc, field, index) => {
+    acc[field.name] = index;
+    return acc;
+  }, {});
+  const additionalTooltipValuesArray = [];
+  const numRows = ((_a = columns[0]) == null ? void 0 : _a.length) || 0;
+  for (let i = 0; i < numRows; i += 1) {
+    const tooltipObject = {};
+    additionalTooltipFields.forEach((field) => {
+      if (field in fieldIndexMap) {
+        const columnIndex = fieldIndexMap[field];
+        tooltipObject[field] = columns[columnIndex][i];
+      } else {
+        tooltipObject[field] = null;
+      }
+    });
+    additionalTooltipValuesArray.push(tooltipObject);
+  }
+  return additionalTooltipValuesArray;
+}
+var Timeline = withDashboardViz_default({
+  ReactViz: PureTimeline_default,
+  computeVizProps,
+  vizConfig: config_default
+});
+var { themes: themes2 } = config_default;
+var config2 = config_default;
+var Timeline_default = Timeline;
+//# sourceMappingURL=Timeline.js.map