@useinsider/guido 2.1.0 → 2.2.0-beta.39b37ff

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

@@ -0,0 +1,232 @@
+var T = Object.defineProperty;
+var C = (a, s, t) => s in a ? T(a, s, { enumerable: !0, configurable: !0, writable: !0, value: t }) : a[s] = t;
+var l = (a, s, t) => C(a, typeof s != "symbol" ? s + "" : s, t);
+import { ModificationDescription as u } from "../../../../../node_modules/@stripoinc/ui-editor-extensions/dist/esm/index.js";
+import { CommonControl as f } from "../../../common-control.js";
+import { ATTR_PRODUCT_IMAGE as O, ATTR_PRODUCT_NAME as g, ATTR_PRODUCT_PRICE as R, ATTR_PRODUCT_OLD_PRICE as A, ATTR_PRODUCT_OMNIBUS_PRICE as D, ATTR_PRODUCT_OMNIBUS_DISCOUNT as N, ATTR_PRODUCT_BUTTON as V } from "../../constants/selectors.js";
+import { useRecommendationExtensionStore as E } from "../../store/recommendation.js";
+import { getTableDisplayValue as I } from "../../utils/tagName.js";
+import { getCurrentLayout as P } from "../main/utils.js";
+const S = "ui-elements-recommendation-card-composition", k = {
+  ORDERABLE: "cardComposition"
+}, c = ".recommendation-attribute-row", v = ".product-card-wrapper > tbody", _ = "data-card-composition", d = "data-attribute-type", m = "data-visibility", n = [
+  { key: O, label: "Product Image", visible: !0 },
+  { key: g, label: "Product Name", visible: !0 },
+  { key: R, label: "Product Price", visible: !0 },
+  { key: A, label: "Product Original Price", visible: !0 },
+  { key: D, label: "Omnibus Price", visible: !1 },
+  { key: N, label: "Omnibus Discount", visible: !1 },
+  { key: V, label: "Product Button", visible: !0 }
+];
+class H extends f {
+  constructor() {
+    super(...arguments);
+    l(this, "store", E());
+    l(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(_);
+    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(c)), 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 o = i.getAttribute(d), r = i.getAttribute(m);
+      o && r !== null && (e[o] = this._parseVisibilityValue(r));
+    }), 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 grid layout
+   */
+  _applyCompositionToBlock(t) {
+    if (!this.currentNode)
+      return;
+    const e = this._getCurrentLayout();
+    this.api.getDocumentModifier().modifyHtml(this.currentNode).setAttribute(_, t.join(",")).apply(new u("Update card composition")), e === "grid" && 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((o) => {
+      const r = this._buildCompositionHtml(o, t);
+      i.modifyHtml(o).setInnerHtml(r);
+    }), i.apply(new u("Reorder product attributes"));
+  }
+  /**
+   * Builds HTML string with attributes ordered according to composition
+   */
+  _buildCompositionHtml(t, e) {
+    return e.reduce((i, o) => {
+      const r = t.querySelector(`${c}[${d}="${o}"]`);
+      return r && "getOuterHTML" in r ? i + r.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(`${c}[${d}="${t}"]`);
+    if (!(i != null && i.length))
+      return;
+    const o = e ? "1" : "0", r = `Set ${t} visibility to ${e ? "visible" : "hidden"}`, b = this.api.getDocumentModifier();
+    i.forEach((p) => {
+      const y = I(p), h = e ? y : "none";
+      b.modifyHtml(p).setStyle("display", h).setAttribute(m, o);
+    }), b.apply(new u(r));
+  }
+  /**
+   * 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 list layout
+   */
+  _updateOrderableState() {
+    const e = this._getCurrentLayout() === "list", i = this.getContainer();
+    if (!i)
+      return;
+    const o = i.querySelector("[data-card-composition-control]");
+    if (!o)
+      return;
+    const r = o.querySelector("ue-orderable");
+    r && r.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,
+  H 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,92 @@
+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 r } 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", i = {
+  LAYOUT: "layout"
+}, C = {
+  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: i.LAYOUT,
+        buttons: g
+      })
+    ])}
+            </div>
+        `;
+  }
+  onRender() {
+    this._setFormValues(), this._listenToFormUpdates();
+  }
+  onTemplateNodeUpdated(t) {
+    super.onTemplateNodeUpdated(t), this._setFormValues();
+  }
+  _setFormValues() {
+    const s = r.getConfig(this.currentNode).layout || u(this.currentNode);
+    this.api.updateValues({
+      [i.LAYOUT]: s
+    });
+  }
+  /**
+   * Handles layout change
+   * Updates node config, data attribute and regenerates product rows
+   */
+  _onLayoutChange(t) {
+    if (this.isChangingLayout || !this.currentNode || (r.getConfig(this.currentNode).layout || u(this.currentNode)) === t)
+      return;
+    const a = f(this.currentNode);
+    if (a) {
+      this.isChangingLayout = !0;
+      try {
+        r.updateConfig(
+          this.api,
+          this.currentNode,
+          { layout: t },
+          `Changed layout to ${t}`
+        ), this.store.patchCurrentBlockConfig({ orientation: t }), this.api.getDocumentModifier().modifyHtml(a).setAttribute(C.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(i.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,102 @@
+var d = Object.defineProperty;
+var l = (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) => l(o, typeof i != "symbol" ? i + "" : i, t);
+import { UEAttr as c } from "../../../../../node_modules/@stripoinc/ui-editor-extensions/dist/esm/index.js";
+import { CommonControl as h } from "../../../common-control.js";
+import { RecommendationConfigService as n } from "../../services/configService.js";
+import { useRecommendationExtensionStore as m } from "../../store/recommendation.js";
+const u = "recommendation-algorithm-control", e = {
+  ALGORITHM: "strategy",
+  PRODUCT_IDS: "productIds"
+};
+class T extends h {
+  constructor() {
+    super(...arguments);
+    // Store is used ONLY for API-fetched data (algorithms list), not for config
+    a(this, "store", m());
+  }
+  getId() {
+    return u;
+  }
+  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 r;
+    const t = (r = this.store) == null ? void 0 : r.getActivePredictiveAlgorithms;
+    if (t != null && t.length)
+      try {
+        this.api.setUIEAttribute(
+          e.ALGORITHM,
+          c.SELECTPICKER.items,
+          t
+        );
+      } catch (s) {
+        console.warn("[AlgorithmControl] Failed to set algorithm options:", s);
+      }
+  }
+  _setProductIdsVisibility(t) {
+    const s = (t ?? n.getConfig(this.currentNode).strategy) === "manualMerchandising";
+    this.api.setVisibility(e.PRODUCT_IDS, s), this.api.setVisibility(`${e.PRODUCT_IDS}_label`, s);
+  }
+  _onAlgorithmChange(t) {
+    this.currentNode && (n.updateConfig(
+      this.api,
+      this.currentNode,
+      { strategy: t },
+      `Changed algorithm to ${t}`
+    ), this.store.patchCurrentBlockConfig({ strategy: t }), this._setProductIdsVisibility(t));
+  }
+  _onProductIdsChange(t) {
+    if (!this.currentNode)
+      return;
+    const r = t.split(",").map((s) => s.trim()).filter(Boolean);
+    n.updateConfig(
+      this.api,
+      this.currentNode,
+      { productIds: r },
+      "Updated product IDs"
+    ), this.store.patchCurrentBlockConfig({ productIds: r });
+  }
+  _listenToFormUpdates() {
+    this.api.onValueChanged(e.ALGORITHM, (t) => {
+      this._onAlgorithmChange(t);
+    }), this.api.onValueChanged(e.PRODUCT_IDS, (t) => {
+      this._onProductIdsChange(t);
+    });
+  }
+}
+export {
+  u as ALGORITHM_CONTROL_ID,
+  T as AlgorithmControl
+};

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
+};