@useinsider/guido 2.0.0-beta.c948eab → 2.0.0-beta.c9db5fd

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

@@ -0,0 +1,243 @@
+var f = Object.defineProperty;
+var C = (a, n, t) => n in a ? f(a, n, { enumerable: !0, configurable: !0, writable: !0, value: t }) : a[n] = t;
+var c = (a, n, t) => C(a, typeof n != "symbol" ? n + "" : n, t);
+import { ModificationDescription as d } from "../../../../../node_modules/@stripoinc/ui-editor-extensions/dist/esm/index.js";
+import { CommonControl as g } from "../../../common-control.js";
+import { ATTR_PRODUCT_IMAGE as O, ATTR_PRODUCT_NAME as A, ATTR_PRODUCT_PRICE as R, ATTR_PRODUCT_OLD_PRICE as N, ATTR_PRODUCT_OMNIBUS_PRICE as E, ATTR_PRODUCT_OMNIBUS_DISCOUNT as D, ATTR_PRODUCT_BUTTON as v } from "../../constants/selectors.js";
+import { useRecommendationExtensionStore as I } from "../../store/recommendation.js";
+const V = "ui-elements-recommendation-card-composition", S = {
+  ORDERABLE: "cardComposition"
+}, b = ".recommendation-attribute-row", P = ".product-card-wrapper > tbody", y = "data-card-composition", p = "data-attribute-type", h = "data-visibility", s = [
+  { key: O, label: "Product Image", visible: !0 },
+  { key: A, label: "Product Name", visible: !0 },
+  { key: R, label: "Product Price", visible: !0 },
+  { key: N, label: "Product Original Price", visible: !0 },
+  { key: E, label: "Omnibus Price", visible: !1 },
+  { key: D, label: "Omnibus Discount", visible: !1 },
+  { key: v, label: "Product Button", visible: !0 }
+];
+class x extends g {
+  constructor() {
+    super(...arguments);
+    c(this, "store", I());
+    c(this, "unsubscribeOrientation", null);
+  }
+  getId() {
+    return V;
+  }
+  getTemplate() {
+    const t = s.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(S.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);
+    }), s.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 s.map((e) => e.key);
+    const t = this.currentNode.getAttribute(y);
+    return t ? t.split(",").filter(Boolean) : s.map((e) => e.key);
+  }
+  /**
+   * Builds visibility values object from the visibility map
+   */
+  _buildVisibilityValues(t) {
+    return s.reduce((e, i) => (e[`visibility_${i.key}`] = t[i.key] ?? !0, e), {});
+  }
+  /**
+   * Read visibility state from individual row elements' data-visibility attributes
+   * This ensures toggles reflect the actual DOM state
+   */
+  _readVisibilityFromRows() {
+    if (!this.currentNode)
+      return this._getDefaultVisibilities();
+    const t = Array.from(this.currentNode.querySelectorAll(b)), e = this._extractVisibilityFromRows(t);
+    return this._mergeWithDefaults(e);
+  }
+  /**
+   * Returns default visibility values for all items
+   */
+  _getDefaultVisibilities() {
+    return s.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(p), r = i.getAttribute(h);
+      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 s.forEach((e) => {
+      e.key in t || (t[e.key] = e.visible);
+    }), t;
+  }
+  /**
+   * Apply the reordered composition to the block's HTML structure
+   * Updates the data-card-composition attribute and reorders product attributes
+   * Note: Reordering is only applied for vertical layout
+   */
+  _applyCompositionToBlock(t) {
+    if (!this.currentNode)
+      return;
+    const e = this._getCurrentLayout();
+    this.api.getDocumentModifier().modifyHtml(this.currentNode).setAttribute(y, t.join(",")).apply(new d("Update card composition")), e === "vertical" && this._reorderProductAttributes(t);
+  }
+  /**
+   * Reorders attribute rows within each product card based on composition order
+   * Targets the tbody inside each product-attribute-cell to preserve card structure
+   */
+  _reorderProductAttributes(t) {
+    if (!this.currentNode)
+      return;
+    const e = this.currentNode.querySelectorAll(P);
+    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 d("Reorder product attributes"));
+  }
+  /**
+   * Builds HTML string with attributes ordered according to composition
+   */
+  _buildCompositionHtml(t, e) {
+    return e.reduce((i, o) => {
+      const r = t.querySelector(`${b}[${p}="${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(`${b}[${p}="${t}"]`);
+    if (!(i != null && i.length))
+      return;
+    const o = e ? "1" : "0", r = `Set ${t} visibility to ${e ? "visible" : "hidden"}`, m = this.api.getDocumentModifier();
+    i.forEach((l) => {
+      let u = "TR";
+      if ("tagName" in l && l.tagName)
+        u = l.tagName.toUpperCase();
+      else if ("getTagName" in l) {
+        const _ = l;
+        typeof _.getTagName == "function" && (u = _.getTagName().toUpperCase());
+      }
+      const T = e ? u === "TD" || u === "BLOCK_IMAGE" || u === "BLOCK_BUTTON" ? "table-cell" : "table-row" : "none";
+      m.modifyHtml(l).setStyle("display", T).setAttribute(h, o);
+    }), m.apply(new d(r));
+  }
+  /**
+   * Gets the current layout orientation from store or DOM
+   */
+  _getCurrentLayout() {
+    const t = this.store.recommendationConfigs.orientation;
+    if (t)
+      return t;
+    if (!this.currentNode || !("querySelector" in this.currentNode))
+      return "vertical";
+    const e = this.currentNode.querySelector(".ins-recommendation-v3-block-v2");
+    return !e || !("getAttribute" in e) ? "vertical" : e.getAttribute("data-layout") === "horizontal" ? "horizontal" : "vertical";
+  }
+  /**
+   * Updates orderable state based on layout orientation
+   * Adds/removes disabled class to hide drag icons for horizontal layout
+   */
+  _updateOrderableState() {
+    const e = this._getCurrentLayout() === "horizontal", i = this.getContainer();
+    if (!i)
+      return;
+    const 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 {
+  V as COMPOSITION_CONTROL_BLOCK_ID,
+  x 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,152 @@
+var g = Object.defineProperty;
+var h = (n, o, t) => o in n ? g(n, o, { enumerable: !0, configurable: !0, writable: !0, value: t }) : n[o] = t;
+var c = (n, o, t) => h(n, typeof o != "symbol" ? o + "" : o, 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 { CONTAINER_SELECTOR as y } from "../../constants/selectors.js";
+import { useRecommendationExtensionStore as C } from "../../store/recommendation.js";
+import { prepareProductRows as _ } from "../../templates/horizontalTemplate.js";
+import { DEFAULT_CARD_COMPOSITION as d, getDefaultProducts as A } from "../../templates/templateUtils.js";
+import { prepareProductRows as L } from "../../templates/verticalTemplate.js";
+const T = "recommendation-layout-control", l = {
+  LAYOUT: "layout"
+}, m = {
+  LAYOUT: "data-layout"
+}, N = [
+  { text: "Vertical", value: "vertical" },
+  { text: "Horizontal", value: "horizontal" }
+];
+class v extends f {
+  constructor() {
+    super(...arguments);
+    c(this, "store", C());
+    c(this, "isChangingLayout", !1);
+  }
+  getId() {
+    return T;
+  }
+  getTemplate() {
+    return `
+            <div class="layout-control-container">
+                ${this._GuTwoColumns([
+      this._GuLabel({ text: "Layout Orientation" }),
+      this._GuRadioButton({
+        name: l.LAYOUT,
+        buttons: N
+      })
+    ])}
+            </div>
+        `;
+  }
+  onRender() {
+    this._setFormValues(), this._listenToFormUpdates();
+  }
+  onTemplateNodeUpdated(t) {
+    super.onTemplateNodeUpdated(t), this._setFormValues();
+  }
+  _setFormValues() {
+    const t = this._getCurrentLayout();
+    this.api.updateValues({
+      [l.LAYOUT]: t
+    });
+  }
+  /**
+   * Gets the block element - either currentNode itself or as a descendant
+   * The currentNode could BE the block element or contain it
+   */
+  _getBlockElement() {
+    if (!this.currentNode)
+      return null;
+    if ("getAttribute" in this.currentNode) {
+      const t = this.currentNode.getAttribute("class");
+      if (t && t.includes("ins-recommendation-v3-block-v2"))
+        return this.currentNode;
+    }
+    return "querySelector" in this.currentNode ? this.currentNode.querySelector(".ins-recommendation-v3-block-v2") : null;
+  }
+  /**
+   * Reads the current layout from the block's data attribute
+   * @returns The layout value ('vertical' or 'horizontal'), defaults to 'vertical'
+   */
+  _getCurrentLayout() {
+    const t = this._getBlockElement();
+    return !t || !("getAttribute" in t) ? "vertical" : t.getAttribute(m.LAYOUT) === "horizontal" ? "horizontal" : "vertical";
+  }
+  /**
+   * Get the current card composition from block data attribute or use default
+   */
+  _getCardComposition() {
+    const t = this._getBlockElement();
+    if (!t || !("getAttribute" in t))
+      return d;
+    const e = t.getAttribute("data-card-composition");
+    return e ? e.split(",").filter(Boolean) : d;
+  }
+  /**
+   * Handles layout change
+   * Updates the block's data attribute and regenerates product rows
+   */
+  _onLayoutChange(t) {
+    if (this.isChangingLayout || this._getCurrentLayout() === t)
+      return;
+    const r = this._getBlockElement();
+    if (r) {
+      this.isChangingLayout = !0;
+      try {
+        this.store.$patch({
+          recommendationConfigs: {
+            orientation: t
+          }
+        }), this.api.getDocumentModifier().modifyHtml(r).setAttribute(m.LAYOUT, t).apply(new u(`Update layout to ${t}`)), this._regenerateProductRows(t);
+      } finally {
+        this.isChangingLayout = !1;
+      }
+    }
+  }
+  /**
+   * Regenerates product rows based on the selected layout
+   */
+  _regenerateProductRows(t) {
+    if (!this.currentNode || !("querySelector" in this.currentNode))
+      return;
+    const e = this.currentNode.querySelector(y);
+    if (!e)
+      return;
+    const r = this._getCurrentCardBackgroundColor(), i = this.store.recommendationProducts.length > 0 ? this.store.recommendationProducts : A(), { cardsInRow: s } = this.store.recommendationConfigs, a = this._getCardComposition(), p = t === "horizontal" ? _(i) : L(i, s, a);
+    this.api.getDocumentModifier().modifyHtml(e).setInnerHtml(p).apply(new u(`Regenerated products for ${t} layout`)), this._applyCardBackgroundColor(r, t);
+  }
+  /**
+   * Gets current card background color from existing elements
+   * Checks both vertical (.product-card-segment) and horizontal (.product-card-wrapper) selectors
+   */
+  _getCurrentCardBackgroundColor() {
+    if (!this.currentNode)
+      return null;
+    const t = this.currentNode.querySelector(".product-card-segment"), e = this.currentNode.querySelector(".product-card-wrapper");
+    let r = null;
+    return t && "getStyle" in t && (r = t.getStyle("background-color")), (!r || r === "transparent") && e && "getStyle" in e && (r = e.getStyle("background-color")), r;
+  }
+  /**
+   * Applies card background color to appropriate elements based on layout
+   */
+  _applyCardBackgroundColor(t, e) {
+    if (!t || t === "transparent" || !this.currentNode)
+      return;
+    const r = e === "vertical" ? ".product-card-segment" : ".product-card-wrapper", i = Array.from(this.currentNode.querySelectorAll(r));
+    if (i.length === 0)
+      return;
+    const s = this.api.getDocumentModifier();
+    i.forEach((a) => {
+      s.modifyHtml(a).setStyle("background-color", t);
+    }), s.apply(new u("Apply card background color"));
+  }
+  _listenToFormUpdates() {
+    this.api.onValueChanged(l.LAYOUT, (t) => {
+      this._onLayoutChange(t);
+    });
+  }
+}
+export {
+  T as LAYOUT_CONTROL_ID,
+  v as LayoutControl
+};