@useinsider/guido 2.1.0-beta.a720424 → 2.1.0-beta.e13d291

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

@@ -0,0 +1,96 @@
+var c = Object.defineProperty;
+var d = (o, e, t) => e in o ? c(o, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : o[e] = t;
+var n = (o, e, t) => d(o, typeof e != "symbol" ? e + "" : e, t);
+import { ModificationDescription as m } from "../../../../../node_modules/@stripoinc/ui-editor-extensions/dist/esm/index.js";
+import { CommonControl as h } from "../../../common-control.js";
+import { LAYOUT_OPTIONS as g } from "../../constants/layout.js";
+import { RecommendationConfigService as i } from "../../services/configService.js";
+import { useRecommendationExtensionStore as l } from "../../store/recommendation.js";
+import { getCurrentLayout as u, getBlockElement as f, regenerateProductRowsWithStyles as p } from "../main/utils.js";
+const L = "recommendation-layout-control", r = {
+  LAYOUT: "layout"
+}, T = {
+  LAYOUT: "data-layout"
+};
+class Y extends h {
+  constructor() {
+    super(...arguments);
+    n(this, "store", l());
+    n(this, "isChangingLayout", !1);
+  }
+  getId() {
+    return L;
+  }
+  getTemplate() {
+    return `
+            <div class="layout-control-container">
+                ${this._GuTwoColumns([
+      this._GuLabel({ text: "Layout Orientation" }),
+      this._GuRadioButton({
+        name: r.LAYOUT,
+        buttons: g
+      })
+    ])}
+            </div>
+        `;
+  }
+  onRender() {
+    this._setFormValues(), this._listenToFormUpdates();
+  }
+  onTemplateNodeUpdated(t) {
+    super.onTemplateNodeUpdated(t), this._setFormValues();
+  }
+  _setFormValues() {
+    const s = i.getConfig(this.currentNode).layout || u(this.currentNode);
+    this.api.updateValues({
+      [r.LAYOUT]: s
+    });
+  }
+  /**
+   * Handles layout change
+   * Updates node config, data attribute and regenerates product rows
+   */
+  _onLayoutChange(t) {
+    if (this.isChangingLayout || !this.currentNode || (i.getConfig(this.currentNode).layout || u(this.currentNode)) === t)
+      return;
+    const a = f(this.currentNode);
+    if (a) {
+      this.isChangingLayout = !0;
+      try {
+        i.updateConfig(
+          this.api,
+          this.currentNode,
+          { layout: t },
+          `Changed layout to ${t}`
+        ), this.store.$patch({
+          recommendationConfigs: {
+            orientation: t
+          }
+        }), this.api.getDocumentModifier().modifyHtml(a).setAttribute(T.LAYOUT, t).apply(new m(`Update layout to ${t}`)), this._regenerateProductRows(t);
+      } finally {
+        this.isChangingLayout = !1;
+      }
+    }
+  }
+  /**
+   * Regenerates product rows based on the selected layout
+   * Uses unified style-preserving regeneration to maintain user customizations
+   * @param layout - The layout to use for regeneration (passed explicitly to avoid stale DOM reads)
+   */
+  _regenerateProductRows(t) {
+    this.currentNode && p({
+      currentNode: this.currentNode,
+      documentModifier: this.api.getDocumentModifier(),
+      layout: t
+    });
+  }
+  _listenToFormUpdates() {
+    this.api.onValueChanged(r.LAYOUT, (t) => {
+      this._onLayoutChange(t);
+    });
+  }
+}
+export {
+  L as LAYOUT_CONTROL_ID,
+  Y as LayoutControl
+};

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

@@ -0,0 +1,110 @@
+var d = Object.defineProperty;
+var c = (o, i, t) => i in o ? d(o, i, { enumerable: !0, configurable: !0, writable: !0, value: t }) : o[i] = t;
+var a = (o, i, t) => c(o, typeof i != "symbol" ? i + "" : i, t);
+import { UEAttr as h } from "../../../../../node_modules/@stripoinc/ui-editor-extensions/dist/esm/index.js";
+import { CommonControl as l } from "../../../common-control.js";
+import { RecommendationConfigService as n } from "../../services/configService.js";
+import { useRecommendationExtensionStore as m } from "../../store/recommendation.js";
+const g = "recommendation-algorithm-control", e = {
+  ALGORITHM: "strategy",
+  PRODUCT_IDS: "productIds"
+};
+class T extends l {
+  constructor() {
+    super(...arguments);
+    // Store is used ONLY for API-fetched data (algorithms list), not for config
+    a(this, "store", m());
+  }
+  getId() {
+    return g;
+  }
+  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();
+  }
+  onTemplateNodeUpdated(t) {
+    super.onTemplateNodeUpdated(t), this._setFormValues();
+  }
+  _setFormValues() {
+    const t = n.getConfig(this.currentNode);
+    this._setProductIdsVisibility(t.strategy), this.api.updateValues({
+      [e.ALGORITHM]: t.strategy,
+      [e.PRODUCT_IDS]: t.productIds.join(",")
+    });
+  }
+  _initializeSelectItems() {
+    var s;
+    const t = (s = this.store) == null ? void 0 : s.getActivePredictiveAlgorithms;
+    if (t != null && t.length)
+      try {
+        this.api.setUIEAttribute(
+          e.ALGORITHM,
+          h.SELECTPICKER.items,
+          t
+        );
+      } catch (r) {
+        console.warn("[AlgorithmControl] Failed to set algorithm options:", r);
+      }
+  }
+  _setProductIdsVisibility(t) {
+    const r = (t ?? n.getConfig(this.currentNode).strategy) === "manualMerchandising";
+    this.api.setVisibility(e.PRODUCT_IDS, r), this.api.setVisibility(`${e.PRODUCT_IDS}_label`, r);
+  }
+  _onAlgorithmChange(t) {
+    this.currentNode && (n.updateConfig(
+      this.api,
+      this.currentNode,
+      { strategy: t },
+      `Changed algorithm to ${t}`
+    ), this.store.$patch({
+      recommendationConfigs: {
+        strategy: t
+      }
+    }), this._setProductIdsVisibility(t));
+  }
+  _onProductIdsChange(t) {
+    if (!this.currentNode)
+      return;
+    const s = t.split(",").map((r) => r.trim()).filter(Boolean);
+    n.updateConfig(
+      this.api,
+      this.currentNode,
+      { productIds: s },
+      "Updated product IDs"
+    ), this.store.$patch({
+      recommendationConfigs: {
+        productIds: s
+      }
+    });
+  }
+  _listenToFormUpdates() {
+    this.api.onValueChanged(e.ALGORITHM, (t) => {
+      this._onAlgorithmChange(t);
+    }), this.api.onValueChanged(e.PRODUCT_IDS, (t) => {
+      this._onProductIdsChange(t);
+    });
+  }
+}
+export {
+  g as ALGORITHM_CONTROL_ID,
+  T as AlgorithmControl
+};

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

@@ -0,0 +1,204 @@
+var h = Object.defineProperty;
+var R = (i, o, e) => o in i ? h(i, o, { enumerable: !0, configurable: !0, writable: !0, value: e }) : i[o] = e;
+var c = (i, o, e) => R(i, typeof o != "symbol" ? o + "" : o, e);
+import { currencyLocationMaps as u, currencyOperators as a, currencyDecimalCounts as l } from "../../../../../enums/extensions/recommendationBlock.js";
+import { UEAttr as _ } from "../../../../../node_modules/@stripoinc/ui-editor-extensions/dist/esm/index.js";
+import { CommonControl as m } from "../../../common-control.js";
+import { RecommendationConfigService as C } from "../../services/configService.js";
+import { useRecommendationExtensionStore as d } from "../../store/recommendation.js";
+import { setCurrencyAttributes as p, updatePricesInPlace as S, regenerateProductRowsWithStyles as E } from "./utils.js";
+const N = "recommendation-currency-control", t = {
+  CURRENCY: "currencyCode",
+  CURRENCY_LOCATION: "currencyAlignment",
+  CURRENCY_SYMBOL: "currencySymbol",
+  CURRENCY_THOUSAND_SEPARATOR: "currencyThousandSeparator",
+  CURRENCY_DECIMAL_SEPARATOR: "currencyDecimalSeparator",
+  CURRENCY_DECIMAL_COUNT: "currencyDecimalCount"
+};
+class b extends m {
+  constructor() {
+    super(...arguments);
+    // Store is used ONLY for API-fetched data (currency list), not for config
+    c(this, "store", d());
+    c(this, "storeUnsubscription", () => {
+    });
+  }
+  getId() {
+    return N;
+  }
+  getTemplate() {
+    return `
+            <div class="currency-control-container">
+                ${this._GuTwoColumns([
+      this._GuLabel({ text: "Currency" }),
+      this._GuSelect({
+        name: t.CURRENCY,
+        placeholder: "Select Currency",
+        options: this.store.currencyList
+      }),
+      this._GuLabel({ text: "Currency Location" }),
+      this._GuSelect({
+        name: t.CURRENCY_LOCATION,
+        placeholder: "Select Currency Location",
+        options: u
+      }),
+      this._GuLabel({ text: "Currency Symbol" }),
+      this._GuTextInput({
+        name: t.CURRENCY_SYMBOL,
+        placeholder: "Enter Currency Symbol",
+        className: "es-180w"
+      }),
+      this._GuLabel({ text: "Thousand Separator" }),
+      this._GuSelect({
+        name: t.CURRENCY_THOUSAND_SEPARATOR,
+        placeholder: "Select Thousand Separator",
+        options: a
+      }),
+      this._GuLabel({ text: "Decimal Separator" }),
+      this._GuSelect({
+        name: t.CURRENCY_DECIMAL_SEPARATOR,
+        placeholder: "Select Decimal Separator",
+        options: a
+      }),
+      this._GuLabel({ text: "Decimal Count" }),
+      this._GuSelect({
+        name: t.CURRENCY_DECIMAL_COUNT,
+        placeholder: "Select Decimal Count",
+        options: l
+      })
+    ])}
+            </div>
+        `;
+  }
+  onRender() {
+    this._initializeSelectItems(), this._setFormValues(), setTimeout(() => {
+      this._listenToFormUpdates();
+    }, 0), this._subscribeToStoreChanges();
+  }
+  onTemplateNodeUpdated(e) {
+    super.onTemplateNodeUpdated(e), this._setFormValues();
+  }
+  onDestroy() {
+    this.storeUnsubscription();
+  }
+  _setFormValues() {
+    const e = C.getConfig(this.currentNode), { currency: r } = e;
+    this.api.updateValues({
+      [t.CURRENCY]: `price.${r.code}`,
+      [t.CURRENCY_LOCATION]: r.alignment === "before" ? "0" : "1",
+      [t.CURRENCY_SYMBOL]: r.symbol,
+      [t.CURRENCY_THOUSAND_SEPARATOR]: r.thousandSeparator,
+      [t.CURRENCY_DECIMAL_SEPARATOR]: r.decimalSeparator,
+      [t.CURRENCY_DECIMAL_COUNT]: r.decimalCount.toString()
+    });
+  }
+  _initializeSelectItems() {
+    const { store: e } = this, r = {
+      [t.CURRENCY]: e.currencyList,
+      [t.CURRENCY_LOCATION]: u,
+      [t.CURRENCY_THOUSAND_SEPARATOR]: a,
+      [t.CURRENCY_DECIMAL_SEPARATOR]: a,
+      [t.CURRENCY_DECIMAL_COUNT]: l
+    };
+    Object.entries(r).forEach(([n, s]) => {
+      this.api.setUIEAttribute(n, _.SELECTPICKER.items, s);
+    });
+  }
+  _updateCurrency(e) {
+    if (!this.currentNode)
+      return;
+    const n = { ...C.getConfig(this.currentNode).currency, ...e };
+    C.updateConfig(
+      this.api,
+      this.currentNode,
+      { currency: n },
+      "Updated currency settings"
+    );
+    const s = this.api.getDocumentModifier();
+    p({
+      currentNode: this.currentNode,
+      documentModifier: s,
+      currency: n
+    }), this.store.$patch({
+      recommendationConfigs: {
+        currencySettings: {
+          name: n.code,
+          value: n.code,
+          symbol: n.symbol,
+          alignment: n.alignment === "before" ? "0" : "1",
+          decimalCount: n.decimalCount.toString(),
+          decimalSeparator: n.decimalSeparator,
+          thousandSeparator: n.thousandSeparator
+        }
+      }
+    }), S({
+      currentNode: this.currentNode,
+      documentModifier: s
+    }) || E({
+      currentNode: this.currentNode,
+      documentModifier: s
+    });
+  }
+  _onCurrencyChange(e) {
+    const [, r] = e.includes(".") ? e.split(".") : [null, e];
+    this._updateCurrency({
+      code: r,
+      symbol: r
+    }), this.api.updateValues({
+      [t.CURRENCY_SYMBOL]: r
+    });
+  }
+  _onCurrencyLocationChange(e) {
+    this._updateCurrency({
+      alignment: e === "0" ? "before" : "after"
+    });
+  }
+  _onCurrencySymbolChange(e) {
+    this._updateCurrency({ symbol: e });
+  }
+  _onThousandSeparatorChange(e) {
+    this._updateCurrency({
+      thousandSeparator: e
+    });
+  }
+  _onDecimalSeparatorChange(e) {
+    this._updateCurrency({
+      decimalSeparator: e
+    });
+  }
+  _onDecimalCountChange(e) {
+    this._updateCurrency({
+      decimalCount: parseInt(e) || 2
+    });
+  }
+  _listenToFormUpdates() {
+    this.api.onValueChanged(t.CURRENCY, (e) => {
+      this._onCurrencyChange(e);
+    }), this.api.onValueChanged(t.CURRENCY_LOCATION, (e) => {
+      this._onCurrencyLocationChange(e);
+    }), this.api.onValueChanged(t.CURRENCY_SYMBOL, (e) => {
+      this._onCurrencySymbolChange(e);
+    }), this.api.onValueChanged(t.CURRENCY_THOUSAND_SEPARATOR, (e) => {
+      this._onThousandSeparatorChange(e);
+    }), this.api.onValueChanged(t.CURRENCY_DECIMAL_SEPARATOR, (e) => {
+      this._onDecimalSeparatorChange(e);
+    }), this.api.onValueChanged(t.CURRENCY_DECIMAL_COUNT, (e) => {
+      this._onDecimalCountChange(e);
+    });
+  }
+  /**
+   * Subscribe to store changes to update currency selects when API data arrives
+   * This handles the case where the control renders before currency list is loaded
+   */
+  _subscribeToStoreChanges() {
+    let e = this.store.currencyList.length;
+    this.storeUnsubscription = this.store.$subscribe(() => {
+      const r = this.store.currencyList.length;
+      r > 0 && r !== e && (e = r, this._initializeSelectItems(), this._setFormValues());
+    });
+  }
+}
+export {
+  N as CURRENCY_CONTROL_ID,
+  b 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
+};

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

@@ -0,0 +1,205 @@
+var g = Object.defineProperty;
+var y = (n, s, t) => s in n ? g(n, s, { enumerable: !0, configurable: !0, writable: !0, value: t }) : n[s] = t;
+var r = (n, s, t) => y(n, typeof s != "symbol" ? s + "" : s, t);
+import { CommonControl as R } from "../../../common-control.js";
+import { useRecommendationExtensionStore as P } from "../../store/recommendation.js";
+import { AlgorithmControl as _ } from "./algorithm.js";
+import { ALGORITHM_CONTROL_ID as j } from "./algorithm.js";
+import { CurrencyControl as b } from "./currency.js";
+import { CURRENCY_CONTROL_ID as q } from "./currency.js";
+import { FiltersControl as L } from "./filters.js";
+import { FILTERS_CONTROL_ID as Q } from "./filters.js";
+import { LocaleControl as N } from "./locale.js";
+import { LOCALE_CONTROL_ID as X } from "./locale.js";
+import { ProductLayoutControl as T } from "./productLayout.js";
+import { PRODUCT_LAYOUT_CONTROL_ID as tt } from "./productLayout.js";
+import { ShuffleControl as O } from "./shuffle.js";
+import { SHUFFLE_CONTROL_ID as ot } from "./shuffle.js";
+import { regenerateProductRowsWithStyles as D, updateProductContentInPlace as S } from "./utils.js";
+import { formatProductPrice as st, getBlockElement as nt, getCardComposition as it, getCurrentLayout as at, reapplySpacing as ct, regenerateProductRows as lt, setCurrencyAttributes as ut, updatePricesInPlace as dt, updateSingleProductContent as ht } from "./utils.js";
+import { useDebounceFn as h } from "../../../../../node_modules/@vueuse/shared/index.js";
+const I = /* @__PURE__ */ new Set([
+  "size",
+  "strategy",
+  "filters",
+  "productIds",
+  "language",
+  "shuffleProducts"
+]), w = "ui-elements-recommendation-block";
+class B extends R {
+  constructor() {
+    super(...arguments);
+    r(this, "store", P());
+    r(this, "storeUnsubscription", () => {
+    });
+    // Track if initial data has been fetched to avoid redundant API calls
+    r(this, "hasInitializedData", !1);
+    // Sub-control instances for lifecycle management
+    r(this, "algorithmControl", null);
+    r(this, "localeControl", null);
+    r(this, "currencyControl", null);
+    r(this, "productLayoutControl", null);
+    r(this, "filtersControl", null);
+    r(this, "shuffleControl", null);
+    /**
+     * Debounced product fetch to prevent rapid API calls during config changes
+     */
+    r(this, "_debouncedFetchProducts", h(() => {
+      this.store.fetchRecommendationProducts();
+    }, 500));
+    /**
+     * Debounced regeneration when products arrive from API
+     * Tries in-place update first to preserve styles, falls back to full regeneration
+     */
+    r(this, "_debouncedRegenerateWithProducts", h(() => {
+      const t = this.store.recommendationProducts;
+      if (!this.currentNode || !this.api)
+        return;
+      const e = this.api.getDocumentModifier();
+      S({
+        currentNode: this.currentNode,
+        documentModifier: e,
+        products: t
+      }) || this._regenerateWithProducts(t);
+    }, 100));
+  }
+  getId() {
+    return w;
+  }
+  getTemplate() {
+    return this.algorithmControl = new _(), this.localeControl = new N(), this.currencyControl = new b(), this.productLayoutControl = new T(), this.filtersControl = new L(), this.shuffleControl = new O(), `
+            <div class="recommendation-controls-container">
+                ${this.algorithmControl.getTemplate()}
+                ${this.localeControl.getTemplate()}
+                ${this.currencyControl.getTemplate()}
+                ${this.filtersControl.getTemplate()}
+                ${this.productLayoutControl.getTemplate()}
+                ${this.shuffleControl.getTemplate()}
+            </div>
+        `;
+  }
+  async onRender() {
+    if (this._listenStateUpdates(), this.hasInitializedData) {
+      this._initializeSubControls();
+      return;
+    }
+    (await Promise.allSettled([
+      this.store.fetchRecommendationFilters(),
+      this.store.fetchRecommendationCreateData(),
+      this.store.fetchRecommendationProducts()
+    ])).forEach((e, o) => {
+      e.status === "rejected" && console.warn(`Recommendation block: ${[
+        "fetchRecommendationFilters",
+        "fetchRecommendationCreateData",
+        "fetchRecommendationProducts"
+      ][o]} failed`, e.reason);
+    }), this.hasInitializedData = !0, this._initializeSubControls();
+  }
+  /**
+   * Immediately regenerate products with styles (no debounce)
+   * Used for initial load after fetch completes
+   */
+  _regenerateWithProducts(t) {
+    if (!this.currentNode || !this.api) {
+      console.warn("[Recommendation] Cannot regenerate - missing currentNode or api");
+      return;
+    }
+    D({
+      currentNode: this.currentNode,
+      documentModifier: this.api.getDocumentModifier(),
+      products: t
+    });
+  }
+  onTemplateNodeUpdated(t) {
+    super.onTemplateNodeUpdated(t), [
+      this.algorithmControl,
+      this.localeControl,
+      this.currencyControl,
+      this.productLayoutControl,
+      this.filtersControl,
+      this.shuffleControl
+    ].forEach((o) => {
+      var i;
+      o != null && o.api && (o.currentNode = t, (i = o.onTemplateNodeUpdated) == null || i.call(o, t));
+    });
+  }
+  onDestroy() {
+    this.storeUnsubscription(), [
+      this.algorithmControl,
+      this.localeControl,
+      this.currencyControl,
+      this.productLayoutControl,
+      this.filtersControl,
+      this.shuffleControl
+    ].forEach((e) => {
+      var o;
+      return (o = e == null ? void 0 : e.onDestroy) == null ? void 0 : o.call(e);
+    });
+  }
+  /**
+   * Initialize all sub-controls with the shared API context
+   * Each sub-control manages its own form values and event listeners
+   */
+  _initializeSubControls() {
+    [
+      this.algorithmControl,
+      this.localeControl,
+      this.currencyControl,
+      this.productLayoutControl,
+      this.filtersControl,
+      this.shuffleControl
+    ].forEach((e) => {
+      var o;
+      e && (e.api = this.api, e.currentNode = this.currentNode, (o = e.onRender) == null || o.call(e));
+    });
+  }
+  /**
+   * Listen to store changes that require product refresh or regeneration
+   * - Config changes (size, strategy, filters, etc.) trigger API refetch
+   * - Currency code changes trigger API refetch (formatting changes are handled in-place)
+   * - Products array changes (API response) trigger HTML regeneration
+   */
+  _listenStateUpdates() {
+    const { store: t } = this;
+    let e = t.recommendationProducts, o = t.recommendationConfigs.currencySettings.value;
+    this.storeUnsubscription = t.$subscribe((i) => {
+      var u;
+      if ("payload" in i) {
+        const c = i.payload.recommendationConfigs;
+        if (c) {
+          const f = Object.keys(c).some((p) => I.has(p)), l = (u = c.currencySettings) == null ? void 0 : u.value, d = l !== void 0 && l !== o;
+          d && (o = l), (f || d) && this._debouncedFetchProducts();
+        }
+      }
+      const a = t.recommendationProducts, m = a !== e, C = Array.isArray(a) && a.length > 0;
+      m && C && (e = a, this._debouncedRegenerateWithProducts());
+    });
+  }
+}
+export {
+  j as ALGORITHM_CONTROL_ID,
+  _ as AlgorithmControl,
+  w as CONTROL_BLOCK_ID,
+  q as CURRENCY_CONTROL_ID,
+  b as CurrencyControl,
+  Q as FILTERS_CONTROL_ID,
+  L as FiltersControl,
+  X as LOCALE_CONTROL_ID,
+  N as LocaleControl,
+  tt as PRODUCT_LAYOUT_CONTROL_ID,
+  T as ProductLayoutControl,
+  B as RecommendationBlockControl,
+  ot as SHUFFLE_CONTROL_ID,
+  O as ShuffleControl,
+  st as formatProductPrice,
+  nt as getBlockElement,
+  it as getCardComposition,
+  at as getCurrentLayout,
+  ct as reapplySpacing,
+  lt as regenerateProductRows,
+  D as regenerateProductRowsWithStyles,
+  ut as setCurrencyAttributes,
+  dt as updatePricesInPlace,
+  S as updateProductContentInPlace,
+  ht as updateSingleProductContent
+};