@useinsider/guido 2.0.0-beta.143201d → 2.0.0-beta.1c331b8

package/dist/extensions/Blocks/Recommendation/controls/cardComposition/index.js

@@ -0,0 +1,238 @@
+var C = Object.defineProperty;
+var f = (a, s, t) => s in a ? C(a, s, { enumerable: !0, configurable: !0, writable: !0, value: t }) : a[s] = t;
+var c = (a, s, t) => f(a, typeof s != "symbol" ? s + "" : s, t);
+import { ModificationDescription as d } from "../../../../../node_modules/@stripoinc/ui-editor-extensions/dist/esm/index.js";
+import { CommonControl as O } from "../../../common-control.js";
+import { ATTR_PRODUCT_IMAGE as g, ATTR_PRODUCT_NAME as R, ATTR_PRODUCT_PRICE as A, ATTR_PRODUCT_OLD_PRICE as N, ATTR_PRODUCT_OMNIBUS_PRICE as D, ATTR_PRODUCT_OMNIBUS_DISCOUNT as E, ATTR_PRODUCT_BUTTON as I } from "../../constants/selectors.js";
+import { useRecommendationExtensionStore as V } from "../../store/recommendation.js";
+import { getCurrentLayout as P } from "../main/utils.js";
+const S = "ui-elements-recommendation-card-composition", k = {
+  ORDERABLE: "cardComposition"
+}, b = ".recommendation-attribute-row", v = ".product-card-wrapper > tbody", T = "data-card-composition", p = "data-attribute-type", y = "data-visibility", n = [
+  { key: g, label: "Product Image", visible: !0 },
+  { key: R, label: "Product Name", visible: !0 },
+  { key: A, label: "Product Price", visible: !0 },
+  { key: N, label: "Product Original Price", visible: !0 },
+  { key: D, label: "Omnibus Price", visible: !1 },
+  { key: E, label: "Omnibus Discount", visible: !1 },
+  { key: I, label: "Product Button", visible: !0 }
+];
+class q extends O {
+  constructor() {
+    super(...arguments);
+    c(this, "store", V());
+    c(this, "unsubscribeOrientation", null);
+  }
+  getId() {
+    return S;
+  }
+  getTemplate() {
+    const t = n.map((e) => ({
+      key: e.key,
+      label: e.label,
+      content: this._createItemContent(e.label, e.key)
+    }));
+    return `
+            <div class="container" data-card-composition-control>
+                ${this._GuLabel({ text: "Card Element Order & Visibility" })}
+                ${this._GuOrderable(k.ORDERABLE, t)}
+            </div>
+        `;
+  }
+  onRender() {
+    this._initializeComposition(), this._registerValueChangeListeners(), this._updateOrderableState(), this._subscribeToOrientationChanges();
+  }
+  onTemplateNodeUpdated(t) {
+    super.onTemplateNodeUpdated(t), this._initializeComposition(), this._updateOrderableState();
+  }
+  /**
+   * Creates the HTML content for an orderable item with label and toggle
+   */
+  _createItemContent(t, e) {
+    return `
+            <div style="display: flex; align-items: center; justify-content: space-between;
+                padding: 8px; gap: 8px;">
+                <span style="flex: 1;">${t}</span>
+                ${this._GuToggle(`visibility_${e}`)}
+            </div>
+        `;
+  }
+  /**
+   * Registers event listeners for composition and visibility changes
+   */
+  _registerValueChangeListeners() {
+    this.api.onValueChanged("cardComposition", (t) => {
+      this._applyCompositionToBlock(t);
+    }), n.forEach((t) => {
+      this.api.onValueChanged(`visibility_${t.key}`, (e) => {
+        this._applyVisibilityToBlock(t.key, e);
+      });
+    });
+  }
+  /**
+   * Initializes composition order and visibility state from the current node
+   */
+  _initializeComposition() {
+    const t = this._readCompositionFromNode(), e = this._readVisibilityFromRows(), i = {
+      cardComposition: t,
+      ...this._buildVisibilityValues(e)
+    };
+    this.api.updateValues(i);
+  }
+  /**
+   * Reads composition order from node's data-card-composition attribute
+   * Falls back to default order if attribute is not present
+   */
+  _readCompositionFromNode() {
+    if (!this.currentNode || !("getAttribute" in this.currentNode))
+      return n.map((e) => e.key);
+    const t = this.currentNode.getAttribute(T);
+    return t ? t.split(",").filter(Boolean) : n.map((e) => e.key);
+  }
+  /**
+   * Builds visibility values object from the visibility map
+   */
+  _buildVisibilityValues(t) {
+    return n.reduce((e, i) => (e[`visibility_${i.key}`] = t[i.key] ?? !0, e), {});
+  }
+  /**
+   * Read visibility state from individual row elements' data-visibility attributes
+   * This ensures toggles reflect the actual DOM state
+   */
+  _readVisibilityFromRows() {
+    if (!this.currentNode)
+      return this._getDefaultVisibilities();
+    const t = Array.from(this.currentNode.querySelectorAll(b)), e = this._extractVisibilityFromRows(t);
+    return this._mergeWithDefaults(e);
+  }
+  /**
+   * Returns default visibility values for all items
+   */
+  _getDefaultVisibilities() {
+    return n.reduce((t, e) => (t[e.key] = e.visible, t), {});
+  }
+  /**
+   * Extracts visibility values from DOM nodes
+   */
+  _extractVisibilityFromRows(t) {
+    const e = {};
+    return t.forEach((i) => {
+      if (!("getAttribute" in i))
+        return;
+      const r = i.getAttribute(p), o = i.getAttribute(y);
+      r && o !== null && (e[r] = this._parseVisibilityValue(o));
+    }), e;
+  }
+  /**
+   * Parses visibility value from string to boolean
+   * Accepts "1", "true" as true, everything else as false
+   */
+  _parseVisibilityValue(t) {
+    return t === "1" || t === "true";
+  }
+  /**
+   * Merges extracted visibilities with default values for missing keys
+   */
+  _mergeWithDefaults(t) {
+    return n.forEach((e) => {
+      e.key in t || (t[e.key] = e.visible);
+    }), t;
+  }
+  /**
+   * Apply the reordered composition to the block's HTML structure
+   * Updates the data-card-composition attribute and reorders product attributes
+   * Note: Reordering is only applied for vertical layout
+   */
+  _applyCompositionToBlock(t) {
+    if (!this.currentNode)
+      return;
+    const e = this._getCurrentLayout();
+    this.api.getDocumentModifier().modifyHtml(this.currentNode).setAttribute(T, t.join(",")).apply(new d("Update card composition")), e === "vertical" && this._reorderProductAttributes(t);
+  }
+  /**
+   * Reorders attribute rows within each product card based on composition order
+   * Targets the tbody inside each product-attribute-cell to preserve card structure
+   */
+  _reorderProductAttributes(t) {
+    if (!this.currentNode)
+      return;
+    const e = this.currentNode.querySelectorAll(v);
+    if (!(e != null && e.length))
+      return;
+    const i = this.api.getDocumentModifier();
+    e.forEach((r) => {
+      const o = this._buildCompositionHtml(r, t);
+      i.modifyHtml(r).setInnerHtml(o);
+    }), i.apply(new d("Reorder product attributes"));
+  }
+  /**
+   * Builds HTML string with attributes ordered according to composition
+   */
+  _buildCompositionHtml(t, e) {
+    return e.reduce((i, r) => {
+      const o = t.querySelector(`${b}[${p}="${r}"]`);
+      return o && "getOuterHTML" in o ? i + o.getOuterHTML() : i;
+    }, "");
+  }
+  /**
+   * Apply visibility changes to the block's HTML structure
+   * Updates display style and data-visibility attribute for all matching elements
+   * - <tr> elements: use display: none / table-row
+   * - <td> elements: use display: none / table-cell
+   */
+  _applyVisibilityToBlock(t, e) {
+    if (!this.currentNode)
+      return;
+    const i = this.currentNode.querySelectorAll(`${b}[${p}="${t}"]`);
+    if (!(i != null && i.length))
+      return;
+    const r = e ? "1" : "0", o = `Set ${t} visibility to ${e ? "visible" : "hidden"}`, m = this.api.getDocumentModifier();
+    i.forEach((l) => {
+      let u = "TR";
+      if ("tagName" in l && l.tagName)
+        u = l.tagName.toUpperCase();
+      else if ("getTagName" in l) {
+        const _ = l;
+        typeof _.getTagName == "function" && (u = _.getTagName().toUpperCase());
+      }
+      const h = e ? u === "TD" || u === "BLOCK_IMAGE" || u === "BLOCK_BUTTON" ? "table-cell" : "table-row" : "none";
+      m.modifyHtml(l).setStyle("display", h).setAttribute(y, r);
+    }), m.apply(new d(o));
+  }
+  /**
+   * Gets the current layout orientation from store or DOM
+   */
+  _getCurrentLayout() {
+    return this.store.recommendationConfigs.orientation || P(this.currentNode);
+  }
+  /**
+   * Updates orderable state based on layout orientation
+   * Adds/removes disabled class to hide drag icons for horizontal layout
+   */
+  _updateOrderableState() {
+    const e = this._getCurrentLayout() === "horizontal", i = this.getContainer();
+    if (!i)
+      return;
+    const r = i.querySelector("[data-card-composition-control]");
+    if (!r)
+      return;
+    const o = r.querySelector("ue-orderable");
+    o && o.classList.toggle("orderable-disabled", e);
+  }
+  /**
+   * Subscribe to store orientation changes
+   * Updates orderable state when layout changes via the layout control
+   */
+  _subscribeToOrientationChanges() {
+    this.unsubscribeOrientation && this.unsubscribeOrientation();
+    let t = this.store.recommendationConfigs.orientation;
+    this.unsubscribeOrientation = this.store.$subscribe(() => {
+      const e = this.store.recommendationConfigs.orientation;
+      e !== t && (t = e, this._updateOrderableState());
+    });
+  }
+}
+export {
+  S as COMPOSITION_CONTROL_BLOCK_ID,
+  q as RecommendationCardCompositionControl
+};

package/dist/extensions/Blocks/Recommendation/controls/image/index.js

@@ -0,0 +1,19 @@
+import { createImageMarginsControl as m, createImageSizeControl as n } from "../../../controlFactories.js";
+import { RecommendationBlockId as o } from "../../constants/blockIds.js";
+import { RecommendationControlId as r } from "../../constants/controlIds.js";
+import { CONTAINER_SELECTOR as t } from "../../constants/selectors.js";
+const e = n(
+  r.IMAGE_SIZE,
+  o.IMAGE,
+  t
+), i = m(
+  r.IMAGE_MARGINS,
+  o.IMAGE,
+  t
+), C = {
+  size: e,
+  margins: i
+};
+export {
+  C as ImageControls
+};

package/dist/extensions/Blocks/Recommendation/controls/layout/index.js

@@ -0,0 +1,104 @@
+var h = Object.defineProperty;
+var p = (e, o, t) => o in e ? h(e, o, { enumerable: !0, configurable: !0, writable: !0, value: t }) : e[o] = t;
+var i = (e, o, t) => p(e, typeof o != "symbol" ? o + "" : o, t);
+import { ModificationDescription as a } from "../../../../../node_modules/@stripoinc/ui-editor-extensions/dist/esm/index.js";
+import { CommonControl as g } from "../../../common-control.js";
+import { CONTAINER_SELECTOR as C } from "../../constants/selectors.js";
+import { useRecommendationExtensionStore as f } from "../../store/recommendation.js";
+import { prepareProductRows as L } from "../../templates/index.js";
+import { getCurrentLayout as u, getBlockElement as T, getCurrentCardBackgroundColor as y, getCardComposition as N, applyCardBackgroundColor as _ } from "../main/utils.js";
+import { getDefaultProducts as O } from "../../templates/utils.js";
+const R = "recommendation-layout-control", s = {
+  LAYOUT: "layout"
+}, A = {
+  LAYOUT: "data-layout"
+}, U = [
+  { text: "Vertical", value: "vertical" },
+  { text: "Horizontal", value: "horizontal" }
+];
+class I extends g {
+  constructor() {
+    super(...arguments);
+    i(this, "store", f());
+    i(this, "isChangingLayout", !1);
+  }
+  getId() {
+    return R;
+  }
+  getTemplate() {
+    return `
+            <div class="layout-control-container">
+                ${this._GuTwoColumns([
+      this._GuLabel({ text: "Layout Orientation" }),
+      this._GuRadioButton({
+        name: s.LAYOUT,
+        buttons: U
+      })
+    ])}
+            </div>
+        `;
+  }
+  onRender() {
+    this._setFormValues(), this._listenToFormUpdates();
+  }
+  onTemplateNodeUpdated(t) {
+    super.onTemplateNodeUpdated(t), this._setFormValues();
+  }
+  _setFormValues() {
+    const t = u(this.currentNode);
+    this.api.updateValues({
+      [s.LAYOUT]: t
+    });
+  }
+  /**
+   * Handles layout change
+   * Updates the block's data attribute and regenerates product rows
+   */
+  _onLayoutChange(t) {
+    if (this.isChangingLayout || u(this.currentNode) === t)
+      return;
+    const r = T(this.currentNode);
+    if (r) {
+      this.isChangingLayout = !0;
+      try {
+        this.store.$patch({
+          recommendationConfigs: {
+            orientation: t
+          }
+        }), this.api.getDocumentModifier().modifyHtml(r).setAttribute(A.LAYOUT, t).apply(new a(`Update layout to ${t}`)), this._regenerateProductRows(t);
+      } finally {
+        this.isChangingLayout = !1;
+      }
+    }
+  }
+  /**
+   * Regenerates product rows based on the selected layout
+   * Special handling: captures and reapplies background color across layout changes
+   */
+  _regenerateProductRows(t) {
+    if (!this.currentNode || !("querySelector" in this.currentNode))
+      return;
+    const n = this.currentNode.querySelector(C);
+    if (!n)
+      return;
+    const r = y(this.currentNode), c = this.store.recommendationProducts.length > 0 ? this.store.recommendationProducts : O(), { cardsInRow: d } = this.store.recommendationConfigs, m = N(this.currentNode), l = L(c, t, {
+      productsPerRow: d,
+      composition: m
+    });
+    this.api.getDocumentModifier().modifyHtml(n).setInnerHtml(l).apply(new a(`Regenerated products for ${t} layout`)), _({
+      currentNode: this.currentNode,
+      documentModifier: this.api.getDocumentModifier(),
+      bgColor: r,
+      layout: t
+    });
+  }
+  _listenToFormUpdates() {
+    this.api.onValueChanged(s.LAYOUT, (t) => {
+      this._onLayoutChange(t);
+    });
+  }
+}
+export {
+  R as LAYOUT_CONTROL_ID,
+  I as LayoutControl
+};

package/dist/extensions/Blocks/Recommendation/controls/main/algorithm.js

@@ -0,0 +1,86 @@
+var r = Object.defineProperty;
+var a = (s, i, t) => i in s ? r(s, i, { enumerable: !0, configurable: !0, writable: !0, value: t }) : s[i] = t;
+var n = (s, i, t) => a(s, typeof i != "symbol" ? i + "" : i, t);
+import { UEAttr as l } from "../../../../../node_modules/@stripoinc/ui-editor-extensions/dist/esm/index.js";
+import { CommonControl as m } from "../../../common-control.js";
+import { useRecommendationExtensionStore as h } from "../../store/recommendation.js";
+const c = "recommendation-algorithm-control", e = {
+  ALGORITHM: "strategy",
+  PRODUCT_IDS: "productIds"
+};
+class _ extends m {
+  constructor() {
+    super(...arguments);
+    n(this, "store", h());
+  }
+  getId() {
+    return c;
+  }
+  getTemplate() {
+    return `
+            <div class="algorithm-control-container">
+                ${this._GuTwoColumns([
+      this._GuLabel({ text: "Recommendation Algorithm" }),
+      this._GuSelect({
+        name: e.ALGORITHM,
+        placeholder: "Select Recommendation Algorithm",
+        options: this.store.getActivePredictiveAlgorithms
+      }),
+      this._GuLabel({ text: "Product Ids", name: `${e.PRODUCT_IDS}_label` }),
+      this._GuTextInput({
+        name: e.PRODUCT_IDS,
+        placeholder: "Enter Product Ids",
+        className: "es-180w"
+      })
+    ])}
+            </div>
+        `;
+  }
+  onRender() {
+    this._initializeSelectItems(), this._setFormValues(), this._listenToFormUpdates();
+  }
+  _setFormValues() {
+    const { recommendationConfigs: t } = this.store;
+    this._setProductIdsVisibility(), this.api.updateValues({
+      [e.ALGORITHM]: t.strategy,
+      [e.PRODUCT_IDS]: t.productIds.join(",")
+    });
+  }
+  _initializeSelectItems() {
+    this.api.setUIEAttribute(
+      e.ALGORITHM,
+      l.SELECTPICKER.items,
+      this.store.getActivePredictiveAlgorithms
+    );
+  }
+  _setProductIdsVisibility() {
+    const { recommendationConfigs: t } = this.store, o = t.strategy === "manualMerchandising";
+    this.api.setVisibility(e.PRODUCT_IDS, o), this.api.setVisibility(`${e.PRODUCT_IDS}_label`, o);
+  }
+  _onAlgorithmChange(t) {
+    this.store.$patch({
+      recommendationConfigs: {
+        strategy: t
+      }
+    }), this._setProductIdsVisibility();
+  }
+  _onProductIdsChange(t) {
+    const o = t.split(",").filter(Boolean);
+    this.store.$patch({
+      recommendationConfigs: {
+        productIds: o
+      }
+    });
+  }
+  _listenToFormUpdates() {
+    this.api.onValueChanged(e.ALGORITHM, (t) => {
+      this._onAlgorithmChange(t);
+    }), this.api.onValueChanged(e.PRODUCT_IDS, (t) => {
+      this._onProductIdsChange(t);
+    });
+  }
+}
+export {
+  c as ALGORITHM_CONTROL_ID,
+  _ as AlgorithmControl
+};

package/dist/extensions/Blocks/Recommendation/controls/main/currency.js

@@ -0,0 +1,134 @@
+var l = Object.defineProperty;
+var _ = (n, o, t) => o in n ? l(n, o, { enumerable: !0, configurable: !0, writable: !0, value: t }) : n[o] = t;
+var s = (n, o, t) => _(n, typeof o != "symbol" ? o + "" : o, t);
+import { currencyLocationMaps as i, currencyOperators as r, currencyDecimalCounts as a } from "../../../../../enums/extensions/recommendationBlock.js";
+import { UEAttr as E } from "../../../../../node_modules/@stripoinc/ui-editor-extensions/dist/esm/index.js";
+import { CommonControl as u } from "../../../common-control.js";
+import { useRecommendationExtensionStore as m } from "../../store/recommendation.js";
+const S = "recommendation-currency-control", e = {
+  CURRENCY: "value",
+  CURRENCY_LOCATION: "alignment",
+  CURRENCY_SYMBOL: "symbol",
+  CURRENCY_THOUSAND_SEPARATOR: "thousandSeparator",
+  CURRENCY_DECIMAL_SEPARATOR: "decimalSeparator",
+  CURRENCY_DECIMAL_COUNT: "decimalCount"
+};
+class p extends u {
+  constructor() {
+    super(...arguments);
+    s(this, "store", m());
+  }
+  getId() {
+    return S;
+  }
+  getTemplate() {
+    return `
+            <div class="currency-control-container">
+                ${this._GuTwoColumns([
+      this._GuLabel({ text: "Currency" }),
+      this._GuSelect({
+        name: e.CURRENCY,
+        placeholder: "Select Currency",
+        options: this.store.currencyList
+      }),
+      this._GuLabel({ text: "Currency Location" }),
+      this._GuSelect({
+        name: e.CURRENCY_LOCATION,
+        placeholder: "Select Currency Location",
+        options: i
+      }),
+      this._GuLabel({ text: "Currency Symbol" }),
+      this._GuSelect({
+        name: e.CURRENCY_SYMBOL,
+        placeholder: "Select Currency Symbol",
+        options: this.store.getCurrencySymbolList
+      }),
+      this._GuLabel({ text: "Thousand Separator" }),
+      this._GuSelect({
+        name: e.CURRENCY_THOUSAND_SEPARATOR,
+        placeholder: "Select Thousand Separator",
+        options: r
+      }),
+      this._GuLabel({ text: "Decimal Separator" }),
+      this._GuSelect({
+        name: e.CURRENCY_DECIMAL_SEPARATOR,
+        placeholder: "Select Decimal Separator",
+        options: r
+      }),
+      this._GuLabel({ text: "Decimal Count" }),
+      this._GuSelect({
+        name: e.CURRENCY_DECIMAL_COUNT,
+        placeholder: "Select Decimal Count",
+        options: a
+      })
+    ])}
+            </div>
+        `;
+  }
+  onRender() {
+    this._initializeSelectItems(), this._setFormValues(), this._listenToFormUpdates();
+  }
+  _setFormValues() {
+    const { currencySettings: t } = this.store.recommendationConfigs;
+    this.api.updateValues({
+      [e.CURRENCY]: t.value,
+      [e.CURRENCY_LOCATION]: t.alignment,
+      [e.CURRENCY_SYMBOL]: t.symbol,
+      [e.CURRENCY_THOUSAND_SEPARATOR]: t.thousandSeparator,
+      [e.CURRENCY_DECIMAL_SEPARATOR]: t.decimalSeparator,
+      [e.CURRENCY_DECIMAL_COUNT]: t.decimalCount
+    });
+  }
+  _initializeSelectItems() {
+    const { store: t } = this, C = {
+      [e.CURRENCY]: t.currencyList,
+      [e.CURRENCY_LOCATION]: i,
+      [e.CURRENCY_SYMBOL]: t.getCurrencySymbolList,
+      [e.CURRENCY_THOUSAND_SEPARATOR]: r,
+      [e.CURRENCY_DECIMAL_SEPARATOR]: r,
+      [e.CURRENCY_DECIMAL_COUNT]: a
+    };
+    Object.entries(C).forEach(([c, R]) => {
+      this.api.setUIEAttribute(c, E.SELECTPICKER.items, R);
+    });
+  }
+  _onCurrencyChange(t) {
+    const [, C] = t.split(".");
+    this.store.$patch({
+      recommendationConfigs: {
+        currencySettings: {
+          name: C,
+          value: C
+        }
+      }
+    });
+  }
+  _onCurrencyConfigChange(t, C) {
+    this.store.$patch({
+      recommendationConfigs: {
+        currencySettings: {
+          [t]: C
+        }
+      }
+    });
+  }
+  _listenToFormUpdates() {
+    this.api.onValueChanged(e.CURRENCY, (C) => {
+      this._onCurrencyChange(C);
+    }), [
+      e.CURRENCY_LOCATION,
+      e.CURRENCY_SYMBOL,
+      e.CURRENCY_THOUSAND_SEPARATOR,
+      e.CURRENCY_DECIMAL_SEPARATOR,
+      e.CURRENCY_DECIMAL_COUNT
+    ].forEach((C) => {
+      this.api.onValueChanged(C, (c) => {
+        this._onCurrencyConfigChange(C, c);
+      });
+    });
+  }
+}
+export {
+  S as CURRENCY_CONTROL_ID,
+  p as CurrencyControl
+};

package/dist/extensions/Blocks/Recommendation/controls/main/filters.js

@@ -0,0 +1,54 @@
+var n = Object.defineProperty;
+var o = (i, e, t) => e in i ? n(i, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : i[e] = t;
+var r = (i, e, t) => o(i, typeof e != "symbol" ? e + "" : e, t);
+import { CommonControl as s } from "../../../common-control.js";
+import { useRecommendationExtensionStore as l } from "../../store/recommendation.js";
+const d = "recommendation-filters-control", a = {
+  FILTERS: "filterStatus"
+};
+class h extends s {
+  constructor() {
+    super(...arguments);
+    r(this, "store", l());
+    r(this, "addFilterListener", () => {
+    });
+    r(this, "addFilterButton", null);
+  }
+  getId() {
+    return d;
+  }
+  getTemplate() {
+    return `
+            <div class="filters-control-container">
+                ${this._GuTwoColumns([
+      this._GuLabel({ text: "Filters" }),
+      this._GuButton({
+        name: a.FILTERS,
+        label: "Add Filter",
+        id: "guido__btn-add-filter"
+      })
+    ])}
+            </div>
+        `;
+  }
+  onRender() {
+    this._setupButtonListener();
+  }
+  onDestroy() {
+    var t;
+    (t = this.addFilterButton) == null || t.removeEventListener("click", this.addFilterListener);
+  }
+  _onFilterSelectClick() {
+    this.store.$patch({
+      filterSelectionDrawerStatus: !0
+    });
+  }
+  _setupButtonListener() {
+    var t;
+    this.addFilterListener = this._onFilterSelectClick.bind(this), this.addFilterButton = this.getContainer().querySelector("#guido__btn-add-filter"), (t = this.addFilterButton) == null || t.addEventListener("click", this.addFilterListener);
+  }
+}
+export {
+  d as FILTERS_CONTROL_ID,
+  h as FiltersControl
+};