@useinsider/guido 2.1.0-beta.99bedd1 → 2.1.0-beta.9a6dc97

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

@@ -0,0 +1,52 @@
+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.openFilterDrawer();
+  }
+  _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,321 @@
+var g = Object.defineProperty;
+var C = (d, c, t) => c in d ? g(d, c, { enumerable: !0, configurable: !0, writable: !0, value: t }) : d[c] = t;
+var i = (d, c, t) => C(d, typeof c != "symbol" ? c + "" : c, t);
+import { CommonControl as p } from "../../../common-control.js";
+import { DEFAULT_NODE_CONFIG as a } from "../../constants/defaultConfig.js";
+import { RecommendationConfigService as m } from "../../services/configService.js";
+import { useRecommendationExtensionStore as y } from "../../store/recommendation.js";
+import { AlgorithmControl as R } from "./algorithm.js";
+import { ALGORITHM_CONTROL_ID as H } from "./algorithm.js";
+import { CurrencyControl as b } from "./currency.js";
+import { CURRENCY_CONTROL_ID as K } from "./currency.js";
+import { FiltersControl as N } from "./filters.js";
+import { FILTERS_CONTROL_ID as J } from "./filters.js";
+import { LocaleControl as _ } from "./locale.js";
+import { LOCALE_CONTROL_ID as X } from "./locale.js";
+import { ProductLayoutControl as S } from "./productLayout.js";
+import { PRODUCT_LAYOUT_CONTROL_ID as tt } from "./productLayout.js";
+import { ShuffleControl as I } from "./shuffle.js";
+import { SHUFFLE_CONTROL_ID as ot } from "./shuffle.js";
+import { getBlockElement as P, updateProductContentInPlace as L, regenerateProductRowsWithStyles as T } from "./utils.js";
+import { adjustProductsToSize as nt, formatProductPrice as st, getCardComposition as it, getCurrentLayout as at, reapplySpacing as ct, regenerateMobileProductRows as lt, regenerateProductRows as ut, setCurrencyAttributes as dt, updatePricesInPlace as mt, updateSingleProductContent as ht } from "./utils.js";
+import { useDebounceFn as h } from "../../../../../node_modules/@vueuse/shared/index.js";
+const k = "recommendation-id", D = "ui-elements-recommendation-block";
+class W extends p {
+  constructor() {
+    super(...arguments);
+    i(this, "store", y());
+    i(this, "storeUnsubscription", () => {
+    });
+    // Sub-control instances for lifecycle management
+    i(this, "algorithmControl", null);
+    i(this, "localeControl", null);
+    i(this, "currencyControl", null);
+    i(this, "productLayoutControl", null);
+    i(this, "filtersControl", null);
+    i(this, "shuffleControl", null);
+    /**
+     * Debounced product fetch to prevent rapid API calls during config changes
+     */
+    i(this, "_debouncedFetchProducts", h(() => {
+      this.store.fetchRecommendationProducts();
+    }, 500));
+    /**
+     * Debounced content update when products arrive from API.
+     *
+     * Tries in-place update first (preserves user-applied styles) — this succeeds
+     * when the product count matches the DOM (algorithm/locale/currency changes).
+     *
+     * Falls back to full regeneration when product count differs from DOM — this
+     * happens after "Number of Products" changes where the DOM still has the old
+     * count. The store pads products to the configured size, so in-place only
+     * fails when the size actually changed.
+     */
+    i(this, "_debouncedRegenerateWithProducts", h(() => {
+      const t = this.store.recommendationProducts;
+      if (!this.currentNode || !this.api)
+        return;
+      const e = this.api.getDocumentModifier();
+      L({
+        currentNode: this.currentNode,
+        documentModifier: e,
+        products: t
+      }) || T({
+        currentNode: this.currentNode,
+        documentModifier: e,
+        products: t
+      });
+    }, 100));
+  }
+  getId() {
+    return D;
+  }
+  getTemplate() {
+    return this.algorithmControl = new R(), this.localeControl = new _(), this.currencyControl = new b(), this.productLayoutControl = new S(), this.filtersControl = new N(), this.shuffleControl = new I(), `
+            <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() {
+    var e;
+    const t = this._getRecommendationIdFromNode(this.currentNode) ?? this.store.currentRecommendationId;
+    if (t !== null && this.store.setCurrentBlock(t), this._listenStateUpdates(), t !== null && ((e = this.store.blockStates[t]) != null && e.isInitialized)) {
+      this._initializeSubControls();
+      return;
+    }
+    await this._fetchBlockData(t), this._initializeSubControls();
+  }
+  onTemplateNodeUpdated(t) {
+    var s;
+    super.onTemplateNodeUpdated(t);
+    const e = this._getRecommendationIdFromNode(t);
+    e !== null && e !== this.store.currentRecommendationId && this.store.setCurrentBlock(e), this._syncNodeConfigToStore(), e !== null && !((s = this.store.blockStates[e]) != null && s.isInitialized) && this._fetchBlockData(e), [
+      this.algorithmControl,
+      this.localeControl,
+      this.currencyControl,
+      this.productLayoutControl,
+      this.filtersControl,
+      this.shuffleControl
+    ].forEach((r) => {
+      var n;
+      r != null && r.api && (r.currentNode = t, (n = r.onTemplateNodeUpdated) == null || n.call(r, 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));
+    });
+  }
+  /**
+   * Syncs persisted node config into the Pinia store's block state.
+   *
+   * setCurrentBlock() creates a default entry (USD, en_US, mostPopular).
+   * For saved templates, the real config lives in the node (e.g., TRY, tr_TR).
+   * This method reads it and patches the store so fetchRecommendationProducts()
+   * uses the correct values.
+   *
+   * Uses triggerRefetch: false because the fetch hasn't happened yet —
+   * values are being prepared for the upcoming initial fetch.
+   */
+  _syncNodeConfigToStore() {
+    const t = m.getConfig(this.currentNode);
+    this.store.patchCurrentBlockConfig({
+      strategy: t.strategy,
+      language: t.language,
+      size: t.size,
+      productIds: t.productIds,
+      filters: t.filters,
+      shuffleProducts: t.shuffleProducts,
+      currencySettings: {
+        name: t.currency.code,
+        value: t.currency.code,
+        symbol: t.currency.symbol,
+        alignment: t.currency.alignment === "before" ? "0" : "1",
+        decimalCount: t.currency.decimalCount.toString(),
+        decimalSeparator: t.currency.decimalSeparator,
+        thousandSeparator: t.currency.thousandSeparator
+      }
+    }, { triggerRefetch: !1 });
+  }
+  /**
+   * Fetches initial data for a block in three phases:
+   * 1. Shared reference data (algorithms, currencies, filters) — parallel
+   * 2. Smart defaults for new blocks (currency, algorithm) — sequential
+   * 3. Product data with correct defaults — sequential
+   *
+   * Shared by onRender() and onTemplateNodeUpdated() to avoid duplication.
+   * Marks the block as initialized to prevent redundant fetches on re-selection.
+   */
+  async _fetchBlockData(t) {
+    t !== null && this.store.markBlockInitialized(t), (await Promise.allSettled([
+      this.store.fetchRecommendationCreateData(),
+      this.store.fetchRecommendationFilters()
+    ])).forEach((o, s) => {
+      o.status === "rejected" && console.warn(`Recommendation block: ${["fetchRecommendationCreateData", "fetchRecommendationFilters"][s]} failed`, o.reason);
+    }), this._applySmartDefaults();
+    try {
+      await this.store.fetchRecommendationProducts();
+    } catch (o) {
+      console.warn("Recommendation block: fetchRecommendationProducts failed", o);
+    }
+  }
+  /**
+   * Applies smart defaults for newly dropped blocks.
+   *
+   * For new blocks (config still matches hardcoded defaults), validates that
+   * the default currency and algorithm are available from the API response.
+   * If not, falls back to the first available option.
+   *
+   * Saved templates with user-customized config are left unchanged because
+   * their values won't match the hardcoded defaults.
+   */
+  _applySmartDefaults() {
+    if (!this.currentNode || !this.api)
+      return;
+    const t = m.getConfig(this.currentNode), e = {};
+    let o = null, s = null, r = null;
+    if (t.currency.code === a.currency.code) {
+      const { currencyList: n } = this.store;
+      n.length > 0 && (n.some(
+        (u) => u.value === `price.${a.currency.code}`
+      ) || (o = n[0].value.replace("price.", ""), e.currency = {
+        ...a.currency,
+        code: o,
+        symbol: o
+      }));
+    }
+    if (t.strategy === a.strategy) {
+      const n = this.store.getActivePredictiveAlgorithms;
+      n.length > 0 && (n.some(
+        (u) => u.value === a.strategy
+      ) || (s = n[0].value, e.strategy = s));
+    }
+    if (t.language === a.language) {
+      const n = this.store.getLanguages;
+      n.length > 0 && (n.some(
+        (u) => u.value === a.language
+      ) || (r = n[0].value, e.language = r));
+    }
+    !o && !s && !r || (m.updateConfig(
+      this.api,
+      this.currentNode,
+      e,
+      "Applied smart defaults"
+    ), this.store.patchCurrentBlockConfig({
+      ...o ? {
+        currencySettings: {
+          name: o,
+          value: o,
+          symbol: o,
+          alignment: a.currency.alignment === "before" ? "0" : "1",
+          decimalCount: a.currency.decimalCount.toString(),
+          decimalSeparator: a.currency.decimalSeparator,
+          thousandSeparator: a.currency.thousandSeparator
+        }
+      } : {},
+      ...s ? { strategy: s } : {},
+      ...r ? { language: r } : {}
+    }, { triggerRefetch: !1 }));
+  }
+  /**
+   * Reads the recommendation-id attribute from the block element within the node
+   */
+  _getRecommendationIdFromNode(t) {
+    const e = P(t);
+    if (!e || !("getAttribute" in e))
+      return null;
+    const o = e.getAttribute(k);
+    if (!o)
+      return null;
+    const s = parseInt(o);
+    return Number.isNaN(s) ? null : s;
+  }
+  /**
+   * Listen to store changes that require product refresh or regeneration.
+   *
+   * Uses configVersion counter (incremented only by patchCurrentBlockConfig)
+   * to distinguish user-initiated config changes from internal mutations
+   * (e.g., fetchRecommendationCreateData setting preferred currency).
+   *
+   * Tracks currentRecommendationId to detect block switches. When the user
+   * selects a different recommendation block, the proxy getters (e.g.,
+   * recommendationProducts) return the new block's data — a different array
+   * reference that would be falsely detected as "new products arrived".
+   * We skip that tick and update tracking references instead.
+   */
+  _listenStateUpdates() {
+    const { store: t } = this;
+    let e = t.recommendationProducts, o = t.$state.configVersion, s = t.currentRecommendationId;
+    this.storeUnsubscription = t.$subscribe(() => {
+      const r = t.currentRecommendationId;
+      if (r !== s) {
+        s = r, e = t.recommendationProducts, o = t.$state.configVersion;
+        return;
+      }
+      const n = t.$state.configVersion;
+      n !== o && (o = n, this._debouncedFetchProducts());
+      const l = t.recommendationProducts, u = l !== e, f = Array.isArray(l) && l.length > 0;
+      u && f && (e = l, this._debouncedRegenerateWithProducts());
+    });
+  }
+}
+export {
+  H as ALGORITHM_CONTROL_ID,
+  R as AlgorithmControl,
+  D as CONTROL_BLOCK_ID,
+  K as CURRENCY_CONTROL_ID,
+  b as CurrencyControl,
+  J as FILTERS_CONTROL_ID,
+  N as FiltersControl,
+  X as LOCALE_CONTROL_ID,
+  _ as LocaleControl,
+  tt as PRODUCT_LAYOUT_CONTROL_ID,
+  S as ProductLayoutControl,
+  W as RecommendationBlockControl,
+  ot as SHUFFLE_CONTROL_ID,
+  I as ShuffleControl,
+  nt as adjustProductsToSize,
+  st as formatProductPrice,
+  P as getBlockElement,
+  it as getCardComposition,
+  at as getCurrentLayout,
+  ct as reapplySpacing,
+  lt as regenerateMobileProductRows,
+  ut as regenerateProductRows,
+  T as regenerateProductRowsWithStyles,
+  dt as setCurrencyAttributes,
+  mt as updatePricesInPlace,
+  L as updateProductContentInPlace,
+  ht as updateSingleProductContent
+};

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

@@ -0,0 +1,70 @@
+var s = Object.defineProperty;
+var r = (o, t, e) => t in o ? s(o, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : o[t] = e;
+var a = (o, t, e) => r(o, typeof t != "symbol" ? t + "" : t, e);
+import { UEAttr as l } from "../../../../../node_modules/@stripoinc/ui-editor-extensions/dist/esm/index.js";
+import { CommonControl as c } from "../../../common-control.js";
+import { RecommendationConfigService as i } from "../../services/configService.js";
+import { useRecommendationExtensionStore as g } from "../../store/recommendation.js";
+const m = "recommendation-locale-control", n = {
+  LOCALE: "language"
+};
+class E extends c {
+  constructor() {
+    super(...arguments);
+    // Store is used ONLY for API-fetched data (language options), not for config
+    a(this, "store", g());
+  }
+  getId() {
+    return m;
+  }
+  getTemplate() {
+    return `
+            <div class="locale-control-container">
+                ${this._GuTwoColumns([
+      this._GuLabel({ text: "Recommendation Locale" }),
+      this._GuSelect({
+        name: n.LOCALE,
+        placeholder: "Select Recommendation Locale",
+        options: this.store.getLanguages
+      })
+    ])}
+            </div>
+        `;
+  }
+  onRender() {
+    this._initializeSelectItems(), this._setFormValues(), this._listenToFormUpdates();
+  }
+  onTemplateNodeUpdated(e) {
+    super.onTemplateNodeUpdated(e), this._setFormValues();
+  }
+  _setFormValues() {
+    const e = i.getConfig(this.currentNode);
+    this.api.updateValues({
+      [n.LOCALE]: e.language
+    });
+  }
+  _initializeSelectItems() {
+    this.api.setUIEAttribute(
+      n.LOCALE,
+      l.SELECTPICKER.items,
+      this.store.getLanguages
+    );
+  }
+  _onLocaleChange(e) {
+    !this.currentNode || i.getConfig(this.currentNode).language === e || (i.updateConfig(
+      this.api,
+      this.currentNode,
+      { language: e },
+      `Changed language to ${e}`
+    ), this.store.patchCurrentBlockConfig({ language: e }));
+  }
+  _listenToFormUpdates() {
+    this.api.onValueChanged(n.LOCALE, (e) => {
+      this._onLocaleChange(e);
+    });
+  }
+}
+export {
+  m as LOCALE_CONTROL_ID,
+  E as LocaleControl
+};

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

@@ -0,0 +1,168 @@
+var u = Object.defineProperty;
+var _ = (n, r, t) => r in n ? u(n, r, { enumerable: !0, configurable: !0, writable: !0, value: t }) : n[r] = t;
+var a = (n, r, t) => _(n, typeof r != "symbol" ? r + "" : r, t);
+import { EditorStatePropertyType as c, PreviewDeviceMode as C } from "../../../../../node_modules/@stripoinc/ui-editor-extensions/dist/esm/index.js";
+import { CommonControl as R } from "../../../common-control.js";
+import { MAX_PRODUCT_COUNT as h, MAX_PRODUCTS_PER_ROW as p, MAX_MOBILE_PRODUCTS_PER_ROW as g, DEFAULT_COLUMN_SPACING as m, DEFAULT_MOBILE_COLUMN_SPACING as O } from "../../constants/layout.js";
+import { RecommendationConfigService as i } from "../../services/configService.js";
+import { useRecommendationExtensionStore as l } from "../../store/recommendation.js";
+import { ensureMobileCssRulesExist as I } from "../mobileLayout/cssRules.js";
+import { getCurrentLayout as N, regenerateMobileProductRows as f, adjustProductsToSize as b, regenerateProductRowsWithStyles as P } from "./utils.js";
+import { useDebounceFn as L } from "../../../../../node_modules/@vueuse/shared/index.js";
+const M = "recommendation-product-layout-control", e = {
+  PRODUCT_COUNT: "size",
+  PRODUCT_IN_ROW: "cardsInRow",
+  PRODUCT_IN_ROW_LABEL: "cardsInRowLabel",
+  MOBILE_CARDS_IN_ROW: "mobileCardsInRow",
+  MOBILE_CARDS_IN_ROW_LABEL: "mobileCardsInRowLabel"
+};
+class V extends R {
+  constructor() {
+    super(...arguments);
+    // Store is used for backward compatibility with product fetching and regeneration
+    a(this, "store", l());
+    a(this, "storeUnsubscription", () => {
+    });
+    a(this, "_debouncedRegenerateProductRows", L(() => {
+      this._regenerateProductRows();
+    }, 500));
+  }
+  getId() {
+    return M;
+  }
+  getTemplate() {
+    return `
+            <div class="product-layout-control-container">
+                ${this._GuTwoColumns([
+      this._GuLabel({ text: "Number of Products" }),
+      this._GuCounter({ name: e.PRODUCT_COUNT, maxValue: h }),
+      this._GuLabel({
+        text: "Products in One Row on Desktop",
+        name: e.PRODUCT_IN_ROW_LABEL
+      }),
+      this._GuCounter({ name: e.PRODUCT_IN_ROW, maxValue: p }),
+      this._GuLabel({
+        text: "Products in One Row on Mobile",
+        name: e.MOBILE_CARDS_IN_ROW_LABEL
+      }),
+      this._GuCounter({
+        name: e.MOBILE_CARDS_IN_ROW,
+        maxValue: g
+      })
+    ])}
+            </div>
+        `;
+  }
+  onRender() {
+    this._setFormValues(), this._updateProductsInRowVisibility(), this._listenToFormUpdates(), this._listenStateUpdates(), this._subscribeToEditorModeChanges();
+  }
+  onTemplateNodeUpdated(t) {
+    super.onTemplateNodeUpdated(t), this._setFormValues(), this._updateProductsInRowVisibility();
+  }
+  onDestroy() {
+    this.storeUnsubscription();
+  }
+  _setFormValues() {
+    const t = i.getConfig(this.currentNode);
+    this.api.updateValues({
+      [e.PRODUCT_COUNT]: t.size,
+      [e.PRODUCT_IN_ROW]: t.cardsInRow,
+      [e.MOBILE_CARDS_IN_ROW]: t.mobileCardsInRow
+    });
+  }
+  /**
+   * Checks if the editor is currently in mobile preview mode
+   * using Stripo's EditorStatePropertyType API.
+   */
+  _isMobileMode() {
+    return this.api.getEditorState()[c.previewDeviceMode] === C.MOBILE;
+  }
+  /**
+   * Updates counter visibility based on layout orientation and editor mode.
+   * - List layout: hide both counters (products always full-width)
+   * - Grid + desktop mode: show desktop counter, hide mobile counter
+   * - Grid + mobile mode: show mobile counter, hide desktop counter
+   */
+  _updateProductsInRowVisibility() {
+    const o = (i.getConfig(this.currentNode).layout || N(this.currentNode)) === "grid", d = this._isMobileMode();
+    this.api.setVisibility(e.PRODUCT_IN_ROW, o && !d), this.api.setVisibility(e.PRODUCT_IN_ROW_LABEL, o && !d), this.api.setVisibility(e.MOBILE_CARDS_IN_ROW, o && d), this.api.setVisibility(e.MOBILE_CARDS_IN_ROW_LABEL, o && d);
+  }
+  /**
+   * Subscribes to editor preview mode changes via Stripo API.
+   * When the user switches between desktop/mobile preview, toggles
+   * which "Products in One Row" counter is visible.
+   */
+  _subscribeToEditorModeChanges() {
+    this.api.onEditorStatePropUpdated(
+      c.previewDeviceMode,
+      () => {
+        this._updateProductsInRowVisibility();
+      }
+    );
+  }
+  _onProductCountChange(t) {
+    !this.currentNode || i.getConfig(this.currentNode).size === t || (i.updateConfig(
+      this.api,
+      this.currentNode,
+      { size: t },
+      `Changed product count to ${t}`
+    ), this.store.patchCurrentBlockConfig({ size: t }));
+  }
+  _onProductsInRowChange(t) {
+    if (!this.currentNode || i.getConfig(this.currentNode).cardsInRow === t)
+      return;
+    const o = t === 1 ? 0 : m;
+    i.updateConfig(
+      this.api,
+      this.currentNode,
+      { cardsInRow: t, columnSpacing: o },
+      `Changed products per row to ${t}`
+    ), this.store.patchCurrentBlockConfig({ cardsInRow: t }, { triggerRefetch: !1 }), this._debouncedRegenerateProductRows();
+  }
+  _onMobileCardsInRowChange(t) {
+    if (!this.currentNode || i.getConfig(this.currentNode).mobileCardsInRow === t)
+      return;
+    const o = t === 1 ? 0 : O;
+    i.updateConfig(
+      this.api,
+      this.currentNode,
+      { mobileCardsInRow: t, mobileColumnSpacing: o },
+      `Changed mobile products per row to ${t}`
+    ), I(this.api), f({
+      currentNode: this.currentNode,
+      documentModifier: this.api.getDocumentModifier()
+    });
+  }
+  _regenerateProductRows() {
+    const t = i.getConfig(this.currentNode), s = parseInt(t.size) || 6, o = b(this.store.recommendationProducts, s);
+    P({
+      currentNode: this.currentNode,
+      documentModifier: this.api.getDocumentModifier(),
+      products: o
+    });
+  }
+  _listenToFormUpdates() {
+    this.api.onValueChanged(e.PRODUCT_COUNT, (t) => {
+      this._onProductCountChange(t.toString());
+    }), this.api.onValueChanged(e.PRODUCT_IN_ROW, (t) => {
+      this._onProductsInRowChange(Number(t));
+    }), this.api.onValueChanged(e.MOBILE_CARDS_IN_ROW, (t) => {
+      this._onMobileCardsInRowChange(Number(t));
+    });
+  }
+  /**
+   * Subscribe to store changes to update visibility when layout changes
+   * This is still needed because layout changes come from LayoutControl
+   */
+  _listenStateUpdates() {
+    let t = this.store.recommendationConfigs.orientation;
+    this.storeUnsubscription = this.store.$subscribe(() => {
+      const s = this.store.recommendationConfigs.orientation;
+      s !== t && (t = s, this._updateProductsInRowVisibility());
+    });
+  }
+}
+export {
+  M as PRODUCT_LAYOUT_CONTROL_ID,
+  V as ProductLayoutControl
+};

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

@@ -0,0 +1,67 @@
+var r = Object.defineProperty;
+var f = (o, t, e) => t in o ? r(o, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : o[t] = e;
+var n = (o, t, e) => f(o, typeof t != "symbol" ? t + "" : t, e);
+import { UEAttr as u } from "../../../../../node_modules/@stripoinc/ui-editor-extensions/dist/esm/index.js";
+import { CommonControl as l } from "../../../common-control.js";
+import { RecommendationConfigService as s } from "../../services/configService.js";
+import { useRecommendationExtensionStore as d } from "../../store/recommendation.js";
+const h = "recommendation-shuffle-control", i = {
+  SHUFFLE_PRODUCTS: "shuffleProducts"
+};
+class S extends l {
+  constructor() {
+    super(...arguments);
+    // Store is used for backward compatibility with product fetching
+    n(this, "store", d());
+  }
+  getId() {
+    return h;
+  }
+  getTemplate() {
+    return `
+            <div class="shuffle-control-container">
+                ${this._GuTwoColumns([
+      this._GuLabel({ text: "Shuffle Recommended Products" }),
+      this._GuToggle(i.SHUFFLE_PRODUCTS)
+    ])}
+            </div>
+        `;
+  }
+  onRender() {
+    this._initializeToggle(), this._setFormValues(), this._listenToFormUpdates();
+  }
+  onTemplateNodeUpdated(e) {
+    super.onTemplateNodeUpdated(e), this._setFormValues();
+  }
+  _setFormValues() {
+    const e = s.getConfig(this.currentNode);
+    this.api.updateValues({
+      [i.SHUFFLE_PRODUCTS]: e.shuffleProducts
+    });
+  }
+  _initializeToggle() {
+    const e = s.getConfig(this.currentNode);
+    this.api.setUIEAttribute(
+      i.SHUFFLE_PRODUCTS,
+      u.SELECTPICKER.items,
+      e.shuffleProducts
+    );
+  }
+  _onShuffleChange(e) {
+    !this.currentNode || s.getConfig(this.currentNode).shuffleProducts === e || (s.updateConfig(
+      this.api,
+      this.currentNode,
+      { shuffleProducts: e },
+      `${e ? "Enabled" : "Disabled"} product shuffle`
+    ), this.store.patchCurrentBlockConfig({ shuffleProducts: e }));
+  }
+  _listenToFormUpdates() {
+    this.api.onValueChanged(i.SHUFFLE_PRODUCTS, (e) => {
+      this._onShuffleChange(!!e);
+    });
+  }
+}
+export {
+  h as SHUFFLE_CONTROL_ID,
+  S as ShuffleControl
+};