@grafana/scenes 6.7.0 → 6.8.0

package/dist/esm/src/variables/components/VariableValueSelect.js

@@ -0,0 +1,228 @@
+import { isArray } from 'lodash';
+import React, { useState, useMemo, useEffect } from 'react';
+import { Select, MultiSelect, useTheme2, getSelectStyles, useStyles2, Checkbox, ToggleAllState } from '@grafana/ui';
+import { selectors } from '@grafana/e2e-selectors';
+import { cx, css } from '@emotion/css';
+import { getOptionSearcher } from './getOptionSearcher.js';
+
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+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;
+};
+const filterNoOp = () => true;
+const filterAll = (v) => v.value !== "$__all";
+const determineToggleAllState = (selectedValues, options) => {
+  if (selectedValues.length === options.filter(filterAll).length) {
+    return ToggleAllState.allSelected;
+  } else if (selectedValues.length === 0 || selectedValues.length === 1 && selectedValues[0] && selectedValues[0].value === "$__all") {
+    return ToggleAllState.noneSelected;
+  } else {
+    return ToggleAllState.indeterminate;
+  }
+};
+function toSelectableValue(value, label) {
+  return {
+    value,
+    label: label != null ? label : String(value)
+  };
+}
+function VariableValueSelect({ model }) {
+  const { value, text, key, options, includeAll, isReadOnly, allowCustomValue = true } = model.useState();
+  const [inputValue, setInputValue] = useState("");
+  const [hasCustomValue, setHasCustomValue] = useState(false);
+  const selectValue = toSelectableValue(value, String(text));
+  const optionSearcher = useMemo(() => getOptionSearcher(options, includeAll), [options, includeAll]);
+  const onInputChange = (value2, { action }) => {
+    if (action === "input-change") {
+      setInputValue(value2);
+      if (model.onSearchChange) {
+        model.onSearchChange(value2);
+      }
+      return value2;
+    }
+    return value2;
+  };
+  const filteredOptions = optionSearcher(inputValue);
+  const onOpenMenu = () => {
+    if (hasCustomValue) {
+      setInputValue(String(text));
+    }
+  };
+  const onCloseMenu = () => {
+    setInputValue("");
+  };
+  return /* @__PURE__ */ React.createElement(Select, {
+    id: key,
+    isValidNewOption: (inputValue2) => inputValue2.trim().length > 0,
+    placeholder: "Select value",
+    width: "auto",
+    disabled: isReadOnly,
+    value: selectValue,
+    inputValue,
+    allowCustomValue,
+    virtualized: true,
+    filterOption: filterNoOp,
+    tabSelectsValue: false,
+    onInputChange,
+    onOpenMenu,
+    onCloseMenu,
+    options: filteredOptions,
+    "data-testid": selectors.pages.Dashboard.SubMenu.submenuItemValueDropDownValueLinkTexts(`${value}`),
+    onChange: (newValue) => {
+      model.changeValueTo(newValue.value, newValue.label);
+      if (hasCustomValue !== newValue.__isNew__) {
+        setHasCustomValue(newValue.__isNew__);
+      }
+    }
+  });
+}
+function VariableValueSelectMulti({ model }) {
+  const {
+    value,
+    options,
+    key,
+    maxVisibleValues,
+    noValueOnClear,
+    includeAll,
+    isReadOnly,
+    allowCustomValue = true
+  } = model.useState();
+  const arrayValue = useMemo(() => isArray(value) ? value : [value], [value]);
+  const [uncommittedValue, setUncommittedValue] = useState(arrayValue);
+  const [inputValue, setInputValue] = useState("");
+  const optionSearcher = useMemo(() => getOptionSearcher(options, includeAll), [options, includeAll]);
+  useEffect(() => {
+    setUncommittedValue(arrayValue);
+  }, [arrayValue]);
+  const onInputChange = (value2, { action }) => {
+    if (action === "input-change") {
+      setInputValue(value2);
+      if (model.onSearchChange) {
+        model.onSearchChange(value2);
+      }
+      return value2;
+    }
+    if (action === "input-blur") {
+      setInputValue("");
+      return "";
+    }
+    return inputValue;
+  };
+  const placeholder = options.length > 0 ? "Select value" : "";
+  const filteredOptions = optionSearcher(inputValue);
+  return /* @__PURE__ */ React.createElement(MultiSelect, {
+    id: key,
+    placeholder,
+    width: "auto",
+    inputValue,
+    disabled: isReadOnly,
+    value: uncommittedValue,
+    noMultiValueWrap: true,
+    maxVisibleValues: maxVisibleValues != null ? maxVisibleValues : 5,
+    tabSelectsValue: false,
+    virtualized: true,
+    allowCustomValue,
+    toggleAllOptions: {
+      enabled: true,
+      optionsFilter: filterAll,
+      determineToggleAllState
+    },
+    options: filteredOptions,
+    closeMenuOnSelect: false,
+    components: { Option: OptionWithCheckbox },
+    isClearable: true,
+    hideSelectedOptions: false,
+    onInputChange,
+    onBlur: () => {
+      model.changeValueTo(uncommittedValue);
+    },
+    filterOption: filterNoOp,
+    "data-testid": selectors.pages.Dashboard.SubMenu.submenuItemValueDropDownValueLinkTexts(`${uncommittedValue}`),
+    onChange: (newValue, action) => {
+      if (action.action === "clear" && noValueOnClear) {
+        model.changeValueTo([]);
+      }
+      setUncommittedValue(newValue.map((x) => x.value));
+    }
+  });
+}
+const OptionWithCheckbox = ({
+  children,
+  data,
+  innerProps,
+  innerRef,
+  isFocused,
+  isSelected,
+  indeterminate,
+  renderOptionLabel
+}) => {
+  var _b;
+  const _a = innerProps, rest = __objRest(_a, ["onMouseMove", "onMouseOver"]);
+  const theme = useTheme2();
+  const selectStyles = getSelectStyles(theme);
+  const optionStyles = useStyles2(getOptionStyles);
+  return /* @__PURE__ */ React.createElement("div", __spreadProps(__spreadValues({
+    ref: innerRef,
+    className: cx(selectStyles.option, isFocused && selectStyles.optionFocused)
+  }, rest), {
+    "data-testid": "data-testid Select option",
+    title: data.title
+  }), /* @__PURE__ */ React.createElement("div", {
+    className: optionStyles.checkbox
+  }, /* @__PURE__ */ React.createElement(Checkbox, {
+    indeterminate,
+    value: isSelected
+  })), /* @__PURE__ */ React.createElement("div", {
+    className: selectStyles.optionBody,
+    "data-testid": selectors.pages.Dashboard.SubMenu.submenuItemValueDropDownOptionTexts(
+      (_b = data.label) != null ? _b : String(data.value)
+    )
+  }, /* @__PURE__ */ React.createElement("span", null, children)));
+};
+OptionWithCheckbox.displayName = "SelectMenuOptions";
+const getOptionStyles = (theme) => ({
+  checkbox: css({
+    marginRight: theme.spacing(2)
+  })
+});
+function renderSelectForVariable(model) {
+  if (model.state.isMulti) {
+    return /* @__PURE__ */ React.createElement(VariableValueSelectMulti, {
+      model
+    });
+  } else {
+    return /* @__PURE__ */ React.createElement(VariableValueSelect, {
+      model
+    });
+  }
+}
+
+export { OptionWithCheckbox, VariableValueSelect, VariableValueSelectMulti, renderSelectForVariable, toSelectableValue };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"VariableValueSelect.js","sources":["../../../../../src/variables/components/VariableValueSelect.tsx"],"sourcesContent":["import { isArray } from 'lodash';\nimport React, { RefCallback, useEffect, useMemo, useState } from 'react';\nimport {\n  Checkbox,\n  InputActionMeta,\n  MultiSelect,\n  Select,\n  ToggleAllState,\n  getSelectStyles,\n  useStyles2,\n  useTheme2,\n} from '@grafana/ui';\n\nimport { SceneComponentProps } from '../../core/types';\nimport { MultiValueVariable } from '../variants/MultiValueVariable';\nimport { VariableValue, VariableValueSingle } from '../types';\nimport { selectors } from '@grafana/e2e-selectors';\nimport { GrafanaTheme2, SelectableValue } from '@grafana/data';\nimport { css, cx } from '@emotion/css';\nimport { getOptionSearcher } from './getOptionSearcher';\n\nconst filterNoOp = () => true;\n\nconst filterAll = (v: SelectableValue<VariableValueSingle>) => v.value !== '$__all';\n\nconst determineToggleAllState = (\n  selectedValues: Array<SelectableValue<VariableValueSingle>>,\n  options: Array<SelectableValue<VariableValueSingle>>\n) => {\n  if (selectedValues.length === options.filter(filterAll).length) {\n    return ToggleAllState.allSelected;\n  } else if (\n    selectedValues.length === 0 ||\n    (selectedValues.length === 1 && selectedValues[0] && selectedValues[0].value === '$__all')\n  ) {\n    return ToggleAllState.noneSelected;\n  } else {\n    return ToggleAllState.indeterminate;\n  }\n};\n\nexport function toSelectableValue<T>(value: T, label?: string): SelectableValue<T> {\n  return {\n    value,\n    label: label ?? String(value),\n  };\n}\n\nexport function VariableValueSelect({ model }: SceneComponentProps<MultiValueVariable>) {\n  const { value, text, key, options, includeAll, isReadOnly, allowCustomValue = true } = model.useState();\n  const [inputValue, setInputValue] = useState('');\n  const [hasCustomValue, setHasCustomValue] = useState(false);\n  const selectValue = toSelectableValue(value, String(text));\n\n  const optionSearcher = useMemo(() => getOptionSearcher(options, includeAll), [options, includeAll]);\n\n  const onInputChange = (value: string, { action }: InputActionMeta) => {\n    if (action === 'input-change') {\n      setInputValue(value);\n      if (model.onSearchChange) {\n        model.onSearchChange!(value);\n      }\n      return value;\n    }\n\n    return value;\n  };\n\n  const filteredOptions = optionSearcher(inputValue);\n\n  const onOpenMenu = () => {\n    if (hasCustomValue) {\n      setInputValue(String(text));\n    }\n  };\n\n  const onCloseMenu = () => {\n    setInputValue('');\n  };\n\n  return (\n    <Select<VariableValue>\n      id={key}\n      isValidNewOption={(inputValue) => inputValue.trim().length > 0}\n      placeholder=\"Select value\"\n      width=\"auto\"\n      disabled={isReadOnly}\n      value={selectValue}\n      inputValue={inputValue}\n      allowCustomValue={allowCustomValue}\n      virtualized\n      filterOption={filterNoOp}\n      tabSelectsValue={false}\n      onInputChange={onInputChange}\n      onOpenMenu={onOpenMenu}\n      onCloseMenu={onCloseMenu}\n      options={filteredOptions}\n      data-testid={selectors.pages.Dashboard.SubMenu.submenuItemValueDropDownValueLinkTexts(`${value}`)}\n      onChange={(newValue) => {\n        model.changeValueTo(newValue.value!, newValue.label!);\n\n        if (hasCustomValue !== newValue.__isNew__) {\n          setHasCustomValue(newValue.__isNew__);\n        }\n      }}\n    />\n  );\n}\n\nexport function VariableValueSelectMulti({ model }: SceneComponentProps<MultiValueVariable>) {\n  const {\n    value,\n    options,\n    key,\n    maxVisibleValues,\n    noValueOnClear,\n    includeAll,\n    isReadOnly,\n    allowCustomValue = true,\n  } = model.useState();\n  const arrayValue = useMemo(() => (isArray(value) ? value : [value]), [value]);\n  // To not trigger queries on every selection we store this state locally here and only update the variable onBlur\n  const [uncommittedValue, setUncommittedValue] = useState(arrayValue);\n  const [inputValue, setInputValue] = useState('');\n\n  const optionSearcher = useMemo(() => getOptionSearcher(options, includeAll), [options, includeAll]);\n\n  // Detect value changes outside\n  useEffect(() => {\n    setUncommittedValue(arrayValue);\n  }, [arrayValue]);\n\n  const onInputChange = (value: string, { action }: InputActionMeta) => {\n    if (action === 'input-change') {\n      setInputValue(value);\n      if (model.onSearchChange) {\n        model.onSearchChange!(value);\n      }\n      return value;\n    }\n\n    if (action === 'input-blur') {\n      setInputValue('');\n      return '';\n    }\n\n    return inputValue;\n  };\n\n  const placeholder = options.length > 0 ? 'Select value' : '';\n  const filteredOptions = optionSearcher(inputValue);\n\n  return (\n    <MultiSelect<VariableValueSingle>\n      id={key}\n      placeholder={placeholder}\n      width=\"auto\"\n      inputValue={inputValue}\n      disabled={isReadOnly}\n      value={uncommittedValue}\n      noMultiValueWrap={true}\n      maxVisibleValues={maxVisibleValues ?? 5}\n      tabSelectsValue={false}\n      virtualized\n      allowCustomValue={allowCustomValue}\n      //@ts-ignore\n      toggleAllOptions={{\n        enabled: true,\n        optionsFilter: filterAll,\n        determineToggleAllState: determineToggleAllState,\n      }}\n      options={filteredOptions}\n      closeMenuOnSelect={false}\n      components={{ Option: OptionWithCheckbox }}\n      isClearable={true}\n      hideSelectedOptions={false}\n      onInputChange={onInputChange}\n      onBlur={() => {\n        model.changeValueTo(uncommittedValue);\n      }}\n      filterOption={filterNoOp}\n      data-testid={selectors.pages.Dashboard.SubMenu.submenuItemValueDropDownValueLinkTexts(`${uncommittedValue}`)}\n      onChange={(newValue, action) => {\n        if (action.action === 'clear' && noValueOnClear) {\n          model.changeValueTo([]);\n        }\n        setUncommittedValue(newValue.map((x) => x.value!));\n      }}\n    />\n  );\n}\n\ninterface SelectMenuOptionProps<T> {\n  isDisabled: boolean;\n  isFocused: boolean;\n  isSelected: boolean;\n  innerProps: JSX.IntrinsicElements['div'];\n  innerRef: RefCallback<HTMLDivElement>;\n  renderOptionLabel?: (value: SelectableValue<T>) => JSX.Element;\n  data: SelectableValue<T>;\n  indeterminate: boolean;\n}\n\nexport const OptionWithCheckbox = ({\n  children,\n  data,\n  innerProps,\n  innerRef,\n  isFocused,\n  isSelected,\n  indeterminate,\n  renderOptionLabel,\n}: React.PropsWithChildren<SelectMenuOptionProps<unknown>>) => {\n  // We are removing onMouseMove and onMouseOver from innerProps because they cause the whole\n  // list to re-render everytime the user hovers over an option. This is a performance issue.\n  // See https://github.com/JedWatson/react-select/issues/3128#issuecomment-451936743\n  const { onMouseMove, onMouseOver, ...rest } = innerProps;\n  const theme = useTheme2();\n  const selectStyles = getSelectStyles(theme);\n  const optionStyles = useStyles2(getOptionStyles);\n\n  return (\n    <div\n      ref={innerRef}\n      className={cx(selectStyles.option, isFocused && selectStyles.optionFocused)}\n      {...rest}\n      // TODO: use below selector once we update grafana dependencies to ^11.1.0\n      // data-testid={selectors.components.Select.option}\n      data-testid=\"data-testid Select option\"\n      title={data.title}\n    >\n      <div className={optionStyles.checkbox}>\n        <Checkbox indeterminate={indeterminate} value={isSelected} />\n      </div>\n      <div\n        className={selectStyles.optionBody}\n        data-testid={selectors.pages.Dashboard.SubMenu.submenuItemValueDropDownOptionTexts(\n          data.label ?? String(data.value)\n        )}\n      >\n        <span>{children}</span>\n      </div>\n    </div>\n  );\n};\n\nOptionWithCheckbox.displayName = 'SelectMenuOptions';\n\nconst getOptionStyles = (theme: GrafanaTheme2) => ({\n  checkbox: css({\n    marginRight: theme.spacing(2),\n  }),\n});\n\nexport function renderSelectForVariable(model: MultiValueVariable) {\n  if (model.state.isMulti) {\n    return <VariableValueSelectMulti model={model} />;\n  } else {\n    return <VariableValueSelect model={model} />;\n  }\n}\n"],"names":["value","inputValue"],"mappings":"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"}

package/dist/esm/src/variables/components/VariableValueSelectors.js

@@ -0,0 +1,72 @@
+import React from 'react';
+import { VariableHide } from '@grafana/data';
+import { SceneObjectBase, useSceneObjectState } from '../../core/SceneObjectBase.js';
+import { sceneGraph } from '../../core/sceneGraph/index.js';
+import { ControlsLabel } from '../../utils/ControlsLabel.js';
+import { css } from '@emotion/css';
+import { selectors } from '@grafana/e2e-selectors';
+
+class VariableValueSelectors extends SceneObjectBase {
+}
+VariableValueSelectors.Component = VariableValueSelectorsRenderer;
+function VariableValueSelectorsRenderer({ model }) {
+  const variables = sceneGraph.getVariables(model).useState();
+  return /* @__PURE__ */ React.createElement(React.Fragment, null, variables.variables.map((variable) => /* @__PURE__ */ React.createElement(VariableValueSelectWrapper, {
+    key: variable.state.key,
+    variable,
+    layout: model.state.layout
+  })));
+}
+function VariableValueSelectWrapper({ variable, layout, showAlways, hideLabel }) {
+  const state = useSceneObjectState(variable, { shouldActivateOrKeepAlive: true });
+  if (state.hide === VariableHide.hideVariable && !showAlways) {
+    return null;
+  }
+  if (layout === "vertical") {
+    return /* @__PURE__ */ React.createElement("div", {
+      className: verticalContainer,
+      "data-testid": selectors.pages.Dashboard.SubMenu.submenuItem
+    }, /* @__PURE__ */ React.createElement(VariableLabel, {
+      variable,
+      layout,
+      hideLabel
+    }), /* @__PURE__ */ React.createElement(variable.Component, {
+      model: variable
+    }));
+  }
+  return /* @__PURE__ */ React.createElement("div", {
+    className: containerStyle,
+    "data-testid": selectors.pages.Dashboard.SubMenu.submenuItem
+  }, /* @__PURE__ */ React.createElement(VariableLabel, {
+    variable,
+    hideLabel
+  }), /* @__PURE__ */ React.createElement(variable.Component, {
+    model: variable
+  }));
+}
+function VariableLabel({ variable, layout, hideLabel }) {
+  var _a;
+  const { state } = variable;
+  if (variable.state.hide === VariableHide.hideLabel || hideLabel) {
+    return null;
+  }
+  const elementId = `var-${state.key}`;
+  const labelOrName = state.label || state.name;
+  return /* @__PURE__ */ React.createElement(ControlsLabel, {
+    htmlFor: elementId,
+    isLoading: state.loading,
+    onCancel: () => {
+      var _a2;
+      return (_a2 = variable.onCancel) == null ? void 0 : _a2.call(variable);
+    },
+    label: labelOrName,
+    error: state.error,
+    layout,
+    description: (_a = state.description) != null ? _a : void 0
+  });
+}
+const containerStyle = css({ display: "flex" });
+const verticalContainer = css({ display: "flex", flexDirection: "column" });
+
+export { VariableValueSelectWrapper, VariableValueSelectors };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/esm/src/variables/components/getOptionSearcher.js

@@ -0,0 +1,15 @@
+import { ALL_VARIABLE_VALUE, ALL_VARIABLE_TEXT } from '../constants.js';
+import { getFuzzySearcher } from '../utils.js';
+
+function getOptionSearcher(options, includeAll = false) {
+  let allOptions = options;
+  if (includeAll) {
+    allOptions = [{ value: ALL_VARIABLE_VALUE, label: ALL_VARIABLE_TEXT }, ...allOptions];
+  }
+  const haystack = allOptions.map((o) => o.label);
+  const fuzzySearch = getFuzzySearcher(haystack);
+  return (search) => fuzzySearch(search).map((i) => allOptions[i]);
+}
+
+export { getOptionSearcher };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2V0T3B0aW9uU2VhcmNoZXIuanMiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3NyYy92YXJpYWJsZXMvY29tcG9uZW50cy9nZXRPcHRpb25TZWFyY2hlci50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBWYXJpYWJsZVZhbHVlT3B0aW9uIH0gZnJvbSAnLi4vdHlwZXMnO1xuaW1wb3J0IHsgQUxMX1ZBUklBQkxFX1RFWFQsIEFMTF9WQVJJQUJMRV9WQUxVRSB9IGZyb20gJy4uL2NvbnN0YW50cyc7XG5pbXBvcnQgeyBnZXRGdXp6eVNlYXJjaGVyIH0gZnJvbSAnLi4vdXRpbHMnO1xuXG5leHBvcnQgZnVuY3Rpb24gZ2V0T3B0aW9uU2VhcmNoZXIob3B0aW9uczogVmFyaWFibGVWYWx1ZU9wdGlvbltdLCBpbmNsdWRlQWxsID0gZmFsc2UpIHtcbiAgbGV0IGFsbE9wdGlvbnMgPSBvcHRpb25zO1xuXG4gIGlmIChpbmNsdWRlQWxsKSB7XG4gICAgYWxsT3B0aW9ucyA9IFt7IHZhbHVlOiBBTExfVkFSSUFCTEVfVkFMVUUsIGxhYmVsOiBBTExfVkFSSUFCTEVfVEVYVCB9LCAuLi5hbGxPcHRpb25zXTtcbiAgfVxuXG4gIGNvbnN0IGhheXN0YWNrID0gYWxsT3B0aW9ucy5tYXAoKG8pID0+IG8ubGFiZWwpO1xuICBjb25zdCBmdXp6eVNlYXJjaCA9IGdldEZ1enp5U2VhcmNoZXIoaGF5c3RhY2spO1xuXG4gIHJldHVybiAoc2VhcmNoOiBzdHJpbmcpID0+IGZ1enp5U2VhcmNoKHNlYXJjaCkubWFwKChpKSA9PiBhbGxPcHRpb25zW2ldKTtcbn1cbiJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFJZ0IsU0FBQSxpQkFBQSxDQUFrQixPQUFnQyxFQUFBLFVBQUEsR0FBYSxLQUFPLEVBQUE7QUFDcEYsRUFBQSxJQUFJLFVBQWEsR0FBQSxPQUFBLENBQUE7QUFFakIsRUFBQSxJQUFJLFVBQVksRUFBQTtBQUNkLElBQWEsVUFBQSxHQUFBLENBQUMsRUFBRSxLQUFPLEVBQUEsa0JBQUEsRUFBb0IsT0FBTyxpQkFBa0IsRUFBQSxFQUFHLEdBQUcsVUFBVSxDQUFBLENBQUE7QUFBQSxHQUN0RjtBQUVBLEVBQUEsTUFBTSxXQUFXLFVBQVcsQ0FBQSxHQUFBLENBQUksQ0FBQyxDQUFBLEtBQU0sRUFBRSxLQUFLLENBQUEsQ0FBQTtBQUM5QyxFQUFNLE1BQUEsV0FBQSxHQUFjLGlCQUFpQixRQUFRLENBQUEsQ0FBQTtBQUU3QyxFQUFPLE9BQUEsQ0FBQyxXQUFtQixXQUFZLENBQUEsTUFBTSxFQUFFLEdBQUksQ0FBQSxDQUFDLENBQU0sS0FBQSxVQUFBLENBQVcsQ0FBRSxDQUFBLENBQUEsQ0FBQTtBQUN6RTs7OzsifQ==

package/dist/esm/src/variables/constants.js

@@ -0,0 +1,9 @@
+const ALL_VARIABLE_TEXT = "All";
+const ALL_VARIABLE_VALUE = "$__all";
+const AUTO_VARIABLE_TEXT = "Auto";
+const AUTO_VARIABLE_VALUE = "$__auto";
+const VARIABLE_REGEX = /\$(\w+)|\[\[(\w+?)(?::(\w+))?\]\]|\${(\w+)(?:\.([^:^\}]+))?(?::([^\}]+))?}/g;
+const SEARCH_FILTER_VARIABLE = "__searchFilter";
+
+export { ALL_VARIABLE_TEXT, ALL_VARIABLE_VALUE, AUTO_VARIABLE_TEXT, AUTO_VARIABLE_VALUE, SEARCH_FILTER_VARIABLE, VARIABLE_REGEX };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uc3RhbnRzLmpzIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvdmFyaWFibGVzL2NvbnN0YW50cy50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgY29uc3QgQUxMX1ZBUklBQkxFX1RFWFQgPSAnQWxsJztcbmV4cG9ydCBjb25zdCBBTExfVkFSSUFCTEVfVkFMVUUgPSAnJF9fYWxsJztcbmV4cG9ydCBjb25zdCBOT05FX1ZBUklBQkxFX1RFWFQgPSAnTm9uZSc7XG5leHBvcnQgY29uc3QgTk9ORV9WQVJJQUJMRV9WQUxVRSA9ICcnO1xuZXhwb3J0IGNvbnN0IEFVVE9fVkFSSUFCTEVfVEVYVCA9ICdBdXRvJztcbmV4cG9ydCBjb25zdCBBVVRPX1ZBUklBQkxFX1ZBTFVFID0gJyRfX2F1dG8nO1xuXG4vLyBHcmFmYW5hIGNvcmUgc291cmNlOiBodHRwczovL2dpdGh1Yi5jb20vZ3JhZmFuYS9ncmFmYW5hL2Jsb2IvbWFpbi9wdWJsaWMvYXBwL2ZlYXR1cmVzL3ZhcmlhYmxlcy91dGlscy50cyNMMjNcbi8qXG4gKiBUaGlzIHJlZ2V4IG1hdGNoZXMgMyB0eXBlcyBvZiB2YXJpYWJsZSByZWZlcmVuY2Ugd2l0aCBhbiBvcHRpb25hbCBmb3JtYXQgc3BlY2lmaWVyXG4gKiBcXCQoXFx3KykgICAgICAgICAgICAgICAgICAgICAgICAgICR2YXIxXG4gKiBcXFtcXFsoXFx3Kz8pKD86OihcXHcrKSk/XFxdXFxdICAgICAgICBbW3ZhcjJdXSBvciBbW3ZhcjI6Zm10Ml1dXG4gKiBcXCR7KFxcdyspKD86OihcXHcrKSk/fSAgICAgICAgICAgICAke3ZhcjN9IG9yICR7dmFyMzpmbXQzfVxuICovXG5leHBvcnQgY29uc3QgVkFSSUFCTEVfUkVHRVggPSAvXFwkKFxcdyspfFxcW1xcWyhcXHcrPykoPzo6KFxcdyspKT9cXF1cXF18XFwkeyhcXHcrKSg/OlxcLihbXjpeXFx9XSspKT8oPzo6KFteXFx9XSspKT99L2c7XG5leHBvcnQgY29uc3QgU0VBUkNIX0ZJTFRFUl9WQVJJQUJMRSA9ICdfX3NlYXJjaEZpbHRlcic7XG4iXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQU8sTUFBTSxpQkFBb0IsR0FBQSxNQUFBO0FBQzFCLE1BQU0sa0JBQXFCLEdBQUEsU0FBQTtBQUczQixNQUFNLGtCQUFxQixHQUFBLE9BQUE7QUFDM0IsTUFBTSxtQkFBc0IsR0FBQSxVQUFBO0FBUzVCLE1BQU0sY0FBaUIsR0FBQSw4RUFBQTtBQUN2QixNQUFNLHNCQUF5QixHQUFBOzs7OyJ9

package/dist/esm/src/variables/getEnrichedFiltersRequest.js

@@ -0,0 +1,12 @@
+import { isFiltersRequestEnricher } from '../core/types.js';
+
+function getEnrichedFiltersRequest(sourceRunner) {
+  const root = sourceRunner.getRoot();
+  if (isFiltersRequestEnricher(root)) {
+    return root.enrichFiltersRequest(sourceRunner);
+  }
+  return null;
+}
+
+export { getEnrichedFiltersRequest };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2V0RW5yaWNoZWRGaWx0ZXJzUmVxdWVzdC5qcyIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL3ZhcmlhYmxlcy9nZXRFbnJpY2hlZEZpbHRlcnNSZXF1ZXN0LnRzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IERhdGFTb3VyY2VHZXRUYWdLZXlzT3B0aW9ucywgRGF0YVNvdXJjZUdldFRhZ1ZhbHVlc09wdGlvbnMgfSBmcm9tICdAZ3JhZmFuYS9kYXRhJztcbmltcG9ydCB7IGlzRmlsdGVyc1JlcXVlc3RFbnJpY2hlciwgU2NlbmVPYmplY3QgfSBmcm9tICcuLi9jb3JlL3R5cGVzJztcblxuZXhwb3J0IGZ1bmN0aW9uIGdldEVucmljaGVkRmlsdGVyc1JlcXVlc3QoXG4gIHNvdXJjZVJ1bm5lcjogU2NlbmVPYmplY3Rcbik6IFBhcnRpYWw8RGF0YVNvdXJjZUdldFRhZ0tleXNPcHRpb25zIHwgRGF0YVNvdXJjZUdldFRhZ1ZhbHVlc09wdGlvbnM+IHwgbnVsbCB7XG4gIGNvbnN0IHJvb3QgPSBzb3VyY2VSdW5uZXIuZ2V0Um9vdCgpO1xuXG4gIGlmIChpc0ZpbHRlcnNSZXF1ZXN0RW5yaWNoZXIocm9vdCkpIHtcbiAgICByZXR1cm4gcm9vdC5lbnJpY2hGaWx0ZXJzUmVxdWVzdChzb3VyY2VSdW5uZXIpO1xuICB9XG5cbiAgcmV0dXJuIG51bGw7XG59XG4iXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUFHTyxTQUFTLDBCQUNkLFlBQzZFLEVBQUE7QUFDN0UsRUFBTSxNQUFBLElBQUEsR0FBTyxhQUFhLE9BQVEsRUFBQSxDQUFBO0FBRWxDLEVBQUksSUFBQSx3QkFBQSxDQUF5QixJQUFJLENBQUcsRUFBQTtBQUNsQyxJQUFPLE9BQUEsSUFBQSxDQUFLLHFCQUFxQixZQUFZLENBQUEsQ0FBQTtBQUFBLEdBQy9DO0FBRUEsRUFBTyxPQUFBLElBQUEsQ0FBQTtBQUNUOzs7OyJ9