@useinsider/guido 2.1.0-beta.f30d59a → 2.1.0-beta.f869a80

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

@@ -0,0 +1,209 @@
+var R = Object.defineProperty;
+var _ = (s, o, e) => o in s ? R(s, o, { enumerable: !0, configurable: !0, writable: !0, value: e }) : s[o] = e;
+var c = (s, o, e) => _(s, typeof o != "symbol" ? o + "" : o, e);
+import { currencyLocationMaps as l, currencyOperators as i, currencyDecimalCounts as h } from "../../../../../enums/extensions/recommendationBlock.js";
+import { UEAttr as m } from "../../../../../node_modules/@stripoinc/ui-editor-extensions/dist/esm/index.js";
+import { CommonControl as d } from "../../../common-control.js";
+import { RecommendationConfigService as C } from "../../services/configService.js";
+import { useRecommendationExtensionStore as p } from "../../store/recommendation.js";
+import { setCurrencyAttributes as S, updatePricesInPlace as E, regenerateProductRowsWithStyles as N } from "./utils.js";
+const y = "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 D extends d {
+  constructor() {
+    super(...arguments);
+    // Store is used ONLY for API-fetched data (currency list), not for config
+    c(this, "store", p());
+    c(this, "storeUnsubscription", () => {
+    });
+  }
+  getId() {
+    return y;
+  }
+  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: l
+      }),
+      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: i
+      }),
+      this._GuLabel({ text: "Decimal Separator" }),
+      this._GuSelect({
+        name: t.CURRENCY_DECIMAL_SEPARATOR,
+        placeholder: "Select Decimal Separator",
+        options: i
+      }),
+      this._GuLabel({ text: "Decimal Count" }),
+      this._GuSelect({
+        name: t.CURRENCY_DECIMAL_COUNT,
+        placeholder: "Select Decimal Count",
+        options: h
+      })
+    ])}
+            </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]: l,
+      [t.CURRENCY_THOUSAND_SEPARATOR]: i,
+      [t.CURRENCY_DECIMAL_SEPARATOR]: i,
+      [t.CURRENCY_DECIMAL_COUNT]: h
+    };
+    Object.entries(r).forEach(([u, n]) => {
+      this.api.setUIEAttribute(u, m.SELECTPICKER.items, n);
+    });
+  }
+  /**
+   * Applies currency updates to node config, HTML attributes, Pinia store, and DOM.
+   * @param updates - Partial currency config to merge
+   * @param triggerRefetch - Whether to trigger a product API refetch.
+   *   true for currency code changes (different prices from API),
+   *   false for display-only changes (symbol, separators, alignment, decimal count).
+   */
+  _updateCurrency(e, r = !1) {
+    if (!this.currentNode)
+      return;
+    const n = { ...C.getConfig(this.currentNode).currency, ...e };
+    C.updateConfig(
+      this.api,
+      this.currentNode,
+      { currency: n },
+      "Updated currency settings"
+    );
+    const a = this.api.getDocumentModifier();
+    S({
+      currentNode: this.currentNode,
+      documentModifier: a,
+      currency: n
+    }), this.store.patchCurrentBlockConfig({
+      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
+      }
+    }, { triggerRefetch: r }), E({
+      currentNode: this.currentNode,
+      documentModifier: a
+    }) || N({
+      currentNode: this.currentNode,
+      documentModifier: a
+    });
+  }
+  _onCurrencyChange(e) {
+    const [, r] = e.includes(".") ? e.split(".") : [null, e];
+    this._updateCurrency({
+      code: r,
+      symbol: r
+    }, !0), 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 {
+  y as CURRENCY_CONTROL_ID,
+  D as CurrencyControl
+};

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,269 @@
+var m = Object.defineProperty;
+var h = (c, s, t) => s in c ? m(c, s, { enumerable: !0, configurable: !0, writable: !0, value: t }) : c[s] = t;
+var n = (c, s, t) => h(c, typeof s != "symbol" ? s + "" : s, t);
+import { CommonControl as f } from "../../../common-control.js";
+import { RecommendationConfigService as l } from "../../services/configService.js";
+import { useRecommendationExtensionStore as C } from "../../store/recommendation.js";
+import { AlgorithmControl as p } from "./algorithm.js";
+import { ALGORITHM_CONTROL_ID as W } from "./algorithm.js";
+import { CurrencyControl as g } from "./currency.js";
+import { CURRENCY_CONTROL_ID as H } from "./currency.js";
+import { FiltersControl as R } from "./filters.js";
+import { FILTERS_CONTROL_ID as j } from "./filters.js";
+import { LocaleControl as N } from "./locale.js";
+import { LOCALE_CONTROL_ID as K } from "./locale.js";
+import { ProductLayoutControl as y } from "./productLayout.js";
+import { PRODUCT_LAYOUT_CONTROL_ID as J } from "./productLayout.js";
+import { ShuffleControl as _ } from "./shuffle.js";
+import { SHUFFLE_CONTROL_ID as X } from "./shuffle.js";
+import { regenerateProductRowsWithStyles as b, getBlockElement as I, updateProductContentInPlace as P } from "./utils.js";
+import { formatProductPrice as tt, getCardComposition as et, getCurrentLayout as ot, reapplySpacing as rt, regenerateMobileProductRows as it, regenerateProductRows as nt, setCurrencyAttributes as st, updatePricesInPlace as ct, updateSingleProductContent as at } from "./utils.js";
+import { useDebounceFn as u } from "../../../../../node_modules/@vueuse/shared/index.js";
+const T = "recommendation-id", S = "ui-elements-recommendation-block";
+class z extends f {
+  constructor() {
+    super(...arguments);
+    n(this, "store", C());
+    n(this, "storeUnsubscription", () => {
+    });
+    // Sub-control instances for lifecycle management
+    n(this, "algorithmControl", null);
+    n(this, "localeControl", null);
+    n(this, "currencyControl", null);
+    n(this, "productLayoutControl", null);
+    n(this, "filtersControl", null);
+    n(this, "shuffleControl", null);
+    /**
+     * Debounced product fetch to prevent rapid API calls during config changes
+     */
+    n(this, "_debouncedFetchProducts", u(() => {
+      this.store.fetchRecommendationProducts();
+    }, 500));
+    /**
+     * Debounced regeneration when products arrive from API
+     * Tries in-place update first to preserve styles, falls back to full regeneration
+     */
+    n(this, "_debouncedRegenerateWithProducts", u(() => {
+      const t = this.store.recommendationProducts;
+      if (!this.currentNode || !this.api)
+        return;
+      const e = this.api.getDocumentModifier();
+      P({
+        currentNode: this.currentNode,
+        documentModifier: e,
+        products: t
+      }) || this._regenerateWithProducts(t);
+    }, 100));
+  }
+  getId() {
+    return S;
+  }
+  getTemplate() {
+    return this.algorithmControl = new p(), this.localeControl = new N(), this.currencyControl = new g(), this.productLayoutControl = new y(), this.filtersControl = new R(), this.shuffleControl = new _(), `
+            <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();
+  }
+  /**
+   * 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;
+    }
+    b({
+      currentNode: this.currentNode,
+      documentModifier: this.api.getDocumentModifier(),
+      products: t
+    });
+  }
+  onTemplateNodeUpdated(t) {
+    var r;
+    super.onTemplateNodeUpdated(t);
+    const e = this._getRecommendationIdFromNode(t);
+    e !== null && e !== this.store.currentRecommendationId && this.store.setCurrentBlock(e), this._syncNodeConfigToStore(), e !== null && !((r = this.store.blockStates[e]) != null && r.isInitialized) && this._fetchBlockData(e), [
+      this.algorithmControl,
+      this.localeControl,
+      this.currencyControl,
+      this.productLayoutControl,
+      this.filtersControl,
+      this.shuffleControl
+    ].forEach((i) => {
+      var a;
+      i != null && i.api && (i.currentNode = t, (a = i.onTemplateNodeUpdated) == null || a.call(i, 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() {
+    var r;
+    const t = l.getConfig(this.currentNode), e = this.store.currentRecommendationId, o = e !== null && ((r = this.store.blockStates[e]) == null ? void 0 : r.isInitialized);
+    this.store.patchCurrentBlockConfig({
+      strategy: t.strategy,
+      language: t.language,
+      size: t.size,
+      productIds: t.productIds,
+      // Only sync filters from node config during initial load.
+      // After initialization, the Pinia store is the source of truth
+      // for filters (edited via the filter drawer).
+      ...o ? {} : { 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 (filters, algorithms, products).
+   * 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.fetchRecommendationFilters(),
+      this.store.fetchRecommendationCreateData(),
+      this.store.fetchRecommendationProducts()
+    ])).forEach((o, r) => {
+      o.status === "rejected" && console.warn(`Recommendation block: ${[
+        "fetchRecommendationFilters",
+        "fetchRecommendationCreateData",
+        "fetchRecommendationProducts"
+      ][r]} failed`, o.reason);
+    });
+  }
+  /**
+   * Reads the recommendation-id attribute from the block element within the node
+   */
+  _getRecommendationIdFromNode(t) {
+    const e = I(t);
+    if (!e || !("getAttribute" in e))
+      return null;
+    const o = e.getAttribute(T);
+    if (!o)
+      return null;
+    const r = parseInt(o);
+    return Number.isNaN(r) ? null : r;
+  }
+  /**
+   * 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).
+   */
+  _listenStateUpdates() {
+    const { store: t } = this;
+    let e = t.recommendationProducts, o = t.$state.configVersion;
+    this.storeUnsubscription = t.$subscribe(() => {
+      const r = t.$state.configVersion;
+      r !== o && (o = r, this._persistFiltersToNodeConfig(), this._debouncedFetchProducts());
+      const i = t.recommendationProducts, a = i !== e, d = Array.isArray(i) && i.length > 0;
+      a && d && (e = i, this._debouncedRegenerateWithProducts());
+    });
+  }
+  /**
+   * Persists the current filter state from Pinia store to the Stripo node config.
+   * This ensures filters survive template save/reload cycles.
+   */
+  _persistFiltersToNodeConfig() {
+    if (!this.currentNode || !this.api)
+      return;
+    const { filters: t } = this.store.recommendationConfigs;
+    l.updateConfig(
+      this.api,
+      this.currentNode,
+      { filters: t },
+      "Update recommendation filters"
+    );
+  }
+}
+export {
+  W as ALGORITHM_CONTROL_ID,
+  p as AlgorithmControl,
+  S as CONTROL_BLOCK_ID,
+  H as CURRENCY_CONTROL_ID,
+  g as CurrencyControl,
+  j as FILTERS_CONTROL_ID,
+  R as FiltersControl,
+  K as LOCALE_CONTROL_ID,
+  N as LocaleControl,
+  J as PRODUCT_LAYOUT_CONTROL_ID,
+  y as ProductLayoutControl,
+  z as RecommendationBlockControl,
+  X as SHUFFLE_CONTROL_ID,
+  _ as ShuffleControl,
+  tt as formatProductPrice,
+  I as getBlockElement,
+  et as getCardComposition,
+  ot as getCurrentLayout,
+  rt as reapplySpacing,
+  it as regenerateMobileProductRows,
+  nt as regenerateProductRows,
+  b as regenerateProductRowsWithStyles,
+  st as setCurrencyAttributes,
+  ct as updatePricesInPlace,
+  P as updateProductContentInPlace,
+  at 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 m } from "../../../common-control.js";
+import { RecommendationConfigService as i } from "../../services/configService.js";
+import { useRecommendationExtensionStore as c } from "../../store/recommendation.js";
+const g = "recommendation-locale-control", n = {
+  LOCALE: "language"
+};
+class C extends m {
+  constructor() {
+    super(...arguments);
+    // Store is used ONLY for API-fetched data (language options), not for config
+    a(this, "store", c());
+  }
+  getId() {
+    return g;
+  }
+  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.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 {
+  g as LOCALE_CONTROL_ID,
+  C as LocaleControl
+};